From: xinhuili Date: Wed, 14 Aug 2019 06:20:55 +0000 (+0800) Subject: Add alert manager patch X-Git-Url: https://gerrit.akraino.org/r/gitweb?a=commitdiff_plain;h=refs%2Fchanges%2F00%2F1400%2F1;p=iec%2Fxconnect.git Add alert manager patch This is to enable alert management. Signed-off-by: XINHUI LI Change-Id: If3e7273f70f8fafadd118aa87735388d76e027db --- diff --git a/src/alertmanager/.dockerignore b/src/alertmanager/.dockerignore new file mode 100644 index 0000000..69c6945 --- /dev/null +++ b/src/alertmanager/.dockerignore @@ -0,0 +1,4 @@ +.build/ +.tarballs/ + +!.build/linux-amd64/ diff --git a/src/alertmanager/.github/ISSUE_TEMPLATE.md b/src/alertmanager/.github/ISSUE_TEMPLATE.md new file mode 100644 index 0000000..0b098ab --- /dev/null +++ b/src/alertmanager/.github/ISSUE_TEMPLATE.md @@ -0,0 +1,47 @@ + + +**What did you do?** + +**What did you expect to see?** + +**What did you see instead? Under which circumstances?** + +**Environment** + +* System information: + + insert output of `uname -srm` here + +* Alertmanager version: + + insert output of `alertmanager --version` here + +* Prometheus version: + + insert output of `prometheus -version` here (if relevant to the issue) + +* Alertmanager configuration file: +``` +insert configuration here +``` + +* Prometheus configuration file: +``` +insert configuration here (if relevant to the issue) +``` + +* Logs: +``` +insert Prometheus and Alertmanager logs relevant to the issue here +``` diff --git a/src/alertmanager/.gitignore b/src/alertmanager/.gitignore new file mode 100644 index 0000000..dda0928 --- /dev/null +++ b/src/alertmanager/.gitignore @@ -0,0 +1,15 @@ +/data/ +/alertmanager +/amtool +*.yml +*.yaml +/.build +/.release +/.tarballs + +!/cli/testdata/*.yml +!/cli/config/testdata/*.yml +!/doc/examples/simple.yml +!/circle.yml +!/.travis.yml +!/.promu.yml diff --git a/src/alertmanager/.promu.yml b/src/alertmanager/.promu.yml new file mode 100644 index 0000000..905e6dd --- /dev/null +++ b/src/alertmanager/.promu.yml @@ -0,0 +1,43 @@ +repository: + path: github.com/prometheus/alertmanager +build: + binaries: + - name: alertmanager + path: ./cmd/alertmanager + - name: amtool + path: ./cmd/amtool + flags: -a -tags netgo + ldflags: | + -X {{repoPath}}/vendor/github.com/prometheus/common/version.Version={{.Version}} + -X {{repoPath}}/vendor/github.com/prometheus/common/version.Revision={{.Revision}} + -X {{repoPath}}/vendor/github.com/prometheus/common/version.Branch={{.Branch}} + -X {{repoPath}}/vendor/github.com/prometheus/common/version.BuildUser={{user}}@{{host}} + -X {{repoPath}}/vendor/github.com/prometheus/common/version.BuildDate={{date "20060102-15:04:05"}} +tarball: + files: + - examples/ha/alertmanager.yml + - LICENSE + - NOTICE +crossbuild: + platforms: + - linux/amd64 + - linux/386 + - darwin/amd64 + - darwin/386 + - windows/amd64 + - windows/386 + - freebsd/amd64 + - freebsd/386 + - openbsd/amd64 + - openbsd/386 + - netbsd/amd64 + - netbsd/386 + - dragonfly/amd64 + - linux/arm + - linux/arm64 + - freebsd/arm + - netbsd/arm + - linux/ppc64 + - linux/ppc64le + - linux/mips64 + - linux/mips64le diff --git a/src/alertmanager/.travis.yml b/src/alertmanager/.travis.yml new file mode 100644 index 0000000..8449bdb --- /dev/null +++ b/src/alertmanager/.travis.yml @@ -0,0 +1,17 @@ +sudo: false +language: go + +services: +- docker + +go: +- 1.10.x + +script: +# test front-end +- make clean +- cd ui/app/ && make && cd ../.. +- make assets +- git diff --exit-code +# test back-end +- make diff --git a/src/alertmanager/CHANGELOG.md b/src/alertmanager/CHANGELOG.md new file mode 100644 index 0000000..c94e2cb --- /dev/null +++ b/src/alertmanager/CHANGELOG.md @@ -0,0 +1,342 @@ +## 0.15.0 / 2018-06-22 + +* [CHANGE] [amtool] Update silence add and update flags (#1298) +* [CHANGE] Replace deprecated InstrumentHandler() (#1302) +* [CHANGE] Validate Slack field config and only allow the necessary input (#1334) +* [CHANGE] Remove legacy alert ingest endpoint (#1362) +* [CHANGE] Moved to memberlist as underlying gossip protocol +* [BUGFIX/CHANGE] The default group by is no labels. (#1287) +* [FEATURE] [amtool] Filter alerts by receiver (#1402) +* [FEATURE] Wait for mesh to settle before sending alerts (#1209) +* [FEATURE] [amtool] Support basic auth in alertmanager url (#1279) +* [FEATURE] Make HTTP clients used for integrations configurable +* [ENHANCEMENT] Support receiving alerts with end time and zero start time +* [ENHANCEMENT] Sort dispatched alerts by job+instance (#1234) +* [ENHANCEMENT] Support alert query filters `active` and `unprocessed` (#1366) +* [ENHANCEMENT] [amtool] Expose alert query flags --active and --unprocessed (#1370) +* [ENHANCEMENT] Add Slack actions to notifications (#1355) +* [BUGFIX] Register nflog snapShotSize metric +* [BUGFIX] Sort alerts in correct order before flushing to notifiers (#1349) +* [BUGFIX] Don't reset initial wait timer if flush is in-progress (#1301) +* [BUGFIX] Fix resolved alerts still inhibiting (#1331) +* [BUGFIX] Template wechat config fields (#1356) +* [BUGFIX] Notify resolved alerts properly (#1408) +* [BUGFIX] Fix parsing for label values with commas (#1395) +* [BUGFIX] Hide sensitive Wechat configuration (#1253) +* [BUGFIX] Prepopulate matchers when recreating a silence (#1270) +* [BUGFIX] Fix wechat panic (#1293) +* [BUGFIX] Allow empty matchers in silences/filtering (#1289) +* [BUGFIX] Properly configure HTTP client for Wechat integration + +## 0.14.0 / 2018-02-12 + +* [ENHANCEMENT] [amtool] Silence update support dwy suffixes to expire flag (#1197) +* [ENHANCEMENT] Allow templating PagerDuty receiver severity (#1214) +* [ENHANCEMENT] Include receiver name in failed notifications log messages (#1207) +* [ENHANCEMENT] Allow global opsgenie api key (#1208) +* [ENHANCEMENT] Add mesh metrics (#1225) +* [ENHANCEMENT] Add Class field to PagerDuty; add templating to PagerDuty-CEF fields (#1231) +* [BUGFIX] Don't notify of resolved alerts if none were reported firing (#1198) +* [BUGFIX] Notify only when new firing alerts are added (#1205) +* [BUGFIX] [mesh] Fix pending connections never set to established (#1204) +* [BUGFIX] Allow OpsGenie notifier to have empty team fields (#1224) +* [BUGFIX] Don't count alerts with EndTime in the future as resolved (#1233) +* [BUGFIX] Speed up re-rendering of Silence UI (#1235) +* [BUGFIX] Forbid 0 value for group_interval and repeat_interval (#1230) +* [BUGFIX] Fix WeChat agentid issue (#1229) + +## 0.13.0 / 2018-01-12 + +* [CHANGE] Switch cmd/alertmanager to kingpin (#974) +* [CHANGE] [amtool] Switch amtool to kingpin (#976) +* [CHANGE] [amtool] silence query: --expired flag only shows expired silences (#1190) +* [CHANGE] Return config reload result from reload endpoint (#1180) +* [FEATURE] UI silence form is populated from location bar (#1148) +* [FEATURE] Add /-/healthy endpoint (#1159) +* [ENHANCEMENT] Instrument and log snapshot sizes on maintenance (#1155) +* [ENHANCEMENT] Make alertGC interval configurable (#1151) +* [ENHANCEMENT] Display mesh connections in the Status page (#1164) +* [BUGFIX] Template service keys for pagerduty notifier (#1182) +* [BUGFIX] Fix expire buttons on the silences page (#1171) +* [BUGFIX] Fix JavaScript error in MSIE due to endswith() usage (#1172) +* [BUGFIX] Correctly format UI error output (#1167) + +## 0.12.0 / 2017-12-15 + +* [FEATURE] package amtool in docker container (#1127) +* [FEATURE] Add notify support for Chinese User wechat (#1059) +* [FEATURE] [amtool] Add a new `silence import` command (#1082) +* [FEATURE] [amtool] Add new command to update silence (#1123) +* [FEATURE] [amtool] Add ability to query for silences that will expire soon (#1120) +* [ENHANCEMENT] Template source field in PagerDuty alert payload (#1117) +* [ENHANCEMENT] Add footer field for slack messages (#1141) +* [ENHANCEMENT] Add Slack additional "fields" to notifications (#1135) +* [ENHANCEMENT] Adding check for webhook's URL formatting (#1129) +* [ENHANCEMENT] Let the browser remember the creator of a silence (#1112) +* [BUGFIX] Fix race in stopping inhibitor (#1118) +* [BUGFIX] Fix browser UI when entering negative duration (#1132) + +## 0.11.0 / 2017-11-16 + +* [CHANGE] Make silence negative filtering consistent with alert filtering (#1095) +* [CHANGE] Change HipChat and OpsGenie api config names (#1087) +* [ENHANCEMENT] amtool: Allow 'd', 'w', 'y' time suffixes when creating silence (#1091) +* [ENHANCEMENT] Support OpsGenie Priority field (#1094) +* [BUGFIX] Fix UI when no silences are present (#1090) +* [BUGFIX] Fix OpsGenie Teams field (#1101) +* [BUGFIX] Fix OpsGenie Tags field (#1108) + +## 0.10.0 / 2017-11-09 + +* [CHANGE] Prevent inhibiting alerts in the source of the inhibition (#1017) +* [ENHANCEMENT] Improve amtool check-config use and description text (#1016) +* [ENHANCEMENT] Add metrics about current silences and alerts (#998) +* [ENHANCEMENT] Sorted silences based on current status (#1015) +* [ENHANCEMENT] Add metric of alertmanager position in mesh (#1024) +* [ENHANCEMENT] Initialise notifications_total and notifications_failed_total (#1011) +* [ENHANCEMENT] Allow selectable matchers on silence view (#1030) +* [ENHANCEMENT] Allow template in victorops message_type field (#1038) +* [ENHANCEMENT] Optionally hide inhibited alerts in API response (#1039) +* [ENHANCEMENT] Toggle silenced and inhibited alerts in UI (#1049) +* [ENHANCEMENT] Fix pushover limits (title, message, url) (#1055) +* [ENHANCEMENT] Add limit to OpsGenie message (#1045) +* [ENHANCEMENT] Upgrade OpsGenie notifier to v2 API. (#1061) +* [ENHANCEMENT] Allow template in victorops routing_key field (#1083) +* [ENHANCEMENT] Add support for PagerDuty API v2 (#1054) +* [BUGFIX] Fix inhibit race (#1032) +* [BUGFIX] Fix segfault on amtool (#1031) +* [BUGFIX] Remove .WasInhibited and .WasSilenced fields of Alert type (#1026) +* [BUGFIX] nflog: Fix Log() crash when gossip is nil (#1064) +* [BUGFIX] Fix notifications for flapping alerts (#1071) +* [BUGFIX] Fix shutdown crash with nil mesh router (#1077) +* [BUGFIX] Fix negative matchers filtering (#1077) + +## 0.9.1 / 2017-09-29 +* [BUGFIX] Fix -web.external-url regression in ui (#1008) +* [BUGFIX] Fix multipart email implementation (#1009) + +## 0.9.0 / 2017-09-28 +* [ENHANCEMENT] Add current time to webhook message (#909) +* [ENHANCEMENT] Add link_names to slack notifier (#912) +* [ENHANCEMENT] Make ui labels selectable/highlightable (#932) +* [ENHANCEMENT] Make links in ui annotations selectable (#946) +* [ENHANCEMENT] Expose the alert's "fingerprint" (unique identifier) through API (#786) +* [ENHANCEMENT] Add README information for amtool (#939) +* [ENHANCEMENT] Use user-set logging option consistently throughout alertmanager (#968) +* [ENHANCEMENT] Sort alerts returned from API by their fingerprint (#969) +* [ENHANCEMENT] Add edit/delete silence buttons on silence page view (#970) +* [ENHANCEMENT] Add check-config subcommand to amtool (#978) +* [ENHANCEMENT] Add email notification text content support (#934) +* [ENHANCEMENT] Support passing binary name to make build target (#990) +* [ENHANCEMENT] Show total no. of silenced alerts in preview (#994) +* [ENHANCEMENT] Added confirmation dialog when expiring silences (#993) +* [BUGFIX] Fix crash when no mesh router is configured (#919) +* [BUGFIX] Render status page without mesh (#920) +* [BUGFIX] Exit amtool subcommands with non-zero error code (#938) +* [BUGFIX] Change mktemp invocation in makefile to work for macOS (#971) +* [BUGFIX] Add a mutex to silences.go:gossipData (#984) +* [BUGFIX] silences: avoid deadlock (#995) +* [BUGFIX] Ignore expired silences OnGossip (#999) + +## 0.8.0 / 2017-07-20 + +* [FEATURE] Add ability to filter alerts by receiver in the UI (#890) +* [FEATURE] Add User-Agent for webhook requests (#893) +* [ENHANCEMENT] Add possibility to have a global victorops api_key (#897) +* [ENHANCEMENT] Add EntityDisplayName and improve StateMessage for Victorops + (#769) +* [ENHANCEMENT] Omit empty config fields and show regex upon re-marshalling to + elide secrets (#864) +* [ENHANCEMENT] Parse API error messages in UI (#866) +* [ENHANCEMENT] Enable sending mail via smtp port 465 (#704) +* [BUGFIX] Prevent duplicate notifications by sorting matchers (#882) +* [BUGFIX] Remove timeout for UI requests (#890) +* [BUGFIX] Update config file location of CLI in flag usage text (#895) + +## 0.7.1 / 2017-06-09 + +* [BUGFIX] Fix filtering by label on Alert list and Silence list page + +## 0.7.0 / 2017-06-08 + +* [CHANGE] Rewrite UI from scratch improving UX +* [CHANGE] Rename `config` to `configYAML` on `api/v1/status` +* [FEATURE] Add ability to update a silence on `api/v1/silences` POST endpoint (See #765) +* [FEATURE] Return alert status on `api/v1/alerts` GET endpoint +* [FEATURE] Serve silence state on `api/v1/silences` GET endpoint +* [FEATURE] Add ability to specify a route prefix +* [FEATURE] Add option to disable AM listening on mesh port +* [ENHANCEMENT] Add ability to specify `filter` string and `silenced` flag on `api/v1/alerts` GET endpoint +* [ENHANCEMENT] Update `cache-control` to prevent caching for web assets in general. +* [ENHANCEMENT] Serve web assets by alertmanager instead of external CDN (See #846) +* [ENHANCEMENT] Elide secrets in alertmanager config (See #840) +* [ENHANCEMENT] AMTool: Move config file to a more consistent location (See #843) +* [BUGFIX] Enable builds for Solaris/Illumos +* [BUGFIX] Load web assets based on url path (See #323) + +## 0.6.2 / 2017-05-09 + +* [BUGFIX] Correctly link to silences from alert again +* [BUGFIX] Correctly hide silenced/show active alerts in UI again +* [BUGFIX] Fix regression of alerts not being displayed until first processing +* [BUGFIX] Fix internal usage of wrong lock for silence markers +* [BUGFIX] Adapt amtool's API parsing to recent API changes +* [BUGFIX] Correctly marshal regexes in config JSON response +* [CHANGE] Anchor silence regex matchers to be consistent with Prometheus +* [ENHANCEMENT] Error if root route is using `continue` keyword + +## 0.6.1 / 2017-04-28 + +* [BUGFIX] Fix incorrectly serialized hash for notification providers. +* [ENHANCEMENT] Add processing status field to alerts. +* [FEATURE] Add config hash metric. + +## 0.6.0 / 2017-04-25 + +* [BUGFIX] Add `groupKey` to `alerts/groups` endpoint https://github.com/prometheus/alertmanager/pull/576 +* [BUGFIX] Only notify on firing alerts https://github.com/prometheus/alertmanager/pull/595 +* [BUGFIX] Correctly marshal regex's in config for routing tree https://github.com/prometheus/alertmanager/pull/602 +* [BUGFIX] Prevent panic when failing to load config https://github.com/prometheus/alertmanager/pull/607 +* [BUGFIX] Prevent panic when alertmanager is started with an empty `-mesh.peer` https://github.com/prometheus/alertmanager/pull/726 +* [CHANGE] Rename VictorOps config variables https://github.com/prometheus/alertmanager/pull/667 +* [CHANGE] No longer generate releases for openbsd/arm https://github.com/prometheus/alertmanager/pull/732 +* [ENHANCEMENT] Add `DELETE` as accepted CORS method https://github.com/prometheus/alertmanager/commit/0ecc59076ca6b4cbb63252fa7720a3d89d1c81d3 +* [ENHANCEMENT] Switch to using `gogoproto` for protobuf https://github.com/prometheus/alertmanager/pull/715 +* [ENHANCEMENT] Include notifier type in logs and errors https://github.com/prometheus/alertmanager/pull/702 +* [FEATURE] Expose mesh peers on status page https://github.com/prometheus/alertmanager/pull/644 +* [FEATURE] Add `reReplaceAll` template function https://github.com/prometheus/alertmanager/pull/639 +* [FEATURE] Allow label-based filtering alerts/silences through API https://github.com/prometheus/alertmanager/pull/633 +* [FEATURE] Add commandline tool for interacting with alertmanager https://github.com/prometheus/alertmanager/pull/636 + +## 0.5.1 / 2016-11-24 + +* [BUGFIX] Fix crash caused by race condition in silencing +* [ENHANCEMENT] Improve logging of API errors +* [ENHANCEMENT] Add metrics for the notification log + +## 0.5.0 / 2016-11-01 + +This release requires a storage wipe. It contains fundamental internal +changes that came with implementing the high availability mode. + +* [FEATURE] Alertmanager clustering for high availability +* [FEATURE] Garbage collection of old silences and notification logs +* [CHANGE] New storage format +* [CHANGE] Stricter silence semantics for consistent historical view + +## 0.4.2 / 2016-09-02 + +* [BUGFIX] Fix broken regex checkbox in silence form +* [BUGFIX] Simplify inconsistent silence update behavior + +## 0.4.1 / 2016-08-31 + +* [BUGFIX] Wait for silence query to finish instead of showing error +* [BUGFIX] Fix sorting of silences +* [BUGFIX] Provide visual feedback after creating a silence +* [BUGFIX] Fix styling of silences +* [ENHANCEMENT] Provide cleaner API silence interface + +## 0.4.0 / 2016-08-23 + +* [FEATURE] Silences are now paginated in the web ui +* [CHANGE] Failure to start on unparsed flags + +## 0.3.0 / 2016-07-07 + +* [CHANGE] Alerts are purely in memory and no longer persistent across restarts +* [FEATURE] Add SMTP LOGIN authentication mechanism + +## 0.2.1 / 2016-06-23 + +* [ENHANCEMENT] Allow inheritance of route receiver +* [ENHANCEMENT] Add silence cache to silence provider +* [BUGFIX] Fix HipChat room number in integration URL + +## 0.2.0 / 2016-06-17 + +This release uses a new storage backend based on BoltDB. You have to backup +and wipe your former storage path to run it. + +* [CHANGE] Use BoltDB as data store. +* [CHANGE] Move SMTP authentification to configuration file +* [FEATURE] add /-/reload HTTP endpoint +* [FEATURE] Filter silenced alerts in web UI +* [ENHANCEMENT] reduce inhibition computation complexity +* [ENHANCEMENT] Add support for teams and tags in OpsGenie integration +* [BUGFIX] Handle OpsGenie responses correctly +* [BUGFIX] Fix Pushover queue length issue +* [BUGFIX] STARTTLS before querying auth mechanism in email integration + +## 0.1.1 / 2016-03-15 +* [BUGFIX] Fix global database lock issue +* [ENHANCEMENT] Improve SQLite alerts index +* [ENHANCEMENT] Enable debug endpoint + +## 0.1.0 / 2016-02-23 +This version is a full rewrite of the Alertmanager with a very different +feature set. Thus, there is no meaningful changelog. + +Changes with respect to 0.1.0-beta2: +* [CHANGE] Expose same data structure to templates and webhook +* [ENHANCEMENT] Show generator URL in default templates and web UI +* [ENHANCEMENT] Support for Slack icon_emoji field +* [ENHANCEMENT] Expose incident key to templates and webhook data +* [ENHANCEMENT] Allow markdown in Slack 'text' field +* [BUGFIX] Fixed database locking issue + +## 0.1.0-beta2 / 2016-02-03 +* [BUGFIX] Properly set timeout for incoming alerts with fixed start time +* [ENHANCEMENT] Send source field in OpsGenie integration +* [ENHANCEMENT] Improved routing configuration validation +* [FEATURE] Basic instrumentation added + +## 0.1.0-beta1 / 2016-01-08 +* [BUGFIX] Send full alert group state on each update. Fixes erroneous resolved notifications. +* [FEATURE] HipChat integration +* [CHANGE] Slack integration no longer sends resolved notifications by default + +## 0.1.0-beta0 / 2015-12-23 +This version is a full rewrite of the Alertmanager with a very different +feature set. Thus, there is no meaningful changelog. + +## 0.0.4 / 2015-09-09 +* [BUGFIX] Fix version info string in startup message. +* [BUGFIX] Fix Pushover notifications by setting the right priority level, as + well as required retry and expiry intervals. +* [FEATURE] Make it possible to link to individual alerts in the UI. +* [FEATURE] Rearrange alert columns in UI and allow expanding more alert details. +* [FEATURE] Add Amazon SNS notifications. +* [FEATURE] Add OpsGenie Webhook notifications. +* [FEATURE] Add `-web.external-url` flag to control the externally visible + Alertmanager URL. +* [FEATURE] Add runbook and alertmanager URLs to PagerDuty and email notifications. +* [FEATURE] Add a GET API to /api/alerts which pulls JSON formatted + AlertAggregates. +* [ENHANCEMENT] Sort alerts consistently in web UI. +* [ENHANCEMENT] Suggest to use email address as silence creator. +* [ENHANCEMENT] Make Slack timeout configurable. +* [ENHANCEMENT] Add channel name to error logging about Slack notifications. +* [ENHANCEMENT] Refactoring and tests for Flowdock notifications. +* [ENHANCEMENT] New Dockerfile using alpine-golang-make-onbuild base image. +* [CLEANUP] Add Docker instructions and other cleanups in README.md. +* [CLEANUP] Update Makefile.COMMON from prometheus/utils. + +## 0.0.3 / 2015-06-10 +* [BUGFIX] Fix email template body writer being called with parameters in wrong order. + +## 0.0.2 / 2015-06-09 + +* [BUGFIX] Fixed silences.json permissions in Docker image. +* [CHANGE] Changed case of API JSON properties to initial lower letter. +* [CHANGE] Migrated logging to use http://github.com/prometheus/log. +* [FEATURE] Flowdock notification support. +* [FEATURE] Slack notification support. +* [FEATURE] Generic webhook notification support. +* [FEATURE] Support for "@"-mentions in HipChat notifications. +* [FEATURE] Path prefix option to support reverse proxies. +* [ENHANCEMENT] Improved web redirection and 404 behavior. +* [CLEANUP] Updated compiled web assets from source. +* [CLEANUP] Updated fsnotify package to its new source location. +* [CLEANUP] Updates to README.md and AUTHORS.md. +* [CLEANUP] Various smaller cleanups and improvements. diff --git a/src/alertmanager/CONTRIBUTING.md b/src/alertmanager/CONTRIBUTING.md new file mode 100644 index 0000000..197872d --- /dev/null +++ b/src/alertmanager/CONTRIBUTING.md @@ -0,0 +1,18 @@ +# Contributing + +Alertmanager uses GitHub to manage reviews of pull requests. + +* If you have a trivial fix or improvement, go ahead and create a pull request, + addressing (with `@...`) the maintainer of this repository (see + [MAINTAINERS.md](MAINTAINERS.md)) in the description of the pull request. + +* If you plan to do something more involved, first discuss your ideas + on our [mailing list](https://groups.google.com/forum/?fromgroups#!forum/prometheus-developers). + This will avoid unnecessary work and surely give you and us a good deal + of inspiration. + +* Relevant coding style guidelines are the [Go Code Review + Comments](https://code.google.com/p/go-wiki/wiki/CodeReviewComments) + and the _Formatting and style_ section of Peter Bourgon's [Go: Best + Practices for Production + Environments](http://peter.bourgon.org/go-in-production/#formatting-and-style). diff --git a/src/alertmanager/Dockerfile b/src/alertmanager/Dockerfile new file mode 100644 index 0000000..ee20872 --- /dev/null +++ b/src/alertmanager/Dockerfile @@ -0,0 +1,12 @@ +FROM prom/busybox:latest +MAINTAINER The Prometheus Authors + +COPY amtool /bin/amtool +COPY alertmanager /bin/alertmanager +COPY examples/ha/alertmanager.yml /etc/alertmanager/alertmanager.yml + +EXPOSE 9093 +VOLUME [ "/alertmanager" ] +WORKDIR /etc/alertmanager +ENTRYPOINT [ "/bin/alertmanager" ] +CMD [ "--storage.path=/alertmanager" ] diff --git a/src/alertmanager/Dockerfile.arm64v8 b/src/alertmanager/Dockerfile.arm64v8 new file mode 100644 index 0000000..d6ad61e --- /dev/null +++ b/src/alertmanager/Dockerfile.arm64v8 @@ -0,0 +1,13 @@ +FROM arm64v8/busybox:latest +MAINTAINER The Prometheus Authors + +COPY amtool /bin/amtool +COPY alertmanager /bin/alertmanager +COPY examples/ha/alertmanager.yml /etc/alertmanager/alertmanager.yml +RUN chmod +x /bin/amtool /bin/alertmanager + +EXPOSE 9093 +VOLUME [ "/alertmanager" ] +WORKDIR /etc/alertmanager +ENTRYPOINT [ "/bin/alertmanager" ] +CMD [ "--storage.path=/alertmanager" ] diff --git a/src/alertmanager/LICENSE b/src/alertmanager/LICENSE new file mode 100644 index 0000000..261eeb9 --- /dev/null +++ b/src/alertmanager/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/src/alertmanager/MAINTAINERS.md b/src/alertmanager/MAINTAINERS.md new file mode 100644 index 0000000..0707f0f --- /dev/null +++ b/src/alertmanager/MAINTAINERS.md @@ -0,0 +1 @@ +* Stuart Nelson diff --git a/src/alertmanager/Makefile b/src/alertmanager/Makefile new file mode 100644 index 0000000..b46bb58 --- /dev/null +++ b/src/alertmanager/Makefile @@ -0,0 +1,61 @@ +# Copyright 2015 The Prometheus Authors +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +include Makefile.common + +FRONTEND_DIR = $(BIN_DIR)/ui/app +DOCKER_IMAGE_NAME ?= alertmanager + +ifdef DEBUG + bindata_flags = -debug +endif + +STATICCHECK_IGNORE = \ + github.com/prometheus/alertmanager/notify/notify.go:SA6002 + + +.PHONY: build-all +# Will build both the front-end as well as the back-end +build-all: assets build + +assets: go-bindata ui/bindata.go template/internal/deftmpl/bindata.go + +go-bindata: + -@$(GO) get -u github.com/jteeuwen/go-bindata/... + +template/internal/deftmpl/bindata.go: template/default.tmpl + @go-bindata $(bindata_flags) -mode 420 -modtime 1 -pkg deftmpl -o template/internal/deftmpl/bindata.go template/default.tmpl + @$(GO) fmt ./template/internal/deftmpl + +ui/bindata.go: ui/app/script.js ui/app/index.html ui/app/lib +# Using "-mode 420" and "-modtime 1" to make assets make target deterministic. +# It sets all file permissions and time stamps to 420 and 1 + @go-bindata $(bindata_flags) -mode 420 -modtime 1 -pkg ui -o \ + ui/bindata.go ui/app/script.js \ + ui/app/index.html \ + ui/app/favicon.ico \ + ui/app/lib/... + @$(GO) fmt ./ui + +ui/app/script.js: $(shell find ui/app/src -iname *.elm) + cd $(FRONTEND_DIR) && $(MAKE) script.js + +.PHONY: proto +proto: + scripts/genproto.sh + +.PHONY: clean +clean: + rm template/internal/deftmpl/bindata.go + rm ui/bindata.go + cd $(FRONTEND_DIR) && $(MAKE) clean diff --git a/src/alertmanager/Makefile.common b/src/alertmanager/Makefile.common new file mode 100644 index 0000000..1456523 --- /dev/null +++ b/src/alertmanager/Makefile.common @@ -0,0 +1,119 @@ +# Copyright 2018 The Prometheus Authors +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# A common Makefile that includes rules to be reused in different prometheus projects. +# !!! Open PRs only against the prometheus/prometheus/Makefile.common repository! + +# Example usage : +# Create the main Makefile in the root project directory. +# include Makefile.common +# customTarget: +# @echo ">> Running customTarget" +# + +# Ensure GOBIN is not set during build so that promu is installed to the correct path +unexport GOBIN + +GO ?= go +GOFMT ?= $(GO)fmt +FIRST_GOPATH := $(firstword $(subst :, ,$(shell $(GO) env GOPATH))) +PROMU := $(FIRST_GOPATH)/bin/promu +STATICCHECK := $(FIRST_GOPATH)/bin/staticcheck +GOVENDOR := $(FIRST_GOPATH)/bin/govendor +pkgs = ./... + +PREFIX ?= $(shell pwd) +BIN_DIR ?= $(shell pwd) +DOCKER_IMAGE_TAG ?= $(subst /,-,$(shell git rev-parse --abbrev-ref HEAD)) +MACH ?= $(shell uname -m) +DOCKERFILE ?= Dockerfile + +.PHONY: all +all: style staticcheck unused build test + +.PHONY: style +style: + @echo ">> checking code style" + ! $(GOFMT) -d $$(find . -path ./vendor -prune -o -name '*.go' -print) | grep '^' + +.PHONY: check_license +check_license: + @echo ">> checking license header" + @licRes=$$(for file in $$(find . -type f -iname '*.go' ! -path './vendor/*') ; do \ + awk 'NR<=3' $$file | grep -Eq "(Copyright|generated|GENERATED)" || echo $$file; \ + done); \ + if [ -n "$${licRes}" ]; then \ + echo "license header checking failed:"; echo "$${licRes}"; \ + exit 1; \ + fi + +.PHONY: test-short +test-short: + @echo ">> running short tests" + $(GO) test -short $(pkgs) + +.PHONY: test +test: + @echo ">> running all tests" + $(GO) test -race $(pkgs) + +.PHONY: format +format: + @echo ">> formatting code" + $(GO) fmt $(pkgs) + +.PHONY: vet +vet: + @echo ">> vetting code" + $(GO) vet $(pkgs) + +.PHONY: staticcheck +staticcheck: $(STATICCHECK) + @echo ">> running staticcheck" + $(STATICCHECK) -ignore "$(STATICCHECK_IGNORE)" $(pkgs) + +.PHONY: unused +unused: $(GOVENDOR) + @echo ">> running check for unused packages" + @$(GOVENDOR) list +unused | grep . && exit 1 || echo 'No unused packages' + +.PHONY: build +build: promu + @echo ">> building binaries" + $(PROMU) build --prefix $(PREFIX) + +.PHONY: tarball +tarball: promu + @echo ">> building release tarball" + $(PROMU) tarball --prefix $(PREFIX) $(BIN_DIR) + +.PHONY: docker +docker: +ifeq ($(MACH), aarch64) + $(eval DOCKERFILE=Dockerfile.arm64v8) +endif + @echo ">> building docker image from $(DOCKERFILE)" + docker build --file $(DOCKERFILE) -t "$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)" . + +.PHONY: promu +promu: + GOOS= GOARCH= $(GO) get -u github.com/prometheus/promu + +.PHONY: $(STATICCHECK) +$(STATICCHECK): + GOOS= GOARCH= $(GO) get -u honnef.co/go/tools/cmd/staticcheck + +.PHONY: $(GOVENDOR) +$(GOVENDOR): + GOOS= GOARCH= $(GO) get -u github.com/kardianos/govendor diff --git a/src/alertmanager/NOTICE b/src/alertmanager/NOTICE new file mode 100644 index 0000000..f5d0bbb --- /dev/null +++ b/src/alertmanager/NOTICE @@ -0,0 +1,18 @@ +Prometheus Alertmanager +Copyright 2013-2015 The Prometheus Authors + +This product includes software developed at +SoundCloud Ltd. (http://soundcloud.com/). + + +The following components are included in this product: + +Bootstrap +http://getbootstrap.com +Copyright 2011-2014 Twitter, Inc. +Licensed under the MIT License + +bootstrap-datetimepicker.js +http://www.eyecon.ro/bootstrap-datepicker +Copyright 2012 Stefan Petre +Licensed under the Apache License, Version 2.0 diff --git a/src/alertmanager/Procfile b/src/alertmanager/Procfile new file mode 100644 index 0000000..ab15cfc --- /dev/null +++ b/src/alertmanager/Procfile @@ -0,0 +1,5 @@ +a1: ./alertmanager --log.level=debug --storage.path=$TMPDIR/a1 --web.listen-address=:9093 --cluster.listen-address=127.0.0.1:8001 --config.file=examples/ha/alertmanager.yml +a2: ./alertmanager --log.level=debug --storage.path=$TMPDIR/a2 --web.listen-address=:9094 --cluster.listen-address=127.0.0.1:8002 --cluster.peer=127.0.0.1:8001 --config.file=examples/ha/alertmanager.yml +a3: ./alertmanager --log.level=debug --storage.path=$TMPDIR/a3 --web.listen-address=:9095 --cluster.listen-address=127.0.0.1:8003 --cluster.peer=127.0.0.1:8001 --config.file=examples/ha/alertmanager.yml +wh: go run ./examples/webhook/echo.go + diff --git a/src/alertmanager/README.md b/src/alertmanager/README.md new file mode 100644 index 0000000..00bed33 --- /dev/null +++ b/src/alertmanager/README.md @@ -0,0 +1,347 @@ +# Alertmanager [![Build Status](https://travis-ci.org/prometheus/alertmanager.svg?branch=master)][travis] + +[![CircleCI](https://circleci.com/gh/prometheus/alertmanager/tree/master.svg?style=shield)][circleci] +[![Docker Repository on Quay](https://quay.io/repository/prometheus/alertmanager/status)][quay] +[![Docker Pulls](https://img.shields.io/docker/pulls/prom/alertmanager.svg?maxAge=604800)][hub] + +The Alertmanager handles alerts sent by client applications such as the Prometheus server. It takes care of deduplicating, grouping, and routing them to the correct receiver integrations such as email, PagerDuty, or OpsGenie. It also takes care of silencing and inhibition of alerts. + +* [Documentation](http://prometheus.io/docs/alerting/alertmanager/) + + +## Install + +There are various ways of installing Alertmanager. + +### Precompiled binaries + +Precompiled binaries for released versions are available in the +[*download* section](https://prometheus.io/download/) +on [prometheus.io](https://prometheus.io). Using the latest production release binary +is the recommended way of installing Alertmanager. + +### Docker images + +Docker images are available on [Quay.io](https://quay.io/repository/prometheus/alertmanager). + +### Compiling the binary + +You can either `go get` it: + +``` +$ GO15VENDOREXPERIMENT=1 go get github.com/prometheus/alertmanager/cmd/... +# cd $GOPATH/src/github.com/prometheus/alertmanager +$ alertmanager --config.file= +``` + +Or checkout the source code and build manually: + +``` +$ mkdir -p $GOPATH/src/github.com/prometheus +$ cd $GOPATH/src/github.com/prometheus +$ git clone https://github.com/prometheus/alertmanager.git +$ cd alertmanager +$ make build +$ ./alertmanager --config.file= +``` + +You can also build just one of the binaries in this repo by passing a name to the build function: +``` +$ make build BINARIES=amtool +``` + +## Example + +This is an example configuration that should cover most relevant aspects of the new YAML configuration format. The full documentation of the configuration can be found [here](https://prometheus.io/docs/alerting/configuration/). + +```yaml +global: + # The smarthost and SMTP sender used for mail notifications. + smtp_smarthost: 'localhost:25' + smtp_from: 'alertmanager@example.org' + +# The root route on which each incoming alert enters. +route: + # The root route must not have any matchers as it is the entry point for + # all alerts. It needs to have a receiver configured so alerts that do not + # match any of the sub-routes are sent to someone. + receiver: 'team-X-mails' + + # The labels by which incoming alerts are grouped together. For example, + # multiple alerts coming in for cluster=A and alertname=LatencyHigh would + # be batched into a single group. + group_by: ['alertname', 'cluster'] + + # When a new group of alerts is created by an incoming alert, wait at + # least 'group_wait' to send the initial notification. + # This way ensures that you get multiple alerts for the same group that start + # firing shortly after another are batched together on the first + # notification. + group_wait: 30s + + # When the first notification was sent, wait 'group_interval' to send a batch + # of new alerts that started firing for that group. + group_interval: 5m + + # If an alert has successfully been sent, wait 'repeat_interval' to + # resend them. + repeat_interval: 3h + + # All the above attributes are inherited by all child routes and can + # overwritten on each. + + # The child route trees. + routes: + # This routes performs a regular expression match on alert labels to + # catch alerts that are related to a list of services. + - match_re: + service: ^(foo1|foo2|baz)$ + receiver: team-X-mails + + # The service has a sub-route for critical alerts, any alerts + # that do not match, i.e. severity != critical, fall-back to the + # parent node and are sent to 'team-X-mails' + routes: + - match: + severity: critical + receiver: team-X-pager + + - match: + service: files + receiver: team-Y-mails + + routes: + - match: + severity: critical + receiver: team-Y-pager + + # This route handles all alerts coming from a database service. If there's + # no team to handle it, it defaults to the DB team. + - match: + service: database + + receiver: team-DB-pager + # Also group alerts by affected database. + group_by: [alertname, cluster, database] + + routes: + - match: + owner: team-X + receiver: team-X-pager + + - match: + owner: team-Y + receiver: team-Y-pager + + +# Inhibition rules allow to mute a set of alerts given that another alert is +# firing. +# We use this to mute any warning-level notifications if the same alert is +# already critical. +inhibit_rules: +- source_match: + severity: 'critical' + target_match: + severity: 'warning' + # Apply inhibition if the alertname is the same. + equal: ['alertname'] + + +receivers: +- name: 'team-X-mails' + email_configs: + - to: 'team-X+alerts@example.org, team-Y+alerts@example.org' + +- name: 'team-X-pager' + email_configs: + - to: 'team-X+alerts-critical@example.org' + pagerduty_configs: + - routing_key: + +- name: 'team-Y-mails' + email_configs: + - to: 'team-Y+alerts@example.org' + +- name: 'team-Y-pager' + pagerduty_configs: + - routing_key: + +- name: 'team-DB-pager' + pagerduty_configs: + - routing_key: +``` + +## Amtool + +`amtool` is a cli tool for interacting with the alertmanager api. It is bundled with all releases of alertmanager. + +### Install + +Alternatively you can install with: +``` +go get github.com/prometheus/alertmanager/cmd/amtool +``` + +### Examples + +View all currently firing alerts +``` +$ amtool alert +Alertname Starts At Summary +Test_Alert 2017-08-02 18:30:18 UTC This is a testing alert! +Test_Alert 2017-08-02 18:30:18 UTC This is a testing alert! +Check_Foo_Fails 2017-08-02 18:30:18 UTC This is a testing alert! +Check_Foo_Fails 2017-08-02 18:30:18 UTC This is a testing alert! +``` + +View all currently firing alerts with extended output +``` +$ amtool -o extended alert +Labels Annotations Starts At Ends At Generator URL +alertname="Test_Alert" instance="node0" link="https://example.com" summary="This is a testing alert!" 2017-08-02 18:31:24 UTC 0001-01-01 00:00:00 UTC http://my.testing.script.local +alertname="Test_Alert" instance="node1" link="https://example.com" summary="This is a testing alert!" 2017-08-02 18:31:24 UTC 0001-01-01 00:00:00 UTC http://my.testing.script.local +alertname="Check_Foo_Fails" instance="node0" link="https://example.com" summary="This is a testing alert!" 2017-08-02 18:31:24 UTC 0001-01-01 00:00:00 UTC http://my.testing.script.local +alertname="Check_Foo_Fails" instance="node1" link="https://example.com" summary="This is a testing alert!" 2017-08-02 18:31:24 UTC 0001-01-01 00:00:00 UTC http://my.testing.script.local +``` + +In addition to viewing alerts you can use the rich query syntax provided by alertmanager +``` +$ amtool -o extended alert query alertname="Test_Alert" +Labels Annotations Starts At Ends At Generator URL +alertname="Test_Alert" instance="node0" link="https://example.com" summary="This is a testing alert!" 2017-08-02 18:31:24 UTC 0001-01-01 00:00:00 UTC http://my.testing.script.local +alertname="Test_Alert" instance="node1" link="https://example.com" summary="This is a testing alert!" 2017-08-02 18:31:24 UTC 0001-01-01 00:00:00 UTC http://my.testing.script.local + +$ amtool -o extended alert query instance=~".+1" +Labels Annotations Starts At Ends At Generator URL +alertname="Test_Alert" instance="node1" link="https://example.com" summary="This is a testing alert!" 2017-08-02 18:31:24 UTC 0001-01-01 00:00:00 UTC http://my.testing.script.local +alertname="Check_Foo_Fails" instance="node1" link="https://example.com" summary="This is a testing alert!" 2017-08-02 18:31:24 UTC 0001-01-01 00:00:00 UTC http://my.testing.script.local + +$ amtool -o extended alert query alertname=~"Test.*" instance=~".+1" +Labels Annotations Starts At Ends At Generator URL +alertname="Test_Alert" instance="node1" link="https://example.com" summary="This is a testing alert!" 2017-08-02 18:31:24 UTC 0001-01-01 00:00:00 UTC http://my.testing.script.local +``` + +Silence an alert +``` +$ amtool silence add alertname=Test_Alert +b3ede22e-ca14-4aa0-932c-ca2f3445f926 + +$ amtool silence add alertname="Test_Alert" instance=~".+0" +e48cb58a-0b17-49ba-b734-3585139b1d25 +``` + +View silences +``` +$ amtool silence query +ID Matchers Ends At Created By Comment +b3ede22e-ca14-4aa0-932c-ca2f3445f926 alertname=Test_Alert 2017-08-02 19:54:50 UTC kellel + +$ amtool silence query instance=~".+0" +ID Matchers Ends At Created By Comment +e48cb58a-0b17-49ba-b734-3585139b1d25 alertname=Test_Alert instance=~.+0 2017-08-02 22:41:39 UTC kellel +``` + +Expire a silence +``` +$ amtool silence expire b3ede22e-ca14-4aa0-932c-ca2f3445f926 +``` + +Expire all silences matching a query +``` +$ amtool silence query instance=~".+0" +ID Matchers Ends At Created By Comment +e48cb58a-0b17-49ba-b734-3585139b1d25 alertname=Test_Alert instance=~.+0 2017-08-02 22:41:39 UTC kellel + +$ amtool silence expire $(amtool silence -q query instance=~".+0") + +$ amtool silence query instance=~".+0" + +``` + +Expire all silences +``` +$ amtool silence expire $(amtool silence query -q) +``` + +### Config + +Amtool allows a config file to specify some options for convenience. The default config file paths are `$HOME/.config/amtool/config.yml` or `/etc/amtool/config.yml` + +An example configfile might look like the following: + +``` +# Define the path that amtool can find your `alertmanager` instance at +alertmanager.url: "http://localhost:9093" + +# Override the default author. (unset defaults to your username) +author: me@example.com + +# Force amtool to give you an error if you don't include a comment on a silence +comment_required: true + +# Set a default output format. (unset defaults to simple) +output: extended + +# Set a default receiver +receiver: team-X-pager +``` + +## High Availability + +> Warning: High Availability is under active development + +To create a highly available cluster of the Alertmanager the instances need to +be configured to communicate with each other. This is configured using the +`--cluster.*` flags. + +- `--cluster.listen-address` string: cluster listen address (default "0.0.0.0:9094") +- `--cluster.advertise-address` string: cluster advertise address +- `--cluster.peer` value: initial peers (repeat flag for each additional peer) +- `--cluster.peer-timeout` value: peer timeout period (default "15s") +- `--cluster.gossip-interval` value: cluster message propagation speed + (default "200ms") +- `--cluster.pushpull-interval` value: lower values will increase + convergence speeds at expense of bandwidth (default "1m0s") +- `--cluster.settle-timeout` value: maximum time to wait for cluster + connections to settle before evaluating notifications. +- `--cluster.tcp-timeout` value: timeout value for tcp connections, reads and writes (default "10s") +- `--cluster.probe-timeout` value: time to wait for ack before marking node unhealthy + (default "500ms") +- `--cluster.probe-interval` value: interval between random node probes (default "1s") + +The chosen port in the `cluster.listen-address` flag is the port that needs to be +specified in the `cluster.peer` flag of the other peers. + +To start a cluster of three peers on your local machine use `goreman` and the +Procfile within this repository. + + goreman start + +To point your Prometheus 1.4, or later, instance to multiple Alertmanagers, configure them +in your `prometheus.yml` configuration file, for example: + +```yaml +alerting: + alertmanagers: + - static_configs: + - targets: + - alertmanager1:9093 + - alertmanager2:9093 + - alertmanager3:9093 +``` + +> Important: Do not load balance traffic between Prometheus and its Alertmanagers, but instead point Prometheus to a list of all Alertmanagers. The Alertmanager implementation expects all alerts to be sent to all Alertmanagers to ensure high availability. + +## Contributing to the Front-End + +Refer to [ui/app/CONTRIBUTING.md](ui/app/CONTRIBUTING.md). + +## Architecture + +![](doc/arch.svg) + + +[travis]: https://travis-ci.org/prometheus/alertmanager +[hub]: https://hub.docker.com/r/prom/alertmanager/ +[circleci]: https://circleci.com/gh/prometheus/alertmanager +[quay]: https://quay.io/repository/prometheus/alertmanager diff --git a/src/alertmanager/VERSION b/src/alertmanager/VERSION new file mode 100644 index 0000000..a551051 --- /dev/null +++ b/src/alertmanager/VERSION @@ -0,0 +1 @@ +0.15.0 diff --git a/src/alertmanager/api/api.go b/src/alertmanager/api/api.go new file mode 100644 index 0000000..ec66c7f --- /dev/null +++ b/src/alertmanager/api/api.go @@ -0,0 +1,826 @@ +// Copyright 2015 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package api + +import ( + "encoding/json" + "errors" + "fmt" + "net/http" + "regexp" + "sort" + "sync" + "time" + + "github.com/go-kit/kit/log" + "github.com/go-kit/kit/log/level" + "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/common/model" + "github.com/prometheus/common/route" + "github.com/prometheus/common/version" + "github.com/prometheus/prometheus/pkg/labels" + + "github.com/prometheus/alertmanager/cluster" + "github.com/prometheus/alertmanager/config" + "github.com/prometheus/alertmanager/dispatch" + "github.com/prometheus/alertmanager/pkg/parse" + "github.com/prometheus/alertmanager/provider" + "github.com/prometheus/alertmanager/silence" + "github.com/prometheus/alertmanager/silence/silencepb" + "github.com/prometheus/alertmanager/types" +) + +var ( + numReceivedAlerts = prometheus.NewCounterVec(prometheus.CounterOpts{ + Namespace: "alertmanager", + Name: "alerts_received_total", + Help: "The total number of received alerts.", + }, []string{"status"}) + + numInvalidAlerts = prometheus.NewCounter(prometheus.CounterOpts{ + Namespace: "alertmanager", + Name: "alerts_invalid_total", + Help: "The total number of received alerts that were invalid.", + }) +) + +func init() { + numReceivedAlerts.WithLabelValues("firing") + numReceivedAlerts.WithLabelValues("resolved") + + prometheus.Register(numReceivedAlerts) + prometheus.Register(numInvalidAlerts) +} + +var corsHeaders = map[string]string{ + "Access-Control-Allow-Headers": "Accept, Authorization, Content-Type, Origin", + "Access-Control-Allow-Methods": "GET, DELETE, OPTIONS", + "Access-Control-Allow-Origin": "*", + "Access-Control-Expose-Headers": "Date", +} + +// Enables cross-site script calls. +func setCORS(w http.ResponseWriter) { + for h, v := range corsHeaders { + w.Header().Set(h, v) + } +} + +// API provides registration of handlers for API routes. +type API struct { + alerts provider.Alerts + silences *silence.Silences + config *config.Config + route *dispatch.Route + resolveTimeout time.Duration + uptime time.Time + peer *cluster.Peer + logger log.Logger + + groups groupsFn + getAlertStatus getAlertStatusFn + + mtx sync.RWMutex +} + +type groupsFn func([]*labels.Matcher) dispatch.AlertOverview +type getAlertStatusFn func(model.Fingerprint) types.AlertStatus + +// New returns a new API. +func New( + alerts provider.Alerts, + silences *silence.Silences, + gf groupsFn, + sf getAlertStatusFn, + peer *cluster.Peer, + l log.Logger, +) *API { + if l == nil { + l = log.NewNopLogger() + } + + return &API{ + alerts: alerts, + silences: silences, + groups: gf, + getAlertStatus: sf, + uptime: time.Now(), + peer: peer, + logger: l, + } +} + +// Register registers the API handlers under their correct routes +// in the given router. +func (api *API) Register(r *route.Router) { + wrap := func(f http.HandlerFunc) http.HandlerFunc { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + setCORS(w) + f(w, r) + }) + } + + r.Options("/*path", wrap(func(w http.ResponseWriter, r *http.Request) {})) + + r.Get("/status", wrap(api.status)) + r.Get("/receivers", wrap(api.receivers)) + + r.Get("/alerts/groups", wrap(api.alertGroups)) + r.Get("/alerts", wrap(api.listAlerts)) + r.Post("/alerts", wrap(api.addAlerts)) + + r.Get("/silences", wrap(api.listSilences)) + r.Post("/silences", wrap(api.setSilence)) + r.Get("/silence/:sid", wrap(api.getSilence)) + r.Del("/silence/:sid", wrap(api.delSilence)) +} + +// Update sets the configuration string to a new value. +func (api *API) Update(cfg *config.Config, resolveTimeout time.Duration) error { + api.mtx.Lock() + defer api.mtx.Unlock() + + api.resolveTimeout = resolveTimeout + api.config = cfg + api.route = dispatch.NewRoute(cfg.Route, nil) + return nil +} + +type errorType string + +const ( + errorNone errorType = "" + errorInternal errorType = "server_error" + errorBadData errorType = "bad_data" +) + +type apiError struct { + typ errorType + err error +} + +func (e *apiError) Error() string { + return fmt.Sprintf("%s: %s", e.typ, e.err) +} + +func (api *API) receivers(w http.ResponseWriter, req *http.Request) { + api.mtx.RLock() + defer api.mtx.RUnlock() + + receivers := make([]string, 0, len(api.config.Receivers)) + for _, r := range api.config.Receivers { + receivers = append(receivers, r.Name) + } + + api.respond(w, receivers) +} + +func (api *API) status(w http.ResponseWriter, req *http.Request) { + api.mtx.RLock() + + var status = struct { + ConfigYAML string `json:"configYAML"` + ConfigJSON *config.Config `json:"configJSON"` + VersionInfo map[string]string `json:"versionInfo"` + Uptime time.Time `json:"uptime"` + ClusterStatus *clusterStatus `json:"clusterStatus"` + }{ + ConfigYAML: api.config.String(), + ConfigJSON: api.config, + VersionInfo: map[string]string{ + "version": version.Version, + "revision": version.Revision, + "branch": version.Branch, + "buildUser": version.BuildUser, + "buildDate": version.BuildDate, + "goVersion": version.GoVersion, + }, + Uptime: api.uptime, + ClusterStatus: getClusterStatus(api.peer), + } + + api.mtx.RUnlock() + + api.respond(w, status) +} + +type peerStatus struct { + Name string `json:"name"` + Address string `json:"address"` +} + +type clusterStatus struct { + Name string `json:"name"` + Status string `json:"status"` + Peers []peerStatus `json:"peers"` +} + +func getClusterStatus(p *cluster.Peer) *clusterStatus { + if p == nil { + return nil + } + s := &clusterStatus{Name: p.Name(), Status: p.Status()} + + for _, n := range p.Peers() { + s.Peers = append(s.Peers, peerStatus{ + Name: n.Name, + Address: n.Address(), + }) + } + return s +} + +func (api *API) alertGroups(w http.ResponseWriter, r *http.Request) { + var err error + matchers := []*labels.Matcher{} + + if filter := r.FormValue("filter"); filter != "" { + matchers, err = parse.Matchers(filter) + if err != nil { + api.respondError(w, apiError{ + typ: errorBadData, + err: err, + }, nil) + return + } + } + + groups := api.groups(matchers) + + api.respond(w, groups) +} + +func (api *API) listAlerts(w http.ResponseWriter, r *http.Request) { + var ( + err error + receiverFilter *regexp.Regexp + // Initialize result slice to prevent api returning `null` when there + // are no alerts present + res = []*dispatch.APIAlert{} + matchers = []*labels.Matcher{} + + showActive, showInhibited bool + showSilenced, showUnprocessed bool + ) + + getBoolParam := func(name string) (bool, error) { + v := r.FormValue(name) + if v == "" { + return true, nil + } + if v == "false" { + return false, nil + } + if v != "true" { + err := fmt.Errorf("parameter %q can either be 'true' or 'false', not %q", name, v) + api.respondError(w, apiError{ + typ: errorBadData, + err: err, + }, nil) + return false, err + } + return true, nil + } + + if filter := r.FormValue("filter"); filter != "" { + matchers, err = parse.Matchers(filter) + if err != nil { + api.respondError(w, apiError{ + typ: errorBadData, + err: err, + }, nil) + return + } + } + + showActive, err = getBoolParam("active") + if err != nil { + return + } + + showSilenced, err = getBoolParam("silenced") + if err != nil { + return + } + + showInhibited, err = getBoolParam("inhibited") + if err != nil { + return + } + + showUnprocessed, err = getBoolParam("unprocessed") + if err != nil { + return + } + + if receiverParam := r.FormValue("receiver"); receiverParam != "" { + receiverFilter, err = regexp.Compile("^(?:" + receiverParam + ")$") + if err != nil { + api.respondError(w, apiError{ + typ: errorBadData, + err: fmt.Errorf( + "failed to parse receiver param: %s", + receiverParam, + ), + }, nil) + return + } + } + + alerts := api.alerts.GetPending() + defer alerts.Close() + + api.mtx.RLock() + // TODO(fabxc): enforce a sensible timeout. + for a := range alerts.Next() { + if err = alerts.Err(); err != nil { + break + } + + routes := api.route.Match(a.Labels) + receivers := make([]string, 0, len(routes)) + for _, r := range routes { + receivers = append(receivers, r.RouteOpts.Receiver) + } + + if receiverFilter != nil && !receiversMatchFilter(receivers, receiverFilter) { + continue + } + + if !alertMatchesFilterLabels(&a.Alert, matchers) { + continue + } + + // Continue if the alert is resolved. + if !a.Alert.EndsAt.IsZero() && a.Alert.EndsAt.Before(time.Now()) { + continue + } + + status := api.getAlertStatus(a.Fingerprint()) + + if !showActive && status.State == types.AlertStateActive { + continue + } + + if !showUnprocessed && status.State == types.AlertStateUnprocessed { + continue + } + + if !showSilenced && len(status.SilencedBy) != 0 { + continue + } + + if !showInhibited && len(status.InhibitedBy) != 0 { + continue + } + + apiAlert := &dispatch.APIAlert{ + Alert: &a.Alert, + Status: status, + Receivers: receivers, + Fingerprint: a.Fingerprint().String(), + } + + res = append(res, apiAlert) + } + api.mtx.RUnlock() + + if err != nil { + api.respondError(w, apiError{ + typ: errorInternal, + err: err, + }, nil) + return + } + sort.Slice(res, func(i, j int) bool { + return res[i].Fingerprint < res[j].Fingerprint + }) + api.respond(w, res) +} + +func receiversMatchFilter(receivers []string, filter *regexp.Regexp) bool { + for _, r := range receivers { + if filter.MatchString(r) { + return true + } + } + + return false +} + +func alertMatchesFilterLabels(a *model.Alert, matchers []*labels.Matcher) bool { + sms := make(map[string]string) + for name, value := range a.Labels { + sms[string(name)] = string(value) + } + return matchFilterLabels(matchers, sms) +} + +func (api *API) addAlerts(w http.ResponseWriter, r *http.Request) { + var alerts []*types.Alert + if err := api.receive(r, &alerts); err != nil { + api.respondError(w, apiError{ + typ: errorBadData, + err: err, + }, nil) + return + } + + api.insertAlerts(w, r, alerts...) +} + +func (api *API) insertAlerts(w http.ResponseWriter, r *http.Request, alerts ...*types.Alert) { + now := time.Now() + + api.mtx.RLock() + resolveTimeout := api.resolveTimeout + api.mtx.RUnlock() + + for _, alert := range alerts { + alert.UpdatedAt = now + + // Ensure StartsAt is set. + if alert.StartsAt.IsZero() { + if alert.EndsAt.IsZero() { + alert.StartsAt = now + } else { + alert.StartsAt = alert.EndsAt + } + } + // If no end time is defined, set a timeout after which an alert + // is marked resolved if it is not updated. + if alert.EndsAt.IsZero() { + alert.Timeout = true + alert.EndsAt = now.Add(resolveTimeout) + } + if alert.EndsAt.After(time.Now()) { + numReceivedAlerts.WithLabelValues("firing").Inc() + } else { + numReceivedAlerts.WithLabelValues("resolved").Inc() + } + } + + // Make a best effort to insert all alerts that are valid. + var ( + validAlerts = make([]*types.Alert, 0, len(alerts)) + validationErrs = &types.MultiError{} + ) + for _, a := range alerts { + removeEmptyLabels(a.Labels) + + if err := a.Validate(); err != nil { + validationErrs.Add(err) + numInvalidAlerts.Inc() + continue + } + validAlerts = append(validAlerts, a) + } + if err := api.alerts.Put(validAlerts...); err != nil { + api.respondError(w, apiError{ + typ: errorInternal, + err: err, + }, nil) + return + } + + if validationErrs.Len() > 0 { + api.respondError(w, apiError{ + typ: errorBadData, + err: validationErrs, + }, nil) + return + } + + api.respond(w, nil) +} + +func removeEmptyLabels(ls model.LabelSet) { + for k, v := range ls { + if string(v) == "" { + delete(ls, k) + } + } +} + +func (api *API) setSilence(w http.ResponseWriter, r *http.Request) { + var sil types.Silence + if err := api.receive(r, &sil); err != nil { + api.respondError(w, apiError{ + typ: errorBadData, + err: err, + }, nil) + return + } + + // This is an API only validation, it cannot be done internally + // because the expired silence is semantically important. + // But one should not be able to create expired silences, that + // won't have any use. + if sil.Expired() { + api.respondError(w, apiError{ + typ: errorBadData, + err: errors.New("start time must not be equal to end time"), + }, nil) + return + } + + if sil.EndsAt.Before(time.Now()) { + api.respondError(w, apiError{ + typ: errorBadData, + err: errors.New("end time can't be in the past"), + }, nil) + return + } + + psil, err := silenceToProto(&sil) + if err != nil { + api.respondError(w, apiError{ + typ: errorBadData, + err: err, + }, nil) + return + } + + sid, err := api.silences.Set(psil) + if err != nil { + api.respondError(w, apiError{ + typ: errorBadData, + err: err, + }, nil) + return + } + + api.respond(w, struct { + SilenceID string `json:"silenceId"` + }{ + SilenceID: sid, + }) +} + +func (api *API) getSilence(w http.ResponseWriter, r *http.Request) { + sid := route.Param(r.Context(), "sid") + + sils, err := api.silences.Query(silence.QIDs(sid)) + if err != nil || len(sils) == 0 { + http.Error(w, fmt.Sprint("Error getting silence: ", err), http.StatusNotFound) + return + } + sil, err := silenceFromProto(sils[0]) + if err != nil { + api.respondError(w, apiError{ + typ: errorInternal, + err: err, + }, nil) + return + } + + api.respond(w, sil) +} + +func (api *API) delSilence(w http.ResponseWriter, r *http.Request) { + sid := route.Param(r.Context(), "sid") + + if err := api.silences.Expire(sid); err != nil { + api.respondError(w, apiError{ + typ: errorBadData, + err: err, + }, nil) + return + } + api.respond(w, nil) +} + +func (api *API) listSilences(w http.ResponseWriter, r *http.Request) { + psils, err := api.silences.Query() + if err != nil { + api.respondError(w, apiError{ + typ: errorInternal, + err: err, + }, nil) + return + } + + matchers := []*labels.Matcher{} + if filter := r.FormValue("filter"); filter != "" { + matchers, err = parse.Matchers(filter) + if err != nil { + api.respondError(w, apiError{ + typ: errorBadData, + err: err, + }, nil) + return + } + } + + sils := []*types.Silence{} + for _, ps := range psils { + s, err := silenceFromProto(ps) + if err != nil { + api.respondError(w, apiError{ + typ: errorInternal, + err: err, + }, nil) + return + } + + if !silenceMatchesFilterLabels(s, matchers) { + continue + } + sils = append(sils, s) + } + + var active, pending, expired []*types.Silence + + for _, s := range sils { + switch s.Status.State { + case types.SilenceStateActive: + active = append(active, s) + case types.SilenceStatePending: + pending = append(pending, s) + case types.SilenceStateExpired: + expired = append(expired, s) + } + } + + sort.Slice(active, func(i int, j int) bool { + return active[i].EndsAt.Before(active[j].EndsAt) + }) + sort.Slice(pending, func(i int, j int) bool { + return pending[i].StartsAt.Before(pending[j].EndsAt) + }) + sort.Slice(expired, func(i int, j int) bool { + return expired[i].EndsAt.After(expired[j].EndsAt) + }) + + // Initialize silences explicitly to an empty list (instead of nil) + // So that it does not get converted to "null" in JSON. + silences := []*types.Silence{} + silences = append(silences, active...) + silences = append(silences, pending...) + silences = append(silences, expired...) + + api.respond(w, silences) +} + +func silenceMatchesFilterLabels(s *types.Silence, matchers []*labels.Matcher) bool { + sms := make(map[string]string) + for _, m := range s.Matchers { + sms[m.Name] = m.Value + } + + return matchFilterLabels(matchers, sms) +} + +func matchFilterLabels(matchers []*labels.Matcher, sms map[string]string) bool { + for _, m := range matchers { + v, prs := sms[m.Name] + switch m.Type { + case labels.MatchNotRegexp, labels.MatchNotEqual: + if string(m.Value) == "" && prs { + continue + } + if !m.Matches(string(v)) { + return false + } + default: + if string(m.Value) == "" && !prs { + continue + } + if !prs || !m.Matches(string(v)) { + return false + } + } + } + + return true +} + +func silenceToProto(s *types.Silence) (*silencepb.Silence, error) { + sil := &silencepb.Silence{ + Id: s.ID, + StartsAt: s.StartsAt, + EndsAt: s.EndsAt, + UpdatedAt: s.UpdatedAt, + Comment: s.Comment, + CreatedBy: s.CreatedBy, + } + for _, m := range s.Matchers { + matcher := &silencepb.Matcher{ + Name: m.Name, + Pattern: m.Value, + Type: silencepb.Matcher_EQUAL, + } + if m.IsRegex { + matcher.Type = silencepb.Matcher_REGEXP + } + sil.Matchers = append(sil.Matchers, matcher) + } + return sil, nil +} + +func silenceFromProto(s *silencepb.Silence) (*types.Silence, error) { + sil := &types.Silence{ + ID: s.Id, + StartsAt: s.StartsAt, + EndsAt: s.EndsAt, + UpdatedAt: s.UpdatedAt, + Status: types.SilenceStatus{ + State: types.CalcSilenceState(s.StartsAt, s.EndsAt), + }, + Comment: s.Comment, + CreatedBy: s.CreatedBy, + } + for _, m := range s.Matchers { + matcher := &types.Matcher{ + Name: m.Name, + Value: m.Pattern, + } + switch m.Type { + case silencepb.Matcher_EQUAL: + case silencepb.Matcher_REGEXP: + matcher.IsRegex = true + default: + return nil, fmt.Errorf("unknown matcher type") + } + sil.Matchers = append(sil.Matchers, matcher) + } + + return sil, nil +} + +type status string + +const ( + statusSuccess status = "success" + statusError status = "error" +) + +type response struct { + Status status `json:"status"` + Data interface{} `json:"data,omitempty"` + ErrorType errorType `json:"errorType,omitempty"` + Error string `json:"error,omitempty"` +} + +func (api *API) respond(w http.ResponseWriter, data interface{}) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + + b, err := json.Marshal(&response{ + Status: statusSuccess, + Data: data, + }) + if err != nil { + level.Error(api.logger).Log("msg", "Error marshalling JSON", "err", err) + return + } + w.Write(b) +} + +func (api *API) respondError(w http.ResponseWriter, apiErr apiError, data interface{}) { + w.Header().Set("Content-Type", "application/json") + + switch apiErr.typ { + case errorBadData: + w.WriteHeader(http.StatusBadRequest) + case errorInternal: + w.WriteHeader(http.StatusInternalServerError) + default: + panic(fmt.Sprintf("unknown error type %q", apiErr.Error())) + } + + b, err := json.Marshal(&response{ + Status: statusError, + ErrorType: apiErr.typ, + Error: apiErr.err.Error(), + Data: data, + }) + if err != nil { + return + } + level.Error(api.logger).Log("msg", "API error", "err", apiErr.Error()) + + w.Write(b) +} + +func (api *API) receive(r *http.Request, v interface{}) error { + dec := json.NewDecoder(r.Body) + defer r.Body.Close() + + err := dec.Decode(v) + if err != nil { + level.Debug(api.logger).Log("msg", "Decoding request failed", "err", err) + } + return err +} diff --git a/src/alertmanager/api/api_test.go b/src/alertmanager/api/api_test.go new file mode 100644 index 0000000..2264574 --- /dev/null +++ b/src/alertmanager/api/api_test.go @@ -0,0 +1,575 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package api + +import ( + "bytes" + "encoding/json" + "errors" + "fmt" + "io/ioutil" + "net/http" + "net/http/httptest" + "regexp" + "testing" + "time" + + "github.com/prometheus/alertmanager/config" + "github.com/prometheus/alertmanager/dispatch" + "github.com/prometheus/alertmanager/provider" + "github.com/prometheus/alertmanager/types" + "github.com/prometheus/common/model" + "github.com/prometheus/prometheus/pkg/labels" + "github.com/stretchr/testify/require" +) + +// fakeAlerts is a struct implementing the provider.Alerts interface for tests. +type fakeAlerts struct { + fps map[model.Fingerprint]int + alerts []*types.Alert + err error +} + +func newFakeAlerts(alerts []*types.Alert, withErr bool) *fakeAlerts { + fps := make(map[model.Fingerprint]int) + for i, a := range alerts { + fps[a.Fingerprint()] = i + } + f := &fakeAlerts{ + alerts: alerts, + fps: fps, + } + if withErr { + f.err = errors.New("Error occured") + } + return f +} + +func (f *fakeAlerts) Subscribe() provider.AlertIterator { return nil } +func (f *fakeAlerts) Get(model.Fingerprint) (*types.Alert, error) { return nil, nil } +func (f *fakeAlerts) Put(alerts ...*types.Alert) error { + return f.err +} +func (f *fakeAlerts) GetPending() provider.AlertIterator { + ch := make(chan *types.Alert) + done := make(chan struct{}) + go func() { + defer close(ch) + for _, a := range f.alerts { + ch <- a + } + }() + return provider.NewAlertIterator(ch, done, f.err) +} + +func groupAlerts([]*labels.Matcher) dispatch.AlertOverview { return dispatch.AlertOverview{} } +func newGetAlertStatus(f *fakeAlerts) func(model.Fingerprint) types.AlertStatus { + return func(fp model.Fingerprint) types.AlertStatus { + status := types.AlertStatus{SilencedBy: []string{}, InhibitedBy: []string{}} + + i, ok := f.fps[fp] + if !ok { + return status + } + alert := f.alerts[i] + switch alert.Labels["state"] { + case "active": + status.State = types.AlertStateActive + case "unprocessed": + status.State = types.AlertStateUnprocessed + case "suppressed": + status.State = types.AlertStateSuppressed + } + if alert.Labels["silenced_by"] != "" { + status.SilencedBy = append(status.SilencedBy, string(alert.Labels["silenced_by"])) + } + if alert.Labels["inhibited_by"] != "" { + status.InhibitedBy = append(status.InhibitedBy, string(alert.Labels["inhibited_by"])) + } + return status + } +} + +func TestAddAlerts(t *testing.T) { + now := func(offset int) time.Time { + return time.Now().Add(time.Duration(offset) * time.Second) + } + + for i, tc := range []struct { + start, end time.Time + err bool + code int + }{ + {time.Time{}, time.Time{}, false, 200}, + {now(0), time.Time{}, false, 200}, + {time.Time{}, now(-1), false, 200}, + {time.Time{}, now(0), false, 200}, + {time.Time{}, now(1), false, 200}, + {now(-2), now(-1), false, 200}, + {now(1), now(2), false, 200}, + {now(1), now(0), false, 400}, + {now(0), time.Time{}, true, 500}, + } { + alerts := []model.Alert{{ + StartsAt: tc.start, + EndsAt: tc.end, + Labels: model.LabelSet{"label1": "test1"}, + Annotations: model.LabelSet{"annotation1": "some text"}, + }} + b, err := json.Marshal(&alerts) + if err != nil { + t.Errorf("Unexpected error %v", err) + } + + alertsProvider := newFakeAlerts([]*types.Alert{}, tc.err) + api := New(alertsProvider, nil, groupAlerts, newGetAlertStatus(alertsProvider), nil, nil) + + r, err := http.NewRequest("POST", "/api/v1/alerts", bytes.NewReader(b)) + w := httptest.NewRecorder() + if err != nil { + t.Errorf("Unexpected error %v", err) + } + + api.addAlerts(w, r) + res := w.Result() + body, _ := ioutil.ReadAll(res.Body) + + require.Equal(t, tc.code, w.Code, fmt.Sprintf("test case: %d, StartsAt %v, EndsAt %v, Response: %s", i, tc.start, tc.end, string(body))) + } +} + +func TestListAlerts(t *testing.T) { + now := time.Now() + alerts := []*types.Alert{ + &types.Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{"state": "active", "alertname": "alert1"}, + StartsAt: now.Add(-time.Minute), + }, + }, + &types.Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{"state": "unprocessed", "alertname": "alert2"}, + StartsAt: now.Add(-time.Minute), + }, + }, + &types.Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{"state": "suppressed", "silenced_by": "abc", "alertname": "alert3"}, + StartsAt: now.Add(-time.Minute), + }, + }, + &types.Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{"state": "suppressed", "inhibited_by": "abc", "alertname": "alert4"}, + StartsAt: now.Add(-time.Minute), + }, + }, + &types.Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{"alertname": "alert5"}, + StartsAt: now.Add(-2 * time.Minute), + EndsAt: now.Add(-time.Minute), + }, + }, + } + + for i, tc := range []struct { + err bool + params map[string]string + + code int + anames []string + }{ + { + false, + map[string]string{}, + 200, + []string{"alert1", "alert2", "alert3", "alert4"}, + }, + { + false, + map[string]string{"active": "true", "unprocessed": "true", "silenced": "true", "inhibited": "true"}, + 200, + []string{"alert1", "alert2", "alert3", "alert4"}, + }, + { + false, + map[string]string{"active": "false", "unprocessed": "true", "silenced": "true", "inhibited": "true"}, + 200, + []string{"alert2", "alert3", "alert4"}, + }, + { + false, + map[string]string{"active": "true", "unprocessed": "false", "silenced": "true", "inhibited": "true"}, + 200, + []string{"alert1", "alert3", "alert4"}, + }, + { + false, + map[string]string{"active": "true", "unprocessed": "true", "silenced": "false", "inhibited": "true"}, + 200, + []string{"alert1", "alert2", "alert4"}, + }, + { + false, + map[string]string{"active": "true", "unprocessed": "true", "silenced": "true", "inhibited": "false"}, + 200, + []string{"alert1", "alert2", "alert3"}, + }, + { + false, + map[string]string{"filter": "{alertname=\"alert3\""}, + 200, + []string{"alert3"}, + }, + { + false, + map[string]string{"filter": "{alertname"}, + 400, + []string{}, + }, + { + false, + map[string]string{"receiver": "other"}, + 200, + []string{}, + }, + { + false, + map[string]string{"active": "invalid"}, + 400, + []string{}, + }, + { + true, + map[string]string{}, + 500, + []string{}, + }, + } { + alertsProvider := newFakeAlerts(alerts, tc.err) + api := New(alertsProvider, nil, groupAlerts, newGetAlertStatus(alertsProvider), nil, nil) + api.route = dispatch.NewRoute(&config.Route{Receiver: "def-receiver"}, nil) + + r, err := http.NewRequest("GET", "/api/v1/alerts", nil) + if err != nil { + t.Fatalf("Unexpected error %v", err) + } + q := r.URL.Query() + for k, v := range tc.params { + q.Add(k, v) + } + r.URL.RawQuery = q.Encode() + w := httptest.NewRecorder() + + api.listAlerts(w, r) + body, _ := ioutil.ReadAll(w.Result().Body) + + var res response + err = json.Unmarshal(body, &res) + if err != nil { + t.Fatalf("Unexpected error %v", err) + } + + require.Equal(t, tc.code, w.Code, fmt.Sprintf("test case: %d, response: %s", i, string(body))) + if w.Code != 200 { + continue + } + + // Data needs to be serialized/deserialized to be converted to the real type. + b, err := json.Marshal(res.Data) + if err != nil { + t.Fatalf("Unexpected error %v", err) + } + retAlerts := []*dispatch.APIAlert{} + err = json.Unmarshal(b, &retAlerts) + if err != nil { + t.Fatalf("Unexpected error %v", err) + } + + anames := []string{} + for _, a := range retAlerts { + name, ok := a.Labels["alertname"] + if ok { + anames = append(anames, string(name)) + } + } + require.Equal(t, tc.anames, anames, fmt.Sprintf("test case: %d, alert names are not equal", i)) + } +} + +func TestAlertFiltering(t *testing.T) { + type test struct { + alert *model.Alert + msg string + expected bool + } + + // Equal + equal, err := labels.NewMatcher(labels.MatchEqual, "label1", "test1") + if err != nil { + t.Errorf("Unexpected error %v", err) + } + + tests := []test{ + {&model.Alert{Labels: model.LabelSet{"label1": "test1"}}, "label1=test1", true}, + {&model.Alert{Labels: model.LabelSet{"label1": "test2"}}, "label1=test2", false}, + {&model.Alert{Labels: model.LabelSet{"label2": "test2"}}, "label2=test2", false}, + } + + for _, test := range tests { + actual := alertMatchesFilterLabels(test.alert, []*labels.Matcher{equal}) + msg := fmt.Sprintf("Expected %t for %s", test.expected, test.msg) + require.Equal(t, test.expected, actual, msg) + } + + // Not Equal + notEqual, err := labels.NewMatcher(labels.MatchNotEqual, "label1", "test1") + if err != nil { + t.Errorf("Unexpected error %v", err) + } + + tests = []test{ + {&model.Alert{Labels: model.LabelSet{"label1": "test1"}}, "label1!=test1", false}, + {&model.Alert{Labels: model.LabelSet{"label1": "test2"}}, "label1!=test2", true}, + {&model.Alert{Labels: model.LabelSet{"label2": "test2"}}, "label2!=test2", true}, + } + + for _, test := range tests { + actual := alertMatchesFilterLabels(test.alert, []*labels.Matcher{notEqual}) + msg := fmt.Sprintf("Expected %t for %s", test.expected, test.msg) + require.Equal(t, test.expected, actual, msg) + } + + // Regexp Equal + regexpEqual, err := labels.NewMatcher(labels.MatchRegexp, "label1", "tes.*") + if err != nil { + t.Errorf("Unexpected error %v", err) + } + + tests = []test{ + {&model.Alert{Labels: model.LabelSet{"label1": "test1"}}, "label1=~test1", true}, + {&model.Alert{Labels: model.LabelSet{"label1": "test2"}}, "label1=~test2", true}, + {&model.Alert{Labels: model.LabelSet{"label2": "test2"}}, "label2=~test2", false}, + } + + for _, test := range tests { + actual := alertMatchesFilterLabels(test.alert, []*labels.Matcher{regexpEqual}) + msg := fmt.Sprintf("Expected %t for %s", test.expected, test.msg) + require.Equal(t, test.expected, actual, msg) + } + + // Regexp Not Equal + regexpNotEqual, err := labels.NewMatcher(labels.MatchNotRegexp, "label1", "tes.*") + if err != nil { + t.Errorf("Unexpected error %v", err) + } + + tests = []test{ + {&model.Alert{Labels: model.LabelSet{"label1": "test1"}}, "label1!~test1", false}, + {&model.Alert{Labels: model.LabelSet{"label1": "test2"}}, "label1!~test2", false}, + {&model.Alert{Labels: model.LabelSet{"label2": "test2"}}, "label2!~test2", true}, + } + + for _, test := range tests { + actual := alertMatchesFilterLabels(test.alert, []*labels.Matcher{regexpNotEqual}) + msg := fmt.Sprintf("Expected %t for %s", test.expected, test.msg) + require.Equal(t, test.expected, actual, msg) + } +} + +func TestSilenceFiltering(t *testing.T) { + type test struct { + silence *types.Silence + msg string + expected bool + } + + // Equal + equal, err := labels.NewMatcher(labels.MatchEqual, "label1", "test1") + if err != nil { + t.Errorf("Unexpected error %v", err) + } + + tests := []test{ + { + &types.Silence{Matchers: newMatcher(model.LabelSet{"label1": "test1"})}, + "label1=test1", + true, + }, + { + &types.Silence{Matchers: newMatcher(model.LabelSet{"label1": "test2"})}, + "label1=test2", + false, + }, + { + &types.Silence{Matchers: newMatcher(model.LabelSet{"label2": "test2"})}, + "label2=test2", + false, + }, + } + + for _, test := range tests { + actual := silenceMatchesFilterLabels(test.silence, []*labels.Matcher{equal}) + msg := fmt.Sprintf("Expected %t for %s", test.expected, test.msg) + require.Equal(t, test.expected, actual, msg) + } + + // Not Equal + notEqual, err := labels.NewMatcher(labels.MatchNotEqual, "label1", "test1") + if err != nil { + t.Errorf("Unexpected error %v", err) + } + + tests = []test{ + { + &types.Silence{Matchers: newMatcher(model.LabelSet{"label1": "test1"})}, + "label1!=test1", + false, + }, + { + &types.Silence{Matchers: newMatcher(model.LabelSet{"label1": "test2"})}, + "label1!=test2", + true, + }, + { + &types.Silence{Matchers: newMatcher(model.LabelSet{"label2": "test2"})}, + "label2!=test2", + true, + }, + } + + for _, test := range tests { + actual := silenceMatchesFilterLabels(test.silence, []*labels.Matcher{notEqual}) + msg := fmt.Sprintf("Expected %t for %s", test.expected, test.msg) + require.Equal(t, test.expected, actual, msg) + } + + // Regexp Equal + regexpEqual, err := labels.NewMatcher(labels.MatchRegexp, "label1", "tes.*") + if err != nil { + t.Errorf("Unexpected error %v", err) + } + + tests = []test{ + { + &types.Silence{Matchers: newMatcher(model.LabelSet{"label1": "test1"})}, + "label1=~test1", + true, + }, + { + &types.Silence{Matchers: newMatcher(model.LabelSet{"label1": "test2"})}, + "label1=~test2", + true, + }, + { + &types.Silence{Matchers: newMatcher(model.LabelSet{"label2": "test2"})}, + "label2=~test2", + false, + }, + } + + for _, test := range tests { + actual := silenceMatchesFilterLabels(test.silence, []*labels.Matcher{regexpEqual}) + msg := fmt.Sprintf("Expected %t for %s", test.expected, test.msg) + require.Equal(t, test.expected, actual, msg) + } + + // Regexp Not Equal + regexpNotEqual, err := labels.NewMatcher(labels.MatchNotRegexp, "label1", "tes.*") + if err != nil { + t.Errorf("Unexpected error %v", err) + } + + tests = []test{ + { + &types.Silence{Matchers: newMatcher(model.LabelSet{"label1": "test1"})}, + "label1!~test1", + false, + }, + { + &types.Silence{Matchers: newMatcher(model.LabelSet{"label1": "test2"})}, + "label1!~test2", + false, + }, + { + &types.Silence{Matchers: newMatcher(model.LabelSet{"label2": "test2"})}, + "label2!~test2", + true, + }, + } + + for _, test := range tests { + actual := silenceMatchesFilterLabels(test.silence, []*labels.Matcher{regexpNotEqual}) + msg := fmt.Sprintf("Expected %t for %s", test.expected, test.msg) + require.Equal(t, test.expected, actual, msg) + } +} + +func TestReceiversMatchFilter(t *testing.T) { + receivers := []string{"pagerduty", "slack", "hipchat"} + + filter, err := regexp.Compile(fmt.Sprintf("^(?:%s)$", "hip.*")) + if err != nil { + t.Errorf("Unexpected error %v", err) + } + require.True(t, receiversMatchFilter(receivers, filter)) + + filter, err = regexp.Compile(fmt.Sprintf("^(?:%s)$", "hip")) + if err != nil { + t.Errorf("Unexpected error %v", err) + } + require.False(t, receiversMatchFilter(receivers, filter)) +} + +func TestMatchFilterLabels(t *testing.T) { + testCases := []struct { + matcher labels.MatchType + expected bool + }{ + {labels.MatchEqual, true}, + {labels.MatchRegexp, true}, + {labels.MatchNotEqual, false}, + {labels.MatchNotRegexp, false}, + } + + for _, tc := range testCases { + l, err := labels.NewMatcher(tc.matcher, "foo", "") + require.NoError(t, err) + sms := map[string]string{ + "baz": "bar", + } + ls := []*labels.Matcher{l} + + require.Equal(t, tc.expected, matchFilterLabels(ls, sms)) + + l, err = labels.NewMatcher(tc.matcher, "foo", "") + require.NoError(t, err) + sms = map[string]string{ + "baz": "bar", + "foo": "quux", + } + ls = []*labels.Matcher{l} + require.NotEqual(t, tc.expected, matchFilterLabels(ls, sms)) + } +} + +func newMatcher(labelSet model.LabelSet) types.Matchers { + matchers := make([]*types.Matcher, 0, len(labelSet)) + for key, val := range labelSet { + matchers = append(matchers, types.NewMatcher(key, string(val))) + } + return matchers +} diff --git a/src/alertmanager/cli/alert.go b/src/alertmanager/cli/alert.go new file mode 100644 index 0000000..f83ffcd --- /dev/null +++ b/src/alertmanager/cli/alert.go @@ -0,0 +1,114 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cli + +import ( + "context" + "errors" + "fmt" + "strings" + + "github.com/prometheus/client_golang/api" + "gopkg.in/alecthomas/kingpin.v2" + + "github.com/prometheus/alertmanager/cli/format" + "github.com/prometheus/alertmanager/client" + "github.com/prometheus/alertmanager/pkg/parse" +) + +type alertQueryCmd struct { + inhibited, silenced, active, unprocessed bool + receiver string + matcherGroups []string +} + +const alertHelp = `View and search through current alerts. + +Amtool has a simplified prometheus query syntax, but contains robust support for +bash variable expansions. The non-option section of arguments constructs a list +of "Matcher Groups" that will be used to filter your query. The following +examples will attempt to show this behaviour in action: + +amtool alert query alertname=foo node=bar + + This query will match all alerts with the alertname=foo and node=bar label + value pairs set. + +amtool alert query foo node=bar + + If alertname is omitted and the first argument does not contain a '=' or a + '=~' then it will be assumed to be the value of the alertname pair. + +amtool alert query 'alertname=~foo.*' + + As well as direct equality, regex matching is also supported. The '=~' syntax + (similar to prometheus) is used to represent a regex match. Regex matching + can be used in combination with a direct match. + +Amtool supports several flags for filtering the returned alerts by state +(inhibited, silenced, active, unprocessed). If none of these flags is given, +only active alerts are returned. +` + +func configureAlertCmd(app *kingpin.Application) { + var ( + a = &alertQueryCmd{} + alertCmd = app.Command("alert", alertHelp).PreAction(requireAlertManagerURL) + queryCmd = alertCmd.Command("query", alertHelp).Default() + ) + queryCmd.Flag("inhibited", "Show inhibited alerts").Short('i').BoolVar(&a.inhibited) + queryCmd.Flag("silenced", "Show silenced alerts").Short('s').BoolVar(&a.silenced) + queryCmd.Flag("active", "Show active alerts").Short('a').BoolVar(&a.active) + queryCmd.Flag("unprocessed", "Show unprocessed alerts").Short('u').BoolVar(&a.unprocessed) + queryCmd.Flag("receiver", "Show alerts matching receiver (Supports regex syntax)").Short('r').StringVar(&a.receiver) + queryCmd.Arg("matcher-groups", "Query filter").StringsVar(&a.matcherGroups) + queryCmd.Action(a.queryAlerts) +} + +func (a *alertQueryCmd) queryAlerts(ctx *kingpin.ParseContext) error { + var filterString = "" + if len(a.matcherGroups) == 1 { + // If the parser fails then we likely don't have a (=|=~|!=|!~) so lets + // assume that the user wants alertname= and prepend `alertname=` + // to the front. + _, err := parse.Matcher(a.matcherGroups[0]) + if err != nil { + filterString = fmt.Sprintf("{alertname=%s}", a.matcherGroups[0]) + } else { + filterString = fmt.Sprintf("{%s}", strings.Join(a.matcherGroups, ",")) + } + } else if len(a.matcherGroups) > 1 { + filterString = fmt.Sprintf("{%s}", strings.Join(a.matcherGroups, ",")) + } + + c, err := api.NewClient(api.Config{Address: alertmanagerURL.String()}) + if err != nil { + return err + } + alertAPI := client.NewAlertAPI(c) + // If no selector was passed, default to showing active alerts. + if !a.silenced && !a.inhibited && !a.active && !a.unprocessed { + a.active = true + } + fetchedAlerts, err := alertAPI.List(context.Background(), filterString, a.receiver, a.silenced, a.inhibited, a.active, a.unprocessed) + if err != nil { + return err + } + + formatter, found := format.Formatters[output] + if !found { + return errors.New("unknown output formatter") + } + return formatter.FormatAlerts(fetchedAlerts) +} diff --git a/src/alertmanager/cli/check_config.go b/src/alertmanager/cli/check_config.go new file mode 100644 index 0000000..0604772 --- /dev/null +++ b/src/alertmanager/cli/check_config.go @@ -0,0 +1,89 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cli + +import ( + "fmt" + + "github.com/prometheus/alertmanager/config" + "github.com/prometheus/alertmanager/template" + "gopkg.in/alecthomas/kingpin.v2" +) + +// TODO: This can just be a type that is []string, doesn't have to be a struct +type checkConfigCmd struct { + files []string +} + +const checkConfigHelp = `Validate alertmanager config files + +Will validate the syntax and schema for alertmanager config file +and associated templates. Non existing templates will not trigger +errors. +` + +func configureCheckConfigCmd(app *kingpin.Application) { + var ( + c = &checkConfigCmd{} + checkCmd = app.Command("check-config", checkConfigHelp) + ) + checkCmd.Arg("check-files", "Files to be validated").ExistingFilesVar(&c.files) + checkCmd.Action(c.checkConfig) +} + +func (c *checkConfigCmd) checkConfig(ctx *kingpin.ParseContext) error { + return CheckConfig(c.files) +} + +func CheckConfig(args []string) error { + failed := 0 + + for _, arg := range args { + fmt.Printf("Checking '%s'", arg) + cfg, _, err := config.LoadFile(arg) + if err != nil { + fmt.Printf(" FAILED: %s\n", err) + failed++ + } else { + fmt.Printf(" SUCCESS\n") + } + + if cfg != nil { + fmt.Println("Found:") + if cfg.Global != nil { + fmt.Println(" - global config") + } + if cfg.Route != nil { + fmt.Println(" - route") + } + fmt.Printf(" - %d inhibit rules\n", len(cfg.InhibitRules)) + fmt.Printf(" - %d receivers\n", len(cfg.Receivers)) + fmt.Printf(" - %d templates\n", len(cfg.Templates)) + if len(cfg.Templates) > 0 { + _, err = template.FromGlobs(cfg.Templates...) + if err != nil { + fmt.Printf(" FAILED: %s\n", err) + failed++ + } else { + fmt.Printf(" SUCCESS\n") + } + } + } + fmt.Printf("\n") + } + if failed > 0 { + return fmt.Errorf("failed to validate %d file(s)", failed) + } + return nil +} diff --git a/src/alertmanager/cli/check_config_test.go b/src/alertmanager/cli/check_config_test.go new file mode 100644 index 0000000..eb80efd --- /dev/null +++ b/src/alertmanager/cli/check_config_test.go @@ -0,0 +1,30 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cli + +import ( + "testing" +) + +func TestCheckConfig(t *testing.T) { + err := CheckConfig([]string{"testdata/conf.good.yml"}) + if err != nil { + t.Fatalf("checking valid config file failed with: %v", err) + } + + err = CheckConfig([]string{"testdata/conf.bad.yml"}) + if err == nil { + t.Fatalf("failed to detect invalid file.") + } +} diff --git a/src/alertmanager/cli/config.go b/src/alertmanager/cli/config.go new file mode 100644 index 0000000..0cadf54 --- /dev/null +++ b/src/alertmanager/cli/config.go @@ -0,0 +1,58 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cli + +import ( + "context" + "errors" + + "github.com/prometheus/client_golang/api" + "gopkg.in/alecthomas/kingpin.v2" + + "github.com/prometheus/alertmanager/cli/format" + "github.com/prometheus/alertmanager/client" +) + +const configHelp = `View current config. + +The amount of output is controlled by the output selection flag: + - Simple: Print just the running config + - Extended: Print the running config as well as uptime and all version info + - Json: Print entire config object as json +` + +// configCmd represents the config command +func configureConfigCmd(app *kingpin.Application) { + app.Command("config", configHelp).Action(queryConfig).PreAction(requireAlertManagerURL) + +} + +func queryConfig(ctx *kingpin.ParseContext) error { + c, err := api.NewClient(api.Config{Address: alertmanagerURL.String()}) + if err != nil { + return err + } + statusAPI := client.NewStatusAPI(c) + status, err := statusAPI.Get(context.Background()) + if err != nil { + return err + } + + formatter, found := format.Formatters[output] + if !found { + return errors.New("unknown output formatter") + } + + return formatter.FormatConfig(status) +} diff --git a/src/alertmanager/cli/config/config.go b/src/alertmanager/cli/config/config.go new file mode 100644 index 0000000..32517f1 --- /dev/null +++ b/src/alertmanager/cli/config/config.go @@ -0,0 +1,89 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package config + +import ( + "io/ioutil" + "os" + + "gopkg.in/alecthomas/kingpin.v2" + "gopkg.in/yaml.v2" +) + +type getFlagger interface { + GetFlag(name string) *kingpin.FlagClause +} + +// Resolver represents a configuration file resolver for kingpin. +type Resolver struct { + flags map[string]string +} + +// NewResolver returns a Resolver structure. +func NewResolver(files []string, legacyFlags map[string]string) (*Resolver, error) { + flags := map[string]string{} + for _, f := range files { + b, err := ioutil.ReadFile(f) + if err != nil { + if os.IsNotExist(err) { + continue + } + return nil, err + } + + var m map[string]string + err = yaml.Unmarshal(b, &m) + if err != nil { + return nil, err + } + for k, v := range m { + if flag, ok := legacyFlags[k]; ok { + if _, ok := m[flag]; ok { + continue + } + k = flag + } + if _, ok := flags[k]; !ok { + flags[k] = v + } + } + } + + return &Resolver{flags: flags}, nil +} + +func (c *Resolver) setDefault(v getFlagger) { + for name, value := range c.flags { + f := v.GetFlag(name) + if f != nil { + f.Default(value) + } + } +} + +// Bind sets active flags with their default values from the configuration file(s). +func (c *Resolver) Bind(app *kingpin.Application, args []string) error { + // Parse the command line arguments to get the selected command. + pc, err := app.ParseContext(args) + if err != nil { + return err + } + + c.setDefault(app) + if pc.SelectedCommand != nil { + c.setDefault(pc.SelectedCommand) + } + + return nil +} diff --git a/src/alertmanager/cli/config/config_test.go b/src/alertmanager/cli/config/config_test.go new file mode 100644 index 0000000..e4199d2 --- /dev/null +++ b/src/alertmanager/cli/config/config_test.go @@ -0,0 +1,184 @@ +// Copyright 2015 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package config + +import ( + "io/ioutil" + "testing" + + "gopkg.in/alecthomas/kingpin.v2" +) + +var ( + url *string + id *string +) + +func newApp() *kingpin.Application { + url = new(string) + id = new(string) + + app := kingpin.New("app", "") + app.UsageWriter(ioutil.Discard) + app.ErrorWriter(ioutil.Discard) + app.Terminate(nil) + + app.Flag("url", "").StringVar(url) + + silence := app.Command("silence", "") + silenceDel := silence.Command("del", "") + silenceDel.Flag("id", "").StringVar(id) + + return app +} + +func TestNewConfigResolver(t *testing.T) { + for i, tc := range []struct { + files []string + err bool + }{ + {[]string{}, false}, + {[]string{"testdata/amtool.good1.yml", "testdata/amtool.good2.yml"}, false}, + {[]string{"testdata/amtool.good1.yml", "testdata/not_existing.yml"}, false}, + {[]string{"testdata/amtool.good1.yml", "testdata/amtool.bad.yml"}, true}, + } { + _, err := NewResolver(tc.files, nil) + if tc.err != (err != nil) { + if tc.err { + t.Fatalf("%d: expected error but got none", i) + } else { + t.Fatalf("%d: expected no error but got %v", i, err) + } + } + } +} + +type expectFn func() + +func TestConfigResolverBind(t *testing.T) { + expectURL := func(expected string) expectFn { + return func() { + if *url != expected { + t.Fatalf("expected url flag %q but got %q", expected, *url) + } + } + } + expectID := func(expected string) expectFn { + return func() { + if *id != expected { + t.Fatalf("expected ID flag %q but got %q", expected, *id) + } + } + } + + for i, tc := range []struct { + files []string + legacyFlags map[string]string + args []string + + err bool + expCmd string + expFns []expectFn + }{ + { + []string{"testdata/amtool.good1.yml", "testdata/amtool.good2.yml"}, + nil, + []string{}, + + true, + "", + []expectFn{expectURL("url1")}, // from amtool.good1.yml + }, + { + []string{"testdata/amtool.good2.yml"}, + nil, + []string{}, + + true, + "", + []expectFn{expectURL("url2")}, // from amtool.good2.yml + }, + { + []string{"testdata/amtool.good1.yml", "testdata/amtool.good2.yml"}, + nil, + []string{"--url", "url3"}, + + true, + "", + []expectFn{expectURL("url3")}, // from command line + }, + { + []string{"testdata/amtool.good1.yml", "testdata/amtool.good2.yml"}, + map[string]string{"old-id": "id"}, + []string{"silence", "del"}, + + false, + "silence del", + []expectFn{ + expectURL("url1"), // from amtool.good1.yml + expectID("id1"), // from amtool.good1.yml + }, + }, + { + []string{"testdata/amtool.good2.yml"}, + map[string]string{"old-id": "id"}, + []string{"silence", "del"}, + + false, + "silence del", + []expectFn{ + expectURL("url2"), // from amtool.good2.yml + expectID("id2"), // from amtool.good2.yml + }, + }, + { + []string{"testdata/amtool.good2.yml"}, + map[string]string{"old-id": "id"}, + []string{"silence", "del", "--id", "id3"}, + + false, + "silence del", + []expectFn{ + expectURL("url2"), // from amtool.good2.yml + expectID("id3"), // from command line + }, + }, + } { + r, err := NewResolver(tc.files, tc.legacyFlags) + if err != nil { + t.Fatalf("%d: expected no error but got: %v", i, err) + } + + app := newApp() + err = r.Bind(app, tc.args) + if err != nil { + t.Fatalf("%d: expected Bind() to return no error but got: %v", i, err) + } + + cmd, err := app.Parse(tc.args) + if tc.err != (err != nil) { + if tc.err { + t.Fatalf("%d: expected Parse() to return an error but got none", i) + } else { + t.Fatalf("%d: expected Parse() to return no error but got: %v", i, err) + } + } + if cmd != tc.expCmd { + t.Fatalf("%d: expected command %q but got %q", i, tc.expCmd, cmd) + } + for _, fn := range tc.expFns { + fn() + } + } +} diff --git a/src/alertmanager/cli/config/testdata/amtool.bad.yml b/src/alertmanager/cli/config/testdata/amtool.bad.yml new file mode 100644 index 0000000..7b3a785 --- /dev/null +++ b/src/alertmanager/cli/config/testdata/amtool.bad.yml @@ -0,0 +1 @@ +BAD diff --git a/src/alertmanager/cli/config/testdata/amtool.good1.yml b/src/alertmanager/cli/config/testdata/amtool.good1.yml new file mode 100644 index 0000000..4185e8a --- /dev/null +++ b/src/alertmanager/cli/config/testdata/amtool.good1.yml @@ -0,0 +1,2 @@ +id: id1 +url: url1 diff --git a/src/alertmanager/cli/config/testdata/amtool.good2.yml b/src/alertmanager/cli/config/testdata/amtool.good2.yml new file mode 100644 index 0000000..1fe36c9 --- /dev/null +++ b/src/alertmanager/cli/config/testdata/amtool.good2.yml @@ -0,0 +1,2 @@ +old-id: id2 +url: url2 diff --git a/src/alertmanager/cli/format/format.go b/src/alertmanager/cli/format/format.go new file mode 100644 index 0000000..471d020 --- /dev/null +++ b/src/alertmanager/cli/format/format.go @@ -0,0 +1,49 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package format + +import ( + "io" + "time" + + "gopkg.in/alecthomas/kingpin.v2" + + "github.com/prometheus/alertmanager/client" + "github.com/prometheus/alertmanager/types" +) + +const DefaultDateFormat = "2006-01-02 15:04:05 MST" + +var ( + dateFormat *string +) + +func InitFormatFlags(app *kingpin.Application) { + dateFormat = app.Flag("date.format", "Format of date output").Default(DefaultDateFormat).String() +} + +// Formatter needs to be implemented for each new output formatter. +type Formatter interface { + SetOutput(io.Writer) + FormatSilences([]types.Silence) error + FormatAlerts([]*client.ExtendedAlert) error + FormatConfig(*client.ServerStatus) error +} + +// Formatters is a map of cli argument names to formatter interface object. +var Formatters = map[string]Formatter{} + +func FormatDate(input time.Time) string { + return input.Format(*dateFormat) +} diff --git a/src/alertmanager/cli/format/format_extended.go b/src/alertmanager/cli/format/format_extended.go new file mode 100644 index 0000000..84e276e --- /dev/null +++ b/src/alertmanager/cli/format/format_extended.go @@ -0,0 +1,123 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package format + +import ( + "fmt" + "io" + "os" + "sort" + "strings" + "text/tabwriter" + + "github.com/prometheus/alertmanager/client" + "github.com/prometheus/alertmanager/types" +) + +type ExtendedFormatter struct { + writer io.Writer +} + +func init() { + Formatters["extended"] = &ExtendedFormatter{writer: os.Stdout} +} + +func (formatter *ExtendedFormatter) SetOutput(writer io.Writer) { + formatter.writer = writer +} + +func (formatter *ExtendedFormatter) FormatSilences(silences []types.Silence) error { + w := tabwriter.NewWriter(formatter.writer, 0, 0, 2, ' ', 0) + sort.Sort(ByEndAt(silences)) + fmt.Fprintln(w, "ID\tMatchers\tStarts At\tEnds At\tUpdated At\tCreated By\tComment\t") + for _, silence := range silences { + fmt.Fprintf( + w, + "%s\t%s\t%s\t%s\t%s\t%s\t%s\t\n", + silence.ID, + extendedFormatMatchers(silence.Matchers), + FormatDate(silence.StartsAt), + FormatDate(silence.EndsAt), + FormatDate(silence.UpdatedAt), + silence.CreatedBy, + silence.Comment, + ) + } + w.Flush() + return nil +} + +func (formatter *ExtendedFormatter) FormatAlerts(alerts []*client.ExtendedAlert) error { + w := tabwriter.NewWriter(formatter.writer, 0, 0, 2, ' ', 0) + sort.Sort(ByStartsAt(alerts)) + fmt.Fprintln(w, "Labels\tAnnotations\tStarts At\tEnds At\tGenerator URL\t") + for _, alert := range alerts { + fmt.Fprintf( + w, + "%s\t%s\t%s\t%s\t%s\t\n", + extendedFormatLabels(alert.Labels), + extendedFormatAnnotations(alert.Annotations), + FormatDate(alert.StartsAt), + FormatDate(alert.EndsAt), + alert.GeneratorURL, + ) + } + w.Flush() + return nil +} + +func (formatter *ExtendedFormatter) FormatConfig(status *client.ServerStatus) error { + fmt.Fprintln(formatter.writer, status.ConfigYAML) + fmt.Fprintln(formatter.writer, "buildUser", status.VersionInfo["buildUser"]) + fmt.Fprintln(formatter.writer, "goVersion", status.VersionInfo["goVersion"]) + fmt.Fprintln(formatter.writer, "revision", status.VersionInfo["revision"]) + fmt.Fprintln(formatter.writer, "version", status.VersionInfo["version"]) + fmt.Fprintln(formatter.writer, "branch", status.VersionInfo["branch"]) + fmt.Fprintln(formatter.writer, "buildDate", status.VersionInfo["buildDate"]) + fmt.Fprintln(formatter.writer, "uptime", status.Uptime) + return nil +} + +func extendedFormatLabels(labels client.LabelSet) string { + output := []string{} + for name, value := range labels { + output = append(output, fmt.Sprintf("%s=\"%s\"", name, value)) + } + sort.Strings(output) + return strings.Join(output, " ") +} + +func extendedFormatAnnotations(labels client.LabelSet) string { + output := []string{} + for name, value := range labels { + output = append(output, fmt.Sprintf("%s=\"%s\"", name, value)) + } + sort.Strings(output) + return strings.Join(output, " ") +} + +func extendedFormatMatchers(matchers types.Matchers) string { + output := []string{} + for _, matcher := range matchers { + output = append(output, extendedFormatMatcher(*matcher)) + } + return strings.Join(output, " ") +} + +func extendedFormatMatcher(matcher types.Matcher) string { + if matcher.IsRegex { + return fmt.Sprintf("%s~=%s", matcher.Name, matcher.Value) + } + return fmt.Sprintf("%s=%s", matcher.Name, matcher.Value) +} diff --git a/src/alertmanager/cli/format/format_json.go b/src/alertmanager/cli/format/format_json.go new file mode 100644 index 0000000..0a2cd50 --- /dev/null +++ b/src/alertmanager/cli/format/format_json.go @@ -0,0 +1,50 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package format + +import ( + "encoding/json" + "io" + "os" + + "github.com/prometheus/alertmanager/client" + "github.com/prometheus/alertmanager/types" +) + +type JSONFormatter struct { + writer io.Writer +} + +func init() { + Formatters["json"] = &JSONFormatter{writer: os.Stdout} +} + +func (formatter *JSONFormatter) SetOutput(writer io.Writer) { + formatter.writer = writer +} + +func (formatter *JSONFormatter) FormatSilences(silences []types.Silence) error { + enc := json.NewEncoder(formatter.writer) + return enc.Encode(silences) +} + +func (formatter *JSONFormatter) FormatAlerts(alerts []*client.ExtendedAlert) error { + enc := json.NewEncoder(formatter.writer) + return enc.Encode(alerts) +} + +func (formatter *JSONFormatter) FormatConfig(status *client.ServerStatus) error { + enc := json.NewEncoder(formatter.writer) + return enc.Encode(status) +} diff --git a/src/alertmanager/cli/format/format_simple.go b/src/alertmanager/cli/format/format_simple.go new file mode 100644 index 0000000..cb688e3 --- /dev/null +++ b/src/alertmanager/cli/format/format_simple.go @@ -0,0 +1,94 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package format + +import ( + "fmt" + "io" + "os" + "sort" + "strings" + "text/tabwriter" + + "github.com/prometheus/alertmanager/client" + "github.com/prometheus/alertmanager/types" +) + +type SimpleFormatter struct { + writer io.Writer +} + +func init() { + Formatters["simple"] = &SimpleFormatter{writer: os.Stdout} +} + +func (formatter *SimpleFormatter) SetOutput(writer io.Writer) { + formatter.writer = writer +} + +func (formatter *SimpleFormatter) FormatSilences(silences []types.Silence) error { + w := tabwriter.NewWriter(formatter.writer, 0, 0, 2, ' ', 0) + sort.Sort(ByEndAt(silences)) + fmt.Fprintln(w, "ID\tMatchers\tEnds At\tCreated By\tComment\t") + for _, silence := range silences { + fmt.Fprintf( + w, + "%s\t%s\t%s\t%s\t%s\t\n", + silence.ID, + simpleFormatMatchers(silence.Matchers), + FormatDate(silence.EndsAt), + silence.CreatedBy, + silence.Comment, + ) + } + w.Flush() + return nil +} + +func (formatter *SimpleFormatter) FormatAlerts(alerts []*client.ExtendedAlert) error { + w := tabwriter.NewWriter(formatter.writer, 0, 0, 2, ' ', 0) + sort.Sort(ByStartsAt(alerts)) + fmt.Fprintln(w, "Alertname\tStarts At\tSummary\t") + for _, alert := range alerts { + fmt.Fprintf( + w, + "%s\t%s\t%s\t\n", + alert.Labels["alertname"], + FormatDate(alert.StartsAt), + alert.Annotations["summary"], + ) + } + w.Flush() + return nil +} + +func (formatter *SimpleFormatter) FormatConfig(status *client.ServerStatus) error { + fmt.Fprintln(formatter.writer, status.ConfigYAML) + return nil +} + +func simpleFormatMatchers(matchers types.Matchers) string { + output := []string{} + for _, matcher := range matchers { + output = append(output, simpleFormatMatcher(*matcher)) + } + return strings.Join(output, " ") +} + +func simpleFormatMatcher(matcher types.Matcher) string { + if matcher.IsRegex { + return fmt.Sprintf("%s=~%s", matcher.Name, matcher.Value) + } + return fmt.Sprintf("%s=%s", matcher.Name, matcher.Value) +} diff --git a/src/alertmanager/cli/format/sort.go b/src/alertmanager/cli/format/sort.go new file mode 100644 index 0000000..7a34607 --- /dev/null +++ b/src/alertmanager/cli/format/sort.go @@ -0,0 +1,31 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package format + +import ( + "github.com/prometheus/alertmanager/client" + "github.com/prometheus/alertmanager/types" +) + +type ByEndAt []types.Silence + +func (s ByEndAt) Len() int { return len(s) } +func (s ByEndAt) Swap(i, j int) { s[i], s[j] = s[j], s[i] } +func (s ByEndAt) Less(i, j int) bool { return s[i].EndsAt.Before(s[j].EndsAt) } + +type ByStartsAt []*client.ExtendedAlert + +func (s ByStartsAt) Len() int { return len(s) } +func (s ByStartsAt) Swap(i, j int) { s[i], s[j] = s[j], s[i] } +func (s ByStartsAt) Less(i, j int) bool { return s[i].StartsAt.Before(s[j].StartsAt) } diff --git a/src/alertmanager/cli/root.go b/src/alertmanager/cli/root.go new file mode 100644 index 0000000..a0931a9 --- /dev/null +++ b/src/alertmanager/cli/root.go @@ -0,0 +1,116 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cli + +import ( + "net/url" + "os" + + "github.com/prometheus/common/version" + "gopkg.in/alecthomas/kingpin.v2" + + "github.com/prometheus/alertmanager/cli/config" + "github.com/prometheus/alertmanager/cli/format" +) + +var ( + verbose bool + alertmanagerURL *url.URL + output string + + configFiles = []string{os.ExpandEnv("$HOME/.config/amtool/config.yml"), "/etc/amtool/config.yml"} + legacyFlags = map[string]string{"comment_required": "require-comment"} +) + +func requireAlertManagerURL(pc *kingpin.ParseContext) error { + // Return without error if any help flag is set. + for _, elem := range pc.Elements { + f, ok := elem.Clause.(*kingpin.FlagClause) + if !ok { + continue + } + name := f.Model().Name + if name == "help" || name == "help-long" || name == "help-man" { + return nil + } + } + if alertmanagerURL == nil { + kingpin.Fatalf("required flag --alertmanager.url not provided") + } + return nil +} + +func Execute() { + var ( + app = kingpin.New("amtool", helpRoot).DefaultEnvars() + ) + + format.InitFormatFlags(app) + + app.Flag("verbose", "Verbose running information").Short('v').BoolVar(&verbose) + app.Flag("alertmanager.url", "Alertmanager to talk to").URLVar(&alertmanagerURL) + app.Flag("output", "Output formatter (simple, extended, json)").Short('o').Default("simple").EnumVar(&output, "simple", "extended", "json") + app.Version(version.Print("amtool")) + app.GetFlag("help").Short('h') + app.UsageTemplate(kingpin.CompactUsageTemplate) + + resolver, err := config.NewResolver(configFiles, legacyFlags) + if err != nil { + kingpin.Fatalf("could not load config file: %v\n", err) + } + + configureAlertCmd(app) + configureSilenceCmd(app) + configureCheckConfigCmd(app) + configureConfigCmd(app) + + err = resolver.Bind(app, os.Args[1:]) + if err != nil { + kingpin.Fatalf("%v\n", err) + } + + _, err = app.Parse(os.Args[1:]) + if err != nil { + kingpin.Fatalf("%v\n", err) + } +} + +const ( + helpRoot = `View and modify the current Alertmanager state. + +Config File: +The alertmanager tool will read a config file in YAML format from one of two +default config locations: $HOME/.config/amtool/config.yml or +/etc/amtool/config.yml + +All flags can be given in the config file, but the following are the suited for +static configuration: + + alertmanager.url + Set a default alertmanager url for each request + + author + Set a default author value for new silences. If this argument is not + specified then the username will be used + + require-comment + Bool, whether to require a comment on silence creation. Defaults to true + + output + Set a default output type. Options are (simple, extended, json) + + date.format + Sets the output format for dates. Defaults to "2006-01-02 15:04:05 MST" +` +) diff --git a/src/alertmanager/cli/silence.go b/src/alertmanager/cli/silence.go new file mode 100644 index 0000000..b2e47c5 --- /dev/null +++ b/src/alertmanager/cli/silence.go @@ -0,0 +1,26 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cli + +import "gopkg.in/alecthomas/kingpin.v2" + +// silenceCmd represents the silence command +func configureSilenceCmd(app *kingpin.Application) { + silenceCmd := app.Command("silence", "Add, expire or view silences. For more information and additional flags see query help").PreAction(requireAlertManagerURL) + configureSilenceAddCmd(silenceCmd) + configureSilenceExpireCmd(silenceCmd) + configureSilenceImportCmd(silenceCmd) + configureSilenceQueryCmd(silenceCmd) + configureSilenceUpdateCmd(silenceCmd) +} diff --git a/src/alertmanager/cli/silence_add.go b/src/alertmanager/cli/silence_add.go new file mode 100644 index 0000000..0cec43d --- /dev/null +++ b/src/alertmanager/cli/silence_add.go @@ -0,0 +1,162 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cli + +import ( + "context" + "errors" + "fmt" + "os/user" + "time" + + "github.com/prometheus/client_golang/api" + "github.com/prometheus/common/model" + "gopkg.in/alecthomas/kingpin.v2" + + "github.com/prometheus/alertmanager/client" + "github.com/prometheus/alertmanager/types" +) + +func username() string { + user, err := user.Current() + if err != nil { + return "" + } + return user.Username +} + +type silenceAddCmd struct { + author string + requireComment bool + duration string + start string + end string + comment string + matchers []string +} + +const silenceAddHelp = `Add a new alertmanager silence + + Amtool uses a simplified Prometheus syntax to represent silences. The + non-option section of arguments constructs a list of "Matcher Groups" + that will be used to create a number of silences. The following examples + will attempt to show this behaviour in action: + + amtool silence add alertname=foo node=bar + + This statement will add a silence that matches alerts with the + alertname=foo and node=bar label value pairs set. + + amtool silence add foo node=bar + + If alertname is omitted and the first argument does not contain a '=' or a + '=~' then it will be assumed to be the value of the alertname pair. + + amtool silence add 'alertname=~foo.*' + + As well as direct equality, regex matching is also supported. The '=~' syntax + (similar to Prometheus) is used to represent a regex match. Regex matching + can be used in combination with a direct match. +` + +func configureSilenceAddCmd(cc *kingpin.CmdClause) { + var ( + c = &silenceAddCmd{} + addCmd = cc.Command("add", silenceAddHelp) + ) + addCmd.Flag("author", "Username for CreatedBy field").Short('a').Default(username()).StringVar(&c.author) + addCmd.Flag("require-comment", "Require comment to be set").Hidden().Default("true").BoolVar(&c.requireComment) + addCmd.Flag("duration", "Duration of silence").Short('d').Default("1h").StringVar(&c.duration) + addCmd.Flag("start", "Set when the silence should start. RFC3339 format 2006-01-02T15:04:05Z07:00").StringVar(&c.start) + addCmd.Flag("end", "Set when the silence should end (overwrites duration). RFC3339 format 2006-01-02T15:04:05Z07:00").StringVar(&c.end) + addCmd.Flag("comment", "A comment to help describe the silence").Short('c').StringVar(&c.comment) + addCmd.Arg("matcher-groups", "Query filter").StringsVar(&c.matchers) + addCmd.Action(c.add) + +} + +func (c *silenceAddCmd) add(ctx *kingpin.ParseContext) error { + var err error + + matchers, err := parseMatchers(c.matchers) + if err != nil { + return err + } + + if len(matchers) < 1 { + return fmt.Errorf("no matchers specified") + } + + var endsAt time.Time + if c.end != "" { + endsAt, err = time.Parse(time.RFC3339, c.end) + if err != nil { + return err + } + } else { + d, err := model.ParseDuration(c.duration) + if err != nil { + return err + } + if d == 0 { + return fmt.Errorf("silence duration must be greater than 0") + } + endsAt = time.Now().UTC().Add(time.Duration(d)) + } + + if c.requireComment && c.comment == "" { + return errors.New("comment required by config") + } + + var startsAt time.Time + if c.start != "" { + startsAt, err = time.Parse(time.RFC3339, c.start) + if err != nil { + return err + } + + } else { + startsAt = time.Now().UTC() + } + + if startsAt.After(endsAt) { + return errors.New("silence cannot start after it ends") + } + + typeMatchers, err := TypeMatchers(matchers) + if err != nil { + return err + } + + silence := types.Silence{ + Matchers: typeMatchers, + StartsAt: startsAt, + EndsAt: endsAt, + CreatedBy: c.author, + Comment: c.comment, + } + + apiClient, err := api.NewClient(api.Config{Address: alertmanagerURL.String()}) + if err != nil { + return err + } + silenceAPI := client.NewSilenceAPI(apiClient) + silenceID, err := silenceAPI.Set(context.Background(), silence) + if err != nil { + return err + } + + _, err = fmt.Println(silenceID) + return err +} diff --git a/src/alertmanager/cli/silence_expire.go b/src/alertmanager/cli/silence_expire.go new file mode 100644 index 0000000..2c2b301 --- /dev/null +++ b/src/alertmanager/cli/silence_expire.go @@ -0,0 +1,58 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cli + +import ( + "context" + "errors" + + "github.com/prometheus/client_golang/api" + "gopkg.in/alecthomas/kingpin.v2" + + "github.com/prometheus/alertmanager/client" +) + +type silenceExpireCmd struct { + ids []string +} + +func configureSilenceExpireCmd(cc *kingpin.CmdClause) { + var ( + c = &silenceExpireCmd{} + expireCmd = cc.Command("expire", "expire an alertmanager silence") + ) + expireCmd.Arg("silence-ids", "Ids of silences to expire").StringsVar(&c.ids) + expireCmd.Action(c.expire) +} + +func (c *silenceExpireCmd) expire(ctx *kingpin.ParseContext) error { + if len(c.ids) < 1 { + return errors.New("no silence IDs specified") + } + + apiClient, err := api.NewClient(api.Config{Address: alertmanagerURL.String()}) + if err != nil { + return err + } + silenceAPI := client.NewSilenceAPI(apiClient) + + for _, id := range c.ids { + err := silenceAPI.Expire(context.Background(), id) + if err != nil { + return err + } + } + + return nil +} diff --git a/src/alertmanager/cli/silence_import.go b/src/alertmanager/cli/silence_import.go new file mode 100644 index 0000000..f33a6e0 --- /dev/null +++ b/src/alertmanager/cli/silence_import.go @@ -0,0 +1,149 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cli + +import ( + "context" + "encoding/json" + "fmt" + "os" + "strings" + "sync" + + "github.com/pkg/errors" + "github.com/prometheus/client_golang/api" + "gopkg.in/alecthomas/kingpin.v2" + + "github.com/prometheus/alertmanager/client" + "github.com/prometheus/alertmanager/types" +) + +type silenceImportCmd struct { + force bool + workers int + file string +} + +const silenceImportHelp = `Import alertmanager silences from JSON file or stdin + +This command can be used to bulk import silences from a JSON file +created by query command. For example: + +amtool silence query -o json foo > foo.json + +amtool silence import foo.json + +JSON data can also come from stdin if no param is specified. +` + +func configureSilenceImportCmd(cc *kingpin.CmdClause) { + var ( + c = &silenceImportCmd{} + importCmd = cc.Command("import", silenceImportHelp) + ) + + importCmd.Flag("force", "Force adding new silences even if it already exists").Short('f').BoolVar(&c.force) + importCmd.Flag("worker", "Number of concurrent workers to use for import").Short('w').Default("8").IntVar(&c.workers) + importCmd.Arg("input-file", "JSON file with silences").ExistingFileVar(&c.file) + importCmd.Action(c.bulkImport) +} + +func addSilenceWorker(sclient client.SilenceAPI, silencec <-chan *types.Silence, errc chan<- error) { + for s := range silencec { + silenceID, err := sclient.Set(context.Background(), *s) + sid := s.ID + if err != nil && strings.Contains(err.Error(), "not found") { + // silence doesn't exists yet, retry to create as a new one + s.ID = "" + silenceID, err = sclient.Set(context.Background(), *s) + } + + if err != nil { + fmt.Fprintf(os.Stderr, "Error adding silence id='%v': %v\n", sid, err) + } else { + fmt.Println(silenceID) + } + errc <- err + } +} + +func (c *silenceImportCmd) bulkImport(ctx *kingpin.ParseContext) error { + input := os.Stdin + var err error + if c.file != "" { + input, err = os.Open(c.file) + if err != nil { + return err + } + defer input.Close() + } + + dec := json.NewDecoder(input) + // read open square bracket + _, err = dec.Token() + if err != nil { + return errors.Wrap(err, "couldn't unmarshal input data, is it JSON?") + } + + apiClient, err := api.NewClient(api.Config{Address: alertmanagerURL.String()}) + if err != nil { + return err + } + silenceAPI := client.NewSilenceAPI(apiClient) + silencec := make(chan *types.Silence, 100) + errc := make(chan error, 100) + var wg sync.WaitGroup + for w := 0; w < c.workers; w++ { + wg.Add(1) + go func() { + addSilenceWorker(silenceAPI, silencec, errc) + wg.Done() + }() + } + + errCount := 0 + go func() { + for err := range errc { + if err != nil { + errCount++ + } + } + }() + + count := 0 + for dec.More() { + var s types.Silence + err := dec.Decode(&s) + if err != nil { + return errors.Wrap(err, "couldn't unmarshal input data, is it JSON?") + } + + if c.force { + // reset the silence ID so Alertmanager will always create new silence + s.ID = "" + } + + silencec <- &s + count++ + } + + close(silencec) + wg.Wait() + close(errc) + + if errCount > 0 { + return fmt.Errorf("couldn't import %v out of %v silences", errCount, count) + } + return nil +} diff --git a/src/alertmanager/cli/silence_query.go b/src/alertmanager/cli/silence_query.go new file mode 100644 index 0000000..c292109 --- /dev/null +++ b/src/alertmanager/cli/silence_query.go @@ -0,0 +1,154 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cli + +import ( + "context" + "errors" + "fmt" + "strings" + "time" + + "github.com/prometheus/client_golang/api" + "gopkg.in/alecthomas/kingpin.v2" + + "github.com/prometheus/alertmanager/cli/format" + "github.com/prometheus/alertmanager/client" + "github.com/prometheus/alertmanager/pkg/parse" + "github.com/prometheus/alertmanager/types" +) + +type silenceQueryCmd struct { + expired bool + quiet bool + matchers []string + within time.Duration +} + +const querySilenceHelp = `Query Alertmanager silences. + +Amtool has a simplified prometheus query syntax, but contains robust support for +bash variable expansions. The non-option section of arguments constructs a list +of "Matcher Groups" that will be used to filter your query. The following +examples will attempt to show this behaviour in action: + +amtool silence query alertname=foo node=bar + + This query will match all silences with the alertname=foo and node=bar label + value pairs set. + +amtool silence query foo node=bar + + If alertname is omitted and the first argument does not contain a '=' or a + '=~' then it will be assumed to be the value of the alertname pair. + +amtool silence query 'alertname=~foo.*' + + As well as direct equality, regex matching is also supported. The '=~' syntax + (similar to prometheus) is used to represent a regex match. Regex matching + can be used in combination with a direct match. + +In addition to filtering by silence labels, one can also query for silences +that are due to expire soon with the "--within" parameter. In the event that +you want to preemptively act upon expiring silences by either fixing them or +extending them. For example: + +amtool silence query --within 8h + +returns all the silences due to expire within the next 8 hours. This syntax can +also be combined with the label based filtering above for more flexibility. + +The "--expired" parameter returns only expired silences. Used in combination +with "--within=TIME", amtool returns the silences that expired within the +preceding duration. + +amtool silence query --within 2h --expired + +returns all silences that expired within the preceeding 2 hours. +` + +func configureSilenceQueryCmd(cc *kingpin.CmdClause) { + var ( + c = &silenceQueryCmd{} + queryCmd = cc.Command("query", querySilenceHelp).Default() + ) + + queryCmd.Flag("expired", "Show expired silences instead of active").BoolVar(&c.expired) + queryCmd.Flag("quiet", "Only show silence ids").Short('q').BoolVar(&c.quiet) + queryCmd.Arg("matcher-groups", "Query filter").StringsVar(&c.matchers) + queryCmd.Flag("within", "Show silences that will expire or have expired within a duration").DurationVar(&c.within) + queryCmd.Action(c.query) +} + +func (c *silenceQueryCmd) query(ctx *kingpin.ParseContext) error { + var filterString = "" + if len(c.matchers) == 1 { + // If the parser fails then we likely don't have a (=|=~|!=|!~) so lets + // assume that the user wants alertname= and prepend `alertname=` + // to the front. + _, err := parse.Matcher(c.matchers[0]) + if err != nil { + filterString = fmt.Sprintf("{alertname=%s}", c.matchers[0]) + } else { + filterString = fmt.Sprintf("{%s}", strings.Join(c.matchers, ",")) + } + } else if len(c.matchers) > 1 { + filterString = fmt.Sprintf("{%s}", strings.Join(c.matchers, ",")) + } + + apiClient, err := api.NewClient(api.Config{Address: alertmanagerURL.String()}) + if err != nil { + return err + } + silenceAPI := client.NewSilenceAPI(apiClient) + fetchedSilences, err := silenceAPI.List(context.Background(), filterString) + if err != nil { + return err + } + + displaySilences := []types.Silence{} + for _, silence := range fetchedSilences { + // skip expired silences if --expired is not set + if !c.expired && silence.EndsAt.Before(time.Now()) { + continue + } + // skip active silences if --expired is set + if c.expired && silence.EndsAt.After(time.Now()) { + continue + } + // skip active silences expiring after "--within" + if !c.expired && int64(c.within) > 0 && silence.EndsAt.After(time.Now().UTC().Add(c.within)) { + continue + } + // skip silences that expired before "--within" + if c.expired && int64(c.within) > 0 && silence.EndsAt.Before(time.Now().UTC().Add(-c.within)) { + continue + } + + displaySilences = append(displaySilences, *silence) + } + + if c.quiet { + for _, silence := range displaySilences { + fmt.Println(silence.ID) + } + } else { + formatter, found := format.Formatters[output] + if !found { + return errors.New("unknown output formatter") + } + formatter.FormatSilences(displaySilences) + } + return nil +} diff --git a/src/alertmanager/cli/silence_update.go b/src/alertmanager/cli/silence_update.go new file mode 100644 index 0000000..55546ce --- /dev/null +++ b/src/alertmanager/cli/silence_update.go @@ -0,0 +1,124 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cli + +import ( + "context" + "errors" + "fmt" + "time" + + "github.com/prometheus/client_golang/api" + "gopkg.in/alecthomas/kingpin.v2" + + "github.com/prometheus/alertmanager/cli/format" + "github.com/prometheus/alertmanager/client" + "github.com/prometheus/alertmanager/types" + "github.com/prometheus/common/model" +) + +type silenceUpdateCmd struct { + quiet bool + duration string + start string + end string + comment string + ids []string +} + +func configureSilenceUpdateCmd(cc *kingpin.CmdClause) { + var ( + c = &silenceUpdateCmd{} + updateCmd = cc.Command("update", "Update silences") + ) + updateCmd.Flag("quiet", "Only show silence ids").Short('q').BoolVar(&c.quiet) + updateCmd.Flag("duration", "Duration of silence").Short('d').StringVar(&c.duration) + updateCmd.Flag("start", "Set when the silence should start. RFC3339 format 2006-01-02T15:04:05Z07:00").StringVar(&c.start) + updateCmd.Flag("end", "Set when the silence should end (overwrites duration). RFC3339 format 2006-01-02T15:04:05Z07:00").StringVar(&c.end) + updateCmd.Flag("comment", "A comment to help describe the silence").Short('c').StringVar(&c.comment) + updateCmd.Arg("update-ids", "Silence IDs to update").StringsVar(&c.ids) + + updateCmd.Action(c.update) +} + +func (c *silenceUpdateCmd) update(ctx *kingpin.ParseContext) error { + if len(c.ids) < 1 { + return fmt.Errorf("no silence IDs specified") + } + + apiClient, err := api.NewClient(api.Config{Address: alertmanagerURL.String()}) + if err != nil { + return err + } + silenceAPI := client.NewSilenceAPI(apiClient) + + var updatedSilences []types.Silence + for _, silenceID := range c.ids { + silence, err := silenceAPI.Get(context.Background(), silenceID) + if err != nil { + return err + } + if c.start != "" { + silence.StartsAt, err = time.Parse(time.RFC3339, c.start) + if err != nil { + return err + } + } + + if c.end != "" { + silence.EndsAt, err = time.Parse(time.RFC3339, c.end) + if err != nil { + return err + } + } else if c.duration != "" { + d, err := model.ParseDuration(c.duration) + if err != nil { + return err + } + if d == 0 { + return fmt.Errorf("silence duration must be greater than 0") + } + silence.EndsAt = silence.StartsAt.UTC().Add(time.Duration(d)) + } + + if silence.StartsAt.After(silence.EndsAt) { + return errors.New("silence cannot start after it ends") + } + + if c.comment != "" { + silence.Comment = c.comment + } + + newID, err := silenceAPI.Set(context.Background(), *silence) + if err != nil { + return err + } + silence.ID = newID + + updatedSilences = append(updatedSilences, *silence) + } + + if c.quiet { + for _, silence := range updatedSilences { + fmt.Println(silence.ID) + } + } else { + formatter, found := format.Formatters[output] + if !found { + return fmt.Errorf("unknown output formatter") + } + formatter.FormatSilences(updatedSilences) + } + return nil +} diff --git a/src/alertmanager/cli/testdata/conf.bad.yml b/src/alertmanager/cli/testdata/conf.bad.yml new file mode 100644 index 0000000..a3e2920 --- /dev/null +++ b/src/alertmanager/cli/testdata/conf.bad.yml @@ -0,0 +1 @@ +BAD \ No newline at end of file diff --git a/src/alertmanager/cli/testdata/conf.good.yml b/src/alertmanager/cli/testdata/conf.good.yml new file mode 100644 index 0000000..0d6b3ef --- /dev/null +++ b/src/alertmanager/cli/testdata/conf.good.yml @@ -0,0 +1,11 @@ +global: + smtp_smarthost: 'localhost:25' + +templates: + - '/etc/alertmanager/template/*.tmpl' + +route: + receiver: default + +receivers: + - name: default diff --git a/src/alertmanager/cli/utils.go b/src/alertmanager/cli/utils.go new file mode 100644 index 0000000..7705003 --- /dev/null +++ b/src/alertmanager/cli/utils.go @@ -0,0 +1,95 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cli + +import ( + "fmt" + "net/url" + "path" + + "github.com/prometheus/alertmanager/pkg/parse" + "github.com/prometheus/alertmanager/types" + "github.com/prometheus/common/model" + "github.com/prometheus/prometheus/pkg/labels" +) + +type ByAlphabetical []labels.Matcher + +func (s ByAlphabetical) Len() int { return len(s) } +func (s ByAlphabetical) Swap(i, j int) { s[i], s[j] = s[j], s[i] } +func (s ByAlphabetical) Less(i, j int) bool { + if s[i].Name != s[j].Name { + return s[i].Name < s[j].Name + } else if s[i].Type != s[j].Type { + return s[i].Type < s[j].Type + } else if s[i].Value != s[j].Value { + return s[i].Value < s[j].Value + } + return false +} + +func GetAlertmanagerURL(p string) url.URL { + amURL := *alertmanagerURL + amURL.Path = path.Join(alertmanagerURL.Path, p) + return amURL +} + +// Parse a list of labels (cli arguments) +func parseMatchers(inputLabels []string) ([]labels.Matcher, error) { + matchers := make([]labels.Matcher, 0) + + for _, v := range inputLabels { + name, value, matchType, err := parse.Input(v) + if err != nil { + return []labels.Matcher{}, err + } + + matchers = append(matchers, labels.Matcher{ + Type: matchType, + Name: name, + Value: value, + }) + } + + return matchers, nil +} + +// Only valid for when you are going to add a silence +func TypeMatchers(matchers []labels.Matcher) (types.Matchers, error) { + typeMatchers := types.Matchers{} + for _, matcher := range matchers { + typeMatcher, err := TypeMatcher(matcher) + if err != nil { + return types.Matchers{}, err + } + typeMatchers = append(typeMatchers, &typeMatcher) + } + return typeMatchers, nil +} + +// Only valid for when you are going to add a silence +// Doesn't allow negative operators +func TypeMatcher(matcher labels.Matcher) (types.Matcher, error) { + typeMatcher := types.NewMatcher(model.LabelName(matcher.Name), matcher.Value) + + switch matcher.Type { + case labels.MatchEqual: + typeMatcher.IsRegex = false + case labels.MatchRegexp: + typeMatcher.IsRegex = true + default: + return types.Matcher{}, fmt.Errorf("invalid match type for creation operation: %s", matcher.Type) + } + return *typeMatcher, nil +} diff --git a/src/alertmanager/client/client.go b/src/alertmanager/client/client.go new file mode 100644 index 0000000..bc8cbee --- /dev/null +++ b/src/alertmanager/client/client.go @@ -0,0 +1,329 @@ +// Copyright 2018 The Prometheus Authors +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package client + +import ( + "bytes" + "context" + "encoding/json" + "fmt" + "net/http" + "net/url" + "time" + + "github.com/prometheus/client_golang/api" + + "github.com/prometheus/alertmanager/config" + "github.com/prometheus/alertmanager/types" +) + +const ( + apiPrefix = "/api/v1" + + epStatus = apiPrefix + "/status" + epSilence = apiPrefix + "/silence/:id" + epSilences = apiPrefix + "/silences" + epAlerts = apiPrefix + "/alerts" + epAlertGroups = apiPrefix + "/alerts/groups" + + statusSuccess = "success" + statusError = "error" +) + +// ServerStatus represents the status of the AlertManager endpoint. +type ServerStatus struct { + ConfigYAML string `json:"configYAML"` + ConfigJSON *config.Config `json:"configJSON"` + VersionInfo map[string]string `json:"versionInfo"` + Uptime time.Time `json:"uptime"` + ClusterStatus *ClusterStatus `json:"clusterStatus"` +} + +// PeerStatus represents the status of a peer in the cluster. +type PeerStatus struct { + Name string `json:"name"` + Address string `json:"address"` +} + +// ClusterStatus represents the status of the cluster. +type ClusterStatus struct { + Name string `json:"name"` + Status string `json:"status"` + Peers []PeerStatus `json:"peers"` +} + +// apiClient wraps a regular client and processes successful API responses. +// Successful also includes responses that errored at the API level. +type apiClient struct { + api.Client +} + +type apiResponse struct { + Status string `json:"status"` + Data json.RawMessage `json:"data,omitempty"` + ErrorType string `json:"errorType,omitempty"` + Error string `json:"error,omitempty"` +} + +type clientError struct { + code int + msg string +} + +func (e *clientError) Error() string { + return fmt.Sprintf("%s (code: %d)", e.msg, e.code) +} + +func (c apiClient) Do(ctx context.Context, req *http.Request) (*http.Response, []byte, error) { + resp, body, err := c.Client.Do(ctx, req) + if err != nil { + return resp, body, err + } + + code := resp.StatusCode + + var result apiResponse + if err = json.Unmarshal(body, &result); err != nil { + // Pass the returned body rather than the JSON error because some API + // endpoints return plain text instead of JSON payload. + return resp, body, &clientError{ + code: code, + msg: string(body), + } + } + + if (code/100 == 2) && (result.Status != statusSuccess) { + return resp, body, &clientError{ + code: code, + msg: "inconsistent body for response code", + } + } + + if result.Status == statusError { + err = &clientError{ + code: code, + msg: result.Error, + } + } + + return resp, []byte(result.Data), err +} + +// StatusAPI provides bindings for the Alertmanager's status API. +type StatusAPI interface { + // Get returns the server's configuration, version, uptime and cluster information. + Get(ctx context.Context) (*ServerStatus, error) +} + +// NewStatusAPI returns a status API client. +func NewStatusAPI(c api.Client) StatusAPI { + return &httpStatusAPI{client: apiClient{c}} +} + +type httpStatusAPI struct { + client api.Client +} + +func (h *httpStatusAPI) Get(ctx context.Context) (*ServerStatus, error) { + u := h.client.URL(epStatus, nil) + + req, _ := http.NewRequest(http.MethodGet, u.String(), nil) + + _, body, err := h.client.Do(ctx, req) + if err != nil { + return nil, err + } + + var ss *ServerStatus + err = json.Unmarshal(body, &ss) + + return ss, err +} + +// AlertAPI provides bindings for the Alertmanager's alert API. +type AlertAPI interface { + // List returns all the active alerts. + List(ctx context.Context, filter, receiver string, silenced, inhibited, active, unprocessed bool) ([]*ExtendedAlert, error) + // Push sends a list of alerts to the Alertmanager. + Push(ctx context.Context, alerts ...Alert) error +} + +// Alert represents an alert as expected by the AlertManager's push alert API. +type Alert struct { + Labels LabelSet `json:"labels"` + Annotations LabelSet `json:"annotations"` + StartsAt time.Time `json:"startsAt,omitempty"` + EndsAt time.Time `json:"endsAt,omitempty"` + GeneratorURL string `json:"generatorURL"` +} + +// ExtendedAlert represents an alert as returned by the AlertManager's list alert API. +type ExtendedAlert struct { + Alert + Status types.AlertStatus `json:"status"` + Receivers []string `json:"receivers"` + Fingerprint string `json:"fingerprint"` +} + +// LabelSet represents a collection of label names and values as a map. +type LabelSet map[LabelName]LabelValue + +// LabelName represents the name of a label. +type LabelName string + +// LabelValue represents the value of a label. +type LabelValue string + +// NewAlertAPI returns a new AlertAPI for the client. +func NewAlertAPI(c api.Client) AlertAPI { + return &httpAlertAPI{client: apiClient{c}} +} + +type httpAlertAPI struct { + client api.Client +} + +func (h *httpAlertAPI) List(ctx context.Context, filter, receiver string, silenced, inhibited, active, unprocessed bool) ([]*ExtendedAlert, error) { + u := h.client.URL(epAlerts, nil) + params := url.Values{} + if filter != "" { + params.Add("filter", filter) + } + params.Add("silenced", fmt.Sprintf("%t", silenced)) + params.Add("inhibited", fmt.Sprintf("%t", inhibited)) + params.Add("active", fmt.Sprintf("%t", active)) + params.Add("unprocessed", fmt.Sprintf("%t", unprocessed)) + params.Add("receiver", receiver) + u.RawQuery = params.Encode() + + req, _ := http.NewRequest(http.MethodGet, u.String(), nil) + + _, body, err := h.client.Do(ctx, req) + if err != nil { + return nil, err + } + + var alts []*ExtendedAlert + err = json.Unmarshal(body, &alts) + + return alts, err +} + +func (h *httpAlertAPI) Push(ctx context.Context, alerts ...Alert) error { + u := h.client.URL(epAlerts, nil) + + var buf bytes.Buffer + if err := json.NewEncoder(&buf).Encode(&alerts); err != nil { + return err + } + + req, _ := http.NewRequest(http.MethodPost, u.String(), &buf) + + _, _, err := h.client.Do(ctx, req) + return err +} + +// SilenceAPI provides bindings for the Alertmanager's silence API. +type SilenceAPI interface { + // Get returns the silence associated with the given ID. + Get(ctx context.Context, id string) (*types.Silence, error) + // Set updates or creates the given silence and returns its ID. + Set(ctx context.Context, sil types.Silence) (string, error) + // Expire expires the silence with the given ID. + Expire(ctx context.Context, id string) error + // List returns silences matching the given filter. + List(ctx context.Context, filter string) ([]*types.Silence, error) +} + +// NewSilenceAPI returns a new SilenceAPI for the client. +func NewSilenceAPI(c api.Client) SilenceAPI { + return &httpSilenceAPI{client: apiClient{c}} +} + +type httpSilenceAPI struct { + client api.Client +} + +func (h *httpSilenceAPI) Get(ctx context.Context, id string) (*types.Silence, error) { + u := h.client.URL(epSilence, map[string]string{ + "id": id, + }) + + req, _ := http.NewRequest(http.MethodGet, u.String(), nil) + + _, body, err := h.client.Do(ctx, req) + if err != nil { + return nil, err + } + + var sil types.Silence + err = json.Unmarshal(body, &sil) + + return &sil, err +} + +func (h *httpSilenceAPI) Expire(ctx context.Context, id string) error { + u := h.client.URL(epSilence, map[string]string{ + "id": id, + }) + + req, _ := http.NewRequest(http.MethodDelete, u.String(), nil) + + _, _, err := h.client.Do(ctx, req) + return err +} + +func (h *httpSilenceAPI) Set(ctx context.Context, sil types.Silence) (string, error) { + u := h.client.URL(epSilences, nil) + + var buf bytes.Buffer + if err := json.NewEncoder(&buf).Encode(&sil); err != nil { + return "", err + } + + req, _ := http.NewRequest(http.MethodPost, u.String(), &buf) + + _, body, err := h.client.Do(ctx, req) + if err != nil { + return "", err + } + + var res struct { + SilenceID string `json:"silenceId"` + } + err = json.Unmarshal(body, &res) + + return res.SilenceID, err +} + +func (h *httpSilenceAPI) List(ctx context.Context, filter string) ([]*types.Silence, error) { + u := h.client.URL(epSilences, nil) + params := url.Values{} + if filter != "" { + params.Add("filter", filter) + } + u.RawQuery = params.Encode() + + req, _ := http.NewRequest(http.MethodGet, u.String(), nil) + + _, body, err := h.client.Do(ctx, req) + if err != nil { + return nil, err + } + + var sils []*types.Silence + err = json.Unmarshal(body, &sils) + + return sils, err +} diff --git a/src/alertmanager/client/client_test.go b/src/alertmanager/client/client_test.go new file mode 100644 index 0000000..5600436 --- /dev/null +++ b/src/alertmanager/client/client_test.go @@ -0,0 +1,457 @@ +// Copyright 2018 The Prometheus Authors +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package client + +import ( + "bytes" + "context" + "encoding/json" + "fmt" + "net/http" + "net/url" + "strings" + "testing" + "time" + + "github.com/prometheus/alertmanager/config" + "github.com/prometheus/alertmanager/types" +) + +type apiTest struct { + // Wrapper around the tested function. + do func() (interface{}, error) + + apiRes fakeAPIResponse + + // Expected values returned by the tested function. + res interface{} + err error +} + +// Fake HTTP client for TestAPI. +type fakeAPIClient struct { + *testing.T + ch chan fakeAPIResponse +} + +type fakeAPIResponse struct { + // Expected input values. + path string + method string + + // Values to be returned by fakeAPIClient.Do(). + err error + res interface{} +} + +func (c *fakeAPIClient) URL(ep string, args map[string]string) *url.URL { + path := ep + for k, v := range args { + path = strings.Replace(path, ":"+k, v, -1) + } + + return &url.URL{ + Host: "test:9093", + Path: path, + } +} + +func (c *fakeAPIClient) Do(ctx context.Context, req *http.Request) (*http.Response, []byte, error) { + test := <-c.ch + + if req.URL.Path != test.path { + c.Errorf("unexpected request path: want %s, got %s", test.path, req.URL.Path) + } + if req.Method != test.method { + c.Errorf("unexpected request method: want %s, got %s", test.method, req.Method) + } + + b, err := json.Marshal(test.res) + if err != nil { + c.Fatal(err) + } + + return &http.Response{}, b, test.err +} + +func TestAPI(t *testing.T) { + client := &fakeAPIClient{T: t, ch: make(chan fakeAPIResponse, 1)} + now := time.Now() + + statusData := &ServerStatus{ + ConfigYAML: "{}", + ConfigJSON: &config.Config{}, + VersionInfo: map[string]string{"version": "v1"}, + Uptime: now, + ClusterStatus: &ClusterStatus{Peers: []PeerStatus{}}, + } + doStatus := func() (interface{}, error) { + api := httpStatusAPI{client: client} + return api.Get(context.Background()) + } + + alertOne := Alert{ + StartsAt: now, + EndsAt: now.Add(time.Duration(5 * time.Minute)), + Labels: LabelSet{"label1": "test1"}, + Annotations: LabelSet{"annotation1": "some text"}, + } + alerts := []*ExtendedAlert{ + { + Alert: alertOne, + Fingerprint: "1c93eec3511dc156", + Status: types.AlertStatus{ + State: types.AlertStateActive, + }, + }, + } + doAlertList := func() (interface{}, error) { + api := httpAlertAPI{client: client} + return api.List(context.Background(), "", "", false, false, false, false) + } + doAlertPush := func() (interface{}, error) { + api := httpAlertAPI{client: client} + return nil, api.Push(context.Background(), []Alert{alertOne}...) + } + + silOne := &types.Silence{ + ID: "abc", + Matchers: []*types.Matcher{ + { + Name: "label1", + Value: "test1", + IsRegex: false, + }, + }, + StartsAt: now, + EndsAt: now.Add(time.Duration(2 * time.Hour)), + UpdatedAt: now, + CreatedBy: "alice", + Comment: "some comment", + Status: types.SilenceStatus{ + State: "active", + }, + } + doSilenceGet := func(id string) func() (interface{}, error) { + return func() (interface{}, error) { + api := httpSilenceAPI{client: client} + return api.Get(context.Background(), id) + } + } + doSilenceSet := func(sil types.Silence) func() (interface{}, error) { + return func() (interface{}, error) { + api := httpSilenceAPI{client: client} + return api.Set(context.Background(), sil) + } + } + doSilenceExpire := func(id string) func() (interface{}, error) { + return func() (interface{}, error) { + api := httpSilenceAPI{client: client} + return nil, api.Expire(context.Background(), id) + } + } + doSilenceList := func() (interface{}, error) { + api := httpSilenceAPI{client: client} + return api.List(context.Background(), "") + } + + tests := []apiTest{ + { + do: doStatus, + apiRes: fakeAPIResponse{ + res: statusData, + path: "/api/v1/status", + method: http.MethodGet, + }, + res: statusData, + }, + { + do: doStatus, + apiRes: fakeAPIResponse{ + err: fmt.Errorf("some error"), + path: "/api/v1/status", + method: http.MethodGet, + }, + err: fmt.Errorf("some error"), + }, + { + do: doAlertList, + apiRes: fakeAPIResponse{ + res: alerts, + path: "/api/v1/alerts", + method: http.MethodGet, + }, + res: alerts, + }, + { + do: doAlertList, + apiRes: fakeAPIResponse{ + err: fmt.Errorf("some error"), + path: "/api/v1/alerts", + method: http.MethodGet, + }, + err: fmt.Errorf("some error"), + }, + { + do: doAlertPush, + apiRes: fakeAPIResponse{ + res: nil, + path: "/api/v1/alerts", + method: http.MethodPost, + }, + res: nil, + }, + { + do: doAlertPush, + apiRes: fakeAPIResponse{ + err: fmt.Errorf("some error"), + path: "/api/v1/alerts", + method: http.MethodPost, + }, + err: fmt.Errorf("some error"), + }, + { + do: doSilenceGet("abc"), + apiRes: fakeAPIResponse{ + res: silOne, + path: "/api/v1/silence/abc", + method: http.MethodGet, + }, + res: silOne, + }, + { + do: doSilenceGet("abc"), + apiRes: fakeAPIResponse{ + err: fmt.Errorf("some error"), + path: "/api/v1/silence/abc", + method: http.MethodGet, + }, + err: fmt.Errorf("some error"), + }, + { + do: doSilenceSet(*silOne), + apiRes: fakeAPIResponse{ + res: map[string]string{"SilenceId": "abc"}, + path: "/api/v1/silences", + method: http.MethodPost, + }, + res: "abc", + }, + { + do: doSilenceSet(*silOne), + apiRes: fakeAPIResponse{ + err: fmt.Errorf("some error"), + path: "/api/v1/silences", + method: http.MethodPost, + }, + err: fmt.Errorf("some error"), + }, + { + do: doSilenceExpire("abc"), + apiRes: fakeAPIResponse{ + path: "/api/v1/silence/abc", + method: http.MethodDelete, + }, + }, + { + do: doSilenceExpire("abc"), + apiRes: fakeAPIResponse{ + err: fmt.Errorf("some error"), + path: "/api/v1/silence/abc", + method: http.MethodDelete, + }, + err: fmt.Errorf("some error"), + }, + { + do: doSilenceList, + apiRes: fakeAPIResponse{ + res: []*types.Silence{silOne}, + path: "/api/v1/silences", + method: http.MethodGet, + }, + res: []*types.Silence{silOne}, + }, + { + do: doSilenceList, + apiRes: fakeAPIResponse{ + err: fmt.Errorf("some error"), + path: "/api/v1/silences", + method: http.MethodGet, + }, + err: fmt.Errorf("some error"), + }, + } + for _, test := range tests { + test := test + client.ch <- test.apiRes + t.Run(fmt.Sprintf("%s %s", test.apiRes.method, test.apiRes.path), func(t *testing.T) { + res, err := test.do() + if test.err != nil { + if err == nil { + t.Errorf("unexpected error: want: %s but got none", test.err) + return + } + if err.Error() != test.err.Error() { + t.Errorf("unexpected error: want: %s, got: %s", test.err, err) + } + return + } + if err != nil { + t.Errorf("unexpected error: %s", err) + return + } + want, err := json.Marshal(test.res) + if err != nil { + t.Fatal(err) + } + got, err := json.Marshal(res) + if err != nil { + t.Fatal(err) + } + if bytes.Compare(want, got) != 0 { + t.Errorf("unexpected result: want: %s, got: %s", string(want), string(got)) + } + }) + } +} + +// Fake HTTP client for TestAPIClientDo. +type fakeClient struct { + *testing.T + ch chan fakeResponse +} + +type fakeResponse struct { + code int + res interface{} + err error +} + +func (c fakeClient) URL(string, map[string]string) *url.URL { + return nil +} + +func (c fakeClient) Do(context.Context, *http.Request) (*http.Response, []byte, error) { + fakeRes := <-c.ch + + if fakeRes.err != nil { + return nil, nil, fakeRes.err + } + + var b []byte + var err error + switch v := fakeRes.res.(type) { + case string: + b = []byte(v) + default: + b, err = json.Marshal(v) + if err != nil { + c.Fatal(err) + } + } + + return &http.Response{StatusCode: fakeRes.code}, b, nil +} + +type apiClientTest struct { + response fakeResponse + + expected string + err error +} + +func TestAPIClientDo(t *testing.T) { + tests := []apiClientTest{ + { + response: fakeResponse{ + code: http.StatusOK, + res: &apiResponse{ + Status: statusSuccess, + Data: json.RawMessage(`"test"`), + }, + err: nil, + }, + expected: `"test"`, + err: nil, + }, + { + response: fakeResponse{ + code: http.StatusBadRequest, + res: &apiResponse{ + Status: statusError, + Error: "some error", + }, + err: nil, + }, + err: fmt.Errorf("some error (code: 400)"), + }, + { + response: fakeResponse{ + code: http.StatusOK, + res: &apiResponse{ + Status: statusError, + Error: "some error", + }, + err: nil, + }, + err: fmt.Errorf("inconsistent body for response code (code: 200)"), + }, + { + response: fakeResponse{ + code: http.StatusNotFound, + res: "not found", + err: nil, + }, + err: fmt.Errorf("not found (code: 404)"), + }, + { + response: fakeResponse{ + err: fmt.Errorf("some error"), + }, + err: fmt.Errorf("some error"), + }, + } + + fake := fakeClient{T: t, ch: make(chan fakeResponse, 1)} + client := apiClient{fake} + + for _, test := range tests { + t.Run("", func(t *testing.T) { + fake.ch <- test.response + + _, body, err := client.Do(context.Background(), &http.Request{}) + if test.err != nil { + if err == nil { + t.Errorf("expected error %q but got none", test.err) + return + } + if test.err.Error() != err.Error() { + t.Errorf("unexpected error: want %q, got %q", test.err, err) + return + } + return + } + + if err != nil { + t.Errorf("unexpected error %q", err) + return + } + + want, got := test.expected, string(body) + if want != got { + t.Errorf("unexpected body: want %q, got %q", want, got) + } + }) + } +} diff --git a/src/alertmanager/cluster/advertise.go b/src/alertmanager/cluster/advertise.go new file mode 100644 index 0000000..fb71cf0 --- /dev/null +++ b/src/alertmanager/cluster/advertise.go @@ -0,0 +1,61 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cluster + +import ( + "net" + + "github.com/hashicorp/go-sockaddr" + "github.com/pkg/errors" +) + +// calculateAdvertiseAddress attempts to clone logic from deep within memberlist +// (NetTransport.FinalAdvertiseAddr) in order to surface its conclusions to the +// application, so we can provide more actionable error messages if the user has +// inadvertantly misconfigured their cluster. +// +// https://github.com/hashicorp/memberlist/blob/022f081/net_transport.go#L126 +func calculateAdvertiseAddress(bindAddr, advertiseAddr string) (net.IP, error) { + if advertiseAddr != "" { + ip := net.ParseIP(advertiseAddr) + if ip == nil { + return nil, errors.Errorf("failed to parse advertise addr '%s'", advertiseAddr) + } + if ip4 := ip.To4(); ip4 != nil { + ip = ip4 + } + return ip, nil + } + + if isAny(bindAddr) { + privateIP, err := sockaddr.GetPrivateIP() + if err != nil { + return nil, errors.Wrap(err, "failed to get private IP") + } + if privateIP == "" { + return nil, errors.Wrap(err, "no private IP found, explicit advertise addr not provided") + } + ip := net.ParseIP(privateIP) + if ip == nil { + return nil, errors.Errorf("failed to parse private IP '%s'", privateIP) + } + return ip, nil + } + + ip := net.ParseIP(bindAddr) + if ip == nil { + return nil, errors.Errorf("failed to parse bind addr '%s'", bindAddr) + } + return ip, nil +} diff --git a/src/alertmanager/cluster/channel.go b/src/alertmanager/cluster/channel.go new file mode 100644 index 0000000..aba87b6 --- /dev/null +++ b/src/alertmanager/cluster/channel.go @@ -0,0 +1,149 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cluster + +import ( + "sync" + "time" + + "github.com/go-kit/kit/log" + "github.com/go-kit/kit/log/level" + "github.com/gogo/protobuf/proto" + "github.com/hashicorp/memberlist" + "github.com/prometheus/alertmanager/cluster/clusterpb" + "github.com/prometheus/client_golang/prometheus" +) + +// Channel allows clients to send messages for a specific state type that will be +// broadcasted in a best-effort manner. +type Channel struct { + key string + send func([]byte) + peers func() []*memberlist.Node + sendOversize func(*memberlist.Node, []byte) error + + msgc chan []byte + logger log.Logger + + oversizeGossipMessageFailureTotal prometheus.Counter + oversizeGossipMessageDroppedTotal prometheus.Counter + oversizeGossipMessageSentTotal prometheus.Counter + oversizeGossipDuration prometheus.Histogram +} + +// NewChannel creates a new Channel struct, which handles sending normal and +// oversize messages to peers. +func NewChannel( + key string, + send func([]byte), + peers func() []*memberlist.Node, + sendOversize func(*memberlist.Node, []byte) error, + logger log.Logger, + stopc chan struct{}, + reg prometheus.Registerer, +) *Channel { + oversizeGossipMessageFailureTotal := prometheus.NewCounter(prometheus.CounterOpts{ + Name: "alertmanager_oversized_gossip_message_failure_total", + Help: "Number of oversized gossip message sends that failed.", + ConstLabels: prometheus.Labels{"key": key}, + }) + oversizeGossipMessageSentTotal := prometheus.NewCounter(prometheus.CounterOpts{ + Name: "alertmanager_oversized_gossip_message_sent_total", + Help: "Number of oversized gossip message sent.", + ConstLabels: prometheus.Labels{"key": key}, + }) + oversizeGossipMessageDroppedTotal := prometheus.NewCounter(prometheus.CounterOpts{ + Name: "alertmanager_oversized_gossip_message_dropped_total", + Help: "Number of oversized gossip messages that were dropped due to a full message queue.", + ConstLabels: prometheus.Labels{"key": key}, + }) + oversizeGossipDuration := prometheus.NewHistogram(prometheus.HistogramOpts{ + Name: "alertmanager_oversize_gossip_message_duration_seconds", + Help: "Duration of oversized gossip message requests.", + ConstLabels: prometheus.Labels{"key": key}, + }) + + reg.MustRegister(oversizeGossipDuration, oversizeGossipMessageFailureTotal, oversizeGossipMessageDroppedTotal, oversizeGossipMessageSentTotal) + + c := &Channel{ + key: key, + send: send, + peers: peers, + logger: logger, + msgc: make(chan []byte, 200), + sendOversize: sendOversize, + oversizeGossipMessageFailureTotal: oversizeGossipMessageFailureTotal, + oversizeGossipMessageDroppedTotal: oversizeGossipMessageDroppedTotal, + oversizeGossipMessageSentTotal: oversizeGossipMessageSentTotal, + oversizeGossipDuration: oversizeGossipDuration, + } + + go c.handleOverSizedMessages(stopc) + + return c +} + +// handleOverSizedMessages prevents memberlist from opening too many parallel +// TCP connections to its peers. +func (c *Channel) handleOverSizedMessages(stopc chan struct{}) { + var wg sync.WaitGroup + for { + select { + case b := <-c.msgc: + for _, n := range c.peers() { + wg.Add(1) + go func(n *memberlist.Node) { + defer wg.Done() + c.oversizeGossipMessageSentTotal.Inc() + start := time.Now() + if err := c.sendOversize(n, b); err != nil { + level.Debug(c.logger).Log("msg", "failed to send reliable", "key", c.key, "node", n, "err", err) + c.oversizeGossipMessageFailureTotal.Inc() + return + } + c.oversizeGossipDuration.Observe(time.Since(start).Seconds()) + }(n) + } + + wg.Wait() + case <-stopc: + return + } + } +} + +// Broadcast enqueues a message for broadcasting. +func (c *Channel) Broadcast(b []byte) { + b, err := proto.Marshal(&clusterpb.Part{Key: c.key, Data: b}) + if err != nil { + return + } + + if OversizedMessage(b) { + select { + case c.msgc <- b: + default: + level.Debug(c.logger).Log("msg", "oversized gossip channel full") + c.oversizeGossipMessageDroppedTotal.Inc() + } + } else { + c.send(b) + } +} + +// OversizedMessage indicates whether or not the byte payload should be sent +// via TCP. +func OversizedMessage(b []byte) bool { + return len(b) > maxGossipPacketSize/2 +} diff --git a/src/alertmanager/cluster/channel_test.go b/src/alertmanager/cluster/channel_test.go new file mode 100644 index 0000000..1e68d26 --- /dev/null +++ b/src/alertmanager/cluster/channel_test.go @@ -0,0 +1,89 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cluster + +import ( + "bytes" + "context" + "io" + "os" + "testing" + + "github.com/go-kit/kit/log" + "github.com/hashicorp/memberlist" + "github.com/prometheus/client_golang/prometheus" +) + +func TestNormalMessagesGossiped(t *testing.T) { + var sent bool + c := newChannel( + func(_ []byte) { sent = true }, + func() []*memberlist.Node { return nil }, + func(_ *memberlist.Node, _ []byte) error { return nil }, + ) + + c.Broadcast([]byte{}) + + if sent != true { + t.Fatalf("small message not sent") + } +} + +func TestOversizedMessagesGossiped(t *testing.T) { + var sent bool + ctx, cancel := context.WithCancel(context.Background()) + c := newChannel( + func(_ []byte) {}, + func() []*memberlist.Node { return []*memberlist.Node{&memberlist.Node{}} }, + func(_ *memberlist.Node, _ []byte) error { sent = true; cancel(); return nil }, + ) + + f, err := os.Open("/dev/zero") + if err != nil { + t.Fatalf("failed to open /dev/zero: %v", err) + } + defer f.Close() + + buf := new(bytes.Buffer) + toCopy := int64(800) + if n, err := io.CopyN(buf, f, toCopy); err != nil { + t.Fatalf("failed to copy bytes: %v", err) + } else if n != toCopy { + t.Fatalf("wanted to copy %d bytes, only copied %d", toCopy, n) + } + + c.Broadcast(buf.Bytes()) + + <-ctx.Done() + + if sent != true { + t.Fatalf("oversized message not sent") + } +} + +func newChannel( + send func([]byte), + peers func() []*memberlist.Node, + sendOversize func(*memberlist.Node, []byte) error, +) *Channel { + return NewChannel( + "test", + send, + peers, + sendOversize, + log.NewNopLogger(), + make(chan struct{}), + prometheus.NewRegistry(), + ) +} diff --git a/src/alertmanager/cluster/cluster.go b/src/alertmanager/cluster/cluster.go new file mode 100644 index 0000000..fb2abe6 --- /dev/null +++ b/src/alertmanager/cluster/cluster.go @@ -0,0 +1,740 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cluster + +import ( + "context" + "fmt" + "math/rand" + "net" + "sort" + "strconv" + "strings" + "sync" + "time" + + "github.com/go-kit/kit/log" + "github.com/go-kit/kit/log/level" + "github.com/hashicorp/memberlist" + "github.com/oklog/ulid" + "github.com/pkg/errors" + + "github.com/prometheus/client_golang/prometheus" +) + +// Peer is a single peer in a gossip cluster. +type Peer struct { + mlist *memberlist.Memberlist + delegate *delegate + + mtx sync.RWMutex + states map[string]State + stopc chan struct{} + readyc chan struct{} + + peerLock sync.RWMutex + peers map[string]peer + failedPeers []peer + + failedReconnectionsCounter prometheus.Counter + reconnectionsCounter prometheus.Counter + peerLeaveCounter prometheus.Counter + peerUpdateCounter prometheus.Counter + peerJoinCounter prometheus.Counter + + logger log.Logger +} + +// peer is an internal type used for bookkeeping. It holds the state of peers +// in the cluster. +type peer struct { + status PeerStatus + leaveTime time.Time + + *memberlist.Node +} + +// PeerStatus is the state that a peer is in. +type PeerStatus int + +const ( + StatusNone PeerStatus = iota + StatusAlive + StatusFailed +) + +func (s PeerStatus) String() string { + switch s { + case StatusNone: + return "none" + case StatusAlive: + return "alive" + case StatusFailed: + return "failed" + default: + panic(fmt.Sprintf("unknown PeerStatus: %d", s)) + } +} + +const ( + DefaultPushPullInterval = 60 * time.Second + DefaultGossipInterval = 200 * time.Millisecond + DefaultTcpTimeout = 10 * time.Second + DefaultProbeTimeout = 500 * time.Millisecond + DefaultProbeInterval = 1 * time.Second + DefaultReconnectInterval = 10 * time.Second + DefaultReconnectTimeout = 6 * time.Hour + maxGossipPacketSize = 1400 +) + +func Join( + l log.Logger, + reg prometheus.Registerer, + bindAddr string, + advertiseAddr string, + knownPeers []string, + waitIfEmpty bool, + pushPullInterval time.Duration, + gossipInterval time.Duration, + tcpTimeout time.Duration, + probeTimeout time.Duration, + probeInterval time.Duration, + reconnectInterval time.Duration, + reconnectTimeout time.Duration, +) (*Peer, error) { + bindHost, bindPortStr, err := net.SplitHostPort(bindAddr) + if err != nil { + return nil, err + } + bindPort, err := strconv.Atoi(bindPortStr) + if err != nil { + return nil, errors.Wrap(err, "invalid listen address") + } + + var advertiseHost string + var advertisePort int + if advertiseAddr != "" { + var advertisePortStr string + advertiseHost, advertisePortStr, err = net.SplitHostPort(advertiseAddr) + if err != nil { + return nil, errors.Wrap(err, "invalid advertise address") + } + advertisePort, err = strconv.Atoi(advertisePortStr) + if err != nil { + return nil, errors.Wrap(err, "invalid advertise address, wrong port") + } + } + + resolvedPeers, err := resolvePeers(context.Background(), knownPeers, advertiseAddr, net.Resolver{}, waitIfEmpty) + if err != nil { + return nil, errors.Wrap(err, "resolve peers") + } + level.Debug(l).Log("msg", "resolved peers to following addresses", "peers", strings.Join(resolvedPeers, ",")) + + // Initial validation of user-specified advertise address. + addr, err := calculateAdvertiseAddress(bindHost, advertiseHost) + if err != nil { + level.Warn(l).Log("err", "couldn't deduce an advertise address: "+err.Error()) + } else if hasNonlocal(resolvedPeers) && isUnroutable(addr.String()) { + level.Warn(l).Log("err", "this node advertises itself on an unroutable address", "addr", addr.String()) + level.Warn(l).Log("err", "this node will be unreachable in the cluster") + level.Warn(l).Log("err", "provide --cluster.advertise-address as a routable IP address or hostname") + } else if isAny(bindAddr) && advertiseHost == "" { + // memberlist doesn't advertise properly when the bind address is empty or unspecified. + level.Info(l).Log("msg", "setting advertise address explicitly", "addr", addr.String(), "port", bindPort) + advertiseHost = addr.String() + advertisePort = bindPort + } + + // TODO(fabxc): generate human-readable but random names? + name, err := ulid.New(ulid.Now(), rand.New(rand.NewSource(time.Now().UnixNano()))) + if err != nil { + return nil, err + } + + p := &Peer{ + states: map[string]State{}, + stopc: make(chan struct{}), + readyc: make(chan struct{}), + logger: l, + peers: map[string]peer{}, + } + + p.register(reg) + + retransmit := len(knownPeers) / 2 + if retransmit < 3 { + retransmit = 3 + } + p.delegate = newDelegate(l, reg, p, retransmit) + + cfg := memberlist.DefaultLANConfig() + cfg.Name = name.String() + cfg.BindAddr = bindHost + cfg.BindPort = bindPort + cfg.Delegate = p.delegate + cfg.Events = p.delegate + cfg.GossipInterval = gossipInterval + cfg.PushPullInterval = pushPullInterval + cfg.TCPTimeout = tcpTimeout + cfg.ProbeTimeout = probeTimeout + cfg.ProbeInterval = probeInterval + cfg.LogOutput = &logWriter{l: l} + cfg.GossipNodes = retransmit + cfg.UDPBufferSize = maxGossipPacketSize + + if advertiseHost != "" { + cfg.AdvertiseAddr = advertiseHost + cfg.AdvertisePort = advertisePort + p.setInitialFailed(resolvedPeers, fmt.Sprintf("%s:%d", advertiseHost, advertisePort)) + } else { + p.setInitialFailed(resolvedPeers, bindAddr) + } + + ml, err := memberlist.Create(cfg) + if err != nil { + return nil, errors.Wrap(err, "create memberlist") + } + p.mlist = ml + + n, err := ml.Join(resolvedPeers) + if err != nil { + level.Warn(l).Log("msg", "failed to join cluster", "err", err) + } else { + level.Debug(l).Log("msg", "joined cluster", "peers", n) + } + + if reconnectInterval != 0 { + go p.handleReconnect(reconnectInterval) + } + if reconnectTimeout != 0 { + go p.handleReconnectTimeout(5*time.Minute, reconnectTimeout) + } + + return p, nil +} + +// All peers are initially added to the failed list. They will be removed from +// this list in peerJoin when making their initial connection. +func (p *Peer) setInitialFailed(peers []string, myAddr string) { + if len(peers) == 0 { + return + } + + p.peerLock.RLock() + defer p.peerLock.RUnlock() + + now := time.Now() + for _, peerAddr := range peers { + if peerAddr == myAddr { + // Don't add ourselves to the initially failing list, + // we don't connect to ourselves. + continue + } + host, port, err := net.SplitHostPort(peerAddr) + if err != nil { + continue + } + ip := net.ParseIP(host) + if ip == nil { + // Don't add textual addresses since memberlist only advertises + // dotted decimal or IPv6 addresses. + continue + } + portUint, err := strconv.ParseUint(port, 10, 16) + if err != nil { + continue + } + + pr := peer{ + status: StatusFailed, + leaveTime: now, + Node: &memberlist.Node{ + Addr: ip, + Port: uint16(portUint), + }, + } + p.failedPeers = append(p.failedPeers, pr) + p.peers[peerAddr] = pr + } +} + +type logWriter struct { + l log.Logger +} + +func (l *logWriter) Write(b []byte) (int, error) { + return len(b), level.Debug(l.l).Log("memberlist", string(b)) +} + +func (p *Peer) register(reg prometheus.Registerer) { + clusterFailedPeers := prometheus.NewGaugeFunc(prometheus.GaugeOpts{ + Name: "alertmanager_cluster_failed_peers", + Help: "Number indicating the current number of failed peers in the cluster.", + }, func() float64 { + p.peerLock.RLock() + defer p.peerLock.RUnlock() + + return float64(len(p.failedPeers)) + }) + p.failedReconnectionsCounter = prometheus.NewCounter(prometheus.CounterOpts{ + Name: "alertmanager_cluster_reconnections_failed_total", + Help: "A counter of the number of failed cluster peer reconnection attempts.", + }) + + p.reconnectionsCounter = prometheus.NewCounter(prometheus.CounterOpts{ + Name: "alertmanager_cluster_reconnections_total", + Help: "A counter of the number of cluster peer reconnections.", + }) + + p.peerLeaveCounter = prometheus.NewCounter(prometheus.CounterOpts{ + Name: "alertmanager_cluster_peers_left_total", + Help: "A counter of the number of peers that have left.", + }) + p.peerUpdateCounter = prometheus.NewCounter(prometheus.CounterOpts{ + Name: "alertmanager_cluster_peers_update_total", + Help: "A counter of the number of peers that have updated metadata.", + }) + p.peerJoinCounter = prometheus.NewCounter(prometheus.CounterOpts{ + Name: "alertmanager_cluster_peers_joined_total", + Help: "A counter of the number of peers that have joined.", + }) + + reg.MustRegister(clusterFailedPeers, p.failedReconnectionsCounter, p.reconnectionsCounter, + p.peerLeaveCounter, p.peerUpdateCounter, p.peerJoinCounter) +} + +func (p *Peer) handleReconnectTimeout(d time.Duration, timeout time.Duration) { + tick := time.NewTicker(d) + defer tick.Stop() + + for { + select { + case <-p.stopc: + return + case <-tick.C: + p.removeFailedPeers(timeout) + } + } +} + +func (p *Peer) removeFailedPeers(timeout time.Duration) { + p.peerLock.Lock() + defer p.peerLock.Unlock() + + now := time.Now() + + keep := make([]peer, 0, len(p.failedPeers)) + for _, pr := range p.failedPeers { + if pr.leaveTime.Add(timeout).After(now) { + keep = append(keep, pr) + } else { + level.Debug(p.logger).Log("msg", "failed peer has timed out", "peer", pr.Node, "addr", pr.Address()) + delete(p.peers, pr.Name) + } + } + + p.failedPeers = keep +} + +func (p *Peer) handleReconnect(d time.Duration) { + tick := time.NewTicker(d) + defer tick.Stop() + + for { + select { + case <-p.stopc: + return + case <-tick.C: + p.reconnect() + } + } +} + +func (p *Peer) reconnect() { + p.peerLock.RLock() + failedPeers := p.failedPeers + p.peerLock.RUnlock() + + logger := log.With(p.logger, "msg", "reconnect") + for _, pr := range failedPeers { + // No need to do book keeping on failedPeers here. If a + // reconnect is successful, they will be announced in + // peerJoin(). + if _, err := p.mlist.Join([]string{pr.Address()}); err != nil { + p.failedReconnectionsCounter.Inc() + level.Debug(logger).Log("result", "failure", "peer", pr.Node, "addr", pr.Address()) + } else { + p.reconnectionsCounter.Inc() + level.Debug(logger).Log("result", "success", "peer", pr.Node, "addr", pr.Address()) + } + } +} + +func (p *Peer) peerJoin(n *memberlist.Node) { + p.peerLock.Lock() + defer p.peerLock.Unlock() + + var oldStatus PeerStatus + pr, ok := p.peers[n.Address()] + if !ok { + oldStatus = StatusNone + pr = peer{ + status: StatusAlive, + Node: n, + } + } else { + oldStatus = pr.status + pr.Node = n + pr.status = StatusAlive + pr.leaveTime = time.Time{} + } + + p.peers[n.Address()] = pr + p.peerJoinCounter.Inc() + + if oldStatus == StatusFailed { + level.Debug(p.logger).Log("msg", "peer rejoined", "peer", pr.Node) + p.failedPeers = removeOldPeer(p.failedPeers, pr.Address()) + } +} + +func (p *Peer) peerLeave(n *memberlist.Node) { + p.peerLock.Lock() + defer p.peerLock.Unlock() + + pr, ok := p.peers[n.Address()] + if !ok { + // Why are we receiving a leave notification from a node that + // never joined? + return + } + + pr.status = StatusFailed + pr.leaveTime = time.Now() + p.failedPeers = append(p.failedPeers, pr) + p.peers[n.Address()] = pr + + p.peerLeaveCounter.Inc() + level.Debug(p.logger).Log("msg", "peer left", "peer", pr.Node) +} + +func (p *Peer) peerUpdate(n *memberlist.Node) { + p.peerLock.Lock() + defer p.peerLock.Unlock() + + pr, ok := p.peers[n.Address()] + if !ok { + // Why are we receiving an update from a node that never + // joined? + return + } + + pr.Node = n + p.peers[n.Address()] = pr + + p.peerUpdateCounter.Inc() + level.Debug(p.logger).Log("msg", "peer updated", "peer", pr.Node) +} + +// AddState adds a new state that will be gossiped. It returns a channel to which +// broadcast messages for the state can be sent. +func (p *Peer) AddState(key string, s State, reg prometheus.Registerer) *Channel { + p.states[key] = s + send := func(b []byte) { + p.delegate.bcast.QueueBroadcast(simpleBroadcast(b)) + } + peers := func() []*memberlist.Node { + nodes := p.Peers() + for i, n := range nodes { + if n.Name == p.Self().Name { + nodes = append(nodes[:i], nodes[i+1:]...) + break + } + } + return nodes + } + sendOversize := func(n *memberlist.Node, b []byte) error { + return p.mlist.SendReliable(n, b) + } + return NewChannel(key, send, peers, sendOversize, p.logger, p.stopc, reg) +} + +// Leave the cluster, waiting up to timeout. +func (p *Peer) Leave(timeout time.Duration) error { + close(p.stopc) + level.Debug(p.logger).Log("msg", "leaving cluster") + return p.mlist.Leave(timeout) +} + +// Name returns the unique ID of this peer in the cluster. +func (p *Peer) Name() string { + return p.mlist.LocalNode().Name +} + +// ClusterSize returns the current number of alive members in the cluster. +func (p *Peer) ClusterSize() int { + return p.mlist.NumMembers() +} + +// Return true when router has settled. +func (p *Peer) Ready() bool { + select { + case <-p.readyc: + return true + default: + } + return false +} + +// Wait until Settle() has finished. +func (p *Peer) WaitReady() { + <-p.readyc +} + +// Return a status string representing the peer state. +func (p *Peer) Status() string { + if p.Ready() { + return "ready" + } else { + return "settling" + } +} + +// Info returns a JSON-serializable dump of cluster state. +// Useful for debug. +func (p *Peer) Info() map[string]interface{} { + p.mtx.RLock() + defer p.mtx.RUnlock() + + return map[string]interface{}{ + "self": p.mlist.LocalNode(), + "members": p.mlist.Members(), + } +} + +// Self returns the node information about the peer itself. +func (p *Peer) Self() *memberlist.Node { + return p.mlist.LocalNode() +} + +// Peers returns the peers in the cluster. +func (p *Peer) Peers() []*memberlist.Node { + return p.mlist.Members() +} + +// Position returns the position of the peer in the cluster. +func (p *Peer) Position() int { + all := p.Peers() + sort.Slice(all, func(i, j int) bool { + return all[i].Name < all[j].Name + }) + + k := 0 + for _, n := range all { + if n.Name == p.Self().Name { + break + } + k++ + } + return k +} + +// Settle waits until the mesh is ready (and sets the appropriate internal state when it is). +// The idea is that we don't want to start "working" before we get a chance to know most of the alerts and/or silences. +// Inspired from https://github.com/apache/cassandra/blob/7a40abb6a5108688fb1b10c375bb751cbb782ea4/src/java/org/apache/cassandra/gms/Gossiper.java +// This is clearly not perfect or strictly correct but should prevent the alertmanager to send notification before it is obviously not ready. +// This is especially important for those that do not have persistent storage. +func (p *Peer) Settle(ctx context.Context, interval time.Duration) { + const NumOkayRequired = 3 + level.Info(p.logger).Log("msg", "Waiting for gossip to settle...", "interval", interval) + start := time.Now() + nPeers := 0 + nOkay := 0 + totalPolls := 0 + for { + select { + case <-ctx.Done(): + elapsed := time.Since(start) + level.Info(p.logger).Log("msg", "gossip not settled but continuing anyway", "polls", totalPolls, "elapsed", elapsed) + close(p.readyc) + return + case <-time.After(interval): + } + elapsed := time.Since(start) + n := len(p.Peers()) + if nOkay >= NumOkayRequired { + level.Info(p.logger).Log("msg", "gossip settled; proceeding", "elapsed", elapsed) + break + } + if n == nPeers { + nOkay++ + level.Debug(p.logger).Log("msg", "gossip looks settled", "elapsed", elapsed) + } else { + nOkay = 0 + level.Info(p.logger).Log("msg", "gossip not settled", "polls", totalPolls, "before", nPeers, "now", n, "elapsed", elapsed) + } + nPeers = n + totalPolls++ + } + close(p.readyc) +} + +// State is a piece of state that can be serialized and merged with other +// serialized state. +type State interface { + // MarshalBinary serializes the underlying state. + MarshalBinary() ([]byte, error) + + // Merge merges serialized state into the underlying state. + Merge(b []byte) error +} + +// We use a simple broadcast implementation in which items are never invalidated by others. +type simpleBroadcast []byte + +func (b simpleBroadcast) Message() []byte { return []byte(b) } +func (b simpleBroadcast) Invalidates(memberlist.Broadcast) bool { return false } +func (b simpleBroadcast) Finished() {} + +func resolvePeers(ctx context.Context, peers []string, myAddress string, res net.Resolver, waitIfEmpty bool) ([]string, error) { + var resolvedPeers []string + + for _, peer := range peers { + host, port, err := net.SplitHostPort(peer) + if err != nil { + return nil, errors.Wrapf(err, "split host/port for peer %s", peer) + } + + retryCtx, cancel := context.WithCancel(ctx) + + ips, err := res.LookupIPAddr(ctx, host) + if err != nil { + // Assume direct address. + resolvedPeers = append(resolvedPeers, peer) + continue + } + + if len(ips) == 0 { + var lookupErrSpotted bool + + err := retry(2*time.Second, retryCtx.Done(), func() error { + if lookupErrSpotted { + // We need to invoke cancel in next run of retry when lookupErrSpotted to preserve LookupIPAddr error. + cancel() + } + + ips, err = res.LookupIPAddr(retryCtx, host) + if err != nil { + lookupErrSpotted = true + return errors.Wrapf(err, "IP Addr lookup for peer %s", peer) + } + + ips = removeMyAddr(ips, port, myAddress) + if len(ips) == 0 { + if !waitIfEmpty { + return nil + } + return errors.New("empty IPAddr result. Retrying") + } + + return nil + }) + if err != nil { + return nil, err + } + } + + for _, ip := range ips { + resolvedPeers = append(resolvedPeers, net.JoinHostPort(ip.String(), port)) + } + } + + return resolvedPeers, nil +} + +func removeMyAddr(ips []net.IPAddr, targetPort string, myAddr string) []net.IPAddr { + var result []net.IPAddr + + for _, ip := range ips { + if net.JoinHostPort(ip.String(), targetPort) == myAddr { + continue + } + result = append(result, ip) + } + + return result +} + +func hasNonlocal(clusterPeers []string) bool { + for _, peer := range clusterPeers { + if host, _, err := net.SplitHostPort(peer); err == nil { + peer = host + } + if ip := net.ParseIP(peer); ip != nil && !ip.IsLoopback() { + return true + } else if ip == nil && strings.ToLower(peer) != "localhost" { + return true + } + } + return false +} + +func isUnroutable(addr string) bool { + if host, _, err := net.SplitHostPort(addr); err == nil { + addr = host + } + if ip := net.ParseIP(addr); ip != nil && (ip.IsUnspecified() || ip.IsLoopback()) { + return true // typically 0.0.0.0 or localhost + } else if ip == nil && strings.ToLower(addr) == "localhost" { + return true + } + return false +} + +func isAny(addr string) bool { + if host, _, err := net.SplitHostPort(addr); err == nil { + addr = host + } + return addr == "" || net.ParseIP(addr).IsUnspecified() +} + +// retry executes f every interval seconds until timeout or no error is returned from f. +func retry(interval time.Duration, stopc <-chan struct{}, f func() error) error { + tick := time.NewTicker(interval) + defer tick.Stop() + + var err error + for { + if err = f(); err == nil { + return nil + } + select { + case <-stopc: + return err + case <-tick.C: + } + } +} + +func removeOldPeer(old []peer, addr string) []peer { + new := make([]peer, 0, len(old)) + for _, p := range old { + if p.Address() != addr { + new = append(new, p) + } + } + + return new +} diff --git a/src/alertmanager/cluster/cluster_test.go b/src/alertmanager/cluster/cluster_test.go new file mode 100644 index 0000000..8333ac0 --- /dev/null +++ b/src/alertmanager/cluster/cluster_test.go @@ -0,0 +1,219 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cluster + +import ( + "context" + "testing" + "time" + + "github.com/go-kit/kit/log" + "github.com/stretchr/testify/require" + + "github.com/prometheus/client_golang/prometheus" +) + +func TestJoinLeave(t *testing.T) { + logger := log.NewNopLogger() + p, err := Join( + logger, + prometheus.NewRegistry(), + "0.0.0.0:0", + "", + []string{}, + true, + DefaultPushPullInterval, + DefaultGossipInterval, + DefaultTcpTimeout, + DefaultProbeTimeout, + DefaultProbeInterval, + DefaultReconnectInterval, + DefaultReconnectTimeout, + ) + require.NoError(t, err) + require.NotNil(t, p) + require.False(t, p.Ready()) + require.Equal(t, p.Status(), "settling") + go p.Settle(context.Background(), 0*time.Second) + p.WaitReady() + require.Equal(t, p.Status(), "ready") + + // Create the peer who joins the first. + p2, err := Join( + logger, + prometheus.NewRegistry(), + "0.0.0.0:0", + "", + []string{p.Self().Address()}, + true, + DefaultPushPullInterval, + DefaultGossipInterval, + DefaultTcpTimeout, + DefaultProbeTimeout, + DefaultProbeInterval, + DefaultReconnectInterval, + DefaultReconnectTimeout, + ) + require.NoError(t, err) + require.NotNil(t, p2) + go p2.Settle(context.Background(), 0*time.Second) + + require.Equal(t, 2, p.ClusterSize()) + p2.Leave(0 * time.Second) + require.Equal(t, 1, p.ClusterSize()) + require.Equal(t, 1, len(p.failedPeers)) + require.Equal(t, p2.Self().Address(), p.peers[p2.Self().Address()].Node.Address()) + require.Equal(t, p2.Name(), p.failedPeers[0].Name) +} + +func TestReconnect(t *testing.T) { + logger := log.NewNopLogger() + p, err := Join( + logger, + prometheus.NewRegistry(), + "0.0.0.0:0", + "", + []string{}, + true, + DefaultPushPullInterval, + DefaultGossipInterval, + DefaultTcpTimeout, + DefaultProbeTimeout, + DefaultProbeInterval, + DefaultReconnectInterval, + DefaultReconnectTimeout, + ) + require.NoError(t, err) + require.NotNil(t, p) + go p.Settle(context.Background(), 0*time.Second) + p.WaitReady() + + p2, err := Join( + logger, + prometheus.NewRegistry(), + "0.0.0.0:0", + "", + []string{}, + true, + DefaultPushPullInterval, + DefaultGossipInterval, + DefaultTcpTimeout, + DefaultProbeTimeout, + DefaultProbeInterval, + DefaultReconnectInterval, + DefaultReconnectTimeout, + ) + require.NoError(t, err) + require.NotNil(t, p2) + go p2.Settle(context.Background(), 0*time.Second) + p2.WaitReady() + + p.peerJoin(p2.Self()) + p.peerLeave(p2.Self()) + + require.Equal(t, 1, p.ClusterSize()) + require.Equal(t, 1, len(p.failedPeers)) + + p.reconnect() + + require.Equal(t, 2, p.ClusterSize()) + require.Equal(t, 0, len(p.failedPeers)) + require.Equal(t, StatusAlive, p.peers[p2.Self().Address()].status) +} + +func TestRemoveFailedPeers(t *testing.T) { + logger := log.NewNopLogger() + p, err := Join( + logger, + prometheus.NewRegistry(), + "0.0.0.0:0", + "", + []string{}, + true, + DefaultPushPullInterval, + DefaultGossipInterval, + DefaultTcpTimeout, + DefaultProbeTimeout, + DefaultProbeInterval, + DefaultReconnectInterval, + DefaultReconnectTimeout, + ) + require.NoError(t, err) + require.NotNil(t, p) + n := p.Self() + + now := time.Now() + p1 := peer{ + status: StatusFailed, + leaveTime: now, + Node: n, + } + p2 := peer{ + status: StatusFailed, + leaveTime: now.Add(-time.Hour), + Node: n, + } + p3 := peer{ + status: StatusFailed, + leaveTime: now.Add(30 * -time.Minute), + Node: n, + } + p.failedPeers = []peer{p1, p2, p3} + + p.removeFailedPeers(30 * time.Minute) + require.Equal(t, 1, len(p.failedPeers)) + require.Equal(t, p1, p.failedPeers[0]) +} + +func TestInitiallyFailingPeers(t *testing.T) { + logger := log.NewNopLogger() + myAddr := "1.2.3.4:5000" + peerAddrs := []string{myAddr, "2.3.4.5:5000", "3.4.5.6:5000", "foo.example.com:5000"} + p, err := Join( + logger, + prometheus.NewRegistry(), + "0.0.0.0:0", + "", + []string{}, + true, + DefaultPushPullInterval, + DefaultGossipInterval, + DefaultTcpTimeout, + DefaultProbeTimeout, + DefaultProbeInterval, + DefaultReconnectInterval, + DefaultReconnectTimeout, + ) + require.NoError(t, err) + require.NotNil(t, p) + + p.setInitialFailed(peerAddrs, myAddr) + + // We shouldn't have added "our" bind addr and the FQDN address to the + // failed peers list. + require.Equal(t, len(peerAddrs)-2, len(p.failedPeers)) + for _, addr := range peerAddrs { + if addr == myAddr || addr == "foo.example.com:5000" { + continue + } + + pr, ok := p.peers[addr] + require.True(t, ok) + require.Equal(t, StatusFailed.String(), pr.status.String()) + require.Equal(t, addr, pr.Address()) + expectedLen := len(p.failedPeers) - 1 + p.peerJoin(pr.Node) + require.Equal(t, expectedLen, len(p.failedPeers)) + } +} diff --git a/src/alertmanager/cluster/clusterpb/cluster.pb.go b/src/alertmanager/cluster/clusterpb/cluster.pb.go new file mode 100644 index 0000000..34ae90b --- /dev/null +++ b/src/alertmanager/cluster/clusterpb/cluster.pb.go @@ -0,0 +1,476 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: cluster.proto + +/* + Package clusterpb is a generated protocol buffer package. + + It is generated from these files: + cluster.proto + + It has these top-level messages: + Part + FullState +*/ +package clusterpb + +import proto "github.com/gogo/protobuf/proto" +import fmt "fmt" +import math "math" +import _ "github.com/gogo/protobuf/gogoproto" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package + +type Part struct { + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` +} + +func (m *Part) Reset() { *m = Part{} } +func (m *Part) String() string { return proto.CompactTextString(m) } +func (*Part) ProtoMessage() {} +func (*Part) Descriptor() ([]byte, []int) { return fileDescriptorCluster, []int{0} } + +type FullState struct { + Parts []Part `protobuf:"bytes,1,rep,name=parts" json:"parts"` +} + +func (m *FullState) Reset() { *m = FullState{} } +func (m *FullState) String() string { return proto.CompactTextString(m) } +func (*FullState) ProtoMessage() {} +func (*FullState) Descriptor() ([]byte, []int) { return fileDescriptorCluster, []int{1} } + +func init() { + proto.RegisterType((*Part)(nil), "clusterpb.Part") + proto.RegisterType((*FullState)(nil), "clusterpb.FullState") +} +func (m *Part) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Part) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Key) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintCluster(dAtA, i, uint64(len(m.Key))) + i += copy(dAtA[i:], m.Key) + } + if len(m.Data) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintCluster(dAtA, i, uint64(len(m.Data))) + i += copy(dAtA[i:], m.Data) + } + return i, nil +} + +func (m *FullState) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *FullState) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Parts) > 0 { + for _, msg := range m.Parts { + dAtA[i] = 0xa + i++ + i = encodeVarintCluster(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + return i, nil +} + +func encodeVarintCluster(dAtA []byte, offset int, v uint64) int { + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return offset + 1 +} +func (m *Part) Size() (n int) { + var l int + _ = l + l = len(m.Key) + if l > 0 { + n += 1 + l + sovCluster(uint64(l)) + } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovCluster(uint64(l)) + } + return n +} + +func (m *FullState) Size() (n int) { + var l int + _ = l + if len(m.Parts) > 0 { + for _, e := range m.Parts { + l = e.Size() + n += 1 + l + sovCluster(uint64(l)) + } + } + return n +} + +func sovCluster(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozCluster(x uint64) (n int) { + return sovCluster(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Part) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCluster + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Part: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Part: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCluster + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthCluster + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCluster + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthCluster + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCluster(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthCluster + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FullState) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCluster + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: FullState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FullState: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Parts", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCluster + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCluster + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Parts = append(m.Parts, Part{}) + if err := m.Parts[len(m.Parts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCluster(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthCluster + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipCluster(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCluster + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCluster + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCluster + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthCluster + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCluster + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipCluster(dAtA[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthCluster = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowCluster = fmt.Errorf("proto: integer overflow") +) + +func init() { proto.RegisterFile("cluster.proto", fileDescriptorCluster) } + +var fileDescriptorCluster = []byte{ + // 168 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x4d, 0xce, 0x29, 0x2d, + 0x2e, 0x49, 0x2d, 0xd2, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x84, 0x72, 0x0b, 0x92, 0xa4, + 0x44, 0xd2, 0xf3, 0xd3, 0xf3, 0xc1, 0xa2, 0xfa, 0x20, 0x16, 0x44, 0x81, 0x92, 0x0e, 0x17, 0x4b, + 0x40, 0x62, 0x51, 0x89, 0x90, 0x00, 0x17, 0x73, 0x76, 0x6a, 0xa5, 0x04, 0xa3, 0x02, 0xa3, 0x06, + 0x67, 0x10, 0x88, 0x29, 0x24, 0xc4, 0xc5, 0x92, 0x92, 0x58, 0x92, 0x28, 0xc1, 0xa4, 0xc0, 0xa8, + 0xc1, 0x13, 0x04, 0x66, 0x2b, 0x59, 0x70, 0x71, 0xba, 0x95, 0xe6, 0xe4, 0x04, 0x97, 0x24, 0x96, + 0xa4, 0x0a, 0x69, 0x73, 0xb1, 0x16, 0x24, 0x16, 0x95, 0x14, 0x4b, 0x30, 0x2a, 0x30, 0x6b, 0x70, + 0x1b, 0xf1, 0xeb, 0xc1, 0xed, 0xd2, 0x03, 0x19, 0xe9, 0xc4, 0x72, 0xe2, 0x9e, 0x3c, 0x43, 0x10, + 0x44, 0x8d, 0x93, 0xc0, 0x89, 0x87, 0x72, 0x0c, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, + 0xf8, 0xe0, 0x91, 0x1c, 0x63, 0x12, 0x1b, 0xd8, 0x01, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xfd, 0x3c, 0xdb, 0xe7, 0xb2, 0x00, 0x00, 0x00, +} diff --git a/src/alertmanager/cluster/clusterpb/cluster.proto b/src/alertmanager/cluster/clusterpb/cluster.proto new file mode 100644 index 0000000..5387a6f --- /dev/null +++ b/src/alertmanager/cluster/clusterpb/cluster.proto @@ -0,0 +1,18 @@ +syntax = "proto3"; + +package clusterpb; +import "gogoproto/gogo.proto"; + +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.goproto_getters_all) = false; + +message Part { + string key = 1; + bytes data = 2; +} + +message FullState { + repeated Part parts = 1 [(gogoproto.nullable) = false]; +} diff --git a/src/alertmanager/cluster/delegate.go b/src/alertmanager/cluster/delegate.go new file mode 100644 index 0000000..6ac050e --- /dev/null +++ b/src/alertmanager/cluster/delegate.go @@ -0,0 +1,239 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cluster + +import ( + "time" + + "github.com/go-kit/kit/log" + "github.com/go-kit/kit/log/level" + "github.com/gogo/protobuf/proto" + "github.com/hashicorp/memberlist" + "github.com/prometheus/alertmanager/cluster/clusterpb" + "github.com/prometheus/client_golang/prometheus" +) + +// Maximum number of messages to be held in the queue. +const maxQueueSize = 4096 + +// delegate implements memberlist.Delegate and memberlist.EventDelegate +// and broadcasts its peer's state in the cluster. +type delegate struct { + *Peer + + logger log.Logger + bcast *memberlist.TransmitLimitedQueue + + messagesReceived *prometheus.CounterVec + messagesReceivedSize *prometheus.CounterVec + messagesSent *prometheus.CounterVec + messagesSentSize *prometheus.CounterVec + messagesPruned prometheus.Counter +} + +func newDelegate(l log.Logger, reg prometheus.Registerer, p *Peer, retransmit int) *delegate { + bcast := &memberlist.TransmitLimitedQueue{ + NumNodes: p.ClusterSize, + RetransmitMult: retransmit, + } + messagesReceived := prometheus.NewCounterVec(prometheus.CounterOpts{ + Name: "alertmanager_cluster_messages_received_total", + Help: "Total number of cluster messsages received.", + }, []string{"msg_type"}) + messagesReceivedSize := prometheus.NewCounterVec(prometheus.CounterOpts{ + Name: "alertmanager_cluster_messages_received_size_total", + Help: "Total size of cluster messages received.", + }, []string{"msg_type"}) + messagesSent := prometheus.NewCounterVec(prometheus.CounterOpts{ + Name: "alertmanager_cluster_messages_sent_total", + Help: "Total number of cluster messsages sent.", + }, []string{"msg_type"}) + messagesSentSize := prometheus.NewCounterVec(prometheus.CounterOpts{ + Name: "alertmanager_cluster_messages_sent_size_total", + Help: "Total size of cluster messages sent.", + }, []string{"msg_type"}) + messagesPruned := prometheus.NewCounter(prometheus.CounterOpts{ + Name: "alertmanager_cluster_messages_pruned_total", + Help: "Total number of cluster messsages pruned.", + }) + gossipClusterMembers := prometheus.NewGaugeFunc(prometheus.GaugeOpts{ + Name: "alertmanager_cluster_members", + Help: "Number indicating current number of members in cluster.", + }, func() float64 { + return float64(p.ClusterSize()) + }) + peerPosition := prometheus.NewGaugeFunc(prometheus.GaugeOpts{ + Name: "alertmanager_peer_position", + Help: "Position the Alertmanager instance believes it's in. The position determines a peer's behavior in the cluster.", + }, func() float64 { + return float64(p.Position()) + }) + healthScore := prometheus.NewGaugeFunc(prometheus.GaugeOpts{ + Name: "alertmanager_cluster_health_score", + Help: "Health score of the cluster. Lower values are better and zero means 'totally healthy'.", + }, func() float64 { + return float64(p.mlist.GetHealthScore()) + }) + messagesQueued := prometheus.NewGaugeFunc(prometheus.GaugeOpts{ + Name: "alertmanager_cluster_messages_queued", + Help: "Number of cluster messsages which are queued.", + }, func() float64 { + return float64(bcast.NumQueued()) + }) + + messagesReceived.WithLabelValues("full_state") + messagesReceivedSize.WithLabelValues("full_state") + messagesReceived.WithLabelValues("update") + messagesReceivedSize.WithLabelValues("update") + messagesSent.WithLabelValues("full_state") + messagesSentSize.WithLabelValues("full_state") + messagesSent.WithLabelValues("update") + messagesSentSize.WithLabelValues("update") + + reg.MustRegister(messagesReceived, messagesReceivedSize, messagesSent, messagesSentSize, + gossipClusterMembers, peerPosition, healthScore, messagesQueued, messagesPruned) + + d := &delegate{ + logger: l, + Peer: p, + bcast: bcast, + messagesReceived: messagesReceived, + messagesReceivedSize: messagesReceivedSize, + messagesSent: messagesSent, + messagesSentSize: messagesSentSize, + messagesPruned: messagesPruned, + } + + go d.handleQueueDepth() + + return d +} + +// NodeMeta retrieves meta-data about the current node when broadcasting an alive message. +func (d *delegate) NodeMeta(limit int) []byte { + return []byte{} +} + +// NotifyMsg is the callback invoked when a user-level gossip message is received. +func (d *delegate) NotifyMsg(b []byte) { + d.messagesReceived.WithLabelValues("update").Inc() + d.messagesReceivedSize.WithLabelValues("update").Add(float64(len(b))) + + var p clusterpb.Part + if err := proto.Unmarshal(b, &p); err != nil { + level.Warn(d.logger).Log("msg", "decode broadcast", "err", err) + return + } + s, ok := d.states[p.Key] + if !ok { + return + } + if err := s.Merge(p.Data); err != nil { + level.Warn(d.logger).Log("msg", "merge broadcast", "err", err, "key", p.Key) + return + } +} + +// GetBroadcasts is called when user data messages can be broadcasted. +func (d *delegate) GetBroadcasts(overhead, limit int) [][]byte { + msgs := d.bcast.GetBroadcasts(overhead, limit) + d.messagesSent.WithLabelValues("update").Add(float64(len(msgs))) + for _, m := range msgs { + d.messagesSentSize.WithLabelValues("update").Add(float64(len(m))) + } + return msgs +} + +// LocalState is called when gossip fetches local state. +func (d *delegate) LocalState(_ bool) []byte { + all := &clusterpb.FullState{ + Parts: make([]clusterpb.Part, 0, len(d.states)), + } + for key, s := range d.states { + b, err := s.MarshalBinary() + if err != nil { + level.Warn(d.logger).Log("msg", "encode local state", "err", err, "key", key) + return nil + } + all.Parts = append(all.Parts, clusterpb.Part{Key: key, Data: b}) + } + b, err := proto.Marshal(all) + if err != nil { + level.Warn(d.logger).Log("msg", "encode local state", "err", err) + return nil + } + d.messagesSent.WithLabelValues("full_state").Inc() + d.messagesSentSize.WithLabelValues("full_state").Add(float64(len(b))) + return b +} + +func (d *delegate) MergeRemoteState(buf []byte, _ bool) { + d.messagesReceived.WithLabelValues("full_state").Inc() + d.messagesReceivedSize.WithLabelValues("full_state").Add(float64(len(buf))) + + var fs clusterpb.FullState + if err := proto.Unmarshal(buf, &fs); err != nil { + level.Warn(d.logger).Log("msg", "merge remote state", "err", err) + return + } + d.mtx.RLock() + defer d.mtx.RUnlock() + + for _, p := range fs.Parts { + s, ok := d.states[p.Key] + if !ok { + continue + } + if err := s.Merge(p.Data); err != nil { + level.Warn(d.logger).Log("msg", "merge remote state", "err", err, "key", p.Key) + return + } + } +} + +// NotifyJoin is called if a peer joins the cluster. +func (d *delegate) NotifyJoin(n *memberlist.Node) { + level.Debug(d.logger).Log("received", "NotifyJoin", "node", n.Name, "addr", n.Address()) + d.Peer.peerJoin(n) +} + +// NotifyLeave is called if a peer leaves the cluster. +func (d *delegate) NotifyLeave(n *memberlist.Node) { + level.Debug(d.logger).Log("received", "NotifyLeave", "node", n.Name, "addr", n.Address()) + d.Peer.peerLeave(n) +} + +// NotifyUpdate is called if a cluster peer gets updated. +func (d *delegate) NotifyUpdate(n *memberlist.Node) { + level.Debug(d.logger).Log("received", "NotifyUpdate", "node", n.Name, "addr", n.Address()) + d.Peer.peerUpdate(n) +} + +// handleQueueDepth ensures that the queue doesn't grow unbounded by pruning +// older messages at regular interval. +func (d *delegate) handleQueueDepth() { + for { + select { + case <-d.stopc: + return + case <-time.After(15 * time.Minute): + n := d.bcast.NumQueued() + if n > maxQueueSize { + level.Warn(d.logger).Log("msg", "dropping messages because too many are queued", "current", n, "limit", maxQueueSize) + d.bcast.Prune(maxQueueSize) + d.messagesPruned.Add(float64(n - maxQueueSize)) + } + } + } +} diff --git a/src/alertmanager/cmd/alertmanager/main.go b/src/alertmanager/cmd/alertmanager/main.go new file mode 100644 index 0000000..a242da2 --- /dev/null +++ b/src/alertmanager/cmd/alertmanager/main.go @@ -0,0 +1,468 @@ +// Copyright 2015 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package main + +import ( + "context" + "crypto/md5" + "encoding/binary" + "fmt" + "net" + "net/http" + "net/url" + "os" + "os/signal" + "path/filepath" + "runtime" + "strings" + "sync" + "syscall" + "time" + + "github.com/go-kit/kit/log" + "github.com/go-kit/kit/log/level" + "github.com/prometheus/alertmanager/api" + "github.com/prometheus/alertmanager/cluster" + "github.com/prometheus/alertmanager/config" + "github.com/prometheus/alertmanager/dispatch" + "github.com/prometheus/alertmanager/inhibit" + "github.com/prometheus/alertmanager/nflog" + "github.com/prometheus/alertmanager/notify" + "github.com/prometheus/alertmanager/provider/mem" + "github.com/prometheus/alertmanager/silence" + "github.com/prometheus/alertmanager/template" + "github.com/prometheus/alertmanager/types" + "github.com/prometheus/alertmanager/ui" + "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/client_golang/prometheus/promhttp" + "github.com/prometheus/common/promlog" + "github.com/prometheus/common/route" + "github.com/prometheus/common/version" + "github.com/prometheus/prometheus/pkg/labels" + "gopkg.in/alecthomas/kingpin.v2" +) + +var ( + configHash = prometheus.NewGauge(prometheus.GaugeOpts{ + Name: "alertmanager_config_hash", + Help: "Hash of the currently loaded alertmanager configuration.", + }) + configSuccess = prometheus.NewGauge(prometheus.GaugeOpts{ + Name: "alertmanager_config_last_reload_successful", + Help: "Whether the last configuration reload attempt was successful.", + }) + configSuccessTime = prometheus.NewGauge(prometheus.GaugeOpts{ + Name: "alertmanager_config_last_reload_success_timestamp_seconds", + Help: "Timestamp of the last successful configuration reload.", + }) + alertsActive prometheus.GaugeFunc + alertsSuppressed prometheus.GaugeFunc + requestDuration = prometheus.NewHistogramVec( + prometheus.HistogramOpts{ + Name: "alertmanager_http_request_duration_seconds", + Help: "Histogram of latencies for HTTP requests.", + Buckets: []float64{.05, 0.1, .25, .5, .75, 1, 2, 5, 20, 60}, + }, + []string{"handler", "method"}, + ) + responseSize = prometheus.NewHistogramVec( + prometheus.HistogramOpts{ + Name: "alertmanager_http_response_size_bytes", + Help: "Histogram of response size for HTTP requests.", + Buckets: prometheus.ExponentialBuckets(100, 10, 7), + }, + []string{"handler", "method"}, + ) +) + +func init() { + prometheus.MustRegister(configSuccess) + prometheus.MustRegister(configSuccessTime) + prometheus.MustRegister(configHash) + prometheus.MustRegister(requestDuration) + prometheus.MustRegister(responseSize) + prometheus.MustRegister(version.NewCollector("alertmanager")) +} + +func instrumentHandler(handlerName string, handler http.HandlerFunc) http.HandlerFunc { + return promhttp.InstrumentHandlerDuration( + requestDuration.MustCurryWith(prometheus.Labels{"handler": handlerName}), + promhttp.InstrumentHandlerResponseSize( + responseSize.MustCurryWith(prometheus.Labels{"handler": handlerName}), + handler, + ), + ) +} + +func newAlertMetricByState(marker types.Marker, st types.AlertState) prometheus.GaugeFunc { + return prometheus.NewGaugeFunc( + prometheus.GaugeOpts{ + Name: "alertmanager_alerts", + Help: "How many alerts by state.", + ConstLabels: prometheus.Labels{"state": string(st)}, + }, + func() float64 { + return float64(marker.Count(st)) + }, + ) +} + +func newMarkerMetrics(marker types.Marker) { + alertsActive = newAlertMetricByState(marker, types.AlertStateActive) + alertsSuppressed = newAlertMetricByState(marker, types.AlertStateSuppressed) + + prometheus.MustRegister(alertsActive) + prometheus.MustRegister(alertsSuppressed) +} + +const defaultClusterAddr = "0.0.0.0:9094" + +func main() { + if os.Getenv("DEBUG") != "" { + runtime.SetBlockProfileRate(20) + runtime.SetMutexProfileFraction(20) + } + + logLevel := &promlog.AllowedLevel{} + if err := logLevel.Set("info"); err != nil { + panic(err) + } + var ( + configFile = kingpin.Flag("config.file", "Alertmanager configuration file name.").Default("alertmanager.yml").String() + dataDir = kingpin.Flag("storage.path", "Base path for data storage.").Default("data/").String() + retention = kingpin.Flag("data.retention", "How long to keep data for.").Default("120h").Duration() + alertGCInterval = kingpin.Flag("alerts.gc-interval", "Interval between alert GC.").Default("30m").Duration() + logLevelString = kingpin.Flag("log.level", "Only log messages with the given severity or above.").Default("info").Enum("debug", "info", "warn", "error") + + externalURL = kingpin.Flag("web.external-url", "The URL under which Alertmanager is externally reachable (for example, if Alertmanager is served via a reverse proxy). Used for generating relative and absolute links back to Alertmanager itself. If the URL has a path portion, it will be used to prefix all HTTP endpoints served by Alertmanager. If omitted, relevant URL components will be derived automatically.").String() + routePrefix = kingpin.Flag("web.route-prefix", "Prefix for the internal routes of web endpoints. Defaults to path of --web.external-url.").String() + listenAddress = kingpin.Flag("web.listen-address", "Address to listen on for the web interface and API.").Default(":9093").String() + + clusterBindAddr = kingpin.Flag("cluster.listen-address", "Listen address for cluster."). + Default(defaultClusterAddr).String() + clusterAdvertiseAddr = kingpin.Flag("cluster.advertise-address", "Explicit address to advertise in cluster.").String() + peers = kingpin.Flag("cluster.peer", "Initial peers (may be repeated).").Strings() + peerTimeout = kingpin.Flag("cluster.peer-timeout", "Time to wait between peers to send notifications.").Default("15s").Duration() + gossipInterval = kingpin.Flag("cluster.gossip-interval", "Interval between sending gossip messages. By lowering this value (more frequent) gossip messages are propagated across the cluster more quickly at the expense of increased bandwidth.").Default(cluster.DefaultGossipInterval.String()).Duration() + pushPullInterval = kingpin.Flag("cluster.pushpull-interval", "Interval for gossip state syncs. Setting this interval lower (more frequent) will increase convergence speeds across larger clusters at the expense of increased bandwidth usage.").Default(cluster.DefaultPushPullInterval.String()).Duration() + tcpTimeout = kingpin.Flag("cluster.tcp-timeout", "Timeout for establishing a stream connection with a remote node for a full state sync, and for stream read and write operations.").Default(cluster.DefaultTcpTimeout.String()).Duration() + probeTimeout = kingpin.Flag("cluster.probe-timeout", "Timeout to wait for an ack from a probed node before assuming it is unhealthy. This should be set to 99-percentile of RTT (round-trip time) on your network.").Default(cluster.DefaultProbeTimeout.String()).Duration() + probeInterval = kingpin.Flag("cluster.probe-interval", "Interval between random node probes. Setting this lower (more frequent) will cause the cluster to detect failed nodes more quickly at the expense of increased bandwidth usage.").Default(cluster.DefaultProbeInterval.String()).Duration() + settleTimeout = kingpin.Flag("cluster.settle-timeout", "Maximum time to wait for cluster connections to settle before evaluating notifications.").Default(cluster.DefaultPushPullInterval.String()).Duration() + reconnectInterval = kingpin.Flag("cluster.reconnect-interval", "Interval between attempting to reconnect to lost peers.").Default(cluster.DefaultReconnectInterval.String()).Duration() + peerReconnectTimeout = kingpin.Flag("cluster.reconnect-timeout", "Length of time to attempt to reconnect to a lost peer.").Default(cluster.DefaultReconnectTimeout.String()).Duration() + ) + + kingpin.Version(version.Print("alertmanager")) + kingpin.CommandLine.GetFlag("help").Short('h') + kingpin.Parse() + + logLevel.Set(*logLevelString) + logger := promlog.New(*logLevel) + + level.Info(logger).Log("msg", "Starting Alertmanager", "version", version.Info()) + level.Info(logger).Log("build_context", version.BuildContext()) + + err := os.MkdirAll(*dataDir, 0777) + if err != nil { + level.Error(logger).Log("msg", "Unable to create data directory", "err", err) + os.Exit(1) + } + + var peer *cluster.Peer + if *clusterBindAddr != "" { + peer, err = cluster.Join( + log.With(logger, "component", "cluster"), + prometheus.DefaultRegisterer, + *clusterBindAddr, + *clusterAdvertiseAddr, + *peers, + true, + *pushPullInterval, + *gossipInterval, + *tcpTimeout, + *probeTimeout, + *probeInterval, + *reconnectInterval, + *peerReconnectTimeout, + ) + if err != nil { + level.Error(logger).Log("msg", "Unable to initialize gossip mesh", "err", err) + os.Exit(1) + } + ctx, cancel := context.WithTimeout(context.Background(), *settleTimeout) + defer func() { + cancel() + peer.Leave(10 * time.Second) + }() + go peer.Settle(ctx, *gossipInterval*10) + } + + stopc := make(chan struct{}) + var wg sync.WaitGroup + wg.Add(1) + + notificationLogOpts := []nflog.Option{ + nflog.WithRetention(*retention), + nflog.WithSnapshot(filepath.Join(*dataDir, "nflog")), + nflog.WithMaintenance(15*time.Minute, stopc, wg.Done), + nflog.WithMetrics(prometheus.DefaultRegisterer), + nflog.WithLogger(log.With(logger, "component", "nflog")), + } + + notificationLog, err := nflog.New(notificationLogOpts...) + if err != nil { + level.Error(logger).Log("err", err) + os.Exit(1) + } + if peer != nil { + c := peer.AddState("nfl", notificationLog, prometheus.DefaultRegisterer) + notificationLog.SetBroadcast(c.Broadcast) + } + + marker := types.NewMarker() + newMarkerMetrics(marker) + + silenceOpts := silence.Options{ + SnapshotFile: filepath.Join(*dataDir, "silences"), + Retention: *retention, + Logger: log.With(logger, "component", "silences"), + Metrics: prometheus.DefaultRegisterer, + } + + silences, err := silence.New(silenceOpts) + if err != nil { + level.Error(logger).Log("err", err) + os.Exit(1) + } + if peer != nil { + c := peer.AddState("sil", silences, prometheus.DefaultRegisterer) + silences.SetBroadcast(c.Broadcast) + } + + // Start providers before router potentially sends updates. + wg.Add(1) + go func() { + silences.Maintenance(15*time.Minute, filepath.Join(*dataDir, "silences"), stopc) + wg.Done() + }() + + defer func() { + close(stopc) + wg.Wait() + }() + + alerts, err := mem.NewAlerts(marker, *alertGCInterval) + if err != nil { + level.Error(logger).Log("err", err) + os.Exit(1) + } + defer alerts.Close() + + var ( + inhibitor *inhibit.Inhibitor + tmpl *template.Template + pipeline notify.Stage + disp *dispatch.Dispatcher + ) + defer disp.Stop() + + apiv := api.New( + alerts, + silences, + func(matchers []*labels.Matcher) dispatch.AlertOverview { + return disp.Groups(matchers) + }, + marker.Status, + peer, + logger, + ) + + amURL, err := extURL(*listenAddress, *externalURL) + if err != nil { + level.Error(logger).Log("err", err) + os.Exit(1) + } + + waitFunc := func() time.Duration { return 0 } + if peer != nil { + waitFunc = clusterWait(peer, *peerTimeout) + } + timeoutFunc := func(d time.Duration) time.Duration { + if d < notify.MinTimeout { + d = notify.MinTimeout + } + return d + waitFunc() + } + + var hash float64 + reload := func() (err error) { + level.Info(logger).Log("msg", "Loading configuration file", "file", *configFile) + defer func() { + if err != nil { + level.Error(logger).Log("msg", "Loading configuration file failed", "file", *configFile, "err", err) + configSuccess.Set(0) + } else { + configSuccess.Set(1) + configSuccessTime.Set(float64(time.Now().Unix())) + configHash.Set(hash) + } + }() + + conf, plainCfg, err := config.LoadFile(*configFile) + if err != nil { + return err + } + + hash = md5HashAsMetricValue(plainCfg) + + err = apiv.Update(conf, time.Duration(conf.Global.ResolveTimeout)) + if err != nil { + return err + } + + tmpl, err = template.FromGlobs(conf.Templates...) + if err != nil { + return err + } + tmpl.ExternalURL = amURL + + inhibitor.Stop() + disp.Stop() + + inhibitor = inhibit.NewInhibitor(alerts, conf.InhibitRules, marker, logger) + pipeline = notify.BuildPipeline( + conf.Receivers, + tmpl, + waitFunc, + inhibitor, + silences, + notificationLog, + marker, + peer, + logger, + ) + disp = dispatch.NewDispatcher(alerts, dispatch.NewRoute(conf.Route, nil), pipeline, marker, timeoutFunc, logger) + + go disp.Run() + go inhibitor.Run() + + return nil + } + + if err := reload(); err != nil { + os.Exit(1) + } + + // Make routePrefix default to externalURL path if empty string. + if routePrefix == nil || *routePrefix == "" { + *routePrefix = amURL.Path + } + + *routePrefix = "/" + strings.Trim(*routePrefix, "/") + + router := route.New().WithInstrumentation(instrumentHandler) + + if *routePrefix != "/" { + router = router.WithPrefix(*routePrefix) + } + + webReload := make(chan chan error) + + ui.Register(router, webReload, logger) + + apiv.Register(router.WithPrefix("/api/v1")) + + level.Info(logger).Log("msg", "Listening", "address", *listenAddress) + go listen(*listenAddress, router, logger) + + var ( + hup = make(chan os.Signal) + hupReady = make(chan bool) + term = make(chan os.Signal, 1) + ) + signal.Notify(hup, syscall.SIGHUP) + signal.Notify(term, os.Interrupt, syscall.SIGTERM) + + go func() { + <-hupReady + for { + select { + case <-hup: + reload() + case errc := <-webReload: + errc <- reload() + } + } + }() + + // Wait for reload or termination signals. + close(hupReady) // Unblock SIGHUP handler. + + <-term + + level.Info(logger).Log("msg", "Received SIGTERM, exiting gracefully...") +} + +// clusterWait returns a function that inspects the current peer state and returns +// a duration of one base timeout for each peer with a higher ID than ourselves. +func clusterWait(p *cluster.Peer, timeout time.Duration) func() time.Duration { + return func() time.Duration { + return time.Duration(p.Position()) * timeout + } +} + +func extURL(listen, external string) (*url.URL, error) { + if external == "" { + hostname, err := os.Hostname() + if err != nil { + return nil, err + } + _, port, err := net.SplitHostPort(listen) + if err != nil { + return nil, err + } + + external = fmt.Sprintf("http://%s:%s/", hostname, port) + } + + u, err := url.Parse(external) + if err != nil { + return nil, err + } + + ppref := strings.TrimRight(u.Path, "/") + if ppref != "" && !strings.HasPrefix(ppref, "/") { + ppref = "/" + ppref + } + u.Path = ppref + + return u, nil +} + +func listen(listen string, router *route.Router, logger log.Logger) { + if err := http.ListenAndServe(listen, router); err != nil { + level.Error(logger).Log("msg", "Listen error", "err", err) + os.Exit(1) + } +} + +func md5HashAsMetricValue(data []byte) float64 { + sum := md5.Sum(data) + // We only want 48 bits as a float64 only has a 53 bit mantissa. + smallSum := sum[0:6] + var bytes = make([]byte, 8) + copy(bytes, smallSum) + return float64(binary.LittleEndian.Uint64(bytes)) +} diff --git a/src/alertmanager/cmd/amtool/README.md b/src/alertmanager/cmd/amtool/README.md new file mode 100644 index 0000000..4e1469f --- /dev/null +++ b/src/alertmanager/cmd/amtool/README.md @@ -0,0 +1,20 @@ +# Generating amtool artifacts + +Amtool comes with the option to create a number of ease-of-use artifacts that can be created. + +## Shell completion + +A bash completion script can be generated by calling `amtool --completion-script-bash`. + +The bash completion file can be added to `/etc/bash_completion.d/`. + +## Man pages + +A man page can be generated by calling `amtool --help-man`. + +Man pages can be added to the man directory of your choice + + amtool --help-man > /usr/local/share/man/man1/amtool.1 + sudo mandb + +Then you should be able to view the man pages as expected. diff --git a/src/alertmanager/cmd/amtool/main.go b/src/alertmanager/cmd/amtool/main.go new file mode 100644 index 0000000..9e36fb9 --- /dev/null +++ b/src/alertmanager/cmd/amtool/main.go @@ -0,0 +1,20 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package main + +import "github.com/prometheus/alertmanager/cli" + +func main() { + cli.Execute() +} diff --git a/src/alertmanager/config/config.go b/src/alertmanager/config/config.go new file mode 100644 index 0000000..77afda4 --- /dev/null +++ b/src/alertmanager/config/config.go @@ -0,0 +1,574 @@ +// Copyright 2015 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package config + +import ( + "encoding/json" + "errors" + "fmt" + "io/ioutil" + "path/filepath" + "regexp" + "strings" + "time" + + commoncfg "github.com/prometheus/common/config" + "github.com/prometheus/common/model" + "gopkg.in/yaml.v2" +) + +// Secret is a string that must not be revealed on marshaling. +type Secret string + +// MarshalYAML implements the yaml.Marshaler interface. +func (s Secret) MarshalYAML() (interface{}, error) { + if s != "" { + return "", nil + } + return nil, nil +} + +//UnmarshalYAML implements the yaml.Unmarshaler interface for Secrets. +func (s *Secret) UnmarshalYAML(unmarshal func(interface{}) error) error { + type plain Secret + return unmarshal((*plain)(s)) +} + +// MarshalJSON implements the json.Marshaler interface. +func (s Secret) MarshalJSON() ([]byte, error) { + return json.Marshal("") +} + +// Load parses the YAML input s into a Config. +func Load(s string) (*Config, error) { + cfg := &Config{} + err := yaml.UnmarshalStrict([]byte(s), cfg) + if err != nil { + return nil, err + } + // Check if we have a root route. We cannot check for it in the + // UnmarshalYAML method because it won't be called if the input is empty + // (e.g. the config file is empty or only contains whitespace). + if cfg.Route == nil { + return nil, errors.New("no route provided in config") + } + + // Check if continue in root route. + if cfg.Route.Continue { + return nil, errors.New("cannot have continue in root route") + } + + cfg.original = s + return cfg, nil +} + +// LoadFile parses the given YAML file into a Config. +func LoadFile(filename string) (*Config, []byte, error) { + content, err := ioutil.ReadFile(filename) + if err != nil { + return nil, nil, err + } + cfg, err := Load(string(content)) + if err != nil { + return nil, nil, err + } + + resolveFilepaths(filepath.Dir(filename), cfg) + return cfg, content, nil +} + +// resolveFilepaths joins all relative paths in a configuration +// with a given base directory. +func resolveFilepaths(baseDir string, cfg *Config) { + join := func(fp string) string { + if len(fp) > 0 && !filepath.IsAbs(fp) { + fp = filepath.Join(baseDir, fp) + } + return fp + } + + for i, tf := range cfg.Templates { + cfg.Templates[i] = join(tf) + } +} + +// Config is the top-level configuration for Alertmanager's config files. +type Config struct { + Global *GlobalConfig `yaml:"global,omitempty" json:"global,omitempty"` + Route *Route `yaml:"route,omitempty" json:"route,omitempty"` + InhibitRules []*InhibitRule `yaml:"inhibit_rules,omitempty" json:"inhibit_rules,omitempty"` + Receivers []*Receiver `yaml:"receivers,omitempty" json:"receivers,omitempty"` + Templates []string `yaml:"templates" json:"templates"` + + // original is the input from which the config was parsed. + original string +} + +func (c Config) String() string { + b, err := yaml.Marshal(c) + if err != nil { + return fmt.Sprintf("", err) + } + return string(b) +} + +// UnmarshalYAML implements the yaml.Unmarshaler interface. +func (c *Config) UnmarshalYAML(unmarshal func(interface{}) error) error { + // We want to set c to the defaults and then overwrite it with the input. + // To make unmarshal fill the plain data struct rather than calling UnmarshalYAML + // again, we have to hide it using a type indirection. + type plain Config + if err := unmarshal((*plain)(c)); err != nil { + return err + } + + // If a global block was open but empty the default global config is overwritten. + // We have to restore it here. + if c.Global == nil { + c.Global = &GlobalConfig{} + *c.Global = DefaultGlobalConfig + } + + names := map[string]struct{}{} + + for _, rcv := range c.Receivers { + if _, ok := names[rcv.Name]; ok { + return fmt.Errorf("notification config name %q is not unique", rcv.Name) + } + for _, wh := range rcv.WebhookConfigs { + if wh.HTTPConfig == nil { + wh.HTTPConfig = c.Global.HTTPConfig + } + } + for _, ec := range rcv.EmailConfigs { + if ec.Smarthost == "" { + if c.Global.SMTPSmarthost == "" { + return fmt.Errorf("no global SMTP smarthost set") + } + ec.Smarthost = c.Global.SMTPSmarthost + } + if ec.From == "" { + if c.Global.SMTPFrom == "" { + return fmt.Errorf("no global SMTP from set") + } + ec.From = c.Global.SMTPFrom + } + if ec.Hello == "" { + ec.Hello = c.Global.SMTPHello + } + if ec.AuthUsername == "" { + ec.AuthUsername = c.Global.SMTPAuthUsername + } + if ec.AuthPassword == "" { + ec.AuthPassword = c.Global.SMTPAuthPassword + } + if ec.AuthSecret == "" { + ec.AuthSecret = c.Global.SMTPAuthSecret + } + if ec.AuthIdentity == "" { + ec.AuthIdentity = c.Global.SMTPAuthIdentity + } + if ec.RequireTLS == nil { + ec.RequireTLS = new(bool) + *ec.RequireTLS = c.Global.SMTPRequireTLS + } + } + for _, sc := range rcv.SlackConfigs { + if sc.HTTPConfig == nil { + sc.HTTPConfig = c.Global.HTTPConfig + } + if sc.APIURL == "" { + if c.Global.SlackAPIURL == "" { + return fmt.Errorf("no global Slack API URL set") + } + sc.APIURL = c.Global.SlackAPIURL + } + } + for _, hc := range rcv.HipchatConfigs { + if hc.HTTPConfig == nil { + hc.HTTPConfig = c.Global.HTTPConfig + } + if hc.APIURL == "" { + if c.Global.HipchatAPIURL == "" { + return fmt.Errorf("no global Hipchat API URL set") + } + hc.APIURL = c.Global.HipchatAPIURL + } + if !strings.HasSuffix(hc.APIURL, "/") { + hc.APIURL += "/" + } + if hc.AuthToken == "" { + if c.Global.HipchatAuthToken == "" { + return fmt.Errorf("no global Hipchat Auth Token set") + } + hc.AuthToken = c.Global.HipchatAuthToken + } + } + for _, poc := range rcv.PushoverConfigs { + if poc.HTTPConfig == nil { + poc.HTTPConfig = c.Global.HTTPConfig + } + } + for _, pdc := range rcv.PagerdutyConfigs { + if pdc.HTTPConfig == nil { + pdc.HTTPConfig = c.Global.HTTPConfig + } + if pdc.URL == "" { + if c.Global.PagerdutyURL == "" { + return fmt.Errorf("no global PagerDuty URL set") + } + pdc.URL = c.Global.PagerdutyURL + } + } + for _, ogc := range rcv.OpsGenieConfigs { + if ogc.HTTPConfig == nil { + ogc.HTTPConfig = c.Global.HTTPConfig + } + if ogc.APIURL == "" { + if c.Global.OpsGenieAPIURL == "" { + return fmt.Errorf("no global OpsGenie URL set") + } + ogc.APIURL = c.Global.OpsGenieAPIURL + } + if !strings.HasSuffix(ogc.APIURL, "/") { + ogc.APIURL += "/" + } + if ogc.APIKey == "" { + if c.Global.OpsGenieAPIKey == "" { + return fmt.Errorf("no global OpsGenie API Key set") + } + ogc.APIKey = c.Global.OpsGenieAPIKey + } + } + for _, wcc := range rcv.WechatConfigs { + if wcc.HTTPConfig == nil { + wcc.HTTPConfig = c.Global.HTTPConfig + } + + if wcc.APIURL == "" { + if c.Global.WeChatAPIURL == "" { + return fmt.Errorf("no global Wechat URL set") + } + wcc.APIURL = c.Global.WeChatAPIURL + } + + if wcc.APISecret == "" { + if c.Global.WeChatAPISecret == "" { + return fmt.Errorf("no global Wechat ApiSecret set") + } + wcc.APISecret = c.Global.WeChatAPISecret + } + + if wcc.CorpID == "" { + if c.Global.WeChatAPICorpID == "" { + return fmt.Errorf("no global Wechat CorpID set") + } + wcc.CorpID = c.Global.WeChatAPICorpID + } + + if !strings.HasSuffix(wcc.APIURL, "/") { + wcc.APIURL += "/" + } + } + for _, voc := range rcv.VictorOpsConfigs { + if voc.HTTPConfig == nil { + voc.HTTPConfig = c.Global.HTTPConfig + } + if voc.APIURL == "" { + if c.Global.VictorOpsAPIURL == "" { + return fmt.Errorf("no global VictorOps URL set") + } + voc.APIURL = c.Global.VictorOpsAPIURL + } + if !strings.HasSuffix(voc.APIURL, "/") { + voc.APIURL += "/" + } + if voc.APIKey == "" { + if c.Global.VictorOpsAPIKey == "" { + return fmt.Errorf("no global VictorOps API Key set") + } + voc.APIKey = c.Global.VictorOpsAPIKey + } + } + names[rcv.Name] = struct{}{} + } + + // The root route must not have any matchers as it is the fallback node + // for all alerts. + if c.Route == nil { + return fmt.Errorf("no routes provided") + } + if len(c.Route.Receiver) == 0 { + return fmt.Errorf("root route must specify a default receiver") + } + if len(c.Route.Match) > 0 || len(c.Route.MatchRE) > 0 { + return fmt.Errorf("root route must not have any matchers") + } + + // Validate that all receivers used in the routing tree are defined. + return checkReceiver(c.Route, names) +} + +// checkReceiver returns an error if a node in the routing tree +// references a receiver not in the given map. +func checkReceiver(r *Route, receivers map[string]struct{}) error { + if r.Receiver == "" { + return nil + } + if _, ok := receivers[r.Receiver]; !ok { + return fmt.Errorf("undefined receiver %q used in route", r.Receiver) + } + for _, sr := range r.Routes { + if err := checkReceiver(sr, receivers); err != nil { + return err + } + } + return nil +} + +// DefaultGlobalConfig provides global default values. +var DefaultGlobalConfig = GlobalConfig{ + ResolveTimeout: model.Duration(5 * time.Minute), + HTTPConfig: &commoncfg.HTTPClientConfig{}, + + SMTPHello: "localhost", + SMTPRequireTLS: true, + PagerdutyURL: "https://events.pagerduty.com/v2/enqueue", + HipchatAPIURL: "https://api.hipchat.com/", + OpsGenieAPIURL: "https://api.opsgenie.com/", + WeChatAPIURL: "https://qyapi.weixin.qq.com/cgi-bin/", + VictorOpsAPIURL: "https://alert.victorops.com/integrations/generic/20131114/alert/", +} + +// GlobalConfig defines configuration parameters that are valid globally +// unless overwritten. +type GlobalConfig struct { + // ResolveTimeout is the time after which an alert is declared resolved + // if it has not been updated. + ResolveTimeout model.Duration `yaml:"resolve_timeout" json:"resolve_timeout"` + + HTTPConfig *commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` + + SMTPFrom string `yaml:"smtp_from,omitempty" json:"smtp_from,omitempty"` + SMTPHello string `yaml:"smtp_hello,omitempty" json:"smtp_hello,omitempty"` + SMTPSmarthost string `yaml:"smtp_smarthost,omitempty" json:"smtp_smarthost,omitempty"` + SMTPAuthUsername string `yaml:"smtp_auth_username,omitempty" json:"smtp_auth_username,omitempty"` + SMTPAuthPassword Secret `yaml:"smtp_auth_password,omitempty" json:"smtp_auth_password,omitempty"` + SMTPAuthSecret Secret `yaml:"smtp_auth_secret,omitempty" json:"smtp_auth_secret,omitempty"` + SMTPAuthIdentity string `yaml:"smtp_auth_identity,omitempty" json:"smtp_auth_identity,omitempty"` + SMTPRequireTLS bool `yaml:"smtp_require_tls,omitempty" json:"smtp_require_tls,omitempty"` + SlackAPIURL Secret `yaml:"slack_api_url,omitempty" json:"slack_api_url,omitempty"` + PagerdutyURL string `yaml:"pagerduty_url,omitempty" json:"pagerduty_url,omitempty"` + HipchatAPIURL string `yaml:"hipchat_api_url,omitempty" json:"hipchat_api_url,omitempty"` + HipchatAuthToken Secret `yaml:"hipchat_auth_token,omitempty" json:"hipchat_auth_token,omitempty"` + OpsGenieAPIURL string `yaml:"opsgenie_api_url,omitempty" json:"opsgenie_api_url,omitempty"` + OpsGenieAPIKey Secret `yaml:"opsgenie_api_key,omitempty" json:"opsgenie_api_key,omitempty"` + WeChatAPIURL string `yaml:"wechat_api_url,omitempty" json:"wechat_api_url,omitempty"` + WeChatAPISecret Secret `yaml:"wechat_api_secret,omitempty" json:"wechat_api_secret,omitempty"` + WeChatAPICorpID string `yaml:"wechat_api_corp_id,omitempty" json:"wechat_api_corp_id,omitempty"` + VictorOpsAPIURL string `yaml:"victorops_api_url,omitempty" json:"victorops_api_url,omitempty"` + VictorOpsAPIKey Secret `yaml:"victorops_api_key,omitempty" json:"victorops_api_key,omitempty"` +} + +// UnmarshalYAML implements the yaml.Unmarshaler interface. +func (c *GlobalConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { + *c = DefaultGlobalConfig + type plain GlobalConfig + return unmarshal((*plain)(c)) +} + +// A Route is a node that contains definitions of how to handle alerts. +type Route struct { + Receiver string `yaml:"receiver,omitempty" json:"receiver,omitempty"` + GroupBy []model.LabelName `yaml:"group_by,omitempty" json:"group_by,omitempty"` + + Match map[string]string `yaml:"match,omitempty" json:"match,omitempty"` + MatchRE map[string]Regexp `yaml:"match_re,omitempty" json:"match_re,omitempty"` + Continue bool `yaml:"continue,omitempty" json:"continue,omitempty"` + Routes []*Route `yaml:"routes,omitempty" json:"routes,omitempty"` + + GroupWait *model.Duration `yaml:"group_wait,omitempty" json:"group_wait,omitempty"` + GroupInterval *model.Duration `yaml:"group_interval,omitempty" json:"group_interval,omitempty"` + RepeatInterval *model.Duration `yaml:"repeat_interval,omitempty" json:"repeat_interval,omitempty"` +} + +// UnmarshalYAML implements the yaml.Unmarshaler interface. +func (r *Route) UnmarshalYAML(unmarshal func(interface{}) error) error { + type plain Route + if err := unmarshal((*plain)(r)); err != nil { + return err + } + + for k := range r.Match { + if !model.LabelNameRE.MatchString(k) { + return fmt.Errorf("invalid label name %q", k) + } + } + + for k := range r.MatchRE { + if !model.LabelNameRE.MatchString(k) { + return fmt.Errorf("invalid label name %q", k) + } + } + + groupBy := map[model.LabelName]struct{}{} + + for _, ln := range r.GroupBy { + if _, ok := groupBy[ln]; ok { + return fmt.Errorf("duplicated label %q in group_by", ln) + } + groupBy[ln] = struct{}{} + } + + if r.GroupInterval != nil && time.Duration(*r.GroupInterval) == time.Duration(0) { + return fmt.Errorf("group_interval cannot be zero") + } + if r.RepeatInterval != nil && time.Duration(*r.RepeatInterval) == time.Duration(0) { + return fmt.Errorf("repeat_interval cannot be zero") + } + + return nil +} + +// InhibitRule defines an inhibition rule that mutes alerts that match the +// target labels if an alert matching the source labels exists. +// Both alerts have to have a set of labels being equal. +type InhibitRule struct { + // SourceMatch defines a set of labels that have to equal the given + // value for source alerts. + SourceMatch map[string]string `yaml:"source_match,omitempty" json:"source_match,omitempty"` + // SourceMatchRE defines pairs like SourceMatch but does regular expression + // matching. + SourceMatchRE map[string]Regexp `yaml:"source_match_re,omitempty" json:"source_match_re,omitempty"` + // TargetMatch defines a set of labels that have to equal the given + // value for target alerts. + TargetMatch map[string]string `yaml:"target_match,omitempty" json:"target_match,omitempty"` + // TargetMatchRE defines pairs like TargetMatch but does regular expression + // matching. + TargetMatchRE map[string]Regexp `yaml:"target_match_re,omitempty" json:"target_match_re,omitempty"` + // A set of labels that must be equal between the source and target alert + // for them to be a match. + Equal model.LabelNames `yaml:"equal,omitempty" json:"equal,omitempty"` +} + +// UnmarshalYAML implements the yaml.Unmarshaler interface. +func (r *InhibitRule) UnmarshalYAML(unmarshal func(interface{}) error) error { + type plain InhibitRule + if err := unmarshal((*plain)(r)); err != nil { + return err + } + + for k := range r.SourceMatch { + if !model.LabelNameRE.MatchString(k) { + return fmt.Errorf("invalid label name %q", k) + } + } + + for k := range r.SourceMatchRE { + if !model.LabelNameRE.MatchString(k) { + return fmt.Errorf("invalid label name %q", k) + } + } + + for k := range r.TargetMatch { + if !model.LabelNameRE.MatchString(k) { + return fmt.Errorf("invalid label name %q", k) + } + } + + for k := range r.TargetMatchRE { + if !model.LabelNameRE.MatchString(k) { + return fmt.Errorf("invalid label name %q", k) + } + } + + return nil +} + +// Receiver configuration provides configuration on how to contact a receiver. +type Receiver struct { + // A unique identifier for this receiver. + Name string `yaml:"name" json:"name"` + + EmailConfigs []*EmailConfig `yaml:"email_configs,omitempty" json:"email_configs,omitempty"` + PagerdutyConfigs []*PagerdutyConfig `yaml:"pagerduty_configs,omitempty" json:"pagerduty_configs,omitempty"` + HipchatConfigs []*HipchatConfig `yaml:"hipchat_configs,omitempty" json:"hipchat_configs,omitempty"` + SlackConfigs []*SlackConfig `yaml:"slack_configs,omitempty" json:"slack_configs,omitempty"` + WebhookConfigs []*WebhookConfig `yaml:"webhook_configs,omitempty" json:"webhook_configs,omitempty"` + OpsGenieConfigs []*OpsGenieConfig `yaml:"opsgenie_configs,omitempty" json:"opsgenie_configs,omitempty"` + WechatConfigs []*WechatConfig `yaml:"wechat_configs,omitempty" json:"wechat_configs,omitempty"` + PushoverConfigs []*PushoverConfig `yaml:"pushover_configs,omitempty" json:"pushover_configs,omitempty"` + VictorOpsConfigs []*VictorOpsConfig `yaml:"victorops_configs,omitempty" json:"victorops_configs,omitempty"` +} + +// UnmarshalYAML implements the yaml.Unmarshaler interface. +func (c *Receiver) UnmarshalYAML(unmarshal func(interface{}) error) error { + type plain Receiver + if err := unmarshal((*plain)(c)); err != nil { + return err + } + if c.Name == "" { + return fmt.Errorf("missing name in receiver") + } + return nil +} + +// Regexp encapsulates a regexp.Regexp and makes it YAML marshalable. +type Regexp struct { + *regexp.Regexp +} + +// UnmarshalYAML implements the yaml.Unmarshaler interface. +func (re *Regexp) UnmarshalYAML(unmarshal func(interface{}) error) error { + var s string + if err := unmarshal(&s); err != nil { + return err + } + regex, err := regexp.Compile("^(?:" + s + ")$") + if err != nil { + return err + } + re.Regexp = regex + return nil +} + +// MarshalYAML implements the yaml.Marshaler interface. +func (re Regexp) MarshalYAML() (interface{}, error) { + if re.Regexp != nil { + return re.String(), nil + } + return nil, nil +} + +// UnmarshalJSON implements the json.Marshaler interface +func (re *Regexp) UnmarshalJSON(data []byte) error { + var s string + if err := json.Unmarshal(data, &s); err != nil { + return err + } + regex, err := regexp.Compile("^(?:" + s + ")$") + if err != nil { + return err + } + re.Regexp = regex + return nil +} + +// MarshalJSON implements the json.Marshaler interface. +func (re Regexp) MarshalJSON() ([]byte, error) { + if re.Regexp != nil { + return json.Marshal(re.String()) + } + return nil, nil +} diff --git a/src/alertmanager/config/config_test.go b/src/alertmanager/config/config_test.go new file mode 100644 index 0000000..c812035 --- /dev/null +++ b/src/alertmanager/config/config_test.go @@ -0,0 +1,451 @@ +// Copyright 2016 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package config + +import ( + "encoding/json" + "reflect" + "regexp" + "strings" + "testing" + "time" + + commoncfg "github.com/prometheus/common/config" + "github.com/prometheus/common/model" + "github.com/stretchr/testify/require" + "gopkg.in/yaml.v2" +) + +func TestLoadEmptyString(t *testing.T) { + + var in string + _, err := Load(in) + + expected := "no route provided in config" + + if err == nil { + t.Fatalf("no error returned, expected:\n%v", expected) + } + if err.Error() != expected { + t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) + } +} + +func TestDefaultReceiverExists(t *testing.T) { + in := ` +route: + group_wait: 30s +` + _, err := Load(in) + + expected := "root route must specify a default receiver" + + if err == nil { + t.Fatalf("no error returned, expected:\n%v", expected) + } + if err.Error() != expected { + t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) + } +} + +func TestReceiverNameIsUnique(t *testing.T) { + in := ` +route: + receiver: team-X + +receivers: +- name: 'team-X' +- name: 'team-X' +` + _, err := Load(in) + + expected := "notification config name \"team-X\" is not unique" + + if err == nil { + t.Fatalf("no error returned, expected:\n%q", expected) + } + if err.Error() != expected { + t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) + } + +} + +func TestReceiverExists(t *testing.T) { + in := ` +route: + receiver: team-X + +receivers: +- name: 'team-Y' +` + _, err := Load(in) + + expected := "undefined receiver \"team-X\" used in route" + + if err == nil { + t.Fatalf("no error returned, expected:\n%q", expected) + } + if err.Error() != expected { + t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) + } + +} + +func TestReceiverHasName(t *testing.T) { + in := ` +route: + +receivers: +- name: '' +` + _, err := Load(in) + + expected := "missing name in receiver" + + if err == nil { + t.Fatalf("no error returned, expected:\n%q", expected) + } + if err.Error() != expected { + t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) + } + +} + +func TestGroupByHasNoDuplicatedLabels(t *testing.T) { + in := ` +route: + group_by: ['alertname', 'cluster', 'service', 'cluster'] + +receivers: +- name: 'team-X-mails' +` + _, err := Load(in) + + expected := "duplicated label \"cluster\" in group_by" + + if err == nil { + t.Fatalf("no error returned, expected:\n%q", expected) + } + if err.Error() != expected { + t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) + } + +} + +func TestRootRouteExists(t *testing.T) { + in := ` +receivers: +- name: 'team-X-mails' +` + _, err := Load(in) + + expected := "no routes provided" + + if err == nil { + t.Fatalf("no error returned, expected:\n%q", expected) + } + if err.Error() != expected { + t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) + } + +} + +func TestRootRouteHasNoMatcher(t *testing.T) { + in := ` +route: + receiver: 'team-X' + match: + severity: critical + +receivers: +- name: 'team-X' +` + _, err := Load(in) + + expected := "root route must not have any matchers" + + if err == nil { + t.Fatalf("no error returned, expected:\n%q", expected) + } + if err.Error() != expected { + t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) + } + +} + +func TestContinueErrorInRouteRoot(t *testing.T) { + in := ` +route: + receiver: team-X-mails + continue: true + +receivers: +- name: 'team-X-mails' +` + _, err := Load(in) + + expected := "cannot have continue in root route" + + if err == nil { + t.Fatalf("no error returned, expected:\n%q", expected) + } + if err.Error() != expected { + t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) + } + +} + +func TestGroupIntervalIsGreaterThanZero(t *testing.T) { + in := ` +route: + receiver: team-X-mails + group_interval: 0s + +receivers: +- name: 'team-X-mails' +` + _, err := Load(in) + + expected := "group_interval cannot be zero" + + if err == nil { + t.Fatalf("no error returned, expected:\n%q", expected) + } + if err.Error() != expected { + t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) + } +} + +func TestRepeatIntervalIsGreaterThanZero(t *testing.T) { + in := ` +route: + receiver: team-X-mails + repeat_interval: 0s + +receivers: +- name: 'team-X-mails' +` + _, err := Load(in) + + expected := "repeat_interval cannot be zero" + + if err == nil { + t.Fatalf("no error returned, expected:\n%q", expected) + } + if err.Error() != expected { + t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) + } +} + +func TestHideConfigSecrets(t *testing.T) { + c, _, err := LoadFile("testdata/conf.good.yml") + if err != nil { + t.Errorf("Error parsing %s: %s", "testdata/conf.good.yml", err) + } + + // String method must not reveal authentication credentials. + s := c.String() + secretRe := regexp.MustCompile("") + matches := secretRe.FindAllStringIndex(s, -1) + if len(matches) != 14 || strings.Contains(s, "mysecret") { + t.Fatal("config's String method reveals authentication credentials.") + } +} + +func TestJSONMarshal(t *testing.T) { + c, _, err := LoadFile("testdata/conf.good.yml") + if err != nil { + t.Errorf("Error parsing %s: %s", "testdata/conf.good.yml", err) + } + + _, err = json.Marshal(c) + if err != nil { + t.Fatal("JSON Marshaling failed:", err) + } +} + +func TestJSONMarshalSecret(t *testing.T) { + test := struct { + S Secret + }{ + S: Secret("test"), + } + + c, err := json.Marshal(test) + if err != nil { + t.Fatal(err) + } + + // u003c -> "<" + // u003e -> ">" + require.Equal(t, "{\"S\":\"\\u003csecret\\u003e\"}", string(c), "Secret not properly elided.") +} + +func TestJSONUnmarshalMarshaled(t *testing.T) { + c, _, err := LoadFile("testdata/conf.good.yml") + if err != nil { + t.Errorf("Error parsing %s: %s", "testdata/conf.good.yml", err) + } + + plainCfg, err := json.Marshal(c) + if err != nil { + t.Fatal("JSON Marshaling failed:", err) + } + + cfg := Config{} + err = json.Unmarshal(plainCfg, &cfg) + if err != nil { + t.Fatal("JSON Unmarshaling failed:", err) + } +} + +func TestEmptyFieldsAndRegex(t *testing.T) { + boolFoo := true + var regexpFoo Regexp + regexpFoo.Regexp, _ = regexp.Compile("^(?:^(foo1|foo2|baz)$)$") + + var expectedConf = Config{ + + Global: &GlobalConfig{ + HTTPConfig: &commoncfg.HTTPClientConfig{}, + ResolveTimeout: model.Duration(5 * time.Minute), + SMTPSmarthost: "localhost:25", + SMTPFrom: "alertmanager@example.org", + HipchatAuthToken: "mysecret", + HipchatAPIURL: "https://hipchat.foobar.org/", + SlackAPIURL: "mysecret", + SMTPRequireTLS: true, + PagerdutyURL: "https://events.pagerduty.com/v2/enqueue", + OpsGenieAPIURL: "https://api.opsgenie.com/", + WeChatAPIURL: "https://qyapi.weixin.qq.com/cgi-bin/", + VictorOpsAPIURL: "https://alert.victorops.com/integrations/generic/20131114/alert/", + }, + + Templates: []string{ + "/etc/alertmanager/template/*.tmpl", + }, + Route: &Route{ + Receiver: "team-X-mails", + GroupBy: []model.LabelName{ + "alertname", + "cluster", + "service", + }, + Routes: []*Route{ + { + Receiver: "team-X-mails", + MatchRE: map[string]Regexp{ + "service": regexpFoo, + }, + }, + }, + }, + Receivers: []*Receiver{ + { + Name: "team-X-mails", + EmailConfigs: []*EmailConfig{ + { + To: "team-X+alerts@example.org", + From: "alertmanager@example.org", + Smarthost: "localhost:25", + HTML: "{{ template \"email.default.html\" . }}", + RequireTLS: &boolFoo, + }, + }, + }, + }, + } + + config, _, err := LoadFile("testdata/conf.empty-fields.yml") + if err != nil { + t.Errorf("Error parsing %s: %s", "testdata/conf.empty-fields.yml", err) + } + + configGot, err := yaml.Marshal(config) + if err != nil { + t.Fatal("YAML Marshaling failed:", err) + } + + configExp, err := yaml.Marshal(expectedConf) + if err != nil { + t.Fatalf("%s", err) + } + + if !reflect.DeepEqual(configGot, configExp) { + t.Fatalf("%s: unexpected config result: \n\n%s\n expected\n\n%s", "testdata/conf.empty-fields.yml", configGot, configExp) + } +} + +func TestSMTPHello(t *testing.T) { + c, _, err := LoadFile("testdata/conf.good.yml") + if err != nil { + t.Errorf("Error parsing %s: %s", "testdata/conf.good.yml", err) + } + + const refValue = "host.example.org" + var hostName = c.Global.SMTPHello + if hostName != refValue { + t.Errorf("Invalid SMTP Hello hostname: %s\nExpected: %s", hostName, refValue) + } +} + +func TestVictorOpsDefaultAPIKey(t *testing.T) { + conf, _, err := LoadFile("testdata/conf.victorops-default-apikey.yml") + if err != nil { + t.Errorf("Error parsing %s: %s", "testdata/conf.victorops-default-apikey.yml", err) + } + + var defaultKey = conf.Global.VictorOpsAPIKey + if defaultKey != conf.Receivers[0].VictorOpsConfigs[0].APIKey { + t.Errorf("Invalid victorops key: %s\nExpected: %s", conf.Receivers[0].VictorOpsConfigs[0].APIKey, defaultKey) + } + if defaultKey == conf.Receivers[1].VictorOpsConfigs[0].APIKey { + t.Errorf("Invalid victorops key: %s\nExpected: %s", conf.Receivers[0].VictorOpsConfigs[0].APIKey, "qwe456") + } +} + +func TestVictorOpsNoAPIKey(t *testing.T) { + _, _, err := LoadFile("testdata/conf.victorops-no-apikey.yml") + if err == nil { + t.Errorf("Expected an error parsing %s: %s", "testdata/conf.victorops-no-apikey.yml", err) + } + if err.Error() != "no global VictorOps API Key set" { + t.Errorf("Expected: %s\nGot: %s", "no global VictorOps API Key set", err.Error()) + } +} + +func TestOpsGenieDefaultAPIKey(t *testing.T) { + conf, _, err := LoadFile("testdata/conf.opsgenie-default-apikey.yml") + if err != nil { + t.Errorf("Error parsing %s: %s", "testdata/conf.opsgenie-default-apikey.yml", err) + } + + var defaultKey = conf.Global.OpsGenieAPIKey + if defaultKey != conf.Receivers[0].OpsGenieConfigs[0].APIKey { + t.Errorf("Invalid OpsGenie key: %s\nExpected: %s", conf.Receivers[0].OpsGenieConfigs[0].APIKey, defaultKey) + } + if defaultKey == conf.Receivers[1].OpsGenieConfigs[0].APIKey { + t.Errorf("Invalid OpsGenie key: %s\nExpected: %s", conf.Receivers[0].OpsGenieConfigs[0].APIKey, "qwe456") + } +} + +func TestOpsGenieNoAPIKey(t *testing.T) { + _, _, err := LoadFile("testdata/conf.opsgenie-no-apikey.yml") + if err == nil { + t.Errorf("Expected an error parsing %s: %s", "testdata/conf.opsgenie-no-apikey.yml", err) + } + if err.Error() != "no global OpsGenie API Key set" { + t.Errorf("Expected: %s\nGot: %s", "no global OpsGenie API Key set", err.Error()) + } +} diff --git a/src/alertmanager/config/notifiers.go b/src/alertmanager/config/notifiers.go new file mode 100644 index 0000000..f7f627c --- /dev/null +++ b/src/alertmanager/config/notifiers.go @@ -0,0 +1,498 @@ +// Copyright 2015 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package config + +import ( + "fmt" + "net/url" + "strings" + "time" + + commoncfg "github.com/prometheus/common/config" +) + +var ( + // DefaultWebhookConfig defines default values for Webhook configurations. + DefaultWebhookConfig = WebhookConfig{ + NotifierConfig: NotifierConfig{ + VSendResolved: true, + }, + } + + // DefaultEmailConfig defines default values for Email configurations. + DefaultEmailConfig = EmailConfig{ + NotifierConfig: NotifierConfig{ + VSendResolved: false, + }, + HTML: `{{ template "email.default.html" . }}`, + Text: ``, + } + + // DefaultEmailSubject defines the default Subject header of an Email. + DefaultEmailSubject = `{{ template "email.default.subject" . }}` + + // DefaultPagerdutyConfig defines default values for PagerDuty configurations. + DefaultPagerdutyConfig = PagerdutyConfig{ + NotifierConfig: NotifierConfig{ + VSendResolved: true, + }, + Description: `{{ template "pagerduty.default.description" .}}`, + Client: `{{ template "pagerduty.default.client" . }}`, + ClientURL: `{{ template "pagerduty.default.clientURL" . }}`, + Details: map[string]string{ + "firing": `{{ template "pagerduty.default.instances" .Alerts.Firing }}`, + "resolved": `{{ template "pagerduty.default.instances" .Alerts.Resolved }}`, + "num_firing": `{{ .Alerts.Firing | len }}`, + "num_resolved": `{{ .Alerts.Resolved | len }}`, + }, + } + + // DefaultSlackConfig defines default values for Slack configurations. + DefaultSlackConfig = SlackConfig{ + NotifierConfig: NotifierConfig{ + VSendResolved: false, + }, + Color: `{{ if eq .Status "firing" }}danger{{ else }}good{{ end }}`, + Username: `{{ template "slack.default.username" . }}`, + Title: `{{ template "slack.default.title" . }}`, + TitleLink: `{{ template "slack.default.titlelink" . }}`, + IconEmoji: `{{ template "slack.default.iconemoji" . }}`, + IconURL: `{{ template "slack.default.iconurl" . }}`, + Pretext: `{{ template "slack.default.pretext" . }}`, + Text: `{{ template "slack.default.text" . }}`, + Fallback: `{{ template "slack.default.fallback" . }}`, + Footer: `{{ template "slack.default.footer" . }}`, + } + + // DefaultHipchatConfig defines default values for Hipchat configurations. + DefaultHipchatConfig = HipchatConfig{ + NotifierConfig: NotifierConfig{ + VSendResolved: false, + }, + Color: `{{ if eq .Status "firing" }}red{{ else }}green{{ end }}`, + From: `{{ template "hipchat.default.from" . }}`, + Notify: false, + Message: `{{ template "hipchat.default.message" . }}`, + MessageFormat: `text`, + } + + // DefaultOpsGenieConfig defines default values for OpsGenie configurations. + DefaultOpsGenieConfig = OpsGenieConfig{ + NotifierConfig: NotifierConfig{ + VSendResolved: true, + }, + Message: `{{ template "opsgenie.default.message" . }}`, + Description: `{{ template "opsgenie.default.description" . }}`, + Source: `{{ template "opsgenie.default.source" . }}`, + // TODO: Add a details field with all the alerts. + } + + // DefaultWechatConfig defines default values for wechat configurations. + DefaultWechatConfig = WechatConfig{ + NotifierConfig: NotifierConfig{ + VSendResolved: false, + }, + Message: `{{ template "wechat.default.message" . }}`, + APISecret: `{{ template "wechat.default.api_secret" . }}`, + ToUser: `{{ template "wechat.default.to_user" . }}`, + ToParty: `{{ template "wechat.default.to_party" . }}`, + ToTag: `{{ template "wechat.default.to_tag" . }}`, + AgentID: `{{ template "wechat.default.agent_id" . }}`, + } + + // DefaultVictorOpsConfig defines default values for VictorOps configurations. + DefaultVictorOpsConfig = VictorOpsConfig{ + NotifierConfig: NotifierConfig{ + VSendResolved: true, + }, + MessageType: `CRITICAL`, + StateMessage: `{{ template "victorops.default.state_message" . }}`, + EntityDisplayName: `{{ template "victorops.default.entity_display_name" . }}`, + MonitoringTool: `{{ template "victorops.default.monitoring_tool" . }}`, + } + + // DefaultPushoverConfig defines default values for Pushover configurations. + DefaultPushoverConfig = PushoverConfig{ + NotifierConfig: NotifierConfig{ + VSendResolved: true, + }, + Title: `{{ template "pushover.default.title" . }}`, + Message: `{{ template "pushover.default.message" . }}`, + URL: `{{ template "pushover.default.url" . }}`, + Priority: `{{ if eq .Status "firing" }}2{{ else }}0{{ end }}`, // emergency (firing) or normal + Retry: duration(1 * time.Minute), + Expire: duration(1 * time.Hour), + } +) + +// NotifierConfig contains base options common across all notifier configurations. +type NotifierConfig struct { + VSendResolved bool `yaml:"send_resolved" json:"send_resolved"` +} + +func (nc *NotifierConfig) SendResolved() bool { + return nc.VSendResolved +} + +// EmailConfig configures notifications via mail. +type EmailConfig struct { + NotifierConfig `yaml:",inline" json:",inline"` + + // Email address to notify. + To string `yaml:"to,omitempty" json:"to,omitempty"` + From string `yaml:"from,omitempty" json:"from,omitempty"` + Hello string `yaml:"hello,omitempty" json:"hello,omitempty"` + Smarthost string `yaml:"smarthost,omitempty" json:"smarthost,omitempty"` + AuthUsername string `yaml:"auth_username,omitempty" json:"auth_username,omitempty"` + AuthPassword Secret `yaml:"auth_password,omitempty" json:"auth_password,omitempty"` + AuthSecret Secret `yaml:"auth_secret,omitempty" json:"auth_secret,omitempty"` + AuthIdentity string `yaml:"auth_identity,omitempty" json:"auth_identity,omitempty"` + Headers map[string]string `yaml:"headers,omitempty" json:"headers,omitempty"` + HTML string `yaml:"html,omitempty" json:"html,omitempty"` + Text string `yaml:"text,omitempty" json:"text,omitempty"` + RequireTLS *bool `yaml:"require_tls,omitempty" json:"require_tls,omitempty"` +} + +// UnmarshalYAML implements the yaml.Unmarshaler interface. +func (c *EmailConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { + *c = DefaultEmailConfig + type plain EmailConfig + if err := unmarshal((*plain)(c)); err != nil { + return err + } + if c.To == "" { + return fmt.Errorf("missing to address in email config") + } + // Header names are case-insensitive, check for collisions. + normalizedHeaders := map[string]string{} + for h, v := range c.Headers { + normalized := strings.Title(h) + if _, ok := normalizedHeaders[normalized]; ok { + return fmt.Errorf("duplicate header %q in email config", normalized) + } + normalizedHeaders[normalized] = v + } + c.Headers = normalizedHeaders + + return nil +} + +// PagerdutyConfig configures notifications via PagerDuty. +type PagerdutyConfig struct { + NotifierConfig `yaml:",inline" json:",inline"` + + HTTPConfig *commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` + + ServiceKey Secret `yaml:"service_key,omitempty" json"service_key,omitempty"` + RoutingKey Secret `yaml:"routing_key,omitempty" json:"routing_key,omitempty"` + URL string `yaml:"url,omitempty" json:"url,omitempty"` + Client string `yaml:"client,omitempty" json:"client,omitempty"` + ClientURL string `yaml:"client_url,omitempty" json:"client_url,omitempty"` + Description string `yaml:"description,omitempty" json:"description,omitempty"` + Details map[string]string `yaml:"details,omitempty" json:"details,omitempty"` + Severity string `yaml:"severity,omitempty" json:"severity,omitempty"` + Class string `yaml:"class,omitempty" json:"class,omitempty"` + Component string `yaml:"component,omitempty" json:"component,omitempty"` + Group string `yaml:"group,omitempty" json:"group,omitempty"` +} + +// UnmarshalYAML implements the yaml.Unmarshaler interface. +func (c *PagerdutyConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { + *c = DefaultPagerdutyConfig + type plain PagerdutyConfig + if err := unmarshal((*plain)(c)); err != nil { + return err + } + if c.RoutingKey == "" && c.ServiceKey == "" { + return fmt.Errorf("missing service or routing key in PagerDuty config") + } + return nil +} + +// SlackAction configures a single Slack action that is sent with each notification. +// Each action must contain a type, text, and url. +// See https://api.slack.com/docs/message-attachments#action_fields for more information. +type SlackAction struct { + Type string `yaml:"type,omitempty" json:"type,omitempty"` + Text string `yaml:"text,omitempty" json:"text,omitempty"` + URL string `yaml:"url,omitempty" json:"url,omitempty"` + Style string `yaml:"style,omitempty" json:"style,omitempty"` +} + +// UnmarshalYAML implements the yaml.Unmarshaler interface for SlackAction. +func (c *SlackAction) UnmarshalYAML(unmarshal func(interface{}) error) error { + type plain SlackAction + if err := unmarshal((*plain)(c)); err != nil { + return err + } + if c.Type == "" { + return fmt.Errorf("missing type in Slack action configuration") + } + if c.Text == "" { + return fmt.Errorf("missing value in Slack text configuration") + } + if c.URL == "" { + return fmt.Errorf("missing value in Slack url configuration") + } + return nil +} + +// SlackField configures a single Slack field that is sent with each notification. +// Each field must contain a title, value, and optionally, a boolean value to indicate if the field +// is short enough to be displayed next to other fields designated as short. +// See https://api.slack.com/docs/message-attachments#fields for more information. +type SlackField struct { + Title string `yaml:"title,omitempty" json:"title,omitempty"` + Value string `yaml:"value,omitempty" json:"value,omitempty"` + Short *bool `yaml:"short,omitempty" json:"short,omitempty"` +} + +// UnmarshalYAML implements the yaml.Unmarshaler interface for SlackField. +func (c *SlackField) UnmarshalYAML(unmarshal func(interface{}) error) error { + type plain SlackField + if err := unmarshal((*plain)(c)); err != nil { + return err + } + if c.Title == "" { + return fmt.Errorf("missing title in Slack field configuration") + } + if c.Value == "" { + return fmt.Errorf("missing value in Slack field configuration") + } + return nil +} + +// SlackConfig configures notifications via Slack. +type SlackConfig struct { + NotifierConfig `yaml:",inline" json:",inline"` + + HTTPConfig *commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` + + APIURL Secret `yaml:"api_url,omitempty" json:"api_url,omitempty"` + + // Slack channel override, (like #other-channel or @username). + Channel string `yaml:"channel,omitempty" json:"channel,omitempty"` + Username string `yaml:"username,omitempty" json:"username,omitempty"` + Color string `yaml:"color,omitempty" json:"color,omitempty"` + + Title string `yaml:"title,omitempty" json:"title,omitempty"` + TitleLink string `yaml:"title_link,omitempty" json:"title_link,omitempty"` + Pretext string `yaml:"pretext,omitempty" json:"pretext,omitempty"` + Text string `yaml:"text,omitempty" json:"text,omitempty"` + Fields []*SlackField `yaml:"fields,omitempty" json:"fields,omitempty"` + ShortFields bool `yaml:"short_fields,omitempty" json:"short_fields,omitempty"` + Footer string `yaml:"footer,omitempty" json:"footer,omitempty"` + Fallback string `yaml:"fallback,omitempty" json:"fallback,omitempty"` + IconEmoji string `yaml:"icon_emoji,omitempty" json:"icon_emoji,omitempty"` + IconURL string `yaml:"icon_url,omitempty" json:"icon_url,omitempty"` + LinkNames bool `yaml:"link_names,omitempty" json:"link_names,omitempty"` + Actions []*SlackAction `yaml:"actions,omitempty" json:"actions,omitempty"` +} + +// UnmarshalYAML implements the yaml.Unmarshaler interface. +func (c *SlackConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { + *c = DefaultSlackConfig + type plain SlackConfig + return unmarshal((*plain)(c)) +} + +// HipchatConfig configures notifications via Hipchat. +type HipchatConfig struct { + NotifierConfig `yaml:",inline" json:",inline"` + + HTTPConfig *commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` + + APIURL string `yaml:"api_url,omitempty" json:"api_url,omitempty"` + AuthToken Secret `yaml:"auth_token,omitempty" json:"auth_token,omitempty"` + RoomID string `yaml:"room_id,omitempty" json:"room_id,omitempty"` + From string `yaml:"from,omitempty" json:"from,omitempty"` + Notify bool `yaml:"notify,omitempty" json:"notify,omitempty"` + Message string `yaml:"message,omitempty" json:"message,omitempty"` + MessageFormat string `yaml:"message_format,omitempty" json:"message_format,omitempty"` + Color string `yaml:"color,omitempty" json:"color,omitempty"` +} + +// UnmarshalYAML implements the yaml.Unmarshaler interface. +func (c *HipchatConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { + *c = DefaultHipchatConfig + type plain HipchatConfig + if err := unmarshal((*plain)(c)); err != nil { + return err + } + if c.RoomID == "" { + return fmt.Errorf("missing room id in Hipchat config") + } + return nil +} + +// WebhookConfig configures notifications via a generic webhook. +type WebhookConfig struct { + NotifierConfig `yaml:",inline" json:",inline"` + + HTTPConfig *commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` + + // URL to send POST request to. + URL string `yaml:"url" json:"url"` +} + +// UnmarshalYAML implements the yaml.Unmarshaler interface. +func (c *WebhookConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { + *c = DefaultWebhookConfig + type plain WebhookConfig + if err := unmarshal((*plain)(c)); err != nil { + return err + } + if c.URL == "" { + return fmt.Errorf("missing URL in webhook config") + } + url, err := url.Parse(c.URL) + if err != nil { + return err + } + if url.Scheme != "https" && url.Scheme != "http" { + return fmt.Errorf("scheme required for webhook url") + } + c.URL = url.String() + return nil +} + +// WechatConfig configures notifications via Wechat. +type WechatConfig struct { + NotifierConfig `yaml:",inline" json:",inline"` + + HTTPConfig *commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` + + APISecret Secret `yaml:"api_secret,omitempty" json:"api_secret,omitempty"` + CorpID string `yaml:"corp_id,omitempty" json:"corp_id,omitempty"` + Message string `yaml:"message,omitempty" json:"message,omitempty"` + APIURL string `yaml:"api_url,omitempty" json:"api_url,omitempty"` + ToUser string `yaml:"to_user,omitempty" json:"to_user,omitempty"` + ToParty string `yaml:"to_party,omitempty" json:"to_party,omitempty"` + ToTag string `yaml:"to_tag,omitempty" json:"to_tag,omitempty"` + AgentID string `yaml:"agent_id,omitempty" json:"agent_id,omitempty"` +} + +// UnmarshalYAML implements the yaml.Unmarshaler interface. +func (c *WechatConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { + *c = DefaultWechatConfig + type plain WechatConfig + if err := unmarshal((*plain)(c)); err != nil { + return err + } + if c.APISecret == "" { + return fmt.Errorf("missing Wechat APISecret in Wechat config") + } + if c.CorpID == "" { + return fmt.Errorf("missing Wechat CorpID in Wechat config") + } + return nil +} + +// OpsGenieConfig configures notifications via OpsGenie. +type OpsGenieConfig struct { + NotifierConfig `yaml:",inline" json:",inline"` + + HTTPConfig *commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` + + APIKey Secret `yaml:"api_key,omitempty" json:"api_key,omitempty"` + APIURL string `yaml:"api_url,omitempty" json:"api_url,omitempty"` + Message string `yaml:"message,omitempty" json:"message,omitempty"` + Description string `yaml:"description,omitempty" json:"description,omitempty"` + Source string `yaml:"source,omitempty" json:"source,omitempty"` + Details map[string]string `yaml:"details,omitempty" json:"details,omitempty"` + Teams string `yaml:"teams,omitempty" json:"teams,omitempty"` + Tags string `yaml:"tags,omitempty" json:"tags,omitempty"` + Note string `yaml:"note,omitempty" json:"note,omitempty"` + Priority string `yaml:"priority,omitempty" json:"priority,omitempty"` +} + +// UnmarshalYAML implements the yaml.Unmarshaler interface. +func (c *OpsGenieConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { + *c = DefaultOpsGenieConfig + type plain OpsGenieConfig + return unmarshal((*plain)(c)) +} + +// VictorOpsConfig configures notifications via VictorOps. +type VictorOpsConfig struct { + NotifierConfig `yaml:",inline" json:",inline"` + + HTTPConfig *commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` + + APIKey Secret `yaml:"api_key" json:"api_key"` + APIURL string `yaml:"api_url" json:"api_url"` + RoutingKey string `yaml:"routing_key" json:"routing_key"` + MessageType string `yaml:"message_type" json:"message_type"` + StateMessage string `yaml:"state_message" json:"state_message"` + EntityDisplayName string `yaml:"entity_display_name" json:"entity_display_name"` + MonitoringTool string `yaml:"monitoring_tool" json:"monitoring_tool"` +} + +// UnmarshalYAML implements the yaml.Unmarshaler interface. +func (c *VictorOpsConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { + *c = DefaultVictorOpsConfig + type plain VictorOpsConfig + if err := unmarshal((*plain)(c)); err != nil { + return err + } + if c.RoutingKey == "" { + return fmt.Errorf("missing Routing key in VictorOps config") + } + return nil +} + +type duration time.Duration + +func (d *duration) UnmarshalText(text []byte) error { + parsed, err := time.ParseDuration(string(text)) + if err == nil { + *d = duration(parsed) + } + return err +} + +func (d duration) MarshalText() ([]byte, error) { + return []byte(time.Duration(d).String()), nil +} + +type PushoverConfig struct { + NotifierConfig `yaml:",inline" json:",inline"` + + HTTPConfig *commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` + + UserKey Secret `yaml:"user_key,omitempty" json:"user_key,omitempty"` + Token Secret `yaml:"token,omitempty" json:"token,omitempty"` + Title string `yaml:"title,omitempty" json:"title,omitempty"` + Message string `yaml:"message,omitempty" json:"message,omitempty"` + URL string `yaml:"url,omitempty" json:"url,omitempty"` + Priority string `yaml:"priority,omitempty" json:"priority,omitempty"` + Retry duration `yaml:"retry,omitempty" json:"retry,omitempty"` + Expire duration `yaml:"expire,omitempty" json:"expire,omitempty"` +} + +// UnmarshalYAML implements the yaml.Unmarshaler interface. +func (c *PushoverConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { + *c = DefaultPushoverConfig + type plain PushoverConfig + if err := unmarshal((*plain)(c)); err != nil { + return err + } + if c.UserKey == "" { + return fmt.Errorf("missing user key in Pushover config") + } + if c.Token == "" { + return fmt.Errorf("missing token in Pushover config") + } + return nil +} diff --git a/src/alertmanager/config/notifiers_test.go b/src/alertmanager/config/notifiers_test.go new file mode 100644 index 0000000..859337c --- /dev/null +++ b/src/alertmanager/config/notifiers_test.go @@ -0,0 +1,385 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package config + +import ( + "strings" + "testing" + + "gopkg.in/yaml.v2" +) + +func TestEmailToIsPresent(t *testing.T) { + in := ` +to: '' +` + var cfg EmailConfig + err := yaml.UnmarshalStrict([]byte(in), &cfg) + + expected := "missing to address in email config" + + if err == nil { + t.Fatalf("no error returned, expected:\n%v", expected) + } + if err.Error() != expected { + t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) + } +} + +func TestEmailHeadersCollision(t *testing.T) { + in := ` +to: 'to@email.com' +headers: + Subject: 'Alert' + subject: 'New Alert' +` + var cfg EmailConfig + err := yaml.UnmarshalStrict([]byte(in), &cfg) + + expected := "duplicate header \"Subject\" in email config" + + if err == nil { + t.Fatalf("no error returned, expected:\n%v", expected) + } + if err.Error() != expected { + t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) + } +} + +func TestPagerdutyRoutingKeyIsPresent(t *testing.T) { + in := ` +routing_key: '' +` + var cfg PagerdutyConfig + err := yaml.UnmarshalStrict([]byte(in), &cfg) + + expected := "missing service or routing key in PagerDuty config" + + if err == nil { + t.Fatalf("no error returned, expected:\n%v", expected) + } + if err.Error() != expected { + t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) + } +} + +func TestPagerdutyServiceKeyIsPresent(t *testing.T) { + in := ` +service_key: '' +` + var cfg PagerdutyConfig + err := yaml.UnmarshalStrict([]byte(in), &cfg) + + expected := "missing service or routing key in PagerDuty config" + + if err == nil { + t.Fatalf("no error returned, expected:\n%v", expected) + } + if err.Error() != expected { + t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) + } +} + +func TestHipchatRoomIDIsPresent(t *testing.T) { + in := ` +room_id: '' +` + var cfg HipchatConfig + err := yaml.UnmarshalStrict([]byte(in), &cfg) + + expected := "missing room id in Hipchat config" + + if err == nil { + t.Fatalf("no error returned, expected:\n%v", expected) + } + if err.Error() != expected { + t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) + } +} + +func TestWebhookURLIsPresent(t *testing.T) { + in := ` +url: '' +` + var cfg WebhookConfig + err := yaml.UnmarshalStrict([]byte(in), &cfg) + + expected := "missing URL in webhook config" + + if err == nil { + t.Fatalf("no error returned, expected:\n%v", expected) + } + if err.Error() != expected { + t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) + } +} + +func TestWebhookHttpConfigIsValid(t *testing.T) { + in := ` +url: 'http://example.com' +http_config: + bearer_token: foo + bearer_token_file: /tmp/bar +` + var cfg WebhookConfig + err := yaml.UnmarshalStrict([]byte(in), &cfg) + + expected := "at most one of bearer_token & bearer_token_file must be configured" + + if err == nil { + t.Fatalf("no error returned, expected:\n%v", expected) + } + if err.Error() != expected { + t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) + } +} + +func TestWebhookHttpConfigIsOptional(t *testing.T) { + in := ` +url: 'http://example.com' +` + var cfg WebhookConfig + err := yaml.UnmarshalStrict([]byte(in), &cfg) + + if err != nil { + t.Fatalf("no error expected, returned:\n%v", err.Error()) + } +} + +func TestWebhookPasswordIsObsfucated(t *testing.T) { + in := ` +url: 'http://example.com' +http_config: + basic_auth: + username: foo + password: supersecret +` + var cfg WebhookConfig + err := yaml.UnmarshalStrict([]byte(in), &cfg) + + if err != nil { + t.Fatalf("no error expected, returned:\n%v", err.Error()) + } + + ycfg, err := yaml.Marshal(cfg) + if err != nil { + t.Fatalf("no error expected, returned:\n%v", err.Error()) + } + if strings.Contains(string(ycfg), "supersecret") { + t.Errorf("Found password in the YAML cfg: %s\n", ycfg) + } +} + +func TestWechatAPIKeyIsPresent(t *testing.T) { + in := ` +api_secret: '' +` + var cfg WechatConfig + err := yaml.UnmarshalStrict([]byte(in), &cfg) + + expected := "missing Wechat APISecret in Wechat config" + + if err == nil { + t.Fatalf("no error returned, expected:\n%v", expected) + } + if err.Error() != expected { + t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) + } +} +func TestWechatCorpIDIsPresent(t *testing.T) { + in := ` +api_secret: 'api_secret' +corp_id: '' +` + var cfg WechatConfig + err := yaml.UnmarshalStrict([]byte(in), &cfg) + + expected := "missing Wechat CorpID in Wechat config" + + if err == nil { + t.Fatalf("no error returned, expected:\n%v", expected) + } + if err.Error() != expected { + t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) + } +} + +func TestVictorOpsRoutingKeyIsPresent(t *testing.T) { + in := ` +routing_key: '' +` + var cfg VictorOpsConfig + err := yaml.UnmarshalStrict([]byte(in), &cfg) + + expected := "missing Routing key in VictorOps config" + + if err == nil { + t.Fatalf("no error returned, expected:\n%v", expected) + } + if err.Error() != expected { + t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) + } +} + +func TestPushoverUserKeyIsPresent(t *testing.T) { + in := ` +user_key: '' +` + var cfg PushoverConfig + err := yaml.UnmarshalStrict([]byte(in), &cfg) + + expected := "missing user key in Pushover config" + + if err == nil { + t.Fatalf("no error returned, expected:\n%v", expected) + } + if err.Error() != expected { + t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) + } +} + +func TestPushoverTokenIsPresent(t *testing.T) { + in := ` +user_key: '' +token: '' +` + var cfg PushoverConfig + err := yaml.UnmarshalStrict([]byte(in), &cfg) + + expected := "missing token in Pushover config" + + if err == nil { + t.Fatalf("no error returned, expected:\n%v", expected) + } + if err.Error() != expected { + t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) + } +} + +func TestSlackFieldConfigValidation(t *testing.T) { + var tests = []struct { + in string + expected string + }{ + { + in: ` +fields: +- title: first + value: hello +- title: second +`, + expected: "missing value in Slack field configuration", + }, + { + in: ` +fields: +- title: first + value: hello + short: true +- value: world + short: true +`, + expected: "missing title in Slack field configuration", + }, + { + in: ` +fields: +- title: first + value: hello + short: true +- title: second + value: world +`, + expected: "", + }, + } + + for _, rt := range tests { + var cfg SlackConfig + err := yaml.UnmarshalStrict([]byte(rt.in), &cfg) + + // Check if an error occurred when it was NOT expected to. + if rt.expected == "" && err != nil { + t.Fatalf("\nerror returned when none expected, error:\n%v", err) + } + // Check that an error occurred if one was expected to. + if rt.expected != "" && err == nil { + t.Fatalf("\nno error returned, expected:\n%v", rt.expected) + } + // Check that the error that occurred was what was expected. + if err != nil && err.Error() != rt.expected { + t.Errorf("\nexpected:\n%v\ngot:\n%v", rt.expected, err.Error()) + } + } +} + +func TestSlackFieldConfigUnmarshalling(t *testing.T) { + in := ` +fields: +- title: first + value: hello + short: true +- title: second + value: world +- title: third + value: slack field test + short: false +` + expected := []*SlackField{ + &SlackField{ + Title: "first", + Value: "hello", + Short: newBoolPointer(true), + }, + &SlackField{ + Title: "second", + Value: "world", + Short: nil, + }, + &SlackField{ + Title: "third", + Value: "slack field test", + Short: newBoolPointer(false), + }, + } + + var cfg SlackConfig + err := yaml.UnmarshalStrict([]byte(in), &cfg) + if err != nil { + t.Fatalf("\nerror returned when none expected, error:\n%v", err) + } + + for index, field := range cfg.Fields { + exp := expected[index] + if field.Title != exp.Title { + t.Errorf("\nexpected:\n%v\ngot:\n%v", exp.Title, field.Title) + } + if field.Value != exp.Value { + t.Errorf("\nexpected:\n%v\ngot:\n%v", exp.Value, field.Value) + } + if exp.Short == nil && field.Short != nil { + t.Errorf("\nexpected:\n%v\ngot:\n%v", exp.Short, *field.Short) + } + if exp.Short != nil && field.Short == nil { + t.Errorf("\nexpected:\n%v\ngot:\n%v", *exp.Short, field.Short) + } + if exp.Short != nil && *exp.Short != *field.Short { + t.Errorf("\nexpected:\n%v\ngot:\n%v", *exp.Short, *field.Short) + } + } +} + +func newBoolPointer(b bool) *bool { + return &b +} diff --git a/src/alertmanager/dispatch/dispatch.go b/src/alertmanager/dispatch/dispatch.go new file mode 100644 index 0000000..3c1a882 --- /dev/null +++ b/src/alertmanager/dispatch/dispatch.go @@ -0,0 +1,457 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package dispatch + +import ( + "fmt" + "sort" + "sync" + "time" + + "github.com/go-kit/kit/log" + "github.com/go-kit/kit/log/level" + "github.com/prometheus/common/model" + "github.com/prometheus/prometheus/pkg/labels" + "golang.org/x/net/context" + + "github.com/prometheus/alertmanager/notify" + "github.com/prometheus/alertmanager/provider" + "github.com/prometheus/alertmanager/types" +) + +// Dispatcher sorts incoming alerts into aggregation groups and +// assigns the correct notifiers to each. +type Dispatcher struct { + route *Route + alerts provider.Alerts + stage notify.Stage + + marker types.Marker + timeout func(time.Duration) time.Duration + + aggrGroups map[*Route]map[model.Fingerprint]*aggrGroup + mtx sync.RWMutex + + done chan struct{} + ctx context.Context + cancel func() + + logger log.Logger +} + +// NewDispatcher returns a new Dispatcher. +func NewDispatcher( + ap provider.Alerts, + r *Route, + s notify.Stage, + mk types.Marker, + to func(time.Duration) time.Duration, + l log.Logger, +) *Dispatcher { + disp := &Dispatcher{ + alerts: ap, + stage: s, + route: r, + marker: mk, + timeout: to, + logger: log.With(l, "component", "dispatcher"), + } + return disp +} + +// Run starts dispatching alerts incoming via the updates channel. +func (d *Dispatcher) Run() { + d.done = make(chan struct{}) + + d.mtx.Lock() + d.aggrGroups = map[*Route]map[model.Fingerprint]*aggrGroup{} + d.mtx.Unlock() + + d.ctx, d.cancel = context.WithCancel(context.Background()) + + d.run(d.alerts.Subscribe()) + close(d.done) +} + +// AlertBlock contains a list of alerts associated with a set of +// routing options. +type AlertBlock struct { + RouteOpts *RouteOpts `json:"routeOpts"` + Alerts []*APIAlert `json:"alerts"` +} + +// APIAlert is the API representation of an alert, which is a regular alert +// annotated with silencing and inhibition info. +type APIAlert struct { + *model.Alert + Status types.AlertStatus `json:"status"` + Receivers []string `json:"receivers"` + Fingerprint string `json:"fingerprint"` +} + +// AlertGroup is a list of alert blocks grouped by the same label set. +type AlertGroup struct { + Labels model.LabelSet `json:"labels"` + GroupKey string `json:"groupKey"` + Blocks []*AlertBlock `json:"blocks"` +} + +// AlertOverview is a representation of all active alerts in the system. +type AlertOverview []*AlertGroup + +func (ao AlertOverview) Swap(i, j int) { ao[i], ao[j] = ao[j], ao[i] } +func (ao AlertOverview) Less(i, j int) bool { return ao[i].Labels.Before(ao[j].Labels) } +func (ao AlertOverview) Len() int { return len(ao) } + +func matchesFilterLabels(a *APIAlert, matchers []*labels.Matcher) bool { + for _, m := range matchers { + if v, prs := a.Labels[model.LabelName(m.Name)]; !prs || !m.Matches(string(v)) { + return false + } + } + + return true +} + +// Groups populates an AlertOverview from the dispatcher's internal state. +func (d *Dispatcher) Groups(matchers []*labels.Matcher) AlertOverview { + overview := AlertOverview{} + + d.mtx.RLock() + defer d.mtx.RUnlock() + + seen := map[model.Fingerprint]*AlertGroup{} + + for route, ags := range d.aggrGroups { + for _, ag := range ags { + alertGroup, ok := seen[ag.fingerprint()] + if !ok { + alertGroup = &AlertGroup{Labels: ag.labels} + alertGroup.GroupKey = ag.GroupKey() + + seen[ag.fingerprint()] = alertGroup + } + + now := time.Now() + + var apiAlerts []*APIAlert + for _, a := range types.Alerts(ag.alertSlice()...) { + if !a.EndsAt.IsZero() && a.EndsAt.Before(now) { + continue + } + status := d.marker.Status(a.Fingerprint()) + aa := &APIAlert{ + Alert: a, + Status: status, + Fingerprint: a.Fingerprint().String(), + } + + if !matchesFilterLabels(aa, matchers) { + continue + } + + apiAlerts = append(apiAlerts, aa) + } + if len(apiAlerts) == 0 { + continue + } + + alertGroup.Blocks = append(alertGroup.Blocks, &AlertBlock{ + RouteOpts: &route.RouteOpts, + Alerts: apiAlerts, + }) + + overview = append(overview, alertGroup) + } + } + + sort.Sort(overview) + + return overview +} + +func (d *Dispatcher) run(it provider.AlertIterator) { + cleanup := time.NewTicker(30 * time.Second) + defer cleanup.Stop() + + defer it.Close() + + for { + select { + case alert, ok := <-it.Next(): + if !ok { + // Iterator exhausted for some reason. + if err := it.Err(); err != nil { + level.Error(d.logger).Log("msg", "Error on alert update", "err", err) + } + return + } + + level.Debug(d.logger).Log("msg", "Received alert", "alert", alert) + + // Log errors but keep trying. + if err := it.Err(); err != nil { + level.Error(d.logger).Log("msg", "Error on alert update", "err", err) + continue + } + + for _, r := range d.route.Match(alert.Labels) { + d.processAlert(alert, r) + } + + case <-cleanup.C: + d.mtx.Lock() + + for _, groups := range d.aggrGroups { + for _, ag := range groups { + if ag.empty() { + ag.stop() + delete(groups, ag.fingerprint()) + } + } + } + + d.mtx.Unlock() + + case <-d.ctx.Done(): + return + } + } +} + +// Stop the dispatcher. +func (d *Dispatcher) Stop() { + if d == nil || d.cancel == nil { + return + } + d.cancel() + d.cancel = nil + + <-d.done +} + +// notifyFunc is a function that performs notifcation for the alert +// with the given fingerprint. It aborts on context cancelation. +// Returns false iff notifying failed. +type notifyFunc func(context.Context, ...*types.Alert) bool + +// processAlert determines in which aggregation group the alert falls +// and inserts it. +func (d *Dispatcher) processAlert(alert *types.Alert, route *Route) { + groupLabels := model.LabelSet{} + + for ln, lv := range alert.Labels { + if _, ok := route.RouteOpts.GroupBy[ln]; ok { + groupLabels[ln] = lv + } + } + + fp := groupLabels.Fingerprint() + + d.mtx.Lock() + group, ok := d.aggrGroups[route] + if !ok { + group = map[model.Fingerprint]*aggrGroup{} + d.aggrGroups[route] = group + } + d.mtx.Unlock() + + // If the group does not exist, create it. + ag, ok := group[fp] + if !ok { + ag = newAggrGroup(d.ctx, groupLabels, route, d.timeout, d.logger) + group[fp] = ag + + go ag.run(func(ctx context.Context, alerts ...*types.Alert) bool { + _, _, err := d.stage.Exec(ctx, d.logger, alerts...) + if err != nil { + level.Error(d.logger).Log("msg", "Notify for alerts failed", "num_alerts", len(alerts), "err", err) + } + return err == nil + }) + } + + ag.insert(alert) +} + +// aggrGroup aggregates alert fingerprints into groups to which a +// common set of routing options applies. +// It emits notifications in the specified intervals. +type aggrGroup struct { + labels model.LabelSet + opts *RouteOpts + logger log.Logger + routeKey string + + ctx context.Context + cancel func() + done chan struct{} + next *time.Timer + timeout func(time.Duration) time.Duration + + mtx sync.RWMutex + alerts map[model.Fingerprint]*types.Alert + hasFlushed bool +} + +// newAggrGroup returns a new aggregation group. +func newAggrGroup(ctx context.Context, labels model.LabelSet, r *Route, to func(time.Duration) time.Duration, logger log.Logger) *aggrGroup { + if to == nil { + to = func(d time.Duration) time.Duration { return d } + } + ag := &aggrGroup{ + labels: labels, + routeKey: r.Key(), + opts: &r.RouteOpts, + timeout: to, + alerts: map[model.Fingerprint]*types.Alert{}, + } + ag.ctx, ag.cancel = context.WithCancel(ctx) + + ag.logger = log.With(logger, "aggrGroup", ag) + + // Set an initial one-time wait before flushing + // the first batch of notifications. + ag.next = time.NewTimer(ag.opts.GroupWait) + + return ag +} + +func (ag *aggrGroup) fingerprint() model.Fingerprint { + return ag.labels.Fingerprint() +} + +func (ag *aggrGroup) GroupKey() string { + return fmt.Sprintf("%s:%s", ag.routeKey, ag.labels) +} + +func (ag *aggrGroup) String() string { + return ag.GroupKey() +} + +func (ag *aggrGroup) alertSlice() []*types.Alert { + ag.mtx.RLock() + defer ag.mtx.RUnlock() + + var alerts []*types.Alert + for _, a := range ag.alerts { + alerts = append(alerts, a) + } + return alerts +} + +func (ag *aggrGroup) run(nf notifyFunc) { + ag.done = make(chan struct{}) + + defer close(ag.done) + defer ag.next.Stop() + + for { + select { + case now := <-ag.next.C: + // Give the notifications time until the next flush to + // finish before terminating them. + ctx, cancel := context.WithTimeout(ag.ctx, ag.timeout(ag.opts.GroupInterval)) + + // The now time we retrieve from the ticker is the only reliable + // point of time reference for the subsequent notification pipeline. + // Calculating the current time directly is prone to flaky behavior, + // which usually only becomes apparent in tests. + ctx = notify.WithNow(ctx, now) + + // Populate context with information needed along the pipeline. + ctx = notify.WithGroupKey(ctx, ag.GroupKey()) + ctx = notify.WithGroupLabels(ctx, ag.labels) + ctx = notify.WithReceiverName(ctx, ag.opts.Receiver) + ctx = notify.WithRepeatInterval(ctx, ag.opts.RepeatInterval) + + // Wait the configured interval before calling flush again. + ag.mtx.Lock() + ag.next.Reset(ag.opts.GroupInterval) + ag.hasFlushed = true + ag.mtx.Unlock() + + ag.flush(func(alerts ...*types.Alert) bool { + return nf(ctx, alerts...) + }) + + cancel() + + case <-ag.ctx.Done(): + return + } + } +} + +func (ag *aggrGroup) stop() { + // Calling cancel will terminate all in-process notifications + // and the run() loop. + ag.cancel() + <-ag.done +} + +// insert inserts the alert into the aggregation group. +func (ag *aggrGroup) insert(alert *types.Alert) { + ag.mtx.Lock() + defer ag.mtx.Unlock() + + ag.alerts[alert.Fingerprint()] = alert + + // Immediately trigger a flush if the wait duration for this + // alert is already over. + if !ag.hasFlushed && alert.StartsAt.Add(ag.opts.GroupWait).Before(time.Now()) { + ag.next.Reset(0) + } +} + +func (ag *aggrGroup) empty() bool { + ag.mtx.RLock() + defer ag.mtx.RUnlock() + + return len(ag.alerts) == 0 +} + +// flush sends notifications for all new alerts. +func (ag *aggrGroup) flush(notify func(...*types.Alert) bool) { + if ag.empty() { + return + } + ag.mtx.Lock() + + var ( + alerts = make(map[model.Fingerprint]*types.Alert, len(ag.alerts)) + alertsSlice = make(types.AlertSlice, 0, len(ag.alerts)) + ) + for fp, alert := range ag.alerts { + alerts[fp] = alert + alertsSlice = append(alertsSlice, alert) + } + sort.Stable(alertsSlice) + + ag.mtx.Unlock() + + level.Debug(ag.logger).Log("msg", "Flushing", "alerts", fmt.Sprintf("%v", alertsSlice)) + + if notify(alertsSlice...) { + ag.mtx.Lock() + for fp, a := range alerts { + // Only delete if the fingerprint has not been inserted + // again since we notified about it. + if a.Resolved() && ag.alerts[fp] == a { + delete(ag.alerts, fp) + } + } + ag.mtx.Unlock() + } +} diff --git a/src/alertmanager/dispatch/dispatch_test.go b/src/alertmanager/dispatch/dispatch_test.go new file mode 100644 index 0000000..32f5f83 --- /dev/null +++ b/src/alertmanager/dispatch/dispatch_test.go @@ -0,0 +1,317 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package dispatch + +import ( + "reflect" + "sort" + "sync" + "testing" + "time" + + "github.com/go-kit/kit/log" + "github.com/prometheus/common/model" + "github.com/prometheus/prometheus/pkg/labels" + "golang.org/x/net/context" + + "github.com/prometheus/alertmanager/notify" + "github.com/prometheus/alertmanager/types" +) + +func newAPIAlert(labels model.LabelSet) APIAlert { + return APIAlert{ + Alert: &model.Alert{ + Labels: labels, + StartsAt: time.Now().Add(1 * time.Minute), + EndsAt: time.Now().Add(1 * time.Hour), + }, + } +} + +func TestFilterLabels(t *testing.T) { + + var ( + a1 = newAPIAlert(model.LabelSet{ + "a": "v1", + "b": "v2", + "c": "v3", + }) + a2 = newAPIAlert(model.LabelSet{ + "a": "v1", + "b": "v2", + "c": "v4", + }) + a3 = newAPIAlert(model.LabelSet{ + "a": "v1", + "b": "v2", + "c": "v5", + }) + a4 = newAPIAlert(model.LabelSet{ + "foo": "bar", + "baz": "qux", + }) + alertsSlices = []struct { + in, want []APIAlert + }{ + { + in: []APIAlert{a1, a2, a3}, + want: []APIAlert{a1, a2, a3}, + }, + { + in: []APIAlert{a1, a4}, + want: []APIAlert{a1}, + }, + { + in: []APIAlert{a4}, + want: []APIAlert{}, + }, + } + ) + + matcher, err := labels.NewMatcher(labels.MatchRegexp, "c", "v.*") + if err != nil { + t.Fatalf("error making matcher: %v", err) + } + matcher2, err := labels.NewMatcher(labels.MatchEqual, "a", "v1") + if err != nil { + t.Fatalf("error making matcher: %v", err) + } + + matchers := []*labels.Matcher{matcher, matcher2} + + for _, alerts := range alertsSlices { + got := []APIAlert{} + for _, a := range alerts.in { + if matchesFilterLabels(&a, matchers) { + got = append(got, a) + } + } + if !reflect.DeepEqual(got, alerts.want) { + t.Fatalf("error: returned alerts do not match:\ngot %v\nwant %v", got, alerts.want) + } + } +} + +func TestAggrGroup(t *testing.T) { + lset := model.LabelSet{ + "a": "v1", + "b": "v2", + } + opts := &RouteOpts{ + Receiver: "n1", + GroupBy: map[model.LabelName]struct{}{}, + GroupWait: 1 * time.Second, + GroupInterval: 300 * time.Millisecond, + RepeatInterval: 1 * time.Hour, + } + route := &Route{ + RouteOpts: *opts, + } + + var ( + a1 = &types.Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{ + "a": "v1", + "b": "v2", + "c": "v3", + }, + StartsAt: time.Now().Add(time.Minute), + EndsAt: time.Now().Add(time.Hour), + }, + UpdatedAt: time.Now(), + } + a2 = &types.Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{ + "a": "v1", + "b": "v2", + "c": "v4", + }, + StartsAt: time.Now().Add(-time.Hour), + EndsAt: time.Now().Add(2 * time.Hour), + }, + UpdatedAt: time.Now(), + } + a3 = &types.Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{ + "a": "v1", + "b": "v2", + "c": "v5", + }, + StartsAt: time.Now().Add(time.Minute), + EndsAt: time.Now().Add(5 * time.Minute), + }, + UpdatedAt: time.Now(), + } + ) + + var ( + last = time.Now() + current = time.Now() + lastCurMtx = &sync.Mutex{} + alertsCh = make(chan types.AlertSlice) + ) + + ntfy := func(ctx context.Context, alerts ...*types.Alert) bool { + // Validate that the context is properly populated. + if _, ok := notify.Now(ctx); !ok { + t.Errorf("now missing") + } + if _, ok := notify.GroupKey(ctx); !ok { + t.Errorf("group key missing") + } + if lbls, ok := notify.GroupLabels(ctx); !ok || !reflect.DeepEqual(lbls, lset) { + t.Errorf("wrong group labels: %q", lbls) + } + if rcv, ok := notify.ReceiverName(ctx); !ok || rcv != opts.Receiver { + t.Errorf("wrong receiver: %q", rcv) + } + if ri, ok := notify.RepeatInterval(ctx); !ok || ri != opts.RepeatInterval { + t.Errorf("wrong repeat interval: %q", ri) + } + + lastCurMtx.Lock() + last = current + current = time.Now() + lastCurMtx.Unlock() + + alertsCh <- types.AlertSlice(alerts) + + return true + } + + // Test regular situation where we wait for group_wait to send out alerts. + ag := newAggrGroup(context.Background(), lset, route, nil, log.NewNopLogger()) + go ag.run(ntfy) + + ag.insert(a1) + + select { + case <-time.After(2 * opts.GroupWait): + t.Fatalf("expected initial batch after group_wait") + + case batch := <-alertsCh: + if s := time.Since(last); s < opts.GroupWait { + t.Fatalf("received batch too early after %v", s) + } + exp := types.AlertSlice{a1} + sort.Sort(batch) + + if !reflect.DeepEqual(batch, exp) { + t.Fatalf("expected alerts %v but got %v", exp, batch) + } + } + + for i := 0; i < 3; i++ { + // New alert should come in after group interval. + ag.insert(a3) + + select { + case <-time.After(2 * opts.GroupInterval): + t.Fatalf("expected new batch after group interval but received none") + + case batch := <-alertsCh: + if s := time.Since(last); s < opts.GroupInterval { + t.Fatalf("received batch too early after %v", s) + } + exp := types.AlertSlice{a1, a3} + sort.Sort(batch) + + if !reflect.DeepEqual(batch, exp) { + t.Fatalf("expected alerts %v but got %v", exp, batch) + } + } + } + + ag.stop() + + // Add an alert that started more than group_interval in the past. We expect + // immediate flushing. + // Finally, set all alerts to be resolved. After successful notify the aggregation group + // should empty itself. + ag = newAggrGroup(context.Background(), lset, route, nil, log.NewNopLogger()) + go ag.run(ntfy) + + ag.insert(a1) + ag.insert(a2) + + // a2 lies way in the past so the initial group_wait should be skipped. + select { + case <-time.After(opts.GroupWait / 2): + t.Fatalf("expected immediate alert but received none") + + case batch := <-alertsCh: + exp := types.AlertSlice{a1, a2} + sort.Sort(batch) + + if !reflect.DeepEqual(batch, exp) { + t.Fatalf("expected alerts %v but got %v", exp, batch) + } + } + + for i := 0; i < 3; i++ { + // New alert should come in after group interval. + ag.insert(a3) + + select { + case <-time.After(2 * opts.GroupInterval): + t.Fatalf("expected new batch after group interval but received none") + + case batch := <-alertsCh: + lastCurMtx.Lock() + s := time.Since(last) + lastCurMtx.Unlock() + if s < opts.GroupInterval { + t.Fatalf("received batch too early after %v", s) + } + exp := types.AlertSlice{a1, a2, a3} + sort.Sort(batch) + + if !reflect.DeepEqual(batch, exp) { + t.Fatalf("expected alerts %v but got %v", exp, batch) + } + } + } + + // Resolve all alerts, they should be removed after the next batch was sent. + a1r, a2r, a3r := *a1, *a2, *a3 + resolved := types.AlertSlice{&a1r, &a2r, &a3r} + for _, a := range resolved { + a.EndsAt = time.Now() + ag.insert(a) + } + + select { + case <-time.After(2 * opts.GroupInterval): + t.Fatalf("expected new batch after group interval but received none") + + case batch := <-alertsCh: + if s := time.Since(last); s < opts.GroupInterval { + t.Fatalf("received batch too early after %v", s) + } + sort.Sort(batch) + + if !reflect.DeepEqual(batch, resolved) { + t.Fatalf("expected alerts %v but got %v", resolved, batch) + } + + if !ag.empty() { + t.Fatalf("Expected aggregation group to be empty after resolving alerts: %v", ag) + } + } + + ag.stop() +} diff --git a/src/alertmanager/dispatch/route.go b/src/alertmanager/dispatch/route.go new file mode 100644 index 0000000..add2afb --- /dev/null +++ b/src/alertmanager/dispatch/route.go @@ -0,0 +1,195 @@ +// Copyright 2015 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package dispatch + +import ( + "encoding/json" + "fmt" + "sort" + "time" + + "github.com/prometheus/common/model" + + "github.com/prometheus/alertmanager/config" + "github.com/prometheus/alertmanager/types" +) + +// DefaultRouteOpts are the defaulting routing options which apply +// to the root route of a routing tree. +var DefaultRouteOpts = RouteOpts{ + GroupWait: 30 * time.Second, + GroupInterval: 5 * time.Minute, + RepeatInterval: 4 * time.Hour, + GroupBy: map[model.LabelName]struct{}{}, +} + +// A Route is a node that contains definitions of how to handle alerts. +type Route struct { + parent *Route + + // The configuration parameters for matches of this route. + RouteOpts RouteOpts + + // Equality or regex matchers an alert has to fulfill to match + // this route. + Matchers types.Matchers + + // If true, an alert matches further routes on the same level. + Continue bool + + // Children routes of this route. + Routes []*Route +} + +// NewRoute returns a new route. +func NewRoute(cr *config.Route, parent *Route) *Route { + // Create default and overwrite with configured settings. + opts := DefaultRouteOpts + if parent != nil { + opts = parent.RouteOpts + } + + if cr.Receiver != "" { + opts.Receiver = cr.Receiver + } + if cr.GroupBy != nil { + opts.GroupBy = map[model.LabelName]struct{}{} + for _, ln := range cr.GroupBy { + opts.GroupBy[ln] = struct{}{} + } + } + if cr.GroupWait != nil { + opts.GroupWait = time.Duration(*cr.GroupWait) + } + if cr.GroupInterval != nil { + opts.GroupInterval = time.Duration(*cr.GroupInterval) + } + if cr.RepeatInterval != nil { + opts.RepeatInterval = time.Duration(*cr.RepeatInterval) + } + + // Build matchers. + var matchers types.Matchers + + for ln, lv := range cr.Match { + matchers = append(matchers, types.NewMatcher(model.LabelName(ln), lv)) + } + for ln, lv := range cr.MatchRE { + matchers = append(matchers, types.NewRegexMatcher(model.LabelName(ln), lv.Regexp)) + } + sort.Sort(matchers) + + route := &Route{ + parent: parent, + RouteOpts: opts, + Matchers: matchers, + Continue: cr.Continue, + } + + route.Routes = NewRoutes(cr.Routes, route) + + return route +} + +// NewRoutes returns a slice of routes. +func NewRoutes(croutes []*config.Route, parent *Route) []*Route { + res := []*Route{} + for _, cr := range croutes { + res = append(res, NewRoute(cr, parent)) + } + return res +} + +// Match does a depth-first left-to-right search through the route tree +// and returns the matching routing nodes. +func (r *Route) Match(lset model.LabelSet) []*Route { + if !r.Matchers.Match(lset) { + return nil + } + + var all []*Route + + for _, cr := range r.Routes { + matches := cr.Match(lset) + + all = append(all, matches...) + + if matches != nil && !cr.Continue { + break + } + } + + // If no child nodes were matches, the current node itself is a match. + if len(all) == 0 { + all = append(all, r) + } + + return all +} + +// Key returns a key for the route. It does not uniquely identify a the route in general. +func (r *Route) Key() string { + b := make([]byte, 0, 1024) + + if r.parent != nil { + b = append(b, r.parent.Key()...) + b = append(b, '/') + } + return string(append(b, r.Matchers.String()...)) +} + +// RouteOpts holds various routing options necessary for processing alerts +// that match a given route. +type RouteOpts struct { + // The identifier of the associated notification configuration. + Receiver string + + // What labels to group alerts by for notifications. + GroupBy map[model.LabelName]struct{} + + // How long to wait to group matching alerts before sending + // a notification. + GroupWait time.Duration + GroupInterval time.Duration + RepeatInterval time.Duration +} + +func (ro *RouteOpts) String() string { + var labels []model.LabelName + for ln := range ro.GroupBy { + labels = append(labels, ln) + } + return fmt.Sprintf("", ro.Receiver, labels, ro.GroupWait, ro.GroupInterval) +} + +// MarshalJSON returns a JSON representation of the routing options. +func (ro *RouteOpts) MarshalJSON() ([]byte, error) { + v := struct { + Receiver string `json:"receiver"` + GroupBy model.LabelNames `json:"groupBy"` + GroupWait time.Duration `json:"groupWait"` + GroupInterval time.Duration `json:"groupInterval"` + RepeatInterval time.Duration `json:"repeatInterval"` + }{ + Receiver: ro.Receiver, + GroupWait: ro.GroupWait, + GroupInterval: ro.GroupInterval, + RepeatInterval: ro.RepeatInterval, + } + for ln := range ro.GroupBy { + v.GroupBy = append(v.GroupBy, ln) + } + + return json.Marshal(&v) +} diff --git a/src/alertmanager/dispatch/route_test.go b/src/alertmanager/dispatch/route_test.go new file mode 100644 index 0000000..396c41a --- /dev/null +++ b/src/alertmanager/dispatch/route_test.go @@ -0,0 +1,260 @@ +// Copyright 2015 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package dispatch + +import ( + "reflect" + "testing" + "time" + + "github.com/prometheus/common/model" + "gopkg.in/yaml.v2" + + "github.com/prometheus/alertmanager/config" +) + +func TestRouteMatch(t *testing.T) { + in := ` +receiver: 'notify-def' + +routes: +- match: + owner: 'team-A' + + receiver: 'notify-A' + + routes: + - match: + env: 'testing' + + receiver: 'notify-testing' + group_by: [] + + - match: + env: "production" + + receiver: 'notify-productionA' + group_wait: 1m + + continue: true + + - match_re: + env: "produ.*" + job: ".*" + + receiver: 'notify-productionB' + group_wait: 30s + group_interval: 5m + repeat_interval: 1h + group_by: ['job'] + + +- match_re: + owner: 'team-(B|C)' + + group_by: ['foo', 'bar'] + group_wait: 2m + receiver: 'notify-BC' + +- match: + group_by: 'role' + group_by: ['role'] + + routes: + - match: + env: 'testing' + receiver: 'notify-testing' + routes: + - match: + wait: 'long' + group_wait: 2m +` + + var ctree config.Route + if err := yaml.UnmarshalStrict([]byte(in), &ctree); err != nil { + t.Fatal(err) + } + var ( + def = DefaultRouteOpts + tree = NewRoute(&ctree, nil) + ) + lset := func(labels ...string) map[model.LabelName]struct{} { + s := map[model.LabelName]struct{}{} + for _, ls := range labels { + s[model.LabelName(ls)] = struct{}{} + } + return s + } + + tests := []struct { + input model.LabelSet + result []*RouteOpts + keys []string + }{ + { + input: model.LabelSet{ + "owner": "team-A", + }, + result: []*RouteOpts{ + { + Receiver: "notify-A", + GroupBy: def.GroupBy, + GroupWait: def.GroupWait, + GroupInterval: def.GroupInterval, + RepeatInterval: def.RepeatInterval, + }, + }, + keys: []string{"{}/{owner=\"team-A\"}"}, + }, + { + input: model.LabelSet{ + "owner": "team-A", + "env": "unset", + }, + result: []*RouteOpts{ + { + Receiver: "notify-A", + GroupBy: def.GroupBy, + GroupWait: def.GroupWait, + GroupInterval: def.GroupInterval, + RepeatInterval: def.RepeatInterval, + }, + }, + keys: []string{"{}/{owner=\"team-A\"}"}, + }, + { + input: model.LabelSet{ + "owner": "team-C", + }, + result: []*RouteOpts{ + { + Receiver: "notify-BC", + GroupBy: lset("foo", "bar"), + GroupWait: 2 * time.Minute, + GroupInterval: def.GroupInterval, + RepeatInterval: def.RepeatInterval, + }, + }, + keys: []string{"{}/{owner=~\"^(?:team-(B|C))$\"}"}, + }, + { + input: model.LabelSet{ + "owner": "team-A", + "env": "testing", + }, + result: []*RouteOpts{ + { + Receiver: "notify-testing", + GroupBy: lset(), + GroupWait: def.GroupWait, + GroupInterval: def.GroupInterval, + RepeatInterval: def.RepeatInterval, + }, + }, + keys: []string{"{}/{owner=\"team-A\"}/{env=\"testing\"}"}, + }, + { + input: model.LabelSet{ + "owner": "team-A", + "env": "production", + }, + result: []*RouteOpts{ + { + Receiver: "notify-productionA", + GroupBy: def.GroupBy, + GroupWait: 1 * time.Minute, + GroupInterval: def.GroupInterval, + RepeatInterval: def.RepeatInterval, + }, + { + Receiver: "notify-productionB", + GroupBy: lset("job"), + GroupWait: 30 * time.Second, + GroupInterval: 5 * time.Minute, + RepeatInterval: 1 * time.Hour, + }, + }, + keys: []string{ + "{}/{owner=\"team-A\"}/{env=\"production\"}", + "{}/{owner=\"team-A\"}/{env=~\"^(?:produ.*)$\",job=~\"^(?:.*)$\"}", + }, + }, + { + input: model.LabelSet{ + "group_by": "role", + }, + result: []*RouteOpts{ + { + Receiver: "notify-def", + GroupBy: lset("role"), + GroupWait: def.GroupWait, + GroupInterval: def.GroupInterval, + RepeatInterval: def.RepeatInterval, + }, + }, + keys: []string{"{}/{group_by=\"role\"}"}, + }, + { + input: model.LabelSet{ + "env": "testing", + "group_by": "role", + }, + result: []*RouteOpts{ + { + Receiver: "notify-testing", + GroupBy: lset("role"), + GroupWait: def.GroupWait, + GroupInterval: def.GroupInterval, + RepeatInterval: def.RepeatInterval, + }, + }, + keys: []string{"{}/{group_by=\"role\"}/{env=\"testing\"}"}, + }, + { + input: model.LabelSet{ + "env": "testing", + "group_by": "role", + "wait": "long", + }, + result: []*RouteOpts{ + { + Receiver: "notify-testing", + GroupBy: lset("role"), + GroupWait: 2 * time.Minute, + GroupInterval: def.GroupInterval, + RepeatInterval: def.RepeatInterval, + }, + }, + keys: []string{"{}/{group_by=\"role\"}/{env=\"testing\"}/{wait=\"long\"}"}, + }, + } + + for _, test := range tests { + var matches []*RouteOpts + var keys []string + + for _, r := range tree.Match(test.input) { + matches = append(matches, &r.RouteOpts) + keys = append(keys, r.Key()) + } + + if !reflect.DeepEqual(matches, test.result) { + t.Errorf("\nexpected:\n%v\ngot:\n%v", test.result, matches) + } + + if !reflect.DeepEqual(keys, test.keys) { + t.Errorf("\nexpected:\n%v\ngot:\n%v", test.keys, keys) + } + } +} diff --git a/src/alertmanager/doc/arch.svg b/src/alertmanager/doc/arch.svg new file mode 100644 index 0000000..d163923 --- /dev/null +++ b/src/alertmanager/doc/arch.svg @@ -0,0 +1,2 @@ + +
Notification Pipeline
Notification Pipeline
Receiver
E-Mail
[Not supported by viewer]
Set Notifies
Set Notifies
Receiver
Webhook
[Not supported by viewer]
Dispatcher
Dispatcher<br>
Gossip
Settle
[Not supported by viewer]
API
API
Alert Generators
(Prometheus)
[Not supported by viewer]
Silence Provider
Silence Provider
Silencer
Silencer
Router
Router
Wait
Wait
Wait
Wait
Already
sent?
Already<br>sent?
Retry
Retry
Dedup
Dedup
Retry
Retry
Set Notifies
Set Notifies
Notify Provider
Notify Provider
Alert Provider
Alert Provider
Subscribe
Subscribe
Inhibitor
Inhibitor
Cluster
Cluster<br>
Peers
Peers
Store
Store
Store
Store
Silences
Silences
Notification
Logs
Notification<br>Logs
Dedup
Dedup
High Availability mode
High Availability mode<br>
Aggregate
Aggregate
Group
Group
Group
Group
...
...
. . .
. . . \ No newline at end of file diff --git a/src/alertmanager/doc/arch.xml b/src/alertmanager/doc/arch.xml new file mode 100644 index 0000000..682e709 --- /dev/null +++ b/src/alertmanager/doc/arch.xml @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/src/alertmanager/doc/examples/simple.yml b/src/alertmanager/doc/examples/simple.yml new file mode 100644 index 0000000..caf5d1b --- /dev/null +++ b/src/alertmanager/doc/examples/simple.yml @@ -0,0 +1,124 @@ +global: + # The smarthost and SMTP sender used for mail notifications. + smtp_smarthost: 'localhost:25' + smtp_from: 'alertmanager@example.org' + smtp_auth_username: 'alertmanager' + smtp_auth_password: 'password' + # The auth token for Hipchat. + hipchat_auth_token: '1234556789' + # Alternative host for Hipchat. + hipchat_api_url: 'https://hipchat.foobar.org/' + +# The directory from which notification templates are read. +templates: +- '/etc/alertmanager/template/*.tmpl' + +# The root route on which each incoming alert enters. +route: + # The labels by which incoming alerts are grouped together. For example, + # multiple alerts coming in for cluster=A and alertname=LatencyHigh would + # be batched into a single group. + group_by: ['alertname', 'cluster', 'service'] + + # When a new group of alerts is created by an incoming alert, wait at + # least 'group_wait' to send the initial notification. + # This way ensures that you get multiple alerts for the same group that start + # firing shortly after another are batched together on the first + # notification. + group_wait: 30s + + # When the first notification was sent, wait 'group_interval' to send a batch + # of new alerts that started firing for that group. + group_interval: 5m + + # If an alert has successfully been sent, wait 'repeat_interval' to + # resend them. + repeat_interval: 3h + + # A default receiver + receiver: team-X-mails + + # All the above attributes are inherited by all child routes and can + # overwritten on each. + + # The child route trees. + routes: + # This routes performs a regular expression match on alert labels to + # catch alerts that are related to a list of services. + - match_re: + service: ^(foo1|foo2|baz)$ + receiver: team-X-mails + # The service has a sub-route for critical alerts, any alerts + # that do not match, i.e. severity != critical, fall-back to the + # parent node and are sent to 'team-X-mails' + routes: + - match: + severity: critical + receiver: team-X-pager + - match: + service: files + receiver: team-Y-mails + + routes: + - match: + severity: critical + receiver: team-Y-pager + + # This route handles all alerts coming from a database service. If there's + # no team to handle it, it defaults to the DB team. + - match: + service: database + receiver: team-DB-pager + # Also group alerts by affected database. + group_by: [alertname, cluster, database] + routes: + - match: + owner: team-X + receiver: team-X-pager + - match: + owner: team-Y + receiver: team-Y-pager + + +# Inhibition rules allow to mute a set of alerts given that another alert is +# firing. +# We use this to mute any warning-level notifications if the same alert is +# already critical. +inhibit_rules: +- source_match: + severity: 'critical' + target_match: + severity: 'warning' + # Apply inhibition if the alertname is the same. + equal: ['alertname', 'cluster', 'service'] + + +receivers: +- name: 'team-X-mails' + email_configs: + - to: 'team-X+alerts@example.org' + +- name: 'team-X-pager' + email_configs: + - to: 'team-X+alerts-critical@example.org' + pagerduty_configs: + - service_key: + +- name: 'team-Y-mails' + email_configs: + - to: 'team-Y+alerts@example.org' + +- name: 'team-Y-pager' + pagerduty_configs: + - service_key: + +- name: 'team-DB-pager' + pagerduty_configs: + - service_key: + +- name: 'team-X-hipchat' + hipchat_configs: + - auth_token: + room_id: 85 + message_format: html + notify: true diff --git a/src/alertmanager/examples/ha/send_alerts.sh b/src/alertmanager/examples/ha/send_alerts.sh new file mode 100755 index 0000000..13ec227 --- /dev/null +++ b/src/alertmanager/examples/ha/send_alerts.sh @@ -0,0 +1,66 @@ +alerts1='[ + { + "labels": { + "alertname": "DiskRunningFull", + "dev": "sda1", + "instance": "example1" + }, + "annotations": { + "info": "The disk sda1 is running full", + "summary": "please check the instance example1" + } + }, + { + "labels": { + "alertname": "DiskRunningFull", + "dev": "sda2", + "instance": "example1" + }, + "annotations": { + "info": "The disk sda2 is running full", + "summary": "please check the instance example1", + "runbook": "the following link http://test-url should be clickable" + } + }, + { + "labels": { + "alertname": "DiskRunningFull", + "dev": "sda1", + "instance": "example2" + }, + "annotations": { + "info": "The disk sda1 is running full", + "summary": "please check the instance example2" + } + }, + { + "labels": { + "alertname": "DiskRunningFull", + "dev": "sdb2", + "instance": "example2" + }, + "annotations": { + "info": "The disk sdb2 is running full", + "summary": "please check the instance example2" + } + }, + { + "labels": { + "alertname": "DiskRunningFull", + "dev": "sda1", + "instance": "example3", + "severity": "critical" + } + }, + { + "labels": { + "alertname": "DiskRunningFull", + "dev": "sda1", + "instance": "example3", + "severity": "warning" + } + } +]' +curl -XPOST -d"$alerts1" http://localhost:9093/api/v1/alerts +curl -XPOST -d"$alerts1" http://localhost:9094/api/v1/alerts +curl -XPOST -d"$alerts1" http://localhost:9095/api/v1/alerts diff --git a/src/alertmanager/examples/webhook/echo.go b/src/alertmanager/examples/webhook/echo.go new file mode 100644 index 0000000..56dcd0e --- /dev/null +++ b/src/alertmanager/examples/webhook/echo.go @@ -0,0 +1,37 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package main + +import ( + "bytes" + "encoding/json" + "io/ioutil" + "log" + "net/http" +) + +func main() { + http.ListenAndServe(":5001", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + b, err := ioutil.ReadAll(r.Body) + if err != nil { + panic(err) + } + defer r.Body.Close() + var buf bytes.Buffer + if err := json.Indent(&buf, b, " >", " "); err != nil { + panic(err) + } + log.Println(buf.String()) + })) +} diff --git a/src/alertmanager/inhibit/inhibit.go b/src/alertmanager/inhibit/inhibit.go new file mode 100644 index 0000000..80575ec --- /dev/null +++ b/src/alertmanager/inhibit/inhibit.go @@ -0,0 +1,246 @@ +// Copyright 2015 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package inhibit + +import ( + "context" + "sync" + "time" + + "github.com/go-kit/kit/log" + "github.com/go-kit/kit/log/level" + "github.com/oklog/oklog/pkg/group" + "github.com/prometheus/common/model" + + "github.com/prometheus/alertmanager/config" + "github.com/prometheus/alertmanager/provider" + "github.com/prometheus/alertmanager/types" +) + +// An Inhibitor determines whether a given label set is muted +// based on the currently active alerts and a set of inhibition rules. +type Inhibitor struct { + alerts provider.Alerts + rules []*InhibitRule + marker types.Marker + logger log.Logger + + mtx sync.RWMutex + cancel func() +} + +// NewInhibitor returns a new Inhibitor. +func NewInhibitor(ap provider.Alerts, rs []*config.InhibitRule, mk types.Marker, logger log.Logger) *Inhibitor { + ih := &Inhibitor{ + alerts: ap, + marker: mk, + logger: logger, + } + for _, cr := range rs { + r := NewInhibitRule(cr) + ih.rules = append(ih.rules, r) + } + return ih +} + +func (ih *Inhibitor) runGC(ctx context.Context) { + for { + select { + case <-time.After(15 * time.Minute): + for _, r := range ih.rules { + r.gc() + } + case <-ctx.Done(): + return + } + } +} + +func (ih *Inhibitor) run(ctx context.Context) { + it := ih.alerts.Subscribe() + defer it.Close() + + for { + select { + case <-ctx.Done(): + return + case a := <-it.Next(): + if err := it.Err(); err != nil { + level.Error(ih.logger).Log("msg", "Error iterating alerts", "err", err) + continue + } + // Update the inhibition rules' cache. + for _, r := range ih.rules { + if r.SourceMatchers.Match(a.Labels) { + r.set(a) + } + } + } + } +} + +// Run the Inihibitor's background processing. +func (ih *Inhibitor) Run() { + var ( + g group.Group + ctx context.Context + ) + + ih.mtx.Lock() + ctx, ih.cancel = context.WithCancel(context.Background()) + ih.mtx.Unlock() + gcCtx, gcCancel := context.WithCancel(ctx) + runCtx, runCancel := context.WithCancel(ctx) + + g.Add(func() error { + ih.runGC(gcCtx) + return nil + }, func(err error) { + gcCancel() + }) + g.Add(func() error { + ih.run(runCtx) + return nil + }, func(err error) { + runCancel() + }) + + g.Run() +} + +// Stop the Inhibitor's background processing. +func (ih *Inhibitor) Stop() { + if ih == nil { + return + } + + ih.mtx.RLock() + defer ih.mtx.RUnlock() + if ih.cancel != nil { + ih.cancel() + } +} + +// Mutes returns true iff the given label set is muted. +func (ih *Inhibitor) Mutes(lset model.LabelSet) bool { + fp := lset.Fingerprint() + + for _, r := range ih.rules { + // Only inhibit if target matchers match but source matchers don't. + if inhibitedByFP, eq := r.hasEqual(lset); !r.SourceMatchers.Match(lset) && r.TargetMatchers.Match(lset) && eq { + ih.marker.SetInhibited(fp, inhibitedByFP.String()) + return true + } + } + ih.marker.SetInhibited(fp) + + return false +} + +// An InhibitRule specifies that a class of (source) alerts should inhibit +// notifications for another class of (target) alerts if all specified matching +// labels are equal between the two alerts. This may be used to inhibit alerts +// from sending notifications if their meaning is logically a subset of a +// higher-level alert. +type InhibitRule struct { + // The set of Filters which define the group of source alerts (which inhibit + // the target alerts). + SourceMatchers types.Matchers + // The set of Filters which define the group of target alerts (which are + // inhibited by the source alerts). + TargetMatchers types.Matchers + // A set of label names whose label values need to be identical in source and + // target alerts in order for the inhibition to take effect. + Equal map[model.LabelName]struct{} + + mtx sync.RWMutex + // Cache of alerts matching source labels. + scache map[model.Fingerprint]*types.Alert +} + +// NewInhibitRule returns a new InihibtRule based on a configuration definition. +func NewInhibitRule(cr *config.InhibitRule) *InhibitRule { + var ( + sourcem types.Matchers + targetm types.Matchers + ) + + for ln, lv := range cr.SourceMatch { + sourcem = append(sourcem, types.NewMatcher(model.LabelName(ln), lv)) + } + for ln, lv := range cr.SourceMatchRE { + sourcem = append(sourcem, types.NewRegexMatcher(model.LabelName(ln), lv.Regexp)) + } + + for ln, lv := range cr.TargetMatch { + targetm = append(targetm, types.NewMatcher(model.LabelName(ln), lv)) + } + for ln, lv := range cr.TargetMatchRE { + targetm = append(targetm, types.NewRegexMatcher(model.LabelName(ln), lv.Regexp)) + } + + equal := map[model.LabelName]struct{}{} + for _, ln := range cr.Equal { + equal[ln] = struct{}{} + } + + return &InhibitRule{ + SourceMatchers: sourcem, + TargetMatchers: targetm, + Equal: equal, + scache: map[model.Fingerprint]*types.Alert{}, + } +} + +// set the alert in the source cache. +func (r *InhibitRule) set(a *types.Alert) { + r.mtx.Lock() + defer r.mtx.Unlock() + + r.scache[a.Fingerprint()] = a +} + +// hasEqual checks whether the source cache contains alerts matching +// the equal labels for the given label set. +func (r *InhibitRule) hasEqual(lset model.LabelSet) (model.Fingerprint, bool) { + r.mtx.RLock() + defer r.mtx.RUnlock() + +Outer: + for fp, a := range r.scache { + // The cache might be stale and contain resolved alerts. + if a.Resolved() { + continue + } + for n := range r.Equal { + if a.Labels[n] != lset[n] { + continue Outer + } + } + return fp, true + } + return model.Fingerprint(0), false +} + +// gc clears out resolved alerts from the source cache. +func (r *InhibitRule) gc() { + r.mtx.Lock() + defer r.mtx.Unlock() + + for fp, a := range r.scache { + if a.Resolved() { + delete(r.scache, fp) + } + } +} diff --git a/src/alertmanager/inhibit/inhibit_test.go b/src/alertmanager/inhibit/inhibit_test.go new file mode 100644 index 0000000..d269c06 --- /dev/null +++ b/src/alertmanager/inhibit/inhibit_test.go @@ -0,0 +1,385 @@ +// Copyright 2016 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package inhibit + +import ( + "reflect" + "testing" + "time" + + "github.com/go-kit/kit/log" + "github.com/kylelemons/godebug/pretty" + "github.com/prometheus/common/model" + + "github.com/prometheus/alertmanager/config" + "github.com/prometheus/alertmanager/provider" + "github.com/prometheus/alertmanager/types" +) + +var nopLogger = log.NewNopLogger() + +func TestInhibitRuleHasEqual(t *testing.T) { + t.Parallel() + + now := time.Now() + cases := []struct { + initial map[model.Fingerprint]*types.Alert + equal model.LabelNames + input model.LabelSet + result bool + }{ + { + // No source alerts at all. + initial: map[model.Fingerprint]*types.Alert{}, + input: model.LabelSet{"a": "b"}, + result: false, + }, + { + // No equal labels, any source alerts satisfies the requirement. + initial: map[model.Fingerprint]*types.Alert{1: &types.Alert{}}, + input: model.LabelSet{"a": "b"}, + result: true, + }, + { + // Matching but already resolved. + initial: map[model.Fingerprint]*types.Alert{ + 1: &types.Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{"a": "b", "b": "f"}, + StartsAt: now.Add(-time.Minute), + EndsAt: now.Add(-time.Second), + }, + }, + 2: &types.Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{"a": "b", "b": "c"}, + StartsAt: now.Add(-time.Minute), + EndsAt: now.Add(-time.Second), + }, + }, + }, + equal: model.LabelNames{"a", "b"}, + input: model.LabelSet{"a": "b", "b": "c"}, + result: false, + }, + { + // Matching and unresolved. + initial: map[model.Fingerprint]*types.Alert{ + 1: &types.Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{"a": "b", "c": "d"}, + StartsAt: now.Add(-time.Minute), + EndsAt: now.Add(-time.Second), + }, + }, + 2: &types.Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{"a": "b", "c": "f"}, + StartsAt: now.Add(-time.Minute), + EndsAt: now.Add(time.Hour), + }, + }, + }, + equal: model.LabelNames{"a"}, + input: model.LabelSet{"a": "b"}, + result: true, + }, + { + // Equal label does not match. + initial: map[model.Fingerprint]*types.Alert{ + 1: &types.Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{"a": "c", "c": "d"}, + StartsAt: now.Add(-time.Minute), + EndsAt: now.Add(-time.Second), + }, + }, + 2: &types.Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{"a": "c", "c": "f"}, + StartsAt: now.Add(-time.Minute), + EndsAt: now.Add(-time.Second), + }, + }, + }, + equal: model.LabelNames{"a"}, + input: model.LabelSet{"a": "b"}, + result: false, + }, + } + + for _, c := range cases { + r := &InhibitRule{ + Equal: map[model.LabelName]struct{}{}, + scache: map[model.Fingerprint]*types.Alert{}, + } + for _, ln := range c.equal { + r.Equal[ln] = struct{}{} + } + for k, v := range c.initial { + r.scache[k] = v + } + + if _, have := r.hasEqual(c.input); have != c.result { + t.Errorf("Unexpected result %t, expected %t", have, c.result) + } + if !reflect.DeepEqual(r.scache, c.initial) { + t.Errorf("Cache state unexpectedly changed") + t.Errorf(pretty.Compare(r.scache, c.initial)) + } + } +} + +func TestInhibitRuleMatches(t *testing.T) { + t.Parallel() + + // Simple inhibut rule + cr := config.InhibitRule{ + SourceMatch: map[string]string{"s": "1"}, + TargetMatch: map[string]string{"t": "1"}, + Equal: model.LabelNames{"e"}, + } + m := types.NewMarker() + ih := NewInhibitor(nil, []*config.InhibitRule{&cr}, m, nopLogger) + ir := ih.rules[0] + now := time.Now() + // Active alert that matches the source filter + sourceAlert := types.Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{"s": "1", "e": "1"}, + StartsAt: now.Add(-time.Minute), + EndsAt: now.Add(time.Hour), + }, + } + ir.scache = map[model.Fingerprint]*types.Alert{1: &sourceAlert} + + cases := []struct { + target model.LabelSet + expected bool + }{ + { + // Matches target filter, inhibited + target: model.LabelSet{"t": "1", "e": "1"}, + expected: true, + }, + { + // Matches target filter (plus noise), inhibited + target: model.LabelSet{"t": "1", "t2": "1", "e": "1"}, + expected: true, + }, + { + // Doesn't match target filter, not inhibited + target: model.LabelSet{"t": "0", "e": "1"}, + expected: false, + }, + { + // Matches both source and target filters, not inhibited + target: model.LabelSet{"s": "1", "t": "1", "e": "1"}, + expected: false, + }, + { + // Matches target filter, equal label doesn't match, not inhibited + target: model.LabelSet{"t": "1", "e": "0"}, + expected: false, + }, + } + + for _, c := range cases { + if actual := ih.Mutes(c.target); actual != c.expected { + t.Errorf("Expected (*Inhibitor).Mutes(%v) to return %t but got %t", c.target, c.expected, actual) + } + } +} + +func TestInhibitRuleGC(t *testing.T) { + // TODO(fabxc): add now() injection function to Resolved() to remove + // dependency on machine time in this test. + now := time.Now() + newAlert := func(start, end time.Duration) *types.Alert { + return &types.Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{"a": "b"}, + StartsAt: now.Add(start * time.Minute), + EndsAt: now.Add(end * time.Minute), + }, + } + } + + before := map[model.Fingerprint]*types.Alert{ + 0: newAlert(-10, -5), + 1: newAlert(10, 20), + 2: newAlert(-10, 10), + 3: newAlert(-10, -1), + } + after := map[model.Fingerprint]*types.Alert{ + 1: newAlert(10, 20), + 2: newAlert(-10, 10), + } + + r := &InhibitRule{scache: before} + r.gc() + + if !reflect.DeepEqual(r.scache, after) { + t.Errorf("Unexpected cache state after GC") + t.Errorf(pretty.Compare(r.scache, after)) + } +} + +type fakeAlerts struct { + alerts []*types.Alert + finished chan struct{} +} + +func newFakeAlerts(alerts []*types.Alert) *fakeAlerts { + return &fakeAlerts{ + alerts: alerts, + finished: make(chan struct{}), + } +} + +func (f *fakeAlerts) GetPending() provider.AlertIterator { return nil } +func (f *fakeAlerts) Get(model.Fingerprint) (*types.Alert, error) { return nil, nil } +func (f *fakeAlerts) Put(...*types.Alert) error { return nil } +func (f *fakeAlerts) Subscribe() provider.AlertIterator { + ch := make(chan *types.Alert) + done := make(chan struct{}) + go func() { + for _, a := range f.alerts { + ch <- a + } + // Send another (meaningless) alert to make sure that the inhibitor has + // processed everything. + ch <- &types.Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{}, + StartsAt: time.Now(), + }, + } + close(f.finished) + <-done + }() + return provider.NewAlertIterator(ch, done, nil) +} + +func TestInhibit(t *testing.T) { + t.Parallel() + + now := time.Now() + inhibitRule := func() *config.InhibitRule { + return &config.InhibitRule{ + SourceMatch: map[string]string{"s": "1"}, + TargetMatch: map[string]string{"t": "1"}, + Equal: model.LabelNames{"e"}, + } + } + // alertOne is muted by alertTwo when it is active. + alertOne := func() *types.Alert { + return &types.Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{"t": "1", "e": "f"}, + StartsAt: now.Add(-time.Minute), + EndsAt: now.Add(time.Hour), + }, + } + } + alertTwo := func(resolved bool) *types.Alert { + var end time.Time + if resolved { + end = now.Add(-time.Second) + } else { + end = now.Add(time.Hour) + } + return &types.Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{"s": "1", "e": "f"}, + StartsAt: now.Add(-time.Minute), + EndsAt: end, + }, + } + } + + type exp struct { + lbls model.LabelSet + muted bool + } + for i, tc := range []struct { + alerts []*types.Alert + expected []exp + }{ + { + // alertOne shouldn't be muted since alertTwo hasn't fired. + alerts: []*types.Alert{alertOne()}, + expected: []exp{ + { + lbls: model.LabelSet{"t": "1", "e": "f"}, + muted: false, + }, + }, + }, + { + // alertOne should be muted by alertTwo which is active. + alerts: []*types.Alert{alertOne(), alertTwo(false)}, + expected: []exp{ + { + lbls: model.LabelSet{"t": "1", "e": "f"}, + muted: true, + }, + { + lbls: model.LabelSet{"s": "1", "e": "f"}, + muted: false, + }, + }, + }, + { + // alertOne shouldn't be muted since alertTwo is resolved. + alerts: []*types.Alert{alertOne(), alertTwo(false), alertTwo(true)}, + expected: []exp{ + { + lbls: model.LabelSet{"t": "1", "e": "f"}, + muted: false, + }, + { + lbls: model.LabelSet{"s": "1", "e": "f"}, + muted: false, + }, + }, + }, + } { + ap := newFakeAlerts(tc.alerts) + mk := types.NewMarker() + inhibitor := NewInhibitor(ap, []*config.InhibitRule{inhibitRule()}, mk, nopLogger) + + go func() { + for ap.finished != nil { + select { + case <-ap.finished: + ap.finished = nil + default: + } + } + inhibitor.Stop() + }() + inhibitor.Run() + + for _, expected := range tc.expected { + if inhibitor.Mutes(expected.lbls) != expected.muted { + mute := "unmuted" + if expected.muted { + mute = "muted" + } + t.Errorf("tc: %d, expected alert with labels %q to be %s", i, expected.lbls, mute) + } + } + } +} diff --git a/src/alertmanager/nflog/nflog.go b/src/alertmanager/nflog/nflog.go new file mode 100644 index 0000000..1b65fb1 --- /dev/null +++ b/src/alertmanager/nflog/nflog.go @@ -0,0 +1,578 @@ +// Copyright 2016 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package nflog implements a garbage-collected and snapshottable append-only log of +// active/resolved notifications. Each log entry stores the active/resolved state, +// the notified receiver, and a hash digest of the notification's identifying contents. +// The log can be queried along different parameters. +package nflog + +import ( + "bytes" + "errors" + "fmt" + "io" + "math/rand" + "os" + "sync" + "time" + + "github.com/go-kit/kit/log" + "github.com/go-kit/kit/log/level" + "github.com/matttproud/golang_protobuf_extensions/pbutil" + "github.com/prometheus/alertmanager/cluster" + pb "github.com/prometheus/alertmanager/nflog/nflogpb" + "github.com/prometheus/client_golang/prometheus" +) + +// ErrNotFound is returned for empty query results. +var ErrNotFound = errors.New("not found") + +// ErrInvalidState is returned if the state isn't valid. +var ErrInvalidState = fmt.Errorf("invalid state") + +// query currently allows filtering by and/or receiver group key. +// It is configured via QueryParameter functions. +// +// TODO(fabxc): Future versions could allow querying a certain receiver +// group or a given time interval. +type query struct { + recv *pb.Receiver + groupKey string +} + +// QueryParam is a function that modifies a query to incorporate +// a set of parameters. Returns an error for invalid or conflicting +// parameters. +type QueryParam func(*query) error + +// QReceiver adds a receiver parameter to a query. +func QReceiver(r *pb.Receiver) QueryParam { + return func(q *query) error { + q.recv = r + return nil + } +} + +// QGroupKey adds a group key as querying argument. +func QGroupKey(gk string) QueryParam { + return func(q *query) error { + q.groupKey = gk + return nil + } +} + +type Log struct { + logger log.Logger + metrics *metrics + now func() time.Time + retention time.Duration + + runInterval time.Duration + snapf string + stopc chan struct{} + done func() + + // For now we only store the most recently added log entry. + // The key is a serialized concatenation of group key and receiver. + mtx sync.RWMutex + st state + broadcast func([]byte) +} + +type metrics struct { + gcDuration prometheus.Summary + snapshotDuration prometheus.Summary + snapshotSize prometheus.Gauge + queriesTotal prometheus.Counter + queryErrorsTotal prometheus.Counter + queryDuration prometheus.Histogram + propagatedMessagesTotal prometheus.Counter +} + +func newMetrics(r prometheus.Registerer) *metrics { + m := &metrics{} + + m.gcDuration = prometheus.NewSummary(prometheus.SummaryOpts{ + Name: "alertmanager_nflog_gc_duration_seconds", + Help: "Duration of the last notification log garbage collection cycle.", + }) + m.snapshotDuration = prometheus.NewSummary(prometheus.SummaryOpts{ + Name: "alertmanager_nflog_snapshot_duration_seconds", + Help: "Duration of the last notification log snapshot.", + }) + m.snapshotSize = prometheus.NewGauge(prometheus.GaugeOpts{ + Name: "alertmanager_nflog_snapshot_size_bytes", + Help: "Size of the last notification log snapshot in bytes.", + }) + m.queriesTotal = prometheus.NewCounter(prometheus.CounterOpts{ + Name: "alertmanager_nflog_queries_total", + Help: "Number of notification log queries were received.", + }) + m.queryErrorsTotal = prometheus.NewCounter(prometheus.CounterOpts{ + Name: "alertmanager_nflog_query_errors_total", + Help: "Number notification log received queries that failed.", + }) + m.queryDuration = prometheus.NewHistogram(prometheus.HistogramOpts{ + Name: "alertmanager_nflog_query_duration_seconds", + Help: "Duration of notification log query evaluation.", + }) + m.propagatedMessagesTotal = prometheus.NewCounter(prometheus.CounterOpts{ + Name: "alertmanager_nflog_gossip_messages_propagated_total", + Help: "Number of received gossip messages that have been further gossiped.", + }) + + if r != nil { + r.MustRegister( + m.gcDuration, + m.snapshotDuration, + m.snapshotSize, + m.queriesTotal, + m.queryErrorsTotal, + m.queryDuration, + m.propagatedMessagesTotal, + ) + } + return m +} + +// Option configures a new Log implementation. +type Option func(*Log) error + +// WithRetention sets the retention time for log st. +func WithRetention(d time.Duration) Option { + return func(l *Log) error { + l.retention = d + return nil + } +} + +// WithNow overwrites the function used to retrieve a timestamp +// for the current point in time. +// This is generally useful for injection during tests. +func WithNow(f func() time.Time) Option { + return func(l *Log) error { + l.now = f + return nil + } +} + +// WithLogger configures a logger for the notification log. +func WithLogger(logger log.Logger) Option { + return func(l *Log) error { + l.logger = logger + return nil + } +} + +// WithMetrics registers metrics for the notification log. +func WithMetrics(r prometheus.Registerer) Option { + return func(l *Log) error { + l.metrics = newMetrics(r) + return nil + } +} + +// WithMaintenance configures the Log to run garbage collection +// and snapshotting, if configured, at the given interval. +// +// The maintenance terminates on receiving from the provided channel. +// The done function is called after the final snapshot was completed. +func WithMaintenance(d time.Duration, stopc chan struct{}, done func()) Option { + return func(l *Log) error { + if d == 0 { + return fmt.Errorf("maintenance interval must not be 0") + } + l.runInterval = d + l.stopc = stopc + l.done = done + return nil + } +} + +// WithSnapshot configures the log to be initialized from a given snapshot file. +// If maintenance is configured, a snapshot will be saved periodically and on +// shutdown as well. +func WithSnapshot(sf string) Option { + return func(l *Log) error { + l.snapf = sf + return nil + } +} + +func utcNow() time.Time { + return time.Now().UTC() +} + +type state map[string]*pb.MeshEntry + +func (s state) clone() state { + c := make(state, len(s)) + for k, v := range s { + c[k] = v + } + return c +} + +// merge returns true or false whether the MeshEntry was merged or +// not. This information is used to decide to gossip the message further. +func (s state) merge(e *pb.MeshEntry) bool { + k := stateKey(string(e.Entry.GroupKey), e.Entry.Receiver) + + prev, ok := s[k] + if !ok || prev.Entry.Timestamp.Before(e.Entry.Timestamp) { + s[k] = e + return true + } + return false +} + +func (s state) MarshalBinary() ([]byte, error) { + var buf bytes.Buffer + + for _, e := range s { + if _, err := pbutil.WriteDelimited(&buf, e); err != nil { + return nil, err + } + } + return buf.Bytes(), nil +} + +func decodeState(r io.Reader) (state, error) { + st := state{} + for { + var e pb.MeshEntry + _, err := pbutil.ReadDelimited(r, &e) + if err == nil { + if e.Entry == nil || e.Entry.Receiver == nil { + return nil, ErrInvalidState + } + st[stateKey(string(e.Entry.GroupKey), e.Entry.Receiver)] = &e + continue + } + if err == io.EOF { + break + } + return nil, err + } + return st, nil +} + +func marshalMeshEntry(e *pb.MeshEntry) ([]byte, error) { + var buf bytes.Buffer + if _, err := pbutil.WriteDelimited(&buf, e); err != nil { + return nil, err + } + return buf.Bytes(), nil +} + +// New creates a new notification log based on the provided options. +// The snapshot is loaded into the Log if it is set. +func New(opts ...Option) (*Log, error) { + l := &Log{ + logger: log.NewNopLogger(), + now: utcNow, + st: state{}, + broadcast: func([]byte) {}, + } + for _, o := range opts { + if err := o(l); err != nil { + return nil, err + } + } + if l.metrics == nil { + l.metrics = newMetrics(nil) + } + + if l.snapf != "" { + if f, err := os.Open(l.snapf); !os.IsNotExist(err) { + if err != nil { + return l, err + } + defer f.Close() + + if err := l.loadSnapshot(f); err != nil { + return l, err + } + } + } + + go l.run() + + return l, nil +} + +// run periodic background maintenance. +func (l *Log) run() { + if l.runInterval == 0 || l.stopc == nil { + return + } + t := time.NewTicker(l.runInterval) + defer t.Stop() + + if l.done != nil { + defer l.done() + } + + f := func() error { + start := l.now() + var size int64 + + level.Debug(l.logger).Log("msg", "Running maintenance") + defer func() { + level.Debug(l.logger).Log("msg", "Maintenance done", "duration", l.now().Sub(start), "size", size) + l.metrics.snapshotSize.Set(float64(size)) + }() + + if _, err := l.GC(); err != nil { + return err + } + if l.snapf == "" { + return nil + } + f, err := openReplace(l.snapf) + if err != nil { + return err + } + if size, err = l.Snapshot(f); err != nil { + return err + } + return f.Close() + } + +Loop: + for { + select { + case <-l.stopc: + break Loop + case <-t.C: + if err := f(); err != nil { + level.Error(l.logger).Log("msg", "Running maintenance failed", "err", err) + } + } + } + // No need to run final maintenance if we don't want to snapshot. + if l.snapf == "" { + return + } + if err := f(); err != nil { + level.Error(l.logger).Log("msg", "Creating shutdown snapshot failed", "err", err) + } +} + +func receiverKey(r *pb.Receiver) string { + return fmt.Sprintf("%s/%s/%d", r.GroupName, r.Integration, r.Idx) +} + +// stateKey returns a string key for a log entry consisting of the group key +// and receiver. +func stateKey(k string, r *pb.Receiver) string { + return fmt.Sprintf("%s:%s", k, receiverKey(r)) +} + +func (l *Log) Log(r *pb.Receiver, gkey string, firingAlerts, resolvedAlerts []uint64) error { + // Write all st with the same timestamp. + now := l.now() + key := stateKey(gkey, r) + + l.mtx.Lock() + defer l.mtx.Unlock() + + if prevle, ok := l.st[key]; ok { + // Entry already exists, only overwrite if timestamp is newer. + // This may happen with raciness or clock-drift across AM nodes. + if prevle.Entry.Timestamp.After(now) { + return nil + } + } + + e := &pb.MeshEntry{ + Entry: &pb.Entry{ + Receiver: r, + GroupKey: []byte(gkey), + Timestamp: now, + FiringAlerts: firingAlerts, + ResolvedAlerts: resolvedAlerts, + }, + ExpiresAt: now.Add(l.retention), + } + + b, err := marshalMeshEntry(e) + if err != nil { + return err + } + l.st.merge(e) + l.broadcast(b) + + return nil +} + +// GC implements the Log interface. +func (l *Log) GC() (int, error) { + start := time.Now() + defer func() { l.metrics.gcDuration.Observe(time.Since(start).Seconds()) }() + + now := l.now() + var n int + + l.mtx.Lock() + defer l.mtx.Unlock() + + for k, le := range l.st { + if le.ExpiresAt.IsZero() { + return n, errors.New("unexpected zero expiration timestamp") + } + if !le.ExpiresAt.After(now) { + delete(l.st, k) + n++ + } + } + + return n, nil +} + +// Query implements the Log interface. +func (l *Log) Query(params ...QueryParam) ([]*pb.Entry, error) { + start := time.Now() + l.metrics.queriesTotal.Inc() + + entries, err := func() ([]*pb.Entry, error) { + q := &query{} + for _, p := range params { + if err := p(q); err != nil { + return nil, err + } + } + // TODO(fabxc): For now our only query mode is the most recent entry for a + // receiver/group_key combination. + if q.recv == nil || q.groupKey == "" { + // TODO(fabxc): allow more complex queries in the future. + // How to enable pagination? + return nil, errors.New("no query parameters specified") + } + + l.mtx.RLock() + defer l.mtx.RUnlock() + + if le, ok := l.st[stateKey(q.groupKey, q.recv)]; ok { + return []*pb.Entry{le.Entry}, nil + } + return nil, ErrNotFound + }() + if err != nil { + l.metrics.queryErrorsTotal.Inc() + } + l.metrics.queryDuration.Observe(time.Since(start).Seconds()) + return entries, err +} + +// loadSnapshot loads a snapshot generated by Snapshot() into the state. +func (l *Log) loadSnapshot(r io.Reader) error { + st, err := decodeState(r) + if err != nil { + return err + } + + l.mtx.Lock() + l.st = st + l.mtx.Unlock() + + return nil +} + +// Snapshot implements the Log interface. +func (l *Log) Snapshot(w io.Writer) (int64, error) { + start := time.Now() + defer func() { l.metrics.snapshotDuration.Observe(time.Since(start).Seconds()) }() + + l.mtx.RLock() + defer l.mtx.RUnlock() + + b, err := l.st.MarshalBinary() + if err != nil { + return 0, err + } + + return io.Copy(w, bytes.NewReader(b)) +} + +// MarshalBinary serializes all contents of the notification log. +func (l *Log) MarshalBinary() ([]byte, error) { + l.mtx.Lock() + defer l.mtx.Unlock() + + return l.st.MarshalBinary() +} + +// Merge merges notification log state received from the cluster with the local state. +func (l *Log) Merge(b []byte) error { + st, err := decodeState(bytes.NewReader(b)) + if err != nil { + return err + } + l.mtx.Lock() + defer l.mtx.Unlock() + + for _, e := range st { + if merged := l.st.merge(e); merged && !cluster.OversizedMessage(b) { + // If this is the first we've seen the message and it's + // not oversized, gossip it to other nodes. We don't + // propagate oversized messages because they're sent to + // all nodes already. + l.broadcast(b) + l.metrics.propagatedMessagesTotal.Inc() + level.Debug(l.logger).Log("msg", "gossiping new entry", "entry", e) + } + } + return nil +} + +// SetBroadcast sets a broadcast callback that will be invoked with serialized state +// on updates. +func (l *Log) SetBroadcast(f func([]byte)) { + l.mtx.Lock() + l.broadcast = f + l.mtx.Unlock() +} + +// replaceFile wraps a file that is moved to another filename on closing. +type replaceFile struct { + *os.File + filename string +} + +func (f *replaceFile) Close() error { + if err := f.File.Sync(); err != nil { + return err + } + if err := f.File.Close(); err != nil { + return err + } + return os.Rename(f.File.Name(), f.filename) +} + +// openReplace opens a new temporary file that is moved to filename on closing. +func openReplace(filename string) (*replaceFile, error) { + tmpFilename := fmt.Sprintf("%s.%x", filename, uint64(rand.Int63())) + + f, err := os.Create(tmpFilename) + if err != nil { + return nil, err + } + + rf := &replaceFile{ + File: f, + filename: filename, + } + return rf, nil +} diff --git a/src/alertmanager/nflog/nflog_test.go b/src/alertmanager/nflog/nflog_test.go new file mode 100644 index 0000000..417af1a --- /dev/null +++ b/src/alertmanager/nflog/nflog_test.go @@ -0,0 +1,309 @@ +// Copyright 2016 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package nflog + +import ( + "bytes" + "io/ioutil" + "os" + "path/filepath" + "testing" + "time" + + pb "github.com/prometheus/alertmanager/nflog/nflogpb" + "github.com/stretchr/testify/require" +) + +func TestLogGC(t *testing.T) { + now := utcNow() + // We only care about key names and expiration timestamps. + newEntry := func(ts time.Time) *pb.MeshEntry { + return &pb.MeshEntry{ + ExpiresAt: ts, + } + } + + l := &Log{ + st: state{ + "a1": newEntry(now), + "a2": newEntry(now.Add(time.Second)), + "a3": newEntry(now.Add(-time.Second)), + }, + now: func() time.Time { return now }, + metrics: newMetrics(nil), + } + n, err := l.GC() + require.NoError(t, err, "unexpected error in garbage collection") + require.Equal(t, 2, n, "unexpected number of removed entries") + + expected := state{ + "a2": newEntry(now.Add(time.Second)), + } + require.Equal(t, l.st, expected, "unepexcted state after garbage collection") +} + +func TestLogSnapshot(t *testing.T) { + // Check whether storing and loading the snapshot is symmetric. + now := utcNow() + + cases := []struct { + entries []*pb.MeshEntry + }{ + { + entries: []*pb.MeshEntry{ + { + Entry: &pb.Entry{ + GroupKey: []byte("d8e8fca2dc0f896fd7cb4cb0031ba249"), + Receiver: &pb.Receiver{GroupName: "abc", Integration: "test1", Idx: 1}, + GroupHash: []byte("126a8a51b9d1bbd07fddc65819a542c3"), + Resolved: false, + Timestamp: now, + }, + ExpiresAt: now, + }, { + Entry: &pb.Entry{ + GroupKey: []byte("d8e8fca2dc0f8abce7cb4cb0031ba249"), + Receiver: &pb.Receiver{GroupName: "def", Integration: "test2", Idx: 29}, + GroupHash: []byte("122c2331b9d1bbd07fddc65819a542c3"), + Resolved: true, + Timestamp: now, + }, + ExpiresAt: now, + }, { + Entry: &pb.Entry{ + GroupKey: []byte("aaaaaca2dc0f896fd7cb4cb0031ba249"), + Receiver: &pb.Receiver{GroupName: "ghi", Integration: "test3", Idx: 0}, + GroupHash: []byte("126a8a51b9d1bbd07fddc6e3e3e542c3"), + Resolved: false, + Timestamp: now, + }, + ExpiresAt: now, + }, + }, + }, + } + + for _, c := range cases { + f, err := ioutil.TempFile("", "snapshot") + require.NoError(t, err, "creating temp file failed") + + l1 := &Log{ + st: state{}, + metrics: newMetrics(nil), + } + // Setup internal state manually. + for _, e := range c.entries { + l1.st[stateKey(string(e.Entry.GroupKey), e.Entry.Receiver)] = e + } + _, err = l1.Snapshot(f) + require.NoError(t, err, "creating snapshot failed") + require.NoError(t, f.Close(), "closing snapshot file failed") + + f, err = os.Open(f.Name()) + require.NoError(t, err, "opening snapshot file failed") + + // Check again against new nlog instance. + l2 := &Log{} + err = l2.loadSnapshot(f) + require.NoError(t, err, "error loading snapshot") + require.Equal(t, l1.st, l2.st, "state after loading snapshot did not match snapshotted state") + + require.NoError(t, f.Close(), "closing snapshot file failed") + } +} + +func TestReplaceFile(t *testing.T) { + dir, err := ioutil.TempDir("", "replace_file") + require.NoError(t, err, "creating temp dir failed") + + origFilename := filepath.Join(dir, "testfile") + + of, err := os.Create(origFilename) + require.NoError(t, err, "creating file failed") + + nf, err := openReplace(origFilename) + require.NoError(t, err, "opening replacement file failed") + + _, err = nf.Write([]byte("test")) + require.NoError(t, err, "writing replace file failed") + + require.NotEqual(t, nf.Name(), of.Name(), "replacement file must have different name while editing") + require.NoError(t, nf.Close(), "closing replacement file failed") + require.NoError(t, of.Close(), "closing original file failed") + + ofr, err := os.Open(origFilename) + require.NoError(t, err, "opening original file failed") + defer ofr.Close() + + res, err := ioutil.ReadAll(ofr) + require.NoError(t, err, "reading original file failed") + require.Equal(t, "test", string(res), "unexpected file contents") +} + +func TestStateMerge(t *testing.T) { + now := utcNow() + + // We only care about key names and timestamps for the + // merging logic. + newEntry := func(ts time.Time, name string) *pb.MeshEntry { + return &pb.MeshEntry{ + Entry: &pb.Entry{ + Timestamp: ts, + GroupKey: []byte("key"), + Receiver: &pb.Receiver{ + GroupName: name, + Idx: 1, + Integration: "integr", + }, + }, + } + } + cases := []struct { + a, b state + final state + }{ + { + a: state{ + "key:a1/integr/1": newEntry(now, "a1"), + "key:a2/integr/1": newEntry(now, "a2"), + "key:a3/integr/1": newEntry(now, "a3"), + }, + b: state{ + "key:b1/integr/1": newEntry(now, "b1"), // new key, should be added + "key:a2/integr/1": newEntry(now.Add(-time.Minute), "a2"), // older timestamp, should be dropped + "key:a3/integr/1": newEntry(now.Add(time.Minute), "a3"), // newer timestamp, should overwrite + }, + final: state{ + "key:a1/integr/1": newEntry(now, "a1"), + "key:a2/integr/1": newEntry(now, "a2"), + "key:a3/integr/1": newEntry(now.Add(time.Minute), "a3"), + "key:b1/integr/1": newEntry(now, "b1"), + }, + }, + } + + for _, c := range cases { + ca, cb := c.a.clone(), c.b.clone() + + res := c.a.clone() + for _, e := range cb { + res.merge(e) + } + require.Equal(t, c.final, res, "Merge result should match expectation") + require.Equal(t, c.b, cb, "Merged state should remain unmodified") + require.NotEqual(t, c.final, ca, "Merge should not change original state") + } +} + +func TestStateDataCoding(t *testing.T) { + // Check whether encoding and decoding the data is symmetric. + now := utcNow() + + cases := []struct { + entries []*pb.MeshEntry + }{ + { + entries: []*pb.MeshEntry{ + { + Entry: &pb.Entry{ + GroupKey: []byte("d8e8fca2dc0f896fd7cb4cb0031ba249"), + Receiver: &pb.Receiver{GroupName: "abc", Integration: "test1", Idx: 1}, + GroupHash: []byte("126a8a51b9d1bbd07fddc65819a542c3"), + Resolved: false, + Timestamp: now, + }, + ExpiresAt: now, + }, { + Entry: &pb.Entry{ + GroupKey: []byte("d8e8fca2dc0f8abce7cb4cb0031ba249"), + Receiver: &pb.Receiver{GroupName: "def", Integration: "test2", Idx: 29}, + GroupHash: []byte("122c2331b9d1bbd07fddc65819a542c3"), + Resolved: true, + Timestamp: now, + }, + ExpiresAt: now, + }, { + Entry: &pb.Entry{ + GroupKey: []byte("aaaaaca2dc0f896fd7cb4cb0031ba249"), + Receiver: &pb.Receiver{GroupName: "ghi", Integration: "test3", Idx: 0}, + GroupHash: []byte("126a8a51b9d1bbd07fddc6e3e3e542c3"), + Resolved: false, + Timestamp: now, + }, + ExpiresAt: now, + }, + }, + }, + } + + for _, c := range cases { + // Create gossip data from input. + in := state{} + for _, e := range c.entries { + in[stateKey(string(e.Entry.GroupKey), e.Entry.Receiver)] = e + } + msg, err := in.MarshalBinary() + require.NoError(t, err) + + out, err := decodeState(bytes.NewReader(msg)) + require.NoError(t, err, "decoding message failed") + + require.Equal(t, in, out, "decoded data doesn't match encoded data") + } +} + +func TestQuery(t *testing.T) { + nl, err := New() + if err != nil { + require.NoError(t, err, "constructing nflog failed") + } + + recv := new(pb.Receiver) + + // no key param + _, err = nl.Query(QGroupKey("key")) + require.EqualError(t, err, "no query parameters specified") + + // no recv param + _, err = nl.Query(QReceiver(recv)) + require.EqualError(t, err, "no query parameters specified") + + // no entry + _, err = nl.Query(QGroupKey("nonexistingkey"), QReceiver(recv)) + require.EqualError(t, err, "not found") + + // existing entry + firingAlerts := []uint64{1, 2, 3} + resolvedAlerts := []uint64{4, 5} + + err = nl.Log(recv, "key", firingAlerts, resolvedAlerts) + require.NoError(t, err, "logging notification failed") + + entries, err := nl.Query(QGroupKey("key"), QReceiver(recv)) + require.NoError(t, err, "querying nflog failed") + entry := entries[0] + require.EqualValues(t, firingAlerts, entry.FiringAlerts) + require.EqualValues(t, resolvedAlerts, entry.ResolvedAlerts) +} + +func TestStateDecodingError(t *testing.T) { + // Check whether decoding copes with erroneous data. + s := state{"": &pb.MeshEntry{}} + + msg, err := s.MarshalBinary() + require.NoError(t, err) + + _, err = decodeState(bytes.NewReader(msg)) + require.Equal(t, ErrInvalidState, err) +} diff --git a/src/alertmanager/nflog/nflogpb/nflog.pb.go b/src/alertmanager/nflog/nflogpb/nflog.pb.go new file mode 100644 index 0000000..598f9de --- /dev/null +++ b/src/alertmanager/nflog/nflogpb/nflog.pb.go @@ -0,0 +1,1046 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: nflog.proto + +/* + Package nflogpb is a generated protocol buffer package. + + It is generated from these files: + nflog.proto + + It has these top-level messages: + Receiver + Entry + MeshEntry +*/ +package nflogpb + +import proto "github.com/gogo/protobuf/proto" +import fmt "fmt" +import math "math" + +import _ "github.com/gogo/protobuf/gogoproto" + +import time "time" + +import types "github.com/gogo/protobuf/types" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf +var _ = time.Kitchen + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package + +type Receiver struct { + // Configured name of the receiver group. + GroupName string `protobuf:"bytes,1,opt,name=group_name,json=groupName,proto3" json:"group_name,omitempty"` + // Name of the integration of the receiver. + Integration string `protobuf:"bytes,2,opt,name=integration,proto3" json:"integration,omitempty"` + // Index of the receiver with respect to the integration. + // Every integration in a group may have 0..N configurations. + Idx uint32 `protobuf:"varint,3,opt,name=idx,proto3" json:"idx,omitempty"` +} + +func (m *Receiver) Reset() { *m = Receiver{} } +func (m *Receiver) String() string { return proto.CompactTextString(m) } +func (*Receiver) ProtoMessage() {} +func (*Receiver) Descriptor() ([]byte, []int) { return fileDescriptorNflog, []int{0} } + +// Entry holds information about a successful notification +// sent to a receiver. +type Entry struct { + // The key identifying the dispatching group. + GroupKey []byte `protobuf:"bytes,1,opt,name=group_key,json=groupKey,proto3" json:"group_key,omitempty"` + // The receiver that was notified. + Receiver *Receiver `protobuf:"bytes,2,opt,name=receiver" json:"receiver,omitempty"` + // Hash over the state of the group at notification time. + // Deprecated in favor of FiringAlerts field, but kept for compatibility. + GroupHash []byte `protobuf:"bytes,3,opt,name=group_hash,json=groupHash,proto3" json:"group_hash,omitempty"` + // Whether the notification was about a resolved alert. + // Deprecated in favor of ResolvedAlerts field, but kept for compatibility. + Resolved bool `protobuf:"varint,4,opt,name=resolved,proto3" json:"resolved,omitempty"` + // Timestamp of the succeeding notification. + Timestamp time.Time `protobuf:"bytes,5,opt,name=timestamp,stdtime" json:"timestamp"` + // FiringAlerts list of hashes of firing alerts at the last notification time. + FiringAlerts []uint64 `protobuf:"varint,6,rep,packed,name=firing_alerts,json=firingAlerts" json:"firing_alerts,omitempty"` + // ResolvedAlerts list of hashes of resolved alerts at the last notification time. + ResolvedAlerts []uint64 `protobuf:"varint,7,rep,packed,name=resolved_alerts,json=resolvedAlerts" json:"resolved_alerts,omitempty"` +} + +func (m *Entry) Reset() { *m = Entry{} } +func (m *Entry) String() string { return proto.CompactTextString(m) } +func (*Entry) ProtoMessage() {} +func (*Entry) Descriptor() ([]byte, []int) { return fileDescriptorNflog, []int{1} } + +// MeshEntry is a wrapper message to communicate a notify log +// entry through a mesh network. +type MeshEntry struct { + // The original raw notify log entry. + Entry *Entry `protobuf:"bytes,1,opt,name=entry" json:"entry,omitempty"` + // A timestamp indicating when the mesh peer should evict + // the log entry from its state. + ExpiresAt time.Time `protobuf:"bytes,2,opt,name=expires_at,json=expiresAt,stdtime" json:"expires_at"` +} + +func (m *MeshEntry) Reset() { *m = MeshEntry{} } +func (m *MeshEntry) String() string { return proto.CompactTextString(m) } +func (*MeshEntry) ProtoMessage() {} +func (*MeshEntry) Descriptor() ([]byte, []int) { return fileDescriptorNflog, []int{2} } + +func init() { + proto.RegisterType((*Receiver)(nil), "nflogpb.Receiver") + proto.RegisterType((*Entry)(nil), "nflogpb.Entry") + proto.RegisterType((*MeshEntry)(nil), "nflogpb.MeshEntry") +} +func (m *Receiver) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Receiver) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.GroupName) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintNflog(dAtA, i, uint64(len(m.GroupName))) + i += copy(dAtA[i:], m.GroupName) + } + if len(m.Integration) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintNflog(dAtA, i, uint64(len(m.Integration))) + i += copy(dAtA[i:], m.Integration) + } + if m.Idx != 0 { + dAtA[i] = 0x18 + i++ + i = encodeVarintNflog(dAtA, i, uint64(m.Idx)) + } + return i, nil +} + +func (m *Entry) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Entry) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.GroupKey) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintNflog(dAtA, i, uint64(len(m.GroupKey))) + i += copy(dAtA[i:], m.GroupKey) + } + if m.Receiver != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintNflog(dAtA, i, uint64(m.Receiver.Size())) + n1, err := m.Receiver.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n1 + } + if len(m.GroupHash) > 0 { + dAtA[i] = 0x1a + i++ + i = encodeVarintNflog(dAtA, i, uint64(len(m.GroupHash))) + i += copy(dAtA[i:], m.GroupHash) + } + if m.Resolved { + dAtA[i] = 0x20 + i++ + if m.Resolved { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + } + dAtA[i] = 0x2a + i++ + i = encodeVarintNflog(dAtA, i, uint64(types.SizeOfStdTime(m.Timestamp))) + n2, err := types.StdTimeMarshalTo(m.Timestamp, dAtA[i:]) + if err != nil { + return 0, err + } + i += n2 + if len(m.FiringAlerts) > 0 { + dAtA4 := make([]byte, len(m.FiringAlerts)*10) + var j3 int + for _, num := range m.FiringAlerts { + for num >= 1<<7 { + dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j3++ + } + dAtA4[j3] = uint8(num) + j3++ + } + dAtA[i] = 0x32 + i++ + i = encodeVarintNflog(dAtA, i, uint64(j3)) + i += copy(dAtA[i:], dAtA4[:j3]) + } + if len(m.ResolvedAlerts) > 0 { + dAtA6 := make([]byte, len(m.ResolvedAlerts)*10) + var j5 int + for _, num := range m.ResolvedAlerts { + for num >= 1<<7 { + dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j5++ + } + dAtA6[j5] = uint8(num) + j5++ + } + dAtA[i] = 0x3a + i++ + i = encodeVarintNflog(dAtA, i, uint64(j5)) + i += copy(dAtA[i:], dAtA6[:j5]) + } + return i, nil +} + +func (m *MeshEntry) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MeshEntry) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Entry != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintNflog(dAtA, i, uint64(m.Entry.Size())) + n7, err := m.Entry.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n7 + } + dAtA[i] = 0x12 + i++ + i = encodeVarintNflog(dAtA, i, uint64(types.SizeOfStdTime(m.ExpiresAt))) + n8, err := types.StdTimeMarshalTo(m.ExpiresAt, dAtA[i:]) + if err != nil { + return 0, err + } + i += n8 + return i, nil +} + +func encodeVarintNflog(dAtA []byte, offset int, v uint64) int { + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return offset + 1 +} +func (m *Receiver) Size() (n int) { + var l int + _ = l + l = len(m.GroupName) + if l > 0 { + n += 1 + l + sovNflog(uint64(l)) + } + l = len(m.Integration) + if l > 0 { + n += 1 + l + sovNflog(uint64(l)) + } + if m.Idx != 0 { + n += 1 + sovNflog(uint64(m.Idx)) + } + return n +} + +func (m *Entry) Size() (n int) { + var l int + _ = l + l = len(m.GroupKey) + if l > 0 { + n += 1 + l + sovNflog(uint64(l)) + } + if m.Receiver != nil { + l = m.Receiver.Size() + n += 1 + l + sovNflog(uint64(l)) + } + l = len(m.GroupHash) + if l > 0 { + n += 1 + l + sovNflog(uint64(l)) + } + if m.Resolved { + n += 2 + } + l = types.SizeOfStdTime(m.Timestamp) + n += 1 + l + sovNflog(uint64(l)) + if len(m.FiringAlerts) > 0 { + l = 0 + for _, e := range m.FiringAlerts { + l += sovNflog(uint64(e)) + } + n += 1 + sovNflog(uint64(l)) + l + } + if len(m.ResolvedAlerts) > 0 { + l = 0 + for _, e := range m.ResolvedAlerts { + l += sovNflog(uint64(e)) + } + n += 1 + sovNflog(uint64(l)) + l + } + return n +} + +func (m *MeshEntry) Size() (n int) { + var l int + _ = l + if m.Entry != nil { + l = m.Entry.Size() + n += 1 + l + sovNflog(uint64(l)) + } + l = types.SizeOfStdTime(m.ExpiresAt) + n += 1 + l + sovNflog(uint64(l)) + return n +} + +func sovNflog(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozNflog(x uint64) (n int) { + return sovNflog(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Receiver) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNflog + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Receiver: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Receiver: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GroupName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNflog + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthNflog + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GroupName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Integration", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNflog + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthNflog + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Integration = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Idx", wireType) + } + m.Idx = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNflog + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Idx |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipNflog(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthNflog + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Entry) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNflog + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Entry: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Entry: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GroupKey", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNflog + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthNflog + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GroupKey = append(m.GroupKey[:0], dAtA[iNdEx:postIndex]...) + if m.GroupKey == nil { + m.GroupKey = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Receiver", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNflog + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthNflog + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Receiver == nil { + m.Receiver = &Receiver{} + } + if err := m.Receiver.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GroupHash", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNflog + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthNflog + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GroupHash = append(m.GroupHash[:0], dAtA[iNdEx:postIndex]...) + if m.GroupHash == nil { + m.GroupHash = []byte{} + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Resolved", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNflog + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Resolved = bool(v != 0) + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNflog + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthNflog + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNflog + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FiringAlerts = append(m.FiringAlerts, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNflog + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthNflog + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNflog + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FiringAlerts = append(m.FiringAlerts, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field FiringAlerts", wireType) + } + case 7: + if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNflog + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.ResolvedAlerts = append(m.ResolvedAlerts, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNflog + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthNflog + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNflog + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.ResolvedAlerts = append(m.ResolvedAlerts, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field ResolvedAlerts", wireType) + } + default: + iNdEx = preIndex + skippy, err := skipNflog(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthNflog + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MeshEntry) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNflog + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MeshEntry: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MeshEntry: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNflog + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthNflog + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Entry == nil { + m.Entry = &Entry{} + } + if err := m.Entry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExpiresAt", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNflog + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthNflog + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := types.StdTimeUnmarshal(&m.ExpiresAt, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipNflog(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthNflog + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipNflog(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowNflog + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowNflog + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowNflog + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthNflog + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowNflog + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipNflog(dAtA[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthNflog = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowNflog = fmt.Errorf("proto: integer overflow") +) + +func init() { proto.RegisterFile("nflog.proto", fileDescriptorNflog) } + +var fileDescriptorNflog = []byte{ + // 385 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x90, 0xcf, 0x6e, 0xd3, 0x40, + 0x10, 0xc6, 0xbb, 0x4d, 0xd3, 0xda, 0xe3, 0xb4, 0x94, 0x15, 0x07, 0xcb, 0x08, 0xc7, 0x0a, 0x48, + 0xf8, 0x82, 0x23, 0x95, 0x27, 0x68, 0x10, 0x12, 0x12, 0x82, 0xc3, 0x8a, 0x2b, 0xb2, 0x36, 0x74, + 0xb2, 0x5e, 0x61, 0x7b, 0xad, 0xf5, 0x36, 0x6a, 0xde, 0x82, 0x47, 0xe0, 0x71, 0x72, 0xe4, 0x09, + 0xf8, 0x93, 0x27, 0x41, 0xde, 0xb5, 0x1d, 0x8e, 0xdc, 0x66, 0x7f, 0xf3, 0xcd, 0xcc, 0xb7, 0x1f, + 0x04, 0xf5, 0xa6, 0x54, 0x22, 0x6b, 0xb4, 0x32, 0x8a, 0x5e, 0xd8, 0x47, 0xb3, 0x8e, 0xe6, 0x42, + 0x29, 0x51, 0xe2, 0xd2, 0xe2, 0xf5, 0xfd, 0x66, 0x69, 0x64, 0x85, 0xad, 0xe1, 0x55, 0xe3, 0x94, + 0xd1, 0x13, 0xa1, 0x84, 0xb2, 0xe5, 0xb2, 0xab, 0x1c, 0x5d, 0x7c, 0x06, 0x8f, 0xe1, 0x17, 0x94, + 0x5b, 0xd4, 0xf4, 0x19, 0x80, 0xd0, 0xea, 0xbe, 0xc9, 0x6b, 0x5e, 0x61, 0x48, 0x12, 0x92, 0xfa, + 0xcc, 0xb7, 0xe4, 0x23, 0xaf, 0x90, 0x26, 0x10, 0xc8, 0xda, 0xa0, 0xd0, 0xdc, 0x48, 0x55, 0x87, + 0xa7, 0xb6, 0xff, 0x2f, 0xa2, 0xd7, 0x30, 0x91, 0x77, 0x0f, 0xe1, 0x24, 0x21, 0xe9, 0x25, 0xeb, + 0xca, 0xc5, 0xf7, 0x53, 0x98, 0xbe, 0xad, 0x8d, 0xde, 0xd1, 0xa7, 0xe0, 0x56, 0xe5, 0x5f, 0x71, + 0x67, 0x77, 0xcf, 0x98, 0x67, 0xc1, 0x7b, 0xdc, 0xd1, 0x57, 0xe0, 0xe9, 0xde, 0x85, 0xdd, 0x1b, + 0xdc, 0x3c, 0xce, 0xfa, 0x8f, 0x65, 0x83, 0x3d, 0x36, 0x4a, 0x8e, 0x46, 0x0b, 0xde, 0x16, 0xf6, + 0xdc, 0xac, 0x37, 0xfa, 0x8e, 0xb7, 0x05, 0x8d, 0xba, 0x6d, 0xad, 0x2a, 0xb7, 0x78, 0x17, 0x9e, + 0x25, 0x24, 0xf5, 0xd8, 0xf8, 0xa6, 0x2b, 0xf0, 0xc7, 0x60, 0xc2, 0xa9, 0x3d, 0x15, 0x65, 0x2e, + 0xba, 0x6c, 0x88, 0x2e, 0xfb, 0x34, 0x28, 0x56, 0xde, 0xfe, 0xe7, 0xfc, 0xe4, 0xdb, 0xaf, 0x39, + 0x61, 0xc7, 0x31, 0xfa, 0x1c, 0x2e, 0x37, 0x52, 0xcb, 0x5a, 0xe4, 0xbc, 0x44, 0x6d, 0xda, 0xf0, + 0x3c, 0x99, 0xa4, 0x67, 0x6c, 0xe6, 0xe0, 0xad, 0x65, 0xf4, 0x25, 0x3c, 0x1a, 0x8e, 0x0e, 0xb2, + 0x0b, 0x2b, 0xbb, 0x1a, 0xb0, 0x13, 0x2e, 0xb6, 0xe0, 0x7f, 0xc0, 0xb6, 0x70, 0x29, 0xbd, 0x80, + 0x29, 0x76, 0x85, 0x4d, 0x28, 0xb8, 0xb9, 0x1a, 0x53, 0xb0, 0x6d, 0xe6, 0x9a, 0xf4, 0x0d, 0x00, + 0x3e, 0x34, 0x52, 0x63, 0x9b, 0x73, 0xd3, 0x07, 0xf6, 0x9f, 0xbf, 0xe8, 0xe7, 0x6e, 0xcd, 0xea, + 0x7a, 0xff, 0x27, 0x3e, 0xd9, 0x1f, 0x62, 0xf2, 0xe3, 0x10, 0x93, 0xdf, 0x87, 0x98, 0xac, 0xcf, + 0xed, 0xe8, 0xeb, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x49, 0xcd, 0xa7, 0x1e, 0x61, 0x02, 0x00, + 0x00, +} diff --git a/src/alertmanager/nflog/nflogpb/nflog.proto b/src/alertmanager/nflog/nflogpb/nflog.proto new file mode 100644 index 0000000..eb4fd8b --- /dev/null +++ b/src/alertmanager/nflog/nflogpb/nflog.proto @@ -0,0 +1,52 @@ +syntax = "proto3"; + +package nflogpb; + +import "google/protobuf/timestamp.proto"; +import "gogoproto/gogo.proto"; + +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.goproto_getters_all) = false; + +message Receiver { + // Configured name of the receiver group. + string group_name = 1; + // Name of the integration of the receiver. + string integration = 2; + // Index of the receiver with respect to the integration. + // Every integration in a group may have 0..N configurations. + uint32 idx = 3; +} + +// Entry holds information about a successful notification +// sent to a receiver. +message Entry { + // The key identifying the dispatching group. + bytes group_key = 1; + // The receiver that was notified. + Receiver receiver = 2; + // Hash over the state of the group at notification time. + // Deprecated in favor of FiringAlerts field, but kept for compatibility. + bytes group_hash = 3; + // Whether the notification was about a resolved alert. + // Deprecated in favor of ResolvedAlerts field, but kept for compatibility. + bool resolved = 4; + // Timestamp of the succeeding notification. + google.protobuf.Timestamp timestamp = 5 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; + // FiringAlerts list of hashes of firing alerts at the last notification time. + repeated uint64 firing_alerts = 6; + // ResolvedAlerts list of hashes of resolved alerts at the last notification time. + repeated uint64 resolved_alerts = 7; +} + +// MeshEntry is a wrapper message to communicate a notify log +// entry through a mesh network. +message MeshEntry { + // The original raw notify log entry. + Entry entry = 1; + // A timestamp indicating when the mesh peer should evict + // the log entry from its state. + google.protobuf.Timestamp expires_at = 2 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; +} diff --git a/src/alertmanager/nflog/nflogpb/set.go b/src/alertmanager/nflog/nflogpb/set.go new file mode 100644 index 0000000..698f7f2 --- /dev/null +++ b/src/alertmanager/nflog/nflogpb/set.go @@ -0,0 +1,47 @@ +// Copyright 2017 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package nflogpb + +// IsFiringSubset returns whether the given subset is a subset of the alerts +// that were firing at the time of the last notification. +func (m *Entry) IsFiringSubset(subset map[uint64]struct{}) bool { + set := map[uint64]struct{}{} + for i := range m.FiringAlerts { + set[m.FiringAlerts[i]] = struct{}{} + } + + return isSubset(set, subset) +} + +// IsResolvedSubset returns whether the given subset is a subset of the alerts +// that were resolved at the time of the last notification. +func (m *Entry) IsResolvedSubset(subset map[uint64]struct{}) bool { + set := map[uint64]struct{}{} + for i := range m.ResolvedAlerts { + set[m.ResolvedAlerts[i]] = struct{}{} + } + + return isSubset(set, subset) +} + +func isSubset(set, subset map[uint64]struct{}) bool { + for k := range subset { + _, exists := set[k] + if !exists { + return false + } + } + + return true +} diff --git a/src/alertmanager/nflog/nflogpb/set_test.go b/src/alertmanager/nflog/nflogpb/set_test.go new file mode 100644 index 0000000..49fe1d3 --- /dev/null +++ b/src/alertmanager/nflog/nflogpb/set_test.go @@ -0,0 +1,92 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package nflogpb + +import ( + "testing" +) + +func TestIsFiringSubset(t *testing.T) { + e := &Entry{ + FiringAlerts: []uint64{1, 2, 3}, + } + + tests := []struct { + subset map[uint64]struct{} + expected bool + }{ + {newSubset(), true}, //empty subset + {newSubset(1), true}, + {newSubset(2), true}, + {newSubset(3), true}, + {newSubset(1, 2), true}, + {newSubset(1, 2), true}, + {newSubset(1, 2, 3), true}, + {newSubset(4), false}, + {newSubset(1, 5), false}, + {newSubset(1, 2, 3, 6), false}, + } + + for _, test := range tests { + if result := e.IsFiringSubset(test.subset); result != test.expected { + t.Errorf("Expected %t, got %t for subset %v", test.expected, result, elements(test.subset)) + } + } +} + +func TestIsResolvedSubset(t *testing.T) { + e := &Entry{ + ResolvedAlerts: []uint64{1, 2, 3}, + } + + tests := []struct { + subset map[uint64]struct{} + expected bool + }{ + {newSubset(), true}, //empty subset + {newSubset(1), true}, + {newSubset(2), true}, + {newSubset(3), true}, + {newSubset(1, 2), true}, + {newSubset(1, 2), true}, + {newSubset(1, 2, 3), true}, + {newSubset(4), false}, + {newSubset(1, 5), false}, + {newSubset(1, 2, 3, 6), false}, + } + + for _, test := range tests { + if result := e.IsResolvedSubset(test.subset); result != test.expected { + t.Errorf("Expected %t, got %t for subset %v", test.expected, result, elements(test.subset)) + } + } +} + +func newSubset(elements ...uint64) map[uint64]struct{} { + subset := make(map[uint64]struct{}) + for _, el := range elements { + subset[el] = struct{}{} + } + + return subset +} + +func elements(m map[uint64]struct{}) []uint64 { + els := make([]uint64, 0, len(m)) + for k, _ := range m { + els = append(els, k) + } + + return els +} diff --git a/src/alertmanager/notify/impl.go b/src/alertmanager/notify/impl.go new file mode 100644 index 0000000..8f3b555 --- /dev/null +++ b/src/alertmanager/notify/impl.go @@ -0,0 +1,1378 @@ +// Copyright 2015 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package notify + +import ( + "bytes" + "crypto/sha256" + "crypto/tls" + "encoding/json" + "errors" + "fmt" + "io/ioutil" + "mime" + "mime/multipart" + "net" + "net/http" + "net/mail" + "net/smtp" + "net/textproto" + "net/url" + "strings" + "time" + + "github.com/go-kit/kit/log" + "github.com/go-kit/kit/log/level" + commoncfg "github.com/prometheus/common/config" + "github.com/prometheus/common/model" + "github.com/prometheus/common/version" + "golang.org/x/net/context" + "golang.org/x/net/context/ctxhttp" + + "github.com/prometheus/alertmanager/config" + "github.com/prometheus/alertmanager/template" + "github.com/prometheus/alertmanager/types" +) + +// A Notifier notifies about alerts under constraints of the given context. +// It returns an error if unsuccessful and a flag whether the error is +// recoverable. This information is useful for a retry logic. +type Notifier interface { + Notify(context.Context, ...*types.Alert) (bool, error) +} + +// An Integration wraps a notifier and its config to be uniquely identified by +// name and index from its origin in the configuration. +type Integration struct { + notifier Notifier + conf notifierConfig + name string + idx int +} + +// Notify implements the Notifier interface. +func (i *Integration) Notify(ctx context.Context, alerts ...*types.Alert) (bool, error) { + return i.notifier.Notify(ctx, alerts...) +} + +// BuildReceiverIntegrations builds a list of integration notifiers off of a +// receivers config. +func BuildReceiverIntegrations(nc *config.Receiver, tmpl *template.Template, logger log.Logger) []Integration { + var ( + integrations []Integration + add = func(name string, i int, n Notifier, nc notifierConfig) { + integrations = append(integrations, Integration{ + notifier: n, + conf: nc, + name: name, + idx: i, + }) + } + ) + + for i, c := range nc.WebhookConfigs { + n := NewWebhook(c, tmpl, logger) + add("webhook", i, n, c) + } + for i, c := range nc.EmailConfigs { + n := NewEmail(c, tmpl, logger) + add("email", i, n, c) + } + for i, c := range nc.PagerdutyConfigs { + n := NewPagerDuty(c, tmpl, logger) + add("pagerduty", i, n, c) + } + for i, c := range nc.OpsGenieConfigs { + n := NewOpsGenie(c, tmpl, logger) + add("opsgenie", i, n, c) + } + for i, c := range nc.WechatConfigs { + n := NewWechat(c, tmpl, logger) + add("wechat", i, n, c) + } + for i, c := range nc.SlackConfigs { + n := NewSlack(c, tmpl, logger) + add("slack", i, n, c) + } + for i, c := range nc.HipchatConfigs { + n := NewHipchat(c, tmpl, logger) + add("hipchat", i, n, c) + } + for i, c := range nc.VictorOpsConfigs { + n := NewVictorOps(c, tmpl, logger) + add("victorops", i, n, c) + } + for i, c := range nc.PushoverConfigs { + n := NewPushover(c, tmpl, logger) + add("pushover", i, n, c) + } + return integrations +} + +const contentTypeJSON = "application/json" + +var userAgentHeader = fmt.Sprintf("Alertmanager/%s", version.Version) + +// Webhook implements a Notifier for generic webhooks. +type Webhook struct { + conf *config.WebhookConfig + tmpl *template.Template + logger log.Logger +} + +// NewWebhook returns a new Webhook. +func NewWebhook(conf *config.WebhookConfig, t *template.Template, l log.Logger) *Webhook { + return &Webhook{conf: conf, tmpl: t, logger: l} +} + +// WebhookMessage defines the JSON object send to webhook endpoints. +type WebhookMessage struct { + *template.Data + + // The protocol version. + Version string `json:"version"` + GroupKey string `json:"groupKey"` +} + +// Notify implements the Notifier interface. +func (w *Webhook) Notify(ctx context.Context, alerts ...*types.Alert) (bool, error) { + data := w.tmpl.Data(receiverName(ctx, w.logger), groupLabels(ctx, w.logger), alerts...) + + groupKey, ok := GroupKey(ctx) + if !ok { + level.Error(w.logger).Log("msg", "group key missing") + } + + msg := &WebhookMessage{ + Version: "4", + Data: data, + GroupKey: groupKey, + } + + var buf bytes.Buffer + if err := json.NewEncoder(&buf).Encode(msg); err != nil { + return false, err + } + + req, err := http.NewRequest("POST", w.conf.URL, &buf) + if err != nil { + return true, err + } + req.Header.Set("Content-Type", contentTypeJSON) + req.Header.Set("User-Agent", userAgentHeader) + + c, err := commoncfg.NewClientFromConfig(*w.conf.HTTPConfig, "webhook") + if err != nil { + return false, err + } + + resp, err := ctxhttp.Do(ctx, c, req) + if err != nil { + return true, err + } + resp.Body.Close() + + return w.retry(resp.StatusCode) +} + +func (w *Webhook) retry(statusCode int) (bool, error) { + // Webhooks are assumed to respond with 2xx response codes on a successful + // request and 5xx response codes are assumed to be recoverable. + if statusCode/100 != 2 { + return (statusCode/100 == 5), fmt.Errorf("unexpected status code %v from %s", statusCode, w.conf.URL) + } + + return false, nil +} + +// Email implements a Notifier for email notifications. +type Email struct { + conf *config.EmailConfig + tmpl *template.Template + logger log.Logger +} + +// NewEmail returns a new Email notifier. +func NewEmail(c *config.EmailConfig, t *template.Template, l log.Logger) *Email { + if _, ok := c.Headers["Subject"]; !ok { + c.Headers["Subject"] = config.DefaultEmailSubject + } + if _, ok := c.Headers["To"]; !ok { + c.Headers["To"] = c.To + } + if _, ok := c.Headers["From"]; !ok { + c.Headers["From"] = c.From + } + return &Email{conf: c, tmpl: t, logger: l} +} + +// auth resolves a string of authentication mechanisms. +func (n *Email) auth(mechs string) (smtp.Auth, error) { + username := n.conf.AuthUsername + + for _, mech := range strings.Split(mechs, " ") { + switch mech { + case "CRAM-MD5": + secret := string(n.conf.AuthSecret) + if secret == "" { + continue + } + return smtp.CRAMMD5Auth(username, secret), nil + + case "PLAIN": + password := string(n.conf.AuthPassword) + if password == "" { + continue + } + identity := n.conf.AuthIdentity + + // We need to know the hostname for both auth and TLS. + host, _, err := net.SplitHostPort(n.conf.Smarthost) + if err != nil { + return nil, fmt.Errorf("invalid address: %s", err) + } + return smtp.PlainAuth(identity, username, password, host), nil + case "LOGIN": + password := string(n.conf.AuthPassword) + if password == "" { + continue + } + return LoginAuth(username, password), nil + } + } + return nil, nil +} + +// Notify implements the Notifier interface. +func (n *Email) Notify(ctx context.Context, as ...*types.Alert) (bool, error) { + // We need to know the hostname for both auth and TLS. + var c *smtp.Client + host, port, err := net.SplitHostPort(n.conf.Smarthost) + if err != nil { + return false, fmt.Errorf("invalid address: %s", err) + } + + if port == "465" { + conn, err := tls.Dial("tcp", n.conf.Smarthost, &tls.Config{ServerName: host}) + if err != nil { + return true, err + } + c, err = smtp.NewClient(conn, n.conf.Smarthost) + if err != nil { + return true, err + } + + } else { + // Connect to the SMTP smarthost. + c, err = smtp.Dial(n.conf.Smarthost) + if err != nil { + return true, err + } + } + defer c.Quit() + + if n.conf.Hello != "" { + err := c.Hello(n.conf.Hello) + if err != nil { + return true, err + } + } + + // Global Config guarantees RequireTLS is not nil + if *n.conf.RequireTLS { + if ok, _ := c.Extension("STARTTLS"); !ok { + return true, fmt.Errorf("require_tls: true (default), but %q does not advertise the STARTTLS extension", n.conf.Smarthost) + } + tlsConf := &tls.Config{ServerName: host} + if err := c.StartTLS(tlsConf); err != nil { + return true, fmt.Errorf("starttls failed: %s", err) + } + } + + if ok, mech := c.Extension("AUTH"); ok { + auth, err := n.auth(mech) + if err != nil { + return true, err + } + if auth != nil { + if err := c.Auth(auth); err != nil { + return true, fmt.Errorf("%T failed: %s", auth, err) + } + } + } + + var ( + data = n.tmpl.Data(receiverName(ctx, n.logger), groupLabels(ctx, n.logger), as...) + tmpl = tmplText(n.tmpl, data, &err) + from = tmpl(n.conf.From) + to = tmpl(n.conf.To) + ) + if err != nil { + return false, err + } + + addrs, err := mail.ParseAddressList(from) + if err != nil { + return false, fmt.Errorf("parsing from addresses: %s", err) + } + if len(addrs) != 1 { + return false, fmt.Errorf("must be exactly one from address") + } + if err := c.Mail(addrs[0].Address); err != nil { + return true, fmt.Errorf("sending mail from: %s", err) + } + addrs, err = mail.ParseAddressList(to) + if err != nil { + return false, fmt.Errorf("parsing to addresses: %s", err) + } + for _, addr := range addrs { + if err := c.Rcpt(addr.Address); err != nil { + return true, fmt.Errorf("sending rcpt to: %s", err) + } + } + + // Send the email body. + wc, err := c.Data() + if err != nil { + return true, err + } + defer wc.Close() + + for header, t := range n.conf.Headers { + value, err := n.tmpl.ExecuteTextString(t, data) + if err != nil { + return false, fmt.Errorf("executing %q header template: %s", header, err) + } + fmt.Fprintf(wc, "%s: %s\r\n", header, mime.QEncoding.Encode("utf-8", value)) + } + + buffer := &bytes.Buffer{} + multipartWriter := multipart.NewWriter(buffer) + + fmt.Fprintf(wc, "Date: %s\r\n", time.Now().Format(time.RFC1123Z)) + fmt.Fprintf(wc, "Content-Type: multipart/alternative; boundary=%s\r\n", multipartWriter.Boundary()) + fmt.Fprintf(wc, "MIME-Version: 1.0\r\n") + + // TODO: Add some useful headers here, such as URL of the alertmanager + // and active/resolved. + fmt.Fprintf(wc, "\r\n") + + if len(n.conf.Text) > 0 { + // Text template + w, err := multipartWriter.CreatePart(textproto.MIMEHeader{"Content-Type": {"text/plain; charset=UTF-8"}}) + if err != nil { + return false, fmt.Errorf("creating part for text template: %s", err) + } + body, err := n.tmpl.ExecuteTextString(n.conf.Text, data) + if err != nil { + return false, fmt.Errorf("executing email text template: %s", err) + } + _, err = w.Write([]byte(body)) + if err != nil { + return true, err + } + } + + if len(n.conf.HTML) > 0 { + // Html template + // Preferred alternative placed last per section 5.1.4 of RFC 2046 + // https://www.ietf.org/rfc/rfc2046.txt + w, err := multipartWriter.CreatePart(textproto.MIMEHeader{"Content-Type": {"text/html; charset=UTF-8"}}) + if err != nil { + return false, fmt.Errorf("creating part for html template: %s", err) + } + body, err := n.tmpl.ExecuteHTMLString(n.conf.HTML, data) + if err != nil { + return false, fmt.Errorf("executing email html template: %s", err) + } + _, err = w.Write([]byte(body)) + if err != nil { + return true, err + } + } + + multipartWriter.Close() + wc.Write(buffer.Bytes()) + + return false, nil +} + +// PagerDuty implements a Notifier for PagerDuty notifications. +type PagerDuty struct { + conf *config.PagerdutyConfig + tmpl *template.Template + logger log.Logger +} + +// NewPagerDuty returns a new PagerDuty notifier. +func NewPagerDuty(c *config.PagerdutyConfig, t *template.Template, l log.Logger) *PagerDuty { + return &PagerDuty{conf: c, tmpl: t, logger: l} +} + +const ( + pagerDutyEventTrigger = "trigger" + pagerDutyEventResolve = "resolve" +) + +type pagerDutyMessage struct { + RoutingKey string `json:"routing_key,omitempty"` + ServiceKey string `json:"service_key,omitempty"` + DedupKey string `json:"dedup_key,omitempty"` + IncidentKey string `json:"incident_key,omitempty"` + EventType string `json:"event_type,omitempty"` + Description string `json:"description,omitempty"` + EventAction string `json:"event_action"` + Payload *pagerDutyPayload `json:"payload"` + Client string `json:"client,omitempty"` + ClientURL string `json:"client_url,omitempty"` + Details map[string]string `json:"details,omitempty"` +} + +type pagerDutyPayload struct { + Summary string `json:"summary"` + Source string `json:"source"` + Severity string `json:"severity"` + Timestamp string `json:"timestamp,omitempty"` + Class string `json:"class,omitempty"` + Component string `json:"component,omitempty"` + Group string `json:"group,omitempty"` + CustomDetails map[string]string `json:"custom_details,omitempty"` +} + +func (n *PagerDuty) notifyV1(ctx context.Context, c *http.Client, eventType, key string, tmpl func(string) string, details map[string]string, as ...*types.Alert) (bool, error) { + + msg := &pagerDutyMessage{ + ServiceKey: tmpl(string(n.conf.ServiceKey)), + EventType: eventType, + IncidentKey: hashKey(key), + Description: tmpl(n.conf.Description), + Details: details, + } + + n.conf.URL = "https://events.pagerduty.com/generic/2010-04-15/create_event.json" + + if eventType == pagerDutyEventTrigger { + msg.Client = tmpl(n.conf.Client) + msg.ClientURL = tmpl(n.conf.ClientURL) + } + + var buf bytes.Buffer + if err := json.NewEncoder(&buf).Encode(msg); err != nil { + return false, err + } + + resp, err := ctxhttp.Post(ctx, c, n.conf.URL, contentTypeJSON, &buf) + if err != nil { + return true, err + } + defer resp.Body.Close() + + return n.retryV1(resp.StatusCode) +} + +func (n *PagerDuty) notifyV2(ctx context.Context, c *http.Client, eventType, key string, tmpl func(string) string, details map[string]string, as ...*types.Alert) (bool, error) { + if n.conf.Severity == "" { + n.conf.Severity = "error" + } + + var payload *pagerDutyPayload + if eventType == pagerDutyEventTrigger { + payload = &pagerDutyPayload{ + Summary: tmpl(n.conf.Description), + Source: tmpl(n.conf.Client), + Severity: tmpl(n.conf.Severity), + CustomDetails: details, + Class: tmpl(n.conf.Class), + Component: tmpl(n.conf.Component), + Group: tmpl(n.conf.Group), + } + } + + msg := &pagerDutyMessage{ + RoutingKey: tmpl(string(n.conf.RoutingKey)), + EventAction: eventType, + DedupKey: hashKey(key), + Payload: payload, + } + + if eventType == pagerDutyEventTrigger { + msg.Client = tmpl(n.conf.Client) + msg.ClientURL = tmpl(n.conf.ClientURL) + } + + var buf bytes.Buffer + if err := json.NewEncoder(&buf).Encode(msg); err != nil { + return false, err + } + + resp, err := ctxhttp.Post(ctx, c, n.conf.URL, contentTypeJSON, &buf) + if err != nil { + return true, err + } + defer resp.Body.Close() + + return n.retryV2(resp.StatusCode) +} + +// Notify implements the Notifier interface. +// +// https://v2.developer.pagerduty.com/docs/events-api-v2 +func (n *PagerDuty) Notify(ctx context.Context, as ...*types.Alert) (bool, error) { + key, ok := GroupKey(ctx) + if !ok { + return false, fmt.Errorf("group key missing") + } + + var err error + var ( + alerts = types.Alerts(as...) + data = n.tmpl.Data(receiverName(ctx, n.logger), groupLabels(ctx, n.logger), as...) + tmpl = tmplText(n.tmpl, data, &err) + eventType = pagerDutyEventTrigger + ) + if alerts.Status() == model.AlertResolved { + eventType = pagerDutyEventResolve + } + + level.Debug(n.logger).Log("msg", "Notifying PagerDuty", "incident", key, "eventType", eventType) + + details := make(map[string]string, len(n.conf.Details)) + for k, v := range n.conf.Details { + details[k] = tmpl(v) + } + + if err != nil { + return false, err + } + + c, err := commoncfg.NewClientFromConfig(*n.conf.HTTPConfig, "pagerduty") + if err != nil { + return false, err + } + + if n.conf.ServiceKey != "" { + return n.notifyV1(ctx, c, eventType, key, tmpl, details, as...) + } + return n.notifyV2(ctx, c, eventType, key, tmpl, details, as...) +} + +func (n *PagerDuty) retryV1(statusCode int) (bool, error) { + // Retrying can solve the issue on 403 (rate limiting) and 5xx response codes. + // 2xx response codes indicate a successful request. + // https://v2.developer.pagerduty.com/docs/trigger-events + if statusCode/100 != 2 { + return (statusCode == 403 || statusCode/100 == 5), fmt.Errorf("unexpected status code %v", statusCode) + } + + return false, nil +} + +func (n *PagerDuty) retryV2(statusCode int) (bool, error) { + // Retrying can solve the issue on 429 (rate limiting) and 5xx response codes. + // 2xx response codes indicate a successful request. + // https://v2.developer.pagerduty.com/docs/events-api-v2#api-response-codes--retry-logic + if statusCode/100 != 2 { + return (statusCode == 429 || statusCode/100 == 5), fmt.Errorf("unexpected status code %v", statusCode) + } + + return false, nil +} + +// Slack implements a Notifier for Slack notifications. +type Slack struct { + conf *config.SlackConfig + tmpl *template.Template + logger log.Logger +} + +// NewSlack returns a new Slack notification handler. +func NewSlack(c *config.SlackConfig, t *template.Template, l log.Logger) *Slack { + return &Slack{ + conf: c, + tmpl: t, + logger: l, + } +} + +// slackReq is the request for sending a slack notification. +type slackReq struct { + Channel string `json:"channel,omitempty"` + Username string `json:"username,omitempty"` + IconEmoji string `json:"icon_emoji,omitempty"` + IconURL string `json:"icon_url,omitempty"` + LinkNames bool `json:"link_names,omitempty"` + Attachments []slackAttachment `json:"attachments"` +} + +// slackAttachment is used to display a richly-formatted message block. +type slackAttachment struct { + Title string `json:"title,omitempty"` + TitleLink string `json:"title_link,omitempty"` + Pretext string `json:"pretext,omitempty"` + Text string `json:"text"` + Fallback string `json:"fallback"` + Fields []config.SlackField `json:"fields,omitempty"` + Actions []config.SlackAction `json:"actions,omitempty"` + Footer string `json:"footer"` + + Color string `json:"color,omitempty"` + MrkdwnIn []string `json:"mrkdwn_in,omitempty"` +} + +// Notify implements the Notifier interface. +func (n *Slack) Notify(ctx context.Context, as ...*types.Alert) (bool, error) { + var err error + var ( + data = n.tmpl.Data(receiverName(ctx, n.logger), groupLabels(ctx, n.logger), as...) + tmplText = tmplText(n.tmpl, data, &err) + ) + + attachment := &slackAttachment{ + Title: tmplText(n.conf.Title), + TitleLink: tmplText(n.conf.TitleLink), + Pretext: tmplText(n.conf.Pretext), + Text: tmplText(n.conf.Text), + Fallback: tmplText(n.conf.Fallback), + Footer: tmplText(n.conf.Footer), + Color: tmplText(n.conf.Color), + MrkdwnIn: []string{"fallback", "pretext", "text"}, + } + + var numFields = len(n.conf.Fields) + if numFields > 0 { + var fields = make([]config.SlackField, numFields) + for index, field := range n.conf.Fields { + // Check if short was defined for the field otherwise fallback to the global setting + var short bool + if field.Short != nil { + short = *field.Short + } else { + short = n.conf.ShortFields + } + + // Rebuild the field by executing any templates and setting the new value for short + fields[index] = config.SlackField{ + Title: tmplText(field.Title), + Value: tmplText(field.Value), + Short: &short, + } + } + attachment.Fields = fields + } + + var numActions = len(n.conf.Actions) + if numActions > 0 { + var actions = make([]config.SlackAction, numActions) + for index, action := range n.conf.Actions { + actions[index] = config.SlackAction{ + Type: tmplText(action.Type), + Text: tmplText(action.Text), + URL: tmplText(action.URL), + Style: tmplText(action.Style), + } + } + attachment.Actions = actions + } + + req := &slackReq{ + Channel: tmplText(n.conf.Channel), + Username: tmplText(n.conf.Username), + IconEmoji: tmplText(n.conf.IconEmoji), + IconURL: tmplText(n.conf.IconURL), + LinkNames: n.conf.LinkNames, + Attachments: []slackAttachment{*attachment}, + } + if err != nil { + return false, err + } + + var buf bytes.Buffer + if err := json.NewEncoder(&buf).Encode(req); err != nil { + return false, err + } + + c, err := commoncfg.NewClientFromConfig(*n.conf.HTTPConfig, "slack") + if err != nil { + return false, err + } + + resp, err := ctxhttp.Post(ctx, c, string(n.conf.APIURL), contentTypeJSON, &buf) + if err != nil { + return true, err + } + resp.Body.Close() + + return n.retry(resp.StatusCode) +} + +func (n *Slack) retry(statusCode int) (bool, error) { + // Only 5xx response codes are recoverable and 2xx codes are successful. + // https://api.slack.com/incoming-webhooks#handling_errors + // https://api.slack.com/changelog/2016-05-17-changes-to-errors-for-incoming-webhooks + if statusCode/100 != 2 { + return (statusCode/100 == 5), fmt.Errorf("unexpected status code %v", statusCode) + } + + return false, nil +} + +// Hipchat implements a Notifier for Hipchat notifications. +type Hipchat struct { + conf *config.HipchatConfig + tmpl *template.Template + logger log.Logger +} + +// NewHipchat returns a new Hipchat notification handler. +func NewHipchat(c *config.HipchatConfig, t *template.Template, l log.Logger) *Hipchat { + return &Hipchat{ + conf: c, + tmpl: t, + logger: l, + } +} + +type hipchatReq struct { + From string `json:"from"` + Notify bool `json:"notify"` + Message string `json:"message"` + MessageFormat string `json:"message_format"` + Color string `json:"color"` +} + +// Notify implements the Notifier interface. +func (n *Hipchat) Notify(ctx context.Context, as ...*types.Alert) (bool, error) { + var err error + var msg string + var ( + data = n.tmpl.Data(receiverName(ctx, n.logger), groupLabels(ctx, n.logger), as...) + tmplText = tmplText(n.tmpl, data, &err) + tmplHTML = tmplHTML(n.tmpl, data, &err) + url = fmt.Sprintf("%sv2/room/%s/notification?auth_token=%s", n.conf.APIURL, n.conf.RoomID, n.conf.AuthToken) + ) + + if n.conf.MessageFormat == "html" { + msg = tmplHTML(n.conf.Message) + } else { + msg = tmplText(n.conf.Message) + } + + req := &hipchatReq{ + From: tmplText(n.conf.From), + Notify: n.conf.Notify, + Message: msg, + MessageFormat: n.conf.MessageFormat, + Color: tmplText(n.conf.Color), + } + if err != nil { + return false, err + } + + var buf bytes.Buffer + if err := json.NewEncoder(&buf).Encode(req); err != nil { + return false, err + } + + c, err := commoncfg.NewClientFromConfig(*n.conf.HTTPConfig, "hipchat") + if err != nil { + return false, err + } + + resp, err := ctxhttp.Post(ctx, c, url, contentTypeJSON, &buf) + if err != nil { + return true, err + } + + defer resp.Body.Close() + + return n.retry(resp.StatusCode) +} + +func (n *Hipchat) retry(statusCode int) (bool, error) { + // Response codes 429 (rate limiting) and 5xx can potentially recover. 2xx + // responce codes indicate successful requests. + // https://developer.atlassian.com/hipchat/guide/hipchat-rest-api/api-response-codes + if statusCode/100 != 2 { + return (statusCode == 429 || statusCode/100 == 5), fmt.Errorf("unexpected status code %v", statusCode) + } + + return false, nil +} + +// Wechat implements a Notfier for wechat notifications +type Wechat struct { + conf *config.WechatConfig + tmpl *template.Template + logger log.Logger + + accessToken string + accessTokenAt time.Time +} + +// Wechat AccessToken with corpid and corpsecret. +type WechatToken struct { + AccessToken string `json:"access_token"` +} + +type weChatMessage struct { + Text weChatMessageContent `yaml:"text,omitempty" json:"text,omitempty"` + ToUser string `yaml:"touser,omitempty" json:"touser,omitempty"` + ToParty string `yaml:"toparty,omitempty" json:"toparty,omitempty"` + Totag string `yaml:"totag,omitempty" json:"totag,omitempty"` + AgentID string `yaml:"agentid,omitempty" json:"agentid,omitempty"` + Safe string `yaml:"safe,omitempty" json:"safe,omitempty"` + Type string `yaml:"msgtype,omitempty" json:"msgtype,omitempty"` +} + +type weChatMessageContent struct { + Content string `json:"content"` +} + +type weChatResponse struct { + Code int `json:"code"` + Error string `json:"error"` +} + +// NewWechat returns a new Wechat notifier. +func NewWechat(c *config.WechatConfig, t *template.Template, l log.Logger) *Wechat { + return &Wechat{conf: c, tmpl: t, logger: l} +} + +// Notify implements the Notifier interface. +func (n *Wechat) Notify(ctx context.Context, as ...*types.Alert) (bool, error) { + key, ok := GroupKey(ctx) + if !ok { + return false, fmt.Errorf("group key missing") + } + + level.Debug(n.logger).Log("msg", "Notifying Wechat", "incident", key) + data := n.tmpl.Data(receiverName(ctx, n.logger), groupLabels(ctx, n.logger), as...) + + var err error + tmpl := tmplText(n.tmpl, data, &err) + if err != nil { + return false, err + } + + c, err := commoncfg.NewClientFromConfig(*n.conf.HTTPConfig, "wechat") + if err != nil { + return false, err + } + + // Refresh AccessToken over 2 hours + if n.accessToken == "" || time.Now().Sub(n.accessTokenAt) > 2*time.Hour { + parameters := url.Values{} + parameters.Add("corpsecret", tmpl(string(n.conf.APISecret))) + parameters.Add("corpid", tmpl(string(n.conf.CorpID))) + + apiURL := n.conf.APIURL + "gettoken" + + u, err := url.Parse(apiURL) + if err != nil { + return false, err + } + + u.RawQuery = parameters.Encode() + + level.Debug(n.logger).Log("msg", "Sending Wechat message", "incident", key, "url", u.String()) + + req, err := http.NewRequest(http.MethodGet, u.String(), nil) + if err != nil { + return true, err + } + + req.Header.Set("Content-Type", contentTypeJSON) + + resp, err := c.Do(req.WithContext(ctx)) + if err != nil { + return true, err + } + defer resp.Body.Close() + + var wechatToken WechatToken + if err := json.NewDecoder(resp.Body).Decode(&wechatToken); err != nil { + return false, err + } + + if wechatToken.AccessToken == "" { + return false, fmt.Errorf("invalid APISecret for CorpID: %s", n.conf.CorpID) + } + + // Cache accessToken + n.accessToken = wechatToken.AccessToken + n.accessTokenAt = time.Now() + } + + msg := &weChatMessage{ + Text: weChatMessageContent{ + Content: tmpl(n.conf.Message), + }, + ToUser: tmpl(n.conf.ToUser), + ToParty: tmpl(n.conf.ToParty), + Totag: tmpl(n.conf.ToTag), + AgentID: tmpl(n.conf.AgentID), + Type: "text", + Safe: "0", + } + + var buf bytes.Buffer + if err := json.NewEncoder(&buf).Encode(msg); err != nil { + return false, err + } + + postMessageURL := n.conf.APIURL + "message/send?access_token=" + n.accessToken + + req, err := http.NewRequest(http.MethodPost, postMessageURL, &buf) + if err != nil { + return true, err + } + + resp, err := c.Do(req.WithContext(ctx)) + if err != nil { + return true, err + } + defer resp.Body.Close() + + body, _ := ioutil.ReadAll(resp.Body) + level.Debug(n.logger).Log("msg", "response: "+string(body), "incident", key) + + if resp.StatusCode != 200 { + return true, fmt.Errorf("unexpected status code %v", resp.StatusCode) + } else { + var weResp weChatResponse + if err := json.Unmarshal(body, &weResp); err != nil { + return true, err + } + + // https://work.weixin.qq.com/api/doc#10649 + if weResp.Code == 0 { + return false, nil + } + + // AccessToken is expired + if weResp.Code == 42001 { + n.accessToken = "" + return true, errors.New(weResp.Error) + } + + return false, errors.New(weResp.Error) + } +} + +// OpsGenie implements a Notifier for OpsGenie notifications. +type OpsGenie struct { + conf *config.OpsGenieConfig + tmpl *template.Template + logger log.Logger +} + +// NewOpsGenie returns a new OpsGenie notifier. +func NewOpsGenie(c *config.OpsGenieConfig, t *template.Template, l log.Logger) *OpsGenie { + return &OpsGenie{conf: c, tmpl: t, logger: l} +} + +type opsGenieCreateMessage struct { + Alias string `json:"alias"` + Message string `json:"message"` + Description string `json:"description,omitempty"` + Details map[string]string `json:"details"` + Source string `json:"source"` + Teams []map[string]string `json:"teams,omitempty"` + Tags []string `json:"tags,omitempty"` + Note string `json:"note,omitempty"` + Priority string `json:"priority,omitempty"` +} + +type opsGenieCloseMessage struct { + Source string `json:"source"` +} + +// Notify implements the Notifier interface. +func (n *OpsGenie) Notify(ctx context.Context, as ...*types.Alert) (bool, error) { + req, retry, err := n.createRequest(ctx, as...) + if err != nil { + return retry, err + } + + c, err := commoncfg.NewClientFromConfig(*n.conf.HTTPConfig, "opsgenie") + if err != nil { + return false, err + } + + resp, err := ctxhttp.Do(ctx, c, req) + + if err != nil { + return true, err + } + defer resp.Body.Close() + + return n.retry(resp.StatusCode) +} + +// Like Split but filter out empty strings. +func safeSplit(s string, sep string) []string { + a := strings.Split(strings.TrimSpace(s), sep) + b := a[:0] + for _, x := range a { + if x != "" { + b = append(b, x) + } + } + return b +} + +// Create requests for a list of alerts. +func (n *OpsGenie) createRequest(ctx context.Context, as ...*types.Alert) (*http.Request, bool, error) { + key, ok := GroupKey(ctx) + if !ok { + return nil, false, fmt.Errorf("group key missing") + } + data := n.tmpl.Data(receiverName(ctx, n.logger), groupLabels(ctx, n.logger), as...) + + level.Debug(n.logger).Log("msg", "Notifying OpsGenie", "incident", key) + + var err error + tmpl := tmplText(n.tmpl, data, &err) + + details := make(map[string]string, len(n.conf.Details)) + for k, v := range n.conf.Details { + details[k] = tmpl(v) + } + + var ( + msg interface{} + apiURL string + alias = hashKey(key) + alerts = types.Alerts(as...) + ) + switch alerts.Status() { + case model.AlertResolved: + apiURL = fmt.Sprintf("%sv2/alerts/%s/close?identifierType=alias", n.conf.APIURL, alias) + msg = &opsGenieCloseMessage{Source: tmpl(n.conf.Source)} + default: + message := tmpl(n.conf.Message) + if len(message) > 130 { + message = message[:127] + "..." + level.Debug(n.logger).Log("msg", "Truncated message to %q due to OpsGenie message limit", "truncated_message", message, "incident", key) + } + + apiURL = n.conf.APIURL + "v2/alerts" + var teams []map[string]string + for _, t := range safeSplit(string(tmpl(n.conf.Teams)), ",") { + teams = append(teams, map[string]string{"name": t}) + } + tags := safeSplit(string(tmpl(n.conf.Tags)), ",") + + msg = &opsGenieCreateMessage{ + Alias: alias, + Message: message, + Description: tmpl(n.conf.Description), + Details: details, + Source: tmpl(n.conf.Source), + Teams: teams, + Tags: tags, + Note: tmpl(n.conf.Note), + Priority: tmpl(n.conf.Priority), + } + } + if err != nil { + return nil, false, fmt.Errorf("templating error: %s", err) + } + + var buf bytes.Buffer + if err := json.NewEncoder(&buf).Encode(msg); err != nil { + return nil, false, err + } + + req, err := http.NewRequest("POST", apiURL, &buf) + if err != nil { + return nil, true, err + } + req.Header.Set("Content-Type", contentTypeJSON) + req.Header.Set("Authorization", fmt.Sprintf("GenieKey %s", n.conf.APIKey)) + return req, true, nil +} + +func (n *OpsGenie) retry(statusCode int) (bool, error) { + // https://docs.opsgenie.com/docs/response#section-response-codes + // Response codes 429 (rate limiting) and 5xx are potentially recoverable + if statusCode/100 == 5 || statusCode == 429 { + return true, fmt.Errorf("unexpected status code %v", statusCode) + } else if statusCode/100 != 2 { + return false, fmt.Errorf("unexpected status code %v", statusCode) + } + + return false, nil +} + +// VictorOps implements a Notifier for VictorOps notifications. +type VictorOps struct { + conf *config.VictorOpsConfig + tmpl *template.Template + logger log.Logger +} + +// NewVictorOps returns a new VictorOps notifier. +func NewVictorOps(c *config.VictorOpsConfig, t *template.Template, l log.Logger) *VictorOps { + return &VictorOps{ + conf: c, + tmpl: t, + logger: l, + } +} + +const ( + victorOpsEventTrigger = "CRITICAL" + victorOpsEventResolve = "RECOVERY" +) + +type victorOpsMessage struct { + MessageType string `json:"message_type"` + EntityID string `json:"entity_id"` + EntityDisplayName string `json:"entity_display_name"` + StateMessage string `json:"state_message"` + MonitoringTool string `json:"monitoring_tool"` +} + +// Notify implements the Notifier interface. +func (n *VictorOps) Notify(ctx context.Context, as ...*types.Alert) (bool, error) { + victorOpsAllowedEvents := map[string]bool{ + "INFO": true, + "WARNING": true, + "CRITICAL": true, + } + + key, ok := GroupKey(ctx) + if !ok { + return false, fmt.Errorf("group key missing") + } + + var err error + var ( + alerts = types.Alerts(as...) + data = n.tmpl.Data(receiverName(ctx, n.logger), groupLabels(ctx, n.logger), as...) + tmpl = tmplText(n.tmpl, data, &err) + apiURL = fmt.Sprintf("%s%s/%s", n.conf.APIURL, n.conf.APIKey, tmpl(n.conf.RoutingKey)) + messageType = tmpl(n.conf.MessageType) + stateMessage = tmpl(n.conf.StateMessage) + ) + + if alerts.Status() == model.AlertFiring && !victorOpsAllowedEvents[messageType] { + messageType = victorOpsEventTrigger + } + + if alerts.Status() == model.AlertResolved { + messageType = victorOpsEventResolve + } + + if len(stateMessage) > 20480 { + stateMessage = stateMessage[0:20475] + "\n..." + level.Debug(n.logger).Log("msg", "Truncated stateMessage due to VictorOps stateMessage limit", "truncated_state_message", stateMessage, "incident", key) + } + + msg := &victorOpsMessage{ + MessageType: messageType, + EntityID: hashKey(key), + EntityDisplayName: tmpl(n.conf.EntityDisplayName), + StateMessage: stateMessage, + MonitoringTool: tmpl(n.conf.MonitoringTool), + } + + if err != nil { + return false, fmt.Errorf("templating error: %s", err) + } + + var buf bytes.Buffer + if err := json.NewEncoder(&buf).Encode(msg); err != nil { + return false, err + } + + c, err := commoncfg.NewClientFromConfig(*n.conf.HTTPConfig, "victorops") + if err != nil { + return false, err + } + + resp, err := ctxhttp.Post(ctx, c, apiURL, contentTypeJSON, &buf) + if err != nil { + return true, err + } + + defer resp.Body.Close() + + return n.retry(resp.StatusCode) +} + +func (n *VictorOps) retry(statusCode int) (bool, error) { + // Missing documentation therefore assuming only 5xx response codes are + // recoverable. + if statusCode/100 == 5 { + return true, fmt.Errorf("unexpected status code %v", statusCode) + } else if statusCode/100 != 2 { + return false, fmt.Errorf("unexpected status code %v", statusCode) + } + + return false, nil +} + +// Pushover implements a Notifier for Pushover notifications. +type Pushover struct { + conf *config.PushoverConfig + tmpl *template.Template + logger log.Logger +} + +// NewPushover returns a new Pushover notifier. +func NewPushover(c *config.PushoverConfig, t *template.Template, l log.Logger) *Pushover { + return &Pushover{conf: c, tmpl: t, logger: l} +} + +// Notify implements the Notifier interface. +func (n *Pushover) Notify(ctx context.Context, as ...*types.Alert) (bool, error) { + key, ok := GroupKey(ctx) + if !ok { + return false, fmt.Errorf("group key missing") + } + data := n.tmpl.Data(receiverName(ctx, n.logger), groupLabels(ctx, n.logger), as...) + + level.Debug(n.logger).Log("msg", "Notifying Pushover", "incident", key) + + var err error + tmpl := tmplText(n.tmpl, data, &err) + + parameters := url.Values{} + parameters.Add("token", tmpl(string(n.conf.Token))) + parameters.Add("user", tmpl(string(n.conf.UserKey))) + + title := tmpl(n.conf.Title) + if len(title) > 250 { + title = title[:247] + "..." + level.Debug(n.logger).Log("msg", "Truncated title due to Pushover title limit", "truncated_title", title, "incident", key) + } + parameters.Add("title", title) + + message := tmpl(n.conf.Message) + if len(message) > 1024 { + message = message[:1021] + "..." + level.Debug(n.logger).Log("msg", "Truncated message due to Pushover message limit", "truncated_message", message, "incident", key) + } + message = strings.TrimSpace(message) + if message == "" { + // Pushover rejects empty messages. + message = "(no details)" + } + parameters.Add("message", message) + + supplementaryURL := tmpl(n.conf.URL) + if len(supplementaryURL) > 512 { + supplementaryURL = supplementaryURL[:509] + "..." + level.Debug(n.logger).Log("msg", "Truncated URL due to Pushover url limit", "truncated_url", supplementaryURL, "incident", key) + } + parameters.Add("url", supplementaryURL) + + parameters.Add("priority", tmpl(n.conf.Priority)) + parameters.Add("retry", fmt.Sprintf("%d", int64(time.Duration(n.conf.Retry).Seconds()))) + parameters.Add("expire", fmt.Sprintf("%d", int64(time.Duration(n.conf.Expire).Seconds()))) + if err != nil { + return false, err + } + + apiURL := "https://api.pushover.net/1/messages.json" + u, err := url.Parse(apiURL) + if err != nil { + return false, err + } + u.RawQuery = parameters.Encode() + level.Debug(n.logger).Log("msg", "Sending Pushover message", "incident", key, "url", u.String()) + + c, err := commoncfg.NewClientFromConfig(*n.conf.HTTPConfig, "pushover") + if err != nil { + return false, err + } + + resp, err := ctxhttp.Post(ctx, c, u.String(), "text/plain", nil) + if err != nil { + return true, err + } + defer resp.Body.Close() + + return n.retry(resp.StatusCode) +} + +func (n *Pushover) retry(statusCode int) (bool, error) { + // Only documented behaviour is that 2xx response codes are successful and + // 4xx are unsuccessful, therefore assuming only 5xx are recoverable. + // https://pushover.net/api#response + if statusCode/100 == 5 { + return true, fmt.Errorf("unexpected status code %v", statusCode) + } else if statusCode/100 != 2 { + return false, fmt.Errorf("unexpected status code %v", statusCode) + } + + return false, nil +} + +func tmplText(tmpl *template.Template, data *template.Data, err *error) func(string) string { + return func(name string) (s string) { + if *err != nil { + return + } + s, *err = tmpl.ExecuteTextString(name, data) + return s + } +} + +func tmplHTML(tmpl *template.Template, data *template.Data, err *error) func(string) string { + return func(name string) (s string) { + if *err != nil { + return + } + s, *err = tmpl.ExecuteHTMLString(name, data) + return s + } +} + +type loginAuth struct { + username, password string +} + +func LoginAuth(username, password string) smtp.Auth { + return &loginAuth{username, password} +} + +func (a *loginAuth) Start(server *smtp.ServerInfo) (string, []byte, error) { + return "LOGIN", []byte{}, nil +} + +// Used for AUTH LOGIN. (Maybe password should be encrypted) +func (a *loginAuth) Next(fromServer []byte, more bool) ([]byte, error) { + if more { + switch strings.ToLower(string(fromServer)) { + case "username:": + return []byte(a.username), nil + case "password:": + return []byte(a.password), nil + default: + return nil, errors.New("unexpected server challenge") + } + } + return nil, nil +} + +// hashKey returns the sha256 for a group key as integrations may have +// maximum length requirements on deduplication keys. +func hashKey(s string) string { + h := sha256.New() + h.Write([]byte(s)) + return fmt.Sprintf("%x", h.Sum(nil)) +} diff --git a/src/alertmanager/notify/impl_test.go b/src/alertmanager/notify/impl_test.go new file mode 100644 index 0000000..8d97a94 --- /dev/null +++ b/src/alertmanager/notify/impl_test.go @@ -0,0 +1,275 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package notify + +import ( + "fmt" + "io/ioutil" + "net/http" + "net/url" + "testing" + "time" + + "github.com/go-kit/kit/log" + "github.com/stretchr/testify/require" + "golang.org/x/net/context" + + "github.com/prometheus/alertmanager/config" + "github.com/prometheus/alertmanager/template" + "github.com/prometheus/alertmanager/types" + "github.com/prometheus/common/model" +) + +func TestWebhookRetry(t *testing.T) { + notifier := &Webhook{conf: &config.WebhookConfig{URL: "http://example.com/"}} + for statusCode, expected := range retryTests(defaultRetryCodes()) { + actual, _ := notifier.retry(statusCode) + require.Equal(t, expected, actual, fmt.Sprintf("error on status %d", statusCode)) + } +} + +func TestPagerDutyRetryV1(t *testing.T) { + notifier := new(PagerDuty) + + retryCodes := append(defaultRetryCodes(), http.StatusForbidden) + for statusCode, expected := range retryTests(retryCodes) { + actual, _ := notifier.retryV1(statusCode) + require.Equal(t, expected, actual, fmt.Sprintf("retryv1 - error on status %d", statusCode)) + } +} + +func TestPagerDutyRetryV2(t *testing.T) { + notifier := new(PagerDuty) + + retryCodes := append(defaultRetryCodes(), http.StatusTooManyRequests) + for statusCode, expected := range retryTests(retryCodes) { + actual, _ := notifier.retryV2(statusCode) + require.Equal(t, expected, actual, fmt.Sprintf("retryv2 - error on status %d", statusCode)) + } +} + +func TestSlackRetry(t *testing.T) { + notifier := new(Slack) + for statusCode, expected := range retryTests(defaultRetryCodes()) { + actual, _ := notifier.retry(statusCode) + require.Equal(t, expected, actual, fmt.Sprintf("error on status %d", statusCode)) + } +} + +func TestHipchatRetry(t *testing.T) { + notifier := new(Hipchat) + retryCodes := append(defaultRetryCodes(), http.StatusTooManyRequests) + for statusCode, expected := range retryTests(retryCodes) { + actual, _ := notifier.retry(statusCode) + require.Equal(t, expected, actual, fmt.Sprintf("error on status %d", statusCode)) + } +} + +func TestOpsGenieRetry(t *testing.T) { + notifier := new(OpsGenie) + + retryCodes := append(defaultRetryCodes(), http.StatusTooManyRequests) + for statusCode, expected := range retryTests(retryCodes) { + actual, _ := notifier.retry(statusCode) + require.Equal(t, expected, actual, fmt.Sprintf("error on status %d", statusCode)) + } +} + +func TestVictorOpsRetry(t *testing.T) { + notifier := new(VictorOps) + for statusCode, expected := range retryTests(defaultRetryCodes()) { + actual, _ := notifier.retry(statusCode) + require.Equal(t, expected, actual, fmt.Sprintf("error on status %d", statusCode)) + } +} + +func TestPushoverRetry(t *testing.T) { + notifier := new(Pushover) + for statusCode, expected := range retryTests(defaultRetryCodes()) { + actual, _ := notifier.retry(statusCode) + require.Equal(t, expected, actual, fmt.Sprintf("error on status %d", statusCode)) + } +} + +func retryTests(retryCodes []int) map[int]bool { + tests := map[int]bool{ + // 1xx + http.StatusContinue: false, + http.StatusSwitchingProtocols: false, + http.StatusProcessing: false, + + // 2xx + http.StatusOK: false, + http.StatusCreated: false, + http.StatusAccepted: false, + http.StatusNonAuthoritativeInfo: false, + http.StatusNoContent: false, + http.StatusResetContent: false, + http.StatusPartialContent: false, + http.StatusMultiStatus: false, + http.StatusAlreadyReported: false, + http.StatusIMUsed: false, + + // 3xx + http.StatusMultipleChoices: false, + http.StatusMovedPermanently: false, + http.StatusFound: false, + http.StatusSeeOther: false, + http.StatusNotModified: false, + http.StatusUseProxy: false, + http.StatusTemporaryRedirect: false, + http.StatusPermanentRedirect: false, + + // 4xx + http.StatusBadRequest: false, + http.StatusUnauthorized: false, + http.StatusPaymentRequired: false, + http.StatusForbidden: false, + http.StatusNotFound: false, + http.StatusMethodNotAllowed: false, + http.StatusNotAcceptable: false, + http.StatusProxyAuthRequired: false, + http.StatusRequestTimeout: false, + http.StatusConflict: false, + http.StatusGone: false, + http.StatusLengthRequired: false, + http.StatusPreconditionFailed: false, + http.StatusRequestEntityTooLarge: false, + http.StatusRequestURITooLong: false, + http.StatusUnsupportedMediaType: false, + http.StatusRequestedRangeNotSatisfiable: false, + http.StatusExpectationFailed: false, + http.StatusTeapot: false, + http.StatusUnprocessableEntity: false, + http.StatusLocked: false, + http.StatusFailedDependency: false, + http.StatusUpgradeRequired: false, + http.StatusPreconditionRequired: false, + http.StatusTooManyRequests: false, + http.StatusRequestHeaderFieldsTooLarge: false, + http.StatusUnavailableForLegalReasons: false, + + // 5xx + http.StatusInternalServerError: false, + http.StatusNotImplemented: false, + http.StatusBadGateway: false, + http.StatusServiceUnavailable: false, + http.StatusGatewayTimeout: false, + http.StatusHTTPVersionNotSupported: false, + http.StatusVariantAlsoNegotiates: false, + http.StatusInsufficientStorage: false, + http.StatusLoopDetected: false, + http.StatusNotExtended: false, + http.StatusNetworkAuthenticationRequired: false, + } + + for _, statusCode := range retryCodes { + tests[statusCode] = true + } + + return tests +} + +func defaultRetryCodes() []int { + return []int{ + http.StatusInternalServerError, + http.StatusNotImplemented, + http.StatusBadGateway, + http.StatusServiceUnavailable, + http.StatusGatewayTimeout, + http.StatusHTTPVersionNotSupported, + http.StatusVariantAlsoNegotiates, + http.StatusInsufficientStorage, + http.StatusLoopDetected, + http.StatusNotExtended, + http.StatusNetworkAuthenticationRequired, + } +} + +func createTmpl(t *testing.T) *template.Template { + tmpl, err := template.FromGlobs() + require.NoError(t, err) + tmpl.ExternalURL, _ = url.Parse("http://am") + return tmpl +} + +func readBody(t *testing.T, r *http.Request) string { + body, err := ioutil.ReadAll(r.Body) + require.NoError(t, err) + return string(body) +} + +func TestOpsGenie(t *testing.T) { + logger := log.NewNopLogger() + tmpl := createTmpl(t) + conf := &config.OpsGenieConfig{ + NotifierConfig: config.NotifierConfig{ + VSendResolved: true, + }, + Message: `{{ .CommonLabels.Message }}`, + Description: `{{ .CommonLabels.Description }}`, + Source: `{{ .CommonLabels.Source }}`, + Teams: `{{ .CommonLabels.Teams }}`, + Tags: `{{ .CommonLabels.Tags }}`, + Note: `{{ .CommonLabels.Note }}`, + Priority: `{{ .CommonLabels.Priority }}`, + APIKey: `s3cr3t`, + APIURL: `https://opsgenie/api`, + } + notifier := NewOpsGenie(conf, tmpl, logger) + + ctx := context.Background() + ctx = WithGroupKey(ctx, "1") + + expectedUrl, _ := url.Parse("https://opsgenie/apiv2/alerts") + + // Empty alert. + alert1 := &types.Alert{ + Alert: model.Alert{ + StartsAt: time.Now(), + EndsAt: time.Now().Add(time.Hour), + }, + } + expectedBody := `{"alias":"6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b","message":"","details":{},"source":""} +` + req, retry, err := notifier.createRequest(ctx, alert1) + require.NoError(t, err) + require.Equal(t, true, retry) + require.Equal(t, expectedUrl, req.URL) + require.Equal(t, "GenieKey s3cr3t", req.Header.Get("Authorization")) + require.Equal(t, expectedBody, readBody(t, req)) + + // Fully defined alert. + alert2 := &types.Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{ + "Message": "message", + "Description": "description", + "Source": "http://prometheus", + "Teams": "TeamA,TeamB,", + "Tags": "tag1,tag2", + "Note": "this is a note", + "Priotity": "P1", + }, + StartsAt: time.Now(), + EndsAt: time.Now().Add(time.Hour), + }, + } + expectedBody = `{"alias":"6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b","message":"message","description":"description","details":{},"source":"http://prometheus","teams":[{"name":"TeamA"},{"name":"TeamB"}],"tags":["tag1","tag2"],"note":"this is a note"} +` + req, retry, err = notifier.createRequest(ctx, alert2) + require.NoError(t, err) + require.Equal(t, true, retry) + require.Equal(t, expectedBody, readBody(t, req)) +} diff --git a/src/alertmanager/notify/notify.go b/src/alertmanager/notify/notify.go new file mode 100644 index 0000000..75b791e --- /dev/null +++ b/src/alertmanager/notify/notify.go @@ -0,0 +1,723 @@ +// Copyright 2015 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package notify + +import ( + "fmt" + "sort" + "sync" + "time" + + "github.com/cenkalti/backoff" + "github.com/cespare/xxhash" + "github.com/go-kit/kit/log" + "github.com/go-kit/kit/log/level" + "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/common/model" + "golang.org/x/net/context" + + "github.com/prometheus/alertmanager/cluster" + "github.com/prometheus/alertmanager/config" + "github.com/prometheus/alertmanager/nflog" + "github.com/prometheus/alertmanager/nflog/nflogpb" + "github.com/prometheus/alertmanager/silence" + "github.com/prometheus/alertmanager/template" + "github.com/prometheus/alertmanager/types" +) + +var ( + numNotifications = prometheus.NewCounterVec(prometheus.CounterOpts{ + Namespace: "alertmanager", + Name: "notifications_total", + Help: "The total number of attempted notifications.", + }, []string{"integration"}) + + numFailedNotifications = prometheus.NewCounterVec(prometheus.CounterOpts{ + Namespace: "alertmanager", + Name: "notifications_failed_total", + Help: "The total number of failed notifications.", + }, []string{"integration"}) + + notificationLatencySeconds = prometheus.NewHistogramVec(prometheus.HistogramOpts{ + Namespace: "alertmanager", + Name: "notification_latency_seconds", + Help: "The latency of notifications in seconds.", + Buckets: []float64{1, 5, 10, 15, 20}, + }, []string{"integration"}) +) + +func init() { + numNotifications.WithLabelValues("email") + numNotifications.WithLabelValues("hipchat") + numNotifications.WithLabelValues("pagerduty") + numNotifications.WithLabelValues("wechat") + numNotifications.WithLabelValues("pushover") + numNotifications.WithLabelValues("slack") + numNotifications.WithLabelValues("opsgenie") + numNotifications.WithLabelValues("webhook") + numNotifications.WithLabelValues("victorops") + numFailedNotifications.WithLabelValues("email") + numFailedNotifications.WithLabelValues("hipchat") + numFailedNotifications.WithLabelValues("pagerduty") + numFailedNotifications.WithLabelValues("wechat") + numFailedNotifications.WithLabelValues("pushover") + numFailedNotifications.WithLabelValues("slack") + numFailedNotifications.WithLabelValues("opsgenie") + numFailedNotifications.WithLabelValues("webhook") + numFailedNotifications.WithLabelValues("victorops") + notificationLatencySeconds.WithLabelValues("email") + notificationLatencySeconds.WithLabelValues("hipchat") + notificationLatencySeconds.WithLabelValues("pagerduty") + notificationLatencySeconds.WithLabelValues("wechat") + notificationLatencySeconds.WithLabelValues("pushover") + notificationLatencySeconds.WithLabelValues("slack") + notificationLatencySeconds.WithLabelValues("opsgenie") + notificationLatencySeconds.WithLabelValues("webhook") + notificationLatencySeconds.WithLabelValues("victorops") + + prometheus.Register(numNotifications) + prometheus.Register(numFailedNotifications) + prometheus.Register(notificationLatencySeconds) +} + +type notifierConfig interface { + SendResolved() bool +} + +// MinTimeout is the minimum timeout that is set for the context of a call +// to a notification pipeline. +const MinTimeout = 10 * time.Second + +// notifyKey defines a custom type with which a context is populated to +// avoid accidental collisions. +type notifyKey int + +const ( + keyReceiverName notifyKey = iota + keyRepeatInterval + keyGroupLabels + keyGroupKey + keyFiringAlerts + keyResolvedAlerts + keyNow +) + +// WithReceiverName populates a context with a receiver name. +func WithReceiverName(ctx context.Context, rcv string) context.Context { + return context.WithValue(ctx, keyReceiverName, rcv) +} + +// WithGroupKey populates a context with a group key. +func WithGroupKey(ctx context.Context, s string) context.Context { + return context.WithValue(ctx, keyGroupKey, s) +} + +// WithFiringAlerts populates a context with a slice of firing alerts. +func WithFiringAlerts(ctx context.Context, alerts []uint64) context.Context { + return context.WithValue(ctx, keyFiringAlerts, alerts) +} + +// WithResolvedAlerts populates a context with a slice of resolved alerts. +func WithResolvedAlerts(ctx context.Context, alerts []uint64) context.Context { + return context.WithValue(ctx, keyResolvedAlerts, alerts) +} + +// WithGroupLabels populates a context with grouping labels. +func WithGroupLabels(ctx context.Context, lset model.LabelSet) context.Context { + return context.WithValue(ctx, keyGroupLabels, lset) +} + +// WithNow populates a context with a now timestamp. +func WithNow(ctx context.Context, t time.Time) context.Context { + return context.WithValue(ctx, keyNow, t) +} + +// WithRepeatInterval populates a context with a repeat interval. +func WithRepeatInterval(ctx context.Context, t time.Duration) context.Context { + return context.WithValue(ctx, keyRepeatInterval, t) +} + +// RepeatInterval extracts a repeat interval from the context. Iff none exists, the +// second argument is false. +func RepeatInterval(ctx context.Context) (time.Duration, bool) { + v, ok := ctx.Value(keyRepeatInterval).(time.Duration) + return v, ok +} + +// ReceiverName extracts a receiver name from the context. Iff none exists, the +// second argument is false. +func ReceiverName(ctx context.Context) (string, bool) { + v, ok := ctx.Value(keyReceiverName).(string) + return v, ok +} + +func receiverName(ctx context.Context, l log.Logger) string { + recv, ok := ReceiverName(ctx) + if !ok { + level.Error(l).Log("msg", "Missing receiver") + } + return recv +} + +// GroupKey extracts a group key from the context. Iff none exists, the +// second argument is false. +func GroupKey(ctx context.Context) (string, bool) { + v, ok := ctx.Value(keyGroupKey).(string) + return v, ok +} + +func groupLabels(ctx context.Context, l log.Logger) model.LabelSet { + groupLabels, ok := GroupLabels(ctx) + if !ok { + level.Error(l).Log("msg", "Missing group labels") + } + return groupLabels +} + +// GroupLabels extracts grouping label set from the context. Iff none exists, the +// second argument is false. +func GroupLabels(ctx context.Context) (model.LabelSet, bool) { + v, ok := ctx.Value(keyGroupLabels).(model.LabelSet) + return v, ok +} + +// Now extracts a now timestamp from the context. Iff none exists, the +// second argument is false. +func Now(ctx context.Context) (time.Time, bool) { + v, ok := ctx.Value(keyNow).(time.Time) + return v, ok +} + +// FiringAlerts extracts a slice of firing alerts from the context. +// Iff none exists, the second argument is false. +func FiringAlerts(ctx context.Context) ([]uint64, bool) { + v, ok := ctx.Value(keyFiringAlerts).([]uint64) + return v, ok +} + +// ResolvedAlerts extracts a slice of firing alerts from the context. +// Iff none exists, the second argument is false. +func ResolvedAlerts(ctx context.Context) ([]uint64, bool) { + v, ok := ctx.Value(keyResolvedAlerts).([]uint64) + return v, ok +} + +// A Stage processes alerts under the constraints of the given context. +type Stage interface { + Exec(ctx context.Context, l log.Logger, alerts ...*types.Alert) (context.Context, []*types.Alert, error) +} + +// StageFunc wraps a function to represent a Stage. +type StageFunc func(ctx context.Context, l log.Logger, alerts ...*types.Alert) (context.Context, []*types.Alert, error) + +// Exec implements Stage interface. +func (f StageFunc) Exec(ctx context.Context, l log.Logger, alerts ...*types.Alert) (context.Context, []*types.Alert, error) { + return f(ctx, l, alerts...) +} + +type NotificationLog interface { + Log(r *nflogpb.Receiver, gkey string, firingAlerts, resolvedAlerts []uint64) error + Query(params ...nflog.QueryParam) ([]*nflogpb.Entry, error) +} + +// BuildPipeline builds a map of receivers to Stages. +func BuildPipeline( + confs []*config.Receiver, + tmpl *template.Template, + wait func() time.Duration, + muter types.Muter, + silences *silence.Silences, + notificationLog NotificationLog, + marker types.Marker, + peer *cluster.Peer, + logger log.Logger, +) RoutingStage { + rs := RoutingStage{} + + ms := NewGossipSettleStage(peer) + is := NewInhibitStage(muter) + ss := NewSilenceStage(silences, marker) + + for _, rc := range confs { + rs[rc.Name] = MultiStage{ms, is, ss, createStage(rc, tmpl, wait, notificationLog, logger)} + } + return rs +} + +// createStage creates a pipeline of stages for a receiver. +func createStage(rc *config.Receiver, tmpl *template.Template, wait func() time.Duration, notificationLog NotificationLog, logger log.Logger) Stage { + var fs FanoutStage + for _, i := range BuildReceiverIntegrations(rc, tmpl, logger) { + recv := &nflogpb.Receiver{ + GroupName: rc.Name, + Integration: i.name, + Idx: uint32(i.idx), + } + var s MultiStage + s = append(s, NewWaitStage(wait)) + s = append(s, NewDedupStage(i, notificationLog, recv)) + s = append(s, NewRetryStage(i, rc.Name)) + s = append(s, NewSetNotifiesStage(notificationLog, recv)) + + fs = append(fs, s) + } + return fs +} + +// RoutingStage executes the inner stages based on the receiver specified in +// the context. +type RoutingStage map[string]Stage + +// Exec implements the Stage interface. +func (rs RoutingStage) Exec(ctx context.Context, l log.Logger, alerts ...*types.Alert) (context.Context, []*types.Alert, error) { + receiver, ok := ReceiverName(ctx) + if !ok { + return ctx, nil, fmt.Errorf("receiver missing") + } + + s, ok := rs[receiver] + if !ok { + return ctx, nil, fmt.Errorf("stage for receiver missing") + } + + return s.Exec(ctx, l, alerts...) +} + +// A MultiStage executes a series of stages sequencially. +type MultiStage []Stage + +// Exec implements the Stage interface. +func (ms MultiStage) Exec(ctx context.Context, l log.Logger, alerts ...*types.Alert) (context.Context, []*types.Alert, error) { + var err error + for _, s := range ms { + if len(alerts) == 0 { + return ctx, nil, nil + } + + ctx, alerts, err = s.Exec(ctx, l, alerts...) + if err != nil { + return ctx, nil, err + } + } + return ctx, alerts, nil +} + +// FanoutStage executes its stages concurrently +type FanoutStage []Stage + +// Exec attempts to execute all stages concurrently and discards the results. +// It returns its input alerts and a types.MultiError if one or more stages fail. +func (fs FanoutStage) Exec(ctx context.Context, l log.Logger, alerts ...*types.Alert) (context.Context, []*types.Alert, error) { + var ( + wg sync.WaitGroup + me types.MultiError + ) + wg.Add(len(fs)) + + for _, s := range fs { + go func(s Stage) { + if _, _, err := s.Exec(ctx, l, alerts...); err != nil { + me.Add(err) + level.Error(l).Log("msg", "Error on notify", "err", err) + } + wg.Done() + }(s) + } + wg.Wait() + + if me.Len() > 0 { + return ctx, alerts, &me + } + return ctx, alerts, nil +} + +// GossipSettleStage waits until the Gossip has settled to forward alerts. +type GossipSettleStage struct { + peer *cluster.Peer +} + +// NewGossipSettleStage returns a new GossipSettleStage. +func NewGossipSettleStage(p *cluster.Peer) *GossipSettleStage { + return &GossipSettleStage{peer: p} +} + +func (n *GossipSettleStage) Exec(ctx context.Context, l log.Logger, alerts ...*types.Alert) (context.Context, []*types.Alert, error) { + if n.peer != nil { + n.peer.WaitReady() + } + return ctx, alerts, nil +} + +// InhibitStage filters alerts through an inhibition muter. +type InhibitStage struct { + muter types.Muter +} + +// NewInhibitStage return a new InhibitStage. +func NewInhibitStage(m types.Muter) *InhibitStage { + return &InhibitStage{muter: m} +} + +// Exec implements the Stage interface. +func (n *InhibitStage) Exec(ctx context.Context, l log.Logger, alerts ...*types.Alert) (context.Context, []*types.Alert, error) { + var filtered []*types.Alert + for _, a := range alerts { + // TODO(fabxc): increment total alerts counter. + // Do not send the alert if the silencer mutes it. + if !n.muter.Mutes(a.Labels) { + // TODO(fabxc): increment muted alerts counter. + filtered = append(filtered, a) + } + } + + return ctx, filtered, nil +} + +// SilenceStage filters alerts through a silence muter. +type SilenceStage struct { + silences *silence.Silences + marker types.Marker +} + +// NewSilenceStage returns a new SilenceStage. +func NewSilenceStage(s *silence.Silences, mk types.Marker) *SilenceStage { + return &SilenceStage{ + silences: s, + marker: mk, + } +} + +// Exec implements the Stage interface. +func (n *SilenceStage) Exec(ctx context.Context, l log.Logger, alerts ...*types.Alert) (context.Context, []*types.Alert, error) { + var filtered []*types.Alert + for _, a := range alerts { + // TODO(fabxc): increment total alerts counter. + // Do not send the alert if the silencer mutes it. + sils, err := n.silences.Query( + silence.QState(types.SilenceStateActive), + silence.QMatches(a.Labels), + ) + if err != nil { + level.Error(l).Log("msg", "Querying silences failed", "err", err) + } + + if len(sils) == 0 { + // TODO(fabxc): increment muted alerts counter. + filtered = append(filtered, a) + n.marker.SetSilenced(a.Labels.Fingerprint()) + } else { + ids := make([]string, len(sils)) + for i, s := range sils { + ids[i] = s.Id + } + n.marker.SetSilenced(a.Labels.Fingerprint(), ids...) + } + } + + return ctx, filtered, nil +} + +// WaitStage waits for a certain amount of time before continuing or until the +// context is done. +type WaitStage struct { + wait func() time.Duration +} + +// NewWaitStage returns a new WaitStage. +func NewWaitStage(wait func() time.Duration) *WaitStage { + return &WaitStage{ + wait: wait, + } +} + +// Exec implements the Stage interface. +func (ws *WaitStage) Exec(ctx context.Context, l log.Logger, alerts ...*types.Alert) (context.Context, []*types.Alert, error) { + select { + case <-time.After(ws.wait()): + case <-ctx.Done(): + return ctx, nil, ctx.Err() + } + return ctx, alerts, nil +} + +// DedupStage filters alerts. +// Filtering happens based on a notification log. +type DedupStage struct { + nflog NotificationLog + recv *nflogpb.Receiver + conf notifierConfig + + now func() time.Time + hash func(*types.Alert) uint64 +} + +// NewDedupStage wraps a DedupStage that runs against the given notification log. +func NewDedupStage(i Integration, l NotificationLog, recv *nflogpb.Receiver) *DedupStage { + return &DedupStage{ + nflog: l, + recv: recv, + conf: i.conf, + now: utcNow, + hash: hashAlert, + } +} + +func utcNow() time.Time { + return time.Now().UTC() +} + +var hashBuffers = sync.Pool{} + +func getHashBuffer() []byte { + b := hashBuffers.Get() + if b == nil { + return make([]byte, 0, 1024) + } + return b.([]byte) +} + +func putHashBuffer(b []byte) { + b = b[:0] + hashBuffers.Put(b) +} + +func hashAlert(a *types.Alert) uint64 { + const sep = '\xff' + + b := getHashBuffer() + defer putHashBuffer(b) + + names := make(model.LabelNames, 0, len(a.Labels)) + + for ln := range a.Labels { + names = append(names, ln) + } + sort.Sort(names) + + for _, ln := range names { + b = append(b, string(ln)...) + b = append(b, sep) + b = append(b, string(a.Labels[ln])...) + b = append(b, sep) + } + + hash := xxhash.Sum64(b) + + return hash +} + +func (n *DedupStage) needsUpdate(entry *nflogpb.Entry, firing, resolved map[uint64]struct{}, repeat time.Duration) bool { + // If we haven't notified about the alert group before, notify right away + // unless we only have resolved alerts. + if entry == nil { + return len(firing) > 0 + } + + if !entry.IsFiringSubset(firing) { + return true + } + + // Notify about all alerts being resolved. + // This is done irrespective of the send_resolved flag to make sure that + // the firing alerts are cleared from the notification log. + if len(firing) == 0 { + // If the current alert group and last notification contain no firing + // alert, it means that some alerts have been fired and resolved during the + // last interval. In this case, there is no need to notify the receiver + // since it doesn't know about them. + return len(entry.FiringAlerts) > 0 + } + + if n.conf.SendResolved() && !entry.IsResolvedSubset(resolved) { + return true + } + + // Nothing changed, only notify if the repeat interval has passed. + return entry.Timestamp.Before(n.now().Add(-repeat)) +} + +// Exec implements the Stage interface. +func (n *DedupStage) Exec(ctx context.Context, l log.Logger, alerts ...*types.Alert) (context.Context, []*types.Alert, error) { + gkey, ok := GroupKey(ctx) + if !ok { + return ctx, nil, fmt.Errorf("group key missing") + } + + repeatInterval, ok := RepeatInterval(ctx) + if !ok { + return ctx, nil, fmt.Errorf("repeat interval missing") + } + + firingSet := map[uint64]struct{}{} + resolvedSet := map[uint64]struct{}{} + firing := []uint64{} + resolved := []uint64{} + + var hash uint64 + for _, a := range alerts { + hash = n.hash(a) + if a.Resolved() { + resolved = append(resolved, hash) + resolvedSet[hash] = struct{}{} + } else { + firing = append(firing, hash) + firingSet[hash] = struct{}{} + } + } + + ctx = WithFiringAlerts(ctx, firing) + ctx = WithResolvedAlerts(ctx, resolved) + + entries, err := n.nflog.Query(nflog.QGroupKey(gkey), nflog.QReceiver(n.recv)) + + if err != nil && err != nflog.ErrNotFound { + return ctx, nil, err + } + var entry *nflogpb.Entry + switch len(entries) { + case 0: + case 1: + entry = entries[0] + case 2: + return ctx, nil, fmt.Errorf("unexpected entry result size %d", len(entries)) + } + if n.needsUpdate(entry, firingSet, resolvedSet, repeatInterval) { + return ctx, alerts, nil + } + return ctx, nil, nil +} + +// RetryStage notifies via passed integration with exponential backoff until it +// succeeds. It aborts if the context is canceled or timed out. +type RetryStage struct { + integration Integration + groupName string +} + +// NewRetryStage returns a new instance of a RetryStage. +func NewRetryStage(i Integration, groupName string) *RetryStage { + return &RetryStage{ + integration: i, + groupName: groupName, + } +} + +// Exec implements the Stage interface. +func (r RetryStage) Exec(ctx context.Context, l log.Logger, alerts ...*types.Alert) (context.Context, []*types.Alert, error) { + var sent []*types.Alert + + // If we shouldn't send notifications for resolved alerts, but there are only + // resolved alerts, report them all as successfully notified (we still want the + // notification log to log them for the next run of DedupStage). + if !r.integration.conf.SendResolved() { + firing, ok := FiringAlerts(ctx) + if !ok { + return ctx, nil, fmt.Errorf("firing alerts missing") + } + if len(firing) == 0 { + return ctx, alerts, nil + } + for _, a := range alerts { + if a.Status() != model.AlertResolved { + sent = append(sent, a) + } + } + } else { + sent = alerts + } + + var ( + i = 0 + b = backoff.NewExponentialBackOff() + tick = backoff.NewTicker(b) + iErr error + ) + defer tick.Stop() + + for { + i++ + // Always check the context first to not notify again. + select { + case <-ctx.Done(): + if iErr != nil { + return ctx, nil, iErr + } + + return ctx, nil, ctx.Err() + default: + } + + select { + case <-tick.C: + now := time.Now() + retry, err := r.integration.Notify(ctx, sent...) + notificationLatencySeconds.WithLabelValues(r.integration.name).Observe(time.Since(now).Seconds()) + if err != nil { + numFailedNotifications.WithLabelValues(r.integration.name).Inc() + level.Debug(l).Log("msg", "Notify attempt failed", "attempt", i, "integration", r.integration.name, "receiver", r.groupName, "err", err) + if !retry { + return ctx, alerts, fmt.Errorf("cancelling notify retry for %q due to unrecoverable error: %s", r.integration.name, err) + } + + // Save this error to be able to return the last seen error by an + // integration upon context timeout. + iErr = err + } else { + numNotifications.WithLabelValues(r.integration.name).Inc() + return ctx, alerts, nil + } + case <-ctx.Done(): + if iErr != nil { + return ctx, nil, iErr + } + + return ctx, nil, ctx.Err() + } + } +} + +// SetNotifiesStage sets the notification information about passed alerts. The +// passed alerts should have already been sent to the receivers. +type SetNotifiesStage struct { + nflog NotificationLog + recv *nflogpb.Receiver +} + +// NewSetNotifiesStage returns a new instance of a SetNotifiesStage. +func NewSetNotifiesStage(l NotificationLog, recv *nflogpb.Receiver) *SetNotifiesStage { + return &SetNotifiesStage{ + nflog: l, + recv: recv, + } +} + +// Exec implements the Stage interface. +func (n SetNotifiesStage) Exec(ctx context.Context, l log.Logger, alerts ...*types.Alert) (context.Context, []*types.Alert, error) { + gkey, ok := GroupKey(ctx) + if !ok { + return ctx, nil, fmt.Errorf("group key missing") + } + + firing, ok := FiringAlerts(ctx) + if !ok { + return ctx, nil, fmt.Errorf("firing alerts missing") + } + + resolved, ok := ResolvedAlerts(ctx) + if !ok { + return ctx, nil, fmt.Errorf("resolved alerts missing") + } + + return ctx, alerts, n.nflog.Log(n.recv, gkey, firing, resolved) +} diff --git a/src/alertmanager/notify/notify_test.go b/src/alertmanager/notify/notify_test.go new file mode 100644 index 0000000..276a244 --- /dev/null +++ b/src/alertmanager/notify/notify_test.go @@ -0,0 +1,681 @@ +// Copyright 2015 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +package notify + +import ( + "errors" + "fmt" + "io" + "reflect" + "testing" + "time" + + "github.com/go-kit/kit/log" + "github.com/prometheus/common/model" + "github.com/stretchr/testify/require" + "golang.org/x/net/context" + + "github.com/prometheus/alertmanager/nflog" + "github.com/prometheus/alertmanager/nflog/nflogpb" + "github.com/prometheus/alertmanager/silence" + "github.com/prometheus/alertmanager/silence/silencepb" + "github.com/prometheus/alertmanager/types" +) + +type notifierConfigFunc func() bool + +func (f notifierConfigFunc) SendResolved() bool { + return f() +} + +type notifierFunc func(ctx context.Context, alerts ...*types.Alert) (bool, error) + +func (f notifierFunc) Notify(ctx context.Context, alerts ...*types.Alert) (bool, error) { + return f(ctx, alerts...) +} + +type failStage struct{} + +func (s failStage) Exec(ctx context.Context, l log.Logger, as ...*types.Alert) (context.Context, []*types.Alert, error) { + return ctx, nil, fmt.Errorf("some error") +} + +type testNflog struct { + qres []*nflogpb.Entry + qerr error + + logFunc func(r *nflogpb.Receiver, gkey string, firingAlerts, resolvedAlerts []uint64) error +} + +func (l *testNflog) Query(p ...nflog.QueryParam) ([]*nflogpb.Entry, error) { + return l.qres, l.qerr +} + +func (l *testNflog) Log(r *nflogpb.Receiver, gkey string, firingAlerts, resolvedAlerts []uint64) error { + return l.logFunc(r, gkey, firingAlerts, resolvedAlerts) +} + +func (l *testNflog) GC() (int, error) { + return 0, nil +} + +func (l *testNflog) Snapshot(w io.Writer) (int, error) { + return 0, nil +} + +func alertHashSet(hashes ...uint64) map[uint64]struct{} { + res := map[uint64]struct{}{} + + for _, h := range hashes { + res[h] = struct{}{} + } + + return res +} + +func TestDedupStageNeedsUpdate(t *testing.T) { + now := utcNow() + + cases := []struct { + entry *nflogpb.Entry + firingAlerts map[uint64]struct{} + resolvedAlerts map[uint64]struct{} + repeat time.Duration + resolve bool + + res bool + }{ + { + // No matching nflog entry should update. + entry: nil, + firingAlerts: alertHashSet(2, 3, 4), + res: true, + }, { + // No matching nflog entry shouldn't update if no alert fires. + entry: nil, + resolvedAlerts: alertHashSet(2, 3, 4), + res: false, + }, { + // Different sets of firing alerts should update. + entry: &nflogpb.Entry{FiringAlerts: []uint64{1, 2, 3}}, + firingAlerts: alertHashSet(2, 3, 4), + res: true, + }, { + // Zero timestamp in the nflog entry should always update. + entry: &nflogpb.Entry{ + FiringAlerts: []uint64{1, 2, 3}, + Timestamp: time.Time{}, + }, + firingAlerts: alertHashSet(1, 2, 3), + res: true, + }, { + // Identical sets of alerts shouldn't update before repeat_interval. + entry: &nflogpb.Entry{ + FiringAlerts: []uint64{1, 2, 3}, + Timestamp: now.Add(-9 * time.Minute), + }, + repeat: 10 * time.Minute, + firingAlerts: alertHashSet(1, 2, 3), + res: false, + }, { + // Identical sets of alerts should update after repeat_interval. + entry: &nflogpb.Entry{ + FiringAlerts: []uint64{1, 2, 3}, + Timestamp: now.Add(-11 * time.Minute), + }, + repeat: 10 * time.Minute, + firingAlerts: alertHashSet(1, 2, 3), + res: true, + }, { + // Different sets of resolved alerts without firing alerts shouldn't update after repeat_interval. + entry: &nflogpb.Entry{ + ResolvedAlerts: []uint64{1, 2, 3}, + Timestamp: now.Add(-11 * time.Minute), + }, + repeat: 10 * time.Minute, + resolvedAlerts: alertHashSet(3, 4, 5), + resolve: true, + res: false, + }, { + // Different sets of resolved alerts shouldn't update when resolve is false. + entry: &nflogpb.Entry{ + FiringAlerts: []uint64{1, 2}, + ResolvedAlerts: []uint64{3}, + Timestamp: now.Add(-9 * time.Minute), + }, + repeat: 10 * time.Minute, + firingAlerts: alertHashSet(1), + resolvedAlerts: alertHashSet(2, 3), + resolve: false, + res: false, + }, { + // Different sets of resolved alerts should update when resolve is true. + entry: &nflogpb.Entry{ + FiringAlerts: []uint64{1, 2}, + ResolvedAlerts: []uint64{3}, + Timestamp: now.Add(-9 * time.Minute), + }, + repeat: 10 * time.Minute, + firingAlerts: alertHashSet(1), + resolvedAlerts: alertHashSet(2, 3), + resolve: true, + res: true, + }, { + // Empty set of firing alerts should update when resolve is false. + entry: &nflogpb.Entry{ + FiringAlerts: []uint64{1, 2}, + ResolvedAlerts: []uint64{3}, + Timestamp: now.Add(-9 * time.Minute), + }, + repeat: 10 * time.Minute, + firingAlerts: alertHashSet(), + resolvedAlerts: alertHashSet(1, 2, 3), + resolve: false, + res: true, + }, { + // Empty set of firing alerts should update when resolve is true. + entry: &nflogpb.Entry{ + FiringAlerts: []uint64{1, 2}, + ResolvedAlerts: []uint64{3}, + Timestamp: now.Add(-9 * time.Minute), + }, + repeat: 10 * time.Minute, + firingAlerts: alertHashSet(), + resolvedAlerts: alertHashSet(1, 2, 3), + resolve: true, + res: true, + }, + } + for i, c := range cases { + t.Log("case", i) + + s := &DedupStage{ + now: func() time.Time { return now }, + conf: notifierConfigFunc(func() bool { return c.resolve }), + } + res := s.needsUpdate(c.entry, c.firingAlerts, c.resolvedAlerts, c.repeat) + require.Equal(t, c.res, res) + } +} + +func TestDedupStage(t *testing.T) { + i := 0 + now := utcNow() + s := &DedupStage{ + hash: func(a *types.Alert) uint64 { + res := uint64(i) + i++ + return res + }, + now: func() time.Time { + return now + }, + conf: notifierConfigFunc(func() bool { return false }), + } + + ctx := context.Background() + + _, _, err := s.Exec(ctx, log.NewNopLogger()) + require.EqualError(t, err, "group key missing") + + ctx = WithGroupKey(ctx, "1") + + _, _, err = s.Exec(ctx, log.NewNopLogger()) + require.EqualError(t, err, "repeat interval missing") + + ctx = WithRepeatInterval(ctx, time.Hour) + + alerts := []*types.Alert{{}, {}, {}} + + // Must catch notification log query errors. + s.nflog = &testNflog{ + qerr: errors.New("bad things"), + } + ctx, _, err = s.Exec(ctx, log.NewNopLogger(), alerts...) + require.EqualError(t, err, "bad things") + + // ... but skip ErrNotFound. + s.nflog = &testNflog{ + qerr: nflog.ErrNotFound, + } + ctx, res, err := s.Exec(ctx, log.NewNopLogger(), alerts...) + require.NoError(t, err, "unexpected error on not found log entry") + require.Equal(t, alerts, res, "input alerts differ from result alerts") + + s.nflog = &testNflog{ + qerr: nil, + qres: []*nflogpb.Entry{ + {FiringAlerts: []uint64{0, 1, 2}}, + {FiringAlerts: []uint64{1, 2, 3}}, + }, + } + ctx, _, err = s.Exec(ctx, log.NewNopLogger(), alerts...) + require.Contains(t, err.Error(), "result size") + + // Must return no error and no alerts no need to update. + i = 0 + s.nflog = &testNflog{ + qerr: nflog.ErrNotFound, + qres: []*nflogpb.Entry{ + { + FiringAlerts: []uint64{0, 1, 2}, + Timestamp: now, + }, + }, + } + ctx, res, err = s.Exec(ctx, log.NewNopLogger(), alerts...) + require.NoError(t, err) + require.Nil(t, res, "unexpected alerts returned") + + // Must return no error and all input alerts on changes. + i = 0 + s.nflog = &testNflog{ + qerr: nil, + qres: []*nflogpb.Entry{ + { + FiringAlerts: []uint64{1, 2, 3, 4}, + Timestamp: now, + }, + }, + } + _, res, err = s.Exec(ctx, log.NewNopLogger(), alerts...) + require.NoError(t, err) + require.Equal(t, alerts, res, "unexpected alerts returned") +} + +func TestMultiStage(t *testing.T) { + var ( + alerts1 = []*types.Alert{{}} + alerts2 = []*types.Alert{{}, {}} + alerts3 = []*types.Alert{{}, {}, {}} + ) + + stage := MultiStage{ + StageFunc(func(ctx context.Context, l log.Logger, alerts ...*types.Alert) (context.Context, []*types.Alert, error) { + if !reflect.DeepEqual(alerts, alerts1) { + t.Fatal("Input not equal to input of MultiStage") + } + ctx = context.WithValue(ctx, "key", "value") + return ctx, alerts2, nil + }), + StageFunc(func(ctx context.Context, l log.Logger, alerts ...*types.Alert) (context.Context, []*types.Alert, error) { + if !reflect.DeepEqual(alerts, alerts2) { + t.Fatal("Input not equal to output of previous stage") + } + v, ok := ctx.Value("key").(string) + if !ok || v != "value" { + t.Fatalf("Expected value %q for key %q but got %q", "value", "key", v) + } + return ctx, alerts3, nil + }), + } + + _, alerts, err := stage.Exec(context.Background(), log.NewNopLogger(), alerts1...) + if err != nil { + t.Fatalf("Exec failed: %s", err) + } + + if !reflect.DeepEqual(alerts, alerts3) { + t.Fatal("Output of MultiStage is not equal to the output of the last stage") + } +} + +func TestMultiStageFailure(t *testing.T) { + var ( + ctx = context.Background() + s1 = failStage{} + stage = MultiStage{s1} + ) + + _, _, err := stage.Exec(ctx, log.NewNopLogger(), nil) + if err.Error() != "some error" { + t.Fatal("Errors were not propagated correctly by MultiStage") + } +} + +func TestRoutingStage(t *testing.T) { + var ( + alerts1 = []*types.Alert{{}} + alerts2 = []*types.Alert{{}, {}} + ) + + stage := RoutingStage{ + "name": StageFunc(func(ctx context.Context, l log.Logger, alerts ...*types.Alert) (context.Context, []*types.Alert, error) { + if !reflect.DeepEqual(alerts, alerts1) { + t.Fatal("Input not equal to input of RoutingStage") + } + return ctx, alerts2, nil + }), + "not": failStage{}, + } + + ctx := WithReceiverName(context.Background(), "name") + + _, alerts, err := stage.Exec(ctx, log.NewNopLogger(), alerts1...) + if err != nil { + t.Fatalf("Exec failed: %s", err) + } + + if !reflect.DeepEqual(alerts, alerts2) { + t.Fatal("Output of RoutingStage is not equal to the output of the inner stage") + } +} + +func TestRetryStageWithError(t *testing.T) { + fail, retry := true, true + sent := []*types.Alert{} + i := Integration{ + notifier: notifierFunc(func(ctx context.Context, alerts ...*types.Alert) (bool, error) { + if fail { + fail = false + return retry, errors.New("fail to deliver notification") + } + sent = append(sent, alerts...) + return false, nil + }), + conf: notifierConfigFunc(func() bool { return false }), + } + r := RetryStage{ + integration: i, + } + + alerts := []*types.Alert{ + &types.Alert{ + Alert: model.Alert{ + EndsAt: time.Now().Add(time.Hour), + }, + }, + } + + ctx := context.Background() + ctx = WithFiringAlerts(ctx, []uint64{0}) + + // Notify with a recoverable error should retry and succeed. + resctx, res, err := r.Exec(ctx, log.NewNopLogger(), alerts...) + require.Nil(t, err) + require.Equal(t, alerts, res) + require.Equal(t, alerts, sent) + require.NotNil(t, resctx) + + // Notify with an unrecoverable error should fail. + sent = sent[:0] + fail = true + retry = false + resctx, _, err = r.Exec(ctx, log.NewNopLogger(), alerts...) + require.NotNil(t, err) + require.NotNil(t, resctx) +} + +func TestRetryStageNoResolved(t *testing.T) { + sent := []*types.Alert{} + i := Integration{ + notifier: notifierFunc(func(ctx context.Context, alerts ...*types.Alert) (bool, error) { + sent = append(sent, alerts...) + return false, nil + }), + conf: notifierConfigFunc(func() bool { return false }), + } + r := RetryStage{ + integration: i, + } + + alerts := []*types.Alert{ + &types.Alert{ + Alert: model.Alert{ + EndsAt: time.Now().Add(-time.Hour), + }, + }, + &types.Alert{ + Alert: model.Alert{ + EndsAt: time.Now().Add(time.Hour), + }, + }, + } + + ctx := context.Background() + + resctx, res, err := r.Exec(ctx, log.NewNopLogger(), alerts...) + require.EqualError(t, err, "firing alerts missing") + require.Nil(t, res) + require.NotNil(t, resctx) + + ctx = WithFiringAlerts(ctx, []uint64{0}) + + resctx, res, err = r.Exec(ctx, log.NewNopLogger(), alerts...) + require.Nil(t, err) + require.Equal(t, alerts, res) + require.Equal(t, []*types.Alert{alerts[1]}, sent) + require.NotNil(t, resctx) + + // All alerts are resolved. + sent = sent[:0] + ctx = WithFiringAlerts(ctx, []uint64{}) + alerts[1].Alert.EndsAt = time.Now().Add(-time.Hour) + + resctx, res, err = r.Exec(ctx, log.NewNopLogger(), alerts...) + require.Nil(t, err) + require.Equal(t, alerts, res) + require.Equal(t, []*types.Alert{}, sent) + require.NotNil(t, resctx) +} + +func TestRetryStageSendResolved(t *testing.T) { + sent := []*types.Alert{} + i := Integration{ + notifier: notifierFunc(func(ctx context.Context, alerts ...*types.Alert) (bool, error) { + sent = append(sent, alerts...) + return false, nil + }), + conf: notifierConfigFunc(func() bool { return true }), + } + r := RetryStage{ + integration: i, + } + + alerts := []*types.Alert{ + &types.Alert{ + Alert: model.Alert{ + EndsAt: time.Now().Add(-time.Hour), + }, + }, + &types.Alert{ + Alert: model.Alert{ + EndsAt: time.Now().Add(time.Hour), + }, + }, + } + + ctx := context.Background() + ctx = WithFiringAlerts(ctx, []uint64{0}) + + resctx, res, err := r.Exec(ctx, log.NewNopLogger(), alerts...) + require.Nil(t, err) + require.Equal(t, alerts, res) + require.Equal(t, alerts, sent) + require.NotNil(t, resctx) + + // All alerts are resolved. + sent = sent[:0] + ctx = WithFiringAlerts(ctx, []uint64{}) + alerts[1].Alert.EndsAt = time.Now().Add(-time.Hour) + + resctx, res, err = r.Exec(ctx, log.NewNopLogger(), alerts...) + require.Nil(t, err) + require.Equal(t, alerts, res) + require.Equal(t, alerts, sent) + require.NotNil(t, resctx) +} + +func TestSetNotifiesStage(t *testing.T) { + tnflog := &testNflog{} + s := &SetNotifiesStage{ + recv: &nflogpb.Receiver{GroupName: "test"}, + nflog: tnflog, + } + alerts := []*types.Alert{{}, {}, {}} + ctx := context.Background() + + resctx, res, err := s.Exec(ctx, log.NewNopLogger(), alerts...) + require.EqualError(t, err, "group key missing") + require.Nil(t, res) + require.NotNil(t, resctx) + + ctx = WithGroupKey(ctx, "1") + + resctx, res, err = s.Exec(ctx, log.NewNopLogger(), alerts...) + require.EqualError(t, err, "firing alerts missing") + require.Nil(t, res) + require.NotNil(t, resctx) + + ctx = WithFiringAlerts(ctx, []uint64{0, 1, 2}) + + resctx, res, err = s.Exec(ctx, log.NewNopLogger(), alerts...) + require.EqualError(t, err, "resolved alerts missing") + require.Nil(t, res) + require.NotNil(t, resctx) + + ctx = WithResolvedAlerts(ctx, []uint64{}) + + tnflog.logFunc = func(r *nflogpb.Receiver, gkey string, firingAlerts, resolvedAlerts []uint64) error { + require.Equal(t, s.recv, r) + require.Equal(t, "1", gkey) + require.Equal(t, []uint64{0, 1, 2}, firingAlerts) + require.Equal(t, []uint64{}, resolvedAlerts) + return nil + } + resctx, res, err = s.Exec(ctx, log.NewNopLogger(), alerts...) + require.Nil(t, err) + require.Equal(t, alerts, res) + require.NotNil(t, resctx) + + ctx = WithFiringAlerts(ctx, []uint64{}) + ctx = WithResolvedAlerts(ctx, []uint64{0, 1, 2}) + + tnflog.logFunc = func(r *nflogpb.Receiver, gkey string, firingAlerts, resolvedAlerts []uint64) error { + require.Equal(t, s.recv, r) + require.Equal(t, "1", gkey) + require.Equal(t, []uint64{}, firingAlerts) + require.Equal(t, []uint64{0, 1, 2}, resolvedAlerts) + return nil + } + resctx, res, err = s.Exec(ctx, log.NewNopLogger(), alerts...) + require.Nil(t, err) + require.Equal(t, alerts, res) + require.NotNil(t, resctx) +} + +func TestSilenceStage(t *testing.T) { + silences, err := silence.New(silence.Options{}) + if err != nil { + t.Fatal(err) + } + if _, err := silences.Set(&silencepb.Silence{ + EndsAt: utcNow().Add(time.Hour), + Matchers: []*silencepb.Matcher{{Name: "mute", Pattern: "me"}}, + }); err != nil { + t.Fatal(err) + } + + marker := types.NewMarker() + silencer := NewSilenceStage(silences, marker) + + in := []model.LabelSet{ + {}, + {"test": "set"}, + {"mute": "me"}, + {"foo": "bar", "test": "set"}, + {"foo": "bar", "mute": "me"}, + {}, + {"not": "muted"}, + } + out := []model.LabelSet{ + {}, + {"test": "set"}, + {"foo": "bar", "test": "set"}, + {}, + {"not": "muted"}, + } + + var inAlerts []*types.Alert + for _, lset := range in { + inAlerts = append(inAlerts, &types.Alert{ + Alert: model.Alert{Labels: lset}, + }) + } + + // Set the second alert as previously silenced. It is expected to have + // the WasSilenced flag set to true afterwards. + marker.SetSilenced(inAlerts[1].Fingerprint(), "123") + + _, alerts, err := silencer.Exec(nil, log.NewNopLogger(), inAlerts...) + if err != nil { + t.Fatalf("Exec failed: %s", err) + } + + var got []model.LabelSet + for _, a := range alerts { + got = append(got, a.Labels) + } + + if !reflect.DeepEqual(got, out) { + t.Fatalf("Muting failed, expected: %v\ngot %v", out, got) + } +} + +func TestInhibitStage(t *testing.T) { + // Mute all label sets that have a "mute" key. + muter := types.MuteFunc(func(lset model.LabelSet) bool { + _, ok := lset["mute"] + return ok + }) + + inhibitor := NewInhibitStage(muter) + + in := []model.LabelSet{ + {}, + {"test": "set"}, + {"mute": "me"}, + {"foo": "bar", "test": "set"}, + {"foo": "bar", "mute": "me"}, + {}, + {"not": "muted"}, + } + out := []model.LabelSet{ + {}, + {"test": "set"}, + {"foo": "bar", "test": "set"}, + {}, + {"not": "muted"}, + } + + var inAlerts []*types.Alert + for _, lset := range in { + inAlerts = append(inAlerts, &types.Alert{ + Alert: model.Alert{Labels: lset}, + }) + } + + _, alerts, err := inhibitor.Exec(nil, log.NewNopLogger(), inAlerts...) + if err != nil { + t.Fatalf("Exec failed: %s", err) + } + + var got []model.LabelSet + for _, a := range alerts { + got = append(got, a.Labels) + } + + if !reflect.DeepEqual(got, out) { + t.Fatalf("Muting failed, expected: %v\ngot %v", out, got) + } +} diff --git a/src/alertmanager/pkg/parse/parse.go b/src/alertmanager/pkg/parse/parse.go new file mode 100644 index 0000000..1a03592 --- /dev/null +++ b/src/alertmanager/pkg/parse/parse.go @@ -0,0 +1,105 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package parse + +import ( + "fmt" + "regexp" + "strings" + + "github.com/prometheus/prometheus/pkg/labels" +) + +var ( + re = regexp.MustCompile(`(?:\s?)(\w+)(=|=~|!=|!~)(?:\"([^"=~!]+)\"|([^"=~!]+)|\"\")`) + typeMap = map[string]labels.MatchType{ + "=": labels.MatchEqual, + "!=": labels.MatchNotEqual, + "=~": labels.MatchRegexp, + "!~": labels.MatchNotRegexp, + } +) + +func Matchers(s string) ([]*labels.Matcher, error) { + matchers := []*labels.Matcher{} + if strings.HasPrefix(s, "{") { + s = s[1:] + } + if strings.HasSuffix(s, "}") { + s = s[:len(s)-1] + } + + var insideQuotes bool + var token string + var tokens []string + for _, r := range s { + if !insideQuotes && r == ',' { + tokens = append(tokens, token) + token = "" + continue + } + token += string(r) + if r == '"' { + insideQuotes = !insideQuotes + } + } + if token != "" { + tokens = append(tokens, token) + } + for _, token := range tokens { + m, err := Matcher(token) + if err != nil { + return nil, err + } + matchers = append(matchers, m) + } + + return matchers, nil +} + +func Matcher(s string) (*labels.Matcher, error) { + name, value, matchType, err := Input(s) + if err != nil { + return nil, err + } + + m, err := labels.NewMatcher(matchType, name, value) + if err != nil { + return nil, err + } + return m, nil +} + +func Input(s string) (name, value string, matchType labels.MatchType, err error) { + ms := re.FindStringSubmatch(s) + if len(ms) < 4 { + return "", "", labels.MatchEqual, fmt.Errorf("bad matcher format: %s", s) + } + + var prs bool + name = ms[1] + matchType, prs = typeMap[ms[2]] + + if ms[3] != "" { + value = ms[3] + } else { + value = ms[4] + } + + if name == "" || !prs { + return "", "", labels.MatchEqual, fmt.Errorf("failed to parse") + } + + return name, value, matchType, nil +} diff --git a/src/alertmanager/pkg/parse/parse_test.go b/src/alertmanager/pkg/parse/parse_test.go new file mode 100644 index 0000000..84f3d6a --- /dev/null +++ b/src/alertmanager/pkg/parse/parse_test.go @@ -0,0 +1,147 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package parse + +import ( + "reflect" + "testing" + + "github.com/prometheus/prometheus/pkg/labels" +) + +func TestMatchers(t *testing.T) { + testCases := []struct { + input string + want []*labels.Matcher + err error + }{ + { + input: `{foo="bar"}`, + want: func() []*labels.Matcher { + ms := []*labels.Matcher{} + m, _ := labels.NewMatcher(labels.MatchEqual, "foo", "bar") + return append(ms, m) + }(), + }, + { + input: `{foo=~"bar.*"}`, + want: func() []*labels.Matcher { + ms := []*labels.Matcher{} + m, _ := labels.NewMatcher(labels.MatchRegexp, "foo", "bar.*") + return append(ms, m) + }(), + }, + { + input: `{foo!="bar"}`, + want: func() []*labels.Matcher { + ms := []*labels.Matcher{} + m, _ := labels.NewMatcher(labels.MatchNotEqual, "foo", "bar") + return append(ms, m) + }(), + }, + { + input: `{foo!~"bar.*"}`, + want: func() []*labels.Matcher { + ms := []*labels.Matcher{} + m, _ := labels.NewMatcher(labels.MatchNotRegexp, "foo", "bar.*") + return append(ms, m) + }(), + }, + { + input: `{foo="bar", baz!="quux"}`, + want: func() []*labels.Matcher { + ms := []*labels.Matcher{} + m, _ := labels.NewMatcher(labels.MatchEqual, "foo", "bar") + m2, _ := labels.NewMatcher(labels.MatchNotEqual, "baz", "quux") + return append(ms, m, m2) + }(), + }, + { + input: `{foo="bar", baz!~"quux.*"}`, + want: func() []*labels.Matcher { + ms := []*labels.Matcher{} + m, _ := labels.NewMatcher(labels.MatchEqual, "foo", "bar") + m2, _ := labels.NewMatcher(labels.MatchNotRegexp, "baz", "quux.*") + return append(ms, m, m2) + }(), + }, + { + input: `{foo="bar",baz!~".*quux", derp="wat"}`, + want: func() []*labels.Matcher { + ms := []*labels.Matcher{} + m, _ := labels.NewMatcher(labels.MatchEqual, "foo", "bar") + m2, _ := labels.NewMatcher(labels.MatchNotRegexp, "baz", ".*quux") + m3, _ := labels.NewMatcher(labels.MatchEqual, "derp", "wat") + return append(ms, m, m2, m3) + }(), + }, + { + input: `{foo="bar", baz!="quux", derp="wat"}`, + want: func() []*labels.Matcher { + ms := []*labels.Matcher{} + m, _ := labels.NewMatcher(labels.MatchEqual, "foo", "bar") + m2, _ := labels.NewMatcher(labels.MatchNotEqual, "baz", "quux") + m3, _ := labels.NewMatcher(labels.MatchEqual, "derp", "wat") + return append(ms, m, m2, m3) + }(), + }, + { + input: `{foo="bar", baz!~".*quux.*", derp="wat"}`, + want: func() []*labels.Matcher { + ms := []*labels.Matcher{} + m, _ := labels.NewMatcher(labels.MatchEqual, "foo", "bar") + m2, _ := labels.NewMatcher(labels.MatchNotRegexp, "baz", ".*quux.*") + m3, _ := labels.NewMatcher(labels.MatchEqual, "derp", "wat") + return append(ms, m, m2, m3) + }(), + }, + { + input: `{foo="bar", instance=~"some-api.*"}`, + want: func() []*labels.Matcher { + ms := []*labels.Matcher{} + m, _ := labels.NewMatcher(labels.MatchEqual, "foo", "bar") + m2, _ := labels.NewMatcher(labels.MatchRegexp, "instance", "some-api.*") + return append(ms, m, m2) + }(), + }, + { + input: `{foo=""}`, + want: func() []*labels.Matcher { + ms := []*labels.Matcher{} + m, _ := labels.NewMatcher(labels.MatchEqual, "foo", "") + return append(ms, m) + }(), + }, + { + input: `{foo="bar,quux", job="job1"}`, + want: func() []*labels.Matcher { + ms := []*labels.Matcher{} + m, _ := labels.NewMatcher(labels.MatchEqual, "foo", "bar,quux") + m2, _ := labels.NewMatcher(labels.MatchEqual, "job", "job1") + return append(ms, m, m2) + }(), + }, + } + + for i, tc := range testCases { + got, err := Matchers(tc.input) + if tc.err != err { + t.Fatalf("error not equal (i=%d):\ngot %v\nwant %v", i, err, tc.err) + } + if !reflect.DeepEqual(got, tc.want) { + t.Fatalf("labels not equal (i=%d):\ngot %v\nwant %v", i, got, tc.want) + } + } + +} diff --git a/src/alertmanager/provider/mem/mem.go b/src/alertmanager/provider/mem/mem.go new file mode 100644 index 0000000..23c91e2 --- /dev/null +++ b/src/alertmanager/provider/mem/mem.go @@ -0,0 +1,194 @@ +// Copyright 2016 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/lic:wenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package mem + +import ( + "sync" + "time" + + "github.com/prometheus/alertmanager/provider" + "github.com/prometheus/alertmanager/types" + "github.com/prometheus/common/model" +) + +// Alerts gives access to a set of alerts. All methods are goroutine-safe. +type Alerts struct { + mtx sync.RWMutex + alerts map[model.Fingerprint]*types.Alert + marker types.Marker + intervalGC time.Duration + stopGC chan struct{} + + listeners map[int]chan *types.Alert + next int +} + +// NewAlerts returns a new alert provider. +func NewAlerts(m types.Marker, intervalGC time.Duration) (*Alerts, error) { + a := &Alerts{ + alerts: map[model.Fingerprint]*types.Alert{}, + marker: m, + intervalGC: intervalGC, + stopGC: make(chan struct{}), + listeners: map[int]chan *types.Alert{}, + next: 0, + } + go a.runGC() + + return a, nil +} + +func (a *Alerts) runGC() { + for { + select { + case <-a.stopGC: + return + case <-time.After(a.intervalGC): + } + + a.mtx.Lock() + + for fp, alert := range a.alerts { + // As we don't persist alerts, we no longer consider them after + // they are resolved. Alerts waiting for resolved notifications are + // held in memory in aggregation groups redundantly. + if alert.EndsAt.Before(time.Now()) { + delete(a.alerts, fp) + a.marker.Delete(fp) + } + } + + a.mtx.Unlock() + } +} + +// Close the alert provider. +func (a *Alerts) Close() error { + close(a.stopGC) + return nil +} + +// Subscribe returns an iterator over active alerts that have not been +// resolved and successfully notified about. +// They are not guaranteed to be in chronological order. +func (a *Alerts) Subscribe() provider.AlertIterator { + var ( + ch = make(chan *types.Alert, 200) + done = make(chan struct{}) + ) + alerts, err := a.getPending() + + a.mtx.Lock() + i := a.next + a.next++ + a.listeners[i] = ch + a.mtx.Unlock() + + go func() { + defer func() { + a.mtx.Lock() + delete(a.listeners, i) + close(ch) + a.mtx.Unlock() + }() + + for _, a := range alerts { + select { + case ch <- a: + case <-done: + return + } + } + + <-done + }() + + return provider.NewAlertIterator(ch, done, err) +} + +// GetPending returns an iterator over all alerts that have +// pending notifications. +func (a *Alerts) GetPending() provider.AlertIterator { + var ( + ch = make(chan *types.Alert, 200) + done = make(chan struct{}) + ) + + alerts, err := a.getPending() + + go func() { + defer close(ch) + + for _, a := range alerts { + select { + case ch <- a: + case <-done: + return + } + } + }() + + return provider.NewAlertIterator(ch, done, err) +} + +func (a *Alerts) getPending() ([]*types.Alert, error) { + a.mtx.RLock() + defer a.mtx.RUnlock() + + res := make([]*types.Alert, 0, len(a.alerts)) + + for _, alert := range a.alerts { + res = append(res, alert) + } + + return res, nil +} + +// Get returns the alert for a given fingerprint. +func (a *Alerts) Get(fp model.Fingerprint) (*types.Alert, error) { + a.mtx.RLock() + defer a.mtx.RUnlock() + + alert, ok := a.alerts[fp] + if !ok { + return nil, provider.ErrNotFound + } + return alert, nil +} + +// Put adds the given alert to the set. +func (a *Alerts) Put(alerts ...*types.Alert) error { + a.mtx.Lock() + defer a.mtx.Unlock() + + for _, alert := range alerts { + fp := alert.Fingerprint() + + if old, ok := a.alerts[fp]; ok { + // Merge alerts if there is an overlap in activity range. + if (alert.EndsAt.After(old.StartsAt) && alert.EndsAt.Before(old.EndsAt)) || + (alert.StartsAt.After(old.StartsAt) && alert.StartsAt.Before(old.EndsAt)) { + alert = old.Merge(alert) + } + } + + a.alerts[fp] = alert + + for _, ch := range a.listeners { + ch <- alert + } + } + + return nil +} diff --git a/src/alertmanager/provider/mem/mem_test.go b/src/alertmanager/provider/mem/mem_test.go new file mode 100644 index 0000000..c79ad77 --- /dev/null +++ b/src/alertmanager/provider/mem/mem_test.go @@ -0,0 +1,287 @@ +// Copyright 2016 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/lic:wenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package mem + +import ( + "fmt" + "reflect" + "testing" + "time" + + "sync" + + "github.com/kylelemons/godebug/pretty" + "github.com/prometheus/alertmanager/provider" + "github.com/prometheus/alertmanager/types" + "github.com/prometheus/common/model" +) + +var ( + t0 = time.Now() + t1 = t0.Add(100 * time.Millisecond) + + alert1 = &types.Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{"bar": "foo"}, + Annotations: model.LabelSet{"foo": "bar"}, + StartsAt: t0, + EndsAt: t1, + GeneratorURL: "http://example.com/prometheus", + }, + UpdatedAt: t0, + Timeout: false, + } + + alert2 = &types.Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{"bar": "foo2"}, + Annotations: model.LabelSet{"foo": "bar2"}, + StartsAt: t0, + EndsAt: t1, + GeneratorURL: "http://example.com/prometheus", + }, + UpdatedAt: t0, + Timeout: false, + } + + alert3 = &types.Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{"bar": "foo3"}, + Annotations: model.LabelSet{"foo": "bar3"}, + StartsAt: t0, + EndsAt: t1, + GeneratorURL: "http://example.com/prometheus", + }, + UpdatedAt: t0, + Timeout: false, + } +) + +func init() { + pretty.CompareConfig.IncludeUnexported = true +} + +func TestAlertsPut(t *testing.T) { + marker := types.NewMarker() + alerts, err := NewAlerts(marker, 30*time.Minute) + if err != nil { + t.Fatal(err) + } + + insert := []*types.Alert{alert1, alert2, alert3} + + if err := alerts.Put(insert...); err != nil { + t.Fatalf("Insert failed: %s", err) + } + + for i, a := range insert { + res, err := alerts.Get(a.Fingerprint()) + if err != nil { + t.Fatalf("retrieval error: %s", err) + } + if !alertsEqual(res, a) { + t.Errorf("Unexpected alert: %d", i) + t.Fatalf(pretty.Compare(res, a)) + } + } +} + +func TestAlertsSubscribe(t *testing.T) { + marker := types.NewMarker() + alerts, err := NewAlerts(marker, 30*time.Minute) + if err != nil { + t.Fatal(err) + } + + // add alert1 to validate if pending alerts will be send + if err := alerts.Put(alert1); err != nil { + t.Fatalf("Insert failed: %s", err) + } + + var wg sync.WaitGroup + wg.Add(2) + fatalc := make(chan string, 2) + + iterator1 := alerts.Subscribe() + iterator2 := alerts.Subscribe() + + go func() { + defer wg.Done() + expectedAlerts := map[model.Fingerprint]*types.Alert{ + alert1.Fingerprint(): alert1, + alert2.Fingerprint(): alert2, + alert3.Fingerprint(): alert3, + } + + for i := 0; i < 3; i++ { + actual := <-iterator1.Next() + expected := expectedAlerts[actual.Fingerprint()] + if !alertsEqual(actual, expected) { + fatalc <- fmt.Sprintf("Unexpected alert (iterator1)\n%s", pretty.Compare(actual, expected)) + return + } + + delete(expectedAlerts, actual.Fingerprint()) + } + + if len(expectedAlerts) != 0 { + fatalc <- fmt.Sprintf("Unexpected number of alerts (iterator1): %d", len(expectedAlerts)) + } + }() + + go func() { + defer wg.Done() + expectedAlerts := map[model.Fingerprint]*types.Alert{ + alert1.Fingerprint(): alert1, + alert2.Fingerprint(): alert2, + alert3.Fingerprint(): alert3, + } + + for i := 0; i < 3; i++ { + actual := <-iterator2.Next() + expected := expectedAlerts[actual.Fingerprint()] + if !alertsEqual(actual, expected) { + t.Errorf("Unexpected alert") + fatalc <- fmt.Sprintf("Unexpected alert (iterator2)\n%s", pretty.Compare(actual, expected)) + } + + delete(expectedAlerts, actual.Fingerprint()) + } + + if len(expectedAlerts) != 0 { + fatalc <- fmt.Sprintf("Unexpected number of alerts (iterator2): %d", len(expectedAlerts)) + } + }() + + go func() { + wg.Wait() + close(fatalc) + }() + + if err := alerts.Put(alert2); err != nil { + t.Fatalf("Insert failed: %s", err) + } + + if err := alerts.Put(alert3); err != nil { + t.Fatalf("Insert failed: %s", err) + } + + fatal, ok := <-fatalc + if ok { + t.Fatalf(fatal) + } + + iterator1.Close() + iterator2.Close() +} + +func TestAlertsGetPending(t *testing.T) { + marker := types.NewMarker() + alerts, err := NewAlerts(marker, 30*time.Minute) + if err != nil { + t.Fatal(err) + } + + if err := alerts.Put(alert1, alert2); err != nil { + t.Fatalf("Insert failed: %s", err) + } + + expectedAlerts := map[model.Fingerprint]*types.Alert{ + alert1.Fingerprint(): alert1, + alert2.Fingerprint(): alert2, + } + iterator := alerts.GetPending() + for actual := range iterator.Next() { + expected := expectedAlerts[actual.Fingerprint()] + if !alertsEqual(actual, expected) { + t.Errorf("Unexpected alert") + t.Fatalf(pretty.Compare(actual, expected)) + } + } + + if err := alerts.Put(alert3); err != nil { + t.Fatalf("Insert failed: %s", err) + } + + expectedAlerts = map[model.Fingerprint]*types.Alert{ + alert1.Fingerprint(): alert1, + alert2.Fingerprint(): alert2, + alert3.Fingerprint(): alert3, + } + iterator = alerts.GetPending() + for actual := range iterator.Next() { + expected := expectedAlerts[actual.Fingerprint()] + if !alertsEqual(actual, expected) { + t.Errorf("Unexpected alert") + t.Fatalf(pretty.Compare(actual, expected)) + } + } +} + +func TestAlertsGC(t *testing.T) { + marker := types.NewMarker() + alerts, err := NewAlerts(marker, 200*time.Millisecond) + if err != nil { + t.Fatal(err) + } + + insert := []*types.Alert{alert1, alert2, alert3} + + if err := alerts.Put(insert...); err != nil { + t.Fatalf("Insert failed: %s", err) + } + + for _, a := range insert { + marker.SetActive(a.Fingerprint()) + if !marker.Active(a.Fingerprint()) { + t.Errorf("error setting status: %v", a) + } + } + + time.Sleep(300 * time.Millisecond) + + for i, a := range insert { + _, err := alerts.Get(a.Fingerprint()) + if err != provider.ErrNotFound { + t.Errorf("alert %d didn't get GC'd", i) + } + + s := marker.Status(a.Fingerprint()) + if s.State != types.AlertStateUnprocessed { + t.Errorf("marker %d didn't get GC'd: %v", i, s) + } + } +} + +func alertsEqual(a1, a2 *types.Alert) bool { + if !reflect.DeepEqual(a1.Labels, a2.Labels) { + return false + } + if !reflect.DeepEqual(a1.Annotations, a2.Annotations) { + return false + } + if a1.GeneratorURL != a2.GeneratorURL { + return false + } + if !a1.StartsAt.Equal(a2.StartsAt) { + return false + } + if !a1.EndsAt.Equal(a2.EndsAt) { + return false + } + if !a1.UpdatedAt.Equal(a2.UpdatedAt) { + return false + } + return a1.Timeout == a2.Timeout +} diff --git a/src/alertmanager/provider/provider.go b/src/alertmanager/provider/provider.go new file mode 100644 index 0000000..1ab5fbe --- /dev/null +++ b/src/alertmanager/provider/provider.go @@ -0,0 +1,88 @@ +// Copyright 2015 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package provider + +import ( + "fmt" + + "github.com/prometheus/common/model" + + "github.com/prometheus/alertmanager/types" +) + +var ( + // ErrNotFound is returned if a provider cannot find a requested item. + ErrNotFound = fmt.Errorf("item not found") +) + +// Iterator provides the functions common to all iterators. To be useful, a +// specific iterator interface (e.g. AlertIterator) has to be implemented that +// provides a Next method. +type Iterator interface { + // Err returns the current error. It is not safe to call it concurrently + // with other iterator methods or while reading from a channel returned + // by the iterator. + Err() error + // Close must be called to release resources once the iterator is not + // used anymore. + Close() +} + +// AlertIterator is an Iterator for Alerts. +type AlertIterator interface { + Iterator + // Next returns a channel that will be closed once the iterator is + // exhausted. It is not necessary to exhaust the iterator but Close must + // be called in any case to release resources used by the iterator (even + // if the iterator is exhausted). + Next() <-chan *types.Alert +} + +// NewAlertIterator returns a new AlertIterator based on the generic alertIterator type +func NewAlertIterator(ch <-chan *types.Alert, done chan struct{}, err error) AlertIterator { + return &alertIterator{ + ch: ch, + done: done, + err: err, + } +} + +// alertIterator implements AlertIterator. So far, this one fits all providers. +type alertIterator struct { + ch <-chan *types.Alert + done chan struct{} + err error +} + +func (ai alertIterator) Next() <-chan *types.Alert { + return ai.ch +} + +func (ai alertIterator) Err() error { return ai.err } +func (ai alertIterator) Close() { close(ai.done) } + +// Alerts gives access to a set of alerts. All methods are goroutine-safe. +type Alerts interface { + // Subscribe returns an iterator over active alerts that have not been + // resolved and successfully notified about. + // They are not guaranteed to be in chronological order. + Subscribe() AlertIterator + // GetPending returns an iterator over all alerts that have + // pending notifications. + GetPending() AlertIterator + // Get returns the alert for a given fingerprint. + Get(model.Fingerprint) (*types.Alert, error) + // Put adds the given alert to the set. + Put(...*types.Alert) error +} diff --git a/src/alertmanager/scripts/genproto.sh b/src/alertmanager/scripts/genproto.sh new file mode 100755 index 0000000..c777fb9 --- /dev/null +++ b/src/alertmanager/scripts/genproto.sh @@ -0,0 +1,40 @@ +#!/usr/bin/env bash +# +# Generate all protobuf bindings. +# Run from repository root. +# +# Initial script taken from etcd under the Apache 2.0 license +# File: https://github.com/coreos/etcd/blob/78a5eb79b510eb497deddd1a76f5153bc4b202d2/scripts/genproto.sh + +set -e +set -u + +if ! [[ "$0" =~ "scripts/genproto.sh" ]]; then + echo "must be run from repository root" + exit 255 +fi + +if ! [[ $(protoc --version) =~ "3.5.1" ]]; then + echo "could not find protoc 3.5.1, is it installed + in PATH?" + exit 255 +fi + +GOGOPROTO_ROOT="${GOPATH}/src/github.com/gogo/protobuf" +GOGOPROTO_PATH="${GOGOPROTO_ROOT}:${GOGOPROTO_ROOT}/protobuf" +GRPC_GATEWAY_ROOT="${GOPATH}/src/github.com/grpc-ecosystem/grpc-gateway" + +DIRS="nflog/nflogpb silence/silencepb cluster/clusterpb" + +for dir in ${DIRS}; do + pushd ${dir} + protoc --gogofast_out=plugins=grpc:. -I=. \ + -I="${GOGOPROTO_PATH}" \ + -I="${GRPC_GATEWAY_ROOT}/third_party/googleapis" \ + *.proto + + sed -i.bak -E 's/import _ \"gogoproto\"//g' *.pb.go + sed -i.bak -E 's/import _ \"google\/protobuf\"//g' *.pb.go + rm -f *.bak + goimports -w *.pb.go + popd +done diff --git a/src/alertmanager/silence/silence.go b/src/alertmanager/silence/silence.go new file mode 100644 index 0000000..1fd3d59 --- /dev/null +++ b/src/alertmanager/silence/silence.go @@ -0,0 +1,829 @@ +// Copyright 2016 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package silence provides a storage for silences, which can share its +// state over a mesh network and snapshot it. +package silence + +import ( + "bytes" + "fmt" + "io" + "math/rand" + "os" + "reflect" + "regexp" + "sync" + "time" + + "github.com/go-kit/kit/log" + "github.com/go-kit/kit/log/level" + "github.com/matttproud/golang_protobuf_extensions/pbutil" + "github.com/pkg/errors" + "github.com/prometheus/alertmanager/cluster" + pb "github.com/prometheus/alertmanager/silence/silencepb" + "github.com/prometheus/alertmanager/types" + "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/common/model" + "github.com/satori/go.uuid" +) + +// ErrNotFound is returned if a silence was not found. +var ErrNotFound = fmt.Errorf("not found") + +// ErrInvalidState is returned if the state isn't valid. +var ErrInvalidState = fmt.Errorf("invalid state") + +func utcNow() time.Time { + return time.Now().UTC() +} + +type matcherCache map[*pb.Silence]types.Matchers + +// Get retrieves the matchers for a given silence. If it is a missed cache +// access, it compiles and adds the matchers of the requested silence to the +// cache. +func (c matcherCache) Get(s *pb.Silence) (types.Matchers, error) { + if m, ok := c[s]; ok { + return m, nil + } + return c.add(s) +} + +// add compiles a silences' matchers and adds them to the cache. +// It returns the compiled matchers. +func (c matcherCache) add(s *pb.Silence) (types.Matchers, error) { + var ( + ms types.Matchers + mt *types.Matcher + ) + + for _, m := range s.Matchers { + mt = &types.Matcher{ + Name: m.Name, + Value: m.Pattern, + } + switch m.Type { + case pb.Matcher_EQUAL: + mt.IsRegex = false + case pb.Matcher_REGEXP: + mt.IsRegex = true + } + err := mt.Init() + if err != nil { + return nil, err + } + + ms = append(ms, mt) + } + + c[s] = ms + + return ms, nil +} + +// Silences holds a silence state that can be modified, queried, and snapshot. +type Silences struct { + logger log.Logger + metrics *metrics + now func() time.Time + retention time.Duration + + mtx sync.RWMutex + st state + broadcast func([]byte) + mc matcherCache +} + +type metrics struct { + gcDuration prometheus.Summary + snapshotDuration prometheus.Summary + snapshotSize prometheus.Gauge + queriesTotal prometheus.Counter + queryErrorsTotal prometheus.Counter + queryDuration prometheus.Histogram + silencesActive prometheus.GaugeFunc + silencesPending prometheus.GaugeFunc + silencesExpired prometheus.GaugeFunc + propagatedMessagesTotal prometheus.Counter +} + +func newSilenceMetricByState(s *Silences, st types.SilenceState) prometheus.GaugeFunc { + return prometheus.NewGaugeFunc( + prometheus.GaugeOpts{ + Name: "alertmanager_silences", + Help: "How many silences by state.", + ConstLabels: prometheus.Labels{"state": string(st)}, + }, + func() float64 { + count, err := s.CountState(st) + if err != nil { + level.Error(s.logger).Log("msg", "Counting silences failed", "err", err) + } + return float64(count) + }, + ) +} + +func newMetrics(r prometheus.Registerer, s *Silences) *metrics { + m := &metrics{} + + m.gcDuration = prometheus.NewSummary(prometheus.SummaryOpts{ + Name: "alertmanager_silences_gc_duration_seconds", + Help: "Duration of the last silence garbage collection cycle.", + }) + m.snapshotDuration = prometheus.NewSummary(prometheus.SummaryOpts{ + Name: "alertmanager_silences_snapshot_duration_seconds", + Help: "Duration of the last silence snapshot.", + }) + m.snapshotSize = prometheus.NewGauge(prometheus.GaugeOpts{ + Name: "alertmanager_silences_snapshot_size_bytes", + Help: "Size of the last silence snapshot in bytes.", + }) + m.queriesTotal = prometheus.NewCounter(prometheus.CounterOpts{ + Name: "alertmanager_silences_queries_total", + Help: "How many silence queries were received.", + }) + m.queryErrorsTotal = prometheus.NewCounter(prometheus.CounterOpts{ + Name: "alertmanager_silences_query_errors_total", + Help: "How many silence received queries did not succeed.", + }) + m.queryDuration = prometheus.NewHistogram(prometheus.HistogramOpts{ + Name: "alertmanager_silences_query_duration_seconds", + Help: "Duration of silence query evaluation.", + }) + m.propagatedMessagesTotal = prometheus.NewCounter(prometheus.CounterOpts{ + Name: "alertmanager_silences_gossip_messages_propagated_total", + Help: "Number of received gossip messages that have been further gossiped.", + }) + if s != nil { + m.silencesActive = newSilenceMetricByState(s, types.SilenceStateActive) + m.silencesPending = newSilenceMetricByState(s, types.SilenceStatePending) + m.silencesExpired = newSilenceMetricByState(s, types.SilenceStateExpired) + } + + if r != nil { + r.MustRegister( + m.gcDuration, + m.snapshotDuration, + m.snapshotSize, + m.queriesTotal, + m.queryErrorsTotal, + m.queryDuration, + m.silencesActive, + m.silencesPending, + m.silencesExpired, + m.propagatedMessagesTotal, + ) + } + return m +} + +// Options exposes configuration options for creating a new Silences object. +// Its zero value is a safe default. +type Options struct { + // A snapshot file or reader from which the initial state is loaded. + // None or only one of them must be set. + SnapshotFile string + SnapshotReader io.Reader + + // Retention time for newly created Silences. Silences may be + // garbage collected after the given duration after they ended. + Retention time.Duration + + // A logger used by background processing. + Logger log.Logger + Metrics prometheus.Registerer +} + +func (o *Options) validate() error { + if o.SnapshotFile != "" && o.SnapshotReader != nil { + return fmt.Errorf("only one of SnapshotFile and SnapshotReader must be set") + } + return nil +} + +// New returns a new Silences object with the given configuration. +func New(o Options) (*Silences, error) { + if err := o.validate(); err != nil { + return nil, err + } + if o.SnapshotFile != "" { + if r, err := os.Open(o.SnapshotFile); err != nil { + if !os.IsNotExist(err) { + return nil, err + } + } else { + o.SnapshotReader = r + } + } + s := &Silences{ + mc: matcherCache{}, + logger: log.NewNopLogger(), + retention: o.Retention, + now: utcNow, + broadcast: func([]byte) {}, + st: state{}, + } + s.metrics = newMetrics(o.Metrics, s) + + if o.Logger != nil { + s.logger = o.Logger + } + if o.SnapshotReader != nil { + if err := s.loadSnapshot(o.SnapshotReader); err != nil { + return s, err + } + } + return s, nil +} + +// Maintenance garbage collects the silence state at the given interval. If the snapshot +// file is set, a snapshot is written to it afterwards. +// Terminates on receiving from stopc. +func (s *Silences) Maintenance(interval time.Duration, snapf string, stopc <-chan struct{}) { + t := time.NewTicker(interval) + defer t.Stop() + + f := func() error { + start := s.now() + var size int64 + + level.Debug(s.logger).Log("msg", "Running maintenance") + defer func() { + level.Debug(s.logger).Log("msg", "Maintenance done", "duration", s.now().Sub(start), "size", size) + s.metrics.snapshotSize.Set(float64(size)) + }() + + if _, err := s.GC(); err != nil { + return err + } + if snapf == "" { + return nil + } + f, err := openReplace(snapf) + if err != nil { + return err + } + if size, err = s.Snapshot(f); err != nil { + return err + } + return f.Close() + } + +Loop: + for { + select { + case <-stopc: + break Loop + case <-t.C: + if err := f(); err != nil { + level.Info(s.logger).Log("msg", "Running maintenance failed", "err", err) + } + } + } + // No need for final maintenance if we don't want to snapshot. + if snapf == "" { + return + } + if err := f(); err != nil { + level.Info(s.logger).Log("msg", "Creating shutdown snapshot failed", "err", err) + } +} + +// GC runs a garbage collection that removes silences that have ended longer +// than the configured retention time ago. +func (s *Silences) GC() (int, error) { + start := time.Now() + defer func() { s.metrics.gcDuration.Observe(time.Since(start).Seconds()) }() + + now := s.now() + var n int + + s.mtx.Lock() + defer s.mtx.Unlock() + + for id, sil := range s.st { + if sil.ExpiresAt.IsZero() { + return n, errors.New("unexpected zero expiration timestamp") + } + if !sil.ExpiresAt.After(now) { + delete(s.st, id) + delete(s.mc, sil.Silence) + n++ + } + } + + return n, nil +} + +func validateMatcher(m *pb.Matcher) error { + if !model.LabelName(m.Name).IsValid() { + return fmt.Errorf("invalid label name %q", m.Name) + } + switch m.Type { + case pb.Matcher_EQUAL: + if !model.LabelValue(m.Pattern).IsValid() { + return fmt.Errorf("invalid label value %q", m.Pattern) + } + case pb.Matcher_REGEXP: + if _, err := regexp.Compile(m.Pattern); err != nil { + return fmt.Errorf("invalid regular expression %q: %s", m.Pattern, err) + } + default: + return fmt.Errorf("unknown matcher type %q", m.Type) + } + return nil +} + +func validateSilence(s *pb.Silence) error { + if s.Id == "" { + return errors.New("ID missing") + } + if len(s.Matchers) == 0 { + return errors.New("at least one matcher required") + } + for i, m := range s.Matchers { + if err := validateMatcher(m); err != nil { + return fmt.Errorf("invalid label matcher %d: %s", i, err) + } + } + if s.StartsAt.IsZero() { + return errors.New("invalid zero start timestamp") + } + if s.EndsAt.IsZero() { + return errors.New("invalid zero end timestamp") + } + if s.EndsAt.Before(s.StartsAt) { + return errors.New("end time must not be before start time") + } + if s.UpdatedAt.IsZero() { + return errors.New("invalid zero update timestamp") + } + return nil +} + +// cloneSilence returns a shallow copy of a silence. +func cloneSilence(sil *pb.Silence) *pb.Silence { + s := *sil + return &s +} + +func (s *Silences) getSilence(id string) (*pb.Silence, bool) { + msil, ok := s.st[id] + if !ok { + return nil, false + } + return msil.Silence, true +} + +func (s *Silences) setSilence(sil *pb.Silence) error { + sil.UpdatedAt = s.now() + + if err := validateSilence(sil); err != nil { + return errors.Wrap(err, "silence invalid") + } + + msil := &pb.MeshSilence{ + Silence: sil, + ExpiresAt: sil.EndsAt.Add(s.retention), + } + b, err := marshalMeshSilence(msil) + if err != nil { + return err + } + + s.st.merge(msil) + s.broadcast(b) + + return nil +} + +// Set the specified silence. If a silence with the ID already exists and the modification +// modifies history, the old silence gets expired and a new one is created. +func (s *Silences) Set(sil *pb.Silence) (string, error) { + s.mtx.Lock() + defer s.mtx.Unlock() + + now := s.now() + prev, ok := s.getSilence(sil.Id) + + if sil.Id != "" && !ok { + return "", ErrNotFound + } + if ok { + if canUpdate(prev, sil, now) { + return sil.Id, s.setSilence(sil) + } + if getState(prev, s.now()) != types.SilenceStateExpired { + // We cannot update the silence, expire the old one. + if err := s.expire(prev.Id); err != nil { + return "", errors.Wrap(err, "expire previous silence") + } + } + } + // If we got here it's either a new silence or a replacing one. + sil.Id = uuid.NewV4().String() + + if sil.StartsAt.Before(now) { + sil.StartsAt = now + } + + return sil.Id, s.setSilence(sil) +} + +// canUpdate returns true if silence a can be updated to b without +// affecting the historic view of silencing. +func canUpdate(a, b *pb.Silence, now time.Time) bool { + if !reflect.DeepEqual(a.Matchers, b.Matchers) { + return false + } + // Allowed timestamp modifications depend on the current time. + switch st := getState(a, now); st { + case types.SilenceStateActive: + if !b.StartsAt.Equal(a.StartsAt) { + return false + } + if b.EndsAt.Before(now) { + return false + } + case types.SilenceStatePending: + if b.StartsAt.Before(now) { + return false + } + case types.SilenceStateExpired: + return false + default: + panic("unknown silence state") + } + return true +} + +// Expire the silence with the given ID immediately. +func (s *Silences) Expire(id string) error { + s.mtx.Lock() + defer s.mtx.Unlock() + return s.expire(id) +} + +// Expire the silence with the given ID immediately. +func (s *Silences) expire(id string) error { + sil, ok := s.getSilence(id) + if !ok { + return ErrNotFound + } + sil = cloneSilence(sil) + now := s.now() + + switch getState(sil, now) { + case types.SilenceStateExpired: + return errors.Errorf("silence %s already expired", id) + case types.SilenceStateActive: + sil.EndsAt = now + case types.SilenceStatePending: + // Set both to now to make Silence move to "expired" state + sil.StartsAt = now + sil.EndsAt = now + } + + return s.setSilence(sil) +} + +// QueryParam expresses parameters along which silences are queried. +type QueryParam func(*query) error + +type query struct { + ids []string + filters []silenceFilter +} + +// silenceFilter is a function that returns true if a silence +// should be dropped from a result set for a given time. +type silenceFilter func(*pb.Silence, *Silences, time.Time) (bool, error) + +var errNotSupported = errors.New("query parameter not supported") + +// QIDs configures a query to select the given silence IDs. +func QIDs(ids ...string) QueryParam { + return func(q *query) error { + q.ids = append(q.ids, ids...) + return nil + } +} + +// QTimeRange configures a query to search for silences that are active +// in the given time range. +// TODO(fabxc): not supported yet. +func QTimeRange(start, end time.Time) QueryParam { + return func(q *query) error { + return errNotSupported + } +} + +// QMatches returns silences that match the given label set. +func QMatches(set model.LabelSet) QueryParam { + return func(q *query) error { + f := func(sil *pb.Silence, s *Silences, _ time.Time) (bool, error) { + m, err := s.mc.Get(sil) + if err != nil { + return true, err + } + return m.Match(set), nil + } + q.filters = append(q.filters, f) + return nil + } +} + +// getState returns a silence's SilenceState at the given timestamp. +func getState(sil *pb.Silence, ts time.Time) types.SilenceState { + if ts.Before(sil.StartsAt) { + return types.SilenceStatePending + } + if ts.After(sil.EndsAt) { + return types.SilenceStateExpired + } + return types.SilenceStateActive +} + +// QState filters queried silences by the given states. +func QState(states ...types.SilenceState) QueryParam { + return func(q *query) error { + f := func(sil *pb.Silence, _ *Silences, now time.Time) (bool, error) { + s := getState(sil, now) + + for _, ps := range states { + if s == ps { + return true, nil + } + } + return false, nil + } + q.filters = append(q.filters, f) + return nil + } +} + +// QueryOne queries with the given parameters and returns the first result. +// Returns ErrNotFound if the query result is empty. +func (s *Silences) QueryOne(params ...QueryParam) (*pb.Silence, error) { + res, err := s.Query(params...) + if err != nil { + return nil, err + } + if len(res) == 0 { + return nil, ErrNotFound + } + return res[0], nil +} + +// Query for silences based on the given query parameters. +func (s *Silences) Query(params ...QueryParam) ([]*pb.Silence, error) { + start := time.Now() + s.metrics.queriesTotal.Inc() + + sils, err := func() ([]*pb.Silence, error) { + q := &query{} + for _, p := range params { + if err := p(q); err != nil { + return nil, err + } + } + return s.query(q, s.now()) + }() + if err != nil { + s.metrics.queryErrorsTotal.Inc() + } + s.metrics.queryDuration.Observe(time.Since(start).Seconds()) + return sils, err +} + +// Count silences by state. +func (s *Silences) CountState(states ...types.SilenceState) (int, error) { + // This could probably be optimized. + sils, err := s.Query(QState(states...)) + if err != nil { + return -1, err + } + return len(sils), nil +} + +func (s *Silences) query(q *query, now time.Time) ([]*pb.Silence, error) { + // If we have an ID constraint, all silences are our base set. + // This and the use of post-filter functions is the + // the trivial solution for now. + var res []*pb.Silence + + s.mtx.Lock() + defer s.mtx.Unlock() + + if q.ids != nil { + for _, id := range q.ids { + if s, ok := s.st[id]; ok { + res = append(res, s.Silence) + } + } + } else { + for _, sil := range s.st { + res = append(res, sil.Silence) + } + } + + var resf []*pb.Silence + for _, sil := range res { + remove := false + for _, f := range q.filters { + ok, err := f(sil, s, now) + if err != nil { + return nil, err + } + if !ok { + remove = true + break + } + } + if !remove { + resf = append(resf, cloneSilence(sil)) + } + } + + return resf, nil +} + +// loadSnapshot loads a snapshot generated by Snapshot() into the state. +// Any previous state is wiped. +func (s *Silences) loadSnapshot(r io.Reader) error { + st, err := decodeState(r) + if err != nil { + return err + } + for _, e := range st { + // Comments list was moved to a single comment. Upgrade on loading the snapshot. + if len(e.Silence.Comments) > 0 { + e.Silence.Comment = e.Silence.Comments[0].Comment + e.Silence.CreatedBy = e.Silence.Comments[0].Author + e.Silence.Comments = nil + } + st[e.Silence.Id] = e + } + s.mtx.Lock() + s.st = st + s.mtx.Unlock() + + return nil +} + +// Snapshot writes the full internal state into the writer and returns the number of bytes +// written. +func (s *Silences) Snapshot(w io.Writer) (int64, error) { + start := time.Now() + defer func() { s.metrics.snapshotDuration.Observe(time.Since(start).Seconds()) }() + + s.mtx.RLock() + defer s.mtx.RUnlock() + + b, err := s.st.MarshalBinary() + if err != nil { + return 0, err + } + + return io.Copy(w, bytes.NewReader(b)) +} + +// MarshalBinary serializes all silences. +func (s *Silences) MarshalBinary() ([]byte, error) { + s.mtx.Lock() + defer s.mtx.Unlock() + + return s.st.MarshalBinary() +} + +// Merge merges silence state received from the cluster with the local state. +func (s *Silences) Merge(b []byte) error { + st, err := decodeState(bytes.NewReader(b)) + if err != nil { + return err + } + s.mtx.Lock() + defer s.mtx.Unlock() + + for _, e := range st { + if merged := s.st.merge(e); merged && !cluster.OversizedMessage(b) { + // If this is the first we've seen the message and it's + // not oversized, gossip it to other nodes. We don't + // propagate oversized messages because they're sent to + // all nodes already. + s.broadcast(b) + s.metrics.propagatedMessagesTotal.Inc() + level.Debug(s.logger).Log("msg", "gossiping new silence", "silence", e) + } + } + return nil +} + +func (s *Silences) SetBroadcast(f func([]byte)) { + s.mtx.Lock() + s.broadcast = f + s.mtx.Unlock() +} + +type state map[string]*pb.MeshSilence + +func (s state) merge(e *pb.MeshSilence) bool { + // Comments list was moved to a single comment. Apply upgrade + // on silences received from peers. + if len(e.Silence.Comments) > 0 { + e.Silence.Comment = e.Silence.Comments[0].Comment + e.Silence.CreatedBy = e.Silence.Comments[0].Author + e.Silence.Comments = nil + } + id := e.Silence.Id + + prev, ok := s[id] + if !ok || prev.Silence.UpdatedAt.Before(e.Silence.UpdatedAt) { + s[id] = e + return true + } + return false +} + +func (s state) MarshalBinary() ([]byte, error) { + var buf bytes.Buffer + + for _, e := range s { + if _, err := pbutil.WriteDelimited(&buf, e); err != nil { + return nil, err + } + } + return buf.Bytes(), nil +} + +func decodeState(r io.Reader) (state, error) { + st := state{} + for { + var s pb.MeshSilence + _, err := pbutil.ReadDelimited(r, &s) + if err == nil { + if s.Silence == nil { + return nil, ErrInvalidState + } + st[s.Silence.Id] = &s + continue + } + if err == io.EOF { + break + } + return nil, err + } + return st, nil +} + +func marshalMeshSilence(e *pb.MeshSilence) ([]byte, error) { + var buf bytes.Buffer + if _, err := pbutil.WriteDelimited(&buf, e); err != nil { + return nil, err + } + return buf.Bytes(), nil +} + +// replaceFile wraps a file that is moved to another filename on closing. +type replaceFile struct { + *os.File + filename string +} + +func (f *replaceFile) Close() error { + if err := f.File.Sync(); err != nil { + return err + } + if err := f.File.Close(); err != nil { + return err + } + return os.Rename(f.File.Name(), f.filename) +} + +// openReplace opens a new temporary file that is moved to filename on closing. +func openReplace(filename string) (*replaceFile, error) { + tmpFilename := fmt.Sprintf("%s.%x", filename, uint64(rand.Int63())) + + f, err := os.Create(tmpFilename) + if err != nil { + return nil, err + } + + rf := &replaceFile{ + File: f, + filename: filename, + } + return rf, nil +} diff --git a/src/alertmanager/silence/silence_test.go b/src/alertmanager/silence/silence_test.go new file mode 100644 index 0000000..febdaf0 --- /dev/null +++ b/src/alertmanager/silence/silence_test.go @@ -0,0 +1,1093 @@ +// Copyright 2016 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package silence + +import ( + "bytes" + "io/ioutil" + "os" + "sort" + "strings" + "testing" + "time" + + "github.com/matttproud/golang_protobuf_extensions/pbutil" + pb "github.com/prometheus/alertmanager/silence/silencepb" + "github.com/prometheus/alertmanager/types" + "github.com/prometheus/common/model" + "github.com/stretchr/testify/require" +) + +func TestOptionsValidate(t *testing.T) { + cases := []struct { + options *Options + err string + }{ + { + options: &Options{ + SnapshotReader: &bytes.Buffer{}, + }, + }, + { + options: &Options{ + SnapshotFile: "test.bkp", + }, + }, + { + options: &Options{ + SnapshotFile: "test bkp", + SnapshotReader: &bytes.Buffer{}, + }, + err: "only one of SnapshotFile and SnapshotReader must be set", + }, + } + + for _, c := range cases { + err := c.options.validate() + if err == nil { + if c.err != "" { + t.Errorf("expected error containing %q but got none", c.err) + } + continue + } + if err != nil && c.err == "" { + t.Errorf("unexpected error %q", err) + continue + } + if !strings.Contains(err.Error(), c.err) { + t.Errorf("expected error to contain %q but got %q", c.err, err) + } + } +} + +func TestSilencesGC(t *testing.T) { + s, err := New(Options{}) + require.NoError(t, err) + + now := utcNow() + s.now = func() time.Time { return now } + + newSilence := func(exp time.Time) *pb.MeshSilence { + return &pb.MeshSilence{ExpiresAt: exp} + } + s.st = state{ + "1": newSilence(now), + "2": newSilence(now.Add(-time.Second)), + "3": newSilence(now.Add(time.Second)), + } + want := state{ + "3": newSilence(now.Add(time.Second)), + } + + n, err := s.GC() + require.NoError(t, err) + require.Equal(t, 2, n) + require.Equal(t, want, s.st) +} + +func TestSilencesSnapshot(t *testing.T) { + // Check whether storing and loading the snapshot is symmetric. + now := utcNow() + + cases := []struct { + entries []*pb.MeshSilence + }{ + { + entries: []*pb.MeshSilence{ + { + Silence: &pb.Silence{ + Id: "3be80475-e219-4ee7-b6fc-4b65114e362f", + Matchers: []*pb.Matcher{ + {Name: "label1", Pattern: "val1", Type: pb.Matcher_EQUAL}, + {Name: "label2", Pattern: "val.+", Type: pb.Matcher_REGEXP}, + }, + StartsAt: now, + EndsAt: now, + UpdatedAt: now, + }, + ExpiresAt: now, + }, + { + Silence: &pb.Silence{ + Id: "4b1e760d-182c-4980-b873-c1a6827c9817", + Matchers: []*pb.Matcher{ + {Name: "label1", Pattern: "val1", Type: pb.Matcher_EQUAL}, + }, + StartsAt: now.Add(time.Hour), + EndsAt: now.Add(2 * time.Hour), + UpdatedAt: now, + }, + ExpiresAt: now.Add(24 * time.Hour), + }, + }, + }, + } + + for _, c := range cases { + f, err := ioutil.TempFile("", "snapshot") + require.NoError(t, err, "creating temp file failed") + + s1 := &Silences{st: state{}, metrics: newMetrics(nil, nil)} + // Setup internal state manually. + for _, e := range c.entries { + s1.st[e.Silence.Id] = e + } + _, err = s1.Snapshot(f) + require.NoError(t, err, "creating snapshot failed") + + require.NoError(t, f.Close(), "closing snapshot file failed") + + f, err = os.Open(f.Name()) + require.NoError(t, err, "opening snapshot file failed") + + // Check again against new nlog instance. + s2 := &Silences{mc: matcherCache{}, st: state{}} + err = s2.loadSnapshot(f) + require.NoError(t, err, "error loading snapshot") + require.Equal(t, s1.st, s2.st, "state after loading snapshot did not match snapshotted state") + + require.NoError(t, f.Close(), "closing snapshot file failed") + } +} + +func TestSilencesSetSilence(t *testing.T) { + s, err := New(Options{ + Retention: time.Minute, + }) + require.NoError(t, err) + + now := utcNow() + nowpb := now + + sil := &pb.Silence{ + Id: "some_id", + Matchers: []*pb.Matcher{{Name: "abc", Pattern: "def"}}, + StartsAt: nowpb, + EndsAt: nowpb, + } + + want := state{ + "some_id": &pb.MeshSilence{ + Silence: sil, + ExpiresAt: now.Add(time.Minute), + }, + } + + done := make(chan bool) + s.broadcast = func(b []byte) { + var e pb.MeshSilence + r := bytes.NewReader(b) + _, err := pbutil.ReadDelimited(r, &e) + require.NoError(t, err) + + require.Equal(t, want["some_id"], &e) + close(done) + } + + // setSilence() is always called with s.mtx locked() + go func() { + s.mtx.Lock() + require.NoError(t, s.setSilence(sil)) + s.mtx.Unlock() + }() + + // GossipBroadcast is called in a goroutine. + select { + case <-done: + case <-time.After(1 * time.Second): + t.Fatal("GossipBroadcast was not called") + } + + require.Equal(t, want, s.st, "Unexpected silence state") +} + +func TestSilenceSet(t *testing.T) { + s, err := New(Options{ + Retention: time.Hour, + }) + require.NoError(t, err) + + now := utcNow() + now1 := now + s.now = func() time.Time { return now } + + // Insert silence with fixed start time. + sil1 := &pb.Silence{ + Matchers: []*pb.Matcher{{Name: "a", Pattern: "b"}}, + StartsAt: now.Add(2 * time.Minute), + EndsAt: now.Add(5 * time.Minute), + } + id1, err := s.Set(sil1) + require.NoError(t, err) + require.NotEqual(t, id1, "") + + want := state{ + id1: &pb.MeshSilence{ + Silence: &pb.Silence{ + Id: id1, + Matchers: []*pb.Matcher{{Name: "a", Pattern: "b"}}, + StartsAt: now1.Add(2 * time.Minute), + EndsAt: now1.Add(5 * time.Minute), + UpdatedAt: now1, + }, + ExpiresAt: now1.Add(5*time.Minute + s.retention), + }, + } + require.Equal(t, want, s.st, "unexpected state after silence creation") + + // Insert silence with unset start time. Must be set to now. + now = now.Add(time.Minute) + now2 := now + + sil2 := &pb.Silence{ + Matchers: []*pb.Matcher{{Name: "a", Pattern: "b"}}, + EndsAt: now.Add(1 * time.Minute), + } + id2, err := s.Set(sil2) + require.NoError(t, err) + require.NotEqual(t, id2, "") + + want = state{ + id1: want[id1], + id2: &pb.MeshSilence{ + Silence: &pb.Silence{ + Id: id2, + Matchers: []*pb.Matcher{{Name: "a", Pattern: "b"}}, + StartsAt: now2, + EndsAt: now2.Add(1 * time.Minute), + UpdatedAt: now2, + }, + ExpiresAt: now2.Add(1*time.Minute + s.retention), + }, + } + require.Equal(t, want, s.st, "unexpected state after silence creation") + + // Overwrite silence 2 with new end time. + now = now.Add(time.Minute) + now3 := now + + sil3 := cloneSilence(sil2) + sil3.EndsAt = now.Add(100 * time.Minute) + + id3, err := s.Set(sil3) + require.NoError(t, err) + require.Equal(t, id2, id3) + + want = state{ + id1: want[id1], + id2: &pb.MeshSilence{ + Silence: &pb.Silence{ + Id: id2, + Matchers: []*pb.Matcher{{Name: "a", Pattern: "b"}}, + StartsAt: now2, + EndsAt: now3.Add(100 * time.Minute), + UpdatedAt: now3, + }, + ExpiresAt: now3.Add(100*time.Minute + s.retention), + }, + } + require.Equal(t, want, s.st, "unexpected state after silence creation") + + // Update silence 2 with new matcher expires it and creates a new one. + now = now.Add(time.Minute) + now4 := now + + sil4 := cloneSilence(sil3) + sil4.Matchers = []*pb.Matcher{{Name: "a", Pattern: "c"}} + + id4, err := s.Set(sil4) + require.NoError(t, err) + require.NotEqual(t, id2, id4) + + want = state{ + id1: want[id1], + id2: &pb.MeshSilence{ + Silence: &pb.Silence{ + Id: id2, + Matchers: []*pb.Matcher{{Name: "a", Pattern: "b"}}, + StartsAt: now2, + EndsAt: now4, + UpdatedAt: now4, + }, + ExpiresAt: now4.Add(s.retention), + }, + id4: &pb.MeshSilence{ + Silence: &pb.Silence{ + Id: id4, + Matchers: []*pb.Matcher{{Name: "a", Pattern: "c"}}, + StartsAt: now4, + EndsAt: now3.Add(100 * time.Minute), + UpdatedAt: now4, + }, + ExpiresAt: now3.Add(100*time.Minute + s.retention), + }, + } + require.Equal(t, want, s.st, "unexpected state after silence creation") + + // Re-create expired silence. + now = now.Add(time.Minute) + now5 := now + + sil5 := cloneSilence(sil3) + sil5.StartsAt = now + sil5.EndsAt = now.Add(5 * time.Minute) + + id5, err := s.Set(sil5) + require.NoError(t, err) + require.NotEqual(t, id2, id4) + + want = state{ + id1: want[id1], + id2: want[id2], + id4: want[id4], + id5: &pb.MeshSilence{ + Silence: &pb.Silence{ + Id: id5, + Matchers: []*pb.Matcher{{Name: "a", Pattern: "b"}}, + StartsAt: now5, + EndsAt: now5.Add(5 * time.Minute), + UpdatedAt: now5, + }, + ExpiresAt: now5.Add(5*time.Minute + s.retention), + }, + } + require.Equal(t, want, s.st, "unexpected state after silence creation") +} + +func TestSilencesSetFail(t *testing.T) { + s, err := New(Options{}) + require.NoError(t, err) + + now := utcNow() + s.now = func() time.Time { return now } + + cases := []struct { + s *pb.Silence + err string + }{ + { + s: &pb.Silence{Id: "some_id"}, + err: ErrNotFound.Error(), + }, { + s: &pb.Silence{}, // Silence without matcher. + err: "silence invalid", + }, + } + for _, c := range cases { + _, err := s.Set(c.s) + if err == nil { + if c.err != "" { + t.Errorf("expected error containing %q but got none", c.err) + } + continue + } + if err != nil && c.err == "" { + t.Errorf("unexpected error %q", err) + continue + } + if !strings.Contains(err.Error(), c.err) { + t.Errorf("expected error to contain %q but got %q", c.err, err) + } + } +} + +func TestQState(t *testing.T) { + now := utcNow() + + cases := []struct { + sil *pb.Silence + states []types.SilenceState + keep bool + }{ + { + sil: &pb.Silence{ + StartsAt: now.Add(time.Minute), + EndsAt: now.Add(time.Hour), + }, + states: []types.SilenceState{types.SilenceStateActive, types.SilenceStateExpired}, + keep: false, + }, + { + sil: &pb.Silence{ + StartsAt: now.Add(time.Minute), + EndsAt: now.Add(time.Hour), + }, + states: []types.SilenceState{types.SilenceStatePending}, + keep: true, + }, + { + sil: &pb.Silence{ + StartsAt: now.Add(time.Minute), + EndsAt: now.Add(time.Hour), + }, + states: []types.SilenceState{types.SilenceStateExpired, types.SilenceStatePending}, + keep: true, + }, + } + for i, c := range cases { + q := &query{} + QState(c.states...)(q) + f := q.filters[0] + + keep, err := f(c.sil, nil, now) + require.NoError(t, err) + require.Equal(t, c.keep, keep, "unexpected filter result for case %d", i) + } +} + +func TestQMatches(t *testing.T) { + qp := QMatches(model.LabelSet{ + "job": "test", + "instance": "web-1", + "path": "/user/profile", + "method": "GET", + }) + + q := &query{} + qp(q) + f := q.filters[0] + + cases := []struct { + sil *pb.Silence + drop bool + }{ + { + sil: &pb.Silence{ + Matchers: []*pb.Matcher{ + {Name: "job", Pattern: "test", Type: pb.Matcher_EQUAL}, + }, + }, + drop: true, + }, + { + sil: &pb.Silence{ + Matchers: []*pb.Matcher{ + {Name: "job", Pattern: "test", Type: pb.Matcher_EQUAL}, + {Name: "method", Pattern: "POST", Type: pb.Matcher_EQUAL}, + }, + }, + drop: false, + }, + { + sil: &pb.Silence{ + Matchers: []*pb.Matcher{ + {Name: "path", Pattern: "/user/.+", Type: pb.Matcher_REGEXP}, + }, + }, + drop: true, + }, + { + sil: &pb.Silence{ + Matchers: []*pb.Matcher{ + {Name: "path", Pattern: "/user/.+", Type: pb.Matcher_REGEXP}, + {Name: "path", Pattern: "/nothing/.+", Type: pb.Matcher_REGEXP}, + }, + }, + drop: false, + }, + } + for _, c := range cases { + drop, err := f(c.sil, &Silences{mc: matcherCache{}, st: state{}}, time.Time{}) + require.NoError(t, err) + require.Equal(t, c.drop, drop, "unexpected filter result") + } +} + +func TestSilencesQuery(t *testing.T) { + s, err := New(Options{}) + require.NoError(t, err) + + s.st = state{ + "1": &pb.MeshSilence{Silence: &pb.Silence{Id: "1"}}, + "2": &pb.MeshSilence{Silence: &pb.Silence{Id: "2"}}, + "3": &pb.MeshSilence{Silence: &pb.Silence{Id: "3"}}, + "4": &pb.MeshSilence{Silence: &pb.Silence{Id: "4"}}, + "5": &pb.MeshSilence{Silence: &pb.Silence{Id: "5"}}, + } + cases := []struct { + q *query + exp []*pb.Silence + }{ + { + // Default query of retrieving all silences. + q: &query{}, + exp: []*pb.Silence{ + {Id: "1"}, + {Id: "2"}, + {Id: "3"}, + {Id: "4"}, + {Id: "5"}, + }, + }, + { + // Retrieve by IDs. + q: &query{ + ids: []string{"2", "5"}, + }, + exp: []*pb.Silence{ + {Id: "2"}, + {Id: "5"}, + }, + }, + { + // Retrieve all and filter + q: &query{ + filters: []silenceFilter{ + func(sil *pb.Silence, _ *Silences, _ time.Time) (bool, error) { + return sil.Id == "1" || sil.Id == "2", nil + }, + }, + }, + exp: []*pb.Silence{ + {Id: "1"}, + {Id: "2"}, + }, + }, + { + // Retrieve by IDs and filter + q: &query{ + ids: []string{"2", "5"}, + filters: []silenceFilter{ + func(sil *pb.Silence, _ *Silences, _ time.Time) (bool, error) { + return sil.Id == "1" || sil.Id == "2", nil + }, + }, + }, + exp: []*pb.Silence{ + {Id: "2"}, + }, + }, + } + + for _, c := range cases { + // Run default query of retrieving all silences. + res, err := s.query(c.q, time.Time{}) + require.NoError(t, err, "unexpected error on querying") + + // Currently there are no sorting guarantees in the querying API. + sort.Sort(silencesByID(c.exp)) + sort.Sort(silencesByID(res)) + require.Equal(t, c.exp, res, "unexpected silences in result") + } +} + +type silencesByID []*pb.Silence + +func (s silencesByID) Len() int { return len(s) } +func (s silencesByID) Swap(i, j int) { s[i], s[j] = s[j], s[i] } +func (s silencesByID) Less(i, j int) bool { return s[i].Id < s[j].Id } + +func TestSilenceCanUpdate(t *testing.T) { + now := utcNow() + + cases := []struct { + a, b *pb.Silence + ok bool + }{ + // Bad arguments. + { + a: &pb.Silence{}, + b: &pb.Silence{ + StartsAt: now, + EndsAt: now.Add(-time.Minute), + }, + ok: false, + }, + // Expired silence. + { + a: &pb.Silence{ + StartsAt: now.Add(-time.Hour), + EndsAt: now.Add(-time.Second), + }, + b: &pb.Silence{ + StartsAt: now, + EndsAt: now, + }, + ok: false, + }, + // Pending silences. + { + a: &pb.Silence{ + StartsAt: now.Add(time.Hour), + EndsAt: now.Add(2 * time.Hour), + UpdatedAt: now.Add(-time.Hour), + }, + b: &pb.Silence{ + StartsAt: now.Add(-time.Minute), + EndsAt: now.Add(time.Hour), + }, + ok: false, + }, + { + a: &pb.Silence{ + StartsAt: now.Add(time.Hour), + EndsAt: now.Add(2 * time.Hour), + UpdatedAt: now.Add(-time.Hour), + }, + b: &pb.Silence{ + StartsAt: now.Add(time.Minute), + EndsAt: now.Add(time.Minute), + }, + ok: true, + }, + { + a: &pb.Silence{ + StartsAt: now.Add(time.Hour), + EndsAt: now.Add(2 * time.Hour), + UpdatedAt: now.Add(-time.Hour), + }, + b: &pb.Silence{ + StartsAt: now, // set to exactly start now. + EndsAt: now.Add(2 * time.Hour), + }, + ok: true, + }, + // Active silences. + { + a: &pb.Silence{ + StartsAt: now.Add(-time.Hour), + EndsAt: now.Add(2 * time.Hour), + UpdatedAt: now.Add(-time.Hour), + }, + b: &pb.Silence{ + StartsAt: now.Add(-time.Minute), + EndsAt: now.Add(2 * time.Hour), + }, + ok: false, + }, + { + a: &pb.Silence{ + StartsAt: now.Add(-time.Hour), + EndsAt: now.Add(2 * time.Hour), + UpdatedAt: now.Add(-time.Hour), + }, + b: &pb.Silence{ + StartsAt: now.Add(-time.Hour), + EndsAt: now.Add(-time.Second), + }, + ok: false, + }, + { + a: &pb.Silence{ + StartsAt: now.Add(-time.Hour), + EndsAt: now.Add(2 * time.Hour), + UpdatedAt: now.Add(-time.Hour), + }, + b: &pb.Silence{ + StartsAt: now.Add(-time.Hour), + EndsAt: now, + }, + ok: true, + }, + { + a: &pb.Silence{ + StartsAt: now.Add(-time.Hour), + EndsAt: now.Add(2 * time.Hour), + UpdatedAt: now.Add(-time.Hour), + }, + b: &pb.Silence{ + StartsAt: now.Add(-time.Hour), + EndsAt: now.Add(3 * time.Hour), + }, + ok: true, + }, + } + for _, c := range cases { + ok := canUpdate(c.a, c.b, now) + if ok && !c.ok { + t.Errorf("expected not-updateable but was: %v, %v", c.a, c.b) + } + if ok && !c.ok { + t.Errorf("expected updateable but was not: %v, %v", c.a, c.b) + } + } +} + +func TestSilenceExpire(t *testing.T) { + s, err := New(Options{}) + require.NoError(t, err) + + now := time.Now() + s.now = func() time.Time { return now } + + m := &pb.Matcher{Type: pb.Matcher_EQUAL, Name: "a", Pattern: "b"} + + s.st = state{ + "pending": &pb.MeshSilence{Silence: &pb.Silence{ + Id: "pending", + Matchers: []*pb.Matcher{m}, + StartsAt: now.Add(time.Minute), + EndsAt: now.Add(time.Hour), + UpdatedAt: now.Add(-time.Hour), + }}, + "active": &pb.MeshSilence{Silence: &pb.Silence{ + Id: "active", + Matchers: []*pb.Matcher{m}, + StartsAt: now.Add(-time.Minute), + EndsAt: now.Add(time.Hour), + UpdatedAt: now.Add(-time.Hour), + }}, + "expired": &pb.MeshSilence{Silence: &pb.Silence{ + Id: "expired", + Matchers: []*pb.Matcher{m}, + StartsAt: now.Add(-time.Hour), + EndsAt: now.Add(-time.Minute), + UpdatedAt: now.Add(-time.Hour), + }}, + } + + count, err := s.CountState(types.SilenceStatePending) + require.NoError(t, err) + require.Equal(t, 1, count) + + require.NoError(t, s.expire("pending")) + require.NoError(t, s.expire("active")) + + err = s.expire("expired") + require.Error(t, err) + require.Contains(t, err.Error(), "already expired") + + sil, err := s.QueryOne(QIDs("pending")) + require.NoError(t, err) + require.Equal(t, &pb.Silence{ + Id: "pending", + Matchers: []*pb.Matcher{m}, + StartsAt: now, + EndsAt: now, + UpdatedAt: now, + }, sil) + + count, err = s.CountState(types.SilenceStatePending) + require.NoError(t, err) + require.Equal(t, 0, count) + + // Expiring a pending Silence should make the API return the + // SilenceStateExpired Silence state. + silenceState := types.CalcSilenceState(sil.StartsAt, sil.EndsAt) + require.Equal(t, silenceState, types.SilenceStateExpired) + + sil, err = s.QueryOne(QIDs("active")) + require.NoError(t, err) + require.Equal(t, &pb.Silence{ + Id: "active", + Matchers: []*pb.Matcher{m}, + StartsAt: now.Add(-time.Minute), + EndsAt: now, + UpdatedAt: now, + }, sil) + + sil, err = s.QueryOne(QIDs("expired")) + require.NoError(t, err) + require.Equal(t, &pb.Silence{ + Id: "expired", + Matchers: []*pb.Matcher{m}, + StartsAt: now.Add(-time.Hour), + EndsAt: now.Add(-time.Minute), + UpdatedAt: now.Add(-time.Hour), + }, sil) +} + +func TestValidateMatcher(t *testing.T) { + cases := []struct { + m *pb.Matcher + err string + }{ + { + m: &pb.Matcher{ + Name: "a", + Pattern: "b", + Type: pb.Matcher_EQUAL, + }, + err: "", + }, { + m: &pb.Matcher{ + Name: "00", + Pattern: "a", + Type: pb.Matcher_EQUAL, + }, + err: "invalid label name", + }, { + m: &pb.Matcher{ + Name: "a", + Pattern: "((", + Type: pb.Matcher_REGEXP, + }, + err: "invalid regular expression", + }, { + m: &pb.Matcher{ + Name: "a", + Pattern: "\xff", + Type: pb.Matcher_EQUAL, + }, + err: "invalid label value", + }, { + m: &pb.Matcher{ + Name: "a", + Pattern: "b", + Type: 333, + }, + err: "unknown matcher type", + }, + } + + for _, c := range cases { + err := validateMatcher(c.m) + if err == nil { + if c.err != "" { + t.Errorf("expected error containing %q but got none", c.err) + } + continue + } + if err != nil && c.err == "" { + t.Errorf("unexpected error %q", err) + continue + } + if !strings.Contains(err.Error(), c.err) { + t.Errorf("expected error to contain %q but got %q", c.err, err) + } + } +} + +func TestValidateSilence(t *testing.T) { + var ( + now = utcNow() + zeroTimestamp = time.Time{} + validTimestamp = now + ) + cases := []struct { + s *pb.Silence + err string + }{ + { + s: &pb.Silence{ + Id: "some_id", + Matchers: []*pb.Matcher{ + &pb.Matcher{Name: "a", Pattern: "b"}, + }, + StartsAt: validTimestamp, + EndsAt: validTimestamp, + UpdatedAt: validTimestamp, + }, + err: "", + }, + { + s: &pb.Silence{ + Id: "", + Matchers: []*pb.Matcher{ + &pb.Matcher{Name: "a", Pattern: "b"}, + }, + StartsAt: validTimestamp, + EndsAt: validTimestamp, + UpdatedAt: validTimestamp, + }, + err: "ID missing", + }, + { + s: &pb.Silence{ + Id: "some_id", + Matchers: []*pb.Matcher{}, + StartsAt: validTimestamp, + EndsAt: validTimestamp, + UpdatedAt: validTimestamp, + }, + err: "at least one matcher required", + }, + { + s: &pb.Silence{ + Id: "some_id", + Matchers: []*pb.Matcher{ + &pb.Matcher{Name: "a", Pattern: "b"}, + &pb.Matcher{Name: "00", Pattern: "b"}, + }, + StartsAt: validTimestamp, + EndsAt: validTimestamp, + UpdatedAt: validTimestamp, + }, + err: "invalid label matcher", + }, + { + s: &pb.Silence{ + Id: "some_id", + Matchers: []*pb.Matcher{ + &pb.Matcher{Name: "a", Pattern: "b"}, + }, + StartsAt: now, + EndsAt: now.Add(-time.Second), + UpdatedAt: validTimestamp, + }, + err: "end time must not be before start time", + }, + { + s: &pb.Silence{ + Id: "some_id", + Matchers: []*pb.Matcher{ + &pb.Matcher{Name: "a", Pattern: "b"}, + }, + StartsAt: zeroTimestamp, + EndsAt: validTimestamp, + UpdatedAt: validTimestamp, + }, + err: "invalid zero start timestamp", + }, + { + s: &pb.Silence{ + Id: "some_id", + Matchers: []*pb.Matcher{ + &pb.Matcher{Name: "a", Pattern: "b"}, + }, + StartsAt: validTimestamp, + EndsAt: zeroTimestamp, + UpdatedAt: validTimestamp, + }, + err: "invalid zero end timestamp", + }, + { + s: &pb.Silence{ + Id: "some_id", + Matchers: []*pb.Matcher{ + &pb.Matcher{Name: "a", Pattern: "b"}, + }, + StartsAt: validTimestamp, + EndsAt: validTimestamp, + UpdatedAt: zeroTimestamp, + }, + err: "invalid zero update timestamp", + }, + } + for _, c := range cases { + err := validateSilence(c.s) + if err == nil { + if c.err != "" { + t.Errorf("expected error containing %q but got none", c.err) + } + continue + } + if err != nil && c.err == "" { + t.Errorf("unexpected error %q", err) + continue + } + if !strings.Contains(err.Error(), c.err) { + t.Errorf("expected error to contain %q but got %q", c.err, err) + } + } +} + +func TestStateMerge(t *testing.T) { + now := utcNow() + + // We only care about key names and timestamps for the + // merging logic. + newSilence := func(id string, ts time.Time) *pb.MeshSilence { + return &pb.MeshSilence{ + Silence: &pb.Silence{Id: id, UpdatedAt: ts}, + } + } + + cases := []struct { + a, b state + final state + }{ + { + a: state{ + "a1": newSilence("a1", now), + "a2": newSilence("a2", now), + "a3": newSilence("a3", now), + }, + b: state{ + "b1": newSilence("b1", now), // new key, should be added + "a2": newSilence("a2", now.Add(-time.Minute)), // older timestamp, should be dropped + "a3": newSilence("a3", now.Add(time.Minute)), // newer timestamp, should overwrite + }, + final: state{ + "a1": newSilence("a1", now), + "a2": newSilence("a2", now), + "a3": newSilence("a3", now.Add(time.Minute)), + "b1": newSilence("b1", now), + }, + }, + } + + for _, c := range cases { + for _, e := range c.b { + c.a.merge(e) + } + + require.Equal(t, c.final, c.a, "Merge result should match expectation") + } +} + +func TestStateCoding(t *testing.T) { + // Check whether encoding and decoding the data is symmetric. + now := utcNow() + + cases := []struct { + entries []*pb.MeshSilence + }{ + { + entries: []*pb.MeshSilence{ + { + Silence: &pb.Silence{ + Id: "3be80475-e219-4ee7-b6fc-4b65114e362f", + Matchers: []*pb.Matcher{ + {Name: "label1", Pattern: "val1", Type: pb.Matcher_EQUAL}, + {Name: "label2", Pattern: "val.+", Type: pb.Matcher_REGEXP}, + }, + StartsAt: now, + EndsAt: now, + UpdatedAt: now, + }, + ExpiresAt: now, + }, + { + Silence: &pb.Silence{ + Id: "4b1e760d-182c-4980-b873-c1a6827c9817", + Matchers: []*pb.Matcher{ + {Name: "label1", Pattern: "val1", Type: pb.Matcher_EQUAL}, + }, + StartsAt: now.Add(time.Hour), + EndsAt: now.Add(2 * time.Hour), + UpdatedAt: now, + }, + ExpiresAt: now.Add(24 * time.Hour), + }, + }, + }, + } + + for _, c := range cases { + // Create gossip data from input. + in := state{} + for _, e := range c.entries { + in[e.Silence.Id] = e + } + msg, err := in.MarshalBinary() + require.NoError(t, err) + + out, err := decodeState(bytes.NewReader(msg)) + require.NoError(t, err, "decoding message failed") + + require.Equal(t, in, out, "decoded data doesn't match encoded data") + } +} + +func TestStateDecodingError(t *testing.T) { + // Check whether decoding copes with erroneous data. + s := state{"": &pb.MeshSilence{}} + + msg, err := s.MarshalBinary() + require.NoError(t, err) + + _, err = decodeState(bytes.NewReader(msg)) + require.Equal(t, ErrInvalidState, err) +} diff --git a/src/alertmanager/silence/silencepb/silence.pb.go b/src/alertmanager/silence/silencepb/silence.pb.go new file mode 100644 index 0000000..164ae17 --- /dev/null +++ b/src/alertmanager/silence/silencepb/silence.pb.go @@ -0,0 +1,1236 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: silence.proto + +/* + Package silencepb is a generated protocol buffer package. + + It is generated from these files: + silence.proto + + It has these top-level messages: + Matcher + Comment + Silence + MeshSilence +*/ +package silencepb + +import proto "github.com/gogo/protobuf/proto" +import fmt "fmt" +import math "math" + +import _ "github.com/gogo/protobuf/gogoproto" + +import time "time" + +import types "github.com/gogo/protobuf/types" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf +var _ = time.Kitchen + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package + +// Type specifies how the given name and pattern are matched +// against a label set. +type Matcher_Type int32 + +const ( + Matcher_EQUAL Matcher_Type = 0 + Matcher_REGEXP Matcher_Type = 1 +) + +var Matcher_Type_name = map[int32]string{ + 0: "EQUAL", + 1: "REGEXP", +} +var Matcher_Type_value = map[string]int32{ + "EQUAL": 0, + "REGEXP": 1, +} + +func (x Matcher_Type) String() string { + return proto.EnumName(Matcher_Type_name, int32(x)) +} +func (Matcher_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptorSilence, []int{0, 0} } + +// Matcher specifies a rule, which can match or set of labels or not. +type Matcher struct { + Type Matcher_Type `protobuf:"varint,1,opt,name=type,proto3,enum=silencepb.Matcher_Type" json:"type,omitempty"` + // The label name in a label set to against which the matcher + // checks the pattern. + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + // The pattern being checked according to the matcher's type. + Pattern string `protobuf:"bytes,3,opt,name=pattern,proto3" json:"pattern,omitempty"` +} + +func (m *Matcher) Reset() { *m = Matcher{} } +func (m *Matcher) String() string { return proto.CompactTextString(m) } +func (*Matcher) ProtoMessage() {} +func (*Matcher) Descriptor() ([]byte, []int) { return fileDescriptorSilence, []int{0} } + +// DEPRECATED: A comment can be attached to a silence. +type Comment struct { + Author string `protobuf:"bytes,1,opt,name=author,proto3" json:"author,omitempty"` + Comment string `protobuf:"bytes,2,opt,name=comment,proto3" json:"comment,omitempty"` + Timestamp time.Time `protobuf:"bytes,3,opt,name=timestamp,stdtime" json:"timestamp"` +} + +func (m *Comment) Reset() { *m = Comment{} } +func (m *Comment) String() string { return proto.CompactTextString(m) } +func (*Comment) ProtoMessage() {} +func (*Comment) Descriptor() ([]byte, []int) { return fileDescriptorSilence, []int{1} } + +// Silence specifies an object that ignores alerts based +// on a set of matchers during a given time frame. +type Silence struct { + // A globally unique identifier. + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // A set of matchers all of which have to be true for a silence + // to affect a given label set. + Matchers []*Matcher `protobuf:"bytes,2,rep,name=matchers" json:"matchers,omitempty"` + // The time range during which the silence is active. + StartsAt time.Time `protobuf:"bytes,3,opt,name=starts_at,json=startsAt,stdtime" json:"starts_at"` + EndsAt time.Time `protobuf:"bytes,4,opt,name=ends_at,json=endsAt,stdtime" json:"ends_at"` + // The last motification made to the silence. + UpdatedAt time.Time `protobuf:"bytes,5,opt,name=updated_at,json=updatedAt,stdtime" json:"updated_at"` + // DEPRECATED: A set of comments made on the silence. + Comments []*Comment `protobuf:"bytes,7,rep,name=comments" json:"comments,omitempty"` + // Comment for the silence. + CreatedBy string `protobuf:"bytes,8,opt,name=created_by,json=createdBy,proto3" json:"created_by,omitempty"` + Comment string `protobuf:"bytes,9,opt,name=comment,proto3" json:"comment,omitempty"` +} + +func (m *Silence) Reset() { *m = Silence{} } +func (m *Silence) String() string { return proto.CompactTextString(m) } +func (*Silence) ProtoMessage() {} +func (*Silence) Descriptor() ([]byte, []int) { return fileDescriptorSilence, []int{2} } + +// MeshSilence wraps a regular silence with an expiration timestamp +// after which the silence may be garbage collected. +type MeshSilence struct { + Silence *Silence `protobuf:"bytes,1,opt,name=silence" json:"silence,omitempty"` + ExpiresAt time.Time `protobuf:"bytes,2,opt,name=expires_at,json=expiresAt,stdtime" json:"expires_at"` +} + +func (m *MeshSilence) Reset() { *m = MeshSilence{} } +func (m *MeshSilence) String() string { return proto.CompactTextString(m) } +func (*MeshSilence) ProtoMessage() {} +func (*MeshSilence) Descriptor() ([]byte, []int) { return fileDescriptorSilence, []int{3} } + +func init() { + proto.RegisterType((*Matcher)(nil), "silencepb.Matcher") + proto.RegisterType((*Comment)(nil), "silencepb.Comment") + proto.RegisterType((*Silence)(nil), "silencepb.Silence") + proto.RegisterType((*MeshSilence)(nil), "silencepb.MeshSilence") + proto.RegisterEnum("silencepb.Matcher_Type", Matcher_Type_name, Matcher_Type_value) +} +func (m *Matcher) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Matcher) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Type != 0 { + dAtA[i] = 0x8 + i++ + i = encodeVarintSilence(dAtA, i, uint64(m.Type)) + } + if len(m.Name) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintSilence(dAtA, i, uint64(len(m.Name))) + i += copy(dAtA[i:], m.Name) + } + if len(m.Pattern) > 0 { + dAtA[i] = 0x1a + i++ + i = encodeVarintSilence(dAtA, i, uint64(len(m.Pattern))) + i += copy(dAtA[i:], m.Pattern) + } + return i, nil +} + +func (m *Comment) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Comment) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Author) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintSilence(dAtA, i, uint64(len(m.Author))) + i += copy(dAtA[i:], m.Author) + } + if len(m.Comment) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintSilence(dAtA, i, uint64(len(m.Comment))) + i += copy(dAtA[i:], m.Comment) + } + dAtA[i] = 0x1a + i++ + i = encodeVarintSilence(dAtA, i, uint64(types.SizeOfStdTime(m.Timestamp))) + n1, err := types.StdTimeMarshalTo(m.Timestamp, dAtA[i:]) + if err != nil { + return 0, err + } + i += n1 + return i, nil +} + +func (m *Silence) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Silence) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Id) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintSilence(dAtA, i, uint64(len(m.Id))) + i += copy(dAtA[i:], m.Id) + } + if len(m.Matchers) > 0 { + for _, msg := range m.Matchers { + dAtA[i] = 0x12 + i++ + i = encodeVarintSilence(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + dAtA[i] = 0x1a + i++ + i = encodeVarintSilence(dAtA, i, uint64(types.SizeOfStdTime(m.StartsAt))) + n2, err := types.StdTimeMarshalTo(m.StartsAt, dAtA[i:]) + if err != nil { + return 0, err + } + i += n2 + dAtA[i] = 0x22 + i++ + i = encodeVarintSilence(dAtA, i, uint64(types.SizeOfStdTime(m.EndsAt))) + n3, err := types.StdTimeMarshalTo(m.EndsAt, dAtA[i:]) + if err != nil { + return 0, err + } + i += n3 + dAtA[i] = 0x2a + i++ + i = encodeVarintSilence(dAtA, i, uint64(types.SizeOfStdTime(m.UpdatedAt))) + n4, err := types.StdTimeMarshalTo(m.UpdatedAt, dAtA[i:]) + if err != nil { + return 0, err + } + i += n4 + if len(m.Comments) > 0 { + for _, msg := range m.Comments { + dAtA[i] = 0x3a + i++ + i = encodeVarintSilence(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.CreatedBy) > 0 { + dAtA[i] = 0x42 + i++ + i = encodeVarintSilence(dAtA, i, uint64(len(m.CreatedBy))) + i += copy(dAtA[i:], m.CreatedBy) + } + if len(m.Comment) > 0 { + dAtA[i] = 0x4a + i++ + i = encodeVarintSilence(dAtA, i, uint64(len(m.Comment))) + i += copy(dAtA[i:], m.Comment) + } + return i, nil +} + +func (m *MeshSilence) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MeshSilence) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Silence != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintSilence(dAtA, i, uint64(m.Silence.Size())) + n5, err := m.Silence.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n5 + } + dAtA[i] = 0x12 + i++ + i = encodeVarintSilence(dAtA, i, uint64(types.SizeOfStdTime(m.ExpiresAt))) + n6, err := types.StdTimeMarshalTo(m.ExpiresAt, dAtA[i:]) + if err != nil { + return 0, err + } + i += n6 + return i, nil +} + +func encodeVarintSilence(dAtA []byte, offset int, v uint64) int { + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return offset + 1 +} +func (m *Matcher) Size() (n int) { + var l int + _ = l + if m.Type != 0 { + n += 1 + sovSilence(uint64(m.Type)) + } + l = len(m.Name) + if l > 0 { + n += 1 + l + sovSilence(uint64(l)) + } + l = len(m.Pattern) + if l > 0 { + n += 1 + l + sovSilence(uint64(l)) + } + return n +} + +func (m *Comment) Size() (n int) { + var l int + _ = l + l = len(m.Author) + if l > 0 { + n += 1 + l + sovSilence(uint64(l)) + } + l = len(m.Comment) + if l > 0 { + n += 1 + l + sovSilence(uint64(l)) + } + l = types.SizeOfStdTime(m.Timestamp) + n += 1 + l + sovSilence(uint64(l)) + return n +} + +func (m *Silence) Size() (n int) { + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + sovSilence(uint64(l)) + } + if len(m.Matchers) > 0 { + for _, e := range m.Matchers { + l = e.Size() + n += 1 + l + sovSilence(uint64(l)) + } + } + l = types.SizeOfStdTime(m.StartsAt) + n += 1 + l + sovSilence(uint64(l)) + l = types.SizeOfStdTime(m.EndsAt) + n += 1 + l + sovSilence(uint64(l)) + l = types.SizeOfStdTime(m.UpdatedAt) + n += 1 + l + sovSilence(uint64(l)) + if len(m.Comments) > 0 { + for _, e := range m.Comments { + l = e.Size() + n += 1 + l + sovSilence(uint64(l)) + } + } + l = len(m.CreatedBy) + if l > 0 { + n += 1 + l + sovSilence(uint64(l)) + } + l = len(m.Comment) + if l > 0 { + n += 1 + l + sovSilence(uint64(l)) + } + return n +} + +func (m *MeshSilence) Size() (n int) { + var l int + _ = l + if m.Silence != nil { + l = m.Silence.Size() + n += 1 + l + sovSilence(uint64(l)) + } + l = types.SizeOfStdTime(m.ExpiresAt) + n += 1 + l + sovSilence(uint64(l)) + return n +} + +func sovSilence(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozSilence(x uint64) (n int) { + return sovSilence(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Matcher) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSilence + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Matcher: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Matcher: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSilence + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Type |= (Matcher_Type(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSilence + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSilence + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pattern", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSilence + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSilence + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Pattern = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSilence(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthSilence + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Comment) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSilence + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Comment: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Comment: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Author", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSilence + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSilence + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Author = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Comment", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSilence + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSilence + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Comment = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSilence + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSilence + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSilence(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthSilence + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Silence) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSilence + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Silence: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Silence: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSilence + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSilence + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Matchers", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSilence + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSilence + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Matchers = append(m.Matchers, &Matcher{}) + if err := m.Matchers[len(m.Matchers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StartsAt", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSilence + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSilence + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := types.StdTimeUnmarshal(&m.StartsAt, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EndsAt", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSilence + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSilence + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := types.StdTimeUnmarshal(&m.EndsAt, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSilence + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSilence + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := types.StdTimeUnmarshal(&m.UpdatedAt, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Comments", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSilence + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSilence + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Comments = append(m.Comments, &Comment{}) + if err := m.Comments[len(m.Comments)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CreatedBy", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSilence + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSilence + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CreatedBy = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Comment", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSilence + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSilence + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Comment = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSilence(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthSilence + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MeshSilence) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSilence + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MeshSilence: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MeshSilence: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Silence", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSilence + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSilence + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Silence == nil { + m.Silence = &Silence{} + } + if err := m.Silence.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExpiresAt", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSilence + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSilence + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := types.StdTimeUnmarshal(&m.ExpiresAt, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSilence(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthSilence + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipSilence(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSilence + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSilence + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSilence + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthSilence + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSilence + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipSilence(dAtA[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthSilence = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowSilence = fmt.Errorf("proto: integer overflow") +) + +func init() { proto.RegisterFile("silence.proto", fileDescriptorSilence) } + +var fileDescriptorSilence = []byte{ + // 444 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x51, 0x4d, 0x6b, 0xdb, 0x40, + 0x10, 0xf5, 0x2a, 0x8e, 0x65, 0x8d, 0x69, 0x30, 0x43, 0x69, 0x85, 0x21, 0xb6, 0xd1, 0xc9, 0xd0, + 0x22, 0x83, 0x7b, 0xee, 0x41, 0x0e, 0xa6, 0x97, 0x06, 0x5a, 0x35, 0x85, 0xde, 0xca, 0xda, 0x9a, + 0xda, 0x82, 0x48, 0xbb, 0x48, 0x63, 0xa8, 0x4f, 0x2d, 0xf4, 0x0f, 0xf4, 0x67, 0xf9, 0xd8, 0x5f, + 0xd0, 0x0f, 0xff, 0x8b, 0xde, 0x8a, 0x56, 0x2b, 0x37, 0x21, 0x27, 0xdf, 0x66, 0x66, 0xdf, 0x9b, + 0xb7, 0xef, 0x0d, 0x3c, 0x2a, 0xd3, 0x5b, 0xca, 0x57, 0x14, 0xea, 0x42, 0xb1, 0x42, 0xcf, 0xb6, + 0x7a, 0x39, 0x18, 0xad, 0x95, 0x5a, 0xdf, 0xd2, 0xd4, 0x3c, 0x2c, 0xb7, 0x9f, 0xa6, 0x9c, 0x66, + 0x54, 0xb2, 0xcc, 0x74, 0x8d, 0x1d, 0x3c, 0x5e, 0xab, 0xb5, 0x32, 0xe5, 0xb4, 0xaa, 0xea, 0x69, + 0xf0, 0x4d, 0x80, 0x7b, 0x2d, 0x79, 0xb5, 0xa1, 0x02, 0x9f, 0x41, 0x9b, 0x77, 0x9a, 0x7c, 0x31, + 0x16, 0x93, 0x8b, 0xd9, 0xd3, 0xf0, 0xb8, 0x3c, 0xb4, 0x88, 0xf0, 0x66, 0xa7, 0x29, 0x36, 0x20, + 0x44, 0x68, 0xe7, 0x32, 0x23, 0xdf, 0x19, 0x8b, 0x89, 0x17, 0x9b, 0x1a, 0x7d, 0x70, 0xb5, 0x64, + 0xa6, 0x22, 0xf7, 0xcf, 0xcc, 0xb8, 0x69, 0x83, 0x4b, 0x68, 0x57, 0x5c, 0xf4, 0xe0, 0x7c, 0xf1, + 0xf6, 0x7d, 0xf4, 0xba, 0xdf, 0x42, 0x80, 0x4e, 0xbc, 0x78, 0xb5, 0xf8, 0xf0, 0xa6, 0x2f, 0x82, + 0x2f, 0xe0, 0x5e, 0xa9, 0x2c, 0xa3, 0x9c, 0xf1, 0x09, 0x74, 0xe4, 0x96, 0x37, 0xaa, 0x30, 0xdf, + 0xf0, 0x62, 0xdb, 0x55, 0xbb, 0x57, 0x35, 0xc4, 0x4a, 0x36, 0x2d, 0xce, 0xc1, 0x3b, 0x7a, 0x35, + 0xba, 0xbd, 0xd9, 0x20, 0xac, 0xd3, 0x08, 0x9b, 0x34, 0xc2, 0x9b, 0x06, 0x31, 0xef, 0xee, 0x7f, + 0x8e, 0x5a, 0xdf, 0x7f, 0x8d, 0x44, 0xfc, 0x9f, 0x16, 0xfc, 0x75, 0xc0, 0x7d, 0x57, 0xdb, 0xc5, + 0x0b, 0x70, 0xd2, 0xc4, 0xaa, 0x3b, 0x69, 0x82, 0x21, 0x74, 0xb3, 0xda, 0x7f, 0xe9, 0x3b, 0xe3, + 0xb3, 0x49, 0x6f, 0x86, 0x0f, 0xa3, 0x89, 0x8f, 0x18, 0x8c, 0xc0, 0x2b, 0x59, 0x16, 0x5c, 0x7e, + 0x94, 0x7c, 0xd2, 0x7f, 0xba, 0x35, 0x2d, 0x62, 0x7c, 0x09, 0x2e, 0xe5, 0x89, 0x59, 0xd0, 0x3e, + 0x61, 0x41, 0xa7, 0x22, 0x45, 0x8c, 0x57, 0x00, 0x5b, 0x9d, 0x48, 0xa6, 0xa4, 0xda, 0x70, 0x7e, + 0x4a, 0x24, 0x96, 0x17, 0x71, 0x65, 0xdb, 0x26, 0x5c, 0xfa, 0xee, 0x03, 0xdb, 0xf6, 0x5c, 0xf1, + 0x11, 0x83, 0x97, 0x00, 0xab, 0x82, 0x8c, 0xe8, 0x72, 0xe7, 0x77, 0x4d, 0x7c, 0x9e, 0x9d, 0xcc, + 0x77, 0x77, 0xef, 0xe7, 0xdd, 0xbb, 0x5f, 0xf0, 0x55, 0x40, 0xef, 0x9a, 0xca, 0x4d, 0x93, 0xff, + 0x73, 0x70, 0xad, 0x8e, 0x39, 0xc2, 0x7d, 0x5d, 0x0b, 0x8a, 0x1b, 0x48, 0xe5, 0x95, 0x3e, 0xeb, + 0xb4, 0x20, 0x93, 0x96, 0x73, 0x8a, 0x57, 0xcb, 0x8b, 0x78, 0xde, 0xdf, 0xff, 0x19, 0xb6, 0xf6, + 0x87, 0xa1, 0xf8, 0x71, 0x18, 0x8a, 0xdf, 0x87, 0xa1, 0x58, 0x76, 0x0c, 0xf5, 0xc5, 0xbf, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xde, 0x36, 0xea, 0xdd, 0x71, 0x03, 0x00, 0x00, +} diff --git a/src/alertmanager/silence/silencepb/silence.proto b/src/alertmanager/silence/silencepb/silence.proto new file mode 100644 index 0000000..b99343f --- /dev/null +++ b/src/alertmanager/silence/silencepb/silence.proto @@ -0,0 +1,66 @@ +syntax = "proto3"; + +package silencepb; + +import "google/protobuf/timestamp.proto"; +import "gogoproto/gogo.proto"; + +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.goproto_getters_all) = false; + +// Matcher specifies a rule, which can match or set of labels or not. +message Matcher { + // Type specifies how the given name and pattern are matched + // against a label set. + enum Type { + EQUAL = 0; + REGEXP = 1; + }; + Type type = 1; + + // The label name in a label set to against which the matcher + // checks the pattern. + string name = 2; + // The pattern being checked according to the matcher's type. + string pattern = 3; +} + +// DEPRECATED: A comment can be attached to a silence. +message Comment { + string author = 1; + string comment = 2; + google.protobuf.Timestamp timestamp = 3 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; +} + +// Silence specifies an object that ignores alerts based +// on a set of matchers during a given time frame. +message Silence { + // A globally unique identifier. + string id = 1; + + // A set of matchers all of which have to be true for a silence + // to affect a given label set. + repeated Matcher matchers = 2; + + // The time range during which the silence is active. + google.protobuf.Timestamp starts_at = 3 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; + google.protobuf.Timestamp ends_at = 4 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; + + // The last motification made to the silence. + google.protobuf.Timestamp updated_at = 5 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; + + // DEPRECATED: A set of comments made on the silence. + repeated Comment comments = 7; + // Comment for the silence. + string created_by = 8; + string comment = 9; +} + +// MeshSilence wraps a regular silence with an expiration timestamp +// after which the silence may be garbage collected. +message MeshSilence { + Silence silence = 1; + google.protobuf.Timestamp expires_at = 2 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; +} \ No newline at end of file diff --git a/src/alertmanager/template/default.tmpl b/src/alertmanager/template/default.tmpl new file mode 100644 index 0000000..5dd460a --- /dev/null +++ b/src/alertmanager/template/default.tmpl @@ -0,0 +1,218 @@ +{{ define "__alertmanager" }}AlertManager{{ end }} +{{ define "__alertmanagerURL" }}{{ .ExternalURL }}/#/alerts?receiver={{ .Receiver }}{{ end }} + +{{ define "__subject" }}[{{ .Status | toUpper }}{{ if eq .Status "firing" }}:{{ .Alerts.Firing | len }}{{ end }}] {{ .GroupLabels.SortedPairs.Values | join " " }} {{ if gt (len .CommonLabels) (len .GroupLabels) }}({{ with .CommonLabels.Remove .GroupLabels.Names }}{{ .Values | join " " }}{{ end }}){{ end }}{{ end }} +{{ define "__description" }}{{ end }} + +{{ define "__text_alert_list" }}{{ range . }}Labels: +{{ range .Labels.SortedPairs }} - {{ .Name }} = {{ .Value }} +{{ end }}Annotations: +{{ range .Annotations.SortedPairs }} - {{ .Name }} = {{ .Value }} +{{ end }}Source: {{ .GeneratorURL }} +{{ end }}{{ end }} + + +{{ define "slack.default.title" }}{{ template "__subject" . }}{{ end }} +{{ define "slack.default.username" }}{{ template "__alertmanager" . }}{{ end }} +{{ define "slack.default.fallback" }}{{ template "slack.default.title" . }} | {{ template "slack.default.titlelink" . }}{{ end }} +{{ define "slack.default.pretext" }}{{ end }} +{{ define "slack.default.titlelink" }}{{ template "__alertmanagerURL" . }}{{ end }} +{{ define "slack.default.iconemoji" }}{{ end }} +{{ define "slack.default.iconurl" }}{{ end }} +{{ define "slack.default.text" }}{{ end }} +{{ define "slack.default.footer" }}{{ end }} + + +{{ define "hipchat.default.from" }}{{ template "__alertmanager" . }}{{ end }} +{{ define "hipchat.default.message" }}{{ template "__subject" . }}{{ end }} + + +{{ define "pagerduty.default.description" }}{{ template "__subject" . }}{{ end }} +{{ define "pagerduty.default.client" }}{{ template "__alertmanager" . }}{{ end }} +{{ define "pagerduty.default.clientURL" }}{{ template "__alertmanagerURL" . }}{{ end }} +{{ define "pagerduty.default.instances" }}{{ template "__text_alert_list" . }}{{ end }} + + +{{ define "opsgenie.default.message" }}{{ template "__subject" . }}{{ end }} +{{ define "opsgenie.default.description" }}{{ .CommonAnnotations.SortedPairs.Values | join " " }} +{{ if gt (len .Alerts.Firing) 0 -}} +Alerts Firing: +{{ template "__text_alert_list" .Alerts.Firing }} +{{- end }} +{{ if gt (len .Alerts.Resolved) 0 -}} +Alerts Resolved: +{{ template "__text_alert_list" .Alerts.Resolved }} +{{- end }} +{{- end }} +{{ define "opsgenie.default.source" }}{{ template "__alertmanagerURL" . }}{{ end }} + + +{{ define "wechat.default.message" }}{{ template "__subject" . }} +{{ .CommonAnnotations.SortedPairs.Values | join " " }} +{{ if gt (len .Alerts.Firing) 0 -}} +Alerts Firing: +{{ template "__text_alert_list" .Alerts.Firing }} +{{- end }} +{{ if gt (len .Alerts.Resolved) 0 -}} +Alerts Resolved: +{{ template "__text_alert_list" .Alerts.Resolved }} +{{- end }} +AlertmanagerUrl: +{{ template "__alertmanagerURL" . }} +{{- end }} + + + +{{ define "victorops.default.state_message" }}{{ .CommonAnnotations.SortedPairs.Values | join " " }} +{{ if gt (len .Alerts.Firing) 0 -}} +Alerts Firing: +{{ template "__text_alert_list" .Alerts.Firing }} +{{- end }} +{{ if gt (len .Alerts.Resolved) 0 -}} +Alerts Resolved: +{{ template "__text_alert_list" .Alerts.Resolved }} +{{- end }} +{{- end }} +{{ define "victorops.default.entity_display_name" }}{{ template "__subject" . }}{{ end }} +{{ define "victorops.default.monitoring_tool" }}{{ template "__alertmanager" . }}{{ end }} + +{{ define "email.default.subject" }}{{ template "__subject" . }}{{ end }} +{{ define "email.default.html" }} + + + + + + +{{ template "__subject" . }} + + + + + + + + + + + +
+
+ + + + + + + +
+ {{ .Alerts | len }} alert{{ if gt (len .Alerts) 1 }}s{{ end }} for {{ range .GroupLabels.SortedPairs }} + {{ .Name }}={{ .Value }} + {{ end }} +
+ + + + + {{ if gt (len .Alerts.Firing) 0 }} + + + + {{ end }} + {{ range .Alerts.Firing }} + + + + {{ end }} + + {{ if gt (len .Alerts.Resolved) 0 }} + {{ if gt (len .Alerts.Firing) 0 }} + + + + {{ end }} + + + + {{ end }} + {{ range .Alerts.Resolved }} + + + + {{ end }} +
+ View in {{ template "__alertmanager" . }} +
+ [{{ .Alerts.Firing | len }}] Firing +
+ Labels
+ {{ range .Labels.SortedPairs }}{{ .Name }} = {{ .Value }}
{{ end }} + {{ if gt (len .Annotations) 0 }}Annotations
{{ end }} + {{ range .Annotations.SortedPairs }}{{ .Name }} = {{ .Value }}
{{ end }} + Source
+
+
+
+
+
+ [{{ .Alerts.Resolved | len }}] Resolved +
+ Labels
+ {{ range .Labels.SortedPairs }}{{ .Name }} = {{ .Value }}
{{ end }} + {{ if gt (len .Annotations) 0 }}Annotations
{{ end }} + {{ range .Annotations.SortedPairs }}{{ .Name }} = {{ .Value }}
{{ end }} + Source
+
+
+ +
+
+ + + + +{{ end }} + +{{ define "pushover.default.title" }}{{ template "__subject" . }}{{ end }} +{{ define "pushover.default.message" }}{{ .CommonAnnotations.SortedPairs.Values | join " " }} +{{ if gt (len .Alerts.Firing) 0 }} +Alerts Firing: +{{ template "__text_alert_list" .Alerts.Firing }} +{{ end }} +{{ if gt (len .Alerts.Resolved) 0 }} +Alerts Resolved: +{{ template "__text_alert_list" .Alerts.Resolved }} +{{ end }} +{{ end }} +{{ define "pushover.default.url" }}{{ template "__alertmanagerURL" . }}{{ end }} diff --git a/src/alertmanager/template/email.html b/src/alertmanager/template/email.html new file mode 100644 index 0000000..01ac523 --- /dev/null +++ b/src/alertmanager/template/email.html @@ -0,0 +1,404 @@ + + + + + + +{{ template "__subject" . }} + + + + + + + + + + + +
+
+ + + + + + + +
+ {{ .Alerts | len }} alert{{ if gt (len .Alerts) 1 }}s{{ end }} for {{ range .GroupLabels.SortedPairs }} + {{ .Name }}={{ .Value }} + {{ end }} +
+ + + + + {{ if gt (len .Alerts.Firing) 0 }} + + + + {{ end }} + {{ range .Alerts.Firing }} + + + + {{ end }} + + {{ if gt (len .Alerts.Resolved) 0 }} + {{ if gt (len .Alerts.Firing) 0 }} + + + + {{ end }} + + + + {{ end }} + {{ range .Alerts.Resolved }} + + + + {{ end }} +
+ View in {{ template "__alertmanager" . }} +
+ [{{ .Alerts.Firing | len }}] Firing +
+ Labels
+ {{ range .Labels.SortedPairs }}{{ .Name }} = {{ .Value }}
{{ end }} + {{ if gt (len .Annotations) 0 }}Annotations
{{ end }} + {{ range .Annotations.SortedPairs }}{{ .Name }} = {{ .Value }}
{{ end }} + Source
+
+
+
+
+
+ [{{ .Alerts.Resolved | len }}] Resolved +
+ Labels
+ {{ range .Labels.SortedPairs }}{{ .Name }} = {{ .Value }}
{{ end }} + {{ if gt (len .Annotations) 0 }}Annotations
{{ end }} + {{ range .Annotations.SortedPairs }}{{ .Name }} = {{ .Value }}
{{ end }} + Source
+
+
+ +
+ + + + +
Sent by {{ template "__alertmanager" . }}
+
+
+ + + diff --git a/src/alertmanager/template/internal/deftmpl/bindata.go b/src/alertmanager/template/internal/deftmpl/bindata.go new file mode 100644 index 0000000..24f440f --- /dev/null +++ b/src/alertmanager/template/internal/deftmpl/bindata.go @@ -0,0 +1,237 @@ +// Code generated by go-bindata. +// sources: +// template/default.tmpl +// DO NOT EDIT! + +package deftmpl + +import ( + "bytes" + "compress/gzip" + "fmt" + "io" + "io/ioutil" + "os" + "path/filepath" + "strings" + "time" +) + +func bindataRead(data []byte, name string) ([]byte, error) { + gz, err := gzip.NewReader(bytes.NewBuffer(data)) + if err != nil { + return nil, fmt.Errorf("Read %q: %v", name, err) + } + + var buf bytes.Buffer + _, err = io.Copy(&buf, gz) + clErr := gz.Close() + + if err != nil { + return nil, fmt.Errorf("Read %q: %v", name, err) + } + if clErr != nil { + return nil, err + } + + return buf.Bytes(), nil +} + +type asset struct { + bytes []byte + info os.FileInfo +} + +type bindataFileInfo struct { + name string + size int64 + mode os.FileMode + modTime time.Time +} + +func (fi bindataFileInfo) Name() string { + return fi.name +} +func (fi bindataFileInfo) Size() int64 { + return fi.size +} +func (fi bindataFileInfo) Mode() os.FileMode { + return fi.mode +} +func (fi bindataFileInfo) ModTime() time.Time { + return fi.modTime +} +func (fi bindataFileInfo) IsDir() bool { + return false +} +func (fi bindataFileInfo) Sys() interface{} { + return nil +} + +var _templateDefaultTmpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x1b\xff\x4f\xdb\xb8\xfe\xf7\xfc\x15\x9f\xcb\xe9\xe9\x86\xd4\x36\x85\xdd\x4d\x47\x69\x79\xea\x4a\x18\xd1\x2b\x29\x4a\xc3\x76\xd3\xe9\x84\xdc\xc4\x6d\xbd\x25\x76\xce\x76\x28\x3d\xd6\xff\xfd\xc9\x4e\xfa\x25\x34\x85\x82\x76\xd0\xf7\x0e\xd0\x46\xe2\xf8\xf3\xfd\xab\x63\xe7\xf6\x16\x42\x3c\x24\x14\x83\x79\x75\x85\x22\xcc\x65\x8c\x28\x1a\x61\x6e\xc2\x6c\xd6\x56\xf7\xe7\xd9\xfd\xed\x2d\x60\x1a\xc2\x6c\x66\x6c\x04\xb9\xf4\xba\x0a\xea\xf6\x16\x6a\xf6\x8d\xc4\x9c\xa2\xe8\xd2\xeb\xc2\x6c\x66\xfd\x68\xe9\x79\xe2\xdf\x1c\x07\x98\x5c\x63\xde\x52\x93\xbc\xfc\x26\x83\xc9\xb1\x17\xd1\x8b\x74\xf0\x05\x07\x52\xa1\xfd\x5d\x81\xf4\x25\x92\xa9\x80\x6f\x20\xd9\x65\x92\xcc\x41\xc9\x10\xf0\x9f\x8b\x87\xe6\x90\x70\x42\x47\x0a\xa6\xa1\x60\xb4\x14\xa2\x76\xaa\x47\xe1\x1b\x44\x98\xae\x52\xfc\x03\xd4\xa4\x0f\x9c\xa5\x49\x17\x0d\x70\x24\x6a\x7d\xc6\x25\x0e\x2f\x10\xe1\xa2\xf6\x11\x45\x29\x56\x04\xbf\x30\x42\xc1\x04\x85\x15\x32\x92\x23\x09\x6f\x14\xae\x5a\x87\xc5\x31\xa3\x19\xf0\x5e\x3e\xb6\x82\x6f\x0f\x66\xb3\x37\xb7\xb7\x30\x21\x72\x5c\x9c\x5c\xf3\x70\xcc\xae\x71\x91\xba\x8b\x62\x2c\x72\x35\x96\x51\x5f\x30\xbe\xb7\xb8\xda\x60\x9b\x10\x8b\x80\x93\x44\x12\x46\xcd\x7b\x74\x2c\xf1\x8d\xcc\xec\x78\x15\x11\x21\xf3\xa9\x1c\xd1\x11\x86\x1a\xcc\x66\x19\x5f\x0d\x63\x39\xb8\xae\x27\xa5\x95\xaa\x56\xa4\x62\x5f\xdd\xb5\x60\x21\x40\xce\x58\x46\xbc\x4d\x29\x93\x48\xf1\x54\x40\xb9\x32\xfc\x34\xbc\x7d\x96\xf2\x00\x37\x32\x63\x62\x8a\x39\x92\x8c\x67\xee\x67\x94\x28\xaa\xa0\x03\x11\xa1\xe0\x6b\x2d\xc4\x43\x94\x46\xb2\x26\x89\x8c\x70\xae\x05\x89\xe3\x24\x42\xb2\xe8\x8b\xb5\x4d\x2a\x2f\xe2\x49\x85\x0a\x81\xb8\x0c\x55\x31\xd0\xb6\xc4\x37\x44\x51\x34\x40\xc1\xd7\x35\x7c\xa5\xec\x2b\xa4\xf0\x0d\x1e\x9a\x18\x11\xfa\x75\x6b\x0e\x12\x8e\x95\xb3\x98\xdb\xcd\x5e\xc1\x7f\xaf\x02\x74\xda\xd8\x92\x03\x12\x30\x8a\x63\xf6\x85\x6c\xc9\x83\x9a\x9f\xf2\x68\x5b\x8e\xb7\x17\x6e\xc8\x98\xcc\x92\xe4\x06\x9f\x1a\x93\x24\x18\x23\xb9\x04\xe0\x2c\x7e\xba\x27\xdc\xc5\x16\x63\x21\xd0\xe8\x11\x5e\x5a\xe0\x2d\x51\xd4\xc2\x54\x4e\x17\xf8\xd6\x53\xc5\xe3\x3c\x7f\x1d\x63\x10\x11\x4c\xe5\xd3\x25\xde\x84\x71\x59\x64\x9e\xe6\x4f\xeb\x78\x09\x15\x12\xd1\x00\x8b\x12\xbc\x6b\xb9\xf1\x1e\xad\xb2\x44\x8c\x30\x25\xf8\xe9\x46\xba\x0f\xd9\xba\x85\xf2\x52\xb2\x21\x73\x96\xd6\x0e\xe3\x4e\xe5\x2a\x94\xc6\x3d\xa8\x43\x75\x36\x33\xb2\x41\xc8\x06\x75\x8e\xbe\x5f\x23\xc5\xfa\xaa\x89\x54\x57\x24\x2a\xa1\xe7\x61\xc1\xa2\x6b\x1c\xde\xa1\x38\x1f\xde\x9e\xe6\x1c\x62\x8d\x6a\x75\x1b\x95\x0a\x5d\x32\x1e\xef\x4d\x05\xab\x4f\xf0\x53\x02\xd3\x78\xb5\xdf\x3d\xf6\x6b\xaf\xea\x9f\x47\x6b\xf8\x4a\xed\xb3\x8a\xa0\x68\xa2\x6b\x12\x48\xc6\x59\x22\x96\x96\x97\x48\xe2\xab\xa2\xad\x5e\xcd\xf1\xb8\x70\x5a\xd7\x2a\xa6\x92\xc8\xe9\x55\x48\x44\x12\xa1\xe9\xd5\x86\xde\xe7\xe1\xdc\xb7\x8e\x39\x66\x94\x48\xa6\x14\x72\x25\x19\x8b\x1e\x59\x55\x56\x71\xe3\x18\x91\x68\xe9\x07\xcb\xe5\xc5\xa3\xb9\x2c\x62\x1a\xcb\x58\xb3\x65\x34\x7f\x38\xe9\x75\xfc\xcf\x17\x36\xa8\x21\xb8\xb8\x7c\xdf\x75\x3a\x60\x56\x2d\xeb\xd3\xdb\x8e\x65\x9d\xf8\x27\xf0\xdb\x99\x7f\xde\x85\xfd\x5a\x1d\x7c\x8e\xa8\x20\xca\xd9\x50\x64\x59\xb6\x6b\x82\x39\x96\x32\x69\x58\xd6\x64\x32\xa9\x4d\xde\xd6\x18\x1f\x59\xbe\x67\xdd\x28\x5c\xfb\x0a\x38\xbf\xac\xca\x15\xc8\x5a\x28\x43\xf3\xd8\x68\xfe\x50\xad\x1a\x7d\x39\x8d\x30\x20\x1a\x82\x26\x12\x62\x4e\x94\x41\x55\xf7\x01\x0a\xb5\x68\x58\xd6\x88\xc8\x71\x3a\xa8\x05\x2c\xb6\x94\x0c\xa3\x94\x5a\x1a\x1d\x0a\x32\x7c\x55\x2d\x5a\x75\xae\x0e\x61\x18\x86\x3f\xc6\x70\xee\xf8\xd0\x25\x01\xa6\x02\xc3\x9b\x73\xc7\xdf\x33\x8c\x0e\x4b\xa6\x9c\x8c\xc6\x12\xde\x04\x7b\x70\x50\xdf\xff\x19\xce\x33\x8c\x86\x71\x81\x79\x4c\x84\x20\x8c\x02\x11\x30\xc6\x1c\x0f\xa6\x30\xe2\x88\x4a\x1c\x56\x60\xc8\x31\x06\x36\x84\x60\x8c\xf8\x08\x57\x40\x32\x40\x74\x0a\x09\xe6\x82\x51\x60\x03\x89\x08\x55\xfe\x8f\x20\x60\xc9\xd4\x60\x43\x90\x63\x22\x40\xb0\xa1\x9c\x20\x9e\x49\x88\x84\x60\x01\x41\x12\x87\x10\xb2\x20\x8d\x31\xcd\x02\x17\x86\x24\xc2\x02\xde\xc8\x31\x06\xb3\x9f\x43\x98\x7b\x9a\x48\x88\x51\x64\x10\x0a\xea\xd9\xfc\x91\x5e\x99\xb1\x54\x02\xc7\x42\x72\xa2\xb5\x50\x01\x42\x83\x28\x0d\x15\x0f\xf3\xc7\x11\x89\x49\x4e\x41\x81\x6b\xc1\x85\x21\x19\xa4\x02\x57\x34\x9f\x15\x88\x59\x48\x86\xea\x2f\xd6\x62\x25\xe9\x20\x22\x62\x5c\x81\x90\x28\xd4\x83\x54\xe2\x0a\x08\x35\xa8\xf5\x58\x51\x72\x58\x8c\x83\xc0\x51\x64\x04\x2c\x21\x58\x80\x96\x75\xc9\x9d\x9e\xa3\x58\x4f\x94\x42\x65\xae\x22\xa1\x46\x26\x63\x16\x17\x25\x21\xc2\x18\xa6\x9c\x12\x31\xc6\x1a\x26\x64\x20\x98\xa6\xa8\xbc\x59\x8d\xa8\xe9\x43\x16\x45\x6c\xa2\x44\x0b\x18\x0d\x49\xbe\x18\xd3\x46\x46\x03\xb5\x20\x0d\x16\x76\xa5\x4c\x92\x20\x53\xb7\x36\x40\xb2\xb4\x6a\xfe\x48\x8c\x51\x14\xc1\x00\xe7\x0a\xc3\x21\x10\x0a\x68\x45\x1c\xae\xc8\xab\x16\x4b\x12\x14\x41\xc2\xb8\xa6\x77\x57\xcc\x9a\x61\xf8\x67\x36\xf4\x7b\xa7\xfe\xa7\xb6\x67\x83\xd3\x87\x0b\xaf\xf7\xd1\x39\xb1\x4f\xc0\x6c\xf7\xc1\xe9\x9b\x15\xf8\xe4\xf8\x67\xbd\x4b\x1f\x3e\xb5\x3d\xaf\xed\xfa\x9f\xa1\x77\x0a\x6d\xf7\x33\xfc\xc7\x71\x4f\x2a\x60\xff\x76\xe1\xd9\xfd\x3e\xf4\x3c\xc3\x39\xbf\xe8\x3a\xf6\x49\x05\x1c\xb7\xd3\xbd\x3c\x71\xdc\x0f\xf0\xfe\xd2\x07\xb7\xe7\x43\xd7\x39\x77\x7c\xfb\x04\xfc\x1e\x28\x82\x39\x2a\xc7\xee\x2b\x64\xe7\xb6\xd7\x39\x6b\xbb\x7e\xfb\xbd\xd3\x75\xfc\xcf\x15\xe3\xd4\xf1\x5d\x85\xf3\xb4\xe7\x41\x1b\x2e\xda\x9e\xef\x74\x2e\xbb\x6d\x0f\x2e\x2e\xbd\x8b\x5e\xdf\x86\xb6\x7b\x02\x6e\xcf\x75\xdc\x53\xcf\x71\x3f\xd8\xe7\xb6\xeb\xd7\xc0\x71\xc1\xed\x81\xfd\xd1\x76\x7d\xe8\x9f\xb5\xbb\x5d\x45\xca\x68\x5f\xfa\x67\x3d\x4f\xf1\x07\x9d\xde\xc5\x67\xcf\xf9\x70\xe6\xc3\x59\xaf\x7b\x62\x7b\x7d\x78\x6f\x43\xd7\x69\xbf\xef\xda\x19\x29\xf7\x33\x74\xba\x6d\xe7\xbc\x02\x27\xed\xf3\xf6\x07\x5b\x43\xf5\xfc\x33\xdb\x33\xd4\xb4\x8c\x3b\xf8\x74\x66\xab\x21\x45\xaf\xed\x42\xbb\xe3\x3b\x3d\x57\x89\xd1\xe9\xb9\xbe\xd7\xee\xf8\x15\xf0\x7b\x9e\xbf\x00\xfd\xe4\xf4\xed\x0a\xb4\x3d\xa7\xaf\x14\x72\xea\xf5\xce\x2b\x86\x52\x67\xef\x54\x4d\x71\x5c\x05\xe7\xda\x19\x16\xa5\x6a\x28\x58\xa4\xe7\xe9\xfb\xcb\xbe\xbd\x40\x08\x27\x76\xbb\xeb\xb8\x1f\xfa\x0a\x58\x89\x38\x9f\x5c\x33\xaa\xd5\x63\xa3\xa9\x53\xe0\x4d\x1c\x51\xd1\x2a\x49\x6c\xfb\x87\x87\x87\x59\x3e\x33\xb7\x9b\x24\x54\x72\x6b\x99\x43\x46\x65\x75\x88\x62\x12\x4d\x1b\xf0\xd3\x19\x8e\xae\xb1\x24\x01\x02\x17\xa7\xf8\xa7\x0a\x2c\x06\x2a\xd0\xe6\x04\x45\x15\x10\x88\x8a\xaa\xc0\x9c\x0c\x8f\x60\xc0\x6e\xaa\x82\xfc\xa5\x6a\x31\x0c\x18\x0f\x31\xaf\x0e\xd8\xcd\x11\x68\xa4\x82\xfc\x85\x1b\xb0\xff\x73\x72\x73\x04\x31\xe2\x23\x42\x1b\x50\x3f\x52\xb9\x75\x8c\x51\xf8\x92\xf4\x63\x2c\x11\xa8\x8a\xda\x32\xaf\x09\x9e\xa8\x28\x32\x55\xf4\x4a\x4c\x65\xcb\x9c\x90\x50\x8e\x5b\x21\xbe\x26\x01\xae\xea\x9b\x97\x53\x16\x58\x73\x76\x95\x31\xab\xf8\xcf\x94\x5c\xb7\xcc\x4e\xc6\x6a\xd5\x9f\x26\x78\x85\x71\xd5\x8a\x58\xca\xb8\x47\xba\x12\x08\x2c\x5b\x97\xfe\x69\xf5\xd7\x17\x66\x5f\xbf\xba\x78\x39\x73\xdf\xd7\x8b\x34\x2d\xcd\xdc\xb1\x61\x34\x2d\xe5\x94\xea\x62\xc0\xc2\x29\x10\x89\x63\x11\xb0\x04\xb7\x4c\x53\xdf\xc8\xa9\xba\xce\x23\x4a\x04\x63\x1c\x23\x1d\x51\xb6\xaa\xee\xe7\xf3\xde\xf7\x59\x85\xac\x4e\xf0\xe0\x2b\x91\xd5\xec\x41\xcc\x98\x1c\x6b\xa0\xac\x36\x10\x24\x70\xb8\x9c\xa4\x7c\x43\x43\x57\x51\xf8\x25\x15\xb2\x01\x94\x51\x7c\x04\x63\xac\x2a\x53\x03\xf6\xeb\xf5\x7f\x1d\x41\x44\x28\xae\x2e\x86\x6a\xef\x70\x7c\x04\x3a\x02\xb2\x09\xf0\x03\x89\x55\xb0\x20\x2a\x8f\x60\x80\x82\xaf\x23\xce\x52\x1a\x56\x03\x16\x31\xde\x80\x1f\x87\xef\xd4\xef\xaa\xfa\x21\x41\x61\xa8\xb9\x52\xde\x30\x18\xe9\x99\x2d\x33\x9f\x69\x2a\x7d\x4b\x34\x78\x6e\xf7\x58\x11\x69\x4b\x39\x4a\x79\x07\x68\x4a\xfe\x82\x79\x0c\x40\x71\xf0\xcc\x99\xf4\x1a\x73\x85\x24\xaa\xa2\x88\x8c\x68\x03\x24\x4b\x8a\x8a\xba\xd6\x0f\x5a\xa6\x64\x89\x79\xdc\xb4\x64\xb8\x64\x34\xcb\xac\xe6\xbb\x7a\xfd\x99\x43\xa5\x94\xe9\x7c\x69\xd5\x80\x41\xc4\x82\xaf\x05\xdf\x8e\xd1\x4d\x35\x77\x92\x77\xf5\x7a\x72\x53\x78\x18\x44\x18\x71\x45\x50\x8e\x0b\xe3\x9b\x02\x65\xa1\x1c\x40\xa9\x64\x77\x42\xa2\xa0\x2d\xad\x28\x80\x66\x48\xae\x9f\xdb\xad\x8a\xf2\xde\x55\xce\xfd\x42\xcc\xf9\x56\x46\xd6\xc1\x9c\xdb\x59\x69\xc2\x84\x00\x47\x51\x3e\xbb\x65\xd6\xb3\x7b\x91\xa0\x60\x7e\xff\xac\x82\xe6\x0f\x39\x0a\x49\x2a\x1a\xf0\x56\x8f\x95\x24\x80\xe1\xb0\x90\xc5\x32\xb0\x06\xec\x27\x37\x20\x58\x44\x42\xf8\x11\x1f\xaa\xdf\x62\x62\x18\x0e\x57\x74\xb1\x0b\xd9\x61\xc9\xc9\xf3\x65\x89\x77\x1b\x03\xae\xa0\x5d\x0d\x32\xc9\x4b\xcd\x2f\xf5\xfa\x11\xe8\x12\x95\xcf\x0f\x30\x95\x98\x97\xd9\x4b\xff\xab\x6b\xa3\xac\xdb\xcd\x7e\xf7\xcb\xc1\x41\xa7\xbc\x00\x1d\x28\xbf\x36\x21\x8f\xb7\x8c\xc0\xaa\xf5\x32\xd8\xf2\x88\x9c\xff\x2c\x77\x40\x17\x5b\x9f\xa0\x5f\x96\x94\xbe\x4b\xda\x83\x7d\x98\xcd\xc4\xe2\x85\x07\x0c\x19\x87\xe5\x2e\xdd\x86\x5d\x52\x98\xcd\xee\x50\x85\xd5\x3d\xbb\x56\x61\xc7\x6e\x6d\x5a\xfe\x6a\xa5\x60\xfc\x45\x0e\x5e\xdc\xf3\x57\x37\xdd\xa6\x98\x2d\x9d\x67\x3f\x73\x9e\xfb\x7c\x63\xe7\x73\xdf\x46\xb5\xef\x96\x13\xec\xba\x2b\xd4\xa1\x3e\xcf\x25\xf7\xb9\x43\x2e\x06\x82\x31\xc7\xc3\x96\xb9\xcd\x4b\xf7\x67\xf6\x87\x79\xd2\x3c\x3d\x3d\xcd\x93\x6f\x88\x03\xc6\xf5\x3b\xb9\xf9\xf2\xa0\xb0\x20\x38\x50\xcb\x81\x42\xde\x1e\xb0\x28\x2c\x4f\xdc\x41\xca\x85\xc2\x9e\x30\x92\x0d\x2c\x1a\x0a\x42\x35\xd2\xbc\xaf\xb8\x93\xe0\x7f\x51\x8c\x69\x7c\xfa\x25\xea\x90\xf1\xb8\x01\x01\x4a\x88\x44\x11\xf9\x0b\x97\x26\xfd\xb7\x3f\xff\x8a\x43\x54\x52\xaf\xd7\x66\xe4\xc3\x5a\xcb\x8d\xac\x90\x2f\x06\x17\xdd\x5b\x72\x93\x9b\xf7\xf8\x23\xc1\x13\x20\x14\x1e\x7c\x3b\xde\xb4\x50\xa9\x0f\xdf\x49\xbc\xe5\xe9\x37\xfb\x79\x68\xf3\xa3\xa4\x28\xbc\x86\xec\xdf\x13\xb2\x42\x72\x46\x47\x2f\xa7\xda\xdf\x37\x9f\xb3\xfa\x23\xdf\xf9\x6a\x5a\x19\x93\xdf\xc1\xeb\x4a\x1a\x86\xfc\xc9\xfc\x30\xd1\xdd\x2d\xb4\x57\x3f\xfc\x67\xf8\x61\xd6\x9a\x2e\x5c\xad\x39\x78\x39\x33\x83\x55\xae\xa3\x07\x4e\xd1\x6d\x3e\xea\xf6\xc2\xc2\x6c\x8e\x3b\x28\xa9\x05\xcb\x4d\xf4\xac\x12\xbc\xb8\x67\xac\x70\xb4\x2b\xee\xf1\xa0\x46\x1f\x3c\x1a\xf9\x3f\xea\x2c\xab\x1d\xe6\xdd\xb3\x9a\x2f\xd4\x50\xce\xdb\xad\xb5\x9e\x32\xa5\x21\xe6\xaa\xfb\x2b\xba\x53\x76\xda\x54\x35\x51\xbb\x97\x63\x9e\x56\x4d\xb7\x6c\xef\x56\xcf\x9a\x94\x9a\xf7\xb5\x2b\xdc\x99\x6a\xbc\x73\x9e\x09\xd0\x1c\xef\x20\x4f\x3b\xa7\xa7\xc7\x44\xf0\x7d\x1d\xf1\x6b\x60\xfd\x7f\xb6\xb9\xab\xcb\xad\xc5\x99\xbd\xe5\x82\x6b\x3e\xf4\x02\x4b\xae\xd5\x13\x84\xaf\xde\xf8\xcf\xf0\xc6\xd7\x45\xd7\xeb\xa2\xeb\x75\xd1\xb5\xeb\xce\xf2\xba\xe8\xda\x99\x96\x6d\x93\xa1\x9a\x96\xde\x8f\x3b\x7e\xc4\x56\xe8\x02\x64\x39\xf2\xec\x27\x31\x0a\x47\x93\x56\x4e\x9a\x2c\x0d\x7d\x78\x78\x78\xdf\x06\x77\x71\x67\x77\x7d\x4b\x72\x37\x9a\x86\x5d\x6a\x5f\x9e\xb3\x75\x39\xd8\xd8\xba\x94\x6e\xa2\x3d\x64\xf2\x95\xde\xe6\xce\xb9\x86\xe2\x29\xac\xd5\x74\x55\xfc\x9a\xfc\xf9\x1c\xe2\x60\x35\x5b\x69\x89\xb6\x4e\x55\x98\x4a\x18\x4c\xb7\xdb\x87\x5b\xcf\x1d\x6b\xe7\x1d\xee\x66\x86\xa6\x15\x92\xeb\xe3\xec\x7f\xa3\x98\x26\x76\xad\xad\xdd\x70\xbc\x2e\x13\x71\x99\xbf\x9a\xd6\x80\x85\x53\x35\x32\x96\x71\x74\x6c\x18\xe5\xdf\xef\x24\xa9\x18\xb3\x6b\xcc\xbf\xc3\xd7\xda\x6b\xa8\xfe\xfe\xef\xc1\xbe\xcf\xe7\x60\xdb\x7f\x0d\xf6\xfd\x3e\x06\x5b\xa1\xb9\x85\x26\x97\x9f\x5c\x3f\xe2\xb3\xca\xff\x06\x00\x00\xff\xff\x96\x70\x0b\x9a\x8b\x42\x00\x00") + +func templateDefaultTmplBytes() ([]byte, error) { + return bindataRead( + _templateDefaultTmpl, + "template/default.tmpl", + ) +} + +func templateDefaultTmpl() (*asset, error) { + bytes, err := templateDefaultTmplBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "template/default.tmpl", size: 17035, mode: os.FileMode(420), modTime: time.Unix(1, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +// Asset loads and returns the asset for the given name. +// It returns an error if the asset could not be found or +// could not be loaded. +func Asset(name string) ([]byte, error) { + cannonicalName := strings.Replace(name, "\\", "/", -1) + if f, ok := _bindata[cannonicalName]; ok { + a, err := f() + if err != nil { + return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err) + } + return a.bytes, nil + } + return nil, fmt.Errorf("Asset %s not found", name) +} + +// MustAsset is like Asset but panics when Asset would return an error. +// It simplifies safe initialization of global variables. +func MustAsset(name string) []byte { + a, err := Asset(name) + if err != nil { + panic("asset: Asset(" + name + "): " + err.Error()) + } + + return a +} + +// AssetInfo loads and returns the asset info for the given name. +// It returns an error if the asset could not be found or +// could not be loaded. +func AssetInfo(name string) (os.FileInfo, error) { + cannonicalName := strings.Replace(name, "\\", "/", -1) + if f, ok := _bindata[cannonicalName]; ok { + a, err := f() + if err != nil { + return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err) + } + return a.info, nil + } + return nil, fmt.Errorf("AssetInfo %s not found", name) +} + +// AssetNames returns the names of the assets. +func AssetNames() []string { + names := make([]string, 0, len(_bindata)) + for name := range _bindata { + names = append(names, name) + } + return names +} + +// _bindata is a table, holding each asset generator, mapped to its name. +var _bindata = map[string]func() (*asset, error){ + "template/default.tmpl": templateDefaultTmpl, +} + +// AssetDir returns the file names below a certain +// directory embedded in the file by go-bindata. +// For example if you run go-bindata on data/... and data contains the +// following hierarchy: +// data/ +// foo.txt +// img/ +// a.png +// b.png +// then AssetDir("data") would return []string{"foo.txt", "img"} +// AssetDir("data/img") would return []string{"a.png", "b.png"} +// AssetDir("foo.txt") and AssetDir("notexist") would return an error +// AssetDir("") will return []string{"data"}. +func AssetDir(name string) ([]string, error) { + node := _bintree + if len(name) != 0 { + cannonicalName := strings.Replace(name, "\\", "/", -1) + pathList := strings.Split(cannonicalName, "/") + for _, p := range pathList { + node = node.Children[p] + if node == nil { + return nil, fmt.Errorf("Asset %s not found", name) + } + } + } + if node.Func != nil { + return nil, fmt.Errorf("Asset %s not found", name) + } + rv := make([]string, 0, len(node.Children)) + for childName := range node.Children { + rv = append(rv, childName) + } + return rv, nil +} + +type bintree struct { + Func func() (*asset, error) + Children map[string]*bintree +} + +var _bintree = &bintree{nil, map[string]*bintree{ + "template": &bintree{nil, map[string]*bintree{ + "default.tmpl": &bintree{templateDefaultTmpl, map[string]*bintree{}}, + }}, +}} + +// RestoreAsset restores an asset under the given directory +func RestoreAsset(dir, name string) error { + data, err := Asset(name) + if err != nil { + return err + } + info, err := AssetInfo(name) + if err != nil { + return err + } + err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755)) + if err != nil { + return err + } + err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode()) + if err != nil { + return err + } + err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime()) + if err != nil { + return err + } + return nil +} + +// RestoreAssets restores an asset under the given directory recursively +func RestoreAssets(dir, name string) error { + children, err := AssetDir(name) + // File + if err != nil { + return RestoreAsset(dir, name) + } + // Dir + for _, child := range children { + err = RestoreAssets(dir, filepath.Join(name, child)) + if err != nil { + return err + } + } + return nil +} + +func _filePath(dir, name string) string { + cannonicalName := strings.Replace(name, "\\", "/", -1) + return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...) +} diff --git a/src/alertmanager/template/template.go b/src/alertmanager/template/template.go new file mode 100644 index 0000000..cb54b8c --- /dev/null +++ b/src/alertmanager/template/template.go @@ -0,0 +1,331 @@ +// Copyright 2015 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package template + +import ( + "bytes" + "net/url" + "path/filepath" + "regexp" + "sort" + "strings" + "time" + + tmplhtml "html/template" + tmpltext "text/template" + + "github.com/prometheus/common/model" + + "github.com/prometheus/alertmanager/template/internal/deftmpl" + "github.com/prometheus/alertmanager/types" +) + +// Template bundles a text and a html template instance. +type Template struct { + text *tmpltext.Template + html *tmplhtml.Template + + ExternalURL *url.URL +} + +// FromGlobs calls ParseGlob on all path globs provided and returns the +// resulting Template. +func FromGlobs(paths ...string) (*Template, error) { + t := &Template{ + text: tmpltext.New("").Option("missingkey=zero"), + html: tmplhtml.New("").Option("missingkey=zero"), + } + var err error + + t.text = t.text.Funcs(tmpltext.FuncMap(DefaultFuncs)) + t.html = t.html.Funcs(tmplhtml.FuncMap(DefaultFuncs)) + + b, err := deftmpl.Asset("template/default.tmpl") + if err != nil { + return nil, err + } + if t.text, err = t.text.Parse(string(b)); err != nil { + return nil, err + } + if t.html, err = t.html.Parse(string(b)); err != nil { + return nil, err + } + + for _, tp := range paths { + // ParseGlob in the template packages errors if not at least one file is + // matched. We want to allow empty matches that may be populated later on. + p, err := filepath.Glob(tp) + if err != nil { + return nil, err + } + if len(p) > 0 { + if t.text, err = t.text.ParseGlob(tp); err != nil { + return nil, err + } + if t.html, err = t.html.ParseGlob(tp); err != nil { + return nil, err + } + } + } + return t, nil +} + +// ExecuteTextString needs a meaningful doc comment (TODO(fabxc)). +func (t *Template) ExecuteTextString(text string, data interface{}) (string, error) { + if text == "" { + return "", nil + } + tmpl, err := t.text.Clone() + if err != nil { + return "", err + } + tmpl, err = tmpl.New("").Option("missingkey=zero").Parse(text) + if err != nil { + return "", err + } + var buf bytes.Buffer + err = tmpl.Execute(&buf, data) + return buf.String(), err +} + +// ExecuteHTMLString needs a meaningful doc comment (TODO(fabxc)). +func (t *Template) ExecuteHTMLString(html string, data interface{}) (string, error) { + if html == "" { + return "", nil + } + tmpl, err := t.html.Clone() + if err != nil { + return "", err + } + tmpl, err = tmpl.New("").Option("missingkey=zero").Parse(html) + if err != nil { + return "", err + } + var buf bytes.Buffer + err = tmpl.Execute(&buf, data) + return buf.String(), err +} + +type FuncMap map[string]interface{} + +var DefaultFuncs = FuncMap{ + "toUpper": strings.ToUpper, + "toLower": strings.ToLower, + "title": strings.Title, + // join is equal to strings.Join but inverts the argument order + // for easier pipelining in templates. + "join": func(sep string, s []string) string { + return strings.Join(s, sep) + }, + "safeHtml": func(text string) tmplhtml.HTML { + return tmplhtml.HTML(text) + }, + "reReplaceAll": func(pattern, repl, text string) string { + re := regexp.MustCompile(pattern) + return re.ReplaceAllString(text, repl) + }, +} + +// Pair is a key/value string pair. +type Pair struct { + Name, Value string +} + +// Pairs is a list of key/value string pairs. +type Pairs []Pair + +// Names returns a list of names of the pairs. +func (ps Pairs) Names() []string { + ns := make([]string, 0, len(ps)) + for _, p := range ps { + ns = append(ns, p.Name) + } + return ns +} + +// Values returns a list of values of the pairs. +func (ps Pairs) Values() []string { + vs := make([]string, 0, len(ps)) + for _, p := range ps { + vs = append(vs, p.Value) + } + return vs +} + +// KV is a set of key/value string pairs. +type KV map[string]string + +// SortedPairs returns a sorted list of key/value pairs. +func (kv KV) SortedPairs() Pairs { + var ( + pairs = make([]Pair, 0, len(kv)) + keys = make([]string, 0, len(kv)) + sortStart = 0 + ) + for k := range kv { + if k == string(model.AlertNameLabel) { + keys = append([]string{k}, keys...) + sortStart = 1 + } else { + keys = append(keys, k) + } + } + sort.Strings(keys[sortStart:]) + + for _, k := range keys { + pairs = append(pairs, Pair{k, kv[k]}) + } + return pairs +} + +// Remove returns a copy of the key/value set without the given keys. +func (kv KV) Remove(keys []string) KV { + keySet := make(map[string]struct{}, len(keys)) + for _, k := range keys { + keySet[k] = struct{}{} + } + + res := KV{} + for k, v := range kv { + if _, ok := keySet[k]; !ok { + res[k] = v + } + } + return res +} + +// Names returns the names of the label names in the LabelSet. +func (kv KV) Names() []string { + return kv.SortedPairs().Names() +} + +// Values returns a list of the values in the LabelSet. +func (kv KV) Values() []string { + return kv.SortedPairs().Values() +} + +// Data is the data passed to notification templates and webhook pushes. +// +// End-users should not be exposed to Go's type system, as this will confuse them and prevent +// simple things like simple equality checks to fail. Map everything to float64/string. +type Data struct { + Receiver string `json:"receiver"` + Status string `json:"status"` + Alerts Alerts `json:"alerts"` + + GroupLabels KV `json:"groupLabels"` + CommonLabels KV `json:"commonLabels"` + CommonAnnotations KV `json:"commonAnnotations"` + + ExternalURL string `json:"externalURL"` +} + +// Alert holds one alert for notification templates. +type Alert struct { + Status string `json:"status"` + Labels KV `json:"labels"` + Annotations KV `json:"annotations"` + StartsAt time.Time `json:"startsAt"` + EndsAt time.Time `json:"endsAt"` + GeneratorURL string `json:"generatorURL"` +} + +// Alerts is a list of Alert objects. +type Alerts []Alert + +// Firing returns the subset of alerts that are firing. +func (as Alerts) Firing() []Alert { + res := []Alert{} + for _, a := range as { + if a.Status == string(model.AlertFiring) { + res = append(res, a) + } + } + return res +} + +// Resolved returns the subset of alerts that are resolved. +func (as Alerts) Resolved() []Alert { + res := []Alert{} + for _, a := range as { + if a.Status == string(model.AlertResolved) { + res = append(res, a) + } + } + return res +} + +// Data assembles data for template expansion. +func (t *Template) Data(recv string, groupLabels model.LabelSet, alerts ...*types.Alert) *Data { + data := &Data{ + Receiver: regexp.QuoteMeta(strings.SplitN(recv, "/", 2)[0]), + Status: string(types.Alerts(alerts...).Status()), + Alerts: make(Alerts, 0, len(alerts)), + GroupLabels: KV{}, + CommonLabels: KV{}, + CommonAnnotations: KV{}, + ExternalURL: t.ExternalURL.String(), + } + + // The call to types.Alert is necessary to correctly resolve the internal + // representation to the user representation. + for _, a := range types.Alerts(alerts...) { + alert := Alert{ + Status: string(a.Status()), + Labels: make(KV, len(a.Labels)), + Annotations: make(KV, len(a.Annotations)), + StartsAt: a.StartsAt, + EndsAt: a.EndsAt, + GeneratorURL: a.GeneratorURL, + } + for k, v := range a.Labels { + alert.Labels[string(k)] = string(v) + } + for k, v := range a.Annotations { + alert.Annotations[string(k)] = string(v) + } + data.Alerts = append(data.Alerts, alert) + } + + for k, v := range groupLabels { + data.GroupLabels[string(k)] = string(v) + } + + if len(alerts) >= 1 { + var ( + commonLabels = alerts[0].Labels.Clone() + commonAnnotations = alerts[0].Annotations.Clone() + ) + for _, a := range alerts[1:] { + for ln, lv := range commonLabels { + if a.Labels[ln] != lv { + delete(commonLabels, ln) + } + } + for an, av := range commonAnnotations { + if a.Annotations[an] != av { + delete(commonAnnotations, an) + } + } + } + for k, v := range commonLabels { + data.CommonLabels[string(k)] = string(v) + } + for k, v := range commonAnnotations { + data.CommonAnnotations[string(k)] = string(v) + } + } + + return data +} diff --git a/src/alertmanager/template/template_test.go b/src/alertmanager/template/template_test.go new file mode 100644 index 0000000..152e1bf --- /dev/null +++ b/src/alertmanager/template/template_test.go @@ -0,0 +1,120 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package template + +import ( + "testing" + + "github.com/prometheus/common/model" + "github.com/stretchr/testify/require" +) + +func TestPairNames(t *testing.T) { + pairs := Pairs{ + {"name1", "value1"}, + {"name2", "value2"}, + {"name3", "value3"}, + } + + expected := []string{"name1", "name2", "name3"} + require.EqualValues(t, expected, pairs.Names()) +} + +func TestPairValues(t *testing.T) { + pairs := Pairs{ + {"name1", "value1"}, + {"name2", "value2"}, + {"name3", "value3"}, + } + + expected := []string{"value1", "value2", "value3"} + require.EqualValues(t, expected, pairs.Values()) +} + +func TestKVSortedPairs(t *testing.T) { + kv := KV{"d": "dVal", "b": "bVal", "c": "cVal"} + + expectedPairs := Pairs{ + {"b", "bVal"}, + {"c", "cVal"}, + {"d", "dVal"}, + } + + for i, p := range kv.SortedPairs() { + require.EqualValues(t, p.Name, expectedPairs[i].Name) + require.EqualValues(t, p.Value, expectedPairs[i].Value) + } + + // validates alertname always comes first + kv = KV{"d": "dVal", "b": "bVal", "c": "cVal", "alertname": "alert", "a": "aVal"} + + expectedPairs = Pairs{ + {"alertname", "alert"}, + {"a", "aVal"}, + {"b", "bVal"}, + {"c", "cVal"}, + {"d", "dVal"}, + } + + for i, p := range kv.SortedPairs() { + require.EqualValues(t, p.Name, expectedPairs[i].Name) + require.EqualValues(t, p.Value, expectedPairs[i].Value) + } +} + +func TestKVRemove(t *testing.T) { + kv := KV{ + "key1": "val1", + "key2": "val2", + "key3": "val3", + "key4": "val4", + } + + kv = kv.Remove([]string{"key2", "key4"}) + + expected := []string{"key1", "key3"} + require.EqualValues(t, expected, kv.Names()) +} + +func TestAlertsFiring(t *testing.T) { + alerts := Alerts{ + {Status: string(model.AlertFiring)}, + {Status: string(model.AlertResolved)}, + {Status: string(model.AlertFiring)}, + {Status: string(model.AlertResolved)}, + {Status: string(model.AlertResolved)}, + } + + for _, alert := range alerts.Firing() { + if alert.Status != string(model.AlertFiring) { + t.Errorf("unexpected status %q", alert.Status) + } + } +} + +func TestAlertsResolved(t *testing.T) { + alerts := Alerts{ + {Status: string(model.AlertFiring)}, + {Status: string(model.AlertResolved)}, + {Status: string(model.AlertFiring)}, + {Status: string(model.AlertResolved)}, + {Status: string(model.AlertResolved)}, + } + + for _, alert := range alerts.Resolved() { + if alert.Status != string(model.AlertResolved) { + t.Errorf("unexpected status %q", alert.Status) + } + } +} diff --git a/src/alertmanager/test/acceptance.go b/src/alertmanager/test/acceptance.go new file mode 100644 index 0000000..a0c0ecd --- /dev/null +++ b/src/alertmanager/test/acceptance.go @@ -0,0 +1,410 @@ +// Copyright 2015 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "io/ioutil" + "net" + "net/http" + "os" + "os/exec" + "path/filepath" + "sync" + "syscall" + "testing" + "time" + + "github.com/prometheus/client_golang/api" + "github.com/prometheus/common/model" + "golang.org/x/net/context" + + "github.com/prometheus/alertmanager/client" +) + +// AcceptanceTest provides declarative definition of given inputs and expected +// output of an Alertmanager setup. +type AcceptanceTest struct { + *testing.T + + opts *AcceptanceOpts + + ams []*Alertmanager + collectors []*Collector + + actions map[float64][]func() +} + +// AcceptanceOpts defines configuration paramters for an acceptance test. +type AcceptanceOpts struct { + Tolerance time.Duration + baseTime time.Time +} + +func (opts *AcceptanceOpts) alertString(a *model.Alert) string { + if a.EndsAt.IsZero() { + return fmt.Sprintf("%s[%v:]", a, opts.relativeTime(a.StartsAt)) + } + return fmt.Sprintf("%s[%v:%v]", a, opts.relativeTime(a.StartsAt), opts.relativeTime(a.EndsAt)) +} + +// expandTime returns the absolute time for the relative time +// calculated from the test's base time. +func (opts *AcceptanceOpts) expandTime(rel float64) time.Time { + return opts.baseTime.Add(time.Duration(rel * float64(time.Second))) +} + +// expandTime returns the relative time for the given time +// calculated from the test's base time. +func (opts *AcceptanceOpts) relativeTime(act time.Time) float64 { + return float64(act.Sub(opts.baseTime)) / float64(time.Second) +} + +// NewAcceptanceTest returns a new acceptance test with the base time +// set to the current time. +func NewAcceptanceTest(t *testing.T, opts *AcceptanceOpts) *AcceptanceTest { + test := &AcceptanceTest{ + T: t, + opts: opts, + actions: map[float64][]func(){}, + } + opts.baseTime = time.Now() + + return test +} + +// freeAddress returns a new listen address not currently in use. +func freeAddress() string { + // Let the OS allocate a free address, close it and hope + // it is still free when starting Alertmanager. + l, err := net.Listen("tcp4", "localhost:0") + if err != nil { + panic(err) + } + defer l.Close() + + return l.Addr().String() +} + +// Do sets the given function to be executed at the given time. +func (t *AcceptanceTest) Do(at float64, f func()) { + t.actions[at] = append(t.actions[at], f) +} + +// Alertmanager returns a new structure that allows starting an instance +// of Alertmanager on a random port. +func (t *AcceptanceTest) Alertmanager(conf string) *Alertmanager { + am := &Alertmanager{ + t: t, + opts: t.opts, + } + + dir, err := ioutil.TempDir("", "am_test") + if err != nil { + t.Fatal(err) + } + am.dir = dir + + cf, err := os.Create(filepath.Join(dir, "config.yml")) + if err != nil { + t.Fatal(err) + } + am.confFile = cf + am.UpdateConfig(conf) + + am.apiAddr = freeAddress() + am.clusterAddr = freeAddress() + + t.Logf("AM on %s", am.apiAddr) + + c, err := api.NewClient(api.Config{ + Address: fmt.Sprintf("http://%s", am.apiAddr), + }) + if err != nil { + t.Fatal(err) + } + am.client = c + + t.ams = append(t.ams, am) + + return am +} + +// Collector returns a new collector bound to the test instance. +func (t *AcceptanceTest) Collector(name string) *Collector { + co := &Collector{ + t: t.T, + name: name, + opts: t.opts, + collected: map[float64][]model.Alerts{}, + expected: map[Interval][]model.Alerts{}, + } + t.collectors = append(t.collectors, co) + + return co +} + +// Run starts all Alertmanagers and runs queries against them. It then checks +// whether all expected notifications have arrived at the expected receiver. +func (t *AcceptanceTest) Run() { + errc := make(chan error) + + for _, am := range t.ams { + am.errc = errc + + am.Start() + defer func(am *Alertmanager) { + am.Terminate() + am.cleanup() + t.Logf("stdout:\n%v", am.cmd.Stdout) + t.Logf("stderr:\n%v", am.cmd.Stderr) + }(am) + } + + go t.runActions() + + var latest float64 + for _, coll := range t.collectors { + if l := coll.latest(); l > latest { + latest = l + } + } + + deadline := t.opts.expandTime(latest) + + select { + case <-time.After(deadline.Sub(time.Now())): + // continue + case err := <-errc: + t.Error(err) + } + + for _, coll := range t.collectors { + report := coll.check() + t.Log(report) + } +} + +// runActions performs the stored actions at the defined times. +func (t *AcceptanceTest) runActions() { + var wg sync.WaitGroup + + for at, fs := range t.actions { + ts := t.opts.expandTime(at) + wg.Add(len(fs)) + + for _, f := range fs { + go func(f func()) { + time.Sleep(ts.Sub(time.Now())) + f() + wg.Done() + }(f) + } + } + + wg.Wait() +} + +type buffer struct { + b bytes.Buffer + mtx sync.Mutex +} + +func (b *buffer) Write(p []byte) (int, error) { + b.mtx.Lock() + defer b.mtx.Unlock() + return b.b.Write(p) +} + +func (b *buffer) String() string { + b.mtx.Lock() + defer b.mtx.Unlock() + return b.b.String() +} + +// Alertmanager encapsulates an Alertmanager process and allows +// declaring alerts being pushed to it at fixed points in time. +type Alertmanager struct { + t *AcceptanceTest + opts *AcceptanceOpts + + apiAddr string + clusterAddr string + client api.Client + cmd *exec.Cmd + confFile *os.File + dir string + + errc chan<- error +} + +// Start the alertmanager and wait until it is ready to receive. +func (am *Alertmanager) Start() { + cmd := exec.Command("../../alertmanager", + "--config.file", am.confFile.Name(), + "--log.level", "debug", + "--web.listen-address", am.apiAddr, + "--storage.path", am.dir, + "--cluster.listen-address", am.clusterAddr, + "--cluster.settle-timeout", "0s", + ) + + if am.cmd == nil { + var outb, errb buffer + cmd.Stdout = &outb + cmd.Stderr = &errb + } else { + cmd.Stdout = am.cmd.Stdout + cmd.Stderr = am.cmd.Stderr + } + am.cmd = cmd + + if err := am.cmd.Start(); err != nil { + am.t.Fatalf("Starting alertmanager failed: %s", err) + } + + go func() { + if err := am.cmd.Wait(); err != nil { + am.errc <- err + } + }() + + time.Sleep(50 * time.Millisecond) + for i := 0; i < 10; i++ { + resp, err := http.Get(fmt.Sprintf("http://%s/status", am.apiAddr)) + if err == nil { + _, err := ioutil.ReadAll(resp.Body) + if err != nil { + am.t.Fatalf("Starting alertmanager failed: %s", err) + } + resp.Body.Close() + return + } + time.Sleep(500 * time.Millisecond) + } + am.t.Fatalf("Starting alertmanager failed: timeout") +} + +// Terminate kills the underlying Alertmanager process and remove intermediate +// data. +func (am *Alertmanager) Terminate() { + syscall.Kill(am.cmd.Process.Pid, syscall.SIGTERM) +} + +// Reload sends the reloading signal to the Alertmanager process. +func (am *Alertmanager) Reload() { + syscall.Kill(am.cmd.Process.Pid, syscall.SIGHUP) +} + +func (am *Alertmanager) cleanup() { + os.RemoveAll(am.confFile.Name()) +} + +// Push declares alerts that are to be pushed to the Alertmanager +// server at a relative point in time. +func (am *Alertmanager) Push(at float64, alerts ...*TestAlert) { + var cas []client.Alert + for i := range alerts { + a := alerts[i].nativeAlert(am.opts) + al := client.Alert{ + Labels: client.LabelSet{}, + Annotations: client.LabelSet{}, + StartsAt: a.StartsAt, + EndsAt: a.EndsAt, + GeneratorURL: a.GeneratorURL, + } + for n, v := range a.Labels { + al.Labels[client.LabelName(n)] = client.LabelValue(v) + } + for n, v := range a.Annotations { + al.Annotations[client.LabelName(n)] = client.LabelValue(v) + } + cas = append(cas, al) + } + + alertAPI := client.NewAlertAPI(am.client) + + am.t.Do(at, func() { + if err := alertAPI.Push(context.Background(), cas...); err != nil { + am.t.Errorf("Error pushing %v: %s", cas, err) + } + }) +} + +// SetSilence updates or creates the given Silence. +func (am *Alertmanager) SetSilence(at float64, sil *TestSilence) { + am.t.Do(at, func() { + var buf bytes.Buffer + if err := json.NewEncoder(&buf).Encode(sil.nativeSilence(am.opts)); err != nil { + am.t.Errorf("Error setting silence %v: %s", sil, err) + return + } + + resp, err := http.Post(fmt.Sprintf("http://%s/api/v1/silences", am.apiAddr), "application/json", &buf) + if err != nil { + am.t.Errorf("Error setting silence %v: %s", sil, err) + return + } + defer resp.Body.Close() + + b, err := ioutil.ReadAll(resp.Body) + if err != nil { + panic(err) + } + + var v struct { + Status string `json:"status"` + Data struct { + SilenceID string `json:"silenceId"` + } `json:"data"` + } + if err := json.Unmarshal(b, &v); err != nil || resp.StatusCode/100 != 2 { + am.t.Errorf("error setting silence %v: %s", sil, err) + return + } + sil.SetID(v.Data.SilenceID) + }) +} + +// DelSilence deletes the silence with the sid at the given time. +func (am *Alertmanager) DelSilence(at float64, sil *TestSilence) { + am.t.Do(at, func() { + req, err := http.NewRequest("DELETE", fmt.Sprintf("http://%s/api/v1/silence/%s", am.apiAddr, sil.ID()), nil) + if err != nil { + am.t.Errorf("Error deleting silence %v: %s", sil, err) + return + } + + resp, err := http.DefaultClient.Do(req) + if err != nil || resp.StatusCode/100 != 2 { + am.t.Errorf("Error deleting silence %v: %s", sil, err) + return + } + }) +} + +// UpdateConfig rewrites the configuration file for the Alertmanager. It does not +// initiate config reloading. +func (am *Alertmanager) UpdateConfig(conf string) { + if _, err := am.confFile.WriteString(conf); err != nil { + am.t.Fatal(err) + return + } + if err := am.confFile.Sync(); err != nil { + am.t.Fatal(err) + return + } +} diff --git a/src/alertmanager/test/acceptance/inhibit_test.go b/src/alertmanager/test/acceptance/inhibit_test.go new file mode 100644 index 0000000..43d317c --- /dev/null +++ b/src/alertmanager/test/acceptance/inhibit_test.go @@ -0,0 +1,152 @@ +// Copyright 2015 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package test + +import ( + "fmt" + "testing" + "time" + + . "github.com/prometheus/alertmanager/test" +) + +func TestInhibiting(t *testing.T) { + t.Parallel() + + // This integration test checks that alerts can be inhibited and that an + // inhibited alert will be notified again as soon as the inhibiting alert + // gets resolved. + + conf := ` +route: + receiver: "default" + group_by: [] + group_wait: 1s + group_interval: 1s + repeat_interval: 1s + +receivers: +- name: "default" + webhook_configs: + - url: 'http://%s' + +inhibit_rules: +- source_match: + alertname: JobDown + target_match: + alertname: InstanceDown + equal: + - job + - zone +` + + at := NewAcceptanceTest(t, &AcceptanceOpts{ + Tolerance: 150 * time.Millisecond, + }) + + co := at.Collector("webhook") + wh := NewWebhook(co) + + am := at.Alertmanager(fmt.Sprintf(conf, wh.Address())) + + am.Push(At(1), Alert("alertname", "test1", "job", "testjob", "zone", "aa")) + am.Push(At(1), Alert("alertname", "InstanceDown", "job", "testjob", "zone", "aa")) + am.Push(At(1), Alert("alertname", "InstanceDown", "job", "testjob", "zone", "ab")) + + // This JobDown in zone aa should inhibit InstanceDown in zone aa in the + // second batch of notifications. + am.Push(At(2.2), Alert("alertname", "JobDown", "job", "testjob", "zone", "aa")) + + // InstanceDown in zone aa should fire again in the third batch of + // notifications once JobDown in zone aa gets resolved. + am.Push(At(3.6), Alert("alertname", "JobDown", "job", "testjob", "zone", "aa").Active(2.2, 3.6)) + + co.Want(Between(2, 2.5), + Alert("alertname", "test1", "job", "testjob", "zone", "aa").Active(1), + Alert("alertname", "InstanceDown", "job", "testjob", "zone", "aa").Active(1), + Alert("alertname", "InstanceDown", "job", "testjob", "zone", "ab").Active(1), + ) + + co.Want(Between(3, 3.5), + Alert("alertname", "test1", "job", "testjob", "zone", "aa").Active(1), + Alert("alertname", "InstanceDown", "job", "testjob", "zone", "ab").Active(1), + Alert("alertname", "JobDown", "job", "testjob", "zone", "aa").Active(2.2), + ) + + co.Want(Between(4, 4.5), + Alert("alertname", "test1", "job", "testjob", "zone", "aa").Active(1), + Alert("alertname", "InstanceDown", "job", "testjob", "zone", "aa").Active(1), + Alert("alertname", "InstanceDown", "job", "testjob", "zone", "ab").Active(1), + Alert("alertname", "JobDown", "job", "testjob", "zone", "aa").Active(2.2, 3.6), + ) + + at.Run() +} + +func TestAlwaysInhibiting(t *testing.T) { + t.Parallel() + + // This integration test checks that when inhibited and inhibiting alerts + // gets resolved at the same time, the final notification contains both + // alerts. + + conf := ` +route: + receiver: "default" + group_by: [] + group_wait: 1s + group_interval: 1s + repeat_interval: 1s + +receivers: +- name: "default" + webhook_configs: + - url: 'http://%s' + +inhibit_rules: +- source_match: + alertname: JobDown + target_match: + alertname: InstanceDown + equal: + - job + - zone +` + + at := NewAcceptanceTest(t, &AcceptanceOpts{ + Tolerance: 150 * time.Millisecond, + }) + + co := at.Collector("webhook") + wh := NewWebhook(co) + + am := at.Alertmanager(fmt.Sprintf(conf, wh.Address())) + + am.Push(At(1), Alert("alertname", "InstanceDown", "job", "testjob", "zone", "aa")) + am.Push(At(1), Alert("alertname", "JobDown", "job", "testjob", "zone", "aa")) + + am.Push(At(2.6), Alert("alertname", "JobDown", "job", "testjob", "zone", "aa").Active(1, 2.6)) + am.Push(At(2.6), Alert("alertname", "InstanceDown", "job", "testjob", "zone", "aa").Active(1, 2.6)) + + co.Want(Between(2, 2.5), + Alert("alertname", "JobDown", "job", "testjob", "zone", "aa").Active(1), + ) + + co.Want(Between(3, 3.5), + Alert("alertname", "InstanceDown", "job", "testjob", "zone", "aa").Active(1, 2.6), + Alert("alertname", "JobDown", "job", "testjob", "zone", "aa").Active(1, 2.6), + ) + + at.Run() +} diff --git a/src/alertmanager/test/acceptance/send_test.go b/src/alertmanager/test/acceptance/send_test.go new file mode 100644 index 0000000..03d5919 --- /dev/null +++ b/src/alertmanager/test/acceptance/send_test.go @@ -0,0 +1,452 @@ +// Copyright 2015 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package test + +import ( + "fmt" + "sync" + "testing" + "time" + + . "github.com/prometheus/alertmanager/test" +) + +// This file contains acceptance tests around the basic sending logic +// for notifications, which includes batching and ensuring that each +// notification is eventually sent at least once and ideally exactly +// once. + +func TestMergeAlerts(t *testing.T) { + t.Parallel() + + conf := ` +route: + receiver: "default" + group_by: [alertname] + group_wait: 1s + group_interval: 1s + repeat_interval: 1ms + +receivers: +- name: "default" + webhook_configs: + - url: 'http://%s' + send_resolved: true +` + + at := NewAcceptanceTest(t, &AcceptanceOpts{ + Tolerance: 150 * time.Millisecond, + }) + + co := at.Collector("webhook") + wh := NewWebhook(co) + + am := at.Alertmanager(fmt.Sprintf(conf, wh.Address())) + + // Refresh an alert several times. The starting time must remain at the earliest + // point in time. + am.Push(At(1), Alert("alertname", "test").Active(1.1)) + // Another Prometheus server might be sending later but with an earlier start time. + am.Push(At(1.2), Alert("alertname", "test").Active(1)) + + co.Want(Between(2, 2.5), Alert("alertname", "test").Active(1)) + + am.Push(At(2.1), Alert("alertname", "test").Annotate("ann", "v1").Active(2)) + + co.Want(Between(3, 3.5), Alert("alertname", "test").Annotate("ann", "v1").Active(1)) + + // Annotations are always overwritten by the alert that arrived most recently. + am.Push(At(3.6), Alert("alertname", "test").Annotate("ann", "v2").Active(1.5)) + + co.Want(Between(4, 4.5), Alert("alertname", "test").Annotate("ann", "v2").Active(1)) + + // If an alert is marked resolved twice, the latest point in time must be + // set as the eventual resolve time. + am.Push(At(4.6), Alert("alertname", "test").Annotate("ann", "v2").Active(3, 4.5)) + am.Push(At(4.8), Alert("alertname", "test").Annotate("ann", "v3").Active(2.9, 4.8)) + am.Push(At(4.8), Alert("alertname", "test").Annotate("ann", "v3").Active(2.9, 4.1)) + + co.Want(Between(5, 5.5), Alert("alertname", "test").Annotate("ann", "v3").Active(1, 4.8)) + + // Reactivate an alert after a previous occurrence has been resolved. + // No overlap, no merge must occur. + am.Push(At(5.3), Alert("alertname", "test")) + + co.Want(Between(6, 6.5), Alert("alertname", "test").Active(5.3)) + + // Test against a bug which ocurrec after a restart. The previous occurrence of + // the alert was sent rather than the most recent one. + // + // XXX(fabxc) disabled as notification info won't be persisted. Thus, with a mesh + // notifier we lose the state in this single-node setup. + //at.Do(At(6.7), func() { + // am.Terminate() + // am.Start() + //}) + + // On restart the alert is flushed right away as the group_wait has already passed. + // However, it must be caught in the deduplication stage. + // The next attempt will be 1s later and won't be filtered in deduping. + //co.Want(Between(7.7, 8), Alert("alertname", "test").Active(5.3)) + + at.Run() +} + +func TestRepeat(t *testing.T) { + t.Parallel() + + conf := ` +route: + receiver: "default" + group_by: [alertname] + group_wait: 1s + group_interval: 1s + repeat_interval: 1ms + +receivers: +- name: "default" + webhook_configs: + - url: 'http://%s' +` + + // Create a new acceptance test that instantiates new Alertmanagers + // with the given configuration and verifies times with the given + // tollerance. + at := NewAcceptanceTest(t, &AcceptanceOpts{ + Tolerance: 150 * time.Millisecond, + }) + + // Create a collector to which alerts can be written and verified + // against a set of expected alert notifications. + co := at.Collector("webhook") + // Run something that satisfies the webhook interface to which the + // Alertmanager pushes as defined by its configuration. + wh := NewWebhook(co) + + // Create a new Alertmanager process listening to a random port + am := at.Alertmanager(fmt.Sprintf(conf, wh.Address())) + + // Declare pushes to be made to the Alertmanager at the given time. + // Times are provided in fractions of seconds. + am.Push(At(1), Alert("alertname", "test").Active(1)) + + // XXX(fabxc): disabled as long as alerts are not persisted. + // at.Do(At(1.2), func() { + // am.Terminate() + // am.Start() + // }) + am.Push(At(3.5), Alert("alertname", "test").Active(1, 3)) + + // Declare which alerts are expected to arrive at the collector within + // the defined time intervals. + co.Want(Between(2, 2.5), Alert("alertname", "test").Active(1)) + co.Want(Between(3, 3.5), Alert("alertname", "test").Active(1)) + co.Want(Between(4, 4.5), Alert("alertname", "test").Active(1, 3)) + + // Start the flow as defined above and run the checks afterwards. + at.Run() +} + +func TestRetry(t *testing.T) { + t.Parallel() + + // We create a notification config that fans out into two different + // webhooks. + // The succeeding one must still only receive the first successful + // notifications. Sending to the succeeding one must eventually succeed. + conf := ` +route: + receiver: "default" + group_by: [alertname] + group_wait: 1s + group_interval: 1s + repeat_interval: 3s + +receivers: +- name: "default" + webhook_configs: + - url: 'http://%s' + - url: 'http://%s' +` + + at := NewAcceptanceTest(t, &AcceptanceOpts{ + Tolerance: 150 * time.Millisecond, + }) + + co1 := at.Collector("webhook") + wh1 := NewWebhook(co1) + + co2 := at.Collector("webhook_failing") + wh2 := NewWebhook(co2) + + wh2.Func = func(ts float64) bool { + // Fail the first two interval periods but eventually + // succeed in the third interval after a few failed attempts. + return ts < 4.5 + } + + am := at.Alertmanager(fmt.Sprintf(conf, wh1.Address(), wh2.Address())) + + am.Push(At(1), Alert("alertname", "test1")) + + co1.Want(Between(2, 2.5), Alert("alertname", "test1").Active(1)) + co1.Want(Between(5, 5.5), Alert("alertname", "test1").Active(1)) + + co2.Want(Between(4.5, 5), Alert("alertname", "test1").Active(1)) +} + +func TestBatching(t *testing.T) { + t.Parallel() + + conf := ` +route: + receiver: "default" + group_by: [] + group_wait: 1s + group_interval: 1s + # use a value slightly below the 5s interval to avoid timing issues + repeat_interval: 4900ms + +receivers: +- name: "default" + webhook_configs: + - url: 'http://%s' +` + + at := NewAcceptanceTest(t, &AcceptanceOpts{ + Tolerance: 150 * time.Millisecond, + }) + + co := at.Collector("webhook") + wh := NewWebhook(co) + + am := at.Alertmanager(fmt.Sprintf(conf, wh.Address())) + + am.Push(At(1.1), Alert("alertname", "test1").Active(1)) + am.Push(At(1.7), Alert("alertname", "test5").Active(1)) + + co.Want(Between(2.0, 2.5), + Alert("alertname", "test1").Active(1), + Alert("alertname", "test5").Active(1), + ) + + am.Push(At(3.3), + Alert("alertname", "test2").Active(1.5), + Alert("alertname", "test3").Active(1.5), + Alert("alertname", "test4").Active(1.6), + ) + + co.Want(Between(4.1, 4.5), + Alert("alertname", "test1").Active(1), + Alert("alertname", "test5").Active(1), + Alert("alertname", "test2").Active(1.5), + Alert("alertname", "test3").Active(1.5), + Alert("alertname", "test4").Active(1.6), + ) + + // While no changes happen expect no additional notifications + // until the 5s repeat interval has ended. + + co.Want(Between(9.1, 9.5), + Alert("alertname", "test1").Active(1), + Alert("alertname", "test5").Active(1), + Alert("alertname", "test2").Active(1.5), + Alert("alertname", "test3").Active(1.5), + Alert("alertname", "test4").Active(1.6), + ) + + at.Run() +} + +func TestResolved(t *testing.T) { + t.Parallel() + + var wg sync.WaitGroup + wg.Add(10) + + for i := 0; i < 10; i++ { + go func() { + conf := ` +global: + resolve_timeout: 10s + +route: + receiver: "default" + group_by: [alertname] + group_wait: 1s + group_interval: 5s + +receivers: +- name: "default" + webhook_configs: + - url: 'http://%s' +` + + at := NewAcceptanceTest(t, &AcceptanceOpts{ + Tolerance: 150 * time.Millisecond, + }) + + co := at.Collector("webhook") + wh := NewWebhook(co) + + am := at.Alertmanager(fmt.Sprintf(conf, wh.Address())) + + am.Push(At(1), + Alert("alertname", "test", "lbl", "v1"), + Alert("alertname", "test", "lbl", "v2"), + Alert("alertname", "test", "lbl", "v3"), + ) + + co.Want(Between(2, 2.5), + Alert("alertname", "test", "lbl", "v1").Active(1), + Alert("alertname", "test", "lbl", "v2").Active(1), + Alert("alertname", "test", "lbl", "v3").Active(1), + ) + co.Want(Between(12, 13), + Alert("alertname", "test", "lbl", "v1").Active(1, 11), + Alert("alertname", "test", "lbl", "v2").Active(1, 11), + Alert("alertname", "test", "lbl", "v3").Active(1, 11), + ) + + at.Run() + wg.Done() + }() + } + + wg.Wait() +} + +func TestResolvedFilter(t *testing.T) { + t.Parallel() + + // This integration test ensures that even though resolved alerts may not be + // notified about, they must be set as notified. Resolved alerts, even when + // filtered, have to end up in the SetNotifiesStage, otherwise when an alert + // fires again it is ambiguous whether it was resolved in between or not. + + conf := ` +global: + resolve_timeout: 10s + +route: + receiver: "default" + group_by: [alertname] + group_wait: 1s + group_interval: 5s + +receivers: +- name: "default" + webhook_configs: + - url: 'http://%s' + send_resolved: true + - url: 'http://%s' + send_resolved: false +` + + at := NewAcceptanceTest(t, &AcceptanceOpts{ + Tolerance: 150 * time.Millisecond, + }) + + co1 := at.Collector("webhook1") + wh1 := NewWebhook(co1) + + co2 := at.Collector("webhook2") + wh2 := NewWebhook(co2) + + am := at.Alertmanager(fmt.Sprintf(conf, wh1.Address(), wh2.Address())) + + am.Push(At(1), + Alert("alertname", "test", "lbl", "v1"), + Alert("alertname", "test", "lbl", "v2"), + ) + am.Push(At(3), + Alert("alertname", "test", "lbl", "v1").Active(1, 4), + Alert("alertname", "test", "lbl", "v3"), + ) + am.Push(At(8), + Alert("alertname", "test", "lbl", "v3").Active(3), + ) + + co1.Want(Between(2, 2.5), + Alert("alertname", "test", "lbl", "v1").Active(1), + Alert("alertname", "test", "lbl", "v2").Active(1), + ) + co1.Want(Between(7, 7.5), + Alert("alertname", "test", "lbl", "v1").Active(1, 4), + Alert("alertname", "test", "lbl", "v2").Active(1), + Alert("alertname", "test", "lbl", "v3").Active(3), + ) + // Notification should be sent because the v2 alert is resolved due to the time-out. + co1.Want(Between(12, 12.5), + Alert("alertname", "test", "lbl", "v2").Active(1, 11), + Alert("alertname", "test", "lbl", "v3").Active(3), + ) + + co2.Want(Between(2, 2.5), + Alert("alertname", "test", "lbl", "v1").Active(1), + Alert("alertname", "test", "lbl", "v2").Active(1), + ) + co2.Want(Between(7, 7.5), + Alert("alertname", "test", "lbl", "v2").Active(1), + Alert("alertname", "test", "lbl", "v3").Active(3), + ) + // No notification should be sent after group_interval because no new alert has been fired. + co2.Want(Between(12, 12.5)) + + at.Run() +} + +func TestReload(t *testing.T) { + t.Parallel() + + // This integration test ensures that the first alert isn't notified twice + // and repeat_interval applies after the AlertManager process has been + // reloaded. + conf := ` +route: + receiver: "default" + group_by: [] + group_wait: 1s + group_interval: 6s + repeat_interval: 10m + +receivers: +- name: "default" + webhook_configs: + - url: 'http://%s' +` + + at := NewAcceptanceTest(t, &AcceptanceOpts{ + Tolerance: 150 * time.Millisecond, + }) + + co := at.Collector("webhook") + wh := NewWebhook(co) + + am := at.Alertmanager(fmt.Sprintf(conf, wh.Address())) + + am.Push(At(1), Alert("alertname", "test1")) + at.Do(At(3), am.Reload) + am.Push(At(4), Alert("alertname", "test2")) + + co.Want(Between(2, 2.5), Alert("alertname", "test1").Active(1)) + // Timers are reset on reload regardless, so we count the 6 second group + // interval from 3 onwards. + co.Want(Between(9, 9.5), + Alert("alertname", "test1").Active(1), + Alert("alertname", "test2").Active(4), + ) + + at.Run() +} diff --git a/src/alertmanager/test/acceptance/silence_test.go b/src/alertmanager/test/acceptance/silence_test.go new file mode 100644 index 0000000..cc83176 --- /dev/null +++ b/src/alertmanager/test/acceptance/silence_test.go @@ -0,0 +1,120 @@ +// Copyright 2015 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package test + +import ( + "fmt" + "testing" + "time" + + . "github.com/prometheus/alertmanager/test" +) + +func TestSilencing(t *testing.T) { + t.Parallel() + + conf := ` +route: + receiver: "default" + group_by: [] + group_wait: 1s + group_interval: 1s + repeat_interval: 1ms + +receivers: +- name: "default" + webhook_configs: + - url: 'http://%s' +` + + at := NewAcceptanceTest(t, &AcceptanceOpts{ + Tolerance: 150 * time.Millisecond, + }) + + co := at.Collector("webhook") + wh := NewWebhook(co) + + am := at.Alertmanager(fmt.Sprintf(conf, wh.Address())) + + // No repeat interval is configured. Thus, we receive an alert + // notification every second. + am.Push(At(1), Alert("alertname", "test1").Active(1)) + am.Push(At(1), Alert("alertname", "test2").Active(1)) + + co.Want(Between(2, 2.5), + Alert("alertname", "test1").Active(1), + Alert("alertname", "test2").Active(1), + ) + + // Add a silence that affects the first alert. + am.SetSilence(At(2.3), Silence(2.5, 4.5).Match("alertname", "test1")) + + co.Want(Between(3, 3.5), Alert("alertname", "test2").Active(1)) + co.Want(Between(4, 4.5), Alert("alertname", "test2").Active(1)) + + // Silence should be over now and we receive both alerts again. + + co.Want(Between(5, 5.5), + Alert("alertname", "test1").Active(1), + Alert("alertname", "test2").Active(1), + ) + + at.Run() +} + +func TestSilenceDelete(t *testing.T) { + t.Parallel() + + conf := ` +route: + receiver: "default" + group_by: [] + group_wait: 1s + group_interval: 1s + repeat_interval: 1ms + +receivers: +- name: "default" + webhook_configs: + - url: 'http://%s' +` + + at := NewAcceptanceTest(t, &AcceptanceOpts{ + Tolerance: 150 * time.Millisecond, + }) + + co := at.Collector("webhook") + wh := NewWebhook(co) + + am := at.Alertmanager(fmt.Sprintf(conf, wh.Address())) + + // No repeat interval is configured. Thus, we receive an alert + // notification every second. + am.Push(At(1), Alert("alertname", "test1").Active(1)) + am.Push(At(1), Alert("alertname", "test2").Active(1)) + + // Silence everything for a long time and delete the silence after + // two iterations. + sil := Silence(1.5, 100).MatchRE("alertname", ".*") + + am.SetSilence(At(1.3), sil) + am.DelSilence(At(3.5), sil) + + co.Want(Between(3.5, 4.5), + Alert("alertname", "test1").Active(1), + Alert("alertname", "test2").Active(1), + ) + + at.Run() +} diff --git a/src/alertmanager/test/collector.go b/src/alertmanager/test/collector.go new file mode 100644 index 0000000..2e5dc6b --- /dev/null +++ b/src/alertmanager/test/collector.go @@ -0,0 +1,172 @@ +// Copyright 2015 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package test + +import ( + "fmt" + "sync" + "testing" + "time" + + "github.com/prometheus/common/model" +) + +// Collector gathers alerts received by a notification receiver +// and verifies whether all arrived and within the correct time boundaries. +type Collector struct { + t *testing.T + name string + opts *AcceptanceOpts + + collected map[float64][]model.Alerts + expected map[Interval][]model.Alerts + + mtx sync.RWMutex +} + +func (c *Collector) String() string { + return c.name +} + +func batchesEqual(as, bs model.Alerts, opts *AcceptanceOpts) bool { + if len(as) != len(bs) { + return false + } + + for _, a := range as { + found := false + for _, b := range bs { + if equalAlerts(a, b, opts) { + found = true + break + } + } + if !found { + return false + } + } + return true +} + +// latest returns the latest relative point in time where a notification is +// expected. +func (c *Collector) latest() float64 { + c.mtx.RLock() + defer c.mtx.RUnlock() + var latest float64 + for iv := range c.expected { + if iv.end > latest { + latest = iv.end + } + } + return latest +} + +// Want declares that the Collector expects to receive the given alerts +// within the given time boundaries. +func (c *Collector) Want(iv Interval, alerts ...*TestAlert) { + c.mtx.Lock() + defer c.mtx.Unlock() + var nas model.Alerts + for _, a := range alerts { + nas = append(nas, a.nativeAlert(c.opts)) + } + + c.expected[iv] = append(c.expected[iv], nas) +} + +// add the given alerts to the collected alerts. +func (c *Collector) add(alerts ...*model.Alert) { + c.mtx.Lock() + defer c.mtx.Unlock() + arrival := c.opts.relativeTime(time.Now()) + + c.collected[arrival] = append(c.collected[arrival], model.Alerts(alerts)) +} + +func (c *Collector) check() string { + report := fmt.Sprintf("\ncollector %q:\n\n", c) + + c.mtx.RLock() + defer c.mtx.RUnlock() + for iv, expected := range c.expected { + report += fmt.Sprintf("interval %v\n", iv) + + var alerts []model.Alerts + for at, got := range c.collected { + if iv.contains(at) { + alerts = append(alerts, got...) + } + } + + for _, exp := range expected { + found := len(exp) == 0 && len(alerts) == 0 + + report += fmt.Sprintf("---\n") + + for _, e := range exp { + report += fmt.Sprintf("- %v\n", c.opts.alertString(e)) + } + + for _, a := range alerts { + if batchesEqual(exp, a, c.opts) { + found = true + break + } + } + + if found { + report += fmt.Sprintf(" [ ✓ ]\n") + } else { + c.t.Fail() + report += fmt.Sprintf(" [ ✗ ]\n") + } + } + } + + // Detect unexpected notifications. + var totalExp, totalAct int + for _, exp := range c.expected { + for _, e := range exp { + totalExp += len(e) + } + } + for _, act := range c.collected { + for _, a := range act { + if len(a) == 0 { + c.t.Error("received empty notifications") + } + totalAct += len(a) + } + } + if totalExp != totalAct { + c.t.Fail() + report += fmt.Sprintf("\nExpected total of %d alerts, got %d", totalExp, totalAct) + } + + if c.t.Failed() { + report += "\nreceived:\n" + + for at, col := range c.collected { + for _, alerts := range col { + report += fmt.Sprintf("@ %v\n", at) + for _, a := range alerts { + report += fmt.Sprintf("- %v\n", c.opts.alertString(a)) + } + } + } + } + + return report +} diff --git a/src/alertmanager/test/mock.go b/src/alertmanager/test/mock.go new file mode 100644 index 0000000..bfe50b9 --- /dev/null +++ b/src/alertmanager/test/mock.go @@ -0,0 +1,309 @@ +// Copyright 2015 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package test + +import ( + "encoding/json" + "fmt" + "net" + "net/http" + "reflect" + "sync" + "time" + + "github.com/prometheus/common/model" + + "github.com/prometheus/alertmanager/notify" + "github.com/prometheus/alertmanager/types" +) + +// At is a convenience method to allow for declarative syntax of Acceptance +// test definitions. +func At(ts float64) float64 { + return ts +} + +type Interval struct { + start, end float64 +} + +func (iv Interval) String() string { + return fmt.Sprintf("[%v,%v]", iv.start, iv.end) +} + +func (iv Interval) contains(f float64) bool { + return f >= iv.start && f <= iv.end +} + +// Between is a convenience constructor for an interval for declarative syntax +// of Acceptance test definitions. +func Between(start, end float64) Interval { + return Interval{start: start, end: end} +} + +// TestSilence models a model.Silence with relative times. +type TestSilence struct { + id string + match []string + matchRE []string + startsAt, endsAt float64 + + mtx sync.RWMutex +} + +// Silence creates a new TestSilence active for the relative interval given +// by start and end. +func Silence(start, end float64) *TestSilence { + return &TestSilence{ + startsAt: start, + endsAt: end, + } +} + +// Match adds a new plain matcher to the silence. +func (s *TestSilence) Match(v ...string) *TestSilence { + s.match = append(s.match, v...) + return s +} + +// MatchRE adds a new regex matcher to the silence +func (s *TestSilence) MatchRE(v ...string) *TestSilence { + if len(v)%2 == 1 { + panic("bad key/values") + } + s.matchRE = append(s.matchRE, v...) + return s +} + +// SetID sets the silence ID. +func (s *TestSilence) SetID(ID string) { + s.mtx.Lock() + defer s.mtx.Unlock() + s.id = ID +} + +// ID gets the silence ID. +func (s *TestSilence) ID() string { + s.mtx.RLock() + defer s.mtx.RUnlock() + return s.id +} + +// nativeSilence converts the declared test silence into a regular +// silence with resolved times. +func (s *TestSilence) nativeSilence(opts *AcceptanceOpts) *types.Silence { + nsil := &types.Silence{} + + for i := 0; i < len(s.match); i += 2 { + nsil.Matchers = append(nsil.Matchers, &types.Matcher{ + Name: s.match[i], + Value: s.match[i+1], + }) + } + for i := 0; i < len(s.matchRE); i += 2 { + nsil.Matchers = append(nsil.Matchers, &types.Matcher{ + Name: s.matchRE[i], + Value: s.matchRE[i+1], + IsRegex: true, + }) + } + + if s.startsAt > 0 { + nsil.StartsAt = opts.expandTime(s.startsAt) + } + if s.endsAt > 0 { + nsil.EndsAt = opts.expandTime(s.endsAt) + } + nsil.Comment = "some comment" + nsil.CreatedBy = "admin@example.com" + + return nsil +} + +// TestAlert models a model.Alert with relative times. +type TestAlert struct { + labels model.LabelSet + annotations model.LabelSet + startsAt, endsAt float64 +} + +// Alert creates a new alert declaration with the given key/value pairs +// as identifying labels. +func Alert(keyval ...interface{}) *TestAlert { + if len(keyval)%2 == 1 { + panic("bad key/values") + } + a := &TestAlert{ + labels: model.LabelSet{}, + annotations: model.LabelSet{}, + } + + for i := 0; i < len(keyval); i += 2 { + ln := model.LabelName(keyval[i].(string)) + lv := model.LabelValue(keyval[i+1].(string)) + + a.labels[ln] = lv + } + + return a +} + +// nativeAlert converts the declared test alert into a full alert based +// on the given paramters. +func (a *TestAlert) nativeAlert(opts *AcceptanceOpts) *model.Alert { + na := &model.Alert{ + Labels: a.labels, + Annotations: a.annotations, + } + + if a.startsAt > 0 { + na.StartsAt = opts.expandTime(a.startsAt) + } + if a.endsAt > 0 { + na.EndsAt = opts.expandTime(a.endsAt) + } + return na +} + +// Annotate the alert with the given key/value pairs. +func (a *TestAlert) Annotate(keyval ...interface{}) *TestAlert { + if len(keyval)%2 == 1 { + panic("bad key/values") + } + + for i := 0; i < len(keyval); i += 2 { + ln := model.LabelName(keyval[i].(string)) + lv := model.LabelValue(keyval[i+1].(string)) + + a.annotations[ln] = lv + } + + return a +} + +// Active declares the relative activity time for this alert. It +// must be a single starting value or two values where the second value +// declares the resolved time. +func (a *TestAlert) Active(tss ...float64) *TestAlert { + if len(tss) > 2 || len(tss) == 0 { + panic("only one or two timestamps allowed") + } + if len(tss) == 2 { + a.endsAt = tss[1] + } + a.startsAt = tss[0] + + return a +} + +func equalAlerts(a, b *model.Alert, opts *AcceptanceOpts) bool { + if !reflect.DeepEqual(a.Labels, b.Labels) { + return false + } + if !reflect.DeepEqual(a.Annotations, b.Annotations) { + return false + } + + if !equalTime(a.StartsAt, b.StartsAt, opts) { + return false + } + if !equalTime(a.EndsAt, b.EndsAt, opts) { + return false + } + return true +} + +func equalTime(a, b time.Time, opts *AcceptanceOpts) bool { + if a.IsZero() != b.IsZero() { + return false + } + + diff := a.Sub(b) + if diff < 0 { + diff = -diff + } + return diff <= opts.Tolerance +} + +type MockWebhook struct { + opts *AcceptanceOpts + collector *Collector + listener net.Listener + + Func func(timestamp float64) bool +} + +func NewWebhook(c *Collector) *MockWebhook { + l, err := net.Listen("tcp4", "localhost:0") + if err != nil { + // TODO(fabxc): if shutdown of mock destinations ever becomes a concern + // we want to shut them down after test completion. Then we might want to + // log the error properly, too. + panic(err) + } + wh := &MockWebhook{ + listener: l, + collector: c, + opts: c.opts, + } + go http.Serve(l, wh) + + return wh +} + +func (ws *MockWebhook) ServeHTTP(w http.ResponseWriter, req *http.Request) { + // Inject Func if it exists. + if ws.Func != nil { + if ws.Func(ws.opts.relativeTime(time.Now())) { + return + } + } + + dec := json.NewDecoder(req.Body) + defer req.Body.Close() + + var v notify.WebhookMessage + if err := dec.Decode(&v); err != nil { + panic(err) + } + + // Transform the webhook message alerts back into model.Alerts. + var alerts model.Alerts + for _, a := range v.Alerts { + var ( + labels = model.LabelSet{} + annotations = model.LabelSet{} + ) + for k, v := range a.Labels { + labels[model.LabelName(k)] = model.LabelValue(v) + } + for k, v := range a.Annotations { + annotations[model.LabelName(k)] = model.LabelValue(v) + } + + alerts = append(alerts, &model.Alert{ + Labels: labels, + Annotations: annotations, + StartsAt: a.StartsAt, + EndsAt: a.EndsAt, + GeneratorURL: a.GeneratorURL, + }) + } + + ws.collector.add(alerts...) +} + +func (ws *MockWebhook) Address() string { + return ws.listener.Addr().String() +} diff --git a/src/alertmanager/types/match.go b/src/alertmanager/types/match.go new file mode 100644 index 0000000..b4b4f5b --- /dev/null +++ b/src/alertmanager/types/match.go @@ -0,0 +1,172 @@ +// Copyright 2015 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package types + +import ( + "fmt" + "regexp" + "sort" + + "bytes" + + "github.com/prometheus/common/model" +) + +// Matcher defines a matching rule for the value of a given label. +type Matcher struct { + Name string `json:"name"` + Value string `json:"value"` + IsRegex bool `json:"isRegex"` + + regex *regexp.Regexp +} + +// Init internals of the Matcher. Must be called before using Match. +func (m *Matcher) Init() error { + if !m.IsRegex { + return nil + } + re, err := regexp.Compile("^(?:" + m.Value + ")$") + if err == nil { + m.regex = re + } + return err +} + +func (m *Matcher) String() string { + if m.IsRegex { + return fmt.Sprintf("%s=~%q", m.Name, m.Value) + } + return fmt.Sprintf("%s=%q", m.Name, m.Value) +} + +// Validate returns true iff all fields of the matcher have valid values. +func (m *Matcher) Validate() error { + if !model.LabelName(m.Name).IsValid() { + return fmt.Errorf("invalid name %q", m.Name) + } + if m.IsRegex { + if _, err := regexp.Compile(m.Value); err != nil { + return fmt.Errorf("invalid regular expression %q", m.Value) + } + } else if !model.LabelValue(m.Value).IsValid() || len(m.Value) == 0 { + return fmt.Errorf("invalid value %q", m.Value) + } + return nil +} + +// Match checks whether the label of the matcher has the specified +// matching value. +func (m *Matcher) Match(lset model.LabelSet) bool { + // Unset labels are treated as unset labels globally. Thus, if a + // label is not set we retrieve the empty label which is correct + // for the comparison below. + v := lset[model.LabelName(m.Name)] + + if m.IsRegex { + return m.regex.MatchString(string(v)) + } + return string(v) == m.Value +} + +// NewMatcher returns a new matcher that compares against equality of +// the given value. +func NewMatcher(name model.LabelName, value string) *Matcher { + return &Matcher{ + Name: string(name), + Value: value, + IsRegex: false, + } +} + +// NewRegexMatcher returns a new matcher that compares values against +// a regular expression. The matcher is already initialized. +// +// TODO(fabxc): refactor usage. +func NewRegexMatcher(name model.LabelName, re *regexp.Regexp) *Matcher { + return &Matcher{ + Name: string(name), + Value: re.String(), + IsRegex: true, + regex: re, + } +} + +// Matchers provides the Match and Fingerprint methods for a slice of Matchers. +// Matchers must always be sorted. +type Matchers []*Matcher + +// NewMatchers returns the given Matchers sorted. +func NewMatchers(ms ...*Matcher) Matchers { + m := Matchers(ms) + sort.Sort(m) + return m +} + +func (ms Matchers) Len() int { return len(ms) } +func (ms Matchers) Swap(i, j int) { ms[i], ms[j] = ms[j], ms[i] } + +func (ms Matchers) Less(i, j int) bool { + if ms[i].Name > ms[j].Name { + return false + } + if ms[i].Name < ms[j].Name { + return true + } + if ms[i].Value > ms[j].Value { + return false + } + if ms[i].Value < ms[j].Value { + return true + } + return !ms[i].IsRegex && ms[j].IsRegex +} + +// Equal returns whether both Matchers are equal. +func (ms Matchers) Equal(o Matchers) bool { + if len(ms) != len(o) { + return false + } + for i, a := range ms { + if *a != *o[i] { + return false + } + } + return true +} + +// Match checks whether all matchers are fulfilled against the given label set. +func (ms Matchers) Match(lset model.LabelSet) bool { + for _, m := range ms { + if !m.Match(lset) { + return false + } + } + return true +} + +func (ms Matchers) String() string { + var buf bytes.Buffer + + buf.WriteByte('{') + for i, m := range ms { + if i > 0 { + buf.WriteByte(',') + } + buf.WriteString(m.String()) + } + buf.WriteByte('}') + + return buf.String() +} diff --git a/src/alertmanager/types/match_test.go b/src/alertmanager/types/match_test.go new file mode 100644 index 0000000..5fed23c --- /dev/null +++ b/src/alertmanager/types/match_test.go @@ -0,0 +1,192 @@ +// Copyright 2018 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package types + +import ( + "fmt" + "regexp" + "testing" + + "github.com/prometheus/common/model" + "github.com/stretchr/testify/require" +) + +func TestMatcherValidate(t *testing.T) { + + validLabelName := "valid_label_name" + validStringValue := "value" + validRegexValue := ".*" + + invalidLabelName := "123_invalid_name" + invalidStringValue := "" + invalidRegexValue := "]*.[" + + tests := []struct { + matcher Matcher + valid bool + errorMsg string + }{ + //valid tests + { + matcher: Matcher{Name: validLabelName, Value: validStringValue}, + valid: true, + }, + { + matcher: Matcher{Name: validLabelName, Value: validRegexValue, IsRegex: true}, + valid: true, + }, + // invalid tests + { + matcher: Matcher{Name: invalidLabelName, Value: validStringValue}, + valid: false, + errorMsg: fmt.Sprintf("invalid name %q", invalidLabelName), + }, + { + matcher: Matcher{Name: validLabelName, Value: invalidStringValue}, + valid: false, + errorMsg: fmt.Sprintf("invalid value %q", invalidStringValue), + }, + { + matcher: Matcher{Name: validLabelName, Value: invalidRegexValue, IsRegex: true}, + valid: false, + errorMsg: fmt.Sprintf("invalid regular expression %q", invalidRegexValue), + }, + } + + for _, test := range tests { + test.matcher.Init() + + if test.valid { + require.NoError(t, test.matcher.Validate()) + continue + } + + require.EqualError(t, test.matcher.Validate(), test.errorMsg) + } +} + +func TestMatcherInit(t *testing.T) { + m := Matcher{Name: "label", Value: ".*", IsRegex: true} + require.NoError(t, m.Init()) + require.EqualValues(t, "^(?:.*)$", m.regex.String()) + + m = Matcher{Name: "label", Value: "]*.[", IsRegex: true} + require.Error(t, m.Init()) +} + +func TestMatcherMatch(t *testing.T) { + tests := []struct { + matcher Matcher + expected bool + }{ + {matcher: Matcher{Name: "label", Value: "value"}, expected: true}, + {matcher: Matcher{Name: "label", Value: "val"}, expected: false}, + {matcher: Matcher{Name: "label", Value: "val.*", IsRegex: true}, expected: true}, + {matcher: Matcher{Name: "label", Value: "diffval.*", IsRegex: true}, expected: false}, + //unset label + {matcher: Matcher{Name: "difflabel", Value: "value"}, expected: false}, + } + + lset := model.LabelSet{"label": "value"} + for _, test := range tests { + test.matcher.Init() + + actual := test.matcher.Match(lset) + require.EqualValues(t, test.expected, actual) + } +} + +func TestMatcherString(t *testing.T) { + m := NewMatcher("foo", "bar") + + if m.String() != "foo=\"bar\"" { + t.Errorf("unexpected matcher string %#v", m.String()) + } + + re, err := regexp.Compile(".*") + if err != nil { + t.Errorf("unexpected error: %s", err) + } + + m = NewRegexMatcher("foo", re) + + if m.String() != "foo=~\".*\"" { + t.Errorf("unexpected matcher string %#v", m.String()) + } +} + +func TestMatchersString(t *testing.T) { + m1 := NewMatcher("foo", "bar") + + re, err := regexp.Compile(".*") + if err != nil { + t.Errorf("unexpected error: %s", err) + } + + m2 := NewRegexMatcher("bar", re) + + matchers := NewMatchers(m1, m2) + + if matchers.String() != "{bar=~\".*\",foo=\"bar\"}" { + t.Errorf("unexpected matcher string %#v", matchers.String()) + } +} + +func TestMatchersMatch(t *testing.T) { + + m1 := &Matcher{Name: "label1", Value: "value1"} + m1.Init() + m2 := &Matcher{Name: "label2", Value: "val.*", IsRegex: true} + m2.Init() + m3 := &Matcher{Name: "label3", Value: "value3"} + m3.Init() + + tests := []struct { + matchers Matchers + expected bool + }{ + {matchers: Matchers{m1, m2}, expected: true}, + {matchers: Matchers{m1, m3}, expected: false}, + } + + lset := model.LabelSet{"label1": "value1", "label2": "value2"} + for _, test := range tests { + actual := test.matchers.Match(lset) + require.EqualValues(t, test.expected, actual) + } +} + +func TestMatchersEqual(t *testing.T) { + + m1 := &Matcher{Name: "label1", Value: "value1"} + m1.Init() + m2 := &Matcher{Name: "label2", Value: "val.*", IsRegex: true} + m2.Init() + m3 := &Matcher{Name: "label3", Value: "value3"} + m3.Init() + + tests := []struct { + matchers1 Matchers + matchers2 Matchers + expected bool + }{ + {matchers1: Matchers{m1, m2}, matchers2: Matchers{m1, m2}, expected: true}, + {matchers1: Matchers{m1, m3}, matchers2: Matchers{m1, m2}, expected: false}, + } + + for _, test := range tests { + actual := test.matchers1.Equal(test.matchers2) + require.EqualValues(t, test.expected, actual) + } +} diff --git a/src/alertmanager/types/types.go b/src/alertmanager/types/types.go new file mode 100644 index 0000000..94545f8 --- /dev/null +++ b/src/alertmanager/types/types.go @@ -0,0 +1,405 @@ +// Copyright 2015 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package types + +import ( + "strings" + "sync" + "time" + + "github.com/prometheus/common/model" +) + +type AlertState string + +const ( + AlertStateUnprocessed AlertState = "unprocessed" + AlertStateActive AlertState = "active" + AlertStateSuppressed AlertState = "suppressed" +) + +// AlertStatus stores the state and values associated with an Alert. +type AlertStatus struct { + State AlertState `json:"state"` + SilencedBy []string `json:"silencedBy"` + InhibitedBy []string `json:"inhibitedBy"` +} + +// Marker helps to mark alerts as silenced and/or inhibited. +// All methods are goroutine-safe. +type Marker interface { + SetActive(alert model.Fingerprint) + SetInhibited(alert model.Fingerprint, ids ...string) + SetSilenced(alert model.Fingerprint, ids ...string) + + Count(...AlertState) int + + Status(model.Fingerprint) AlertStatus + Delete(model.Fingerprint) + + Unprocessed(model.Fingerprint) bool + Active(model.Fingerprint) bool + Silenced(model.Fingerprint) ([]string, bool) + Inhibited(model.Fingerprint) ([]string, bool) +} + +// NewMarker returns an instance of a Marker implementation. +func NewMarker() Marker { + return &memMarker{ + m: map[model.Fingerprint]*AlertStatus{}, + } +} + +type memMarker struct { + m map[model.Fingerprint]*AlertStatus + + mtx sync.RWMutex +} + +// Count alerts of a given state. +func (m *memMarker) Count(states ...AlertState) int { + count := 0 + + m.mtx.RLock() + defer m.mtx.RUnlock() + + if len(states) == 0 { + count = len(m.m) + } else { + for _, status := range m.m { + for _, state := range states { + if status.State == state { + count++ + } + } + } + } + return count +} + +// SetSilenced sets the AlertStatus to suppressed and stores the associated silence IDs. +func (m *memMarker) SetSilenced(alert model.Fingerprint, ids ...string) { + m.mtx.Lock() + + s, found := m.m[alert] + if !found { + s = &AlertStatus{} + m.m[alert] = s + } + + // If there are any silence or alert IDs associated with the + // fingerprint, it is suppressed. Otherwise, set it to + // AlertStateUnprocessed. + if len(ids) == 0 && len(s.InhibitedBy) == 0 { + m.mtx.Unlock() + m.SetActive(alert) + return + } + + s.State = AlertStateSuppressed + s.SilencedBy = ids + + m.mtx.Unlock() +} + +// SetInhibited sets the AlertStatus to suppressed and stores the associated alert IDs. +func (m *memMarker) SetInhibited(alert model.Fingerprint, ids ...string) { + m.mtx.Lock() + + s, found := m.m[alert] + if !found { + s = &AlertStatus{} + m.m[alert] = s + } + + // If there are any silence or alert IDs associated with the + // fingerprint, it is suppressed. Otherwise, set it to + // AlertStateUnprocessed. + if len(ids) == 0 && len(s.SilencedBy) == 0 { + m.mtx.Unlock() + m.SetActive(alert) + return + } + + s.State = AlertStateSuppressed + s.InhibitedBy = ids + + m.mtx.Unlock() +} + +func (m *memMarker) SetActive(alert model.Fingerprint) { + m.mtx.Lock() + defer m.mtx.Unlock() + + s, found := m.m[alert] + if !found { + s = &AlertStatus{ + SilencedBy: []string{}, + InhibitedBy: []string{}, + } + m.m[alert] = s + } + + s.State = AlertStateActive + s.SilencedBy = []string{} + s.InhibitedBy = []string{} +} + +// Status returns the AlertStatus for the given Fingerprint. +func (m *memMarker) Status(alert model.Fingerprint) AlertStatus { + m.mtx.RLock() + defer m.mtx.RUnlock() + + s, found := m.m[alert] + if !found { + s = &AlertStatus{ + State: AlertStateUnprocessed, + SilencedBy: []string{}, + InhibitedBy: []string{}, + } + } + return *s +} + +// Delete deletes the given Fingerprint from the internal cache. +func (m *memMarker) Delete(alert model.Fingerprint) { + m.mtx.Lock() + defer m.mtx.Unlock() + + delete(m.m, alert) +} + +// Unprocessed returns whether the alert for the given Fingerprint is in the +// Unprocessed state. +func (m *memMarker) Unprocessed(alert model.Fingerprint) bool { + return m.Status(alert).State == AlertStateUnprocessed +} + +// Active returns whether the alert for the given Fingerprint is in the Active +// state. +func (m *memMarker) Active(alert model.Fingerprint) bool { + return m.Status(alert).State == AlertStateActive +} + +// Inhibited returns whether the alert for the given Fingerprint is in the +// Inhibited state and any associated alert IDs. +func (m *memMarker) Inhibited(alert model.Fingerprint) ([]string, bool) { + s := m.Status(alert) + return s.InhibitedBy, + s.State == AlertStateSuppressed && len(s.InhibitedBy) > 0 +} + +// Silenced returns whether the alert for the given Fingerprint is in the +// Silenced state and any associated silence IDs. +func (m *memMarker) Silenced(alert model.Fingerprint) ([]string, bool) { + s := m.Status(alert) + return s.SilencedBy, + s.State == AlertStateSuppressed && len(s.SilencedBy) > 0 +} + +// MultiError contains multiple errors and implements the error interface. Its +// zero value is ready to use. All its methods are goroutine safe. +type MultiError struct { + mtx sync.Mutex + errors []error +} + +// Add adds an error to the MultiError. +func (e *MultiError) Add(err error) { + e.mtx.Lock() + defer e.mtx.Unlock() + + e.errors = append(e.errors, err) +} + +// Len returns the number of errors added to the MultiError. +func (e *MultiError) Len() int { + e.mtx.Lock() + defer e.mtx.Unlock() + + return len(e.errors) +} + +// Errors returns the errors added to the MuliError. The returned slice is a +// copy of the internal slice of errors. +func (e *MultiError) Errors() []error { + e.mtx.Lock() + defer e.mtx.Unlock() + + return append(make([]error, 0, len(e.errors)), e.errors...) +} + +func (e *MultiError) Error() string { + e.mtx.Lock() + defer e.mtx.Unlock() + + es := make([]string, 0, len(e.errors)) + for _, err := range e.errors { + es = append(es, err.Error()) + } + return strings.Join(es, "; ") +} + +// Alert wraps a model.Alert with additional information relevant +// to internal of the Alertmanager. +// The type is never exposed to external communication and the +// embedded alert has to be sanitized beforehand. +type Alert struct { + model.Alert + + // The authoritative timestamp. + UpdatedAt time.Time + Timeout bool +} + +// AlertSlice is a sortable slice of Alerts. +type AlertSlice []*Alert + +func (as AlertSlice) Less(i, j int) bool { + // Look at labels.job, then labels.instance. + for _, overrideKey := range [...]model.LabelName{"job", "instance"} { + iVal, iOk := as[i].Labels[overrideKey] + jVal, jOk := as[j].Labels[overrideKey] + if !iOk && !jOk { + continue + } + if !iOk { + return false + } + if !jOk { + return true + } + if iVal != jVal { + return iVal < jVal + } + } + return as[i].Labels.Before(as[j].Labels) +} +func (as AlertSlice) Swap(i, j int) { as[i], as[j] = as[j], as[i] } +func (as AlertSlice) Len() int { return len(as) } + +// Alerts turns a sequence of internal alerts into a list of +// exposable model.Alert structures. +func Alerts(alerts ...*Alert) model.Alerts { + res := make(model.Alerts, 0, len(alerts)) + for _, a := range alerts { + v := a.Alert + // If the end timestamp was set as the expected value in case + // of a timeout but is not reached yet, do not expose it. + if a.Timeout && !a.Resolved() { + v.EndsAt = time.Time{} + } + res = append(res, &v) + } + return res +} + +// Merge merges the timespan of two alerts based and overwrites annotations +// based on the authoritative timestamp. A new alert is returned, the labels +// are assumed to be equal. +func (a *Alert) Merge(o *Alert) *Alert { + // Let o always be the younger alert. + if o.UpdatedAt.Before(a.UpdatedAt) { + return o.Merge(a) + } + + res := *o + + // Always pick the earliest starting time. + if a.StartsAt.Before(o.StartsAt) { + res.StartsAt = a.StartsAt + } + + // A non-timeout resolved timestamp always rules. + // The latest explicit resolved timestamp wins. + if a.EndsAt.After(o.EndsAt) && !a.Timeout { + res.EndsAt = a.EndsAt + } + + return &res +} + +// A Muter determines whether a given label set is muted. +type Muter interface { + Mutes(model.LabelSet) bool +} + +// A MuteFunc is a function that implements the Muter interface. +type MuteFunc func(model.LabelSet) bool + +// Mutes implements the Muter interface. +func (f MuteFunc) Mutes(lset model.LabelSet) bool { return f(lset) } + +// A Silence determines whether a given label set is muted. +type Silence struct { + // A unique identifier across all connected instances. + ID string `json:"id"` + // A set of matchers determining if a label set is affect + // by the silence. + Matchers Matchers `json:"matchers"` + + // Time range of the silence. + // + // * StartsAt must not be before creation time + // * EndsAt must be after StartsAt + // * Deleting a silence means to set EndsAt to now + // * Time range must not be modified in different ways + // + // TODO(fabxc): this may potentially be extended by + // creation and update timestamps. + StartsAt time.Time `json:"startsAt"` + EndsAt time.Time `json:"endsAt"` + + // The last time the silence was updated. + UpdatedAt time.Time `json:"updatedAt"` + + // Information about who created the silence for which reason. + CreatedBy string `json:"createdBy"` + Comment string `json:"comment,omitempty"` + + // timeFunc provides the time against which to evaluate + // the silence. Used for test injection. + now func() time.Time + + Status SilenceStatus `json:"status"` +} + +// Expired return if the silence is expired +// meaning that both StartsAt and EndsAt are equal +func (s *Silence) Expired() bool { + return s.StartsAt.Equal(s.EndsAt) +} + +type SilenceStatus struct { + State SilenceState `json:"state"` +} + +type SilenceState string + +const ( + SilenceStateExpired SilenceState = "expired" + SilenceStateActive SilenceState = "active" + SilenceStatePending SilenceState = "pending" +) + +func CalcSilenceState(start, end time.Time) SilenceState { + current := time.Now() + if current.Before(start) { + return SilenceStatePending + } + if current.Before(end) { + return SilenceStateActive + } + return SilenceStateExpired +} diff --git a/src/alertmanager/types/types_test.go b/src/alertmanager/types/types_test.go new file mode 100644 index 0000000..4e3fc2d --- /dev/null +++ b/src/alertmanager/types/types_test.go @@ -0,0 +1,172 @@ +// Copyright 2015 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package types + +import ( + "reflect" + "sort" + "testing" + "time" + + "github.com/prometheus/common/model" + "github.com/stretchr/testify/require" +) + +func TestAlertMerge(t *testing.T) { + now := time.Now() + + pairs := []struct { + A, B, Res *Alert + }{ + { + A: &Alert{ + Alert: model.Alert{ + StartsAt: now.Add(-time.Minute), + EndsAt: now.Add(2 * time.Minute), + }, + UpdatedAt: now, + Timeout: true, + }, + B: &Alert{ + Alert: model.Alert{ + StartsAt: now.Add(-time.Minute), + EndsAt: now.Add(3 * time.Minute), + }, + UpdatedAt: now.Add(time.Minute), + Timeout: true, + }, + Res: &Alert{ + Alert: model.Alert{ + StartsAt: now.Add(-time.Minute), + EndsAt: now.Add(3 * time.Minute), + }, + UpdatedAt: now.Add(time.Minute), + Timeout: true, + }, + }, + } + + for _, p := range pairs { + if res := p.A.Merge(p.B); !reflect.DeepEqual(p.Res, res) { + t.Errorf("unexpected merged alert %#v", res) + } + } +} + +func TestCalcSilenceState(t *testing.T) { + + var ( + pastStartTime = time.Now() + pastEndTime = time.Now() + + futureStartTime = time.Now().Add(time.Hour) + futureEndTime = time.Now().Add(time.Hour) + ) + + expected := CalcSilenceState(futureStartTime, futureEndTime) + require.Equal(t, SilenceStatePending, expected) + + expected = CalcSilenceState(pastStartTime, futureEndTime) + require.Equal(t, SilenceStateActive, expected) + + expected = CalcSilenceState(pastStartTime, pastEndTime) + require.Equal(t, SilenceStateExpired, expected) +} + +func TestSilenceExpired(t *testing.T) { + now := time.Now() + silence := Silence{StartsAt: now, EndsAt: now} + require.True(t, silence.Expired()) + + silence = Silence{StartsAt: now.Add(time.Hour), EndsAt: now.Add(time.Hour)} + require.True(t, silence.Expired()) + + silence = Silence{StartsAt: now, EndsAt: now.Add(time.Hour)} + require.False(t, silence.Expired()) +} + +func TestAlertSliceSort(t *testing.T) { + var ( + a1 = &Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{ + "job": "j1", + "instance": "i1", + "alertname": "an1", + }, + }, + } + a2 = &Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{ + "job": "j1", + "instance": "i1", + "alertname": "an2", + }, + }, + } + a3 = &Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{ + "job": "j2", + "instance": "i1", + "alertname": "an1", + }, + }, + } + a4 = &Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{ + "alertname": "an1", + }, + }, + } + a5 = &Alert{ + Alert: model.Alert{ + Labels: model.LabelSet{ + "alertname": "an2", + }, + }, + } + ) + + cases := []struct { + alerts AlertSlice + exp AlertSlice + }{ + { + alerts: AlertSlice{a2, a1}, + exp: AlertSlice{a1, a2}, + }, + { + alerts: AlertSlice{a3, a2, a1}, + exp: AlertSlice{a1, a2, a3}, + }, + { + alerts: AlertSlice{a4, a2, a4}, + exp: AlertSlice{a2, a4, a4}, + }, + { + alerts: AlertSlice{a5, a4}, + exp: AlertSlice{a4, a5}, + }, + } + + for _, tc := range cases { + sort.Stable(tc.alerts) + if !reflect.DeepEqual(tc.alerts, tc.exp) { + t.Fatalf("expected %v but got %v", tc.exp, tc.alerts) + } + } +} diff --git a/src/alertmanager/ui/Dockerfile b/src/alertmanager/ui/Dockerfile new file mode 100644 index 0000000..27663c1 --- /dev/null +++ b/src/alertmanager/ui/Dockerfile @@ -0,0 +1,3 @@ +FROM node:6.10 + +RUN npm install -g elm@0.18.0 elm-format@0.6.1-alpha elm-test@0.18.3 uglify-js@3.0.15 diff --git a/src/alertmanager/ui/app/.gitignore b/src/alertmanager/ui/app/.gitignore new file mode 100644 index 0000000..3c3a3ee --- /dev/null +++ b/src/alertmanager/ui/app/.gitignore @@ -0,0 +1,3 @@ +dist/ +elm-stuff/ +script.js diff --git a/src/alertmanager/ui/app/CONTRIBUTING.md b/src/alertmanager/ui/app/CONTRIBUTING.md new file mode 100644 index 0000000..b754032 --- /dev/null +++ b/src/alertmanager/ui/app/CONTRIBUTING.md @@ -0,0 +1,74 @@ +# Contributing + +This document describes how to: + +- Set up your dev environment +- Become familiar with [Elm](http://elm-lang.org/) +- Develop against AlertManager + +## Dev Environment Setup + +You can either use our default Docker setup or install all dev dependencies +locally. For the former you only need Docker installed, for the latter you need +to set the environment flag `NO_DOCKER` to `true` and have the following +dependencies installed: + +- [Elm](https://guide.elm-lang.org/install.html#install) +- [Elm-Format](https://github.com/avh4/elm-format) is installed + +In addition for easier development you +can [configure](https://guide.elm-lang.org/install.html#configure-your-editor) +your editor. + +**All submitted elm code must be formatted with `elm-format`**. Install and +execute it however works best for you. We recommend having formatting the file +on save, similar to how many developers use `gofmt`. + +If you prefer, there's a make target available to format all elm source files: + +``` +# make format +``` + +Once you've installed Elm, install the dependencies listed in +`elm-package.json`: + +``` +# elm package install -y +``` + +## Elm Resources + +- The [Official Elm Guide](https://guide.elm-lang.org/) is a great place to + start. Going through the entire guide takes about an hour, and is a good + primer to get involved in our codebase. Once you've worked through it, you + should be able to start writing your feature with the help of the compiler. +- Check the [syntax reference](http://elm-lang.org/docs/syntax) when you need a + reminder of how the language works. +- Read up on [how to write elm code](http://elm-lang.org/docs/style-guide). +- Watch videos from the + latest [elm-conf](https://www.youtube.com/channel/UCOpGiN9AkczVjlpGDaBwQrQ) +- Learn how to use the debugger! Elm comes packaged with an excellent + [debugger](http://elm-lang.org/blog/the-perfect-bug-report). We've found this + tool to be invaluable in understanding how the app is working as we're + debugging behavior. + +## Local development workflow + +At the top level of this repo, follow the HA AlertManager instructions. Compile +the binary, then run with `goreman`. Add example alerts with the file provided +in the HA example folder. Then start the development server: + +``` +# cd ui/app +# make dev-server +``` + +Your app should be available at `http://localhost:`. Navigate to +`src/Main.elm`. Any changes to the file system are detected automatically, +triggering a recompile of the project. + +## Commiting changes + +Before you commit changes, please run `make build-all` on the root level +Makefile. Please include `ui/bindata.go` in your commit. diff --git a/src/alertmanager/ui/app/Makefile b/src/alertmanager/ui/app/Makefile new file mode 100644 index 0000000..67ed93f --- /dev/null +++ b/src/alertmanager/ui/app/Makefile @@ -0,0 +1,41 @@ +ELM_FILES := $(shell find src -iname *.elm) +DOCKER_IMG :=elm-env +DOCKER_CMD := docker run --rm -t -v $(PWD):/app -w /app $(DOCKER_IMG) +# macOS requires mktemp template to be at the end of the filename. +TEMPFILE := $(shell mktemp ./elm-XXXXXXXXXX) +# --output flag for elm make must end in .js or .html. +TEMPFILE_JS := "$(TEMPFILE).js" + +ifeq ($(NO_DOCKER), true) + DOCKER_CMD= +endif + +all: test script.js + +elm-env: + @(if [ "$(NO_DOCKER)" != "true" ] ; then \ + echo ">> building elm-env docker image"; \ + docker build -t $(DOCKER_IMG) ../. > /dev/null; \ + fi; ) + +format: elm-env $(ELM_FILES) + @echo ">> format front-end code" + @$(DOCKER_CMD) elm-format --yes $(ELM_FILES) + +test: elm-env + @$(DOCKER_CMD) elm-format $(ELM_FILES) --validate + @$(DOCKER_CMD) elm-test + +dev-server: + elm-reactor + +script.js: elm-env format $(ELM_FILES) + @echo ">> building script.js" + @$(DOCKER_CMD) elm make src/Main.elm --yes --output $(TEMPFILE_JS) + @$(DOCKER_CMD) uglifyjs $(TEMPFILE_JS) --compress unused --mangle --output $(@) + @rm -rf $(TEMPFILE_JS) + @rm -rf $(TEMPFILE) + +clean: + - @rm script.js + - @docker rmi $(DOCKER_IMG) diff --git a/src/alertmanager/ui/app/README.md b/src/alertmanager/ui/app/README.md new file mode 100644 index 0000000..a25ce02 --- /dev/null +++ b/src/alertmanager/ui/app/README.md @@ -0,0 +1,59 @@ +# Alertmanager UI + +This is a re-write of the Alertmanager UI in [elm-lang](http://elm-lang.org/). + +## Usage + +### Filtering on the alerts page + +By default, the alerts page only shows active (not silenced) alerts. Adding a +query string containing the following will additionally show silenced alerts. + +``` +http://alertmanager/#/alerts?silenced=true +``` + +The alerts page can also be filtered by the receivers for a page. Receivers are +configured in Alertmanager's yaml configuration file. + +``` +http://alertmanager/#/alerts?receiver=backend +``` + +Filtering based on label matchers is available. They can easily be added and +modified through the UI. + +``` +http://alertmanager/#/alerts?filter=%7Bseverity%3D%22warning%22%2C%20owner%3D%22backend%22%7D +``` + +These filters can be used in conjunction. + +### Filtering on the silences page + +Filtering based on label matchers is available. They can easily be added and +modified through the UI. + +``` +http://alertmanager/#/silences?filter=%7Bseverity%3D%22warning%22%2C%20owner%3D%22backend%22%7D +``` + +### Note on filtering via label matchers + +Filtering via label matchers follows the same syntax and semantics as Prometheus. + +A properly formatted filter is a set of label matchers joined by accepted +matching operators, surrounded by curly braces: + +``` +{foo="bar", baz=~"quu.*"} +``` + +Operators include: + +- `=` +- `!=` +- `=~` +- `!~` + +See the official documentation for additional information: https://prometheus.io/docs/querying/basics/#instant-vector-selectors diff --git a/src/alertmanager/ui/app/elm-package.json b/src/alertmanager/ui/app/elm-package.json new file mode 100644 index 0000000..89e3074 --- /dev/null +++ b/src/alertmanager/ui/app/elm-package.json @@ -0,0 +1,23 @@ +{ + "version": "1.0.0", + "summary": "Alertmanager UI", + "repository": "https://github.com/prometheus/alertmanager.git", + "license": "Apache-2.0", + "source-directories": [ + "src" + ], + "exposed-modules": [], + "dependencies": { + "elm-lang/core": "5.0.0 <= v < 6.0.0", + "elm-lang/dom": "1.1.1 <= v < 2.0.0", + "elm-lang/html": "2.0.0 <= v < 3.0.0", + "elm-lang/http": "1.0.0 <= v < 2.0.0", + "elm-lang/navigation": "2.0.1 <= v < 3.0.0", + "elm-tools/parser": "2.0.0 <= v < 3.0.0", + "evancz/url-parser": "2.0.1 <= v < 3.0.0", + "jweir/elm-iso8601": "3.0.2 <= v < 4.0.0", + "krisajenkins/elm-dialog": "4.0.3 <= v < 5.0.0", + "rluiten/elm-date-extra": "8.5.0 <= v < 9.0.0" + }, + "elm-version": "0.18.0 <= v < 0.19.0" +} diff --git a/src/alertmanager/ui/app/favicon.ico b/src/alertmanager/ui/app/favicon.ico new file mode 100644 index 0000000..34bd1fb Binary files /dev/null and b/src/alertmanager/ui/app/favicon.ico differ diff --git a/src/alertmanager/ui/app/index.html b/src/alertmanager/ui/app/index.html new file mode 100644 index 0000000..eed6691 --- /dev/null +++ b/src/alertmanager/ui/app/index.html @@ -0,0 +1,25 @@ + + + + + + Alertmanager + + + + + + + diff --git a/src/alertmanager/ui/app/lib/bootstrap-4.0.0-alpha.6-dist/css/bootstrap.min.css b/src/alertmanager/ui/app/lib/bootstrap-4.0.0-alpha.6-dist/css/bootstrap.min.css new file mode 100644 index 0000000..a8da074 --- /dev/null +++ b/src/alertmanager/ui/app/lib/bootstrap-4.0.0-alpha.6-dist/css/bootstrap.min.css @@ -0,0 +1,6 @@ +/*! + * Bootstrap v4.0.0-alpha.6 (https://getbootstrap.com) + * Copyright 2011-2017 The Bootstrap Authors + * Copyright 2011-2017 Twitter, Inc. + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) + *//*! normalize.css v5.0.0 | MIT License | github.com/necolas/normalize.css */html{font-family:sans-serif;line-height:1.15;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%}body{margin:0}article,aside,footer,header,nav,section{display:block}h1{font-size:2em;margin:.67em 0}figcaption,figure,main{display:block}figure{margin:1em 40px}hr{-webkit-box-sizing:content-box;box-sizing:content-box;height:0;overflow:visible}pre{font-family:monospace,monospace;font-size:1em}a{background-color:transparent;-webkit-text-decoration-skip:objects}a:active,a:hover{outline-width:0}abbr[title]{border-bottom:none;text-decoration:underline;text-decoration:underline dotted}b,strong{font-weight:inherit}b,strong{font-weight:bolder}code,kbd,samp{font-family:monospace,monospace;font-size:1em}dfn{font-style:italic}mark{background-color:#ff0;color:#000}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}audio,video{display:inline-block}audio:not([controls]){display:none;height:0}img{border-style:none}svg:not(:root){overflow:hidden}button,input,optgroup,select,textarea{font-family:sans-serif;font-size:100%;line-height:1.15;margin:0}button,input{overflow:visible}button,select{text-transform:none}[type=reset],[type=submit],button,html [type=button]{-webkit-appearance:button}[type=button]::-moz-focus-inner,[type=reset]::-moz-focus-inner,[type=submit]::-moz-focus-inner,button::-moz-focus-inner{border-style:none;padding:0}[type=button]:-moz-focusring,[type=reset]:-moz-focusring,[type=submit]:-moz-focusring,button:-moz-focusring{outline:1px dotted ButtonText}fieldset{border:1px solid silver;margin:0 2px;padding:.35em .625em .75em}legend{-webkit-box-sizing:border-box;box-sizing:border-box;color:inherit;display:table;max-width:100%;padding:0;white-space:normal}progress{display:inline-block;vertical-align:baseline}textarea{overflow:auto}[type=checkbox],[type=radio]{-webkit-box-sizing:border-box;box-sizing:border-box;padding:0}[type=number]::-webkit-inner-spin-button,[type=number]::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}[type=search]::-webkit-search-cancel-button,[type=search]::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}details,menu{display:block}summary{display:list-item}canvas{display:inline-block}template{display:none}[hidden]{display:none}@media print{*,::after,::before,blockquote::first-letter,blockquote::first-line,div::first-letter,div::first-line,li::first-letter,li::first-line,p::first-letter,p::first-line{text-shadow:none!important;-webkit-box-shadow:none!important;box-shadow:none!important}a,a:visited{text-decoration:underline}abbr[title]::after{content:" (" attr(title) ")"}pre{white-space:pre-wrap!important}blockquote,pre{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}img,tr{page-break-inside:avoid}h2,h3,p{orphans:3;widows:3}h2,h3{page-break-after:avoid}.navbar{display:none}.badge{border:1px solid #000}.table{border-collapse:collapse!important}.table td,.table th{background-color:#fff!important}.table-bordered td,.table-bordered th{border:1px solid #ddd!important}}html{-webkit-box-sizing:border-box;box-sizing:border-box}*,::after,::before{-webkit-box-sizing:inherit;box-sizing:inherit}@-ms-viewport{width:device-width}html{-ms-overflow-style:scrollbar;-webkit-tap-highlight-color:transparent}body{font-family:-apple-system,system-ui,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,sans-serif;font-size:1rem;font-weight:400;line-height:1.5;color:#292b2c;background-color:#fff}[tabindex="-1"]:focus{outline:0!important}h1,h2,h3,h4,h5,h6{margin-top:0;margin-bottom:.5rem}p{margin-top:0;margin-bottom:1rem}abbr[data-original-title],abbr[title]{cursor:help}address{margin-bottom:1rem;font-style:normal;line-height:inherit}dl,ol,ul{margin-top:0;margin-bottom:1rem}ol ol,ol ul,ul ol,ul ul{margin-bottom:0}dt{font-weight:700}dd{margin-bottom:.5rem;margin-left:0}blockquote{margin:0 0 1rem}a{color:#0275d8;text-decoration:none}a:focus,a:hover{color:#014c8c;text-decoration:underline}a:not([href]):not([tabindex]){color:inherit;text-decoration:none}a:not([href]):not([tabindex]):focus,a:not([href]):not([tabindex]):hover{color:inherit;text-decoration:none}a:not([href]):not([tabindex]):focus{outline:0}pre{margin-top:0;margin-bottom:1rem;overflow:auto}figure{margin:0 0 1rem}img{vertical-align:middle}[role=button]{cursor:pointer}[role=button],a,area,button,input,label,select,summary,textarea{-ms-touch-action:manipulation;touch-action:manipulation}table{border-collapse:collapse;background-color:transparent}caption{padding-top:.75rem;padding-bottom:.75rem;color:#636c72;text-align:left;caption-side:bottom}th{text-align:left}label{display:inline-block;margin-bottom:.5rem}button:focus{outline:1px dotted;outline:5px auto -webkit-focus-ring-color}button,input,select,textarea{line-height:inherit}input[type=checkbox]:disabled,input[type=radio]:disabled{cursor:not-allowed}input[type=date],input[type=time],input[type=datetime-local],input[type=month]{-webkit-appearance:listbox}textarea{resize:vertical}fieldset{min-width:0;padding:0;margin:0;border:0}legend{display:block;width:100%;padding:0;margin-bottom:.5rem;font-size:1.5rem;line-height:inherit}input[type=search]{-webkit-appearance:none}output{display:inline-block}[hidden]{display:none!important}.h1,.h2,.h3,.h4,.h5,.h6,h1,h2,h3,h4,h5,h6{margin-bottom:.5rem;font-family:inherit;font-weight:500;line-height:1.1;color:inherit}.h1,h1{font-size:2.5rem}.h2,h2{font-size:2rem}.h3,h3{font-size:1.75rem}.h4,h4{font-size:1.5rem}.h5,h5{font-size:1.25rem}.h6,h6{font-size:1rem}.lead{font-size:1.25rem;font-weight:300}.display-1{font-size:6rem;font-weight:300;line-height:1.1}.display-2{font-size:5.5rem;font-weight:300;line-height:1.1}.display-3{font-size:4.5rem;font-weight:300;line-height:1.1}.display-4{font-size:3.5rem;font-weight:300;line-height:1.1}hr{margin-top:1rem;margin-bottom:1rem;border:0;border-top:1px solid rgba(0,0,0,.1)}.small,small{font-size:80%;font-weight:400}.mark,mark{padding:.2em;background-color:#fcf8e3}.list-unstyled{padding-left:0;list-style:none}.list-inline{padding-left:0;list-style:none}.list-inline-item{display:inline-block}.list-inline-item:not(:last-child){margin-right:5px}.initialism{font-size:90%;text-transform:uppercase}.blockquote{padding:.5rem 1rem;margin-bottom:1rem;font-size:1.25rem;border-left:.25rem solid #eceeef}.blockquote-footer{display:block;font-size:80%;color:#636c72}.blockquote-footer::before{content:"\2014 \00A0"}.blockquote-reverse{padding-right:1rem;padding-left:0;text-align:right;border-right:.25rem solid #eceeef;border-left:0}.blockquote-reverse .blockquote-footer::before{content:""}.blockquote-reverse .blockquote-footer::after{content:"\00A0 \2014"}.img-fluid{max-width:100%;height:auto}.img-thumbnail{padding:.25rem;background-color:#fff;border:1px solid #ddd;border-radius:.25rem;-webkit-transition:all .2s ease-in-out;-o-transition:all .2s ease-in-out;transition:all .2s ease-in-out;max-width:100%;height:auto}.figure{display:inline-block}.figure-img{margin-bottom:.5rem;line-height:1}.figure-caption{font-size:90%;color:#636c72}code,kbd,pre,samp{font-family:Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace}code{padding:.2rem .4rem;font-size:90%;color:#bd4147;background-color:#f7f7f9;border-radius:.25rem}a>code{padding:0;color:inherit;background-color:inherit}kbd{padding:.2rem .4rem;font-size:90%;color:#fff;background-color:#292b2c;border-radius:.2rem}kbd kbd{padding:0;font-size:100%;font-weight:700}pre{display:block;margin-top:0;margin-bottom:1rem;font-size:90%;color:#292b2c}pre code{padding:0;font-size:inherit;color:inherit;background-color:transparent;border-radius:0}.pre-scrollable{max-height:340px;overflow-y:scroll}.container{position:relative;margin-left:auto;margin-right:auto;padding-right:15px;padding-left:15px}@media (min-width:576px){.container{padding-right:15px;padding-left:15px}}@media (min-width:768px){.container{padding-right:15px;padding-left:15px}}@media (min-width:992px){.container{padding-right:15px;padding-left:15px}}@media (min-width:1200px){.container{padding-right:15px;padding-left:15px}}@media (min-width:576px){.container{width:540px;max-width:100%}}@media (min-width:768px){.container{width:720px;max-width:100%}}@media (min-width:992px){.container{width:960px;max-width:100%}}@media (min-width:1200px){.container{width:1140px;max-width:100%}}.container-fluid{position:relative;margin-left:auto;margin-right:auto;padding-right:15px;padding-left:15px}@media (min-width:576px){.container-fluid{padding-right:15px;padding-left:15px}}@media (min-width:768px){.container-fluid{padding-right:15px;padding-left:15px}}@media (min-width:992px){.container-fluid{padding-right:15px;padding-left:15px}}@media (min-width:1200px){.container-fluid{padding-right:15px;padding-left:15px}}.row{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:wrap;-ms-flex-wrap:wrap;flex-wrap:wrap;margin-right:-15px;margin-left:-15px}@media (min-width:576px){.row{margin-right:-15px;margin-left:-15px}}@media (min-width:768px){.row{margin-right:-15px;margin-left:-15px}}@media (min-width:992px){.row{margin-right:-15px;margin-left:-15px}}@media (min-width:1200px){.row{margin-right:-15px;margin-left:-15px}}.no-gutters{margin-right:0;margin-left:0}.no-gutters>.col,.no-gutters>[class*=col-]{padding-right:0;padding-left:0}.col,.col-1,.col-10,.col-11,.col-12,.col-2,.col-3,.col-4,.col-5,.col-6,.col-7,.col-8,.col-9,.col-lg,.col-lg-1,.col-lg-10,.col-lg-11,.col-lg-12,.col-lg-2,.col-lg-3,.col-lg-4,.col-lg-5,.col-lg-6,.col-lg-7,.col-lg-8,.col-lg-9,.col-md,.col-md-1,.col-md-10,.col-md-11,.col-md-12,.col-md-2,.col-md-3,.col-md-4,.col-md-5,.col-md-6,.col-md-7,.col-md-8,.col-md-9,.col-sm,.col-sm-1,.col-sm-10,.col-sm-11,.col-sm-12,.col-sm-2,.col-sm-3,.col-sm-4,.col-sm-5,.col-sm-6,.col-sm-7,.col-sm-8,.col-sm-9,.col-xl,.col-xl-1,.col-xl-10,.col-xl-11,.col-xl-12,.col-xl-2,.col-xl-3,.col-xl-4,.col-xl-5,.col-xl-6,.col-xl-7,.col-xl-8,.col-xl-9{position:relative;width:100%;min-height:1px;padding-right:15px;padding-left:15px}@media (min-width:576px){.col,.col-1,.col-10,.col-11,.col-12,.col-2,.col-3,.col-4,.col-5,.col-6,.col-7,.col-8,.col-9,.col-lg,.col-lg-1,.col-lg-10,.col-lg-11,.col-lg-12,.col-lg-2,.col-lg-3,.col-lg-4,.col-lg-5,.col-lg-6,.col-lg-7,.col-lg-8,.col-lg-9,.col-md,.col-md-1,.col-md-10,.col-md-11,.col-md-12,.col-md-2,.col-md-3,.col-md-4,.col-md-5,.col-md-6,.col-md-7,.col-md-8,.col-md-9,.col-sm,.col-sm-1,.col-sm-10,.col-sm-11,.col-sm-12,.col-sm-2,.col-sm-3,.col-sm-4,.col-sm-5,.col-sm-6,.col-sm-7,.col-sm-8,.col-sm-9,.col-xl,.col-xl-1,.col-xl-10,.col-xl-11,.col-xl-12,.col-xl-2,.col-xl-3,.col-xl-4,.col-xl-5,.col-xl-6,.col-xl-7,.col-xl-8,.col-xl-9{padding-right:15px;padding-left:15px}}@media (min-width:768px){.col,.col-1,.col-10,.col-11,.col-12,.col-2,.col-3,.col-4,.col-5,.col-6,.col-7,.col-8,.col-9,.col-lg,.col-lg-1,.col-lg-10,.col-lg-11,.col-lg-12,.col-lg-2,.col-lg-3,.col-lg-4,.col-lg-5,.col-lg-6,.col-lg-7,.col-lg-8,.col-lg-9,.col-md,.col-md-1,.col-md-10,.col-md-11,.col-md-12,.col-md-2,.col-md-3,.col-md-4,.col-md-5,.col-md-6,.col-md-7,.col-md-8,.col-md-9,.col-sm,.col-sm-1,.col-sm-10,.col-sm-11,.col-sm-12,.col-sm-2,.col-sm-3,.col-sm-4,.col-sm-5,.col-sm-6,.col-sm-7,.col-sm-8,.col-sm-9,.col-xl,.col-xl-1,.col-xl-10,.col-xl-11,.col-xl-12,.col-xl-2,.col-xl-3,.col-xl-4,.col-xl-5,.col-xl-6,.col-xl-7,.col-xl-8,.col-xl-9{padding-right:15px;padding-left:15px}}@media (min-width:992px){.col,.col-1,.col-10,.col-11,.col-12,.col-2,.col-3,.col-4,.col-5,.col-6,.col-7,.col-8,.col-9,.col-lg,.col-lg-1,.col-lg-10,.col-lg-11,.col-lg-12,.col-lg-2,.col-lg-3,.col-lg-4,.col-lg-5,.col-lg-6,.col-lg-7,.col-lg-8,.col-lg-9,.col-md,.col-md-1,.col-md-10,.col-md-11,.col-md-12,.col-md-2,.col-md-3,.col-md-4,.col-md-5,.col-md-6,.col-md-7,.col-md-8,.col-md-9,.col-sm,.col-sm-1,.col-sm-10,.col-sm-11,.col-sm-12,.col-sm-2,.col-sm-3,.col-sm-4,.col-sm-5,.col-sm-6,.col-sm-7,.col-sm-8,.col-sm-9,.col-xl,.col-xl-1,.col-xl-10,.col-xl-11,.col-xl-12,.col-xl-2,.col-xl-3,.col-xl-4,.col-xl-5,.col-xl-6,.col-xl-7,.col-xl-8,.col-xl-9{padding-right:15px;padding-left:15px}}@media (min-width:1200px){.col,.col-1,.col-10,.col-11,.col-12,.col-2,.col-3,.col-4,.col-5,.col-6,.col-7,.col-8,.col-9,.col-lg,.col-lg-1,.col-lg-10,.col-lg-11,.col-lg-12,.col-lg-2,.col-lg-3,.col-lg-4,.col-lg-5,.col-lg-6,.col-lg-7,.col-lg-8,.col-lg-9,.col-md,.col-md-1,.col-md-10,.col-md-11,.col-md-12,.col-md-2,.col-md-3,.col-md-4,.col-md-5,.col-md-6,.col-md-7,.col-md-8,.col-md-9,.col-sm,.col-sm-1,.col-sm-10,.col-sm-11,.col-sm-12,.col-sm-2,.col-sm-3,.col-sm-4,.col-sm-5,.col-sm-6,.col-sm-7,.col-sm-8,.col-sm-9,.col-xl,.col-xl-1,.col-xl-10,.col-xl-11,.col-xl-12,.col-xl-2,.col-xl-3,.col-xl-4,.col-xl-5,.col-xl-6,.col-xl-7,.col-xl-8,.col-xl-9{padding-right:15px;padding-left:15px}}.col{-webkit-flex-basis:0;-ms-flex-preferred-size:0;flex-basis:0;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;max-width:100%}.col-auto{-webkit-box-flex:0;-webkit-flex:0 0 auto;-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.col-1{-webkit-box-flex:0;-webkit-flex:0 0 8.333333%;-ms-flex:0 0 8.333333%;flex:0 0 8.333333%;max-width:8.333333%}.col-2{-webkit-box-flex:0;-webkit-flex:0 0 16.666667%;-ms-flex:0 0 16.666667%;flex:0 0 16.666667%;max-width:16.666667%}.col-3{-webkit-box-flex:0;-webkit-flex:0 0 25%;-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.col-4{-webkit-box-flex:0;-webkit-flex:0 0 33.333333%;-ms-flex:0 0 33.333333%;flex:0 0 33.333333%;max-width:33.333333%}.col-5{-webkit-box-flex:0;-webkit-flex:0 0 41.666667%;-ms-flex:0 0 41.666667%;flex:0 0 41.666667%;max-width:41.666667%}.col-6{-webkit-box-flex:0;-webkit-flex:0 0 50%;-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.col-7{-webkit-box-flex:0;-webkit-flex:0 0 58.333333%;-ms-flex:0 0 58.333333%;flex:0 0 58.333333%;max-width:58.333333%}.col-8{-webkit-box-flex:0;-webkit-flex:0 0 66.666667%;-ms-flex:0 0 66.666667%;flex:0 0 66.666667%;max-width:66.666667%}.col-9{-webkit-box-flex:0;-webkit-flex:0 0 75%;-ms-flex:0 0 75%;flex:0 0 75%;max-width:75%}.col-10{-webkit-box-flex:0;-webkit-flex:0 0 83.333333%;-ms-flex:0 0 83.333333%;flex:0 0 83.333333%;max-width:83.333333%}.col-11{-webkit-box-flex:0;-webkit-flex:0 0 91.666667%;-ms-flex:0 0 91.666667%;flex:0 0 91.666667%;max-width:91.666667%}.col-12{-webkit-box-flex:0;-webkit-flex:0 0 100%;-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.pull-0{right:auto}.pull-1{right:8.333333%}.pull-2{right:16.666667%}.pull-3{right:25%}.pull-4{right:33.333333%}.pull-5{right:41.666667%}.pull-6{right:50%}.pull-7{right:58.333333%}.pull-8{right:66.666667%}.pull-9{right:75%}.pull-10{right:83.333333%}.pull-11{right:91.666667%}.pull-12{right:100%}.push-0{left:auto}.push-1{left:8.333333%}.push-2{left:16.666667%}.push-3{left:25%}.push-4{left:33.333333%}.push-5{left:41.666667%}.push-6{left:50%}.push-7{left:58.333333%}.push-8{left:66.666667%}.push-9{left:75%}.push-10{left:83.333333%}.push-11{left:91.666667%}.push-12{left:100%}.offset-1{margin-left:8.333333%}.offset-2{margin-left:16.666667%}.offset-3{margin-left:25%}.offset-4{margin-left:33.333333%}.offset-5{margin-left:41.666667%}.offset-6{margin-left:50%}.offset-7{margin-left:58.333333%}.offset-8{margin-left:66.666667%}.offset-9{margin-left:75%}.offset-10{margin-left:83.333333%}.offset-11{margin-left:91.666667%}@media (min-width:576px){.col-sm{-webkit-flex-basis:0;-ms-flex-preferred-size:0;flex-basis:0;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;max-width:100%}.col-sm-auto{-webkit-box-flex:0;-webkit-flex:0 0 auto;-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.col-sm-1{-webkit-box-flex:0;-webkit-flex:0 0 8.333333%;-ms-flex:0 0 8.333333%;flex:0 0 8.333333%;max-width:8.333333%}.col-sm-2{-webkit-box-flex:0;-webkit-flex:0 0 16.666667%;-ms-flex:0 0 16.666667%;flex:0 0 16.666667%;max-width:16.666667%}.col-sm-3{-webkit-box-flex:0;-webkit-flex:0 0 25%;-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.col-sm-4{-webkit-box-flex:0;-webkit-flex:0 0 33.333333%;-ms-flex:0 0 33.333333%;flex:0 0 33.333333%;max-width:33.333333%}.col-sm-5{-webkit-box-flex:0;-webkit-flex:0 0 41.666667%;-ms-flex:0 0 41.666667%;flex:0 0 41.666667%;max-width:41.666667%}.col-sm-6{-webkit-box-flex:0;-webkit-flex:0 0 50%;-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.col-sm-7{-webkit-box-flex:0;-webkit-flex:0 0 58.333333%;-ms-flex:0 0 58.333333%;flex:0 0 58.333333%;max-width:58.333333%}.col-sm-8{-webkit-box-flex:0;-webkit-flex:0 0 66.666667%;-ms-flex:0 0 66.666667%;flex:0 0 66.666667%;max-width:66.666667%}.col-sm-9{-webkit-box-flex:0;-webkit-flex:0 0 75%;-ms-flex:0 0 75%;flex:0 0 75%;max-width:75%}.col-sm-10{-webkit-box-flex:0;-webkit-flex:0 0 83.333333%;-ms-flex:0 0 83.333333%;flex:0 0 83.333333%;max-width:83.333333%}.col-sm-11{-webkit-box-flex:0;-webkit-flex:0 0 91.666667%;-ms-flex:0 0 91.666667%;flex:0 0 91.666667%;max-width:91.666667%}.col-sm-12{-webkit-box-flex:0;-webkit-flex:0 0 100%;-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.pull-sm-0{right:auto}.pull-sm-1{right:8.333333%}.pull-sm-2{right:16.666667%}.pull-sm-3{right:25%}.pull-sm-4{right:33.333333%}.pull-sm-5{right:41.666667%}.pull-sm-6{right:50%}.pull-sm-7{right:58.333333%}.pull-sm-8{right:66.666667%}.pull-sm-9{right:75%}.pull-sm-10{right:83.333333%}.pull-sm-11{right:91.666667%}.pull-sm-12{right:100%}.push-sm-0{left:auto}.push-sm-1{left:8.333333%}.push-sm-2{left:16.666667%}.push-sm-3{left:25%}.push-sm-4{left:33.333333%}.push-sm-5{left:41.666667%}.push-sm-6{left:50%}.push-sm-7{left:58.333333%}.push-sm-8{left:66.666667%}.push-sm-9{left:75%}.push-sm-10{left:83.333333%}.push-sm-11{left:91.666667%}.push-sm-12{left:100%}.offset-sm-0{margin-left:0}.offset-sm-1{margin-left:8.333333%}.offset-sm-2{margin-left:16.666667%}.offset-sm-3{margin-left:25%}.offset-sm-4{margin-left:33.333333%}.offset-sm-5{margin-left:41.666667%}.offset-sm-6{margin-left:50%}.offset-sm-7{margin-left:58.333333%}.offset-sm-8{margin-left:66.666667%}.offset-sm-9{margin-left:75%}.offset-sm-10{margin-left:83.333333%}.offset-sm-11{margin-left:91.666667%}}@media (min-width:768px){.col-md{-webkit-flex-basis:0;-ms-flex-preferred-size:0;flex-basis:0;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;max-width:100%}.col-md-auto{-webkit-box-flex:0;-webkit-flex:0 0 auto;-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.col-md-1{-webkit-box-flex:0;-webkit-flex:0 0 8.333333%;-ms-flex:0 0 8.333333%;flex:0 0 8.333333%;max-width:8.333333%}.col-md-2{-webkit-box-flex:0;-webkit-flex:0 0 16.666667%;-ms-flex:0 0 16.666667%;flex:0 0 16.666667%;max-width:16.666667%}.col-md-3{-webkit-box-flex:0;-webkit-flex:0 0 25%;-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.col-md-4{-webkit-box-flex:0;-webkit-flex:0 0 33.333333%;-ms-flex:0 0 33.333333%;flex:0 0 33.333333%;max-width:33.333333%}.col-md-5{-webkit-box-flex:0;-webkit-flex:0 0 41.666667%;-ms-flex:0 0 41.666667%;flex:0 0 41.666667%;max-width:41.666667%}.col-md-6{-webkit-box-flex:0;-webkit-flex:0 0 50%;-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.col-md-7{-webkit-box-flex:0;-webkit-flex:0 0 58.333333%;-ms-flex:0 0 58.333333%;flex:0 0 58.333333%;max-width:58.333333%}.col-md-8{-webkit-box-flex:0;-webkit-flex:0 0 66.666667%;-ms-flex:0 0 66.666667%;flex:0 0 66.666667%;max-width:66.666667%}.col-md-9{-webkit-box-flex:0;-webkit-flex:0 0 75%;-ms-flex:0 0 75%;flex:0 0 75%;max-width:75%}.col-md-10{-webkit-box-flex:0;-webkit-flex:0 0 83.333333%;-ms-flex:0 0 83.333333%;flex:0 0 83.333333%;max-width:83.333333%}.col-md-11{-webkit-box-flex:0;-webkit-flex:0 0 91.666667%;-ms-flex:0 0 91.666667%;flex:0 0 91.666667%;max-width:91.666667%}.col-md-12{-webkit-box-flex:0;-webkit-flex:0 0 100%;-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.pull-md-0{right:auto}.pull-md-1{right:8.333333%}.pull-md-2{right:16.666667%}.pull-md-3{right:25%}.pull-md-4{right:33.333333%}.pull-md-5{right:41.666667%}.pull-md-6{right:50%}.pull-md-7{right:58.333333%}.pull-md-8{right:66.666667%}.pull-md-9{right:75%}.pull-md-10{right:83.333333%}.pull-md-11{right:91.666667%}.pull-md-12{right:100%}.push-md-0{left:auto}.push-md-1{left:8.333333%}.push-md-2{left:16.666667%}.push-md-3{left:25%}.push-md-4{left:33.333333%}.push-md-5{left:41.666667%}.push-md-6{left:50%}.push-md-7{left:58.333333%}.push-md-8{left:66.666667%}.push-md-9{left:75%}.push-md-10{left:83.333333%}.push-md-11{left:91.666667%}.push-md-12{left:100%}.offset-md-0{margin-left:0}.offset-md-1{margin-left:8.333333%}.offset-md-2{margin-left:16.666667%}.offset-md-3{margin-left:25%}.offset-md-4{margin-left:33.333333%}.offset-md-5{margin-left:41.666667%}.offset-md-6{margin-left:50%}.offset-md-7{margin-left:58.333333%}.offset-md-8{margin-left:66.666667%}.offset-md-9{margin-left:75%}.offset-md-10{margin-left:83.333333%}.offset-md-11{margin-left:91.666667%}}@media (min-width:992px){.col-lg{-webkit-flex-basis:0;-ms-flex-preferred-size:0;flex-basis:0;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;max-width:100%}.col-lg-auto{-webkit-box-flex:0;-webkit-flex:0 0 auto;-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.col-lg-1{-webkit-box-flex:0;-webkit-flex:0 0 8.333333%;-ms-flex:0 0 8.333333%;flex:0 0 8.333333%;max-width:8.333333%}.col-lg-2{-webkit-box-flex:0;-webkit-flex:0 0 16.666667%;-ms-flex:0 0 16.666667%;flex:0 0 16.666667%;max-width:16.666667%}.col-lg-3{-webkit-box-flex:0;-webkit-flex:0 0 25%;-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.col-lg-4{-webkit-box-flex:0;-webkit-flex:0 0 33.333333%;-ms-flex:0 0 33.333333%;flex:0 0 33.333333%;max-width:33.333333%}.col-lg-5{-webkit-box-flex:0;-webkit-flex:0 0 41.666667%;-ms-flex:0 0 41.666667%;flex:0 0 41.666667%;max-width:41.666667%}.col-lg-6{-webkit-box-flex:0;-webkit-flex:0 0 50%;-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.col-lg-7{-webkit-box-flex:0;-webkit-flex:0 0 58.333333%;-ms-flex:0 0 58.333333%;flex:0 0 58.333333%;max-width:58.333333%}.col-lg-8{-webkit-box-flex:0;-webkit-flex:0 0 66.666667%;-ms-flex:0 0 66.666667%;flex:0 0 66.666667%;max-width:66.666667%}.col-lg-9{-webkit-box-flex:0;-webkit-flex:0 0 75%;-ms-flex:0 0 75%;flex:0 0 75%;max-width:75%}.col-lg-10{-webkit-box-flex:0;-webkit-flex:0 0 83.333333%;-ms-flex:0 0 83.333333%;flex:0 0 83.333333%;max-width:83.333333%}.col-lg-11{-webkit-box-flex:0;-webkit-flex:0 0 91.666667%;-ms-flex:0 0 91.666667%;flex:0 0 91.666667%;max-width:91.666667%}.col-lg-12{-webkit-box-flex:0;-webkit-flex:0 0 100%;-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.pull-lg-0{right:auto}.pull-lg-1{right:8.333333%}.pull-lg-2{right:16.666667%}.pull-lg-3{right:25%}.pull-lg-4{right:33.333333%}.pull-lg-5{right:41.666667%}.pull-lg-6{right:50%}.pull-lg-7{right:58.333333%}.pull-lg-8{right:66.666667%}.pull-lg-9{right:75%}.pull-lg-10{right:83.333333%}.pull-lg-11{right:91.666667%}.pull-lg-12{right:100%}.push-lg-0{left:auto}.push-lg-1{left:8.333333%}.push-lg-2{left:16.666667%}.push-lg-3{left:25%}.push-lg-4{left:33.333333%}.push-lg-5{left:41.666667%}.push-lg-6{left:50%}.push-lg-7{left:58.333333%}.push-lg-8{left:66.666667%}.push-lg-9{left:75%}.push-lg-10{left:83.333333%}.push-lg-11{left:91.666667%}.push-lg-12{left:100%}.offset-lg-0{margin-left:0}.offset-lg-1{margin-left:8.333333%}.offset-lg-2{margin-left:16.666667%}.offset-lg-3{margin-left:25%}.offset-lg-4{margin-left:33.333333%}.offset-lg-5{margin-left:41.666667%}.offset-lg-6{margin-left:50%}.offset-lg-7{margin-left:58.333333%}.offset-lg-8{margin-left:66.666667%}.offset-lg-9{margin-left:75%}.offset-lg-10{margin-left:83.333333%}.offset-lg-11{margin-left:91.666667%}}@media (min-width:1200px){.col-xl{-webkit-flex-basis:0;-ms-flex-preferred-size:0;flex-basis:0;-webkit-box-flex:1;-webkit-flex-grow:1;-ms-flex-positive:1;flex-grow:1;max-width:100%}.col-xl-auto{-webkit-box-flex:0;-webkit-flex:0 0 auto;-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.col-xl-1{-webkit-box-flex:0;-webkit-flex:0 0 8.333333%;-ms-flex:0 0 8.333333%;flex:0 0 8.333333%;max-width:8.333333%}.col-xl-2{-webkit-box-flex:0;-webkit-flex:0 0 16.666667%;-ms-flex:0 0 16.666667%;flex:0 0 16.666667%;max-width:16.666667%}.col-xl-3{-webkit-box-flex:0;-webkit-flex:0 0 25%;-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.col-xl-4{-webkit-box-flex:0;-webkit-flex:0 0 33.333333%;-ms-flex:0 0 33.333333%;flex:0 0 33.333333%;max-width:33.333333%}.col-xl-5{-webkit-box-flex:0;-webkit-flex:0 0 41.666667%;-ms-flex:0 0 41.666667%;flex:0 0 41.666667%;max-width:41.666667%}.col-xl-6{-webkit-box-flex:0;-webkit-flex:0 0 50%;-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.col-xl-7{-webkit-box-flex:0;-webkit-flex:0 0 58.333333%;-ms-flex:0 0 58.333333%;flex:0 0 58.333333%;max-width:58.333333%}.col-xl-8{-webkit-box-flex:0;-webkit-flex:0 0 66.666667%;-ms-flex:0 0 66.666667%;flex:0 0 66.666667%;max-width:66.666667%}.col-xl-9{-webkit-box-flex:0;-webkit-flex:0 0 75%;-ms-flex:0 0 75%;flex:0 0 75%;max-width:75%}.col-xl-10{-webkit-box-flex:0;-webkit-flex:0 0 83.333333%;-ms-flex:0 0 83.333333%;flex:0 0 83.333333%;max-width:83.333333%}.col-xl-11{-webkit-box-flex:0;-webkit-flex:0 0 91.666667%;-ms-flex:0 0 91.666667%;flex:0 0 91.666667%;max-width:91.666667%}.col-xl-12{-webkit-box-flex:0;-webkit-flex:0 0 100%;-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.pull-xl-0{right:auto}.pull-xl-1{right:8.333333%}.pull-xl-2{right:16.666667%}.pull-xl-3{right:25%}.pull-xl-4{right:33.333333%}.pull-xl-5{right:41.666667%}.pull-xl-6{right:50%}.pull-xl-7{right:58.333333%}.pull-xl-8{right:66.666667%}.pull-xl-9{right:75%}.pull-xl-10{right:83.333333%}.pull-xl-11{right:91.666667%}.pull-xl-12{right:100%}.push-xl-0{left:auto}.push-xl-1{left:8.333333%}.push-xl-2{left:16.666667%}.push-xl-3{left:25%}.push-xl-4{left:33.333333%}.push-xl-5{left:41.666667%}.push-xl-6{left:50%}.push-xl-7{left:58.333333%}.push-xl-8{left:66.666667%}.push-xl-9{left:75%}.push-xl-10{left:83.333333%}.push-xl-11{left:91.666667%}.push-xl-12{left:100%}.offset-xl-0{margin-left:0}.offset-xl-1{margin-left:8.333333%}.offset-xl-2{margin-left:16.666667%}.offset-xl-3{margin-left:25%}.offset-xl-4{margin-left:33.333333%}.offset-xl-5{margin-left:41.666667%}.offset-xl-6{margin-left:50%}.offset-xl-7{margin-left:58.333333%}.offset-xl-8{margin-left:66.666667%}.offset-xl-9{margin-left:75%}.offset-xl-10{margin-left:83.333333%}.offset-xl-11{margin-left:91.666667%}}.table{width:100%;max-width:100%;margin-bottom:1rem}.table td,.table th{padding:.75rem;vertical-align:top;border-top:1px solid #eceeef}.table thead th{vertical-align:bottom;border-bottom:2px solid #eceeef}.table tbody+tbody{border-top:2px solid #eceeef}.table .table{background-color:#fff}.table-sm td,.table-sm th{padding:.3rem}.table-bordered{border:1px solid #eceeef}.table-bordered td,.table-bordered th{border:1px solid #eceeef}.table-bordered thead td,.table-bordered thead th{border-bottom-width:2px}.table-striped tbody tr:nth-of-type(odd){background-color:rgba(0,0,0,.05)}.table-hover tbody tr:hover{background-color:rgba(0,0,0,.075)}.table-active,.table-active>td,.table-active>th{background-color:rgba(0,0,0,.075)}.table-hover .table-active:hover{background-color:rgba(0,0,0,.075)}.table-hover .table-active:hover>td,.table-hover .table-active:hover>th{background-color:rgba(0,0,0,.075)}.table-success,.table-success>td,.table-success>th{background-color:#dff0d8}.table-hover .table-success:hover{background-color:#d0e9c6}.table-hover .table-success:hover>td,.table-hover .table-success:hover>th{background-color:#d0e9c6}.table-info,.table-info>td,.table-info>th{background-color:#d9edf7}.table-hover .table-info:hover{background-color:#c4e3f3}.table-hover .table-info:hover>td,.table-hover .table-info:hover>th{background-color:#c4e3f3}.table-warning,.table-warning>td,.table-warning>th{background-color:#fcf8e3}.table-hover .table-warning:hover{background-color:#faf2cc}.table-hover .table-warning:hover>td,.table-hover .table-warning:hover>th{background-color:#faf2cc}.table-danger,.table-danger>td,.table-danger>th{background-color:#f2dede}.table-hover .table-danger:hover{background-color:#ebcccc}.table-hover .table-danger:hover>td,.table-hover .table-danger:hover>th{background-color:#ebcccc}.thead-inverse th{color:#fff;background-color:#292b2c}.thead-default th{color:#464a4c;background-color:#eceeef}.table-inverse{color:#fff;background-color:#292b2c}.table-inverse td,.table-inverse th,.table-inverse thead th{border-color:#fff}.table-inverse.table-bordered{border:0}.table-responsive{display:block;width:100%;overflow-x:auto;-ms-overflow-style:-ms-autohiding-scrollbar}.table-responsive.table-bordered{border:0}.form-control{display:block;width:100%;padding:.5rem .75rem;font-size:1rem;line-height:1.25;color:#464a4c;background-color:#fff;background-image:none;-webkit-background-clip:padding-box;background-clip:padding-box;border:1px solid rgba(0,0,0,.15);border-radius:.25rem;-webkit-transition:border-color ease-in-out .15s,-webkit-box-shadow ease-in-out .15s;transition:border-color ease-in-out .15s,-webkit-box-shadow ease-in-out .15s;-o-transition:border-color ease-in-out .15s,box-shadow ease-in-out .15s;transition:border-color ease-in-out .15s,box-shadow ease-in-out .15s;transition:border-color ease-in-out .15s,box-shadow ease-in-out .15s,-webkit-box-shadow ease-in-out .15s}.form-control::-ms-expand{background-color:transparent;border:0}.form-control:focus{color:#464a4c;background-color:#fff;border-color:#5cb3fd;outline:0}.form-control::-webkit-input-placeholder{color:#636c72;opacity:1}.form-control::-moz-placeholder{color:#636c72;opacity:1}.form-control:-ms-input-placeholder{color:#636c72;opacity:1}.form-control::placeholder{color:#636c72;opacity:1}.form-control:disabled,.form-control[readonly]{background-color:#eceeef;opacity:1}.form-control:disabled{cursor:not-allowed}select.form-control:not([size]):not([multiple]){height:calc(2.25rem + 2px)}select.form-control:focus::-ms-value{color:#464a4c;background-color:#fff}.form-control-file,.form-control-range{display:block}.col-form-label{padding-top:calc(.5rem - 1px * 2);padding-bottom:calc(.5rem - 1px * 2);margin-bottom:0}.col-form-label-lg{padding-top:calc(.75rem - 1px * 2);padding-bottom:calc(.75rem - 1px * 2);font-size:1.25rem}.col-form-label-sm{padding-top:calc(.25rem - 1px * 2);padding-bottom:calc(.25rem - 1px * 2);font-size:.875rem}.col-form-legend{padding-top:.5rem;padding-bottom:.5rem;margin-bottom:0;font-size:1rem}.form-control-static{padding-top:.5rem;padding-bottom:.5rem;margin-bottom:0;line-height:1.25;border:solid transparent;border-width:1px 0}.form-control-static.form-control-lg,.form-control-static.form-control-sm,.input-group-lg>.form-control-static.form-control,.input-group-lg>.form-control-static.input-group-addon,.input-group-lg>.input-group-btn>.form-control-static.btn,.input-group-sm>.form-control-static.form-control,.input-group-sm>.form-control-static.input-group-addon,.input-group-sm>.input-group-btn>.form-control-static.btn{padding-right:0;padding-left:0}.form-control-sm,.input-group-sm>.form-control,.input-group-sm>.input-group-addon,.input-group-sm>.input-group-btn>.btn{padding:.25rem .5rem;font-size:.875rem;border-radius:.2rem}.input-group-sm>.input-group-btn>select.btn:not([size]):not([multiple]),.input-group-sm>select.form-control:not([size]):not([multiple]),.input-group-sm>select.input-group-addon:not([size]):not([multiple]),select.form-control-sm:not([size]):not([multiple]){height:1.8125rem}.form-control-lg,.input-group-lg>.form-control,.input-group-lg>.input-group-addon,.input-group-lg>.input-group-btn>.btn{padding:.75rem 1.5rem;font-size:1.25rem;border-radius:.3rem}.input-group-lg>.input-group-btn>select.btn:not([size]):not([multiple]),.input-group-lg>select.form-control:not([size]):not([multiple]),.input-group-lg>select.input-group-addon:not([size]):not([multiple]),select.form-control-lg:not([size]):not([multiple]){height:3.166667rem}.form-group{margin-bottom:1rem}.form-text{display:block;margin-top:.25rem}.form-check{position:relative;display:block;margin-bottom:.5rem}.form-check.disabled .form-check-label{color:#636c72;cursor:not-allowed}.form-check-label{padding-left:1.25rem;margin-bottom:0;cursor:pointer}.form-check-input{position:absolute;margin-top:.25rem;margin-left:-1.25rem}.form-check-input:only-child{position:static}.form-check-inline{display:inline-block}.form-check-inline .form-check-label{vertical-align:middle}.form-check-inline+.form-check-inline{margin-left:.75rem}.form-control-feedback{margin-top:.25rem}.form-control-danger,.form-control-success,.form-control-warning{padding-right:2.25rem;background-repeat:no-repeat;background-position:center right .5625rem;-webkit-background-size:1.125rem 1.125rem;background-size:1.125rem 1.125rem}.has-success .col-form-label,.has-success .custom-control,.has-success .form-check-label,.has-success .form-control-feedback,.has-success .form-control-label{color:#5cb85c}.has-success .form-control{border-color:#5cb85c}.has-success .input-group-addon{color:#5cb85c;border-color:#5cb85c;background-color:#eaf6ea}.has-success .form-control-success{background-image:url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 8 8'%3E%3Cpath fill='%235cb85c' d='M2.3 6.73L.6 4.53c-.4-1.04.46-1.4 1.1-.8l1.1 1.4 3.4-3.8c.6-.63 1.6-.27 1.2.7l-4 4.6c-.43.5-.8.4-1.1.1z'/%3E%3C/svg%3E")}.has-warning .col-form-label,.has-warning .custom-control,.has-warning .form-check-label,.has-warning .form-control-feedback,.has-warning .form-control-label{color:#f0ad4e}.has-warning .form-control{border-color:#f0ad4e}.has-warning .input-group-addon{color:#f0ad4e;border-color:#f0ad4e;background-color:#fff}.has-warning .form-control-warning{background-image:url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 8 8'%3E%3Cpath fill='%23f0ad4e' d='M4.4 5.324h-.8v-2.46h.8zm0 1.42h-.8V5.89h.8zM3.76.63L.04 7.075c-.115.2.016.425.26.426h7.397c.242 0 .372-.226.258-.426C6.726 4.924 5.47 2.79 4.253.63c-.113-.174-.39-.174-.494 0z'/%3E%3C/svg%3E")}.has-danger .col-form-label,.has-danger .custom-control,.has-danger .form-check-label,.has-danger .form-control-feedback,.has-danger .form-control-label{color:#d9534f}.has-danger .form-control{border-color:#d9534f}.has-danger .input-group-addon{color:#d9534f;border-color:#d9534f;background-color:#fdf7f7}.has-danger .form-control-danger{background-image:url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='%23d9534f' viewBox='-2 -2 7 7'%3E%3Cpath stroke='%23d9534f' d='M0 0l3 3m0-3L0 3'/%3E%3Ccircle r='.5'/%3E%3Ccircle cx='3' r='.5'/%3E%3Ccircle cy='3' r='.5'/%3E%3Ccircle cx='3' cy='3' r='.5'/%3E%3C/svg%3E")}.form-inline{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-flow:row wrap;-ms-flex-flow:row wrap;flex-flow:row wrap;-webkit-box-align:center;-webkit-align-items:center;-ms-flex-align:center;align-items:center}.form-inline .form-check{width:100%}@media (min-width:576px){.form-inline label{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-align:center;-webkit-align-items:center;-ms-flex-align:center;align-items:center;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;margin-bottom:0}.form-inline .form-group{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-flex:0;-webkit-flex:0 0 auto;-ms-flex:0 0 auto;flex:0 0 auto;-webkit-flex-flow:row wrap;-ms-flex-flow:row wrap;flex-flow:row wrap;-webkit-box-align:center;-webkit-align-items:center;-ms-flex-align:center;align-items:center;margin-bottom:0}.form-inline .form-control{display:inline-block;width:auto;vertical-align:middle}.form-inline .form-control-static{display:inline-block}.form-inline .input-group{width:auto}.form-inline .form-control-label{margin-bottom:0;vertical-align:middle}.form-inline .form-check{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-align:center;-webkit-align-items:center;-ms-flex-align:center;align-items:center;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;width:auto;margin-top:0;margin-bottom:0}.form-inline .form-check-label{padding-left:0}.form-inline .form-check-input{position:relative;margin-top:0;margin-right:.25rem;margin-left:0}.form-inline .custom-control{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-align:center;-webkit-align-items:center;-ms-flex-align:center;align-items:center;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;padding-left:0}.form-inline .custom-control-indicator{position:static;display:inline-block;margin-right:.25rem;vertical-align:text-bottom}.form-inline .has-feedback .form-control-feedback{top:0}}.btn{display:inline-block;font-weight:400;line-height:1.25;text-align:center;white-space:nowrap;vertical-align:middle;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;border:1px solid transparent;padding:.5rem 1rem;font-size:1rem;border-radius:.25rem;-webkit-transition:all .2s ease-in-out;-o-transition:all .2s ease-in-out;transition:all .2s ease-in-out}.btn:focus,.btn:hover{text-decoration:none}.btn.focus,.btn:focus{outline:0;-webkit-box-shadow:0 0 0 2px rgba(2,117,216,.25);box-shadow:0 0 0 2px rgba(2,117,216,.25)}.btn.disabled,.btn:disabled{cursor:not-allowed;opacity:.65}.btn.active,.btn:active{background-image:none}a.btn.disabled,fieldset[disabled] a.btn{pointer-events:none}.btn-primary{color:#fff;background-color:#0275d8;border-color:#0275d8}.btn-primary:hover{color:#fff;background-color:#025aa5;border-color:#01549b}.btn-primary.focus,.btn-primary:focus{-webkit-box-shadow:0 0 0 2px rgba(2,117,216,.5);box-shadow:0 0 0 2px rgba(2,117,216,.5)}.btn-primary.disabled,.btn-primary:disabled{background-color:#0275d8;border-color:#0275d8}.btn-primary.active,.btn-primary:active,.show>.btn-primary.dropdown-toggle{color:#fff;background-color:#025aa5;background-image:none;border-color:#01549b}.btn-secondary{color:#292b2c;background-color:#fff;border-color:#ccc}.btn-secondary:hover{color:#292b2c;background-color:#e6e6e6;border-color:#adadad}.btn-secondary.focus,.btn-secondary:focus{-webkit-box-shadow:0 0 0 2px rgba(204,204,204,.5);box-shadow:0 0 0 2px rgba(204,204,204,.5)}.btn-secondary.disabled,.btn-secondary:disabled{background-color:#fff;border-color:#ccc}.btn-secondary.active,.btn-secondary:active,.show>.btn-secondary.dropdown-toggle{color:#292b2c;background-color:#e6e6e6;background-image:none;border-color:#adadad}.btn-info{color:#fff;background-color:#5bc0de;border-color:#5bc0de}.btn-info:hover{color:#fff;background-color:#31b0d5;border-color:#2aabd2}.btn-info.focus,.btn-info:focus{-webkit-box-shadow:0 0 0 2px rgba(91,192,222,.5);box-shadow:0 0 0 2px rgba(91,192,222,.5)}.btn-info.disabled,.btn-info:disabled{background-color:#5bc0de;border-color:#5bc0de}.btn-info.active,.btn-info:active,.show>.btn-info.dropdown-toggle{color:#fff;background-color:#31b0d5;background-image:none;border-color:#2aabd2}.btn-success{color:#fff;background-color:#5cb85c;border-color:#5cb85c}.btn-success:hover{color:#fff;background-color:#449d44;border-color:#419641}.btn-success.focus,.btn-success:focus{-webkit-box-shadow:0 0 0 2px rgba(92,184,92,.5);box-shadow:0 0 0 2px rgba(92,184,92,.5)}.btn-success.disabled,.btn-success:disabled{background-color:#5cb85c;border-color:#5cb85c}.btn-success.active,.btn-success:active,.show>.btn-success.dropdown-toggle{color:#fff;background-color:#449d44;background-image:none;border-color:#419641}.btn-warning{color:#fff;background-color:#f0ad4e;border-color:#f0ad4e}.btn-warning:hover{color:#fff;background-color:#ec971f;border-color:#eb9316}.btn-warning.focus,.btn-warning:focus{-webkit-box-shadow:0 0 0 2px rgba(240,173,78,.5);box-shadow:0 0 0 2px rgba(240,173,78,.5)}.btn-warning.disabled,.btn-warning:disabled{background-color:#f0ad4e;border-color:#f0ad4e}.btn-warning.active,.btn-warning:active,.show>.btn-warning.dropdown-toggle{color:#fff;background-color:#ec971f;background-image:none;border-color:#eb9316}.btn-danger{color:#fff;background-color:#d9534f;border-color:#d9534f}.btn-danger:hover{color:#fff;background-color:#c9302c;border-color:#c12e2a}.btn-danger.focus,.btn-danger:focus{-webkit-box-shadow:0 0 0 2px rgba(217,83,79,.5);box-shadow:0 0 0 2px rgba(217,83,79,.5)}.btn-danger.disabled,.btn-danger:disabled{background-color:#d9534f;border-color:#d9534f}.btn-danger.active,.btn-danger:active,.show>.btn-danger.dropdown-toggle{color:#fff;background-color:#c9302c;background-image:none;border-color:#c12e2a}.btn-outline-primary{color:#0275d8;background-image:none;background-color:transparent;border-color:#0275d8}.btn-outline-primary:hover{color:#fff;background-color:#0275d8;border-color:#0275d8}.btn-outline-primary.focus,.btn-outline-primary:focus{-webkit-box-shadow:0 0 0 2px rgba(2,117,216,.5);box-shadow:0 0 0 2px rgba(2,117,216,.5)}.btn-outline-primary.disabled,.btn-outline-primary:disabled{color:#0275d8;background-color:transparent}.btn-outline-primary.active,.btn-outline-primary:active,.show>.btn-outline-primary.dropdown-toggle{color:#fff;background-color:#0275d8;border-color:#0275d8}.btn-outline-secondary{color:#ccc;background-image:none;background-color:transparent;border-color:#ccc}.btn-outline-secondary:hover{color:#fff;background-color:#ccc;border-color:#ccc}.btn-outline-secondary.focus,.btn-outline-secondary:focus{-webkit-box-shadow:0 0 0 2px rgba(204,204,204,.5);box-shadow:0 0 0 2px rgba(204,204,204,.5)}.btn-outline-secondary.disabled,.btn-outline-secondary:disabled{color:#ccc;background-color:transparent}.btn-outline-secondary.active,.btn-outline-secondary:active,.show>.btn-outline-secondary.dropdown-toggle{color:#fff;background-color:#ccc;border-color:#ccc}.btn-outline-info{color:#5bc0de;background-image:none;background-color:transparent;border-color:#5bc0de}.btn-outline-info:hover{color:#fff;background-color:#5bc0de;border-color:#5bc0de}.btn-outline-info.focus,.btn-outline-info:focus{-webkit-box-shadow:0 0 0 2px rgba(91,192,222,.5);box-shadow:0 0 0 2px rgba(91,192,222,.5)}.btn-outline-info.disabled,.btn-outline-info:disabled{color:#5bc0de;background-color:transparent}.btn-outline-info.active,.btn-outline-info:active,.show>.btn-outline-info.dropdown-toggle{color:#fff;background-color:#5bc0de;border-color:#5bc0de}.btn-outline-success{color:#5cb85c;background-image:none;background-color:transparent;border-color:#5cb85c}.btn-outline-success:hover{color:#fff;background-color:#5cb85c;border-color:#5cb85c}.btn-outline-success.focus,.btn-outline-success:focus{-webkit-box-shadow:0 0 0 2px rgba(92,184,92,.5);box-shadow:0 0 0 2px rgba(92,184,92,.5)}.btn-outline-success.disabled,.btn-outline-success:disabled{color:#5cb85c;background-color:transparent}.btn-outline-success.active,.btn-outline-success:active,.show>.btn-outline-success.dropdown-toggle{color:#fff;background-color:#5cb85c;border-color:#5cb85c}.btn-outline-warning{color:#f0ad4e;background-image:none;background-color:transparent;border-color:#f0ad4e}.btn-outline-warning:hover{color:#fff;background-color:#f0ad4e;border-color:#f0ad4e}.btn-outline-warning.focus,.btn-outline-warning:focus{-webkit-box-shadow:0 0 0 2px rgba(240,173,78,.5);box-shadow:0 0 0 2px rgba(240,173,78,.5)}.btn-outline-warning.disabled,.btn-outline-warning:disabled{color:#f0ad4e;background-color:transparent}.btn-outline-warning.active,.btn-outline-warning:active,.show>.btn-outline-warning.dropdown-toggle{color:#fff;background-color:#f0ad4e;border-color:#f0ad4e}.btn-outline-danger{color:#d9534f;background-image:none;background-color:transparent;border-color:#d9534f}.btn-outline-danger:hover{color:#fff;background-color:#d9534f;border-color:#d9534f}.btn-outline-danger.focus,.btn-outline-danger:focus{-webkit-box-shadow:0 0 0 2px rgba(217,83,79,.5);box-shadow:0 0 0 2px rgba(217,83,79,.5)}.btn-outline-danger.disabled,.btn-outline-danger:disabled{color:#d9534f;background-color:transparent}.btn-outline-danger.active,.btn-outline-danger:active,.show>.btn-outline-danger.dropdown-toggle{color:#fff;background-color:#d9534f;border-color:#d9534f}.btn-link{font-weight:400;color:#0275d8;border-radius:0}.btn-link,.btn-link.active,.btn-link:active,.btn-link:disabled{background-color:transparent}.btn-link,.btn-link:active,.btn-link:focus{border-color:transparent}.btn-link:hover{border-color:transparent}.btn-link:focus,.btn-link:hover{color:#014c8c;text-decoration:underline;background-color:transparent}.btn-link:disabled{color:#636c72}.btn-link:disabled:focus,.btn-link:disabled:hover{text-decoration:none}.btn-group-lg>.btn,.btn-lg{padding:.75rem 1.5rem;font-size:1.25rem;border-radius:.3rem}.btn-group-sm>.btn,.btn-sm{padding:.25rem .5rem;font-size:.875rem;border-radius:.2rem}.btn-block{display:block;width:100%}.btn-block+.btn-block{margin-top:.5rem}input[type=button].btn-block,input[type=reset].btn-block,input[type=submit].btn-block{width:100%}.fade{opacity:0;-webkit-transition:opacity .15s linear;-o-transition:opacity .15s linear;transition:opacity .15s linear}.fade.show{opacity:1}.collapse{display:none}.collapse.show{display:block}tr.collapse.show{display:table-row}tbody.collapse.show{display:table-row-group}.collapsing{position:relative;height:0;overflow:hidden;-webkit-transition:height .35s ease;-o-transition:height .35s ease;transition:height .35s ease}.dropdown,.dropup{position:relative}.dropdown-toggle::after{display:inline-block;width:0;height:0;margin-left:.3em;vertical-align:middle;content:"";border-top:.3em solid;border-right:.3em solid transparent;border-left:.3em solid transparent}.dropdown-toggle:focus{outline:0}.dropup .dropdown-toggle::after{border-top:0;border-bottom:.3em solid}.dropdown-menu{position:absolute;top:100%;left:0;z-index:1000;display:none;float:left;min-width:10rem;padding:.5rem 0;margin:.125rem 0 0;font-size:1rem;color:#292b2c;text-align:left;list-style:none;background-color:#fff;-webkit-background-clip:padding-box;background-clip:padding-box;border:1px solid rgba(0,0,0,.15);border-radius:.25rem}.dropdown-divider{height:1px;margin:.5rem 0;overflow:hidden;background-color:#eceeef}.dropdown-item{display:block;width:100%;padding:3px 1.5rem;clear:both;font-weight:400;color:#292b2c;text-align:inherit;white-space:nowrap;background:0 0;border:0}.dropdown-item:focus,.dropdown-item:hover{color:#1d1e1f;text-decoration:none;background-color:#f7f7f9}.dropdown-item.active,.dropdown-item:active{color:#fff;text-decoration:none;background-color:#0275d8}.dropdown-item.disabled,.dropdown-item:disabled{color:#636c72;cursor:not-allowed;background-color:transparent}.show>.dropdown-menu{display:block}.show>a{outline:0}.dropdown-menu-right{right:0;left:auto}.dropdown-menu-left{right:auto;left:0}.dropdown-header{display:block;padding:.5rem 1.5rem;margin-bottom:0;font-size:.875rem;color:#636c72;white-space:nowrap}.dropdown-backdrop{position:fixed;top:0;right:0;bottom:0;left:0;z-index:990}.dropup .dropdown-menu{top:auto;bottom:100%;margin-bottom:.125rem}.btn-group,.btn-group-vertical{position:relative;display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;vertical-align:middle}.btn-group-vertical>.btn,.btn-group>.btn{position:relative;-webkit-box-flex:0;-webkit-flex:0 1 auto;-ms-flex:0 1 auto;flex:0 1 auto}.btn-group-vertical>.btn:hover,.btn-group>.btn:hover{z-index:2}.btn-group-vertical>.btn.active,.btn-group-vertical>.btn:active,.btn-group-vertical>.btn:focus,.btn-group>.btn.active,.btn-group>.btn:active,.btn-group>.btn:focus{z-index:2}.btn-group .btn+.btn,.btn-group .btn+.btn-group,.btn-group .btn-group+.btn,.btn-group .btn-group+.btn-group,.btn-group-vertical .btn+.btn,.btn-group-vertical .btn+.btn-group,.btn-group-vertical .btn-group+.btn,.btn-group-vertical .btn-group+.btn-group{margin-left:-1px}.btn-toolbar{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:start;-webkit-justify-content:flex-start;-ms-flex-pack:start;justify-content:flex-start}.btn-toolbar .input-group{width:auto}.btn-group>.btn:not(:first-child):not(:last-child):not(.dropdown-toggle){border-radius:0}.btn-group>.btn:first-child{margin-left:0}.btn-group>.btn:first-child:not(:last-child):not(.dropdown-toggle){border-bottom-right-radius:0;border-top-right-radius:0}.btn-group>.btn:last-child:not(:first-child),.btn-group>.dropdown-toggle:not(:first-child){border-bottom-left-radius:0;border-top-left-radius:0}.btn-group>.btn-group{float:left}.btn-group>.btn-group:not(:first-child):not(:last-child)>.btn{border-radius:0}.btn-group>.btn-group:first-child:not(:last-child)>.btn:last-child,.btn-group>.btn-group:first-child:not(:last-child)>.dropdown-toggle{border-bottom-right-radius:0;border-top-right-radius:0}.btn-group>.btn-group:last-child:not(:first-child)>.btn:first-child{border-bottom-left-radius:0;border-top-left-radius:0}.btn-group .dropdown-toggle:active,.btn-group.open .dropdown-toggle{outline:0}.btn+.dropdown-toggle-split{padding-right:.75rem;padding-left:.75rem}.btn+.dropdown-toggle-split::after{margin-left:0}.btn-group-sm>.btn+.dropdown-toggle-split,.btn-sm+.dropdown-toggle-split{padding-right:.375rem;padding-left:.375rem}.btn-group-lg>.btn+.dropdown-toggle-split,.btn-lg+.dropdown-toggle-split{padding-right:1.125rem;padding-left:1.125rem}.btn-group-vertical{display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;-webkit-box-orient:vertical;-webkit-box-direction:normal;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;-webkit-box-align:start;-webkit-align-items:flex-start;-ms-flex-align:start;align-items:flex-start;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center}.btn-group-vertical .btn,.btn-group-vertical .btn-group{width:100%}.btn-group-vertical>.btn+.btn,.btn-group-vertical>.btn+.btn-group,.btn-group-vertical>.btn-group+.btn,.btn-group-vertical>.btn-group+.btn-group{margin-top:-1px;margin-left:0}.btn-group-vertical>.btn:not(:first-child):not(:last-child){border-radius:0}.btn-group-vertical>.btn:first-child:not(:last-child){border-bottom-right-radius:0;border-bottom-left-radius:0}.btn-group-vertical>.btn:last-child:not(:first-child){border-top-right-radius:0;border-top-left-radius:0}.btn-group-vertical>.btn-group:not(:first-child):not(:last-child)>.btn{border-radius:0}.btn-group-vertical>.btn-group:first-child:not(:last-child)>.btn:last-child,.btn-group-vertical>.btn-group:first-child:not(:last-child)>.dropdown-toggle{border-bottom-right-radius:0;border-bottom-left-radius:0}.btn-group-vertical>.btn-group:last-child:not(:first-child)>.btn:first-child{border-top-right-radius:0;border-top-left-radius:0}[data-toggle=buttons]>.btn input[type=checkbox],[data-toggle=buttons]>.btn input[type=radio],[data-toggle=buttons]>.btn-group>.btn input[type=checkbox],[data-toggle=buttons]>.btn-group>.btn input[type=radio]{position:absolute;clip:rect(0,0,0,0);pointer-events:none}.input-group{position:relative;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;width:100%}.input-group .form-control{position:relative;z-index:2;-webkit-box-flex:1;-webkit-flex:1 1 auto;-ms-flex:1 1 auto;flex:1 1 auto;width:1%;margin-bottom:0}.input-group .form-control:active,.input-group .form-control:focus,.input-group .form-control:hover{z-index:3}.input-group .form-control,.input-group-addon,.input-group-btn{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-orient:vertical;-webkit-box-direction:normal;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center}.input-group .form-control:not(:first-child):not(:last-child),.input-group-addon:not(:first-child):not(:last-child),.input-group-btn:not(:first-child):not(:last-child){border-radius:0}.input-group-addon,.input-group-btn{white-space:nowrap;vertical-align:middle}.input-group-addon{padding:.5rem .75rem;margin-bottom:0;font-size:1rem;font-weight:400;line-height:1.25;color:#464a4c;text-align:center;background-color:#eceeef;border:1px solid rgba(0,0,0,.15);border-radius:.25rem}.input-group-addon.form-control-sm,.input-group-sm>.input-group-addon,.input-group-sm>.input-group-btn>.input-group-addon.btn{padding:.25rem .5rem;font-size:.875rem;border-radius:.2rem}.input-group-addon.form-control-lg,.input-group-lg>.input-group-addon,.input-group-lg>.input-group-btn>.input-group-addon.btn{padding:.75rem 1.5rem;font-size:1.25rem;border-radius:.3rem}.input-group-addon input[type=checkbox],.input-group-addon input[type=radio]{margin-top:0}.input-group .form-control:not(:last-child),.input-group-addon:not(:last-child),.input-group-btn:not(:first-child)>.btn-group:not(:last-child)>.btn,.input-group-btn:not(:first-child)>.btn:not(:last-child):not(.dropdown-toggle),.input-group-btn:not(:last-child)>.btn,.input-group-btn:not(:last-child)>.btn-group>.btn,.input-group-btn:not(:last-child)>.dropdown-toggle{border-bottom-right-radius:0;border-top-right-radius:0}.input-group-addon:not(:last-child){border-right:0}.input-group .form-control:not(:first-child),.input-group-addon:not(:first-child),.input-group-btn:not(:first-child)>.btn,.input-group-btn:not(:first-child)>.btn-group>.btn,.input-group-btn:not(:first-child)>.dropdown-toggle,.input-group-btn:not(:last-child)>.btn-group:not(:first-child)>.btn,.input-group-btn:not(:last-child)>.btn:not(:first-child){border-bottom-left-radius:0;border-top-left-radius:0}.form-control+.input-group-addon:not(:first-child){border-left:0}.input-group-btn{position:relative;font-size:0;white-space:nowrap}.input-group-btn>.btn{position:relative;-webkit-box-flex:1;-webkit-flex:1 1 0%;-ms-flex:1 1 0%;flex:1 1 0%}.input-group-btn>.btn+.btn{margin-left:-1px}.input-group-btn>.btn:active,.input-group-btn>.btn:focus,.input-group-btn>.btn:hover{z-index:3}.input-group-btn:not(:last-child)>.btn,.input-group-btn:not(:last-child)>.btn-group{margin-right:-1px}.input-group-btn:not(:first-child)>.btn,.input-group-btn:not(:first-child)>.btn-group{z-index:2;margin-left:-1px}.input-group-btn:not(:first-child)>.btn-group:active,.input-group-btn:not(:first-child)>.btn-group:focus,.input-group-btn:not(:first-child)>.btn-group:hover,.input-group-btn:not(:first-child)>.btn:active,.input-group-btn:not(:first-child)>.btn:focus,.input-group-btn:not(:first-child)>.btn:hover{z-index:3}.custom-control{position:relative;display:-webkit-inline-box;display:-webkit-inline-flex;display:-ms-inline-flexbox;display:inline-flex;min-height:1.5rem;padding-left:1.5rem;margin-right:1rem;cursor:pointer}.custom-control-input{position:absolute;z-index:-1;opacity:0}.custom-control-input:checked~.custom-control-indicator{color:#fff;background-color:#0275d8}.custom-control-input:focus~.custom-control-indicator{-webkit-box-shadow:0 0 0 1px #fff,0 0 0 3px #0275d8;box-shadow:0 0 0 1px #fff,0 0 0 3px #0275d8}.custom-control-input:active~.custom-control-indicator{color:#fff;background-color:#8fcafe}.custom-control-input:disabled~.custom-control-indicator{cursor:not-allowed;background-color:#eceeef}.custom-control-input:disabled~.custom-control-description{color:#636c72;cursor:not-allowed}.custom-control-indicator{position:absolute;top:.25rem;left:0;display:block;width:1rem;height:1rem;pointer-events:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;background-color:#ddd;background-repeat:no-repeat;background-position:center center;-webkit-background-size:50% 50%;background-size:50% 50%}.custom-checkbox .custom-control-indicator{border-radius:.25rem}.custom-checkbox .custom-control-input:checked~.custom-control-indicator{background-image:url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 8 8'%3E%3Cpath fill='%23fff' d='M6.564.75l-3.59 3.612-1.538-1.55L0 4.26 2.974 7.25 8 2.193z'/%3E%3C/svg%3E")}.custom-checkbox .custom-control-input:indeterminate~.custom-control-indicator{background-color:#0275d8;background-image:url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 4 4'%3E%3Cpath stroke='%23fff' d='M0 2h4'/%3E%3C/svg%3E")}.custom-radio .custom-control-indicator{border-radius:50%}.custom-radio .custom-control-input:checked~.custom-control-indicator{background-image:url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3E%3Ccircle r='3' fill='%23fff'/%3E%3C/svg%3E")}.custom-controls-stacked{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-orient:vertical;-webkit-box-direction:normal;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column}.custom-controls-stacked .custom-control{margin-bottom:.25rem}.custom-controls-stacked .custom-control+.custom-control{margin-left:0}.custom-select{display:inline-block;max-width:100%;height:calc(2.25rem + 2px);padding:.375rem 1.75rem .375rem .75rem;line-height:1.25;color:#464a4c;vertical-align:middle;background:#fff url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 4 5'%3E%3Cpath fill='%23333' d='M2 0L0 2h4zm0 5L0 3h4z'/%3E%3C/svg%3E") no-repeat right .75rem center;-webkit-background-size:8px 10px;background-size:8px 10px;border:1px solid rgba(0,0,0,.15);border-radius:.25rem;-moz-appearance:none;-webkit-appearance:none}.custom-select:focus{border-color:#5cb3fd;outline:0}.custom-select:focus::-ms-value{color:#464a4c;background-color:#fff}.custom-select:disabled{color:#636c72;cursor:not-allowed;background-color:#eceeef}.custom-select::-ms-expand{opacity:0}.custom-select-sm{padding-top:.375rem;padding-bottom:.375rem;font-size:75%}.custom-file{position:relative;display:inline-block;max-width:100%;height:2.5rem;margin-bottom:0;cursor:pointer}.custom-file-input{min-width:14rem;max-width:100%;height:2.5rem;margin:0;filter:alpha(opacity=0);opacity:0}.custom-file-control{position:absolute;top:0;right:0;left:0;z-index:5;height:2.5rem;padding:.5rem 1rem;line-height:1.5;color:#464a4c;pointer-events:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;background-color:#fff;border:1px solid rgba(0,0,0,.15);border-radius:.25rem}.custom-file-control:lang(en)::after{content:"Choose file..."}.custom-file-control::before{position:absolute;top:-1px;right:-1px;bottom:-1px;z-index:6;display:block;height:2.5rem;padding:.5rem 1rem;line-height:1.5;color:#464a4c;background-color:#eceeef;border:1px solid rgba(0,0,0,.15);border-radius:0 .25rem .25rem 0}.custom-file-control:lang(en)::before{content:"Browse"}.nav{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;padding-left:0;margin-bottom:0;list-style:none}.nav-link{display:block;padding:.5em 1em}.nav-link:focus,.nav-link:hover{text-decoration:none}.nav-link.disabled{color:#636c72;cursor:not-allowed}.nav-tabs{border-bottom:1px solid #ddd}.nav-tabs .nav-item{margin-bottom:-1px}.nav-tabs .nav-link{border:1px solid transparent;border-top-right-radius:.25rem;border-top-left-radius:.25rem}.nav-tabs .nav-link:focus,.nav-tabs .nav-link:hover{border-color:#eceeef #eceeef #ddd}.nav-tabs .nav-link.disabled{color:#636c72;background-color:transparent;border-color:transparent}.nav-tabs .nav-item.show .nav-link,.nav-tabs .nav-link.active{color:#464a4c;background-color:#fff;border-color:#ddd #ddd #fff}.nav-tabs .dropdown-menu{margin-top:-1px;border-top-right-radius:0;border-top-left-radius:0}.nav-pills .nav-link{border-radius:.25rem}.nav-pills .nav-item.show .nav-link,.nav-pills .nav-link.active{color:#fff;cursor:default;background-color:#0275d8}.nav-fill .nav-item{-webkit-box-flex:1;-webkit-flex:1 1 auto;-ms-flex:1 1 auto;flex:1 1 auto;text-align:center}.nav-justified .nav-item{-webkit-box-flex:1;-webkit-flex:1 1 100%;-ms-flex:1 1 100%;flex:1 1 100%;text-align:center}.tab-content>.tab-pane{display:none}.tab-content>.active{display:block}.navbar{position:relative;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-orient:vertical;-webkit-box-direction:normal;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;padding:.5rem 1rem}.navbar-brand{display:inline-block;padding-top:.25rem;padding-bottom:.25rem;margin-right:1rem;font-size:1.25rem;line-height:inherit;white-space:nowrap}.navbar-brand:focus,.navbar-brand:hover{text-decoration:none}.navbar-nav{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-orient:vertical;-webkit-box-direction:normal;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;padding-left:0;margin-bottom:0;list-style:none}.navbar-nav .nav-link{padding-right:0;padding-left:0}.navbar-text{display:inline-block;padding-top:.425rem;padding-bottom:.425rem}.navbar-toggler{-webkit-align-self:flex-start;-ms-flex-item-align:start;align-self:flex-start;padding:.25rem .75rem;font-size:1.25rem;line-height:1;background:0 0;border:1px solid transparent;border-radius:.25rem}.navbar-toggler:focus,.navbar-toggler:hover{text-decoration:none}.navbar-toggler-icon{display:inline-block;width:1.5em;height:1.5em;vertical-align:middle;content:"";background:no-repeat center center;-webkit-background-size:100% 100%;background-size:100% 100%}.navbar-toggler-left{position:absolute;left:1rem}.navbar-toggler-right{position:absolute;right:1rem}@media (max-width:575px){.navbar-toggleable .navbar-nav .dropdown-menu{position:static;float:none}.navbar-toggleable>.container{padding-right:0;padding-left:0}}@media (min-width:576px){.navbar-toggleable{-webkit-box-orient:horizontal;-webkit-box-direction:normal;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-flex-wrap:nowrap;-ms-flex-wrap:nowrap;flex-wrap:nowrap;-webkit-box-align:center;-webkit-align-items:center;-ms-flex-align:center;align-items:center}.navbar-toggleable .navbar-nav{-webkit-box-orient:horizontal;-webkit-box-direction:normal;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row}.navbar-toggleable .navbar-nav .nav-link{padding-right:.5rem;padding-left:.5rem}.navbar-toggleable>.container{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:nowrap;-ms-flex-wrap:nowrap;flex-wrap:nowrap;-webkit-box-align:center;-webkit-align-items:center;-ms-flex-align:center;align-items:center}.navbar-toggleable .navbar-collapse{display:-webkit-box!important;display:-webkit-flex!important;display:-ms-flexbox!important;display:flex!important;width:100%}.navbar-toggleable .navbar-toggler{display:none}}@media (max-width:767px){.navbar-toggleable-sm .navbar-nav .dropdown-menu{position:static;float:none}.navbar-toggleable-sm>.container{padding-right:0;padding-left:0}}@media (min-width:768px){.navbar-toggleable-sm{-webkit-box-orient:horizontal;-webkit-box-direction:normal;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-flex-wrap:nowrap;-ms-flex-wrap:nowrap;flex-wrap:nowrap;-webkit-box-align:center;-webkit-align-items:center;-ms-flex-align:center;align-items:center}.navbar-toggleable-sm .navbar-nav{-webkit-box-orient:horizontal;-webkit-box-direction:normal;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row}.navbar-toggleable-sm .navbar-nav .nav-link{padding-right:.5rem;padding-left:.5rem}.navbar-toggleable-sm>.container{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:nowrap;-ms-flex-wrap:nowrap;flex-wrap:nowrap;-webkit-box-align:center;-webkit-align-items:center;-ms-flex-align:center;align-items:center}.navbar-toggleable-sm .navbar-collapse{display:-webkit-box!important;display:-webkit-flex!important;display:-ms-flexbox!important;display:flex!important;width:100%}.navbar-toggleable-sm .navbar-toggler{display:none}}@media (max-width:991px){.navbar-toggleable-md .navbar-nav .dropdown-menu{position:static;float:none}.navbar-toggleable-md>.container{padding-right:0;padding-left:0}}@media (min-width:992px){.navbar-toggleable-md{-webkit-box-orient:horizontal;-webkit-box-direction:normal;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-flex-wrap:nowrap;-ms-flex-wrap:nowrap;flex-wrap:nowrap;-webkit-box-align:center;-webkit-align-items:center;-ms-flex-align:center;align-items:center}.navbar-toggleable-md .navbar-nav{-webkit-box-orient:horizontal;-webkit-box-direction:normal;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row}.navbar-toggleable-md .navbar-nav .nav-link{padding-right:.5rem;padding-left:.5rem}.navbar-toggleable-md>.container{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:nowrap;-ms-flex-wrap:nowrap;flex-wrap:nowrap;-webkit-box-align:center;-webkit-align-items:center;-ms-flex-align:center;align-items:center}.navbar-toggleable-md .navbar-collapse{display:-webkit-box!important;display:-webkit-flex!important;display:-ms-flexbox!important;display:flex!important;width:100%}.navbar-toggleable-md .navbar-toggler{display:none}}@media (max-width:1199px){.navbar-toggleable-lg .navbar-nav .dropdown-menu{position:static;float:none}.navbar-toggleable-lg>.container{padding-right:0;padding-left:0}}@media (min-width:1200px){.navbar-toggleable-lg{-webkit-box-orient:horizontal;-webkit-box-direction:normal;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-flex-wrap:nowrap;-ms-flex-wrap:nowrap;flex-wrap:nowrap;-webkit-box-align:center;-webkit-align-items:center;-ms-flex-align:center;align-items:center}.navbar-toggleable-lg .navbar-nav{-webkit-box-orient:horizontal;-webkit-box-direction:normal;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row}.navbar-toggleable-lg .navbar-nav .nav-link{padding-right:.5rem;padding-left:.5rem}.navbar-toggleable-lg>.container{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:nowrap;-ms-flex-wrap:nowrap;flex-wrap:nowrap;-webkit-box-align:center;-webkit-align-items:center;-ms-flex-align:center;align-items:center}.navbar-toggleable-lg .navbar-collapse{display:-webkit-box!important;display:-webkit-flex!important;display:-ms-flexbox!important;display:flex!important;width:100%}.navbar-toggleable-lg .navbar-toggler{display:none}}.navbar-toggleable-xl{-webkit-box-orient:horizontal;-webkit-box-direction:normal;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row;-webkit-flex-wrap:nowrap;-ms-flex-wrap:nowrap;flex-wrap:nowrap;-webkit-box-align:center;-webkit-align-items:center;-ms-flex-align:center;align-items:center}.navbar-toggleable-xl .navbar-nav .dropdown-menu{position:static;float:none}.navbar-toggleable-xl>.container{padding-right:0;padding-left:0}.navbar-toggleable-xl .navbar-nav{-webkit-box-orient:horizontal;-webkit-box-direction:normal;-webkit-flex-direction:row;-ms-flex-direction:row;flex-direction:row}.navbar-toggleable-xl .navbar-nav .nav-link{padding-right:.5rem;padding-left:.5rem}.navbar-toggleable-xl>.container{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-wrap:nowrap;-ms-flex-wrap:nowrap;flex-wrap:nowrap;-webkit-box-align:center;-webkit-align-items:center;-ms-flex-align:center;align-items:center}.navbar-toggleable-xl .navbar-collapse{display:-webkit-box!important;display:-webkit-flex!important;display:-ms-flexbox!important;display:flex!important;width:100%}.navbar-toggleable-xl .navbar-toggler{display:none}.navbar-light .navbar-brand,.navbar-light .navbar-toggler{color:rgba(0,0,0,.9)}.navbar-light .navbar-brand:focus,.navbar-light .navbar-brand:hover,.navbar-light .navbar-toggler:focus,.navbar-light .navbar-toggler:hover{color:rgba(0,0,0,.9)}.navbar-light .navbar-nav .nav-link{color:rgba(0,0,0,.5)}.navbar-light .navbar-nav .nav-link:focus,.navbar-light .navbar-nav .nav-link:hover{color:rgba(0,0,0,.7)}.navbar-light .navbar-nav .nav-link.disabled{color:rgba(0,0,0,.3)}.navbar-light .navbar-nav .active>.nav-link,.navbar-light .navbar-nav .nav-link.active,.navbar-light .navbar-nav .nav-link.open,.navbar-light .navbar-nav .open>.nav-link{color:rgba(0,0,0,.9)}.navbar-light .navbar-toggler{border-color:rgba(0,0,0,.1)}.navbar-light .navbar-toggler-icon{background-image:url("data:image/svg+xml;charset=utf8,%3Csvg viewBox='0 0 32 32' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath stroke='rgba(0, 0, 0, 0.5)' stroke-width='2' stroke-linecap='round' stroke-miterlimit='10' d='M4 8h24M4 16h24M4 24h24'/%3E%3C/svg%3E")}.navbar-light .navbar-text{color:rgba(0,0,0,.5)}.navbar-inverse .navbar-brand,.navbar-inverse .navbar-toggler{color:#fff}.navbar-inverse .navbar-brand:focus,.navbar-inverse .navbar-brand:hover,.navbar-inverse .navbar-toggler:focus,.navbar-inverse .navbar-toggler:hover{color:#fff}.navbar-inverse .navbar-nav .nav-link{color:rgba(255,255,255,.5)}.navbar-inverse .navbar-nav .nav-link:focus,.navbar-inverse .navbar-nav .nav-link:hover{color:rgba(255,255,255,.75)}.navbar-inverse .navbar-nav .nav-link.disabled{color:rgba(255,255,255,.25)}.navbar-inverse .navbar-nav .active>.nav-link,.navbar-inverse .navbar-nav .nav-link.active,.navbar-inverse .navbar-nav .nav-link.open,.navbar-inverse .navbar-nav .open>.nav-link{color:#fff}.navbar-inverse .navbar-toggler{border-color:rgba(255,255,255,.1)}.navbar-inverse .navbar-toggler-icon{background-image:url("data:image/svg+xml;charset=utf8,%3Csvg viewBox='0 0 32 32' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath stroke='rgba(255, 255, 255, 0.5)' stroke-width='2' stroke-linecap='round' stroke-miterlimit='10' d='M4 8h24M4 16h24M4 24h24'/%3E%3C/svg%3E")}.navbar-inverse .navbar-text{color:rgba(255,255,255,.5)}.card{position:relative;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-orient:vertical;-webkit-box-direction:normal;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;background-color:#fff;border:1px solid rgba(0,0,0,.125);border-radius:.25rem}.card-block{-webkit-box-flex:1;-webkit-flex:1 1 auto;-ms-flex:1 1 auto;flex:1 1 auto;padding:1.25rem}.card-title{margin-bottom:.75rem}.card-subtitle{margin-top:-.375rem;margin-bottom:0}.card-text:last-child{margin-bottom:0}.card-link:hover{text-decoration:none}.card-link+.card-link{margin-left:1.25rem}.card>.list-group:first-child .list-group-item:first-child{border-top-right-radius:.25rem;border-top-left-radius:.25rem}.card>.list-group:last-child .list-group-item:last-child{border-bottom-right-radius:.25rem;border-bottom-left-radius:.25rem}.card-header{padding:.75rem 1.25rem;margin-bottom:0;background-color:#f7f7f9;border-bottom:1px solid rgba(0,0,0,.125)}.card-header:first-child{border-radius:calc(.25rem - 1px) calc(.25rem - 1px) 0 0}.card-footer{padding:.75rem 1.25rem;background-color:#f7f7f9;border-top:1px solid rgba(0,0,0,.125)}.card-footer:last-child{border-radius:0 0 calc(.25rem - 1px) calc(.25rem - 1px)}.card-header-tabs{margin-right:-.625rem;margin-bottom:-.75rem;margin-left:-.625rem;border-bottom:0}.card-header-pills{margin-right:-.625rem;margin-left:-.625rem}.card-primary{background-color:#0275d8;border-color:#0275d8}.card-primary .card-footer,.card-primary .card-header{background-color:transparent}.card-success{background-color:#5cb85c;border-color:#5cb85c}.card-success .card-footer,.card-success .card-header{background-color:transparent}.card-info{background-color:#5bc0de;border-color:#5bc0de}.card-info .card-footer,.card-info .card-header{background-color:transparent}.card-warning{background-color:#f0ad4e;border-color:#f0ad4e}.card-warning .card-footer,.card-warning .card-header{background-color:transparent}.card-danger{background-color:#d9534f;border-color:#d9534f}.card-danger .card-footer,.card-danger .card-header{background-color:transparent}.card-outline-primary{background-color:transparent;border-color:#0275d8}.card-outline-secondary{background-color:transparent;border-color:#ccc}.card-outline-info{background-color:transparent;border-color:#5bc0de}.card-outline-success{background-color:transparent;border-color:#5cb85c}.card-outline-warning{background-color:transparent;border-color:#f0ad4e}.card-outline-danger{background-color:transparent;border-color:#d9534f}.card-inverse{color:rgba(255,255,255,.65)}.card-inverse .card-footer,.card-inverse .card-header{background-color:transparent;border-color:rgba(255,255,255,.2)}.card-inverse .card-blockquote,.card-inverse .card-footer,.card-inverse .card-header,.card-inverse .card-title{color:#fff}.card-inverse .card-blockquote .blockquote-footer,.card-inverse .card-link,.card-inverse .card-subtitle,.card-inverse .card-text{color:rgba(255,255,255,.65)}.card-inverse .card-link:focus,.card-inverse .card-link:hover{color:#fff}.card-blockquote{padding:0;margin-bottom:0;border-left:0}.card-img{border-radius:calc(.25rem - 1px)}.card-img-overlay{position:absolute;top:0;right:0;bottom:0;left:0;padding:1.25rem}.card-img-top{border-top-right-radius:calc(.25rem - 1px);border-top-left-radius:calc(.25rem - 1px)}.card-img-bottom{border-bottom-right-radius:calc(.25rem - 1px);border-bottom-left-radius:calc(.25rem - 1px)}@media (min-width:576px){.card-deck{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-flow:row wrap;-ms-flex-flow:row wrap;flex-flow:row wrap}.card-deck .card{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-flex:1;-webkit-flex:1 0 0%;-ms-flex:1 0 0%;flex:1 0 0%;-webkit-box-orient:vertical;-webkit-box-direction:normal;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column}.card-deck .card:not(:first-child){margin-left:15px}.card-deck .card:not(:last-child){margin-right:15px}}@media (min-width:576px){.card-group{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-flow:row wrap;-ms-flex-flow:row wrap;flex-flow:row wrap}.card-group .card{-webkit-box-flex:1;-webkit-flex:1 0 0%;-ms-flex:1 0 0%;flex:1 0 0%}.card-group .card+.card{margin-left:0;border-left:0}.card-group .card:first-child{border-bottom-right-radius:0;border-top-right-radius:0}.card-group .card:first-child .card-img-top{border-top-right-radius:0}.card-group .card:first-child .card-img-bottom{border-bottom-right-radius:0}.card-group .card:last-child{border-bottom-left-radius:0;border-top-left-radius:0}.card-group .card:last-child .card-img-top{border-top-left-radius:0}.card-group .card:last-child .card-img-bottom{border-bottom-left-radius:0}.card-group .card:not(:first-child):not(:last-child){border-radius:0}.card-group .card:not(:first-child):not(:last-child) .card-img-bottom,.card-group .card:not(:first-child):not(:last-child) .card-img-top{border-radius:0}}@media (min-width:576px){.card-columns{-webkit-column-count:3;-moz-column-count:3;column-count:3;-webkit-column-gap:1.25rem;-moz-column-gap:1.25rem;column-gap:1.25rem}.card-columns .card{display:inline-block;width:100%;margin-bottom:.75rem}}.breadcrumb{padding:.75rem 1rem;margin-bottom:1rem;list-style:none;background-color:#eceeef;border-radius:.25rem}.breadcrumb::after{display:block;content:"";clear:both}.breadcrumb-item{float:left}.breadcrumb-item+.breadcrumb-item::before{display:inline-block;padding-right:.5rem;padding-left:.5rem;color:#636c72;content:"/"}.breadcrumb-item+.breadcrumb-item:hover::before{text-decoration:underline}.breadcrumb-item+.breadcrumb-item:hover::before{text-decoration:none}.breadcrumb-item.active{color:#636c72}.pagination{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;padding-left:0;list-style:none;border-radius:.25rem}.page-item:first-child .page-link{margin-left:0;border-bottom-left-radius:.25rem;border-top-left-radius:.25rem}.page-item:last-child .page-link{border-bottom-right-radius:.25rem;border-top-right-radius:.25rem}.page-item.active .page-link{z-index:2;color:#fff;background-color:#0275d8;border-color:#0275d8}.page-item.disabled .page-link{color:#636c72;pointer-events:none;cursor:not-allowed;background-color:#fff;border-color:#ddd}.page-link{position:relative;display:block;padding:.5rem .75rem;margin-left:-1px;line-height:1.25;color:#0275d8;background-color:#fff;border:1px solid #ddd}.page-link:focus,.page-link:hover{color:#014c8c;text-decoration:none;background-color:#eceeef;border-color:#ddd}.pagination-lg .page-link{padding:.75rem 1.5rem;font-size:1.25rem}.pagination-lg .page-item:first-child .page-link{border-bottom-left-radius:.3rem;border-top-left-radius:.3rem}.pagination-lg .page-item:last-child .page-link{border-bottom-right-radius:.3rem;border-top-right-radius:.3rem}.pagination-sm .page-link{padding:.25rem .5rem;font-size:.875rem}.pagination-sm .page-item:first-child .page-link{border-bottom-left-radius:.2rem;border-top-left-radius:.2rem}.pagination-sm .page-item:last-child .page-link{border-bottom-right-radius:.2rem;border-top-right-radius:.2rem}.badge{display:inline-block;padding:.25em .4em;font-size:75%;font-weight:700;line-height:1;color:#fff;text-align:center;white-space:nowrap;vertical-align:baseline;border-radius:.25rem}.badge:empty{display:none}.btn .badge{position:relative;top:-1px}a.badge:focus,a.badge:hover{color:#fff;text-decoration:none;cursor:pointer}.badge-pill{padding-right:.6em;padding-left:.6em;border-radius:10rem}.badge-default{background-color:#636c72}.badge-default[href]:focus,.badge-default[href]:hover{background-color:#4b5257}.badge-primary{background-color:#0275d8}.badge-primary[href]:focus,.badge-primary[href]:hover{background-color:#025aa5}.badge-success{background-color:#5cb85c}.badge-success[href]:focus,.badge-success[href]:hover{background-color:#449d44}.badge-info{background-color:#5bc0de}.badge-info[href]:focus,.badge-info[href]:hover{background-color:#31b0d5}.badge-warning{background-color:#f0ad4e}.badge-warning[href]:focus,.badge-warning[href]:hover{background-color:#ec971f}.badge-danger{background-color:#d9534f}.badge-danger[href]:focus,.badge-danger[href]:hover{background-color:#c9302c}.jumbotron{padding:2rem 1rem;margin-bottom:2rem;background-color:#eceeef;border-radius:.3rem}@media (min-width:576px){.jumbotron{padding:4rem 2rem}}.jumbotron-hr{border-top-color:#d0d5d8}.jumbotron-fluid{padding-right:0;padding-left:0;border-radius:0}.alert{padding:.75rem 1.25rem;margin-bottom:1rem;border:1px solid transparent;border-radius:.25rem}.alert-heading{color:inherit}.alert-link{font-weight:700}.alert-dismissible .close{position:relative;top:-.75rem;right:-1.25rem;padding:.75rem 1.25rem;color:inherit}.alert-success{background-color:#dff0d8;border-color:#d0e9c6;color:#3c763d}.alert-success hr{border-top-color:#c1e2b3}.alert-success .alert-link{color:#2b542c}.alert-info{background-color:#d9edf7;border-color:#bcdff1;color:#31708f}.alert-info hr{border-top-color:#a6d5ec}.alert-info .alert-link{color:#245269}.alert-warning{background-color:#fcf8e3;border-color:#faf2cc;color:#8a6d3b}.alert-warning hr{border-top-color:#f7ecb5}.alert-warning .alert-link{color:#66512c}.alert-danger{background-color:#f2dede;border-color:#ebcccc;color:#a94442}.alert-danger hr{border-top-color:#e4b9b9}.alert-danger .alert-link{color:#843534}@-webkit-keyframes progress-bar-stripes{from{background-position:1rem 0}to{background-position:0 0}}@-o-keyframes progress-bar-stripes{from{background-position:1rem 0}to{background-position:0 0}}@keyframes progress-bar-stripes{from{background-position:1rem 0}to{background-position:0 0}}.progress{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;overflow:hidden;font-size:.75rem;line-height:1rem;text-align:center;background-color:#eceeef;border-radius:.25rem}.progress-bar{height:1rem;color:#fff;background-color:#0275d8}.progress-bar-striped{background-image:-webkit-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:-o-linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);-webkit-background-size:1rem 1rem;background-size:1rem 1rem}.progress-bar-animated{-webkit-animation:progress-bar-stripes 1s linear infinite;-o-animation:progress-bar-stripes 1s linear infinite;animation:progress-bar-stripes 1s linear infinite}.media{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-align:start;-webkit-align-items:flex-start;-ms-flex-align:start;align-items:flex-start}.media-body{-webkit-box-flex:1;-webkit-flex:1 1 0%;-ms-flex:1 1 0%;flex:1 1 0%}.list-group{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-orient:vertical;-webkit-box-direction:normal;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;padding-left:0;margin-bottom:0}.list-group-item-action{width:100%;color:#464a4c;text-align:inherit}.list-group-item-action .list-group-item-heading{color:#292b2c}.list-group-item-action:focus,.list-group-item-action:hover{color:#464a4c;text-decoration:none;background-color:#f7f7f9}.list-group-item-action:active{color:#292b2c;background-color:#eceeef}.list-group-item{position:relative;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-flex-flow:row wrap;-ms-flex-flow:row wrap;flex-flow:row wrap;-webkit-box-align:center;-webkit-align-items:center;-ms-flex-align:center;align-items:center;padding:.75rem 1.25rem;margin-bottom:-1px;background-color:#fff;border:1px solid rgba(0,0,0,.125)}.list-group-item:first-child{border-top-right-radius:.25rem;border-top-left-radius:.25rem}.list-group-item:last-child{margin-bottom:0;border-bottom-right-radius:.25rem;border-bottom-left-radius:.25rem}.list-group-item:focus,.list-group-item:hover{text-decoration:none}.list-group-item.disabled,.list-group-item:disabled{color:#636c72;cursor:not-allowed;background-color:#fff}.list-group-item.disabled .list-group-item-heading,.list-group-item:disabled .list-group-item-heading{color:inherit}.list-group-item.disabled .list-group-item-text,.list-group-item:disabled .list-group-item-text{color:#636c72}.list-group-item.active{z-index:2;color:#fff;background-color:#0275d8;border-color:#0275d8}.list-group-item.active .list-group-item-heading,.list-group-item.active .list-group-item-heading>.small,.list-group-item.active .list-group-item-heading>small{color:inherit}.list-group-item.active .list-group-item-text{color:#daeeff}.list-group-flush .list-group-item{border-right:0;border-left:0;border-radius:0}.list-group-flush:first-child .list-group-item:first-child{border-top:0}.list-group-flush:last-child .list-group-item:last-child{border-bottom:0}.list-group-item-success{color:#3c763d;background-color:#dff0d8}a.list-group-item-success,button.list-group-item-success{color:#3c763d}a.list-group-item-success .list-group-item-heading,button.list-group-item-success .list-group-item-heading{color:inherit}a.list-group-item-success:focus,a.list-group-item-success:hover,button.list-group-item-success:focus,button.list-group-item-success:hover{color:#3c763d;background-color:#d0e9c6}a.list-group-item-success.active,button.list-group-item-success.active{color:#fff;background-color:#3c763d;border-color:#3c763d}.list-group-item-info{color:#31708f;background-color:#d9edf7}a.list-group-item-info,button.list-group-item-info{color:#31708f}a.list-group-item-info .list-group-item-heading,button.list-group-item-info .list-group-item-heading{color:inherit}a.list-group-item-info:focus,a.list-group-item-info:hover,button.list-group-item-info:focus,button.list-group-item-info:hover{color:#31708f;background-color:#c4e3f3}a.list-group-item-info.active,button.list-group-item-info.active{color:#fff;background-color:#31708f;border-color:#31708f}.list-group-item-warning{color:#8a6d3b;background-color:#fcf8e3}a.list-group-item-warning,button.list-group-item-warning{color:#8a6d3b}a.list-group-item-warning .list-group-item-heading,button.list-group-item-warning .list-group-item-heading{color:inherit}a.list-group-item-warning:focus,a.list-group-item-warning:hover,button.list-group-item-warning:focus,button.list-group-item-warning:hover{color:#8a6d3b;background-color:#faf2cc}a.list-group-item-warning.active,button.list-group-item-warning.active{color:#fff;background-color:#8a6d3b;border-color:#8a6d3b}.list-group-item-danger{color:#a94442;background-color:#f2dede}a.list-group-item-danger,button.list-group-item-danger{color:#a94442}a.list-group-item-danger .list-group-item-heading,button.list-group-item-danger .list-group-item-heading{color:inherit}a.list-group-item-danger:focus,a.list-group-item-danger:hover,button.list-group-item-danger:focus,button.list-group-item-danger:hover{color:#a94442;background-color:#ebcccc}a.list-group-item-danger.active,button.list-group-item-danger.active{color:#fff;background-color:#a94442;border-color:#a94442}.embed-responsive{position:relative;display:block;width:100%;padding:0;overflow:hidden}.embed-responsive::before{display:block;content:""}.embed-responsive .embed-responsive-item,.embed-responsive embed,.embed-responsive iframe,.embed-responsive object,.embed-responsive video{position:absolute;top:0;bottom:0;left:0;width:100%;height:100%;border:0}.embed-responsive-21by9::before{padding-top:42.857143%}.embed-responsive-16by9::before{padding-top:56.25%}.embed-responsive-4by3::before{padding-top:75%}.embed-responsive-1by1::before{padding-top:100%}.close{float:right;font-size:1.5rem;font-weight:700;line-height:1;color:#000;text-shadow:0 1px 0 #fff;opacity:.5}.close:focus,.close:hover{color:#000;text-decoration:none;cursor:pointer;opacity:.75}button.close{padding:0;cursor:pointer;background:0 0;border:0;-webkit-appearance:none}.modal-open{overflow:hidden}.modal{position:fixed;top:0;right:0;bottom:0;left:0;z-index:1050;display:none;overflow:hidden;outline:0}.modal.fade .modal-dialog{-webkit-transition:-webkit-transform .3s ease-out;transition:-webkit-transform .3s ease-out;-o-transition:-o-transform .3s ease-out;transition:transform .3s ease-out;transition:transform .3s ease-out,-webkit-transform .3s ease-out,-o-transform .3s ease-out;-webkit-transform:translate(0,-25%);-o-transform:translate(0,-25%);transform:translate(0,-25%)}.modal.show .modal-dialog{-webkit-transform:translate(0,0);-o-transform:translate(0,0);transform:translate(0,0)}.modal-open .modal{overflow-x:hidden;overflow-y:auto}.modal-dialog{position:relative;width:auto;margin:10px}.modal-content{position:relative;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-orient:vertical;-webkit-box-direction:normal;-webkit-flex-direction:column;-ms-flex-direction:column;flex-direction:column;background-color:#fff;-webkit-background-clip:padding-box;background-clip:padding-box;border:1px solid rgba(0,0,0,.2);border-radius:.3rem;outline:0}.modal-backdrop{position:fixed;top:0;right:0;bottom:0;left:0;z-index:1040;background-color:#000}.modal-backdrop.fade{opacity:0}.modal-backdrop.show{opacity:.5}.modal-header{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-align:center;-webkit-align-items:center;-ms-flex-align:center;align-items:center;-webkit-box-pack:justify;-webkit-justify-content:space-between;-ms-flex-pack:justify;justify-content:space-between;padding:15px;border-bottom:1px solid #eceeef}.modal-title{margin-bottom:0;line-height:1.5}.modal-body{position:relative;-webkit-box-flex:1;-webkit-flex:1 1 auto;-ms-flex:1 1 auto;flex:1 1 auto;padding:15px}.modal-footer{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-align:center;-webkit-align-items:center;-ms-flex-align:center;align-items:center;-webkit-box-pack:end;-webkit-justify-content:flex-end;-ms-flex-pack:end;justify-content:flex-end;padding:15px;border-top:1px solid #eceeef}.modal-footer>:not(:first-child){margin-left:.25rem}.modal-footer>:not(:last-child){margin-right:.25rem}.modal-scrollbar-measure{position:absolute;top:-9999px;width:50px;height:50px;overflow:scroll}@media (min-width:576px){.modal-dialog{max-width:500px;margin:30px auto}.modal-sm{max-width:300px}}@media (min-width:992px){.modal-lg{max-width:800px}}.tooltip{position:absolute;z-index:1070;display:block;font-family:-apple-system,system-ui,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,sans-serif;font-style:normal;font-weight:400;letter-spacing:normal;line-break:auto;line-height:1.5;text-align:left;text-align:start;text-decoration:none;text-shadow:none;text-transform:none;white-space:normal;word-break:normal;word-spacing:normal;font-size:.875rem;word-wrap:break-word;opacity:0}.tooltip.show{opacity:.9}.tooltip.bs-tether-element-attached-bottom,.tooltip.tooltip-top{padding:5px 0;margin-top:-3px}.tooltip.bs-tether-element-attached-bottom .tooltip-inner::before,.tooltip.tooltip-top .tooltip-inner::before{bottom:0;left:50%;margin-left:-5px;content:"";border-width:5px 5px 0;border-top-color:#000}.tooltip.bs-tether-element-attached-left,.tooltip.tooltip-right{padding:0 5px;margin-left:3px}.tooltip.bs-tether-element-attached-left .tooltip-inner::before,.tooltip.tooltip-right .tooltip-inner::before{top:50%;left:0;margin-top:-5px;content:"";border-width:5px 5px 5px 0;border-right-color:#000}.tooltip.bs-tether-element-attached-top,.tooltip.tooltip-bottom{padding:5px 0;margin-top:3px}.tooltip.bs-tether-element-attached-top .tooltip-inner::before,.tooltip.tooltip-bottom .tooltip-inner::before{top:0;left:50%;margin-left:-5px;content:"";border-width:0 5px 5px;border-bottom-color:#000}.tooltip.bs-tether-element-attached-right,.tooltip.tooltip-left{padding:0 5px;margin-left:-3px}.tooltip.bs-tether-element-attached-right .tooltip-inner::before,.tooltip.tooltip-left .tooltip-inner::before{top:50%;right:0;margin-top:-5px;content:"";border-width:5px 0 5px 5px;border-left-color:#000}.tooltip-inner{max-width:200px;padding:3px 8px;color:#fff;text-align:center;background-color:#000;border-radius:.25rem}.tooltip-inner::before{position:absolute;width:0;height:0;border-color:transparent;border-style:solid}.popover{position:absolute;top:0;left:0;z-index:1060;display:block;max-width:276px;padding:1px;font-family:-apple-system,system-ui,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,sans-serif;font-style:normal;font-weight:400;letter-spacing:normal;line-break:auto;line-height:1.5;text-align:left;text-align:start;text-decoration:none;text-shadow:none;text-transform:none;white-space:normal;word-break:normal;word-spacing:normal;font-size:.875rem;word-wrap:break-word;background-color:#fff;-webkit-background-clip:padding-box;background-clip:padding-box;border:1px solid rgba(0,0,0,.2);border-radius:.3rem}.popover.bs-tether-element-attached-bottom,.popover.popover-top{margin-top:-10px}.popover.bs-tether-element-attached-bottom::after,.popover.bs-tether-element-attached-bottom::before,.popover.popover-top::after,.popover.popover-top::before{left:50%;border-bottom-width:0}.popover.bs-tether-element-attached-bottom::before,.popover.popover-top::before{bottom:-11px;margin-left:-11px;border-top-color:rgba(0,0,0,.25)}.popover.bs-tether-element-attached-bottom::after,.popover.popover-top::after{bottom:-10px;margin-left:-10px;border-top-color:#fff}.popover.bs-tether-element-attached-left,.popover.popover-right{margin-left:10px}.popover.bs-tether-element-attached-left::after,.popover.bs-tether-element-attached-left::before,.popover.popover-right::after,.popover.popover-right::before{top:50%;border-left-width:0}.popover.bs-tether-element-attached-left::before,.popover.popover-right::before{left:-11px;margin-top:-11px;border-right-color:rgba(0,0,0,.25)}.popover.bs-tether-element-attached-left::after,.popover.popover-right::after{left:-10px;margin-top:-10px;border-right-color:#fff}.popover.bs-tether-element-attached-top,.popover.popover-bottom{margin-top:10px}.popover.bs-tether-element-attached-top::after,.popover.bs-tether-element-attached-top::before,.popover.popover-bottom::after,.popover.popover-bottom::before{left:50%;border-top-width:0}.popover.bs-tether-element-attached-top::before,.popover.popover-bottom::before{top:-11px;margin-left:-11px;border-bottom-color:rgba(0,0,0,.25)}.popover.bs-tether-element-attached-top::after,.popover.popover-bottom::after{top:-10px;margin-left:-10px;border-bottom-color:#f7f7f7}.popover.bs-tether-element-attached-top .popover-title::before,.popover.popover-bottom .popover-title::before{position:absolute;top:0;left:50%;display:block;width:20px;margin-left:-10px;content:"";border-bottom:1px solid #f7f7f7}.popover.bs-tether-element-attached-right,.popover.popover-left{margin-left:-10px}.popover.bs-tether-element-attached-right::after,.popover.bs-tether-element-attached-right::before,.popover.popover-left::after,.popover.popover-left::before{top:50%;border-right-width:0}.popover.bs-tether-element-attached-right::before,.popover.popover-left::before{right:-11px;margin-top:-11px;border-left-color:rgba(0,0,0,.25)}.popover.bs-tether-element-attached-right::after,.popover.popover-left::after{right:-10px;margin-top:-10px;border-left-color:#fff}.popover-title{padding:8px 14px;margin-bottom:0;font-size:1rem;background-color:#f7f7f7;border-bottom:1px solid #ebebeb;border-top-right-radius:calc(.3rem - 1px);border-top-left-radius:calc(.3rem - 1px)}.popover-title:empty{display:none}.popover-content{padding:9px 14px}.popover::after,.popover::before{position:absolute;display:block;width:0;height:0;border-color:transparent;border-style:solid}.popover::before{content:"";border-width:11px}.popover::after{content:"";border-width:10px}.carousel{position:relative}.carousel-inner{position:relative;width:100%;overflow:hidden}.carousel-item{position:relative;display:none;width:100%}@media (-webkit-transform-3d){.carousel-item{-webkit-transition:-webkit-transform .6s ease-in-out;transition:-webkit-transform .6s ease-in-out;-o-transition:-o-transform .6s ease-in-out;transition:transform .6s ease-in-out;transition:transform .6s ease-in-out,-webkit-transform .6s ease-in-out,-o-transform .6s ease-in-out;-webkit-backface-visibility:hidden;backface-visibility:hidden;-webkit-perspective:1000px;perspective:1000px}}@supports ((-webkit-transform:translate3d(0,0,0)) or (transform:translate3d(0,0,0))){.carousel-item{-webkit-transition:-webkit-transform .6s ease-in-out;transition:-webkit-transform .6s ease-in-out;-o-transition:-o-transform .6s ease-in-out;transition:transform .6s ease-in-out;transition:transform .6s ease-in-out,-webkit-transform .6s ease-in-out,-o-transform .6s ease-in-out;-webkit-backface-visibility:hidden;backface-visibility:hidden;-webkit-perspective:1000px;perspective:1000px}}.carousel-item-next,.carousel-item-prev,.carousel-item.active{display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex}.carousel-item-next,.carousel-item-prev{position:absolute;top:0}@media (-webkit-transform-3d){.carousel-item-next.carousel-item-left,.carousel-item-prev.carousel-item-right{-webkit-transform:translate3d(0,0,0);transform:translate3d(0,0,0)}.active.carousel-item-right,.carousel-item-next{-webkit-transform:translate3d(100%,0,0);transform:translate3d(100%,0,0)}.active.carousel-item-left,.carousel-item-prev{-webkit-transform:translate3d(-100%,0,0);transform:translate3d(-100%,0,0)}}@supports ((-webkit-transform:translate3d(0,0,0)) or (transform:translate3d(0,0,0))){.carousel-item-next.carousel-item-left,.carousel-item-prev.carousel-item-right{-webkit-transform:translate3d(0,0,0);transform:translate3d(0,0,0)}.active.carousel-item-right,.carousel-item-next{-webkit-transform:translate3d(100%,0,0);transform:translate3d(100%,0,0)}.active.carousel-item-left,.carousel-item-prev{-webkit-transform:translate3d(-100%,0,0);transform:translate3d(-100%,0,0)}}.carousel-control-next,.carousel-control-prev{position:absolute;top:0;bottom:0;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-align:center;-webkit-align-items:center;-ms-flex-align:center;align-items:center;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;width:15%;color:#fff;text-align:center;opacity:.5}.carousel-control-next:focus,.carousel-control-next:hover,.carousel-control-prev:focus,.carousel-control-prev:hover{color:#fff;text-decoration:none;outline:0;opacity:.9}.carousel-control-prev{left:0}.carousel-control-next{right:0}.carousel-control-next-icon,.carousel-control-prev-icon{display:inline-block;width:20px;height:20px;background:transparent no-repeat center center;-webkit-background-size:100% 100%;background-size:100% 100%}.carousel-control-prev-icon{background-image:url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='%23fff' viewBox='0 0 8 8'%3E%3Cpath d='M4 0l-4 4 4 4 1.5-1.5-2.5-2.5 2.5-2.5-1.5-1.5z'/%3E%3C/svg%3E")}.carousel-control-next-icon{background-image:url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='%23fff' viewBox='0 0 8 8'%3E%3Cpath d='M1.5 0l-1.5 1.5 2.5 2.5-2.5 2.5 1.5 1.5 4-4-4-4z'/%3E%3C/svg%3E")}.carousel-indicators{position:absolute;right:0;bottom:10px;left:0;z-index:15;display:-webkit-box;display:-webkit-flex;display:-ms-flexbox;display:flex;-webkit-box-pack:center;-webkit-justify-content:center;-ms-flex-pack:center;justify-content:center;padding-left:0;margin-right:15%;margin-left:15%;list-style:none}.carousel-indicators li{position:relative;-webkit-box-flex:1;-webkit-flex:1 0 auto;-ms-flex:1 0 auto;flex:1 0 auto;max-width:30px;height:3px;margin-right:3px;margin-left:3px;text-indent:-999px;cursor:pointer;background-color:rgba(255,255,255,.5)}.carousel-indicators li::before{position:absolute;top:-10px;left:0;display:inline-block;width:100%;height:10px;content:""}.carousel-indicators li::after{position:absolute;bottom:-10px;left:0;display:inline-block;width:100%;height:10px;content:""}.carousel-indicators .active{background-color:#fff}.carousel-caption{position:absolute;right:15%;bottom:20px;left:15%;z-index:10;padding-top:20px;padding-bottom:20px;color:#fff;text-align:center}.align-baseline{vertical-align:baseline!important}.align-top{vertical-align:top!important}.align-middle{vertical-align:middle!important}.align-bottom{vertical-align:bottom!important}.align-text-bottom{vertical-align:text-bottom!important}.align-text-top{vertical-align:text-top!important}.bg-faded{background-color:#f7f7f7}.bg-primary{background-color:#0275d8!important}a.bg-primary:focus,a.bg-primary:hover{background-color:#025aa5!important}.bg-success{background-color:#5cb85c!important}a.bg-success:focus,a.bg-success:hover{background-color:#449d44!important}.bg-info{background-color:#5bc0de!important}a.bg-info:focus,a.bg-info:hover{background-color:#31b0d5!important}.bg-warning{background-color:#f0ad4e!important}a.bg-warning:focus,a.bg-warning:hover{background-color:#ec971f!important}.bg-danger{background-color:#d9534f!important}a.bg-danger:focus,a.bg-danger:hover{background-color:#c9302c!important}.bg-inverse{background-color:#292b2c!important}a.bg-inverse:focus,a.bg-inverse:hover{background-color:#101112!important}.border-0{border:0!important}.border-top-0{border-top:0!important}.border-right-0{border-right:0!important}.border-bottom-0{border-bottom:0!important}.border-left-0{border-left:0!important}.rounded{border-radius:.25rem}.rounded-top{border-top-right-radius:.25rem;border-top-left-radius:.25rem}.rounded-right{border-bottom-right-radius:.25rem;border-top-right-radius:.25rem}.rounded-bottom{border-bottom-right-radius:.25rem;border-bottom-left-radius:.25rem}.rounded-left{border-bottom-left-radius:.25rem;border-top-left-radius:.25rem}.rounded-circle{border-radius:50%}.rounded-0{border-radius:0}.clearfix::after{display:block;content:"";clear:both}.d-none{display:none!important}.d-inline{display:inline!important}.d-inline-block{display:inline-block!important}.d-block{display:block!important}.d-table{display:table!important}.d-table-cell{display:table-cell!important}.d-flex{display:-webkit-box!important;display:-webkit-flex!important;display:-ms-flexbox!important;display:flex!important}.d-inline-flex{display:-webkit-inline-box!important;display:-webkit-inline-flex!important;display:-ms-inline-flexbox!important;display:inline-flex!important}@media (min-width:576px){.d-sm-none{display:none!important}.d-sm-inline{display:inline!important}.d-sm-inline-block{display:inline-block!important}.d-sm-block{display:block!important}.d-sm-table{display:table!important}.d-sm-table-cell{display:table-cell!important}.d-sm-flex{display:-webkit-box!important;display:-webkit-flex!important;display:-ms-flexbox!important;display:flex!important}.d-sm-inline-flex{display:-webkit-inline-box!important;display:-webkit-inline-flex!important;display:-ms-inline-flexbox!important;display:inline-flex!important}}@media (min-width:768px){.d-md-none{display:none!important}.d-md-inline{display:inline!important}.d-md-inline-block{display:inline-block!important}.d-md-block{display:block!important}.d-md-table{display:table!important}.d-md-table-cell{display:table-cell!important}.d-md-flex{display:-webkit-box!important;display:-webkit-flex!important;display:-ms-flexbox!important;display:flex!important}.d-md-inline-flex{display:-webkit-inline-box!important;display:-webkit-inline-flex!important;display:-ms-inline-flexbox!important;display:inline-flex!important}}@media (min-width:992px){.d-lg-none{display:none!important}.d-lg-inline{display:inline!important}.d-lg-inline-block{display:inline-block!important}.d-lg-block{display:block!important}.d-lg-table{display:table!important}.d-lg-table-cell{display:table-cell!important}.d-lg-flex{display:-webkit-box!important;display:-webkit-flex!important;display:-ms-flexbox!important;display:flex!important}.d-lg-inline-flex{display:-webkit-inline-box!important;display:-webkit-inline-flex!important;display:-ms-inline-flexbox!important;display:inline-flex!important}}@media (min-width:1200px){.d-xl-none{display:none!important}.d-xl-inline{display:inline!important}.d-xl-inline-block{display:inline-block!important}.d-xl-block{display:block!important}.d-xl-table{display:table!important}.d-xl-table-cell{display:table-cell!important}.d-xl-flex{display:-webkit-box!important;display:-webkit-flex!important;display:-ms-flexbox!important;display:flex!important}.d-xl-inline-flex{display:-webkit-inline-box!important;display:-webkit-inline-flex!important;display:-ms-inline-flexbox!important;display:inline-flex!important}}.flex-first{-webkit-box-ordinal-group:0;-webkit-order:-1;-ms-flex-order:-1;order:-1}.flex-last{-webkit-box-ordinal-group:2;-webkit-order:1;-ms-flex-order:1;order:1}.flex-unordered{-webkit-box-ordinal-group:1;-webkit-order:0;-ms-flex-order:0;order:0}.flex-row{-webkit-box-orient:horizontal!important;-webkit-box-direction:normal!important;-webkit-flex-direction:row!important;-ms-flex-direction:row!important;flex-direction:row!important}.flex-column{-webkit-box-orient:vertical!important;-webkit-box-direction:normal!important;-webkit-flex-direction:column!important;-ms-flex-direction:column!important;flex-direction:column!important}.flex-row-reverse{-webkit-box-orient:horizontal!important;-webkit-box-direction:reverse!important;-webkit-flex-direction:row-reverse!important;-ms-flex-direction:row-reverse!important;flex-direction:row-reverse!important}.flex-column-reverse{-webkit-box-orient:vertical!important;-webkit-box-direction:reverse!important;-webkit-flex-direction:column-reverse!important;-ms-flex-direction:column-reverse!important;flex-direction:column-reverse!important}.flex-wrap{-webkit-flex-wrap:wrap!important;-ms-flex-wrap:wrap!important;flex-wrap:wrap!important}.flex-nowrap{-webkit-flex-wrap:nowrap!important;-ms-flex-wrap:nowrap!important;flex-wrap:nowrap!important}.flex-wrap-reverse{-webkit-flex-wrap:wrap-reverse!important;-ms-flex-wrap:wrap-reverse!important;flex-wrap:wrap-reverse!important}.justify-content-start{-webkit-box-pack:start!important;-webkit-justify-content:flex-start!important;-ms-flex-pack:start!important;justify-content:flex-start!important}.justify-content-end{-webkit-box-pack:end!important;-webkit-justify-content:flex-end!important;-ms-flex-pack:end!important;justify-content:flex-end!important}.justify-content-center{-webkit-box-pack:center!important;-webkit-justify-content:center!important;-ms-flex-pack:center!important;justify-content:center!important}.justify-content-between{-webkit-box-pack:justify!important;-webkit-justify-content:space-between!important;-ms-flex-pack:justify!important;justify-content:space-between!important}.justify-content-around{-webkit-justify-content:space-around!important;-ms-flex-pack:distribute!important;justify-content:space-around!important}.align-items-start{-webkit-box-align:start!important;-webkit-align-items:flex-start!important;-ms-flex-align:start!important;align-items:flex-start!important}.align-items-end{-webkit-box-align:end!important;-webkit-align-items:flex-end!important;-ms-flex-align:end!important;align-items:flex-end!important}.align-items-center{-webkit-box-align:center!important;-webkit-align-items:center!important;-ms-flex-align:center!important;align-items:center!important}.align-items-baseline{-webkit-box-align:baseline!important;-webkit-align-items:baseline!important;-ms-flex-align:baseline!important;align-items:baseline!important}.align-items-stretch{-webkit-box-align:stretch!important;-webkit-align-items:stretch!important;-ms-flex-align:stretch!important;align-items:stretch!important}.align-content-start{-webkit-align-content:flex-start!important;-ms-flex-line-pack:start!important;align-content:flex-start!important}.align-content-end{-webkit-align-content:flex-end!important;-ms-flex-line-pack:end!important;align-content:flex-end!important}.align-content-center{-webkit-align-content:center!important;-ms-flex-line-pack:center!important;align-content:center!important}.align-content-between{-webkit-align-content:space-between!important;-ms-flex-line-pack:justify!important;align-content:space-between!important}.align-content-around{-webkit-align-content:space-around!important;-ms-flex-line-pack:distribute!important;align-content:space-around!important}.align-content-stretch{-webkit-align-content:stretch!important;-ms-flex-line-pack:stretch!important;align-content:stretch!important}.align-self-auto{-webkit-align-self:auto!important;-ms-flex-item-align:auto!important;-ms-grid-row-align:auto!important;align-self:auto!important}.align-self-start{-webkit-align-self:flex-start!important;-ms-flex-item-align:start!important;align-self:flex-start!important}.align-self-end{-webkit-align-self:flex-end!important;-ms-flex-item-align:end!important;align-self:flex-end!important}.align-self-center{-webkit-align-self:center!important;-ms-flex-item-align:center!important;-ms-grid-row-align:center!important;align-self:center!important}.align-self-baseline{-webkit-align-self:baseline!important;-ms-flex-item-align:baseline!important;align-self:baseline!important}.align-self-stretch{-webkit-align-self:stretch!important;-ms-flex-item-align:stretch!important;-ms-grid-row-align:stretch!important;align-self:stretch!important}@media (min-width:576px){.flex-sm-first{-webkit-box-ordinal-group:0;-webkit-order:-1;-ms-flex-order:-1;order:-1}.flex-sm-last{-webkit-box-ordinal-group:2;-webkit-order:1;-ms-flex-order:1;order:1}.flex-sm-unordered{-webkit-box-ordinal-group:1;-webkit-order:0;-ms-flex-order:0;order:0}.flex-sm-row{-webkit-box-orient:horizontal!important;-webkit-box-direction:normal!important;-webkit-flex-direction:row!important;-ms-flex-direction:row!important;flex-direction:row!important}.flex-sm-column{-webkit-box-orient:vertical!important;-webkit-box-direction:normal!important;-webkit-flex-direction:column!important;-ms-flex-direction:column!important;flex-direction:column!important}.flex-sm-row-reverse{-webkit-box-orient:horizontal!important;-webkit-box-direction:reverse!important;-webkit-flex-direction:row-reverse!important;-ms-flex-direction:row-reverse!important;flex-direction:row-reverse!important}.flex-sm-column-reverse{-webkit-box-orient:vertical!important;-webkit-box-direction:reverse!important;-webkit-flex-direction:column-reverse!important;-ms-flex-direction:column-reverse!important;flex-direction:column-reverse!important}.flex-sm-wrap{-webkit-flex-wrap:wrap!important;-ms-flex-wrap:wrap!important;flex-wrap:wrap!important}.flex-sm-nowrap{-webkit-flex-wrap:nowrap!important;-ms-flex-wrap:nowrap!important;flex-wrap:nowrap!important}.flex-sm-wrap-reverse{-webkit-flex-wrap:wrap-reverse!important;-ms-flex-wrap:wrap-reverse!important;flex-wrap:wrap-reverse!important}.justify-content-sm-start{-webkit-box-pack:start!important;-webkit-justify-content:flex-start!important;-ms-flex-pack:start!important;justify-content:flex-start!important}.justify-content-sm-end{-webkit-box-pack:end!important;-webkit-justify-content:flex-end!important;-ms-flex-pack:end!important;justify-content:flex-end!important}.justify-content-sm-center{-webkit-box-pack:center!important;-webkit-justify-content:center!important;-ms-flex-pack:center!important;justify-content:center!important}.justify-content-sm-between{-webkit-box-pack:justify!important;-webkit-justify-content:space-between!important;-ms-flex-pack:justify!important;justify-content:space-between!important}.justify-content-sm-around{-webkit-justify-content:space-around!important;-ms-flex-pack:distribute!important;justify-content:space-around!important}.align-items-sm-start{-webkit-box-align:start!important;-webkit-align-items:flex-start!important;-ms-flex-align:start!important;align-items:flex-start!important}.align-items-sm-end{-webkit-box-align:end!important;-webkit-align-items:flex-end!important;-ms-flex-align:end!important;align-items:flex-end!important}.align-items-sm-center{-webkit-box-align:center!important;-webkit-align-items:center!important;-ms-flex-align:center!important;align-items:center!important}.align-items-sm-baseline{-webkit-box-align:baseline!important;-webkit-align-items:baseline!important;-ms-flex-align:baseline!important;align-items:baseline!important}.align-items-sm-stretch{-webkit-box-align:stretch!important;-webkit-align-items:stretch!important;-ms-flex-align:stretch!important;align-items:stretch!important}.align-content-sm-start{-webkit-align-content:flex-start!important;-ms-flex-line-pack:start!important;align-content:flex-start!important}.align-content-sm-end{-webkit-align-content:flex-end!important;-ms-flex-line-pack:end!important;align-content:flex-end!important}.align-content-sm-center{-webkit-align-content:center!important;-ms-flex-line-pack:center!important;align-content:center!important}.align-content-sm-between{-webkit-align-content:space-between!important;-ms-flex-line-pack:justify!important;align-content:space-between!important}.align-content-sm-around{-webkit-align-content:space-around!important;-ms-flex-line-pack:distribute!important;align-content:space-around!important}.align-content-sm-stretch{-webkit-align-content:stretch!important;-ms-flex-line-pack:stretch!important;align-content:stretch!important}.align-self-sm-auto{-webkit-align-self:auto!important;-ms-flex-item-align:auto!important;-ms-grid-row-align:auto!important;align-self:auto!important}.align-self-sm-start{-webkit-align-self:flex-start!important;-ms-flex-item-align:start!important;align-self:flex-start!important}.align-self-sm-end{-webkit-align-self:flex-end!important;-ms-flex-item-align:end!important;align-self:flex-end!important}.align-self-sm-center{-webkit-align-self:center!important;-ms-flex-item-align:center!important;-ms-grid-row-align:center!important;align-self:center!important}.align-self-sm-baseline{-webkit-align-self:baseline!important;-ms-flex-item-align:baseline!important;align-self:baseline!important}.align-self-sm-stretch{-webkit-align-self:stretch!important;-ms-flex-item-align:stretch!important;-ms-grid-row-align:stretch!important;align-self:stretch!important}}@media (min-width:768px){.flex-md-first{-webkit-box-ordinal-group:0;-webkit-order:-1;-ms-flex-order:-1;order:-1}.flex-md-last{-webkit-box-ordinal-group:2;-webkit-order:1;-ms-flex-order:1;order:1}.flex-md-unordered{-webkit-box-ordinal-group:1;-webkit-order:0;-ms-flex-order:0;order:0}.flex-md-row{-webkit-box-orient:horizontal!important;-webkit-box-direction:normal!important;-webkit-flex-direction:row!important;-ms-flex-direction:row!important;flex-direction:row!important}.flex-md-column{-webkit-box-orient:vertical!important;-webkit-box-direction:normal!important;-webkit-flex-direction:column!important;-ms-flex-direction:column!important;flex-direction:column!important}.flex-md-row-reverse{-webkit-box-orient:horizontal!important;-webkit-box-direction:reverse!important;-webkit-flex-direction:row-reverse!important;-ms-flex-direction:row-reverse!important;flex-direction:row-reverse!important}.flex-md-column-reverse{-webkit-box-orient:vertical!important;-webkit-box-direction:reverse!important;-webkit-flex-direction:column-reverse!important;-ms-flex-direction:column-reverse!important;flex-direction:column-reverse!important}.flex-md-wrap{-webkit-flex-wrap:wrap!important;-ms-flex-wrap:wrap!important;flex-wrap:wrap!important}.flex-md-nowrap{-webkit-flex-wrap:nowrap!important;-ms-flex-wrap:nowrap!important;flex-wrap:nowrap!important}.flex-md-wrap-reverse{-webkit-flex-wrap:wrap-reverse!important;-ms-flex-wrap:wrap-reverse!important;flex-wrap:wrap-reverse!important}.justify-content-md-start{-webkit-box-pack:start!important;-webkit-justify-content:flex-start!important;-ms-flex-pack:start!important;justify-content:flex-start!important}.justify-content-md-end{-webkit-box-pack:end!important;-webkit-justify-content:flex-end!important;-ms-flex-pack:end!important;justify-content:flex-end!important}.justify-content-md-center{-webkit-box-pack:center!important;-webkit-justify-content:center!important;-ms-flex-pack:center!important;justify-content:center!important}.justify-content-md-between{-webkit-box-pack:justify!important;-webkit-justify-content:space-between!important;-ms-flex-pack:justify!important;justify-content:space-between!important}.justify-content-md-around{-webkit-justify-content:space-around!important;-ms-flex-pack:distribute!important;justify-content:space-around!important}.align-items-md-start{-webkit-box-align:start!important;-webkit-align-items:flex-start!important;-ms-flex-align:start!important;align-items:flex-start!important}.align-items-md-end{-webkit-box-align:end!important;-webkit-align-items:flex-end!important;-ms-flex-align:end!important;align-items:flex-end!important}.align-items-md-center{-webkit-box-align:center!important;-webkit-align-items:center!important;-ms-flex-align:center!important;align-items:center!important}.align-items-md-baseline{-webkit-box-align:baseline!important;-webkit-align-items:baseline!important;-ms-flex-align:baseline!important;align-items:baseline!important}.align-items-md-stretch{-webkit-box-align:stretch!important;-webkit-align-items:stretch!important;-ms-flex-align:stretch!important;align-items:stretch!important}.align-content-md-start{-webkit-align-content:flex-start!important;-ms-flex-line-pack:start!important;align-content:flex-start!important}.align-content-md-end{-webkit-align-content:flex-end!important;-ms-flex-line-pack:end!important;align-content:flex-end!important}.align-content-md-center{-webkit-align-content:center!important;-ms-flex-line-pack:center!important;align-content:center!important}.align-content-md-between{-webkit-align-content:space-between!important;-ms-flex-line-pack:justify!important;align-content:space-between!important}.align-content-md-around{-webkit-align-content:space-around!important;-ms-flex-line-pack:distribute!important;align-content:space-around!important}.align-content-md-stretch{-webkit-align-content:stretch!important;-ms-flex-line-pack:stretch!important;align-content:stretch!important}.align-self-md-auto{-webkit-align-self:auto!important;-ms-flex-item-align:auto!important;-ms-grid-row-align:auto!important;align-self:auto!important}.align-self-md-start{-webkit-align-self:flex-start!important;-ms-flex-item-align:start!important;align-self:flex-start!important}.align-self-md-end{-webkit-align-self:flex-end!important;-ms-flex-item-align:end!important;align-self:flex-end!important}.align-self-md-center{-webkit-align-self:center!important;-ms-flex-item-align:center!important;-ms-grid-row-align:center!important;align-self:center!important}.align-self-md-baseline{-webkit-align-self:baseline!important;-ms-flex-item-align:baseline!important;align-self:baseline!important}.align-self-md-stretch{-webkit-align-self:stretch!important;-ms-flex-item-align:stretch!important;-ms-grid-row-align:stretch!important;align-self:stretch!important}}@media (min-width:992px){.flex-lg-first{-webkit-box-ordinal-group:0;-webkit-order:-1;-ms-flex-order:-1;order:-1}.flex-lg-last{-webkit-box-ordinal-group:2;-webkit-order:1;-ms-flex-order:1;order:1}.flex-lg-unordered{-webkit-box-ordinal-group:1;-webkit-order:0;-ms-flex-order:0;order:0}.flex-lg-row{-webkit-box-orient:horizontal!important;-webkit-box-direction:normal!important;-webkit-flex-direction:row!important;-ms-flex-direction:row!important;flex-direction:row!important}.flex-lg-column{-webkit-box-orient:vertical!important;-webkit-box-direction:normal!important;-webkit-flex-direction:column!important;-ms-flex-direction:column!important;flex-direction:column!important}.flex-lg-row-reverse{-webkit-box-orient:horizontal!important;-webkit-box-direction:reverse!important;-webkit-flex-direction:row-reverse!important;-ms-flex-direction:row-reverse!important;flex-direction:row-reverse!important}.flex-lg-column-reverse{-webkit-box-orient:vertical!important;-webkit-box-direction:reverse!important;-webkit-flex-direction:column-reverse!important;-ms-flex-direction:column-reverse!important;flex-direction:column-reverse!important}.flex-lg-wrap{-webkit-flex-wrap:wrap!important;-ms-flex-wrap:wrap!important;flex-wrap:wrap!important}.flex-lg-nowrap{-webkit-flex-wrap:nowrap!important;-ms-flex-wrap:nowrap!important;flex-wrap:nowrap!important}.flex-lg-wrap-reverse{-webkit-flex-wrap:wrap-reverse!important;-ms-flex-wrap:wrap-reverse!important;flex-wrap:wrap-reverse!important}.justify-content-lg-start{-webkit-box-pack:start!important;-webkit-justify-content:flex-start!important;-ms-flex-pack:start!important;justify-content:flex-start!important}.justify-content-lg-end{-webkit-box-pack:end!important;-webkit-justify-content:flex-end!important;-ms-flex-pack:end!important;justify-content:flex-end!important}.justify-content-lg-center{-webkit-box-pack:center!important;-webkit-justify-content:center!important;-ms-flex-pack:center!important;justify-content:center!important}.justify-content-lg-between{-webkit-box-pack:justify!important;-webkit-justify-content:space-between!important;-ms-flex-pack:justify!important;justify-content:space-between!important}.justify-content-lg-around{-webkit-justify-content:space-around!important;-ms-flex-pack:distribute!important;justify-content:space-around!important}.align-items-lg-start{-webkit-box-align:start!important;-webkit-align-items:flex-start!important;-ms-flex-align:start!important;align-items:flex-start!important}.align-items-lg-end{-webkit-box-align:end!important;-webkit-align-items:flex-end!important;-ms-flex-align:end!important;align-items:flex-end!important}.align-items-lg-center{-webkit-box-align:center!important;-webkit-align-items:center!important;-ms-flex-align:center!important;align-items:center!important}.align-items-lg-baseline{-webkit-box-align:baseline!important;-webkit-align-items:baseline!important;-ms-flex-align:baseline!important;align-items:baseline!important}.align-items-lg-stretch{-webkit-box-align:stretch!important;-webkit-align-items:stretch!important;-ms-flex-align:stretch!important;align-items:stretch!important}.align-content-lg-start{-webkit-align-content:flex-start!important;-ms-flex-line-pack:start!important;align-content:flex-start!important}.align-content-lg-end{-webkit-align-content:flex-end!important;-ms-flex-line-pack:end!important;align-content:flex-end!important}.align-content-lg-center{-webkit-align-content:center!important;-ms-flex-line-pack:center!important;align-content:center!important}.align-content-lg-between{-webkit-align-content:space-between!important;-ms-flex-line-pack:justify!important;align-content:space-between!important}.align-content-lg-around{-webkit-align-content:space-around!important;-ms-flex-line-pack:distribute!important;align-content:space-around!important}.align-content-lg-stretch{-webkit-align-content:stretch!important;-ms-flex-line-pack:stretch!important;align-content:stretch!important}.align-self-lg-auto{-webkit-align-self:auto!important;-ms-flex-item-align:auto!important;-ms-grid-row-align:auto!important;align-self:auto!important}.align-self-lg-start{-webkit-align-self:flex-start!important;-ms-flex-item-align:start!important;align-self:flex-start!important}.align-self-lg-end{-webkit-align-self:flex-end!important;-ms-flex-item-align:end!important;align-self:flex-end!important}.align-self-lg-center{-webkit-align-self:center!important;-ms-flex-item-align:center!important;-ms-grid-row-align:center!important;align-self:center!important}.align-self-lg-baseline{-webkit-align-self:baseline!important;-ms-flex-item-align:baseline!important;align-self:baseline!important}.align-self-lg-stretch{-webkit-align-self:stretch!important;-ms-flex-item-align:stretch!important;-ms-grid-row-align:stretch!important;align-self:stretch!important}}@media (min-width:1200px){.flex-xl-first{-webkit-box-ordinal-group:0;-webkit-order:-1;-ms-flex-order:-1;order:-1}.flex-xl-last{-webkit-box-ordinal-group:2;-webkit-order:1;-ms-flex-order:1;order:1}.flex-xl-unordered{-webkit-box-ordinal-group:1;-webkit-order:0;-ms-flex-order:0;order:0}.flex-xl-row{-webkit-box-orient:horizontal!important;-webkit-box-direction:normal!important;-webkit-flex-direction:row!important;-ms-flex-direction:row!important;flex-direction:row!important}.flex-xl-column{-webkit-box-orient:vertical!important;-webkit-box-direction:normal!important;-webkit-flex-direction:column!important;-ms-flex-direction:column!important;flex-direction:column!important}.flex-xl-row-reverse{-webkit-box-orient:horizontal!important;-webkit-box-direction:reverse!important;-webkit-flex-direction:row-reverse!important;-ms-flex-direction:row-reverse!important;flex-direction:row-reverse!important}.flex-xl-column-reverse{-webkit-box-orient:vertical!important;-webkit-box-direction:reverse!important;-webkit-flex-direction:column-reverse!important;-ms-flex-direction:column-reverse!important;flex-direction:column-reverse!important}.flex-xl-wrap{-webkit-flex-wrap:wrap!important;-ms-flex-wrap:wrap!important;flex-wrap:wrap!important}.flex-xl-nowrap{-webkit-flex-wrap:nowrap!important;-ms-flex-wrap:nowrap!important;flex-wrap:nowrap!important}.flex-xl-wrap-reverse{-webkit-flex-wrap:wrap-reverse!important;-ms-flex-wrap:wrap-reverse!important;flex-wrap:wrap-reverse!important}.justify-content-xl-start{-webkit-box-pack:start!important;-webkit-justify-content:flex-start!important;-ms-flex-pack:start!important;justify-content:flex-start!important}.justify-content-xl-end{-webkit-box-pack:end!important;-webkit-justify-content:flex-end!important;-ms-flex-pack:end!important;justify-content:flex-end!important}.justify-content-xl-center{-webkit-box-pack:center!important;-webkit-justify-content:center!important;-ms-flex-pack:center!important;justify-content:center!important}.justify-content-xl-between{-webkit-box-pack:justify!important;-webkit-justify-content:space-between!important;-ms-flex-pack:justify!important;justify-content:space-between!important}.justify-content-xl-around{-webkit-justify-content:space-around!important;-ms-flex-pack:distribute!important;justify-content:space-around!important}.align-items-xl-start{-webkit-box-align:start!important;-webkit-align-items:flex-start!important;-ms-flex-align:start!important;align-items:flex-start!important}.align-items-xl-end{-webkit-box-align:end!important;-webkit-align-items:flex-end!important;-ms-flex-align:end!important;align-items:flex-end!important}.align-items-xl-center{-webkit-box-align:center!important;-webkit-align-items:center!important;-ms-flex-align:center!important;align-items:center!important}.align-items-xl-baseline{-webkit-box-align:baseline!important;-webkit-align-items:baseline!important;-ms-flex-align:baseline!important;align-items:baseline!important}.align-items-xl-stretch{-webkit-box-align:stretch!important;-webkit-align-items:stretch!important;-ms-flex-align:stretch!important;align-items:stretch!important}.align-content-xl-start{-webkit-align-content:flex-start!important;-ms-flex-line-pack:start!important;align-content:flex-start!important}.align-content-xl-end{-webkit-align-content:flex-end!important;-ms-flex-line-pack:end!important;align-content:flex-end!important}.align-content-xl-center{-webkit-align-content:center!important;-ms-flex-line-pack:center!important;align-content:center!important}.align-content-xl-between{-webkit-align-content:space-between!important;-ms-flex-line-pack:justify!important;align-content:space-between!important}.align-content-xl-around{-webkit-align-content:space-around!important;-ms-flex-line-pack:distribute!important;align-content:space-around!important}.align-content-xl-stretch{-webkit-align-content:stretch!important;-ms-flex-line-pack:stretch!important;align-content:stretch!important}.align-self-xl-auto{-webkit-align-self:auto!important;-ms-flex-item-align:auto!important;-ms-grid-row-align:auto!important;align-self:auto!important}.align-self-xl-start{-webkit-align-self:flex-start!important;-ms-flex-item-align:start!important;align-self:flex-start!important}.align-self-xl-end{-webkit-align-self:flex-end!important;-ms-flex-item-align:end!important;align-self:flex-end!important}.align-self-xl-center{-webkit-align-self:center!important;-ms-flex-item-align:center!important;-ms-grid-row-align:center!important;align-self:center!important}.align-self-xl-baseline{-webkit-align-self:baseline!important;-ms-flex-item-align:baseline!important;align-self:baseline!important}.align-self-xl-stretch{-webkit-align-self:stretch!important;-ms-flex-item-align:stretch!important;-ms-grid-row-align:stretch!important;align-self:stretch!important}}.float-left{float:left!important}.float-right{float:right!important}.float-none{float:none!important}@media (min-width:576px){.float-sm-left{float:left!important}.float-sm-right{float:right!important}.float-sm-none{float:none!important}}@media (min-width:768px){.float-md-left{float:left!important}.float-md-right{float:right!important}.float-md-none{float:none!important}}@media (min-width:992px){.float-lg-left{float:left!important}.float-lg-right{float:right!important}.float-lg-none{float:none!important}}@media (min-width:1200px){.float-xl-left{float:left!important}.float-xl-right{float:right!important}.float-xl-none{float:none!important}}.fixed-top{position:fixed;top:0;right:0;left:0;z-index:1030}.fixed-bottom{position:fixed;right:0;bottom:0;left:0;z-index:1030}.sticky-top{position:-webkit-sticky;position:sticky;top:0;z-index:1030}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);border:0}.sr-only-focusable:active,.sr-only-focusable:focus{position:static;width:auto;height:auto;margin:0;overflow:visible;clip:auto}.w-25{width:25%!important}.w-50{width:50%!important}.w-75{width:75%!important}.w-100{width:100%!important}.h-25{height:25%!important}.h-50{height:50%!important}.h-75{height:75%!important}.h-100{height:100%!important}.mw-100{max-width:100%!important}.mh-100{max-height:100%!important}.m-0{margin:0 0!important}.mt-0{margin-top:0!important}.mr-0{margin-right:0!important}.mb-0{margin-bottom:0!important}.ml-0{margin-left:0!important}.mx-0{margin-right:0!important;margin-left:0!important}.my-0{margin-top:0!important;margin-bottom:0!important}.m-1{margin:.25rem .25rem!important}.mt-1{margin-top:.25rem!important}.mr-1{margin-right:.25rem!important}.mb-1{margin-bottom:.25rem!important}.ml-1{margin-left:.25rem!important}.mx-1{margin-right:.25rem!important;margin-left:.25rem!important}.my-1{margin-top:.25rem!important;margin-bottom:.25rem!important}.m-2{margin:.5rem .5rem!important}.mt-2{margin-top:.5rem!important}.mr-2{margin-right:.5rem!important}.mb-2{margin-bottom:.5rem!important}.ml-2{margin-left:.5rem!important}.mx-2{margin-right:.5rem!important;margin-left:.5rem!important}.my-2{margin-top:.5rem!important;margin-bottom:.5rem!important}.m-3{margin:1rem 1rem!important}.mt-3{margin-top:1rem!important}.mr-3{margin-right:1rem!important}.mb-3{margin-bottom:1rem!important}.ml-3{margin-left:1rem!important}.mx-3{margin-right:1rem!important;margin-left:1rem!important}.my-3{margin-top:1rem!important;margin-bottom:1rem!important}.m-4{margin:1.5rem 1.5rem!important}.mt-4{margin-top:1.5rem!important}.mr-4{margin-right:1.5rem!important}.mb-4{margin-bottom:1.5rem!important}.ml-4{margin-left:1.5rem!important}.mx-4{margin-right:1.5rem!important;margin-left:1.5rem!important}.my-4{margin-top:1.5rem!important;margin-bottom:1.5rem!important}.m-5{margin:3rem 3rem!important}.mt-5{margin-top:3rem!important}.mr-5{margin-right:3rem!important}.mb-5{margin-bottom:3rem!important}.ml-5{margin-left:3rem!important}.mx-5{margin-right:3rem!important;margin-left:3rem!important}.my-5{margin-top:3rem!important;margin-bottom:3rem!important}.p-0{padding:0 0!important}.pt-0{padding-top:0!important}.pr-0{padding-right:0!important}.pb-0{padding-bottom:0!important}.pl-0{padding-left:0!important}.px-0{padding-right:0!important;padding-left:0!important}.py-0{padding-top:0!important;padding-bottom:0!important}.p-1{padding:.25rem .25rem!important}.pt-1{padding-top:.25rem!important}.pr-1{padding-right:.25rem!important}.pb-1{padding-bottom:.25rem!important}.pl-1{padding-left:.25rem!important}.px-1{padding-right:.25rem!important;padding-left:.25rem!important}.py-1{padding-top:.25rem!important;padding-bottom:.25rem!important}.p-2{padding:.5rem .5rem!important}.pt-2{padding-top:.5rem!important}.pr-2{padding-right:.5rem!important}.pb-2{padding-bottom:.5rem!important}.pl-2{padding-left:.5rem!important}.px-2{padding-right:.5rem!important;padding-left:.5rem!important}.py-2{padding-top:.5rem!important;padding-bottom:.5rem!important}.p-3{padding:1rem 1rem!important}.pt-3{padding-top:1rem!important}.pr-3{padding-right:1rem!important}.pb-3{padding-bottom:1rem!important}.pl-3{padding-left:1rem!important}.px-3{padding-right:1rem!important;padding-left:1rem!important}.py-3{padding-top:1rem!important;padding-bottom:1rem!important}.p-4{padding:1.5rem 1.5rem!important}.pt-4{padding-top:1.5rem!important}.pr-4{padding-right:1.5rem!important}.pb-4{padding-bottom:1.5rem!important}.pl-4{padding-left:1.5rem!important}.px-4{padding-right:1.5rem!important;padding-left:1.5rem!important}.py-4{padding-top:1.5rem!important;padding-bottom:1.5rem!important}.p-5{padding:3rem 3rem!important}.pt-5{padding-top:3rem!important}.pr-5{padding-right:3rem!important}.pb-5{padding-bottom:3rem!important}.pl-5{padding-left:3rem!important}.px-5{padding-right:3rem!important;padding-left:3rem!important}.py-5{padding-top:3rem!important;padding-bottom:3rem!important}.m-auto{margin:auto!important}.mt-auto{margin-top:auto!important}.mr-auto{margin-right:auto!important}.mb-auto{margin-bottom:auto!important}.ml-auto{margin-left:auto!important}.mx-auto{margin-right:auto!important;margin-left:auto!important}.my-auto{margin-top:auto!important;margin-bottom:auto!important}@media (min-width:576px){.m-sm-0{margin:0 0!important}.mt-sm-0{margin-top:0!important}.mr-sm-0{margin-right:0!important}.mb-sm-0{margin-bottom:0!important}.ml-sm-0{margin-left:0!important}.mx-sm-0{margin-right:0!important;margin-left:0!important}.my-sm-0{margin-top:0!important;margin-bottom:0!important}.m-sm-1{margin:.25rem .25rem!important}.mt-sm-1{margin-top:.25rem!important}.mr-sm-1{margin-right:.25rem!important}.mb-sm-1{margin-bottom:.25rem!important}.ml-sm-1{margin-left:.25rem!important}.mx-sm-1{margin-right:.25rem!important;margin-left:.25rem!important}.my-sm-1{margin-top:.25rem!important;margin-bottom:.25rem!important}.m-sm-2{margin:.5rem .5rem!important}.mt-sm-2{margin-top:.5rem!important}.mr-sm-2{margin-right:.5rem!important}.mb-sm-2{margin-bottom:.5rem!important}.ml-sm-2{margin-left:.5rem!important}.mx-sm-2{margin-right:.5rem!important;margin-left:.5rem!important}.my-sm-2{margin-top:.5rem!important;margin-bottom:.5rem!important}.m-sm-3{margin:1rem 1rem!important}.mt-sm-3{margin-top:1rem!important}.mr-sm-3{margin-right:1rem!important}.mb-sm-3{margin-bottom:1rem!important}.ml-sm-3{margin-left:1rem!important}.mx-sm-3{margin-right:1rem!important;margin-left:1rem!important}.my-sm-3{margin-top:1rem!important;margin-bottom:1rem!important}.m-sm-4{margin:1.5rem 1.5rem!important}.mt-sm-4{margin-top:1.5rem!important}.mr-sm-4{margin-right:1.5rem!important}.mb-sm-4{margin-bottom:1.5rem!important}.ml-sm-4{margin-left:1.5rem!important}.mx-sm-4{margin-right:1.5rem!important;margin-left:1.5rem!important}.my-sm-4{margin-top:1.5rem!important;margin-bottom:1.5rem!important}.m-sm-5{margin:3rem 3rem!important}.mt-sm-5{margin-top:3rem!important}.mr-sm-5{margin-right:3rem!important}.mb-sm-5{margin-bottom:3rem!important}.ml-sm-5{margin-left:3rem!important}.mx-sm-5{margin-right:3rem!important;margin-left:3rem!important}.my-sm-5{margin-top:3rem!important;margin-bottom:3rem!important}.p-sm-0{padding:0 0!important}.pt-sm-0{padding-top:0!important}.pr-sm-0{padding-right:0!important}.pb-sm-0{padding-bottom:0!important}.pl-sm-0{padding-left:0!important}.px-sm-0{padding-right:0!important;padding-left:0!important}.py-sm-0{padding-top:0!important;padding-bottom:0!important}.p-sm-1{padding:.25rem .25rem!important}.pt-sm-1{padding-top:.25rem!important}.pr-sm-1{padding-right:.25rem!important}.pb-sm-1{padding-bottom:.25rem!important}.pl-sm-1{padding-left:.25rem!important}.px-sm-1{padding-right:.25rem!important;padding-left:.25rem!important}.py-sm-1{padding-top:.25rem!important;padding-bottom:.25rem!important}.p-sm-2{padding:.5rem .5rem!important}.pt-sm-2{padding-top:.5rem!important}.pr-sm-2{padding-right:.5rem!important}.pb-sm-2{padding-bottom:.5rem!important}.pl-sm-2{padding-left:.5rem!important}.px-sm-2{padding-right:.5rem!important;padding-left:.5rem!important}.py-sm-2{padding-top:.5rem!important;padding-bottom:.5rem!important}.p-sm-3{padding:1rem 1rem!important}.pt-sm-3{padding-top:1rem!important}.pr-sm-3{padding-right:1rem!important}.pb-sm-3{padding-bottom:1rem!important}.pl-sm-3{padding-left:1rem!important}.px-sm-3{padding-right:1rem!important;padding-left:1rem!important}.py-sm-3{padding-top:1rem!important;padding-bottom:1rem!important}.p-sm-4{padding:1.5rem 1.5rem!important}.pt-sm-4{padding-top:1.5rem!important}.pr-sm-4{padding-right:1.5rem!important}.pb-sm-4{padding-bottom:1.5rem!important}.pl-sm-4{padding-left:1.5rem!important}.px-sm-4{padding-right:1.5rem!important;padding-left:1.5rem!important}.py-sm-4{padding-top:1.5rem!important;padding-bottom:1.5rem!important}.p-sm-5{padding:3rem 3rem!important}.pt-sm-5{padding-top:3rem!important}.pr-sm-5{padding-right:3rem!important}.pb-sm-5{padding-bottom:3rem!important}.pl-sm-5{padding-left:3rem!important}.px-sm-5{padding-right:3rem!important;padding-left:3rem!important}.py-sm-5{padding-top:3rem!important;padding-bottom:3rem!important}.m-sm-auto{margin:auto!important}.mt-sm-auto{margin-top:auto!important}.mr-sm-auto{margin-right:auto!important}.mb-sm-auto{margin-bottom:auto!important}.ml-sm-auto{margin-left:auto!important}.mx-sm-auto{margin-right:auto!important;margin-left:auto!important}.my-sm-auto{margin-top:auto!important;margin-bottom:auto!important}}@media (min-width:768px){.m-md-0{margin:0 0!important}.mt-md-0{margin-top:0!important}.mr-md-0{margin-right:0!important}.mb-md-0{margin-bottom:0!important}.ml-md-0{margin-left:0!important}.mx-md-0{margin-right:0!important;margin-left:0!important}.my-md-0{margin-top:0!important;margin-bottom:0!important}.m-md-1{margin:.25rem .25rem!important}.mt-md-1{margin-top:.25rem!important}.mr-md-1{margin-right:.25rem!important}.mb-md-1{margin-bottom:.25rem!important}.ml-md-1{margin-left:.25rem!important}.mx-md-1{margin-right:.25rem!important;margin-left:.25rem!important}.my-md-1{margin-top:.25rem!important;margin-bottom:.25rem!important}.m-md-2{margin:.5rem .5rem!important}.mt-md-2{margin-top:.5rem!important}.mr-md-2{margin-right:.5rem!important}.mb-md-2{margin-bottom:.5rem!important}.ml-md-2{margin-left:.5rem!important}.mx-md-2{margin-right:.5rem!important;margin-left:.5rem!important}.my-md-2{margin-top:.5rem!important;margin-bottom:.5rem!important}.m-md-3{margin:1rem 1rem!important}.mt-md-3{margin-top:1rem!important}.mr-md-3{margin-right:1rem!important}.mb-md-3{margin-bottom:1rem!important}.ml-md-3{margin-left:1rem!important}.mx-md-3{margin-right:1rem!important;margin-left:1rem!important}.my-md-3{margin-top:1rem!important;margin-bottom:1rem!important}.m-md-4{margin:1.5rem 1.5rem!important}.mt-md-4{margin-top:1.5rem!important}.mr-md-4{margin-right:1.5rem!important}.mb-md-4{margin-bottom:1.5rem!important}.ml-md-4{margin-left:1.5rem!important}.mx-md-4{margin-right:1.5rem!important;margin-left:1.5rem!important}.my-md-4{margin-top:1.5rem!important;margin-bottom:1.5rem!important}.m-md-5{margin:3rem 3rem!important}.mt-md-5{margin-top:3rem!important}.mr-md-5{margin-right:3rem!important}.mb-md-5{margin-bottom:3rem!important}.ml-md-5{margin-left:3rem!important}.mx-md-5{margin-right:3rem!important;margin-left:3rem!important}.my-md-5{margin-top:3rem!important;margin-bottom:3rem!important}.p-md-0{padding:0 0!important}.pt-md-0{padding-top:0!important}.pr-md-0{padding-right:0!important}.pb-md-0{padding-bottom:0!important}.pl-md-0{padding-left:0!important}.px-md-0{padding-right:0!important;padding-left:0!important}.py-md-0{padding-top:0!important;padding-bottom:0!important}.p-md-1{padding:.25rem .25rem!important}.pt-md-1{padding-top:.25rem!important}.pr-md-1{padding-right:.25rem!important}.pb-md-1{padding-bottom:.25rem!important}.pl-md-1{padding-left:.25rem!important}.px-md-1{padding-right:.25rem!important;padding-left:.25rem!important}.py-md-1{padding-top:.25rem!important;padding-bottom:.25rem!important}.p-md-2{padding:.5rem .5rem!important}.pt-md-2{padding-top:.5rem!important}.pr-md-2{padding-right:.5rem!important}.pb-md-2{padding-bottom:.5rem!important}.pl-md-2{padding-left:.5rem!important}.px-md-2{padding-right:.5rem!important;padding-left:.5rem!important}.py-md-2{padding-top:.5rem!important;padding-bottom:.5rem!important}.p-md-3{padding:1rem 1rem!important}.pt-md-3{padding-top:1rem!important}.pr-md-3{padding-right:1rem!important}.pb-md-3{padding-bottom:1rem!important}.pl-md-3{padding-left:1rem!important}.px-md-3{padding-right:1rem!important;padding-left:1rem!important}.py-md-3{padding-top:1rem!important;padding-bottom:1rem!important}.p-md-4{padding:1.5rem 1.5rem!important}.pt-md-4{padding-top:1.5rem!important}.pr-md-4{padding-right:1.5rem!important}.pb-md-4{padding-bottom:1.5rem!important}.pl-md-4{padding-left:1.5rem!important}.px-md-4{padding-right:1.5rem!important;padding-left:1.5rem!important}.py-md-4{padding-top:1.5rem!important;padding-bottom:1.5rem!important}.p-md-5{padding:3rem 3rem!important}.pt-md-5{padding-top:3rem!important}.pr-md-5{padding-right:3rem!important}.pb-md-5{padding-bottom:3rem!important}.pl-md-5{padding-left:3rem!important}.px-md-5{padding-right:3rem!important;padding-left:3rem!important}.py-md-5{padding-top:3rem!important;padding-bottom:3rem!important}.m-md-auto{margin:auto!important}.mt-md-auto{margin-top:auto!important}.mr-md-auto{margin-right:auto!important}.mb-md-auto{margin-bottom:auto!important}.ml-md-auto{margin-left:auto!important}.mx-md-auto{margin-right:auto!important;margin-left:auto!important}.my-md-auto{margin-top:auto!important;margin-bottom:auto!important}}@media (min-width:992px){.m-lg-0{margin:0 0!important}.mt-lg-0{margin-top:0!important}.mr-lg-0{margin-right:0!important}.mb-lg-0{margin-bottom:0!important}.ml-lg-0{margin-left:0!important}.mx-lg-0{margin-right:0!important;margin-left:0!important}.my-lg-0{margin-top:0!important;margin-bottom:0!important}.m-lg-1{margin:.25rem .25rem!important}.mt-lg-1{margin-top:.25rem!important}.mr-lg-1{margin-right:.25rem!important}.mb-lg-1{margin-bottom:.25rem!important}.ml-lg-1{margin-left:.25rem!important}.mx-lg-1{margin-right:.25rem!important;margin-left:.25rem!important}.my-lg-1{margin-top:.25rem!important;margin-bottom:.25rem!important}.m-lg-2{margin:.5rem .5rem!important}.mt-lg-2{margin-top:.5rem!important}.mr-lg-2{margin-right:.5rem!important}.mb-lg-2{margin-bottom:.5rem!important}.ml-lg-2{margin-left:.5rem!important}.mx-lg-2{margin-right:.5rem!important;margin-left:.5rem!important}.my-lg-2{margin-top:.5rem!important;margin-bottom:.5rem!important}.m-lg-3{margin:1rem 1rem!important}.mt-lg-3{margin-top:1rem!important}.mr-lg-3{margin-right:1rem!important}.mb-lg-3{margin-bottom:1rem!important}.ml-lg-3{margin-left:1rem!important}.mx-lg-3{margin-right:1rem!important;margin-left:1rem!important}.my-lg-3{margin-top:1rem!important;margin-bottom:1rem!important}.m-lg-4{margin:1.5rem 1.5rem!important}.mt-lg-4{margin-top:1.5rem!important}.mr-lg-4{margin-right:1.5rem!important}.mb-lg-4{margin-bottom:1.5rem!important}.ml-lg-4{margin-left:1.5rem!important}.mx-lg-4{margin-right:1.5rem!important;margin-left:1.5rem!important}.my-lg-4{margin-top:1.5rem!important;margin-bottom:1.5rem!important}.m-lg-5{margin:3rem 3rem!important}.mt-lg-5{margin-top:3rem!important}.mr-lg-5{margin-right:3rem!important}.mb-lg-5{margin-bottom:3rem!important}.ml-lg-5{margin-left:3rem!important}.mx-lg-5{margin-right:3rem!important;margin-left:3rem!important}.my-lg-5{margin-top:3rem!important;margin-bottom:3rem!important}.p-lg-0{padding:0 0!important}.pt-lg-0{padding-top:0!important}.pr-lg-0{padding-right:0!important}.pb-lg-0{padding-bottom:0!important}.pl-lg-0{padding-left:0!important}.px-lg-0{padding-right:0!important;padding-left:0!important}.py-lg-0{padding-top:0!important;padding-bottom:0!important}.p-lg-1{padding:.25rem .25rem!important}.pt-lg-1{padding-top:.25rem!important}.pr-lg-1{padding-right:.25rem!important}.pb-lg-1{padding-bottom:.25rem!important}.pl-lg-1{padding-left:.25rem!important}.px-lg-1{padding-right:.25rem!important;padding-left:.25rem!important}.py-lg-1{padding-top:.25rem!important;padding-bottom:.25rem!important}.p-lg-2{padding:.5rem .5rem!important}.pt-lg-2{padding-top:.5rem!important}.pr-lg-2{padding-right:.5rem!important}.pb-lg-2{padding-bottom:.5rem!important}.pl-lg-2{padding-left:.5rem!important}.px-lg-2{padding-right:.5rem!important;padding-left:.5rem!important}.py-lg-2{padding-top:.5rem!important;padding-bottom:.5rem!important}.p-lg-3{padding:1rem 1rem!important}.pt-lg-3{padding-top:1rem!important}.pr-lg-3{padding-right:1rem!important}.pb-lg-3{padding-bottom:1rem!important}.pl-lg-3{padding-left:1rem!important}.px-lg-3{padding-right:1rem!important;padding-left:1rem!important}.py-lg-3{padding-top:1rem!important;padding-bottom:1rem!important}.p-lg-4{padding:1.5rem 1.5rem!important}.pt-lg-4{padding-top:1.5rem!important}.pr-lg-4{padding-right:1.5rem!important}.pb-lg-4{padding-bottom:1.5rem!important}.pl-lg-4{padding-left:1.5rem!important}.px-lg-4{padding-right:1.5rem!important;padding-left:1.5rem!important}.py-lg-4{padding-top:1.5rem!important;padding-bottom:1.5rem!important}.p-lg-5{padding:3rem 3rem!important}.pt-lg-5{padding-top:3rem!important}.pr-lg-5{padding-right:3rem!important}.pb-lg-5{padding-bottom:3rem!important}.pl-lg-5{padding-left:3rem!important}.px-lg-5{padding-right:3rem!important;padding-left:3rem!important}.py-lg-5{padding-top:3rem!important;padding-bottom:3rem!important}.m-lg-auto{margin:auto!important}.mt-lg-auto{margin-top:auto!important}.mr-lg-auto{margin-right:auto!important}.mb-lg-auto{margin-bottom:auto!important}.ml-lg-auto{margin-left:auto!important}.mx-lg-auto{margin-right:auto!important;margin-left:auto!important}.my-lg-auto{margin-top:auto!important;margin-bottom:auto!important}}@media (min-width:1200px){.m-xl-0{margin:0 0!important}.mt-xl-0{margin-top:0!important}.mr-xl-0{margin-right:0!important}.mb-xl-0{margin-bottom:0!important}.ml-xl-0{margin-left:0!important}.mx-xl-0{margin-right:0!important;margin-left:0!important}.my-xl-0{margin-top:0!important;margin-bottom:0!important}.m-xl-1{margin:.25rem .25rem!important}.mt-xl-1{margin-top:.25rem!important}.mr-xl-1{margin-right:.25rem!important}.mb-xl-1{margin-bottom:.25rem!important}.ml-xl-1{margin-left:.25rem!important}.mx-xl-1{margin-right:.25rem!important;margin-left:.25rem!important}.my-xl-1{margin-top:.25rem!important;margin-bottom:.25rem!important}.m-xl-2{margin:.5rem .5rem!important}.mt-xl-2{margin-top:.5rem!important}.mr-xl-2{margin-right:.5rem!important}.mb-xl-2{margin-bottom:.5rem!important}.ml-xl-2{margin-left:.5rem!important}.mx-xl-2{margin-right:.5rem!important;margin-left:.5rem!important}.my-xl-2{margin-top:.5rem!important;margin-bottom:.5rem!important}.m-xl-3{margin:1rem 1rem!important}.mt-xl-3{margin-top:1rem!important}.mr-xl-3{margin-right:1rem!important}.mb-xl-3{margin-bottom:1rem!important}.ml-xl-3{margin-left:1rem!important}.mx-xl-3{margin-right:1rem!important;margin-left:1rem!important}.my-xl-3{margin-top:1rem!important;margin-bottom:1rem!important}.m-xl-4{margin:1.5rem 1.5rem!important}.mt-xl-4{margin-top:1.5rem!important}.mr-xl-4{margin-right:1.5rem!important}.mb-xl-4{margin-bottom:1.5rem!important}.ml-xl-4{margin-left:1.5rem!important}.mx-xl-4{margin-right:1.5rem!important;margin-left:1.5rem!important}.my-xl-4{margin-top:1.5rem!important;margin-bottom:1.5rem!important}.m-xl-5{margin:3rem 3rem!important}.mt-xl-5{margin-top:3rem!important}.mr-xl-5{margin-right:3rem!important}.mb-xl-5{margin-bottom:3rem!important}.ml-xl-5{margin-left:3rem!important}.mx-xl-5{margin-right:3rem!important;margin-left:3rem!important}.my-xl-5{margin-top:3rem!important;margin-bottom:3rem!important}.p-xl-0{padding:0 0!important}.pt-xl-0{padding-top:0!important}.pr-xl-0{padding-right:0!important}.pb-xl-0{padding-bottom:0!important}.pl-xl-0{padding-left:0!important}.px-xl-0{padding-right:0!important;padding-left:0!important}.py-xl-0{padding-top:0!important;padding-bottom:0!important}.p-xl-1{padding:.25rem .25rem!important}.pt-xl-1{padding-top:.25rem!important}.pr-xl-1{padding-right:.25rem!important}.pb-xl-1{padding-bottom:.25rem!important}.pl-xl-1{padding-left:.25rem!important}.px-xl-1{padding-right:.25rem!important;padding-left:.25rem!important}.py-xl-1{padding-top:.25rem!important;padding-bottom:.25rem!important}.p-xl-2{padding:.5rem .5rem!important}.pt-xl-2{padding-top:.5rem!important}.pr-xl-2{padding-right:.5rem!important}.pb-xl-2{padding-bottom:.5rem!important}.pl-xl-2{padding-left:.5rem!important}.px-xl-2{padding-right:.5rem!important;padding-left:.5rem!important}.py-xl-2{padding-top:.5rem!important;padding-bottom:.5rem!important}.p-xl-3{padding:1rem 1rem!important}.pt-xl-3{padding-top:1rem!important}.pr-xl-3{padding-right:1rem!important}.pb-xl-3{padding-bottom:1rem!important}.pl-xl-3{padding-left:1rem!important}.px-xl-3{padding-right:1rem!important;padding-left:1rem!important}.py-xl-3{padding-top:1rem!important;padding-bottom:1rem!important}.p-xl-4{padding:1.5rem 1.5rem!important}.pt-xl-4{padding-top:1.5rem!important}.pr-xl-4{padding-right:1.5rem!important}.pb-xl-4{padding-bottom:1.5rem!important}.pl-xl-4{padding-left:1.5rem!important}.px-xl-4{padding-right:1.5rem!important;padding-left:1.5rem!important}.py-xl-4{padding-top:1.5rem!important;padding-bottom:1.5rem!important}.p-xl-5{padding:3rem 3rem!important}.pt-xl-5{padding-top:3rem!important}.pr-xl-5{padding-right:3rem!important}.pb-xl-5{padding-bottom:3rem!important}.pl-xl-5{padding-left:3rem!important}.px-xl-5{padding-right:3rem!important;padding-left:3rem!important}.py-xl-5{padding-top:3rem!important;padding-bottom:3rem!important}.m-xl-auto{margin:auto!important}.mt-xl-auto{margin-top:auto!important}.mr-xl-auto{margin-right:auto!important}.mb-xl-auto{margin-bottom:auto!important}.ml-xl-auto{margin-left:auto!important}.mx-xl-auto{margin-right:auto!important;margin-left:auto!important}.my-xl-auto{margin-top:auto!important;margin-bottom:auto!important}}.text-justify{text-align:justify!important}.text-nowrap{white-space:nowrap!important}.text-truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.text-left{text-align:left!important}.text-right{text-align:right!important}.text-center{text-align:center!important}@media (min-width:576px){.text-sm-left{text-align:left!important}.text-sm-right{text-align:right!important}.text-sm-center{text-align:center!important}}@media (min-width:768px){.text-md-left{text-align:left!important}.text-md-right{text-align:right!important}.text-md-center{text-align:center!important}}@media (min-width:992px){.text-lg-left{text-align:left!important}.text-lg-right{text-align:right!important}.text-lg-center{text-align:center!important}}@media (min-width:1200px){.text-xl-left{text-align:left!important}.text-xl-right{text-align:right!important}.text-xl-center{text-align:center!important}}.text-lowercase{text-transform:lowercase!important}.text-uppercase{text-transform:uppercase!important}.text-capitalize{text-transform:capitalize!important}.font-weight-normal{font-weight:400}.font-weight-bold{font-weight:700}.font-italic{font-style:italic}.text-white{color:#fff!important}.text-muted{color:#636c72!important}a.text-muted:focus,a.text-muted:hover{color:#4b5257!important}.text-primary{color:#0275d8!important}a.text-primary:focus,a.text-primary:hover{color:#025aa5!important}.text-success{color:#5cb85c!important}a.text-success:focus,a.text-success:hover{color:#449d44!important}.text-info{color:#5bc0de!important}a.text-info:focus,a.text-info:hover{color:#31b0d5!important}.text-warning{color:#f0ad4e!important}a.text-warning:focus,a.text-warning:hover{color:#ec971f!important}.text-danger{color:#d9534f!important}a.text-danger:focus,a.text-danger:hover{color:#c9302c!important}.text-gray-dark{color:#292b2c!important}a.text-gray-dark:focus,a.text-gray-dark:hover{color:#101112!important}.text-hide{font:0/0 a;color:transparent;text-shadow:none;background-color:transparent;border:0}.invisible{visibility:hidden!important}.hidden-xs-up{display:none!important}@media (max-width:575px){.hidden-xs-down{display:none!important}}@media (min-width:576px){.hidden-sm-up{display:none!important}}@media (max-width:767px){.hidden-sm-down{display:none!important}}@media (min-width:768px){.hidden-md-up{display:none!important}}@media (max-width:991px){.hidden-md-down{display:none!important}}@media (min-width:992px){.hidden-lg-up{display:none!important}}@media (max-width:1199px){.hidden-lg-down{display:none!important}}@media (min-width:1200px){.hidden-xl-up{display:none!important}}.hidden-xl-down{display:none!important}.visible-print-block{display:none!important}@media print{.visible-print-block{display:block!important}}.visible-print-inline{display:none!important}@media print{.visible-print-inline{display:inline!important}}.visible-print-inline-block{display:none!important}@media print{.visible-print-inline-block{display:inline-block!important}}@media print{.hidden-print{display:none!important}}/*# sourceMappingURL=bootstrap.min.css.map */ \ No newline at end of file diff --git a/src/alertmanager/ui/app/lib/bootstrap-4.0.0-alpha.6-dist/css/bootstrap.min.css.map b/src/alertmanager/ui/app/lib/bootstrap-4.0.0-alpha.6-dist/css/bootstrap.min.css.map new file mode 100644 index 0000000..74462f2 --- /dev/null +++ b/src/alertmanager/ui/app/lib/bootstrap-4.0.0-alpha.6-dist/css/bootstrap.min.css.map @@ -0,0 +1 @@ +{"version":3,"sources":["../../scss/_normalize.scss","bootstrap.css","../../scss/_print.scss","../../scss/_reboot.scss","../../scss/_variables.scss","../../scss/mixins/_hover.scss","../../scss/_type.scss","../../scss/mixins/_lists.scss","../../scss/_images.scss","../../scss/mixins/_image.scss","../../scss/mixins/_border-radius.scss","../../scss/_mixins.scss","../../scss/_code.scss","../../scss/_grid.scss","../../scss/mixins/_grid.scss","../../scss/mixins/_breakpoints.scss","../../scss/mixins/_grid-framework.scss","../../scss/_tables.scss","../../scss/mixins/_table-row.scss","../../scss/_forms.scss","../../scss/mixins/_forms.scss","../../scss/_buttons.scss","../../scss/mixins/_buttons.scss","../../scss/_transitions.scss","../../scss/_dropdown.scss","../../scss/mixins/_nav-divider.scss","../../scss/_button-group.scss","../../scss/_input-group.scss","../../scss/_custom-forms.scss","../../scss/_nav.scss","../../scss/_navbar.scss","../../scss/_card.scss","../../scss/mixins/_cards.scss","../../scss/_breadcrumb.scss","../../scss/mixins/_clearfix.scss","../../scss/_pagination.scss","../../scss/mixins/_pagination.scss","../../scss/_badge.scss","../../scss/mixins/_badge.scss","../../scss/_jumbotron.scss","../../scss/_alert.scss","../../scss/mixins/_alert.scss","../../scss/_progress.scss","../../scss/mixins/_gradients.scss","../../scss/_media.scss","../../scss/_list-group.scss","../../scss/mixins/_list-group.scss","../../scss/_responsive-embed.scss","../../scss/_close.scss","../../scss/_modal.scss","../../scss/_tooltip.scss","../../scss/mixins/_reset-text.scss","../../scss/_popover.scss","../../scss/_carousel.scss","../../scss/mixins/_transforms.scss","../../scss/utilities/_align.scss","../../scss/utilities/_background.scss","../../scss/mixins/_background-variant.scss","../../scss/utilities/_borders.scss","../../scss/utilities/_display.scss","../../scss/utilities/_flex.scss","../../scss/utilities/_float.scss","../../scss/mixins/_float.scss","../../scss/utilities/_position.scss","../../scss/utilities/_screenreaders.scss","../../scss/mixins/_screen-reader.scss","../../scss/utilities/_sizing.scss","../../scss/utilities/_spacing.scss","../../scss/utilities/_text.scss","../../scss/mixins/_text-truncate.scss","../../scss/mixins/_text-emphasis.scss","../../scss/mixins/_text-hide.scss","../../scss/utilities/_visibility.scss","../../scss/mixins/_visibility.scss"],"names":[],"mappings":";;;;;4EAYA,KACE,YAAA,WACA,YAAA,KACA,qBAAA,KACA,yBAAA,KAUF,KACE,OAAA,EAOF,QAAA,MAAA,OAAA,OAAA,IAAA,QAME,QAAA,MAQF,GACE,UAAA,IACA,OAAA,MAAA,EAWF,WAAA,OAAA,KAGE,QAAA,MAOF,OACE,OAAA,IAAA,KAQF,GACE,mBAAA,YAAA,WAAA,YACA,OAAA,EACA,SAAA,QAQF,IACE,YAAA,UAAA,UACA,UAAA,IAWF,EACE,iBAAA,YACA,6BAAA,QAQF,SAAA,QAEE,cAAA,EAQF,YACE,cAAA,KACA,gBAAA,UACA,gBAAA,UAAA,OAOF,EAAA,OAEE,YAAA,QAOF,EAAA,OAEE,YAAA,OAQF,KAAA,IAAA,KAGE,YAAA,UAAA,UACA,UAAA,IAOF,IACE,WAAA,OAOF,KACE,iBAAA,KACA,MAAA,KAOF,MACE,UAAA,IAQF,IAAA,IAEE,UAAA,IACA,YAAA,EACA,SAAA,SACA,eAAA,SAGF,IACE,OAAA,OAGF,IACE,IAAA,MAUF,MAAA,MAEE,QAAA,aAOF,sBACE,QAAA,KACA,OAAA,EAOF,IACE,aAAA,KAOF,eACE,SAAA,OAWF,OAAA,MAAA,SAAA,OAAA,SAKE,YAAA,WACA,UAAA,KACA,YAAA,KACA,OAAA,EAQF,OAAA,MAEE,SAAA,QAQF,OAAA,OAEE,eAAA,KASF,aAAA,cAAA,OAAA,mBAIE,mBAAA,OAOF,gCAAA,+BAAA,gCAAA,yBAIE,aAAA,KACA,QAAA,EAOF,6BAAA,4BAAA,6BAAA,sBAIE,QAAA,IAAA,OAAA,WAOF,SACE,OAAA,IAAA,MAAA,OACA,OAAA,EAAA,IACA,QAAA,MAAA,OAAA,MAUF,OACE,mBAAA,WAAA,WAAA,WACA,MAAA,QACA,QAAA,MACA,UAAA,KACA,QAAA,EACA,YAAA,OAQF,SACE,QAAA,aACA,eAAA,SAOF,SACE,SAAA,KC/JF,gBAAA,aDyKE,mBAAA,WAAA,WAAA,WACA,QAAA,ECpKF,yCAAA,yCD6KE,OAAA,KCxKF,cDiLE,mBAAA,UACA,eAAA,KC7KF,4CAAA,yCDsLE,mBAAA,KAQF,6BACE,mBAAA,OACA,KAAA,QAWF,QAAA,KAEE,QAAA,MAOF,QACE,QAAA,UAUF,OACE,QAAA,aAOF,SACE,QAAA,KC7MF,SDwNE,QAAA,KEhcA,aACE,EAAA,QAAA,SAAA,yBAAA,uBAAA,kBAAA,gBAAA,iBAAA,eAAA,gBAAA,cAcE,YAAA,eAEA,mBAAA,eAAA,WAAA,eAGF,EAAA,UAEE,gBAAA,UAQF,mBACE,QAA6B,KAA7B,YAA6B,IAc/B,IACE,YAAA,mBAEF,WAAA,IAEE,OAAA,IAAA,MAAA,KACA,kBAAA,MAQF,MACE,QAAA,mBAGF,IAAA,GAEE,kBAAA,MAGF,GAAA,GAAA,EAGE,QAAA,EACA,OAAA,EAGF,GAAA,GAEE,iBAAA,MAMF,QACE,QAAA,KAEF,OACE,OAAA,IAAA,MAAA,KAGF,OACE,gBAAA,mBADF,UAAA,UAKI,iBAAA,eAGJ,mBAAA,mBAGI,OAAA,IAAA,MAAA,gBC3FR,KACE,mBAAA,WAAA,WAAA,WAGF,EAAA,QAAA,SAGE,mBAAA,QAAA,WAAA,QAoBA,cAAgB,MAAA,aAQlB,KAYE,mBAAA,UAGA,4BAAA,YAGF,KACE,YAAA,cAAA,UAAA,mBAAA,WAAA,OC2K4H,iBD3K5H,MAAA,WACA,UAAA,KACA,YAAA,IACA,YAAA,IAEA,MAAA,QAEA,iBAAA,KFmQF,sBE1PE,QAAA,YAYF,GAAI,GAAI,GAAI,GAAI,GAAI,GAClB,WAAA,EACA,cAAA,MAOF,EACE,WAAA,EACA,cAAA,KAIF,0BAAA,YAGE,OAAA,KAGF,QACE,cAAA,KACA,WAAA,OACA,YAAA,QAGF,GAAA,GAAA,GAGE,WAAA,EACA,cAAA,KAGF,MAAA,MAAA,MAAA,MAIE,cAAA,EAGF,GACE,YAAA,IAGF,GACE,cAAA,MACA,YAAA,EAGF,WACE,OAAA,EAAA,EAAA,KAQF,EACE,MAAA,QACA,gBAAA,KEhJE,QAAA,QFmJA,MAAA,QACA,gBAAA,UAUJ,8BACE,MAAA,QACA,gBAAA,KEhKE,oCAAA,oCFmKA,MAAA,QACA,gBAAA,KANJ,oCAUI,QAAA,EASJ,IAEE,WAAA,EAEA,cAAA,KAEA,SAAA,KAQF,OAGE,OAAA,EAAA,EAAA,KAQF,IAGE,eAAA,OF8MF,cEjME,OAAA,QAcF,cAAA,EAAA,KAAA,OAAA,MAAA,MAAA,OAAA,QAAA,SASE,iBAAA,aAAA,aAAA,aAQF,MAEE,gBAAA,SAEA,iBAAA,YAGF,QACE,YAAA,OACA,eAAA,OACA,MAAA,QACA,WAAA,KACA,aAAA,OAGF,GAEE,WAAA,KAQF,MAEE,QAAA,aACA,cAAA,MAOF,aACE,QAAA,IAAA,OACA,QAAA,IAAA,KAAA,yBAGF,OAAA,MAAA,OAAA,SAME,YAAA,QAGF,8BAAA,2BAMI,OAAA,YAKJ,iBAAA,iBAAA,2BAAA,kBASE,mBAAA,QAGF,SAEE,OAAA,SAGF,SAME,UAAA,EAEA,QAAA,EACA,OAAA,EACA,OAAA,EAGF,OAEE,QAAA,MACA,MAAA,KACA,QAAA,EACA,cAAA,MACA,UAAA,OACA,YAAA,QAGF,mBAKE,mBAAA,KAIF,OACE,QAAA,aF8IF,SEtIE,QAAA,eG/XF,IAAK,IAAK,IAAK,IAAK,IAAK,IAAzB,GAAI,GAAI,GAAI,GAAI,GAAI,GAElB,cAAA,MACA,YAAA,QACA,YAAA,IACA,YAAA,IACA,MAAA,QAGE,IAAJ,GAAU,UAAA,OACN,IAAJ,GAAU,UAAA,KACN,IAAJ,GAAU,UAAA,QACN,IAAJ,GAAU,UAAA,OACN,IAAJ,GAAU,UAAA,QACN,IAAJ,GAAU,UAAA,KAEV,MACE,UAAA,QACA,YAAA,IAIF,WACE,UAAA,KACA,YAAA,IACA,YAAA,IAEF,WACE,UAAA,OACA,YAAA,IACA,YAAA,IAEF,WACE,UAAA,OACA,YAAA,IACA,YAAA,IAEF,WACE,UAAA,OACA,YAAA,IACA,YAAA,IAQF,GACE,WAAA,KACA,cAAA,KACA,OAAA,EACA,WAAA,IAAA,MAAA,eAQF,OAAA,MAEE,UAAA,IACA,YAAA,IAGF,MAAA,KAEE,QAAA,KACA,iBAAA,QAQF,eC7EE,aAAA,EACA,WAAA,KDiFF,aClFE,aAAA,EACA,WAAA,KDoFF,kBACE,QAAA,aADF,mCAII,aAAA,IAUJ,YACE,UAAA,IACA,eAAA,UAIF,YACE,QAAA,MAAA,KACA,cAAA,KACA,UAAA,QACA,YAAA,OAAA,MAAA,QAGF,mBACE,QAAA,MACA,UAAA,IACA,MAAA,QAHF,2BAMI,QAAsB,cAK1B,oBACE,cAAA,KACA,aAAA,EACA,WAAA,MACA,aAAA,OAAA,MAAA,QACA,YAAA,EAGF,+CAEI,QAAW,GAFf,8CAKI,QAAsB,cErI1B,WCIE,UAAA,KAGA,OAAA,KDDF,eACE,QAAA,OACA,iBAAA,KACA,OAAA,IAAA,MAAA,KEZE,cAAA,OCWE,mBAAA,IAAA,IAAA,YAAA,cAAA,IAAA,IAAA,YAAA,WAAA,IAAA,IAAA,YFJJ,UAAA,KAGA,OAAA,KDeF,QAEE,QAAA,aAGF,YACE,cAAA,MACA,YAAA,EAGF,gBACE,UAAA,IACA,MAAA,QIxCF,KAAA,IAAA,IAAA,KAIE,YAAA,MAAA,OAAA,SAAA,kBRmP2F,cQnP3F,UAIF,KACE,QAAA,MAAA,MACA,UAAA,IACA,MAAA,QACA,iBAAA,QFTE,cAAA,OEaF,OACE,QAAA,EACA,MAAA,QACA,iBAAA,QAKJ,IACE,QAAA,MAAA,MACA,UAAA,IACA,MAAA,KACA,iBAAA,QFzBE,cAAA,MEqBJ,QASI,QAAA,EACA,UAAA,KACA,YAAA,IAMJ,IACE,QAAA,MACA,WAAA,EACA,cAAA,KACA,UAAA,IACA,MAAA,QALF,SASI,QAAA,EACA,UAAA,QACA,MAAA,QACA,iBAAA,YACA,cAAA,EAKJ,gBACE,WAAA,MACA,WAAA,OCzDA,WCAA,SAAA,SACA,YAAA,KACA,aAAA,KAKI,cAAA,KACA,aAAA,KC2CF,yBFnDF,WCOI,cAAA,KACA,aAAA,MC2CF,yBFnDF,WCOI,cAAA,KACA,aAAA,MC2CF,yBFnDF,WCOI,cAAA,KACA,aAAA,MC2CF,0BFnDF,WCOI,cAAA,KACA,aAAA,MC2CF,yBFnDF,WCkBI,MAAA,MACA,UAAA,MCgCF,yBFnDF,WCkBI,MAAA,MACA,UAAA,MCgCF,yBFnDF,WCkBI,MAAA,MACA,UAAA,MCgCF,0BFnDF,WCkBI,MAAA,OACA,UAAA,MDPJ,iBCZA,SAAA,SACA,YAAA,KACA,aAAA,KAKI,cAAA,KACA,aAAA,KC2CF,yBFvCF,iBCLI,cAAA,KACA,aAAA,MC2CF,yBFvCF,iBCLI,cAAA,KACA,aAAA,MC2CF,yBFvCF,iBCLI,cAAA,KACA,aAAA,MC2CF,0BFvCF,iBCLI,cAAA,KACA,aAAA,MDcJ,KCaA,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,kBAAA,KAAA,cAAA,KAAA,UAAA,KAKI,aAAA,MACA,YAAA,MCSF,yBF7BF,KCmBI,aAAA,MACA,YAAA,OCSF,yBF7BF,KCmBI,aAAA,MACA,YAAA,OCSF,yBF7BF,KCmBI,aAAA,MACA,YAAA,OCSF,0BF7BF,KCmBI,aAAA,MACA,YAAA,ODdJ,YACE,aAAA,EACA,YAAA,EAFF,iBAAA,0BAMI,cAAA,EACA,aAAA,EGjCJ,KAAA,OAAA,QAAA,QAAA,QAAA,OAAA,OAAA,OAAA,OAAA,OAAA,OAAA,OAAA,OAAA,QAAA,UAAA,WAAA,WAAA,WAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,QAAA,UAAA,WAAA,WAAA,WAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,QAAA,UAAA,WAAA,WAAA,WAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,QAAA,UAAA,WAAA,WAAA,WAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UACE,SAAA,SACA,MAAA,KACA,WAAA,IFuBE,cAAA,KACA,aAAA,KCsBF,yBCjDF,KAAA,OAAA,QAAA,QAAA,QAAA,OAAA,OAAA,OAAA,OAAA,OAAA,OAAA,OAAA,OAAA,QAAA,UAAA,WAAA,WAAA,WAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,QAAA,UAAA,WAAA,WAAA,WAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,QAAA,UAAA,WAAA,WAAA,WAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,QAAA,UAAA,WAAA,WAAA,WAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UF0BI,cAAA,KACA,aAAA,MCsBF,yBCjDF,KAAA,OAAA,QAAA,QAAA,QAAA,OAAA,OAAA,OAAA,OAAA,OAAA,OAAA,OAAA,OAAA,QAAA,UAAA,WAAA,WAAA,WAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,QAAA,UAAA,WAAA,WAAA,WAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,QAAA,UAAA,WAAA,WAAA,WAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,QAAA,UAAA,WAAA,WAAA,WAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UF0BI,cAAA,KACA,aAAA,MCsBF,yBCjDF,KAAA,OAAA,QAAA,QAAA,QAAA,OAAA,OAAA,OAAA,OAAA,OAAA,OAAA,OAAA,OAAA,QAAA,UAAA,WAAA,WAAA,WAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,QAAA,UAAA,WAAA,WAAA,WAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,QAAA,UAAA,WAAA,WAAA,WAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,QAAA,UAAA,WAAA,WAAA,WAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UF0BI,cAAA,KACA,aAAA,MCsBF,0BCjDF,KAAA,OAAA,QAAA,QAAA,QAAA,OAAA,OAAA,OAAA,OAAA,OAAA,OAAA,OAAA,OAAA,QAAA,UAAA,WAAA,WAAA,WAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,QAAA,UAAA,WAAA,WAAA,WAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,QAAA,UAAA,WAAA,WAAA,WAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,QAAA,UAAA,WAAA,WAAA,WAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UAAA,UF0BI,cAAA,KACA,aAAA,MEJA,KACE,mBAAA,EAAA,wBAAA,EAAA,WAAA,EACA,iBAAA,EAAA,kBAAA,EAAA,kBAAA,EAAA,UAAA,EACA,UAAA,KAEF,UACE,iBAAA,EAAA,aAAA,EAAA,EAAA,KAAA,SAAA,EAAA,EAAA,KAAA,KAAA,EAAA,EAAA,KACA,MAAA,KAIA,OF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,UAAA,SAAA,EAAA,EAAA,UAAA,KAAA,EAAA,EAAA,UAKA,UAAA,UElCM,OF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,OF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,IAAA,SAAA,EAAA,EAAA,IAAA,KAAA,EAAA,EAAA,IAKA,UAAA,IElCM,OF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,OF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,OF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,IAAA,SAAA,EAAA,EAAA,IAAA,KAAA,EAAA,EAAA,IAKA,UAAA,IElCM,OF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,OF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,OF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,IAAA,SAAA,EAAA,EAAA,IAAA,KAAA,EAAA,EAAA,IAKA,UAAA,IElCM,QF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,QF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,QF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,KAAA,SAAA,EAAA,EAAA,KAAA,KAAA,EAAA,EAAA,KAKA,UAAA,KE3BQ,QFuCR,MAAA,KEvCQ,QFuCR,MAAA,UEvCQ,QFuCR,MAAA,WEvCQ,QFuCR,MAAA,IEvCQ,QFuCR,MAAA,WEvCQ,QFuCR,MAAA,WEvCQ,QFuCR,MAAA,IEvCQ,QFuCR,MAAA,WEvCQ,QFuCR,MAAA,WEvCQ,QFuCR,MAAA,IEvCQ,SFuCR,MAAA,WEvCQ,SFuCR,MAAA,WEvCQ,SFuCR,MAAA,KEvCQ,QFmCR,KAAA,KEnCQ,QFmCR,KAAA,UEnCQ,QFmCR,KAAA,WEnCQ,QFmCR,KAAA,IEnCQ,QFmCR,KAAA,WEnCQ,QFmCR,KAAA,WEnCQ,QFmCR,KAAA,IEnCQ,QFmCR,KAAA,WEnCQ,QFmCR,KAAA,WEnCQ,QFmCR,KAAA,IEnCQ,SFmCR,KAAA,WEnCQ,SFmCR,KAAA,WEnCQ,SFmCR,KAAA,KE1BQ,UFsBR,YAAA,UEtBQ,UFsBR,YAAA,WEtBQ,UFsBR,YAAA,IEtBQ,UFsBR,YAAA,WEtBQ,UFsBR,YAAA,WEtBQ,UFsBR,YAAA,IEtBQ,UFsBR,YAAA,WEtBQ,UFsBR,YAAA,WEtBQ,UFsBR,YAAA,IEtBQ,WFsBR,YAAA,WEtBQ,WFsBR,YAAA,WCvBE,yBC1BE,QACE,mBAAA,EAAA,wBAAA,EAAA,WAAA,EACA,iBAAA,EAAA,kBAAA,EAAA,kBAAA,EAAA,UAAA,EACA,UAAA,KAEF,aACE,iBAAA,EAAA,aAAA,EAAA,EAAA,KAAA,SAAA,EAAA,EAAA,KAAA,KAAA,EAAA,EAAA,KACA,MAAA,KAIA,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,UAAA,SAAA,EAAA,EAAA,UAAA,KAAA,EAAA,EAAA,UAKA,UAAA,UElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,IAAA,SAAA,EAAA,EAAA,IAAA,KAAA,EAAA,EAAA,IAKA,UAAA,IElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,IAAA,SAAA,EAAA,EAAA,IAAA,KAAA,EAAA,EAAA,IAKA,UAAA,IElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,IAAA,SAAA,EAAA,EAAA,IAAA,KAAA,EAAA,EAAA,IAKA,UAAA,IElCM,WF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,WF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,WF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,KAAA,SAAA,EAAA,EAAA,KAAA,KAAA,EAAA,EAAA,KAKA,UAAA,KE3BQ,WFuCR,MAAA,KEvCQ,WFuCR,MAAA,UEvCQ,WFuCR,MAAA,WEvCQ,WFuCR,MAAA,IEvCQ,WFuCR,MAAA,WEvCQ,WFuCR,MAAA,WEvCQ,WFuCR,MAAA,IEvCQ,WFuCR,MAAA,WEvCQ,WFuCR,MAAA,WEvCQ,WFuCR,MAAA,IEvCQ,YFuCR,MAAA,WEvCQ,YFuCR,MAAA,WEvCQ,YFuCR,MAAA,KEvCQ,WFmCR,KAAA,KEnCQ,WFmCR,KAAA,UEnCQ,WFmCR,KAAA,WEnCQ,WFmCR,KAAA,IEnCQ,WFmCR,KAAA,WEnCQ,WFmCR,KAAA,WEnCQ,WFmCR,KAAA,IEnCQ,WFmCR,KAAA,WEnCQ,WFmCR,KAAA,WEnCQ,WFmCR,KAAA,IEnCQ,YFmCR,KAAA,WEnCQ,YFmCR,KAAA,WEnCQ,YFmCR,KAAA,KE1BQ,aFsBR,YAAA,EEtBQ,aFsBR,YAAA,UEtBQ,aFsBR,YAAA,WEtBQ,aFsBR,YAAA,IEtBQ,aFsBR,YAAA,WEtBQ,aFsBR,YAAA,WEtBQ,aFsBR,YAAA,IEtBQ,aFsBR,YAAA,WEtBQ,aFsBR,YAAA,WEtBQ,aFsBR,YAAA,IEtBQ,cFsBR,YAAA,WEtBQ,cFsBR,YAAA,YCvBE,yBC1BE,QACE,mBAAA,EAAA,wBAAA,EAAA,WAAA,EACA,iBAAA,EAAA,kBAAA,EAAA,kBAAA,EAAA,UAAA,EACA,UAAA,KAEF,aACE,iBAAA,EAAA,aAAA,EAAA,EAAA,KAAA,SAAA,EAAA,EAAA,KAAA,KAAA,EAAA,EAAA,KACA,MAAA,KAIA,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,UAAA,SAAA,EAAA,EAAA,UAAA,KAAA,EAAA,EAAA,UAKA,UAAA,UElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,IAAA,SAAA,EAAA,EAAA,IAAA,KAAA,EAAA,EAAA,IAKA,UAAA,IElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,IAAA,SAAA,EAAA,EAAA,IAAA,KAAA,EAAA,EAAA,IAKA,UAAA,IElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,IAAA,SAAA,EAAA,EAAA,IAAA,KAAA,EAAA,EAAA,IAKA,UAAA,IElCM,WF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,WF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,WF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,KAAA,SAAA,EAAA,EAAA,KAAA,KAAA,EAAA,EAAA,KAKA,UAAA,KE3BQ,WFuCR,MAAA,KEvCQ,WFuCR,MAAA,UEvCQ,WFuCR,MAAA,WEvCQ,WFuCR,MAAA,IEvCQ,WFuCR,MAAA,WEvCQ,WFuCR,MAAA,WEvCQ,WFuCR,MAAA,IEvCQ,WFuCR,MAAA,WEvCQ,WFuCR,MAAA,WEvCQ,WFuCR,MAAA,IEvCQ,YFuCR,MAAA,WEvCQ,YFuCR,MAAA,WEvCQ,YFuCR,MAAA,KEvCQ,WFmCR,KAAA,KEnCQ,WFmCR,KAAA,UEnCQ,WFmCR,KAAA,WEnCQ,WFmCR,KAAA,IEnCQ,WFmCR,KAAA,WEnCQ,WFmCR,KAAA,WEnCQ,WFmCR,KAAA,IEnCQ,WFmCR,KAAA,WEnCQ,WFmCR,KAAA,WEnCQ,WFmCR,KAAA,IEnCQ,YFmCR,KAAA,WEnCQ,YFmCR,KAAA,WEnCQ,YFmCR,KAAA,KE1BQ,aFsBR,YAAA,EEtBQ,aFsBR,YAAA,UEtBQ,aFsBR,YAAA,WEtBQ,aFsBR,YAAA,IEtBQ,aFsBR,YAAA,WEtBQ,aFsBR,YAAA,WEtBQ,aFsBR,YAAA,IEtBQ,aFsBR,YAAA,WEtBQ,aFsBR,YAAA,WEtBQ,aFsBR,YAAA,IEtBQ,cFsBR,YAAA,WEtBQ,cFsBR,YAAA,YCvBE,yBC1BE,QACE,mBAAA,EAAA,wBAAA,EAAA,WAAA,EACA,iBAAA,EAAA,kBAAA,EAAA,kBAAA,EAAA,UAAA,EACA,UAAA,KAEF,aACE,iBAAA,EAAA,aAAA,EAAA,EAAA,KAAA,SAAA,EAAA,EAAA,KAAA,KAAA,EAAA,EAAA,KACA,MAAA,KAIA,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,UAAA,SAAA,EAAA,EAAA,UAAA,KAAA,EAAA,EAAA,UAKA,UAAA,UElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,IAAA,SAAA,EAAA,EAAA,IAAA,KAAA,EAAA,EAAA,IAKA,UAAA,IElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,IAAA,SAAA,EAAA,EAAA,IAAA,KAAA,EAAA,EAAA,IAKA,UAAA,IElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,IAAA,SAAA,EAAA,EAAA,IAAA,KAAA,EAAA,EAAA,IAKA,UAAA,IElCM,WF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,WF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,WF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,KAAA,SAAA,EAAA,EAAA,KAAA,KAAA,EAAA,EAAA,KAKA,UAAA,KE3BQ,WFuCR,MAAA,KEvCQ,WFuCR,MAAA,UEvCQ,WFuCR,MAAA,WEvCQ,WFuCR,MAAA,IEvCQ,WFuCR,MAAA,WEvCQ,WFuCR,MAAA,WEvCQ,WFuCR,MAAA,IEvCQ,WFuCR,MAAA,WEvCQ,WFuCR,MAAA,WEvCQ,WFuCR,MAAA,IEvCQ,YFuCR,MAAA,WEvCQ,YFuCR,MAAA,WEvCQ,YFuCR,MAAA,KEvCQ,WFmCR,KAAA,KEnCQ,WFmCR,KAAA,UEnCQ,WFmCR,KAAA,WEnCQ,WFmCR,KAAA,IEnCQ,WFmCR,KAAA,WEnCQ,WFmCR,KAAA,WEnCQ,WFmCR,KAAA,IEnCQ,WFmCR,KAAA,WEnCQ,WFmCR,KAAA,WEnCQ,WFmCR,KAAA,IEnCQ,YFmCR,KAAA,WEnCQ,YFmCR,KAAA,WEnCQ,YFmCR,KAAA,KE1BQ,aFsBR,YAAA,EEtBQ,aFsBR,YAAA,UEtBQ,aFsBR,YAAA,WEtBQ,aFsBR,YAAA,IEtBQ,aFsBR,YAAA,WEtBQ,aFsBR,YAAA,WEtBQ,aFsBR,YAAA,IEtBQ,aFsBR,YAAA,WEtBQ,aFsBR,YAAA,WEtBQ,aFsBR,YAAA,IEtBQ,cFsBR,YAAA,WEtBQ,cFsBR,YAAA,YCvBE,0BC1BE,QACE,mBAAA,EAAA,wBAAA,EAAA,WAAA,EACA,iBAAA,EAAA,kBAAA,EAAA,kBAAA,EAAA,UAAA,EACA,UAAA,KAEF,aACE,iBAAA,EAAA,aAAA,EAAA,EAAA,KAAA,SAAA,EAAA,EAAA,KAAA,KAAA,EAAA,EAAA,KACA,MAAA,KAIA,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,UAAA,SAAA,EAAA,EAAA,UAAA,KAAA,EAAA,EAAA,UAKA,UAAA,UElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,IAAA,SAAA,EAAA,EAAA,IAAA,KAAA,EAAA,EAAA,IAKA,UAAA,IElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,IAAA,SAAA,EAAA,EAAA,IAAA,KAAA,EAAA,EAAA,IAKA,UAAA,IElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,UF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,IAAA,SAAA,EAAA,EAAA,IAAA,KAAA,EAAA,EAAA,IAKA,UAAA,IElCM,WF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,WF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,WAAA,SAAA,EAAA,EAAA,WAAA,KAAA,EAAA,EAAA,WAKA,UAAA,WElCM,WF6BN,iBAAA,EAAA,aAAA,EAAA,EAAA,KAAA,SAAA,EAAA,EAAA,KAAA,KAAA,EAAA,EAAA,KAKA,UAAA,KE3BQ,WFuCR,MAAA,KEvCQ,WFuCR,MAAA,UEvCQ,WFuCR,MAAA,WEvCQ,WFuCR,MAAA,IEvCQ,WFuCR,MAAA,WEvCQ,WFuCR,MAAA,WEvCQ,WFuCR,MAAA,IEvCQ,WFuCR,MAAA,WEvCQ,WFuCR,MAAA,WEvCQ,WFuCR,MAAA,IEvCQ,YFuCR,MAAA,WEvCQ,YFuCR,MAAA,WEvCQ,YFuCR,MAAA,KEvCQ,WFmCR,KAAA,KEnCQ,WFmCR,KAAA,UEnCQ,WFmCR,KAAA,WEnCQ,WFmCR,KAAA,IEnCQ,WFmCR,KAAA,WEnCQ,WFmCR,KAAA,WEnCQ,WFmCR,KAAA,IEnCQ,WFmCR,KAAA,WEnCQ,WFmCR,KAAA,WEnCQ,WFmCR,KAAA,IEnCQ,YFmCR,KAAA,WEnCQ,YFmCR,KAAA,WEnCQ,YFmCR,KAAA,KE1BQ,aFsBR,YAAA,EEtBQ,aFsBR,YAAA,UEtBQ,aFsBR,YAAA,WEtBQ,aFsBR,YAAA,IEtBQ,aFsBR,YAAA,WEtBQ,aFsBR,YAAA,WEtBQ,aFsBR,YAAA,IEtBQ,aFsBR,YAAA,WEtBQ,aFsBR,YAAA,WEtBQ,aFsBR,YAAA,IEtBQ,cFsBR,YAAA,WEtBQ,cFsBR,YAAA,YG3EF,OACE,MAAA,KACA,UAAA,KACA,cAAA,KAHF,UAAA,UAOI,QAAA,OACA,eAAA,IACA,WAAA,IAAA,MAAA,QATJ,gBAaI,eAAA,OACA,cAAA,IAAA,MAAA,QAdJ,mBAkBI,WAAA,IAAA,MAAA,QAlBJ,cAsBI,iBAAA,KASJ,aAAA,aAGI,QAAA,MASJ,gBACE,OAAA,IAAA,MAAA,QADF,mBAAA,mBAKI,OAAA,IAAA,MAAA,QALJ,yBAAA,yBAWM,oBAAA,IAUN,yCAEI,iBAAA,gBASJ,4BAGM,iBAAA,iBC7EJ,cAAA,iBAAA,iBAII,iBAAA,iBAMJ,iCAKM,iBAAA,iBALN,oCAAA,oCASQ,iBAAA,iBAnBR,eAAA,kBAAA,kBAII,iBAAA,QAMJ,kCAKM,iBAAA,QALN,qCAAA,qCASQ,iBAAA,QAnBR,YAAA,eAAA,eAII,iBAAA,QAMJ,+BAKM,iBAAA,QALN,kCAAA,kCASQ,iBAAA,QAnBR,eAAA,kBAAA,kBAII,iBAAA,QAMJ,kCAKM,iBAAA,QALN,qCAAA,qCASQ,iBAAA,QAnBR,cAAA,iBAAA,iBAII,iBAAA,QAMJ,iCAKM,iBAAA,QALN,oCAAA,oCASQ,iBAAA,QDiFV,kBAEI,MAAA,KACA,iBAAA,QAIJ,kBAEI,MAAA,QACA,iBAAA,QAIJ,eACE,MAAA,KACA,iBAAA,QAFF,kBAAA,kBAAA,wBAOI,aAAA,KAPJ,8BAWI,OAAA,EAYJ,kBACE,QAAA,MACA,MAAA,KACA,WAAA,KACA,mBAAA,yBAJF,iCAQI,OAAA,EEhJJ,cACE,QAAA,MACA,MAAA,KAGA,QAAA,MAAA,OACA,UAAA,KACA,YAAA,KACA,MAAA,QACA,iBAAA,KAEA,iBAAA,KACA,wBAAA,YAAA,gBAAA,YACA,OAAA,IAAA,MAAA,gBAKE,cAAA,ORTE,mBAAA,aAAA,YAAA,KAAA,mBAAA,YAAA,KAAA,WAAA,aAAA,YAAA,KAAA,mBAAA,YAAA,KAAA,cAAA,aAAA,YAAA,KAAA,WAAA,YAAA,KAAA,WAAA,aAAA,YAAA,KAAA,WAAA,YAAA,KAAA,WAAA,aAAA,YAAA,KAAA,WAAA,YAAA,KAAA,mBAAA,YAAA,KQTN,0BA6BI,iBAAA,YACA,OAAA,ECSF,oBACE,MAAA,QACA,iBAAA,KACA,aAAA,QACA,QAAA,ED3CJ,yCAsCI,MAAA,QAEA,QAAA,EAxCJ,gCAsCI,MAAA,QAEA,QAAA,EAxCJ,oCAsCI,MAAA,QAEA,QAAA,EAxCJ,2BAsCI,MAAA,QAEA,QAAA,EAxCJ,uBAAwB,wBAkDpB,iBAAA,QAEA,QAAA,EApDJ,uBAwDI,OAAA,YAIJ,gDAGI,OAAA,oBAHJ,qCAYI,MAAA,QACA,iBAAA,KAKJ,mBAAA,oBAEE,QAAA,MAUF,gBACE,YAAA,sBACA,eAAA,sBACA,cAAA,EAGF,mBACE,YAAA,uBACA,eAAA,uBACA,UAAA,QAGF,mBACE,YAAA,uBACA,eAAA,uBACA,UAAA,QAUF,iBACE,YAAA,MACA,eAAA,MACA,cAAA,EACA,UAAA,KASF,qBACE,YAAA,MACA,eAAA,MACA,cAAA,EACA,YAAA,KACA,OAAA,MAAA,YACA,aAAA,IAAA,EAN6D,qCAA/D,qCAAqG,kDAArG,uDAAA,0DAAsC,kDAAtC,uDAAA,0DAUI,cAAA,EACA,aAAA,EAaJ,iBAAkB,8BAAlB,mCAAA,sCACE,QAAA,OAAA,MACA,UAAA,QT5JE,cAAA,MSgKJ,wEAAoD,gEAApD,qEAAA,mDAEI,OAAA,UAIJ,iBAAkB,8BAAlB,mCAAA,sCACE,QAAA,OAAA,OACA,UAAA,QTxKE,cAAA,MS4KJ,wEAAoD,gEAApD,qEAAA,mDAEI,OAAA,YAUJ,YACE,cAAA,KAGF,WACE,QAAA,MACA,WAAA,OAQF,YACE,SAAA,SACA,QAAA,MACA,cAAA,MAHF,uCAOM,MAAA,QACA,OAAA,YAKN,kBACE,aAAA,QACA,cAAA,EACA,OAAA,QAGF,kBACE,SAAA,SACA,WAAA,OACA,YAAA,SAHF,6BAMI,SAAA,OAKJ,mBACE,QAAA,aADF,qCAII,eAAA,OAJJ,sCAQI,YAAA,OASJ,uBACE,WAAA,OAGF,qBAAA,sBAAA,sBAGE,cAAA,QACA,kBAAA,UACA,oBAAA,OAAA,MAAA,SACA,wBAAA,SAAA,SAAA,gBAAA,SAAA,SC5PA,6BAAA,6BAAA,+BAAA,oCAAA,iCAKE,MAAA,QAIF,2BACE,aAAA,QAQF,gCACE,MAAA,QACA,aAAA,QACA,iBAAA,QD2OJ,mCAII,iBAAA,wPCpQF,6BAAA,6BAAA,+BAAA,oCAAA,iCAKE,MAAA,QAIF,2BACE,aAAA,QAQF,gCACE,MAAA,QACA,aAAA,QACA,iBAAA,KDmPJ,mCAII,iBAAA,iUC5QF,4BAAA,4BAAA,8BAAA,mCAAA,gCAKE,MAAA,QAIF,0BACE,aAAA,QAQF,+BACE,MAAA,QACA,aAAA,QACA,iBAAA,QD2PJ,iCAII,iBAAA,kSAcJ,aACE,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,kBAAA,IAAA,KAAA,cAAA,IAAA,KAAA,UAAA,IAAA,KACA,kBAAA,OAAA,oBAAA,OAAA,eAAA,OAAA,YAAA,OAHF,yBASI,MAAA,KJ1PA,yBIiPF,mBAeI,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,kBAAA,OAAA,oBAAA,OAAA,eAAA,OAAA,YAAA,OACA,iBAAA,OAAA,wBAAA,OAAA,cAAA,OAAA,gBAAA,OACA,cAAA,EAlBJ,yBAuBI,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,iBAAA,EAAA,aAAA,EAAA,EAAA,KAAA,SAAA,EAAA,EAAA,KAAA,KAAA,EAAA,EAAA,KACA,kBAAA,IAAA,KAAA,cAAA,IAAA,KAAA,UAAA,IAAA,KACA,kBAAA,OAAA,oBAAA,OAAA,eAAA,OAAA,YAAA,OACA,cAAA,EA3BJ,2BAgCI,QAAA,aACA,MAAA,KACA,eAAA,OAlCJ,kCAuCI,QAAA,aAvCJ,0BA2CI,MAAA,KA3CJ,iCA+CI,cAAA,EACA,eAAA,OAhDJ,yBAsDI,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,kBAAA,OAAA,oBAAA,OAAA,eAAA,OAAA,YAAA,OACA,iBAAA,OAAA,wBAAA,OAAA,cAAA,OAAA,gBAAA,OACA,MAAA,KACA,WAAA,EACA,cAAA,EA3DJ,+BA8DI,aAAA,EA9DJ,+BAiEI,SAAA,SACA,WAAA,EACA,aAAA,OACA,YAAA,EApEJ,6BAyEI,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,kBAAA,OAAA,oBAAA,OAAA,eAAA,OAAA,YAAA,OACA,iBAAA,OAAA,wBAAA,OAAA,cAAA,OAAA,gBAAA,OACA,aAAA,EA5EJ,uCA+EI,SAAA,OACA,QAAA,aACA,aAAA,OACA,eAAA,YAlFJ,kDAuFI,IAAA,GE1XN,KACE,QAAA,aACA,YAAA,IACA,YAAA,KACA,WAAA,OACA,YAAA,OACA,eAAA,OACA,oBAAA,KAAA,iBAAA,KAAA,gBAAA,KAAA,YAAA,KACA,OAAA,IAAA,MAAA,YCoEA,QAAA,MAAA,KACA,UAAA,KZ/EE,cAAA,OCWE,mBAAA,IAAA,IAAA,YAAA,cAAA,IAAA,IAAA,YAAA,WAAA,IAAA,IAAA,YNKF,WAAA,WgBAA,gBAAA,KAdQ,WAAZ,WAkBI,QAAA,EACA,mBAAA,EAAA,EAAA,EAAA,IAAA,oBAAA,WAAA,EAAA,EAAA,EAAA,IAAA,oBAnBJ,cAAe,cAyBX,OAAA,YACA,QAAA,IA1BS,YAAb,YAgCI,iBAAA,KAMJ,eAAA,yBAEE,eAAA,KAQF,aC7CE,MAAA,KACA,iBAAA,QACA,aAAA,QjBDE,mBiBMA,MAAA,KACA,iBAAA,QACA,aAAA,QAEF,mBAAA,mBAMI,mBAAA,EAAA,EAAA,EAAA,IAAA,mBAAA,WAAA,EAAA,EAAA,EAAA,IAAA,mBAKJ,sBAAA,sBAEE,iBAAA,QACA,aAAA,QAGF,oBAAA,oBAAA,mCAGE,MAAA,KACA,iBAAA,QACA,iBAAA,KACA,aAAA,QDcJ,eChDE,MAAA,QACA,iBAAA,KACA,aAAA,KjBDE,qBiBMA,MAAA,QACA,iBAAA,QACA,aAAA,QAEF,qBAAA,qBAMI,mBAAA,EAAA,EAAA,EAAA,IAAA,qBAAA,WAAA,EAAA,EAAA,EAAA,IAAA,qBAKJ,wBAAA,wBAEE,iBAAA,KACA,aAAA,KAGF,sBAAA,sBAAA,qCAGE,MAAA,QACA,iBAAA,QACA,iBAAA,KACA,aAAA,QDiBJ,UCnDE,MAAA,KACA,iBAAA,QACA,aAAA,QjBDE,gBiBMA,MAAA,KACA,iBAAA,QACA,aAAA,QAEF,gBAAA,gBAMI,mBAAA,EAAA,EAAA,EAAA,IAAA,oBAAA,WAAA,EAAA,EAAA,EAAA,IAAA,oBAKJ,mBAAA,mBAEE,iBAAA,QACA,aAAA,QAGF,iBAAA,iBAAA,gCAGE,MAAA,KACA,iBAAA,QACA,iBAAA,KACA,aAAA,QDoBJ,aCtDE,MAAA,KACA,iBAAA,QACA,aAAA,QjBDE,mBiBMA,MAAA,KACA,iBAAA,QACA,aAAA,QAEF,mBAAA,mBAMI,mBAAA,EAAA,EAAA,EAAA,IAAA,mBAAA,WAAA,EAAA,EAAA,EAAA,IAAA,mBAKJ,sBAAA,sBAEE,iBAAA,QACA,aAAA,QAGF,oBAAA,oBAAA,mCAGE,MAAA,KACA,iBAAA,QACA,iBAAA,KACA,aAAA,QDuBJ,aCzDE,MAAA,KACA,iBAAA,QACA,aAAA,QjBDE,mBiBMA,MAAA,KACA,iBAAA,QACA,aAAA,QAEF,mBAAA,mBAMI,mBAAA,EAAA,EAAA,EAAA,IAAA,oBAAA,WAAA,EAAA,EAAA,EAAA,IAAA,oBAKJ,sBAAA,sBAEE,iBAAA,QACA,aAAA,QAGF,oBAAA,oBAAA,mCAGE,MAAA,KACA,iBAAA,QACA,iBAAA,KACA,aAAA,QD0BJ,YC5DE,MAAA,KACA,iBAAA,QACA,aAAA,QjBDE,kBiBMA,MAAA,KACA,iBAAA,QACA,aAAA,QAEF,kBAAA,kBAMI,mBAAA,EAAA,EAAA,EAAA,IAAA,mBAAA,WAAA,EAAA,EAAA,EAAA,IAAA,mBAKJ,qBAAA,qBAEE,iBAAA,QACA,aAAA,QAGF,mBAAA,mBAAA,kCAGE,MAAA,KACA,iBAAA,QACA,iBAAA,KACA,aAAA,QD+BJ,qBCzBE,MAAA,QACA,iBAAA,KACA,iBAAA,YACA,aAAA,QjB1CE,2BiB6CA,MAAA,KACA,iBAAA,QACA,aAAA,QAGF,2BAAA,2BAEE,mBAAA,EAAA,EAAA,EAAA,IAAA,mBAAA,WAAA,EAAA,EAAA,EAAA,IAAA,mBAGF,8BAAA,8BAEE,MAAA,QACA,iBAAA,YAGF,4BAAA,4BAAA,2CAGE,MAAA,KACA,iBAAA,QACA,aAAA,QDCJ,uBC5BE,MAAA,KACA,iBAAA,KACA,iBAAA,YACA,aAAA,KjB1CE,6BiB6CA,MAAA,KACA,iBAAA,KACA,aAAA,KAGF,6BAAA,6BAEE,mBAAA,EAAA,EAAA,EAAA,IAAA,qBAAA,WAAA,EAAA,EAAA,EAAA,IAAA,qBAGF,gCAAA,gCAEE,MAAA,KACA,iBAAA,YAGF,8BAAA,8BAAA,6CAGE,MAAA,KACA,iBAAA,KACA,aAAA,KDIJ,kBC/BE,MAAA,QACA,iBAAA,KACA,iBAAA,YACA,aAAA,QjB1CE,wBiB6CA,MAAA,KACA,iBAAA,QACA,aAAA,QAGF,wBAAA,wBAEE,mBAAA,EAAA,EAAA,EAAA,IAAA,oBAAA,WAAA,EAAA,EAAA,EAAA,IAAA,oBAGF,2BAAA,2BAEE,MAAA,QACA,iBAAA,YAGF,yBAAA,yBAAA,wCAGE,MAAA,KACA,iBAAA,QACA,aAAA,QDOJ,qBClCE,MAAA,QACA,iBAAA,KACA,iBAAA,YACA,aAAA,QjB1CE,2BiB6CA,MAAA,KACA,iBAAA,QACA,aAAA,QAGF,2BAAA,2BAEE,mBAAA,EAAA,EAAA,EAAA,IAAA,mBAAA,WAAA,EAAA,EAAA,EAAA,IAAA,mBAGF,8BAAA,8BAEE,MAAA,QACA,iBAAA,YAGF,4BAAA,4BAAA,2CAGE,MAAA,KACA,iBAAA,QACA,aAAA,QDUJ,qBCrCE,MAAA,QACA,iBAAA,KACA,iBAAA,YACA,aAAA,QjB1CE,2BiB6CA,MAAA,KACA,iBAAA,QACA,aAAA,QAGF,2BAAA,2BAEE,mBAAA,EAAA,EAAA,EAAA,IAAA,oBAAA,WAAA,EAAA,EAAA,EAAA,IAAA,oBAGF,8BAAA,8BAEE,MAAA,QACA,iBAAA,YAGF,4BAAA,4BAAA,2CAGE,MAAA,KACA,iBAAA,QACA,aAAA,QDaJ,oBCxCE,MAAA,QACA,iBAAA,KACA,iBAAA,YACA,aAAA,QjB1CE,0BiB6CA,MAAA,KACA,iBAAA,QACA,aAAA,QAGF,0BAAA,0BAEE,mBAAA,EAAA,EAAA,EAAA,IAAA,mBAAA,WAAA,EAAA,EAAA,EAAA,IAAA,mBAGF,6BAAA,6BAEE,MAAA,QACA,iBAAA,YAGF,2BAAA,2BAAA,0CAGE,MAAA,KACA,iBAAA,QACA,aAAA,QDuBJ,UACE,YAAA,IACA,MAAA,QACA,cAAA,EAHF,UAA6B,iBAAlB,iBAAoC,mBAS3C,iBAAA,YATJ,UAA4B,iBAAjB,gBAeP,aAAA,YhBxGA,gBgB2GA,aAAA,YhBjGA,gBAAA,gBgBoGA,MAAA,QACA,gBAAA,UACA,iBAAA,YAvBJ,mBA0BI,MAAA,QhBzGA,yBAAA,yBgB4GE,gBAAA,KAUG,mBAAT,QCxDE,QAAA,OAAA,OACA,UAAA,QZ/EE,cAAA,MW0IK,mBAAT,QC5DE,QAAA,OAAA,MACA,UAAA,QZ/EE,cAAA,MWoJJ,WACE,QAAA,MACA,MAAA,KAIF,sBACE,WAAA,MAIF,6BAAA,4BAAA,6BAII,MAAA,KEvKJ,MACE,QAAA,EZcI,mBAAA,QAAA,KAAA,OAAA,cAAA,QAAA,KAAA,OAAA,WAAA,QAAA,KAAA,OYfN,WAKI,QAAA,EAIJ,UACE,QAAA,KADF,eAGI,QAAA,MAIJ,iBAEI,QAAA,UAIJ,oBAEI,QAAA,gBAIJ,YACE,SAAA,SACA,OAAA,EACA,SAAA,OZhBI,mBAAA,OAAA,KAAA,KAAA,cAAA,OAAA,KAAA,KAAA,WAAA,OAAA,KAAA,KadN,UAAA,QAEE,SAAA,SAGF,wBAGI,QAAA,aACA,MAAA,EACA,OAAA,EACA,YAAA,KACA,eAAA,OACA,QAAW,GACX,WAAA,KAAA,MACA,aAAA,KAAA,MAAA,YACA,YAAA,KAAA,MAAA,YAXJ,uBAgBI,QAAA,EAIJ,gCAGM,WAAA,EACA,cAAA,KAAA,MAMN,eACE,SAAA,SACA,IAAA,KACA,KAAA,EACA,QAAA,KACA,QAAA,KACA,MAAA,KACA,UAAA,MACA,QAAA,MAAA,EACA,OAAA,QAAA,EAAA,EACA,UAAA,KACA,MAAA,QACA,WAAA,KACA,WAAA,KACA,iBAAA,KACA,wBAAA,YAAA,gBAAA,YACA,OAAA,IAAA,MAAA,gBdhDE,cAAA,OcsDJ,kBCrDE,OAAA,IACA,OAAA,MAAA,EACA,SAAA,OACA,iBAAA,QDyDF,eACE,QAAA,MACA,MAAA,KACA,QAAA,IAAA,OACA,MAAA,KACA,YAAA,IACA,MAAA,QACA,WAAA,QACA,YAAA,OACA,WAAA,IACA,OAAA,EnBvDE,qBAAA,qBmB0DA,MAAA,QACA,gBAAA,KACA,iBAAA,QAfJ,sBAAuB,sBAoBnB,MAAA,KACA,gBAAA,KACA,iBAAA,QAtBJ,wBAAyB,wBA2BrB,MAAA,QACA,OAAA,YACA,iBAAA,YASJ,qBAGI,QAAA,MAHJ,QAQI,QAAA,EAQJ,qBACE,MAAA,EACA,KAAA,KAGF,oBACE,MAAA,KACA,KAAA,EAIF,iBACE,QAAA,MACA,QAAA,MAAA,OACA,cAAA,EACA,UAAA,QACA,MAAA,QACA,YAAA,OAIF,mBACE,SAAA,MACA,IAAA,EACA,MAAA,EACA,OAAA,EACA,KAAA,EACA,QAAA,IAOF,uBAGI,IAAA,KACA,OAAA,KACA,cAAA,QE3JJ,WAAA,oBAEE,SAAA,SACA,QAAA,mBAAA,QAAA,oBAAA,QAAA,mBAAA,QAAA,YACA,eAAA,OAJF,yBAAA,gBAOI,SAAA,SACA,iBAAA,EAAA,aAAA,EAAA,EAAA,KAAA,SAAA,EAAA,EAAA,KAAA,KAAA,EAAA,EAAA,KARJ,+BAAA,sBAaM,QAAA,EAbN,gCAAA,gCAAA,+BAAmD,uBAA1B,uBAAzB,sBAkBM,QAAA,EAlBN,qBAAA,2BAAA,2BAAA,iCAAA,8BAAA,oCAAA,oCAAA,0CA2BI,YAAA,KAKJ,aACE,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,iBAAA,MAAA,wBAAA,WAAA,cAAA,MAAA,gBAAA,WAFF,0BAKI,MAAA,KAIJ,yEACE,cAAA,EAIF,4BACE,YAAA,EADF,mEhBhCI,2BAAA,EACA,wBAAA,EgBuCJ,6CAAA,8ChB1BI,0BAAA,EACA,uBAAA,EgB+BJ,sBACE,MAAA,KAEF,8DACE,cAAA,EAEF,mEAAA,oEhBpDI,2BAAA,EACA,wBAAA,EgByDJ,oEhB5CI,0BAAA,EACA,uBAAA,EgBgDJ,mCAAA,iCAEE,QAAA,EAgBF,4BACE,cAAA,OACA,aAAA,OAFF,mCAKI,YAAA,EAI8B,0CAAlC,+BACE,cAAA,QACA,aAAA,QAGgC,0CAAlC,+BACE,cAAA,SACA,aAAA,SAoBF,oBACE,QAAA,mBAAA,QAAA,oBAAA,QAAA,mBAAA,QAAA,YACA,mBAAA,SAAA,sBAAA,OAAA,uBAAA,OAAA,mBAAA,OAAA,eAAA,OACA,kBAAA,MAAA,oBAAA,WAAA,eAAA,MAAA,YAAA,WACA,iBAAA,OAAA,wBAAA,OAAA,cAAA,OAAA,gBAAA,OAJF,yBAAA,+BAQI,MAAA,KARJ,8BAAA,oCAAA,oCAAA,0CAeI,WAAA,KACA,YAAA,EAIJ,4DAEI,cAAA,EAFJ,sDhBlII,2BAAA,EACA,0BAAA,EgBiIJ,sDhBhJI,wBAAA,EACA,uBAAA,EgB0JJ,uEACE,cAAA,EAEF,4EAAA,6EhBhJI,2BAAA,EACA,0BAAA,EgBqJJ,6EhBpKI,wBAAA,EACA,uBAAA,ET0gGJ,gDAAA,6CAAA,2DAAA,wDyBj1FM,SAAA,SACA,KAAA,cACA,eAAA,KClMN,aACE,SAAA,SACA,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,MAAA,KAHF,2BAQI,SAAA,SACA,QAAA,EACA,iBAAA,EAAA,aAAA,EAAA,EAAA,KAAA,SAAA,EAAA,EAAA,KAAA,KAAA,EAAA,EAAA,KAGA,MAAA,GACA,cAAA,EAd8B,kCAAlC,iCAAqE,iCAkB/D,QAAA,EAKN,2BAAA,mBAAA,iBAIE,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,mBAAA,SAAA,sBAAA,OAAA,uBAAA,OAAA,mBAAA,OAAA,eAAA,OACA,iBAAA,OAAA,wBAAA,OAAA,cAAA,OAAA,gBAAA,OANF,8DAAA,sDAAA,oDjBvBI,cAAA,EiBoCJ,mBAAA,iBAEE,YAAA,OACA,eAAA,OAyBF,mBACE,QAAA,MAAA,OACA,cAAA,EACA,UAAA,KACA,YAAA,IACA,YAAA,KACA,MAAA,QACA,WAAA,OACA,iBAAA,QACA,OAAA,IAAA,MAAA,gBjBzEE,cAAA,OiBgEJ,mCAAA,mCAAA,wDAcI,QAAA,OAAA,MACA,UAAA,QjB/EA,cAAA,MiBgEJ,mCAAA,mCAAA,wDAmBI,QAAA,OAAA,OACA,UAAA,QjBpFA,cAAA,MiBgEJ,wCAAA,qCA4BI,WAAA,EAUJ,4CAAA,oCAAA,oEAAA,+EAAA,uCAAA,kDAAA,mDjBzFI,2BAAA,EACA,wBAAA,EiBiGJ,oCACE,aAAA,EAEF,6CAAA,qCAAA,wCAAA,mDAAA,oDAAA,oEAAA,yDjBvFI,0BAAA,EACA,uBAAA,EiB+FJ,mDACE,YAAA,EAOF,iBACE,SAAA,SAGA,UAAA,EACA,YAAA,OALF,sBAUI,SAAA,SAEA,iBAAA,EAAA,aAAA,EAAA,EAAA,GAAA,SAAA,EAAA,EAAA,GAAA,KAAA,EAAA,EAAA,GAZJ,2BAeM,YAAA,KAfyB,6BAA/B,4BAA+D,4BAoBzD,QAAA,EApBN,uCAAA,6CA4BM,aAAA,KA5BN,wCAAA,8CAkCM,QAAA,EACA,YAAA,KAnCN,qDAAA,oDAAA,oDAAiD,+CAAjD,8CAAmG,8CAsC3F,QAAA,EClKR,gBACE,SAAA,SACA,QAAA,mBAAA,QAAA,oBAAA,QAAA,mBAAA,QAAA,YACA,WAAA,OACA,aAAA,OACA,aAAA,KACA,OAAA,QAGF,sBACE,SAAA,SACA,QAAA,GACA,QAAA,EAHF,wDAMI,MAAA,KACA,iBAAA,QAPJ,sDAaI,mBAAA,EAAA,EAAA,EAAA,IAAA,KAAA,EAAA,EAAA,EAAA,IAAA,QAAA,WAAA,EAAA,EAAA,EAAA,IAAA,KAAA,EAAA,EAAA,EAAA,IAAA,QAbJ,uDAiBI,MAAA,KACA,iBAAA,QAlBJ,yDAwBM,OAAA,YACA,iBAAA,QAzBN,2DA6BM,MAAA,QACA,OAAA,YASN,0BACE,SAAA,SACA,IAAA,OACA,KAAA,EACA,QAAA,MACA,MAAA,KACA,OAAA,KACA,eAAA,KACA,oBAAA,KAAA,iBAAA,KAAA,gBAAA,KAAA,YAAA,KACA,iBAAA,KACA,kBAAA,UACA,oBAAA,OAAA,OACA,wBAAA,IAAA,IAAA,gBAAA,IAAA,IAQF,2ClB3EI,cAAA,OkB2EJ,yEAMI,iBAAA,yMANJ,+EAUI,iBAAA,QACA,iBAAA,sJASJ,wCAEI,cAAA,IAFJ,sEAMI,iBAAA,mJAUJ,yBACE,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,mBAAA,SAAA,sBAAA,OAAA,uBAAA,OAAA,mBAAA,OAAA,eAAA,OAFF,yCAKI,cAAA,OALJ,yDAQM,YAAA,EAYN,eACE,QAAA,aACA,UAAA,KAEA,OAAA,oBACA,QAAA,QAAA,QAAA,QAAA,OACA,YAAA,KACA,MAAA,QACA,eAAA,OACA,WAAA,KAAA,oKAAA,UAAA,MAAA,OAAA,OACA,wBAAA,IAAA,KAAA,gBAAA,IAAA,KACA,OAAA,IAAA,MAAA,gBlB9IE,cAAA,OkBiJF,gBAAA,KACA,mBAAA,KAfF,qBAkBI,aAAA,QACA,QAAA,EAnBJ,gCA4BM,MAAA,QACA,iBAAA,KA7BN,wBAkCI,MAAA,QACA,OAAA,YACA,iBAAA,QApCJ,2BAyCI,QAAA,EAIJ,kBACE,YAAA,QACA,eAAA,QACA,UAAA,IAaF,aACE,SAAA,SACA,QAAA,aACA,UAAA,KACA,OAAA,OACA,cAAA,EACA,OAAA,QAGF,mBACE,UAAA,MACA,UAAA,KACA,OAAA,OACA,OAAA,EACA,OAAA,iBACA,QAAA,EAOF,qBACE,SAAA,SACA,IAAA,EACA,MAAA,EACA,KAAA,EACA,QAAA,EACA,OAAA,OACA,QAAA,MAAA,KACA,YAAA,IACA,MAAA,QACA,eAAA,KACA,oBAAA,KAAA,iBAAA,KAAA,gBAAA,KAAA,YAAA,KACA,iBAAA,KACA,OAAA,IAAA,MAAA,gBlBnOE,cAAA,OkBsNJ,qCAmBM,QxB8SkB,iBwBjUxB,6BAwBI,SAAA,SACA,IAAA,KACA,MAAA,KACA,OAAA,KACA,QAAA,EACA,QAAA,MACA,OAAA,OACA,QAAA,MAAA,KACA,YAAA,IACA,MAAA,QACA,iBAAA,QACA,OAAA,IAAA,MAAA,gBlBzPA,cAAA,EAAA,OAAA,OAAA,EkBsNJ,sCAyCM,QxB2RU,SyBzhBhB,KACE,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,aAAA,EACA,cAAA,EACA,WAAA,KAGF,UACE,QAAA,MACA,QAAA,KAAA,IxBME,gBAAA,gBwBHA,gBAAA,KALJ,mBAUI,MAAA,QACA,OAAA,YASJ,UACE,cAAA,IAAA,MAAA,KADF,oBAII,cAAA,KAJJ,oBAQI,OAAA,IAAA,MAAA,YnB9BA,wBAAA,OACA,uBAAA,OmBqBJ,0BAA2B,0BAYrB,aAAA,QAAA,QAAA,KAZN,6BAgBM,MAAA,QACA,iBAAA,YACA,aAAA,YAlBN,mCAAA,2BAwBI,MAAA,QACA,iBAAA,KACA,aAAA,KAAA,KAAA,KA1BJ,yBA+BI,WAAA,KnBrDA,wBAAA,EACA,uBAAA,EmB+DJ,qBnBtEI,cAAA,OmBsEJ,oCAAA,4BAOI,MAAA,KACA,OAAA,QACA,iBAAA,QASJ,oBAEI,iBAAA,EAAA,aAAA,EAAA,EAAA,KAAA,SAAA,EAAA,EAAA,KAAA,KAAA,EAAA,EAAA,KACA,WAAA,OAIJ,yBAEI,iBAAA,EAAA,aAAA,EAAA,EAAA,KAAA,SAAA,EAAA,EAAA,KAAA,KAAA,EAAA,EAAA,KACA,WAAA,OASJ,uBAEI,QAAA,KAFJ,qBAKI,QAAA,MCnGJ,QACE,SAAA,SACA,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,mBAAA,SAAA,sBAAA,OAAA,uBAAA,OAAA,mBAAA,OAAA,eAAA,OACA,QAAA,MAAA,KAQF,cACE,QAAA,aACA,YAAA,OACA,eAAA,OACA,aAAA,KACA,UAAA,QACA,YAAA,QACA,YAAA,OzBhBE,oBAAA,oByBmBA,gBAAA,KASJ,YACE,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,mBAAA,SAAA,sBAAA,OAAA,uBAAA,OAAA,mBAAA,OAAA,eAAA,OACA,aAAA,EACA,cAAA,EACA,WAAA,KALF,sBAQI,cAAA,EACA,aAAA,EASJ,aACE,QAAA,aACA,YAAA,QACA,eAAA,QAUF,gBACE,mBAAA,WAAA,oBAAA,MAAA,WAAA,WACA,QAAA,OAAA,OACA,UAAA,QACA,YAAA,EACA,WAAA,IACA,OAAA,IAAA,MAAA,YpBjFE,cAAA,OLgBA,sBAAA,sByBqEA,gBAAA,KAMJ,qBACE,QAAA,aACA,MAAA,MACA,OAAA,MACA,eAAA,OACA,QAAW,GACX,WAAA,UAAA,OAAA,OACA,wBAAA,KAAA,KAAA,gBAAA,KAAA,KAKF,qBACE,SAAA,SACA,KAAA,KAEF,sBACE,SAAA,SACA,MAAA,Kf5CE,yBeiDF,8CASU,SAAA,OACA,MAAA,KAVV,8BAeQ,cAAA,EACA,aAAA,Gf9EN,yBe8DF,mBAqBM,mBAAA,WAAA,sBAAA,OAAA,uBAAA,IAAA,mBAAA,IAAA,eAAA,IACA,kBAAA,OAAA,cAAA,OAAA,UAAA,OACA,kBAAA,OAAA,oBAAA,OAAA,eAAA,OAAA,YAAA,OAvBN,+BA0BQ,mBAAA,WAAA,sBAAA,OAAA,uBAAA,IAAA,mBAAA,IAAA,eAAA,IA1BR,yCA6BU,cAAA,MACA,aAAA,MA9BV,8BAoCQ,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,kBAAA,OAAA,cAAA,OAAA,UAAA,OACA,kBAAA,OAAA,oBAAA,OAAA,eAAA,OAAA,YAAA,OAtCR,oCA2CQ,QAAA,sBAAA,QAAA,uBAAA,QAAA,sBAAA,QAAA,eACA,MAAA,KA5CR,mCAiDQ,QAAA,MflGN,yBesDA,iDAIQ,SAAA,OACA,MAAA,KALR,iCAUM,cAAA,EACA,aAAA,Gf9EN,yBemEA,sBAgBI,mBAAA,WAAA,sBAAA,OAAA,uBAAA,IAAA,mBAAA,IAAA,eAAA,IACA,kBAAA,OAAA,cAAA,OAAA,UAAA,OACA,kBAAA,OAAA,oBAAA,OAAA,eAAA,OAAA,YAAA,OAlBJ,kCAqBM,mBAAA,WAAA,sBAAA,OAAA,uBAAA,IAAA,mBAAA,IAAA,eAAA,IArBN,4CAwBQ,cAAA,MACA,aAAA,MAzBR,iCA+BM,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,kBAAA,OAAA,cAAA,OAAA,UAAA,OACA,kBAAA,OAAA,oBAAA,OAAA,eAAA,OAAA,YAAA,OAjCN,uCAsCM,QAAA,sBAAA,QAAA,uBAAA,QAAA,sBAAA,QAAA,eACA,MAAA,KAvCN,sCA4CM,QAAA,MflGN,yBesDA,iDAIQ,SAAA,OACA,MAAA,KALR,iCAUM,cAAA,EACA,aAAA,Gf9EN,yBemEA,sBAgBI,mBAAA,WAAA,sBAAA,OAAA,uBAAA,IAAA,mBAAA,IAAA,eAAA,IACA,kBAAA,OAAA,cAAA,OAAA,UAAA,OACA,kBAAA,OAAA,oBAAA,OAAA,eAAA,OAAA,YAAA,OAlBJ,kCAqBM,mBAAA,WAAA,sBAAA,OAAA,uBAAA,IAAA,mBAAA,IAAA,eAAA,IArBN,4CAwBQ,cAAA,MACA,aAAA,MAzBR,iCA+BM,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,kBAAA,OAAA,cAAA,OAAA,UAAA,OACA,kBAAA,OAAA,oBAAA,OAAA,eAAA,OAAA,YAAA,OAjCN,uCAsCM,QAAA,sBAAA,QAAA,uBAAA,QAAA,sBAAA,QAAA,eACA,MAAA,KAvCN,sCA4CM,QAAA,MflGN,0BesDA,iDAIQ,SAAA,OACA,MAAA,KALR,iCAUM,cAAA,EACA,aAAA,Gf9EN,0BemEA,sBAgBI,mBAAA,WAAA,sBAAA,OAAA,uBAAA,IAAA,mBAAA,IAAA,eAAA,IACA,kBAAA,OAAA,cAAA,OAAA,UAAA,OACA,kBAAA,OAAA,oBAAA,OAAA,eAAA,OAAA,YAAA,OAlBJ,kCAqBM,mBAAA,WAAA,sBAAA,OAAA,uBAAA,IAAA,mBAAA,IAAA,eAAA,IArBN,4CAwBQ,cAAA,MACA,aAAA,MAzBR,iCA+BM,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,kBAAA,OAAA,cAAA,OAAA,UAAA,OACA,kBAAA,OAAA,oBAAA,OAAA,eAAA,OAAA,YAAA,OAjCN,uCAsCM,QAAA,sBAAA,QAAA,uBAAA,QAAA,sBAAA,QAAA,eACA,MAAA,KAvCN,sCA4CM,QAAA,MA5CN,sBAgBI,mBAAA,WAAA,sBAAA,OAAA,uBAAA,IAAA,mBAAA,IAAA,eAAA,IACA,kBAAA,OAAA,cAAA,OAAA,UAAA,OACA,kBAAA,OAAA,oBAAA,OAAA,eAAA,OAAA,YAAA,OAlBJ,iDAIQ,SAAA,OACA,MAAA,KALR,iCAUM,cAAA,EACA,aAAA,EAXN,kCAqBM,mBAAA,WAAA,sBAAA,OAAA,uBAAA,IAAA,mBAAA,IAAA,eAAA,IArBN,4CAwBQ,cAAA,MACA,aAAA,MAzBR,iCA+BM,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,kBAAA,OAAA,cAAA,OAAA,UAAA,OACA,kBAAA,OAAA,oBAAA,OAAA,eAAA,OAAA,YAAA,OAjCN,uCAsCM,QAAA,sBAAA,QAAA,uBAAA,QAAA,sBAAA,QAAA,eACA,MAAA,KAvCN,sCA4CM,QAAA,KAaV,4BAAA,8BAGI,MAAA,eAHJ,kCAAmC,kCAAnC,oCAAA,oCAMM,MAAA,eANN,oCAYM,MAAA,eAZN,0CAA2C,0CAenC,MAAA,eAfR,6CAmBQ,MAAA,eAnBR,4CAAA,2CAAA,yCAAA,0CA2BM,MAAA,eA3BN,8BAgCI,aAAA,eAhCJ,mCAoCI,iBAAA,oPApCJ,2BAwCI,MAAA,eAKJ,8BAAA,gCAGI,MAAA,KAHJ,oCAAqC,oCAArC,sCAAA,sCAMM,MAAA,KANN,sCAYM,MAAA,qBAZN,4CAA6C,4CAerC,MAAA,sBAfR,+CAmBQ,MAAA,sBAnBR,8CAAA,6CAAA,2CAAA,4CA2BM,MAAA,KA3BN,gCAgCI,aAAA,qBAhCJ,qCAoCI,iBAAA,0PApCJ,6BAwCI,MAAA,qBCrQJ,MACE,SAAA,SACA,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,mBAAA,SAAA,sBAAA,OAAA,uBAAA,OAAA,mBAAA,OAAA,eAAA,OACA,iBAAA,KACA,OAAA,IAAA,MAAA,iBrBLE,cAAA,OqBSJ,YAGE,iBAAA,EAAA,aAAA,EAAA,EAAA,KAAA,SAAA,EAAA,EAAA,KAAA,KAAA,EAAA,EAAA,KACA,QAAA,QAGF,YACE,cAAA,OAGF,eACE,WAAA,SACA,cAAA,EAGF,sBACE,cAAA,E1BpBE,iB0ByBA,gBAAA,KAFJ,sBAMI,YAAA,QAIJ,2DrBjCI,wBAAA,OACA,uBAAA,OqBgCJ,yDrBnBI,2BAAA,OACA,0BAAA,OqBqCJ,aACE,QAAA,OAAA,QACA,cAAA,EACA,iBAAA,QACA,cAAA,IAAA,MAAA,iBAJF,yBrB1DI,cAAA,mBAAA,mBAAA,EAAA,EqBqEJ,aACE,QAAA,OAAA,QACA,iBAAA,QACA,WAAA,IAAA,MAAA,iBAHF,wBrBrEI,cAAA,EAAA,EAAA,mBAAA,mBqBoFJ,kBACE,aAAA,SACA,cAAA,QACA,YAAA,SACA,cAAA,EAGF,mBACE,aAAA,SACA,YAAA,SAQF,cCtGE,iBAAA,QACA,aAAA,QAEA,2BAAA,2BAEE,iBAAA,YDoGJ,cCzGE,iBAAA,QACA,aAAA,QAEA,2BAAA,2BAEE,iBAAA,YDuGJ,WC5GE,iBAAA,QACA,aAAA,QAEA,wBAAA,wBAEE,iBAAA,YD0GJ,cC/GE,iBAAA,QACA,aAAA,QAEA,2BAAA,2BAEE,iBAAA,YD6GJ,aClHE,iBAAA,QACA,aAAA,QAEA,0BAAA,0BAEE,iBAAA,YDkHJ,sBC7GE,iBAAA,YACA,aAAA,QD+GF,wBChHE,iBAAA,YACA,aAAA,KDkHF,mBCnHE,iBAAA,YACA,aAAA,QDqHF,sBCtHE,iBAAA,YACA,aAAA,QDwHF,sBCzHE,iBAAA,YACA,aAAA,QD2HF,qBC5HE,iBAAA,YACA,aAAA,QDmIF,cC3HE,MAAA,sBAEA,2BAAA,2BAEE,iBAAA,YACA,aAAA,qBAEF,+BAAA,2BAAA,2BAAA,0BAIE,MAAA,KAEF,kDAAA,yBAAA,6BAAA,yBAIE,MAAA,sBAEF,+BAAA,+BAEI,MAAA,KD8GN,iBACE,QAAA,EACA,cAAA,EACA,YAAA,EAIF,UrB5JI,cAAA,mBqBgKJ,kBACE,SAAA,SACA,IAAA,EACA,MAAA,EACA,OAAA,EACA,KAAA,EACA,QAAA,QAMF,crBtKI,wBAAA,mBACA,uBAAA,mBqBwKJ,iBrB3JI,2BAAA,mBACA,0BAAA,mBK+BA,yBgBmIF,WACE,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,kBAAA,IAAA,KAAA,cAAA,IAAA,KAAA,UAAA,IAAA,KAFF,iBAKI,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,iBAAA,EAAA,aAAA,EAAA,EAAA,GAAA,SAAA,EAAA,EAAA,GAAA,KAAA,EAAA,EAAA,GACA,mBAAA,SAAA,sBAAA,OAAA,uBAAA,OAAA,mBAAA,OAAA,eAAA,OAPJ,mCAY0B,YAAA,KAZ1B,kCAayB,aAAA,MhBhJvB,yBgB2JF,YACE,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,kBAAA,IAAA,KAAA,cAAA,IAAA,KAAA,UAAA,IAAA,KAFF,kBAKI,iBAAA,EAAA,aAAA,EAAA,EAAA,GAAA,SAAA,EAAA,EAAA,GAAA,KAAA,EAAA,EAAA,GALJ,wBAQM,YAAA,EACA,YAAA,EATN,8BrBlME,2BAAA,EACA,wBAAA,EqBiMF,4CAkBU,wBAAA,EAlBV,+CAqBU,2BAAA,EArBV,6BrBpLE,0BAAA,EACA,uBAAA,EqBmLF,2CA4BU,uBAAA,EA5BV,8CA+BU,0BAAA,EA/BV,qDAoCQ,cAAA,EApCR,sEAAA,mEAwCU,cAAA,GhBnMR,yBgBiNF,cACE,qBAAA,EAAA,kBAAA,EAAA,aAAA,EACA,mBAAA,QAAA,gBAAA,QAAA,WAAA,QAFF,oBAKI,QAAA,aACA,MAAA,KACA,cAAA,QEhRN,YACE,QAAA,OAAA,KACA,cAAA,KACA,WAAA,KACA,iBAAA,QvBAE,cAAA,OwBHF,mBACE,QAAA,MACA,QAAW,GACX,MAAA,KDKJ,iBACE,MAAA,KADF,0CAKI,QAAA,aACA,cAAA,MACA,aAAA,MACA,MAAA,QACA,QAAiC,IATrC,gDAmBI,gBAAA,UAnBJ,gDAsBI,gBAAA,KAtBJ,wBA0BI,MAAA,QEnCJ,YACE,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KAEA,aAAA,EACA,WAAA,KzBAE,cAAA,OyBIJ,kCAGM,YAAA,EzBoBF,0BAAA,OACA,uBAAA,OyBxBJ,iCzBSI,2BAAA,OACA,wBAAA,OyBVJ,6BAcI,QAAA,EACA,MAAA,KACA,iBAAA,QACA,aAAA,QAjBJ,+BAqBI,MAAA,QACA,eAAA,KACA,OAAA,YACA,iBAAA,KACA,aAAA,KAIJ,WACE,SAAA,SACA,QAAA,MACA,QAAA,MAAA,OACA,YAAA,KACA,YAAA,KACA,MAAA,QACA,iBAAA,KACA,OAAA,IAAA,MAAA,K9BzBE,iBAAA,iB8B4BA,MAAA,QACA,gBAAA,KACA,iBAAA,QACA,aAAA,KChDF,0BACE,QAAA,OAAA,OACA,UAAA,QAKE,iD1BqBF,0BAAA,MACA,uBAAA,M0BjBE,gD1BEF,2BAAA,MACA,wBAAA,M0BfF,0BACE,QAAA,OAAA,MACA,UAAA,QAKE,iD1BqBF,0BAAA,MACA,uBAAA,M0BjBE,gD1BEF,2BAAA,MACA,wBAAA,M2BbJ,OACE,QAAA,aACA,QAAA,MAAA,KACA,UAAA,IACA,YAAA,IACA,YAAA,EACA,MAAA,KACA,WAAA,OACA,YAAA,OACA,eAAA,S3BVE,cAAA,O2BCJ,aAcI,QAAA,KAKJ,YACE,SAAA,SACA,IAAA,KhCNE,cAAA,cgCaA,MAAA,KACA,gBAAA,KACA,OAAA,QASJ,YACE,cAAA,KACA,aAAA,K3B1CE,cAAA,M2BkDJ,eCnDE,iBAAA,QjCiBE,2BAAA,2BiCbE,iBAAA,QDmDN,eCvDE,iBAAA,QjCiBE,2BAAA,2BiCbE,iBAAA,QDuDN,eC3DE,iBAAA,QjCiBE,2BAAA,2BiCbE,iBAAA,QD2DN,YC/DE,iBAAA,QjCiBE,wBAAA,wBiCbE,iBAAA,QD+DN,eCnEE,iBAAA,QjCiBE,2BAAA,2BiCbE,iBAAA,QDmEN,cCvEE,iBAAA,QjCiBE,0BAAA,0BiCbE,iBAAA,QCPN,WACE,QAAA,KAAA,KACA,cAAA,KACA,iBAAA,Q7BCE,cAAA,MKoDA,yBwBxDF,WAOE,QAAA,KAAA,MAIJ,cACE,iBAAA,QAGF,iBACE,cAAA,EACA,aAAA,E7BbE,cAAA,E8BAJ,OACE,QAAA,OAAA,QACA,cAAA,KACA,OAAA,IAAA,MAAA,Y9BHE,cAAA,O8BQJ,eAEE,MAAA,QAIF,YACE,YAAA,IAQF,0BAGI,SAAA,SACA,IAAA,QACA,MAAA,SACA,QAAA,OAAA,QACA,MAAA,QASJ,eCxCE,iBAAA,QACA,aAAA,QACA,MAAA,QAEA,kBACE,iBAAA,QAEF,2BACE,MAAA,QDmCJ,YC3CE,iBAAA,QACA,aAAA,QACA,MAAA,QAEA,eACE,iBAAA,QAEF,wBACE,MAAA,QDsCJ,eC9CE,iBAAA,QACA,aAAA,QACA,MAAA,QAEA,kBACE,iBAAA,QAEF,2BACE,MAAA,QDyCJ,cCjDE,iBAAA,QACA,aAAA,QACA,MAAA,QAEA,iBACE,iBAAA,QAEF,0BACE,MAAA,QCVJ,wCACE,KAAO,oBAAA,KAAA,EACP,GAAK,oBAAA,EAAA,GAFP,mCACE,KAAO,oBAAA,KAAA,EACP,GAAK,oBAAA,EAAA,GAFP,gCACE,KAAO,oBAAA,KAAA,EACP,GAAK,oBAAA,EAAA,GAIP,UACE,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,SAAA,OACA,UAAA,OACA,YAAA,KACA,WAAA,OACA,iBAAA,QhCTE,cAAA,OgCYJ,cACE,OAAA,KACA,MAAA,KACA,iBAAA,QAIF,sBCYE,iBAAA,yKAAA,iBAAA,oKAAA,iBAAA,iKDVA,wBAAA,KAAA,KAAA,gBAAA,KAAA,KAIF,uBACE,kBAAA,qBAAA,GAAA,OAAA,SAAA,aAAA,qBAAA,GAAA,OAAA,SAAA,UAAA,qBAAA,GAAA,OAAA,SE9BF,OACE,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,kBAAA,MAAA,oBAAA,WAAA,eAAA,MAAA,YAAA,WAGF,YACE,iBAAA,EAAA,aAAA,EAAA,EAAA,GAAA,SAAA,EAAA,EAAA,GAAA,KAAA,EAAA,EAAA,GCFF,YACE,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,mBAAA,SAAA,sBAAA,OAAA,uBAAA,OAAA,mBAAA,OAAA,eAAA,OAGA,aAAA,EACA,cAAA,EASF,wBACE,MAAA,KACA,MAAA,QACA,WAAA,QAHF,iDAMI,MAAA,QxCLA,8BAAA,8BwCUA,MAAA,QACA,gBAAA,KACA,iBAAA,QAbJ,+BAiBI,MAAA,QACA,iBAAA,QASJ,iBACE,SAAA,SACA,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,kBAAA,IAAA,KAAA,cAAA,IAAA,KAAA,UAAA,IAAA,KACA,kBAAA,OAAA,oBAAA,OAAA,eAAA,OAAA,YAAA,OACA,QAAA,OAAA,QAEA,cAAA,KACA,iBAAA,KACA,OAAA,IAAA,MAAA,iBATF,6BnCpCI,wBAAA,OACA,uBAAA,OmCmCJ,4BAgBI,cAAA,EnCtCA,2BAAA,OACA,0BAAA,OLLA,uBAAA,uBwC+CA,gBAAA,KArBJ,0BAA2B,0BA0BvB,MAAA,QACA,OAAA,YACA,iBAAA,KA5BJ,mDAAoD,mDAgC9C,MAAA,QAhCN,gDAAiD,gDAmC3C,MAAA,QAnCN,wBAyCI,QAAA,EACA,MAAA,KACA,iBAAA,QACA,aAAA,QA5CJ,iDAAA,wDAAA,uDAkDM,MAAA,QAlDN,8CAsDM,MAAA,QAWN,mCAEI,aAAA,EACA,YAAA,EACA,cAAA,EAJJ,2DASM,WAAA,EATN,yDAeM,cAAA,EC3HJ,yBACE,MAAA,QACA,iBAAA,QAGF,0BAAA,+BACE,MAAA,QADF,mDAAA,wDAII,MAAA,QzCQF,gCAAA,gCAAA,qCAAA,qCyCJE,MAAA,QACA,iBAAA,QATJ,iCAAA,sCAaI,MAAA,KACA,iBAAA,QACA,aAAA,QApBJ,sBACE,MAAA,QACA,iBAAA,QAGF,uBAAA,4BACE,MAAA,QADF,gDAAA,qDAII,MAAA,QzCQF,6BAAA,6BAAA,kCAAA,kCyCJE,MAAA,QACA,iBAAA,QATJ,8BAAA,mCAaI,MAAA,KACA,iBAAA,QACA,aAAA,QApBJ,yBACE,MAAA,QACA,iBAAA,QAGF,0BAAA,+BACE,MAAA,QADF,mDAAA,wDAII,MAAA,QzCQF,gCAAA,gCAAA,qCAAA,qCyCJE,MAAA,QACA,iBAAA,QATJ,iCAAA,sCAaI,MAAA,KACA,iBAAA,QACA,aAAA,QApBJ,wBACE,MAAA,QACA,iBAAA,QAGF,yBAAA,8BACE,MAAA,QADF,kDAAA,uDAII,MAAA,QzCQF,+BAAA,+BAAA,oCAAA,oCyCJE,MAAA,QACA,iBAAA,QATJ,gCAAA,qCAaI,MAAA,KACA,iBAAA,QACA,aAAA,QCrBN,kBACE,SAAA,SACA,QAAA,MACA,MAAA,KACA,QAAA,EACA,SAAA,OALF,0BAQI,QAAA,MACA,QAAW,GATf,yCAAA,wBAAA,yBAAA,yBAAA,wBAiBI,SAAA,SACA,IAAA,EACA,OAAA,EACA,KAAA,EACA,MAAA,KACA,OAAA,KACA,OAAA,EAIJ,gCAEI,YAAA,WAIJ,gCAEI,YAAA,OAIJ,+BAEI,YAAA,IAIJ,+BAEI,YAAA,KCjDJ,OACE,MAAA,MACA,UAAA,OACA,YAAA,IACA,YAAA,EACA,MAAA,KACA,YAAA,EAAA,IAAA,EAAA,KACA,QAAA,G3CaE,aAAA,a2CVA,MAAA,KACA,gBAAA,KACA,OAAA,QACA,QAAA,IAUJ,aACE,QAAA,EACA,OAAA,QACA,WAAA,IACA,OAAA,EACA,mBAAA,KCrBF,YACE,SAAA,OAIF,OACE,SAAA,MACA,IAAA,EACA,MAAA,EACA,OAAA,EACA,KAAA,EACA,QAAA,KACA,QAAA,KACA,SAAA,OAGA,QAAA,EAXF,0BtCGM,mBAAA,kBAAA,IAAA,SAAA,WAAA,kBAAA,IAAA,SAAA,cAAA,aAAA,IAAA,SAAA,WAAA,UAAA,IAAA,SAAA,WAAA,UAAA,IAAA,SAAA,kBAAA,IAAA,SAAA,aAAA,IAAA,SsCgBF,kBAAA,kBAAA,aAAA,kBAAA,UAAA,kBAnBJ,0BAqByB,kBAAA,eAAA,aAAA,eAAA,UAAA,eAEzB,mBACE,WAAA,OACA,WAAA,KAIF,cACE,SAAA,SACA,MAAA,KACA,OAAA,KAIF,eACE,SAAA,SACA,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,mBAAA,SAAA,sBAAA,OAAA,uBAAA,OAAA,mBAAA,OAAA,eAAA,OACA,iBAAA,KACA,wBAAA,YAAA,gBAAA,YACA,OAAA,IAAA,MAAA,evClDE,cAAA,MuCsDF,QAAA,EAIF,gBACE,SAAA,MACA,IAAA,EACA,MAAA,EACA,OAAA,EACA,KAAA,EACA,QAAA,KACA,iBAAA,KAPF,qBAUW,QAAA,EAVX,qBAWW,QAAA,GAKX,cACE,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,kBAAA,OAAA,oBAAA,OAAA,eAAA,OAAA,YAAA,OACA,iBAAA,QAAA,wBAAA,cAAA,cAAA,QAAA,gBAAA,cACA,QAAA,KACA,cAAA,IAAA,MAAA,QAIF,aACE,cAAA,EACA,YAAA,IAKF,YACE,SAAA,SAGA,iBAAA,EAAA,aAAA,EAAA,EAAA,KAAA,SAAA,EAAA,EAAA,KAAA,KAAA,EAAA,EAAA,KACA,QAAA,KAIF,cACE,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,kBAAA,OAAA,oBAAA,OAAA,eAAA,OAAA,YAAA,OACA,iBAAA,IAAA,wBAAA,SAAA,cAAA,IAAA,gBAAA,SACA,QAAA,KACA,WAAA,IAAA,MAAA,QALF,iCAQyB,YAAA,OARzB,gCASwB,aAAA,OAIxB,yBACE,SAAA,SACA,IAAA,QACA,MAAA,KACA,OAAA,KACA,SAAA,OlCjEE,yBkCuEF,cACE,UAAA,MACA,OAAA,KAAA,KAOF,UAAY,UAAA,OlChFV,yBkCoFF,UAAY,UAAA,OC3Id,SACE,SAAA,SACA,QAAA,KACA,QAAA,MCHA,YAAA,cAAA,UAAA,mBAAA,WAAA,O/CqP4H,iB+CrP5H,MAAA,WAEA,WAAA,OACA,YAAA,IACA,eAAA,OACA,WAAA,KACA,YAAA,IACA,WAAA,KACA,WAAA,MACA,gBAAA,KACA,YAAA,KACA,eAAA,KACA,YAAA,OACA,WAAA,OACA,aAAA,ODPA,UAAA,QAEA,UAAA,WACA,QAAA,EAVF,cAYW,QAAA,GAZW,2CAAtB,qBAgBI,QAAA,IAAA,EACA,WAAA,KAjByC,kEAA7C,4CAoBM,OAAA,EACA,KAAA,IACA,YAAA,KACA,QAAW,GACX,aAAA,IAAA,IAAA,EACA,iBAAA,KAzBkB,yCAAxB,uBA8BI,QAAA,EAAA,IACA,YAAA,IA/B2C,gEAA/C,8CAkCM,IAAA,IACA,KAAA,EACA,WAAA,KACA,QAAW,GACX,aAAA,IAAA,IAAA,IAAA,EACA,mBAAA,KAvCmB,wCAAzB,wBA4CI,QAAA,IAAA,EACA,WAAA,IA7C4C,+DAAhD,+CAgDM,IAAA,EACA,KAAA,IACA,YAAA,KACA,QAAW,GACX,aAAA,EAAA,IAAA,IACA,oBAAA,KArDiB,0CAAvB,sBA0DI,QAAA,EAAA,IACA,YAAA,KA3D0C,iEAA9C,6CA8DM,IAAA,IACA,MAAA,EACA,WAAA,KACA,QAAW,GACX,aAAA,IAAA,EAAA,IAAA,IACA,kBAAA,KAMN,eACE,UAAA,MACA,QAAA,IAAA,IACA,MAAA,KACA,WAAA,OACA,iBAAA,KxC3EE,cAAA,OwCsEJ,uBASI,SAAA,SACA,MAAA,EACA,OAAA,EACA,aAAA,YACA,aAAA,MEvFJ,SACE,SAAA,SACA,IAAA,EACA,KAAA,EACA,QAAA,KACA,QAAA,MACA,UAAA,MACA,QAAA,IDNA,YAAA,cAAA,UAAA,mBAAA,WAAA,O/CqP4H,iB+CrP5H,MAAA,WAEA,WAAA,OACA,YAAA,IACA,eAAA,OACA,WAAA,KACA,YAAA,IACA,WAAA,KACA,WAAA,MACA,gBAAA,KACA,YAAA,KACA,eAAA,KACA,YAAA,OACA,WAAA,OACA,aAAA,OCJA,UAAA,QAEA,UAAA,WACA,iBAAA,KACA,wBAAA,YAAA,gBAAA,YACA,OAAA,IAAA,MAAA,e1CZE,cAAA,M0CJkB,2CAAtB,qBAyBI,WAAA,MAzB2G,kDAApD,mDAA7B,4BAA9B,6BA6BM,KAAA,IACA,oBAAA,EA9BwB,mDAA9B,6BAkCM,OAAA,MACA,YAAA,MACA,iBAAA,gBApCuB,kDAA7B,4BAwCM,OAAA,MACA,YAAA,MACA,iBAAA,KA1CkB,yCAAxB,uBAgDI,YAAA,KAhD6G,gDAAlD,iDAA/B,8BAAhC,+BAoDM,IAAA,IACA,kBAAA,EArD0B,iDAAhC,+BAyDM,KAAA,MACA,WAAA,MACA,mBAAA,gBA3DyB,gDAA/B,8BA+DM,KAAA,MACA,WAAA,MACA,mBAAA,KAjEmB,wCAAzB,wBAuEI,WAAA,KAvE8G,+CAAjD,gDAAhC,+BAAjC,gCA2EM,KAAA,IACA,iBAAA,EA5E2B,gDAAjC,gCAgFM,IAAA,MACA,YAAA,MACA,oBAAA,gBAlF0B,+CAAhC,+BAsFM,IAAA,MACA,YAAA,MACA,oBAAA,QAxF0C,+DAAhD,+CA6FM,SAAA,SACA,IAAA,EACA,KAAA,IACA,QAAA,MACA,MAAA,KACA,YAAA,MACA,QAAW,GACX,cAAA,IAAA,MAAA,QApGiB,0CAAvB,sBA0GI,YAAA,MA1G4G,iDAAnD,kDAA9B,6BAA/B,8BA8GM,IAAA,IACA,mBAAA,EA/GyB,kDAA/B,8BAmHM,MAAA,MACA,WAAA,MACA,kBAAA,gBArHwB,iDAA9B,6BAyHM,MAAA,MACA,WAAA,MACA,kBAAA,KAON,eACE,QAAA,IAAA,KACA,cAAA,EACA,UAAA,KACA,iBAAA,QACA,cAAA,IAAA,MAAA,Q1C7HE,wBAAA,kBACA,uBAAA,kB0CuHJ,qBAUI,QAAA,KAIJ,iBACE,QAAA,IAAA,KAQF,gBAAA,iBAEE,SAAA,SACA,QAAA,MACA,MAAA,EACA,OAAA,EACA,aAAA,YACA,aAAA,MAGF,iBACE,QAAW,GACX,aAAA,KAEF,gBACE,QAAW,GACX,aAAA,KCxKF,UACE,SAAA,SAGF,gBACE,SAAA,SACA,MAAA,KACA,SAAA,OAGF,eACE,SAAA,SACA,QAAA,KACA,MAAA,KCZA,8BDSA,e1CII,mBAAA,kBAAA,IAAA,YAAA,WAAA,kBAAA,IAAA,YAAA,cAAA,aAAA,IAAA,YAAA,WAAA,UAAA,IAAA,YAAA,WAAA,UAAA,IAAA,YAAA,kBAAA,IAAA,YAAA,aAAA,IAAA,Y0CGF,4BAAA,OAAA,oBAAA,OACA,oBAAA,OAAA,YAAA,QCVuC,qFDEzC,e1CII,mBAAA,kBAAA,IAAA,YAAA,WAAA,kBAAA,IAAA,YAAA,cAAA,aAAA,IAAA,YAAA,WAAA,UAAA,IAAA,YAAA,WAAA,UAAA,IAAA,YAAA,kBAAA,IAAA,YAAA,aAAA,IAAA,Y0CGF,4BAAA,OAAA,oBAAA,OACA,oBAAA,OAAA,YAAA,QAIJ,oBAAA,oBAAA,sBAGE,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KAGF,oBAAA,oBAEE,SAAA,SACA,IAAA,EC9BA,8BDmCA,uCAAA,wCAEE,kBAAA,mBAAA,UAAA,mBAGF,4BAAA,oBAEE,kBAAA,sBAAA,UAAA,sBAGF,2BAAA,oBAEE,kBAAA,uBAAA,UAAA,wBCxCuC,qFD4BzC,uCAAA,wCAEE,kBAAA,mBAAA,UAAA,mBAGF,4BAAA,oBAEE,kBAAA,sBAAA,UAAA,sBAGF,2BAAA,oBAEE,kBAAA,uBAAA,UAAA,wBASJ,uBAAA,uBAEE,SAAA,SACA,IAAA,EACA,OAAA,EAEA,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,kBAAA,OAAA,oBAAA,OAAA,eAAA,OAAA,YAAA,OACA,iBAAA,OAAA,wBAAA,OAAA,cAAA,OAAA,gBAAA,OACA,MAAA,IACA,MAAA,KACA,WAAA,OACA,QAAA,GhDlDE,6BAAA,6BAAA,6BAAA,6BgDwDA,MAAA,KACA,gBAAA,KACA,QAAA,EACA,QAAA,GAGJ,uBACE,KAAA,EAEF,uBACE,MAAA,EAIF,4BAAA,4BAEE,QAAA,aACA,MAAA,KACA,OAAA,KACA,WAAA,YAAA,UAAA,OAAA,OACA,wBAAA,KAAA,KAAA,gBAAA,KAAA,KAEF,4BACE,iBAAA,4LAEF,4BACE,iBAAA,8LASF,qBACE,SAAA,SACA,MAAA,EACA,OAAA,KACA,KAAA,EACA,QAAA,GACA,QAAA,YAAA,QAAA,aAAA,QAAA,YAAA,QAAA,KACA,iBAAA,OAAA,wBAAA,OAAA,cAAA,OAAA,gBAAA,OACA,aAAA,EAEA,aAAA,IACA,YAAA,IACA,WAAA,KAZF,wBAeI,SAAA,SACA,iBAAA,EAAA,aAAA,EAAA,EAAA,KAAA,SAAA,EAAA,EAAA,KAAA,KAAA,EAAA,EAAA,KACA,UAAA,KACA,OAAA,IACA,aAAA,IACA,YAAA,IACA,YAAA,OACA,OAAA,QACA,iBAAA,qBAvBJ,gCA2BM,SAAA,SACA,IAAA,MACA,KAAA,EACA,QAAA,aACA,MAAA,KACA,OAAA,KACA,QAAW,GAjCjB,+BAoCM,SAAA,SACA,OAAA,MACA,KAAA,EACA,QAAA,aACA,MAAA,KACA,OAAA,KACA,QAAW,GA1CjB,6BA+CI,iBAAA,KASJ,kBACE,SAAA,SACA,MAAA,IACA,OAAA,KACA,KAAA,IACA,QAAA,GACA,YAAA,KACA,eAAA,KACA,MAAA,KACA,WAAA,OEhLF,gBAAqB,eAAA,mBACrB,WAAqB,eAAA,cACrB,cAAqB,eAAA,iBACrB,cAAqB,eAAA,iBACrB,mBAAqB,eAAA,sBACrB,gBAAqB,eAAA,mBCDrB,UACE,iBAAA,QCFA,YACE,iBAAA,kBpDgBA,mBAAA,mBoDZE,iBAAA,kBALJ,YACE,iBAAA,kBpDgBA,mBAAA,mBoDZE,iBAAA,kBALJ,SACE,iBAAA,kBpDgBA,gBAAA,gBoDZE,iBAAA,kBALJ,YACE,iBAAA,kBpDgBA,mBAAA,mBoDZE,iBAAA,kBALJ,WACE,iBAAA,kBpDgBA,kBAAA,kBoDZE,iBAAA,kBALJ,YACE,iBAAA,kBpDgBA,mBAAA,mBoDZE,iBAAA,kBCJN,UAAmB,OAAA,YACnB,cAAmB,WAAA,YACnB,gBAAmB,aAAA,YACnB,iBAAmB,cAAA,YACnB,eAAmB,YAAA,YAMnB,ShDVI,cAAA,OgDaJ,ahDPI,wBAAA,OACA,uBAAA,OgDSJ,ehDHI,2BAAA,OACA,wBAAA,OgDKJ,gBhDCI,2BAAA,OACA,0BAAA,OgDCJ,chDKI,0BAAA,OACA,uBAAA,OgDFJ,gBACE,cAAA,IAGF,WACE,cAAA,ExBlCA,iBACE,QAAA,MACA,QAAW,GACX,MAAA,KyBIA,QAAE,QAAA,eACF,UAAE,QAAA,iBACF,gBAAE,QAAA,uBACF,SAAE,QAAA,gBACF,SAAE,QAAA,gBACF,cAAE,QAAA,qBACF,QAAE,QAAA,sBAAA,QAAA,uBAAA,QAAA,sBAAA,QAAA,eACF,eAAE,QAAA,6BAAA,QAAA,8BAAA,QAAA,6BAAA,QAAA,sB5CyCF,yB4ChDA,WAAE,QAAA,eACF,aAAE,QAAA,iBACF,mBAAE,QAAA,uBACF,YAAE,QAAA,gBACF,YAAE,QAAA,gBACF,iBAAE,QAAA,qBACF,WAAE,QAAA,sBAAA,QAAA,uBAAA,QAAA,sBAAA,QAAA,eACF,kBAAE,QAAA,6BAAA,QAAA,8BAAA,QAAA,6BAAA,QAAA,uB5CyCF,yB4ChDA,WAAE,QAAA,eACF,aAAE,QAAA,iBACF,mBAAE,QAAA,uBACF,YAAE,QAAA,gBACF,YAAE,QAAA,gBACF,iBAAE,QAAA,qBACF,WAAE,QAAA,sBAAA,QAAA,uBAAA,QAAA,sBAAA,QAAA,eACF,kBAAE,QAAA,6BAAA,QAAA,8BAAA,QAAA,6BAAA,QAAA,uB5CyCF,yB4ChDA,WAAE,QAAA,eACF,aAAE,QAAA,iBACF,mBAAE,QAAA,uBACF,YAAE,QAAA,gBACF,YAAE,QAAA,gBACF,iBAAE,QAAA,qBACF,WAAE,QAAA,sBAAA,QAAA,uBAAA,QAAA,sBAAA,QAAA,eACF,kBAAE,QAAA,6BAAA,QAAA,8BAAA,QAAA,6BAAA,QAAA,uB5CyCF,0B4ChDA,WAAE,QAAA,eACF,aAAE,QAAA,iBACF,mBAAE,QAAA,uBACF,YAAE,QAAA,gBACF,YAAE,QAAA,gBACF,iBAAE,QAAA,qBACF,WAAE,QAAA,sBAAA,QAAA,uBAAA,QAAA,sBAAA,QAAA,eACF,kBAAE,QAAA,6BAAA,QAAA,8BAAA,QAAA,6BAAA,QAAA,uBCPF,YAAE,0BAAA,EAAA,cAAA,GAAA,eAAA,GAAA,MAAA,GACF,WAAE,0BAAA,EAAA,cAAA,EAAA,eAAA,EAAA,MAAA,EACF,gBAAE,0BAAA,EAAA,cAAA,EAAA,eAAA,EAAA,MAAA,EAEF,UAAE,mBAAA,qBAAA,sBAAA,iBAAA,uBAAA,cAAA,mBAAA,cAAA,eAAA,cACF,aAAE,mBAAA,mBAAA,sBAAA,iBAAA,uBAAA,iBAAA,mBAAA,iBAAA,eAAA,iBACF,kBAAE,mBAAA,qBAAA,sBAAA,kBAAA,uBAAA,sBAAA,mBAAA,sBAAA,eAAA,sBACF,qBAAE,mBAAA,mBAAA,sBAAA,kBAAA,uBAAA,yBAAA,mBAAA,yBAAA,eAAA,yBAEF,WAAE,kBAAA,eAAA,cAAA,eAAA,UAAA,eACF,aAAE,kBAAA,iBAAA,cAAA,iBAAA,UAAA,iBACF,mBAAE,kBAAA,uBAAA,cAAA,uBAAA,UAAA,uBAEF,uBAAE,iBAAA,gBAAA,wBAAA,qBAAA,cAAA,gBAAA,gBAAA,qBACF,qBAAE,iBAAA,cAAA,wBAAA,mBAAA,cAAA,cAAA,gBAAA,mBACF,wBAAE,iBAAA,iBAAA,wBAAA,iBAAA,cAAA,iBAAA,gBAAA,iBACF,yBAAE,iBAAA,kBAAA,wBAAA,wBAAA,cAAA,kBAAA,gBAAA,wBACF,wBAAE,wBAAA,uBAAA,cAAA,qBAAA,gBAAA,uBAEF,mBAAE,kBAAA,gBAAA,oBAAA,qBAAA,eAAA,gBAAA,YAAA,qBACF,iBAAE,kBAAA,cAAA,oBAAA,mBAAA,eAAA,cAAA,YAAA,mBACF,oBAAE,kBAAA,iBAAA,oBAAA,iBAAA,eAAA,iBAAA,YAAA,iBACF,sBAAE,kBAAA,mBAAA,oBAAA,mBAAA,eAAA,mBAAA,YAAA,mBACF,qBAAE,kBAAA,kBAAA,oBAAA,kBAAA,eAAA,kBAAA,YAAA,kBAEF,qBAAE,sBAAA,qBAAA,mBAAA,gBAAA,cAAA,qBACF,mBAAE,sBAAA,mBAAA,mBAAA,cAAA,cAAA,mBACF,sBAAE,sBAAA,iBAAA,mBAAA,iBAAA,cAAA,iBACF,uBAAE,sBAAA,wBAAA,mBAAA,kBAAA,cAAA,wBACF,sBAAE,sBAAA,uBAAA,mBAAA,qBAAA,cAAA,uBACF,uBAAE,sBAAA,kBAAA,mBAAA,kBAAA,cAAA,kBAEF,iBAAE,mBAAA,eAAA,oBAAA,eAAA,mBAAA,eAAA,WAAA,eACF,kBAAE,mBAAA,qBAAA,oBAAA,gBAAA,WAAA,qBACF,gBAAE,mBAAA,mBAAA,oBAAA,cAAA,WAAA,mBACF,mBAAE,mBAAA,iBAAA,oBAAA,iBAAA,mBAAA,iBAAA,WAAA,iBACF,qBAAE,mBAAA,mBAAA,oBAAA,mBAAA,WAAA,mBACF,oBAAE,mBAAA,kBAAA,oBAAA,kBAAA,mBAAA,kBAAA,WAAA,kB7CWF,yB6ChDA,eAAE,0BAAA,EAAA,cAAA,GAAA,eAAA,GAAA,MAAA,GACF,cAAE,0BAAA,EAAA,cAAA,EAAA,eAAA,EAAA,MAAA,EACF,mBAAE,0BAAA,EAAA,cAAA,EAAA,eAAA,EAAA,MAAA,EAEF,aAAE,mBAAA,qBAAA,sBAAA,iBAAA,uBAAA,cAAA,mBAAA,cAAA,eAAA,cACF,gBAAE,mBAAA,mBAAA,sBAAA,iBAAA,uBAAA,iBAAA,mBAAA,iBAAA,eAAA,iBACF,qBAAE,mBAAA,qBAAA,sBAAA,kBAAA,uBAAA,sBAAA,mBAAA,sBAAA,eAAA,sBACF,wBAAE,mBAAA,mBAAA,sBAAA,kBAAA,uBAAA,yBAAA,mBAAA,yBAAA,eAAA,yBAEF,cAAE,kBAAA,eAAA,cAAA,eAAA,UAAA,eACF,gBAAE,kBAAA,iBAAA,cAAA,iBAAA,UAAA,iBACF,sBAAE,kBAAA,uBAAA,cAAA,uBAAA,UAAA,uBAEF,0BAAE,iBAAA,gBAAA,wBAAA,qBAAA,cAAA,gBAAA,gBAAA,qBACF,wBAAE,iBAAA,cAAA,wBAAA,mBAAA,cAAA,cAAA,gBAAA,mBACF,2BAAE,iBAAA,iBAAA,wBAAA,iBAAA,cAAA,iBAAA,gBAAA,iBACF,4BAAE,iBAAA,kBAAA,wBAAA,wBAAA,cAAA,kBAAA,gBAAA,wBACF,2BAAE,wBAAA,uBAAA,cAAA,qBAAA,gBAAA,uBAEF,sBAAE,kBAAA,gBAAA,oBAAA,qBAAA,eAAA,gBAAA,YAAA,qBACF,oBAAE,kBAAA,cAAA,oBAAA,mBAAA,eAAA,cAAA,YAAA,mBACF,uBAAE,kBAAA,iBAAA,oBAAA,iBAAA,eAAA,iBAAA,YAAA,iBACF,yBAAE,kBAAA,mBAAA,oBAAA,mBAAA,eAAA,mBAAA,YAAA,mBACF,wBAAE,kBAAA,kBAAA,oBAAA,kBAAA,eAAA,kBAAA,YAAA,kBAEF,wBAAE,sBAAA,qBAAA,mBAAA,gBAAA,cAAA,qBACF,sBAAE,sBAAA,mBAAA,mBAAA,cAAA,cAAA,mBACF,yBAAE,sBAAA,iBAAA,mBAAA,iBAAA,cAAA,iBACF,0BAAE,sBAAA,wBAAA,mBAAA,kBAAA,cAAA,wBACF,yBAAE,sBAAA,uBAAA,mBAAA,qBAAA,cAAA,uBACF,0BAAE,sBAAA,kBAAA,mBAAA,kBAAA,cAAA,kBAEF,oBAAE,mBAAA,eAAA,oBAAA,eAAA,mBAAA,eAAA,WAAA,eACF,qBAAE,mBAAA,qBAAA,oBAAA,gBAAA,WAAA,qBACF,mBAAE,mBAAA,mBAAA,oBAAA,cAAA,WAAA,mBACF,sBAAE,mBAAA,iBAAA,oBAAA,iBAAA,mBAAA,iBAAA,WAAA,iBACF,wBAAE,mBAAA,mBAAA,oBAAA,mBAAA,WAAA,mBACF,uBAAE,mBAAA,kBAAA,oBAAA,kBAAA,mBAAA,kBAAA,WAAA,mB7CWF,yB6ChDA,eAAE,0BAAA,EAAA,cAAA,GAAA,eAAA,GAAA,MAAA,GACF,cAAE,0BAAA,EAAA,cAAA,EAAA,eAAA,EAAA,MAAA,EACF,mBAAE,0BAAA,EAAA,cAAA,EAAA,eAAA,EAAA,MAAA,EAEF,aAAE,mBAAA,qBAAA,sBAAA,iBAAA,uBAAA,cAAA,mBAAA,cAAA,eAAA,cACF,gBAAE,mBAAA,mBAAA,sBAAA,iBAAA,uBAAA,iBAAA,mBAAA,iBAAA,eAAA,iBACF,qBAAE,mBAAA,qBAAA,sBAAA,kBAAA,uBAAA,sBAAA,mBAAA,sBAAA,eAAA,sBACF,wBAAE,mBAAA,mBAAA,sBAAA,kBAAA,uBAAA,yBAAA,mBAAA,yBAAA,eAAA,yBAEF,cAAE,kBAAA,eAAA,cAAA,eAAA,UAAA,eACF,gBAAE,kBAAA,iBAAA,cAAA,iBAAA,UAAA,iBACF,sBAAE,kBAAA,uBAAA,cAAA,uBAAA,UAAA,uBAEF,0BAAE,iBAAA,gBAAA,wBAAA,qBAAA,cAAA,gBAAA,gBAAA,qBACF,wBAAE,iBAAA,cAAA,wBAAA,mBAAA,cAAA,cAAA,gBAAA,mBACF,2BAAE,iBAAA,iBAAA,wBAAA,iBAAA,cAAA,iBAAA,gBAAA,iBACF,4BAAE,iBAAA,kBAAA,wBAAA,wBAAA,cAAA,kBAAA,gBAAA,wBACF,2BAAE,wBAAA,uBAAA,cAAA,qBAAA,gBAAA,uBAEF,sBAAE,kBAAA,gBAAA,oBAAA,qBAAA,eAAA,gBAAA,YAAA,qBACF,oBAAE,kBAAA,cAAA,oBAAA,mBAAA,eAAA,cAAA,YAAA,mBACF,uBAAE,kBAAA,iBAAA,oBAAA,iBAAA,eAAA,iBAAA,YAAA,iBACF,yBAAE,kBAAA,mBAAA,oBAAA,mBAAA,eAAA,mBAAA,YAAA,mBACF,wBAAE,kBAAA,kBAAA,oBAAA,kBAAA,eAAA,kBAAA,YAAA,kBAEF,wBAAE,sBAAA,qBAAA,mBAAA,gBAAA,cAAA,qBACF,sBAAE,sBAAA,mBAAA,mBAAA,cAAA,cAAA,mBACF,yBAAE,sBAAA,iBAAA,mBAAA,iBAAA,cAAA,iBACF,0BAAE,sBAAA,wBAAA,mBAAA,kBAAA,cAAA,wBACF,yBAAE,sBAAA,uBAAA,mBAAA,qBAAA,cAAA,uBACF,0BAAE,sBAAA,kBAAA,mBAAA,kBAAA,cAAA,kBAEF,oBAAE,mBAAA,eAAA,oBAAA,eAAA,mBAAA,eAAA,WAAA,eACF,qBAAE,mBAAA,qBAAA,oBAAA,gBAAA,WAAA,qBACF,mBAAE,mBAAA,mBAAA,oBAAA,cAAA,WAAA,mBACF,sBAAE,mBAAA,iBAAA,oBAAA,iBAAA,mBAAA,iBAAA,WAAA,iBACF,wBAAE,mBAAA,mBAAA,oBAAA,mBAAA,WAAA,mBACF,uBAAE,mBAAA,kBAAA,oBAAA,kBAAA,mBAAA,kBAAA,WAAA,mB7CWF,yB6ChDA,eAAE,0BAAA,EAAA,cAAA,GAAA,eAAA,GAAA,MAAA,GACF,cAAE,0BAAA,EAAA,cAAA,EAAA,eAAA,EAAA,MAAA,EACF,mBAAE,0BAAA,EAAA,cAAA,EAAA,eAAA,EAAA,MAAA,EAEF,aAAE,mBAAA,qBAAA,sBAAA,iBAAA,uBAAA,cAAA,mBAAA,cAAA,eAAA,cACF,gBAAE,mBAAA,mBAAA,sBAAA,iBAAA,uBAAA,iBAAA,mBAAA,iBAAA,eAAA,iBACF,qBAAE,mBAAA,qBAAA,sBAAA,kBAAA,uBAAA,sBAAA,mBAAA,sBAAA,eAAA,sBACF,wBAAE,mBAAA,mBAAA,sBAAA,kBAAA,uBAAA,yBAAA,mBAAA,yBAAA,eAAA,yBAEF,cAAE,kBAAA,eAAA,cAAA,eAAA,UAAA,eACF,gBAAE,kBAAA,iBAAA,cAAA,iBAAA,UAAA,iBACF,sBAAE,kBAAA,uBAAA,cAAA,uBAAA,UAAA,uBAEF,0BAAE,iBAAA,gBAAA,wBAAA,qBAAA,cAAA,gBAAA,gBAAA,qBACF,wBAAE,iBAAA,cAAA,wBAAA,mBAAA,cAAA,cAAA,gBAAA,mBACF,2BAAE,iBAAA,iBAAA,wBAAA,iBAAA,cAAA,iBAAA,gBAAA,iBACF,4BAAE,iBAAA,kBAAA,wBAAA,wBAAA,cAAA,kBAAA,gBAAA,wBACF,2BAAE,wBAAA,uBAAA,cAAA,qBAAA,gBAAA,uBAEF,sBAAE,kBAAA,gBAAA,oBAAA,qBAAA,eAAA,gBAAA,YAAA,qBACF,oBAAE,kBAAA,cAAA,oBAAA,mBAAA,eAAA,cAAA,YAAA,mBACF,uBAAE,kBAAA,iBAAA,oBAAA,iBAAA,eAAA,iBAAA,YAAA,iBACF,yBAAE,kBAAA,mBAAA,oBAAA,mBAAA,eAAA,mBAAA,YAAA,mBACF,wBAAE,kBAAA,kBAAA,oBAAA,kBAAA,eAAA,kBAAA,YAAA,kBAEF,wBAAE,sBAAA,qBAAA,mBAAA,gBAAA,cAAA,qBACF,sBAAE,sBAAA,mBAAA,mBAAA,cAAA,cAAA,mBACF,yBAAE,sBAAA,iBAAA,mBAAA,iBAAA,cAAA,iBACF,0BAAE,sBAAA,wBAAA,mBAAA,kBAAA,cAAA,wBACF,yBAAE,sBAAA,uBAAA,mBAAA,qBAAA,cAAA,uBACF,0BAAE,sBAAA,kBAAA,mBAAA,kBAAA,cAAA,kBAEF,oBAAE,mBAAA,eAAA,oBAAA,eAAA,mBAAA,eAAA,WAAA,eACF,qBAAE,mBAAA,qBAAA,oBAAA,gBAAA,WAAA,qBACF,mBAAE,mBAAA,mBAAA,oBAAA,cAAA,WAAA,mBACF,sBAAE,mBAAA,iBAAA,oBAAA,iBAAA,mBAAA,iBAAA,WAAA,iBACF,wBAAE,mBAAA,mBAAA,oBAAA,mBAAA,WAAA,mBACF,uBAAE,mBAAA,kBAAA,oBAAA,kBAAA,mBAAA,kBAAA,WAAA,mB7CWF,0B6ChDA,eAAE,0BAAA,EAAA,cAAA,GAAA,eAAA,GAAA,MAAA,GACF,cAAE,0BAAA,EAAA,cAAA,EAAA,eAAA,EAAA,MAAA,EACF,mBAAE,0BAAA,EAAA,cAAA,EAAA,eAAA,EAAA,MAAA,EAEF,aAAE,mBAAA,qBAAA,sBAAA,iBAAA,uBAAA,cAAA,mBAAA,cAAA,eAAA,cACF,gBAAE,mBAAA,mBAAA,sBAAA,iBAAA,uBAAA,iBAAA,mBAAA,iBAAA,eAAA,iBACF,qBAAE,mBAAA,qBAAA,sBAAA,kBAAA,uBAAA,sBAAA,mBAAA,sBAAA,eAAA,sBACF,wBAAE,mBAAA,mBAAA,sBAAA,kBAAA,uBAAA,yBAAA,mBAAA,yBAAA,eAAA,yBAEF,cAAE,kBAAA,eAAA,cAAA,eAAA,UAAA,eACF,gBAAE,kBAAA,iBAAA,cAAA,iBAAA,UAAA,iBACF,sBAAE,kBAAA,uBAAA,cAAA,uBAAA,UAAA,uBAEF,0BAAE,iBAAA,gBAAA,wBAAA,qBAAA,cAAA,gBAAA,gBAAA,qBACF,wBAAE,iBAAA,cAAA,wBAAA,mBAAA,cAAA,cAAA,gBAAA,mBACF,2BAAE,iBAAA,iBAAA,wBAAA,iBAAA,cAAA,iBAAA,gBAAA,iBACF,4BAAE,iBAAA,kBAAA,wBAAA,wBAAA,cAAA,kBAAA,gBAAA,wBACF,2BAAE,wBAAA,uBAAA,cAAA,qBAAA,gBAAA,uBAEF,sBAAE,kBAAA,gBAAA,oBAAA,qBAAA,eAAA,gBAAA,YAAA,qBACF,oBAAE,kBAAA,cAAA,oBAAA,mBAAA,eAAA,cAAA,YAAA,mBACF,uBAAE,kBAAA,iBAAA,oBAAA,iBAAA,eAAA,iBAAA,YAAA,iBACF,yBAAE,kBAAA,mBAAA,oBAAA,mBAAA,eAAA,mBAAA,YAAA,mBACF,wBAAE,kBAAA,kBAAA,oBAAA,kBAAA,eAAA,kBAAA,YAAA,kBAEF,wBAAE,sBAAA,qBAAA,mBAAA,gBAAA,cAAA,qBACF,sBAAE,sBAAA,mBAAA,mBAAA,cAAA,cAAA,mBACF,yBAAE,sBAAA,iBAAA,mBAAA,iBAAA,cAAA,iBACF,0BAAE,sBAAA,wBAAA,mBAAA,kBAAA,cAAA,wBACF,yBAAE,sBAAA,uBAAA,mBAAA,qBAAA,cAAA,uBACF,0BAAE,sBAAA,kBAAA,mBAAA,kBAAA,cAAA,kBAEF,oBAAE,mBAAA,eAAA,oBAAA,eAAA,mBAAA,eAAA,WAAA,eACF,qBAAE,mBAAA,qBAAA,oBAAA,gBAAA,WAAA,qBACF,mBAAE,mBAAA,mBAAA,oBAAA,cAAA,WAAA,mBACF,sBAAE,mBAAA,iBAAA,oBAAA,iBAAA,mBAAA,iBAAA,WAAA,iBACF,wBAAE,mBAAA,mBAAA,oBAAA,mBAAA,WAAA,mBACF,uBAAE,mBAAA,kBAAA,oBAAA,kBAAA,mBAAA,kBAAA,WAAA,mBCzCF,YCHF,MAAA,eDIE,aCDF,MAAA,gBDEE,YCCF,MAAA,e/CiDE,yB8CpDA,eCHF,MAAA,eDIE,gBCDF,MAAA,gBDEE,eCCF,MAAA,gB/CiDE,yB8CpDA,eCHF,MAAA,eDIE,gBCDF,MAAA,gBDEE,eCCF,MAAA,gB/CiDE,yB8CpDA,eCHF,MAAA,eDIE,gBCDF,MAAA,gBDEE,eCCF,MAAA,gB/CiDE,0B8CpDA,eCHF,MAAA,eDIE,gBCDF,MAAA,gBDEE,eCCF,MAAA,gBCLF,WACE,SAAA,MACA,IAAA,EACA,MAAA,EACA,KAAA,EACA,QAAA,KAGF,cACE,SAAA,MACA,MAAA,EACA,OAAA,EACA,KAAA,EACA,QAAA,KAGF,YACE,SAAA,eAAA,SAAA,OACA,IAAA,EACA,QAAA,KCjBF,SCCE,SAAA,SACA,MAAA,IACA,OAAA,IACA,QAAA,EACA,OAAA,KACA,SAAA,OACA,KAAA,cACA,OAAA,EAUA,0BAAA,yBAEE,SAAA,OACA,MAAA,KACA,OAAA,KACA,OAAA,EACA,SAAA,QACA,KAAA,KCzBA,MAAE,MAAA,cAAF,MAAE,MAAA,cAAF,MAAE,MAAA,cAAF,OAAE,MAAA,eAAF,MAAE,OAAA,cAAF,MAAE,OAAA,cAAF,MAAE,OAAA,cAAF,OAAE,OAAA,eAIN,QAAU,UAAA,eACV,QAAU,WAAA,eCEF,KAAE,OAAA,EAAA,YACF,MAAE,WAAA,YACF,MAAE,aAAA,YACF,MAAE,cAAA,YACF,MAAE,YAAA,YACF,MACE,aAAA,YACA,YAAA,YAEF,MACE,WAAA,YACA,cAAA,YAXF,KAAE,OAAA,OAAA,iBACF,MAAE,WAAA,iBACF,MAAE,aAAA,iBACF,MAAE,cAAA,iBACF,MAAE,YAAA,iBACF,MACE,aAAA,iBACA,YAAA,iBAEF,MACE,WAAA,iBACA,cAAA,iBAXF,KAAE,OAAA,MAAA,gBACF,MAAE,WAAA,gBACF,MAAE,aAAA,gBACF,MAAE,cAAA,gBACF,MAAE,YAAA,gBACF,MACE,aAAA,gBACA,YAAA,gBAEF,MACE,WAAA,gBACA,cAAA,gBAXF,KAAE,OAAA,KAAA,eACF,MAAE,WAAA,eACF,MAAE,aAAA,eACF,MAAE,cAAA,eACF,MAAE,YAAA,eACF,MACE,aAAA,eACA,YAAA,eAEF,MACE,WAAA,eACA,cAAA,eAXF,KAAE,OAAA,OAAA,iBACF,MAAE,WAAA,iBACF,MAAE,aAAA,iBACF,MAAE,cAAA,iBACF,MAAE,YAAA,iBACF,MACE,aAAA,iBACA,YAAA,iBAEF,MACE,WAAA,iBACA,cAAA,iBAXF,KAAE,OAAA,KAAA,eACF,MAAE,WAAA,eACF,MAAE,aAAA,eACF,MAAE,cAAA,eACF,MAAE,YAAA,eACF,MACE,aAAA,eACA,YAAA,eAEF,MACE,WAAA,eACA,cAAA,eAXF,KAAE,QAAA,EAAA,YACF,MAAE,YAAA,YACF,MAAE,cAAA,YACF,MAAE,eAAA,YACF,MAAE,aAAA,YACF,MACE,cAAA,YACA,aAAA,YAEF,MACE,YAAA,YACA,eAAA,YAXF,KAAE,QAAA,OAAA,iBACF,MAAE,YAAA,iBACF,MAAE,cAAA,iBACF,MAAE,eAAA,iBACF,MAAE,aAAA,iBACF,MACE,cAAA,iBACA,aAAA,iBAEF,MACE,YAAA,iBACA,eAAA,iBAXF,KAAE,QAAA,MAAA,gBACF,MAAE,YAAA,gBACF,MAAE,cAAA,gBACF,MAAE,eAAA,gBACF,MAAE,aAAA,gBACF,MACE,cAAA,gBACA,aAAA,gBAEF,MACE,YAAA,gBACA,eAAA,gBAXF,KAAE,QAAA,KAAA,eACF,MAAE,YAAA,eACF,MAAE,cAAA,eACF,MAAE,eAAA,eACF,MAAE,aAAA,eACF,MACE,cAAA,eACA,aAAA,eAEF,MACE,YAAA,eACA,eAAA,eAXF,KAAE,QAAA,OAAA,iBACF,MAAE,YAAA,iBACF,MAAE,cAAA,iBACF,MAAE,eAAA,iBACF,MAAE,aAAA,iBACF,MACE,cAAA,iBACA,aAAA,iBAEF,MACE,YAAA,iBACA,eAAA,iBAXF,KAAE,QAAA,KAAA,eACF,MAAE,YAAA,eACF,MAAE,cAAA,eACF,MAAE,eAAA,eACF,MAAE,aAAA,eACF,MACE,cAAA,eACA,aAAA,eAEF,MACE,YAAA,eACA,eAAA,eAMN,QAAE,OAAA,eACF,SAAE,WAAA,eACF,SAAE,aAAA,eACF,SAAE,cAAA,eACF,SAAE,YAAA,eACF,SACE,aAAA,eACA,YAAA,eAEF,SACE,WAAA,eACA,cAAA,epDiBF,yBoD7CI,QAAE,OAAA,EAAA,YACF,SAAE,WAAA,YACF,SAAE,aAAA,YACF,SAAE,cAAA,YACF,SAAE,YAAA,YACF,SACE,aAAA,YACA,YAAA,YAEF,SACE,WAAA,YACA,cAAA,YAXF,QAAE,OAAA,OAAA,iBACF,SAAE,WAAA,iBACF,SAAE,aAAA,iBACF,SAAE,cAAA,iBACF,SAAE,YAAA,iBACF,SACE,aAAA,iBACA,YAAA,iBAEF,SACE,WAAA,iBACA,cAAA,iBAXF,QAAE,OAAA,MAAA,gBACF,SAAE,WAAA,gBACF,SAAE,aAAA,gBACF,SAAE,cAAA,gBACF,SAAE,YAAA,gBACF,SACE,aAAA,gBACA,YAAA,gBAEF,SACE,WAAA,gBACA,cAAA,gBAXF,QAAE,OAAA,KAAA,eACF,SAAE,WAAA,eACF,SAAE,aAAA,eACF,SAAE,cAAA,eACF,SAAE,YAAA,eACF,SACE,aAAA,eACA,YAAA,eAEF,SACE,WAAA,eACA,cAAA,eAXF,QAAE,OAAA,OAAA,iBACF,SAAE,WAAA,iBACF,SAAE,aAAA,iBACF,SAAE,cAAA,iBACF,SAAE,YAAA,iBACF,SACE,aAAA,iBACA,YAAA,iBAEF,SACE,WAAA,iBACA,cAAA,iBAXF,QAAE,OAAA,KAAA,eACF,SAAE,WAAA,eACF,SAAE,aAAA,eACF,SAAE,cAAA,eACF,SAAE,YAAA,eACF,SACE,aAAA,eACA,YAAA,eAEF,SACE,WAAA,eACA,cAAA,eAXF,QAAE,QAAA,EAAA,YACF,SAAE,YAAA,YACF,SAAE,cAAA,YACF,SAAE,eAAA,YACF,SAAE,aAAA,YACF,SACE,cAAA,YACA,aAAA,YAEF,SACE,YAAA,YACA,eAAA,YAXF,QAAE,QAAA,OAAA,iBACF,SAAE,YAAA,iBACF,SAAE,cAAA,iBACF,SAAE,eAAA,iBACF,SAAE,aAAA,iBACF,SACE,cAAA,iBACA,aAAA,iBAEF,SACE,YAAA,iBACA,eAAA,iBAXF,QAAE,QAAA,MAAA,gBACF,SAAE,YAAA,gBACF,SAAE,cAAA,gBACF,SAAE,eAAA,gBACF,SAAE,aAAA,gBACF,SACE,cAAA,gBACA,aAAA,gBAEF,SACE,YAAA,gBACA,eAAA,gBAXF,QAAE,QAAA,KAAA,eACF,SAAE,YAAA,eACF,SAAE,cAAA,eACF,SAAE,eAAA,eACF,SAAE,aAAA,eACF,SACE,cAAA,eACA,aAAA,eAEF,SACE,YAAA,eACA,eAAA,eAXF,QAAE,QAAA,OAAA,iBACF,SAAE,YAAA,iBACF,SAAE,cAAA,iBACF,SAAE,eAAA,iBACF,SAAE,aAAA,iBACF,SACE,cAAA,iBACA,aAAA,iBAEF,SACE,YAAA,iBACA,eAAA,iBAXF,QAAE,QAAA,KAAA,eACF,SAAE,YAAA,eACF,SAAE,cAAA,eACF,SAAE,eAAA,eACF,SAAE,aAAA,eACF,SACE,cAAA,eACA,aAAA,eAEF,SACE,YAAA,eACA,eAAA,eAMN,WAAE,OAAA,eACF,YAAE,WAAA,eACF,YAAE,aAAA,eACF,YAAE,cAAA,eACF,YAAE,YAAA,eACF,YACE,aAAA,eACA,YAAA,eAEF,YACE,WAAA,eACA,cAAA,gBpDiBF,yBoD7CI,QAAE,OAAA,EAAA,YACF,SAAE,WAAA,YACF,SAAE,aAAA,YACF,SAAE,cAAA,YACF,SAAE,YAAA,YACF,SACE,aAAA,YACA,YAAA,YAEF,SACE,WAAA,YACA,cAAA,YAXF,QAAE,OAAA,OAAA,iBACF,SAAE,WAAA,iBACF,SAAE,aAAA,iBACF,SAAE,cAAA,iBACF,SAAE,YAAA,iBACF,SACE,aAAA,iBACA,YAAA,iBAEF,SACE,WAAA,iBACA,cAAA,iBAXF,QAAE,OAAA,MAAA,gBACF,SAAE,WAAA,gBACF,SAAE,aAAA,gBACF,SAAE,cAAA,gBACF,SAAE,YAAA,gBACF,SACE,aAAA,gBACA,YAAA,gBAEF,SACE,WAAA,gBACA,cAAA,gBAXF,QAAE,OAAA,KAAA,eACF,SAAE,WAAA,eACF,SAAE,aAAA,eACF,SAAE,cAAA,eACF,SAAE,YAAA,eACF,SACE,aAAA,eACA,YAAA,eAEF,SACE,WAAA,eACA,cAAA,eAXF,QAAE,OAAA,OAAA,iBACF,SAAE,WAAA,iBACF,SAAE,aAAA,iBACF,SAAE,cAAA,iBACF,SAAE,YAAA,iBACF,SACE,aAAA,iBACA,YAAA,iBAEF,SACE,WAAA,iBACA,cAAA,iBAXF,QAAE,OAAA,KAAA,eACF,SAAE,WAAA,eACF,SAAE,aAAA,eACF,SAAE,cAAA,eACF,SAAE,YAAA,eACF,SACE,aAAA,eACA,YAAA,eAEF,SACE,WAAA,eACA,cAAA,eAXF,QAAE,QAAA,EAAA,YACF,SAAE,YAAA,YACF,SAAE,cAAA,YACF,SAAE,eAAA,YACF,SAAE,aAAA,YACF,SACE,cAAA,YACA,aAAA,YAEF,SACE,YAAA,YACA,eAAA,YAXF,QAAE,QAAA,OAAA,iBACF,SAAE,YAAA,iBACF,SAAE,cAAA,iBACF,SAAE,eAAA,iBACF,SAAE,aAAA,iBACF,SACE,cAAA,iBACA,aAAA,iBAEF,SACE,YAAA,iBACA,eAAA,iBAXF,QAAE,QAAA,MAAA,gBACF,SAAE,YAAA,gBACF,SAAE,cAAA,gBACF,SAAE,eAAA,gBACF,SAAE,aAAA,gBACF,SACE,cAAA,gBACA,aAAA,gBAEF,SACE,YAAA,gBACA,eAAA,gBAXF,QAAE,QAAA,KAAA,eACF,SAAE,YAAA,eACF,SAAE,cAAA,eACF,SAAE,eAAA,eACF,SAAE,aAAA,eACF,SACE,cAAA,eACA,aAAA,eAEF,SACE,YAAA,eACA,eAAA,eAXF,QAAE,QAAA,OAAA,iBACF,SAAE,YAAA,iBACF,SAAE,cAAA,iBACF,SAAE,eAAA,iBACF,SAAE,aAAA,iBACF,SACE,cAAA,iBACA,aAAA,iBAEF,SACE,YAAA,iBACA,eAAA,iBAXF,QAAE,QAAA,KAAA,eACF,SAAE,YAAA,eACF,SAAE,cAAA,eACF,SAAE,eAAA,eACF,SAAE,aAAA,eACF,SACE,cAAA,eACA,aAAA,eAEF,SACE,YAAA,eACA,eAAA,eAMN,WAAE,OAAA,eACF,YAAE,WAAA,eACF,YAAE,aAAA,eACF,YAAE,cAAA,eACF,YAAE,YAAA,eACF,YACE,aAAA,eACA,YAAA,eAEF,YACE,WAAA,eACA,cAAA,gBpDiBF,yBoD7CI,QAAE,OAAA,EAAA,YACF,SAAE,WAAA,YACF,SAAE,aAAA,YACF,SAAE,cAAA,YACF,SAAE,YAAA,YACF,SACE,aAAA,YACA,YAAA,YAEF,SACE,WAAA,YACA,cAAA,YAXF,QAAE,OAAA,OAAA,iBACF,SAAE,WAAA,iBACF,SAAE,aAAA,iBACF,SAAE,cAAA,iBACF,SAAE,YAAA,iBACF,SACE,aAAA,iBACA,YAAA,iBAEF,SACE,WAAA,iBACA,cAAA,iBAXF,QAAE,OAAA,MAAA,gBACF,SAAE,WAAA,gBACF,SAAE,aAAA,gBACF,SAAE,cAAA,gBACF,SAAE,YAAA,gBACF,SACE,aAAA,gBACA,YAAA,gBAEF,SACE,WAAA,gBACA,cAAA,gBAXF,QAAE,OAAA,KAAA,eACF,SAAE,WAAA,eACF,SAAE,aAAA,eACF,SAAE,cAAA,eACF,SAAE,YAAA,eACF,SACE,aAAA,eACA,YAAA,eAEF,SACE,WAAA,eACA,cAAA,eAXF,QAAE,OAAA,OAAA,iBACF,SAAE,WAAA,iBACF,SAAE,aAAA,iBACF,SAAE,cAAA,iBACF,SAAE,YAAA,iBACF,SACE,aAAA,iBACA,YAAA,iBAEF,SACE,WAAA,iBACA,cAAA,iBAXF,QAAE,OAAA,KAAA,eACF,SAAE,WAAA,eACF,SAAE,aAAA,eACF,SAAE,cAAA,eACF,SAAE,YAAA,eACF,SACE,aAAA,eACA,YAAA,eAEF,SACE,WAAA,eACA,cAAA,eAXF,QAAE,QAAA,EAAA,YACF,SAAE,YAAA,YACF,SAAE,cAAA,YACF,SAAE,eAAA,YACF,SAAE,aAAA,YACF,SACE,cAAA,YACA,aAAA,YAEF,SACE,YAAA,YACA,eAAA,YAXF,QAAE,QAAA,OAAA,iBACF,SAAE,YAAA,iBACF,SAAE,cAAA,iBACF,SAAE,eAAA,iBACF,SAAE,aAAA,iBACF,SACE,cAAA,iBACA,aAAA,iBAEF,SACE,YAAA,iBACA,eAAA,iBAXF,QAAE,QAAA,MAAA,gBACF,SAAE,YAAA,gBACF,SAAE,cAAA,gBACF,SAAE,eAAA,gBACF,SAAE,aAAA,gBACF,SACE,cAAA,gBACA,aAAA,gBAEF,SACE,YAAA,gBACA,eAAA,gBAXF,QAAE,QAAA,KAAA,eACF,SAAE,YAAA,eACF,SAAE,cAAA,eACF,SAAE,eAAA,eACF,SAAE,aAAA,eACF,SACE,cAAA,eACA,aAAA,eAEF,SACE,YAAA,eACA,eAAA,eAXF,QAAE,QAAA,OAAA,iBACF,SAAE,YAAA,iBACF,SAAE,cAAA,iBACF,SAAE,eAAA,iBACF,SAAE,aAAA,iBACF,SACE,cAAA,iBACA,aAAA,iBAEF,SACE,YAAA,iBACA,eAAA,iBAXF,QAAE,QAAA,KAAA,eACF,SAAE,YAAA,eACF,SAAE,cAAA,eACF,SAAE,eAAA,eACF,SAAE,aAAA,eACF,SACE,cAAA,eACA,aAAA,eAEF,SACE,YAAA,eACA,eAAA,eAMN,WAAE,OAAA,eACF,YAAE,WAAA,eACF,YAAE,aAAA,eACF,YAAE,cAAA,eACF,YAAE,YAAA,eACF,YACE,aAAA,eACA,YAAA,eAEF,YACE,WAAA,eACA,cAAA,gBpDiBF,0BoD7CI,QAAE,OAAA,EAAA,YACF,SAAE,WAAA,YACF,SAAE,aAAA,YACF,SAAE,cAAA,YACF,SAAE,YAAA,YACF,SACE,aAAA,YACA,YAAA,YAEF,SACE,WAAA,YACA,cAAA,YAXF,QAAE,OAAA,OAAA,iBACF,SAAE,WAAA,iBACF,SAAE,aAAA,iBACF,SAAE,cAAA,iBACF,SAAE,YAAA,iBACF,SACE,aAAA,iBACA,YAAA,iBAEF,SACE,WAAA,iBACA,cAAA,iBAXF,QAAE,OAAA,MAAA,gBACF,SAAE,WAAA,gBACF,SAAE,aAAA,gBACF,SAAE,cAAA,gBACF,SAAE,YAAA,gBACF,SACE,aAAA,gBACA,YAAA,gBAEF,SACE,WAAA,gBACA,cAAA,gBAXF,QAAE,OAAA,KAAA,eACF,SAAE,WAAA,eACF,SAAE,aAAA,eACF,SAAE,cAAA,eACF,SAAE,YAAA,eACF,SACE,aAAA,eACA,YAAA,eAEF,SACE,WAAA,eACA,cAAA,eAXF,QAAE,OAAA,OAAA,iBACF,SAAE,WAAA,iBACF,SAAE,aAAA,iBACF,SAAE,cAAA,iBACF,SAAE,YAAA,iBACF,SACE,aAAA,iBACA,YAAA,iBAEF,SACE,WAAA,iBACA,cAAA,iBAXF,QAAE,OAAA,KAAA,eACF,SAAE,WAAA,eACF,SAAE,aAAA,eACF,SAAE,cAAA,eACF,SAAE,YAAA,eACF,SACE,aAAA,eACA,YAAA,eAEF,SACE,WAAA,eACA,cAAA,eAXF,QAAE,QAAA,EAAA,YACF,SAAE,YAAA,YACF,SAAE,cAAA,YACF,SAAE,eAAA,YACF,SAAE,aAAA,YACF,SACE,cAAA,YACA,aAAA,YAEF,SACE,YAAA,YACA,eAAA,YAXF,QAAE,QAAA,OAAA,iBACF,SAAE,YAAA,iBACF,SAAE,cAAA,iBACF,SAAE,eAAA,iBACF,SAAE,aAAA,iBACF,SACE,cAAA,iBACA,aAAA,iBAEF,SACE,YAAA,iBACA,eAAA,iBAXF,QAAE,QAAA,MAAA,gBACF,SAAE,YAAA,gBACF,SAAE,cAAA,gBACF,SAAE,eAAA,gBACF,SAAE,aAAA,gBACF,SACE,cAAA,gBACA,aAAA,gBAEF,SACE,YAAA,gBACA,eAAA,gBAXF,QAAE,QAAA,KAAA,eACF,SAAE,YAAA,eACF,SAAE,cAAA,eACF,SAAE,eAAA,eACF,SAAE,aAAA,eACF,SACE,cAAA,eACA,aAAA,eAEF,SACE,YAAA,eACA,eAAA,eAXF,QAAE,QAAA,OAAA,iBACF,SAAE,YAAA,iBACF,SAAE,cAAA,iBACF,SAAE,eAAA,iBACF,SAAE,aAAA,iBACF,SACE,cAAA,iBACA,aAAA,iBAEF,SACE,YAAA,iBACA,eAAA,iBAXF,QAAE,QAAA,KAAA,eACF,SAAE,YAAA,eACF,SAAE,cAAA,eACF,SAAE,eAAA,eACF,SAAE,aAAA,eACF,SACE,cAAA,eACA,aAAA,eAEF,SACE,YAAA,eACA,eAAA,eAMN,WAAE,OAAA,eACF,YAAE,WAAA,eACF,YAAE,aAAA,eACF,YAAE,cAAA,eACF,YAAE,YAAA,eACF,YACE,aAAA,eACA,YAAA,eAEF,YACE,WAAA,eACA,cAAA,gBCjCN,cAAiB,WAAA,kBACjB,aAAiB,YAAA,iBACjB,eCJE,SAAA,OACA,cAAA,SACA,YAAA,ODUE,WAAE,WAAA,eACF,YAAE,WAAA,gBACF,aAAE,WAAA,iBrDsCF,yBqDxCA,cAAE,WAAA,eACF,eAAE,WAAA,gBACF,gBAAE,WAAA,kBrDsCF,yBqDxCA,cAAE,WAAA,eACF,eAAE,WAAA,gBACF,gBAAE,WAAA,kBrDsCF,yBqDxCA,cAAE,WAAA,eACF,eAAE,WAAA,gBACF,gBAAE,WAAA,kBrDsCF,0BqDxCA,cAAE,WAAA,eACF,eAAE,WAAA,gBACF,gBAAE,WAAA,kBAMN,gBAAmB,eAAA,oBACnB,gBAAmB,eAAA,oBACnB,iBAAmB,eAAA,qBAInB,oBAAsB,YAAA,IACtB,kBAAsB,YAAA,IACtB,aAAsB,WAAA,OAItB,YACE,MAAA,eElCA,YACE,MAAA,kBjEgBA,mBAAA,mBiEZE,MAAA,kBALJ,cACE,MAAA,kBjEgBA,qBAAA,qBiEZE,MAAA,kBALJ,cACE,MAAA,kBjEgBA,qBAAA,qBiEZE,MAAA,kBALJ,WACE,MAAA,kBjEgBA,kBAAA,kBiEZE,MAAA,kBALJ,cACE,MAAA,kBjEgBA,qBAAA,qBiEZE,MAAA,kBALJ,aACE,MAAA,kBjEgBA,oBAAA,oBiEZE,MAAA,kBALJ,gBACE,MAAA,kBjEgBA,uBAAA,uBiEZE,MAAA,kBFkDN,WGxDE,KAAA,EAAA,EAAA,EACA,MAAA,YACA,YAAA,KACA,iBAAA,YACA,OAAA,ECFF,WCDE,WAAA,iBDQA,cAEI,QAAA,ezDwDF,yByDrDF,gBAEI,QAAA,gBzDsCF,yByD7CF,cAEI,QAAA,gBzDwDF,yByDrDF,gBAEI,QAAA,gBzDsCF,yByD7CF,cAEI,QAAA,gBzDwDF,yByDrDF,gBAEI,QAAA,gBzDsCF,yByD7CF,cAEI,QAAA,gBzDwDF,0ByDrDF,gBAEI,QAAA,gBzDsCF,0ByD7CF,cAEI,QAAA,gBAGJ,gBAEI,QAAA,eAUN,qBACE,QAAA,eAEA,aAHA,qBAIE,QAAA,iBAGJ,sBACE,QAAA,eAEA,aAHA,sBAIE,QAAA,kBAGJ,4BACE,QAAA,eAEA,aAHA,4BAIE,QAAA,wBAKF,aADA,cAEE,QAAA"} \ No newline at end of file diff --git a/src/alertmanager/ui/app/lib/font-awesome-4.7.0/css/font-awesome.css b/src/alertmanager/ui/app/lib/font-awesome-4.7.0/css/font-awesome.css new file mode 100644 index 0000000..ee906a8 --- /dev/null +++ b/src/alertmanager/ui/app/lib/font-awesome-4.7.0/css/font-awesome.css @@ -0,0 +1,2337 @@ +/*! + * Font Awesome 4.7.0 by @davegandy - http://fontawesome.io - @fontawesome + * License - http://fontawesome.io/license (Font: SIL OFL 1.1, CSS: MIT License) + */ +/* FONT PATH + * -------------------------- */ +@font-face { + font-family: 'FontAwesome'; + src: url('../fonts/fontawesome-webfont.eot?v=4.7.0'); + src: url('../fonts/fontawesome-webfont.eot?#iefix&v=4.7.0') format('embedded-opentype'), url('../fonts/fontawesome-webfont.woff2?v=4.7.0') format('woff2'), url('../fonts/fontawesome-webfont.woff?v=4.7.0') format('woff'), url('../fonts/fontawesome-webfont.ttf?v=4.7.0') format('truetype'), url('../fonts/fontawesome-webfont.svg?v=4.7.0#fontawesomeregular') format('svg'); + font-weight: normal; + font-style: normal; +} +.fa { + display: inline-block; + font: normal normal normal 14px/1 FontAwesome; + font-size: inherit; + text-rendering: auto; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; +} +/* makes the font 33% larger relative to the icon container */ +.fa-lg { + font-size: 1.33333333em; + line-height: 0.75em; + vertical-align: -15%; +} +.fa-2x { + font-size: 2em; +} +.fa-3x { + font-size: 3em; +} +.fa-4x { + font-size: 4em; +} +.fa-5x { + font-size: 5em; +} +.fa-fw { + width: 1.28571429em; + text-align: center; +} +.fa-ul { + padding-left: 0; + margin-left: 2.14285714em; + list-style-type: none; +} +.fa-ul > li { + position: relative; +} +.fa-li { + position: absolute; + left: -2.14285714em; + width: 2.14285714em; + top: 0.14285714em; + text-align: center; +} +.fa-li.fa-lg { + left: -1.85714286em; +} +.fa-border { + padding: .2em .25em .15em; + border: solid 0.08em #eeeeee; + border-radius: .1em; +} +.fa-pull-left { + float: left; +} +.fa-pull-right { + float: right; +} +.fa.fa-pull-left { + margin-right: .3em; +} +.fa.fa-pull-right { + margin-left: .3em; +} +/* Deprecated as of 4.4.0 */ +.pull-right { + float: right; +} +.pull-left { + float: left; +} +.fa.pull-left { + margin-right: .3em; +} +.fa.pull-right { + margin-left: .3em; +} +.fa-spin { + -webkit-animation: fa-spin 2s infinite linear; + animation: fa-spin 2s infinite linear; +} +.fa-pulse { + -webkit-animation: fa-spin 1s infinite steps(8); + animation: fa-spin 1s infinite steps(8); +} +@-webkit-keyframes fa-spin { + 0% { + -webkit-transform: rotate(0deg); + transform: rotate(0deg); + } + 100% { + -webkit-transform: rotate(359deg); + transform: rotate(359deg); + } +} +@keyframes fa-spin { + 0% { + -webkit-transform: rotate(0deg); + transform: rotate(0deg); + } + 100% { + -webkit-transform: rotate(359deg); + transform: rotate(359deg); + } +} +.fa-rotate-90 { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=1)"; + -webkit-transform: rotate(90deg); + -ms-transform: rotate(90deg); + transform: rotate(90deg); +} +.fa-rotate-180 { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=2)"; + -webkit-transform: rotate(180deg); + -ms-transform: rotate(180deg); + transform: rotate(180deg); +} +.fa-rotate-270 { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=3)"; + -webkit-transform: rotate(270deg); + -ms-transform: rotate(270deg); + transform: rotate(270deg); +} +.fa-flip-horizontal { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)"; + -webkit-transform: scale(-1, 1); + -ms-transform: scale(-1, 1); + transform: scale(-1, 1); +} +.fa-flip-vertical { + -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)"; + -webkit-transform: scale(1, -1); + -ms-transform: scale(1, -1); + transform: scale(1, -1); +} +:root .fa-rotate-90, +:root .fa-rotate-180, +:root .fa-rotate-270, +:root .fa-flip-horizontal, +:root .fa-flip-vertical { + filter: none; +} +.fa-stack { + position: relative; + display: inline-block; + width: 2em; + height: 2em; + line-height: 2em; + vertical-align: middle; +} +.fa-stack-1x, +.fa-stack-2x { + position: absolute; + left: 0; + width: 100%; + text-align: center; +} +.fa-stack-1x { + line-height: inherit; +} +.fa-stack-2x { + font-size: 2em; +} +.fa-inverse { + color: #ffffff; +} +/* Font Awesome uses the Unicode Private Use Area (PUA) to ensure screen + readers do not read off random characters that represent icons */ +.fa-glass:before { + content: "\f000"; +} +.fa-music:before { + content: "\f001"; +} +.fa-search:before { + content: "\f002"; +} +.fa-envelope-o:before { + content: "\f003"; +} +.fa-heart:before { + content: "\f004"; +} +.fa-star:before { + content: "\f005"; +} +.fa-star-o:before { + content: "\f006"; +} +.fa-user:before { + content: "\f007"; +} +.fa-film:before { + content: "\f008"; +} +.fa-th-large:before { + content: "\f009"; +} +.fa-th:before { + content: "\f00a"; +} +.fa-th-list:before { + content: "\f00b"; +} +.fa-check:before { + content: "\f00c"; +} +.fa-remove:before, +.fa-close:before, +.fa-times:before { + content: "\f00d"; +} +.fa-search-plus:before { + content: "\f00e"; +} +.fa-search-minus:before { + content: "\f010"; +} +.fa-power-off:before { + content: "\f011"; +} +.fa-signal:before { + content: "\f012"; +} +.fa-gear:before, +.fa-cog:before { + content: "\f013"; +} +.fa-trash-o:before { + content: "\f014"; +} +.fa-home:before { + content: "\f015"; +} +.fa-file-o:before { + content: "\f016"; +} +.fa-clock-o:before { + content: "\f017"; +} +.fa-road:before { + content: "\f018"; +} +.fa-download:before { + content: "\f019"; +} +.fa-arrow-circle-o-down:before { + content: "\f01a"; +} +.fa-arrow-circle-o-up:before { + content: "\f01b"; +} +.fa-inbox:before { + content: "\f01c"; +} +.fa-play-circle-o:before { + content: "\f01d"; +} +.fa-rotate-right:before, +.fa-repeat:before { + content: "\f01e"; +} +.fa-refresh:before { + content: "\f021"; +} +.fa-list-alt:before { + content: "\f022"; +} +.fa-lock:before { + content: "\f023"; +} +.fa-flag:before { + content: "\f024"; +} +.fa-headphones:before { + content: "\f025"; +} +.fa-volume-off:before { + content: "\f026"; +} +.fa-volume-down:before { + content: "\f027"; +} +.fa-volume-up:before { + content: "\f028"; +} +.fa-qrcode:before { + content: "\f029"; +} +.fa-barcode:before { + content: "\f02a"; +} +.fa-tag:before { + content: "\f02b"; +} +.fa-tags:before { + content: "\f02c"; +} +.fa-book:before { + content: "\f02d"; +} +.fa-bookmark:before { + content: "\f02e"; +} +.fa-print:before { + content: "\f02f"; +} +.fa-camera:before { + content: "\f030"; +} +.fa-font:before { + content: "\f031"; +} +.fa-bold:before { + content: "\f032"; +} +.fa-italic:before { + content: "\f033"; +} +.fa-text-height:before { + content: "\f034"; +} +.fa-text-width:before { + content: "\f035"; +} +.fa-align-left:before { + content: "\f036"; +} +.fa-align-center:before { + content: "\f037"; +} +.fa-align-right:before { + content: "\f038"; +} +.fa-align-justify:before { + content: "\f039"; +} +.fa-list:before { + content: "\f03a"; +} +.fa-dedent:before, +.fa-outdent:before { + content: "\f03b"; +} +.fa-indent:before { + content: "\f03c"; +} +.fa-video-camera:before { + content: "\f03d"; +} +.fa-photo:before, +.fa-image:before, +.fa-picture-o:before { + content: "\f03e"; +} +.fa-pencil:before { + content: "\f040"; +} +.fa-map-marker:before { + content: "\f041"; +} +.fa-adjust:before { + content: "\f042"; +} +.fa-tint:before { + content: "\f043"; +} +.fa-edit:before, +.fa-pencil-square-o:before { + content: "\f044"; +} +.fa-share-square-o:before { + content: "\f045"; +} +.fa-check-square-o:before { + content: "\f046"; +} +.fa-arrows:before { + content: "\f047"; +} +.fa-step-backward:before { + content: "\f048"; +} +.fa-fast-backward:before { + content: "\f049"; +} +.fa-backward:before { + content: "\f04a"; +} +.fa-play:before { + content: "\f04b"; +} +.fa-pause:before { + content: "\f04c"; +} +.fa-stop:before { + content: "\f04d"; +} +.fa-forward:before { + content: "\f04e"; +} +.fa-fast-forward:before { + content: "\f050"; +} +.fa-step-forward:before { + content: "\f051"; +} +.fa-eject:before { + content: "\f052"; +} +.fa-chevron-left:before { + content: "\f053"; +} +.fa-chevron-right:before { + content: "\f054"; +} +.fa-plus-circle:before { + content: "\f055"; +} +.fa-minus-circle:before { + content: "\f056"; +} +.fa-times-circle:before { + content: "\f057"; +} +.fa-check-circle:before { + content: "\f058"; +} +.fa-question-circle:before { + content: "\f059"; +} +.fa-info-circle:before { + content: "\f05a"; +} +.fa-crosshairs:before { + content: "\f05b"; +} +.fa-times-circle-o:before { + content: "\f05c"; +} +.fa-check-circle-o:before { + content: "\f05d"; +} +.fa-ban:before { + content: "\f05e"; +} +.fa-arrow-left:before { + content: "\f060"; +} +.fa-arrow-right:before { + content: "\f061"; +} +.fa-arrow-up:before { + content: "\f062"; +} +.fa-arrow-down:before { + content: "\f063"; +} +.fa-mail-forward:before, +.fa-share:before { + content: "\f064"; +} +.fa-expand:before { + content: "\f065"; +} +.fa-compress:before { + content: "\f066"; +} +.fa-plus:before { + content: "\f067"; +} +.fa-minus:before { + content: "\f068"; +} +.fa-asterisk:before { + content: "\f069"; +} +.fa-exclamation-circle:before { + content: "\f06a"; +} +.fa-gift:before { + content: "\f06b"; +} +.fa-leaf:before { + content: "\f06c"; +} +.fa-fire:before { + content: "\f06d"; +} +.fa-eye:before { + content: "\f06e"; +} +.fa-eye-slash:before { + content: "\f070"; +} +.fa-warning:before, +.fa-exclamation-triangle:before { + content: "\f071"; +} +.fa-plane:before { + content: "\f072"; +} +.fa-calendar:before { + content: "\f073"; +} +.fa-random:before { + content: "\f074"; +} +.fa-comment:before { + content: "\f075"; +} +.fa-magnet:before { + content: "\f076"; +} +.fa-chevron-up:before { + content: "\f077"; +} +.fa-chevron-down:before { + content: "\f078"; +} +.fa-retweet:before { + content: "\f079"; +} +.fa-shopping-cart:before { + content: "\f07a"; +} +.fa-folder:before { + content: "\f07b"; +} +.fa-folder-open:before { + content: "\f07c"; +} +.fa-arrows-v:before { + content: "\f07d"; +} +.fa-arrows-h:before { + content: "\f07e"; +} +.fa-bar-chart-o:before, +.fa-bar-chart:before { + content: "\f080"; +} +.fa-twitter-square:before { + content: "\f081"; +} +.fa-facebook-square:before { + content: "\f082"; +} +.fa-camera-retro:before { + content: "\f083"; +} +.fa-key:before { + content: "\f084"; +} +.fa-gears:before, +.fa-cogs:before { + content: "\f085"; +} +.fa-comments:before { + content: "\f086"; +} +.fa-thumbs-o-up:before { + content: "\f087"; +} +.fa-thumbs-o-down:before { + content: "\f088"; +} +.fa-star-half:before { + content: "\f089"; +} +.fa-heart-o:before { + content: "\f08a"; +} +.fa-sign-out:before { + content: "\f08b"; +} +.fa-linkedin-square:before { + content: "\f08c"; +} +.fa-thumb-tack:before { + content: "\f08d"; +} +.fa-external-link:before { + content: "\f08e"; +} +.fa-sign-in:before { + content: "\f090"; +} +.fa-trophy:before { + content: "\f091"; +} +.fa-github-square:before { + content: "\f092"; +} +.fa-upload:before { + content: "\f093"; +} +.fa-lemon-o:before { + content: "\f094"; +} +.fa-phone:before { + content: "\f095"; +} +.fa-square-o:before { + content: "\f096"; +} +.fa-bookmark-o:before { + content: "\f097"; +} +.fa-phone-square:before { + content: "\f098"; +} +.fa-twitter:before { + content: "\f099"; +} +.fa-facebook-f:before, +.fa-facebook:before { + content: "\f09a"; +} +.fa-github:before { + content: "\f09b"; +} +.fa-unlock:before { + content: "\f09c"; +} +.fa-credit-card:before { + content: "\f09d"; +} +.fa-feed:before, +.fa-rss:before { + content: "\f09e"; +} +.fa-hdd-o:before { + content: "\f0a0"; +} +.fa-bullhorn:before { + content: "\f0a1"; +} +.fa-bell:before { + content: "\f0f3"; +} +.fa-certificate:before { + content: "\f0a3"; +} +.fa-hand-o-right:before { + content: "\f0a4"; +} +.fa-hand-o-left:before { + content: "\f0a5"; +} +.fa-hand-o-up:before { + content: "\f0a6"; +} +.fa-hand-o-down:before { + content: "\f0a7"; +} +.fa-arrow-circle-left:before { + content: "\f0a8"; +} +.fa-arrow-circle-right:before { + content: "\f0a9"; +} +.fa-arrow-circle-up:before { + content: "\f0aa"; +} +.fa-arrow-circle-down:before { + content: "\f0ab"; +} +.fa-globe:before { + content: "\f0ac"; +} +.fa-wrench:before { + content: "\f0ad"; +} +.fa-tasks:before { + content: "\f0ae"; +} +.fa-filter:before { + content: "\f0b0"; +} +.fa-briefcase:before { + content: "\f0b1"; +} +.fa-arrows-alt:before { + content: "\f0b2"; +} +.fa-group:before, +.fa-users:before { + content: "\f0c0"; +} +.fa-chain:before, +.fa-link:before { + content: "\f0c1"; +} +.fa-cloud:before { + content: "\f0c2"; +} +.fa-flask:before { + content: "\f0c3"; +} +.fa-cut:before, +.fa-scissors:before { + content: "\f0c4"; +} +.fa-copy:before, +.fa-files-o:before { + content: "\f0c5"; +} +.fa-paperclip:before { + content: "\f0c6"; +} +.fa-save:before, +.fa-floppy-o:before { + content: "\f0c7"; +} +.fa-square:before { + content: "\f0c8"; +} +.fa-navicon:before, +.fa-reorder:before, +.fa-bars:before { + content: "\f0c9"; +} +.fa-list-ul:before { + content: "\f0ca"; +} +.fa-list-ol:before { + content: "\f0cb"; +} +.fa-strikethrough:before { + content: "\f0cc"; +} +.fa-underline:before { + content: "\f0cd"; +} +.fa-table:before { + content: "\f0ce"; +} +.fa-magic:before { + content: "\f0d0"; +} +.fa-truck:before { + content: "\f0d1"; +} +.fa-pinterest:before { + content: "\f0d2"; +} +.fa-pinterest-square:before { + content: "\f0d3"; +} +.fa-google-plus-square:before { + content: "\f0d4"; +} +.fa-google-plus:before { + content: "\f0d5"; +} +.fa-money:before { + content: "\f0d6"; +} +.fa-caret-down:before { + content: "\f0d7"; +} +.fa-caret-up:before { + content: "\f0d8"; +} +.fa-caret-left:before { + content: "\f0d9"; +} +.fa-caret-right:before { + content: "\f0da"; +} +.fa-columns:before { + content: "\f0db"; +} +.fa-unsorted:before, +.fa-sort:before { + content: "\f0dc"; +} +.fa-sort-down:before, +.fa-sort-desc:before { + content: "\f0dd"; +} +.fa-sort-up:before, +.fa-sort-asc:before { + content: "\f0de"; +} +.fa-envelope:before { + content: "\f0e0"; +} +.fa-linkedin:before { + content: "\f0e1"; +} +.fa-rotate-left:before, +.fa-undo:before { + content: "\f0e2"; +} +.fa-legal:before, +.fa-gavel:before { + content: "\f0e3"; +} +.fa-dashboard:before, +.fa-tachometer:before { + content: "\f0e4"; +} +.fa-comment-o:before { + content: "\f0e5"; +} +.fa-comments-o:before { + content: "\f0e6"; +} +.fa-flash:before, +.fa-bolt:before { + content: "\f0e7"; +} +.fa-sitemap:before { + content: "\f0e8"; +} +.fa-umbrella:before { + content: "\f0e9"; +} +.fa-paste:before, +.fa-clipboard:before { + content: "\f0ea"; +} +.fa-lightbulb-o:before { + content: "\f0eb"; +} +.fa-exchange:before { + content: "\f0ec"; +} +.fa-cloud-download:before { + content: "\f0ed"; +} +.fa-cloud-upload:before { + content: "\f0ee"; +} +.fa-user-md:before { + content: "\f0f0"; +} +.fa-stethoscope:before { + content: "\f0f1"; +} +.fa-suitcase:before { + content: "\f0f2"; +} +.fa-bell-o:before { + content: "\f0a2"; +} +.fa-coffee:before { + content: "\f0f4"; +} +.fa-cutlery:before { + content: "\f0f5"; +} +.fa-file-text-o:before { + content: "\f0f6"; +} +.fa-building-o:before { + content: "\f0f7"; +} +.fa-hospital-o:before { + content: "\f0f8"; +} +.fa-ambulance:before { + content: "\f0f9"; +} +.fa-medkit:before { + content: "\f0fa"; +} +.fa-fighter-jet:before { + content: "\f0fb"; +} +.fa-beer:before { + content: "\f0fc"; +} +.fa-h-square:before { + content: "\f0fd"; +} +.fa-plus-square:before { + content: "\f0fe"; +} +.fa-angle-double-left:before { + content: "\f100"; +} +.fa-angle-double-right:before { + content: "\f101"; +} +.fa-angle-double-up:before { + content: "\f102"; +} +.fa-angle-double-down:before { + content: "\f103"; +} +.fa-angle-left:before { + content: "\f104"; +} +.fa-angle-right:before { + content: "\f105"; +} +.fa-angle-up:before { + content: "\f106"; +} +.fa-angle-down:before { + content: "\f107"; +} +.fa-desktop:before { + content: "\f108"; +} +.fa-laptop:before { + content: "\f109"; +} +.fa-tablet:before { + content: "\f10a"; +} +.fa-mobile-phone:before, +.fa-mobile:before { + content: "\f10b"; +} +.fa-circle-o:before { + content: "\f10c"; +} +.fa-quote-left:before { + content: "\f10d"; +} +.fa-quote-right:before { + content: "\f10e"; +} +.fa-spinner:before { + content: "\f110"; +} +.fa-circle:before { + content: "\f111"; +} +.fa-mail-reply:before, +.fa-reply:before { + content: "\f112"; +} +.fa-github-alt:before { + content: "\f113"; +} +.fa-folder-o:before { + content: "\f114"; +} +.fa-folder-open-o:before { + content: "\f115"; +} +.fa-smile-o:before { + content: "\f118"; +} +.fa-frown-o:before { + content: "\f119"; +} +.fa-meh-o:before { + content: "\f11a"; +} +.fa-gamepad:before { + content: "\f11b"; +} +.fa-keyboard-o:before { + content: "\f11c"; +} +.fa-flag-o:before { + content: "\f11d"; +} +.fa-flag-checkered:before { + content: "\f11e"; +} +.fa-terminal:before { + content: "\f120"; +} +.fa-code:before { + content: "\f121"; +} +.fa-mail-reply-all:before, +.fa-reply-all:before { + content: "\f122"; +} +.fa-star-half-empty:before, +.fa-star-half-full:before, +.fa-star-half-o:before { + content: "\f123"; +} +.fa-location-arrow:before { + content: "\f124"; +} +.fa-crop:before { + content: "\f125"; +} +.fa-code-fork:before { + content: "\f126"; +} +.fa-unlink:before, +.fa-chain-broken:before { + content: "\f127"; +} +.fa-question:before { + content: "\f128"; +} +.fa-info:before { + content: "\f129"; +} +.fa-exclamation:before { + content: "\f12a"; +} +.fa-superscript:before { + content: "\f12b"; +} +.fa-subscript:before { + content: "\f12c"; +} +.fa-eraser:before { + content: "\f12d"; +} +.fa-puzzle-piece:before { + content: "\f12e"; +} +.fa-microphone:before { + content: "\f130"; +} +.fa-microphone-slash:before { + content: "\f131"; +} +.fa-shield:before { + content: "\f132"; +} +.fa-calendar-o:before { + content: "\f133"; +} +.fa-fire-extinguisher:before { + content: "\f134"; +} +.fa-rocket:before { + content: "\f135"; +} +.fa-maxcdn:before { + content: "\f136"; +} +.fa-chevron-circle-left:before { + content: "\f137"; +} +.fa-chevron-circle-right:before { + content: "\f138"; +} +.fa-chevron-circle-up:before { + content: "\f139"; +} +.fa-chevron-circle-down:before { + content: "\f13a"; +} +.fa-html5:before { + content: "\f13b"; +} +.fa-css3:before { + content: "\f13c"; +} +.fa-anchor:before { + content: "\f13d"; +} +.fa-unlock-alt:before { + content: "\f13e"; +} +.fa-bullseye:before { + content: "\f140"; +} +.fa-ellipsis-h:before { + content: "\f141"; +} +.fa-ellipsis-v:before { + content: "\f142"; +} +.fa-rss-square:before { + content: "\f143"; +} +.fa-play-circle:before { + content: "\f144"; +} +.fa-ticket:before { + content: "\f145"; +} +.fa-minus-square:before { + content: "\f146"; +} +.fa-minus-square-o:before { + content: "\f147"; +} +.fa-level-up:before { + content: "\f148"; +} +.fa-level-down:before { + content: "\f149"; +} +.fa-check-square:before { + content: "\f14a"; +} +.fa-pencil-square:before { + content: "\f14b"; +} +.fa-external-link-square:before { + content: "\f14c"; +} +.fa-share-square:before { + content: "\f14d"; +} +.fa-compass:before { + content: "\f14e"; +} +.fa-toggle-down:before, +.fa-caret-square-o-down:before { + content: "\f150"; +} +.fa-toggle-up:before, +.fa-caret-square-o-up:before { + content: "\f151"; +} +.fa-toggle-right:before, +.fa-caret-square-o-right:before { + content: "\f152"; +} +.fa-euro:before, +.fa-eur:before { + content: "\f153"; +} +.fa-gbp:before { + content: "\f154"; +} +.fa-dollar:before, +.fa-usd:before { + content: "\f155"; +} +.fa-rupee:before, +.fa-inr:before { + content: "\f156"; +} +.fa-cny:before, +.fa-rmb:before, +.fa-yen:before, +.fa-jpy:before { + content: "\f157"; +} +.fa-ruble:before, +.fa-rouble:before, +.fa-rub:before { + content: "\f158"; +} +.fa-won:before, +.fa-krw:before { + content: "\f159"; +} +.fa-bitcoin:before, +.fa-btc:before { + content: "\f15a"; +} +.fa-file:before { + content: "\f15b"; +} +.fa-file-text:before { + content: "\f15c"; +} +.fa-sort-alpha-asc:before { + content: "\f15d"; +} +.fa-sort-alpha-desc:before { + content: "\f15e"; +} +.fa-sort-amount-asc:before { + content: "\f160"; +} +.fa-sort-amount-desc:before { + content: "\f161"; +} +.fa-sort-numeric-asc:before { + content: "\f162"; +} +.fa-sort-numeric-desc:before { + content: "\f163"; +} +.fa-thumbs-up:before { + content: "\f164"; +} +.fa-thumbs-down:before { + content: "\f165"; +} +.fa-youtube-square:before { + content: "\f166"; +} +.fa-youtube:before { + content: "\f167"; +} +.fa-xing:before { + content: "\f168"; +} +.fa-xing-square:before { + content: "\f169"; +} +.fa-youtube-play:before { + content: "\f16a"; +} +.fa-dropbox:before { + content: "\f16b"; +} +.fa-stack-overflow:before { + content: "\f16c"; +} +.fa-instagram:before { + content: "\f16d"; +} +.fa-flickr:before { + content: "\f16e"; +} +.fa-adn:before { + content: "\f170"; +} +.fa-bitbucket:before { + content: "\f171"; +} +.fa-bitbucket-square:before { + content: "\f172"; +} +.fa-tumblr:before { + content: "\f173"; +} +.fa-tumblr-square:before { + content: "\f174"; +} +.fa-long-arrow-down:before { + content: "\f175"; +} +.fa-long-arrow-up:before { + content: "\f176"; +} +.fa-long-arrow-left:before { + content: "\f177"; +} +.fa-long-arrow-right:before { + content: "\f178"; +} +.fa-apple:before { + content: "\f179"; +} +.fa-windows:before { + content: "\f17a"; +} +.fa-android:before { + content: "\f17b"; +} +.fa-linux:before { + content: "\f17c"; +} +.fa-dribbble:before { + content: "\f17d"; +} +.fa-skype:before { + content: "\f17e"; +} +.fa-foursquare:before { + content: "\f180"; +} +.fa-trello:before { + content: "\f181"; +} +.fa-female:before { + content: "\f182"; +} +.fa-male:before { + content: "\f183"; +} +.fa-gittip:before, +.fa-gratipay:before { + content: "\f184"; +} +.fa-sun-o:before { + content: "\f185"; +} +.fa-moon-o:before { + content: "\f186"; +} +.fa-archive:before { + content: "\f187"; +} +.fa-bug:before { + content: "\f188"; +} +.fa-vk:before { + content: "\f189"; +} +.fa-weibo:before { + content: "\f18a"; +} +.fa-renren:before { + content: "\f18b"; +} +.fa-pagelines:before { + content: "\f18c"; +} +.fa-stack-exchange:before { + content: "\f18d"; +} +.fa-arrow-circle-o-right:before { + content: "\f18e"; +} +.fa-arrow-circle-o-left:before { + content: "\f190"; +} +.fa-toggle-left:before, +.fa-caret-square-o-left:before { + content: "\f191"; +} +.fa-dot-circle-o:before { + content: "\f192"; +} +.fa-wheelchair:before { + content: "\f193"; +} +.fa-vimeo-square:before { + content: "\f194"; +} +.fa-turkish-lira:before, +.fa-try:before { + content: "\f195"; +} +.fa-plus-square-o:before { + content: "\f196"; +} +.fa-space-shuttle:before { + content: "\f197"; +} +.fa-slack:before { + content: "\f198"; +} +.fa-envelope-square:before { + content: "\f199"; +} +.fa-wordpress:before { + content: "\f19a"; +} +.fa-openid:before { + content: "\f19b"; +} +.fa-institution:before, +.fa-bank:before, +.fa-university:before { + content: "\f19c"; +} +.fa-mortar-board:before, +.fa-graduation-cap:before { + content: "\f19d"; +} +.fa-yahoo:before { + content: "\f19e"; +} +.fa-google:before { + content: "\f1a0"; +} +.fa-reddit:before { + content: "\f1a1"; +} +.fa-reddit-square:before { + content: "\f1a2"; +} +.fa-stumbleupon-circle:before { + content: "\f1a3"; +} +.fa-stumbleupon:before { + content: "\f1a4"; +} +.fa-delicious:before { + content: "\f1a5"; +} +.fa-digg:before { + content: "\f1a6"; +} +.fa-pied-piper-pp:before { + content: "\f1a7"; +} +.fa-pied-piper-alt:before { + content: "\f1a8"; +} +.fa-drupal:before { + content: "\f1a9"; +} +.fa-joomla:before { + content: "\f1aa"; +} +.fa-language:before { + content: "\f1ab"; +} +.fa-fax:before { + content: "\f1ac"; +} +.fa-building:before { + content: "\f1ad"; +} +.fa-child:before { + content: "\f1ae"; +} +.fa-paw:before { + content: "\f1b0"; +} +.fa-spoon:before { + content: "\f1b1"; +} +.fa-cube:before { + content: "\f1b2"; +} +.fa-cubes:before { + content: "\f1b3"; +} +.fa-behance:before { + content: "\f1b4"; +} +.fa-behance-square:before { + content: "\f1b5"; +} +.fa-steam:before { + content: "\f1b6"; +} +.fa-steam-square:before { + content: "\f1b7"; +} +.fa-recycle:before { + content: "\f1b8"; +} +.fa-automobile:before, +.fa-car:before { + content: "\f1b9"; +} +.fa-cab:before, +.fa-taxi:before { + content: "\f1ba"; +} +.fa-tree:before { + content: "\f1bb"; +} +.fa-spotify:before { + content: "\f1bc"; +} +.fa-deviantart:before { + content: "\f1bd"; +} +.fa-soundcloud:before { + content: "\f1be"; +} +.fa-database:before { + content: "\f1c0"; +} +.fa-file-pdf-o:before { + content: "\f1c1"; +} +.fa-file-word-o:before { + content: "\f1c2"; +} +.fa-file-excel-o:before { + content: "\f1c3"; +} +.fa-file-powerpoint-o:before { + content: "\f1c4"; +} +.fa-file-photo-o:before, +.fa-file-picture-o:before, +.fa-file-image-o:before { + content: "\f1c5"; +} +.fa-file-zip-o:before, +.fa-file-archive-o:before { + content: "\f1c6"; +} +.fa-file-sound-o:before, +.fa-file-audio-o:before { + content: "\f1c7"; +} +.fa-file-movie-o:before, +.fa-file-video-o:before { + content: "\f1c8"; +} +.fa-file-code-o:before { + content: "\f1c9"; +} +.fa-vine:before { + content: "\f1ca"; +} +.fa-codepen:before { + content: "\f1cb"; +} +.fa-jsfiddle:before { + content: "\f1cc"; +} +.fa-life-bouy:before, +.fa-life-buoy:before, +.fa-life-saver:before, +.fa-support:before, +.fa-life-ring:before { + content: "\f1cd"; +} +.fa-circle-o-notch:before { + content: "\f1ce"; +} +.fa-ra:before, +.fa-resistance:before, +.fa-rebel:before { + content: "\f1d0"; +} +.fa-ge:before, +.fa-empire:before { + content: "\f1d1"; +} +.fa-git-square:before { + content: "\f1d2"; +} +.fa-git:before { + content: "\f1d3"; +} +.fa-y-combinator-square:before, +.fa-yc-square:before, +.fa-hacker-news:before { + content: "\f1d4"; +} +.fa-tencent-weibo:before { + content: "\f1d5"; +} +.fa-qq:before { + content: "\f1d6"; +} +.fa-wechat:before, +.fa-weixin:before { + content: "\f1d7"; +} +.fa-send:before, +.fa-paper-plane:before { + content: "\f1d8"; +} +.fa-send-o:before, +.fa-paper-plane-o:before { + content: "\f1d9"; +} +.fa-history:before { + content: "\f1da"; +} +.fa-circle-thin:before { + content: "\f1db"; +} +.fa-header:before { + content: "\f1dc"; +} +.fa-paragraph:before { + content: "\f1dd"; +} +.fa-sliders:before { + content: "\f1de"; +} +.fa-share-alt:before { + content: "\f1e0"; +} +.fa-share-alt-square:before { + content: "\f1e1"; +} +.fa-bomb:before { + content: "\f1e2"; +} +.fa-soccer-ball-o:before, +.fa-futbol-o:before { + content: "\f1e3"; +} +.fa-tty:before { + content: "\f1e4"; +} +.fa-binoculars:before { + content: "\f1e5"; +} +.fa-plug:before { + content: "\f1e6"; +} +.fa-slideshare:before { + content: "\f1e7"; +} +.fa-twitch:before { + content: "\f1e8"; +} +.fa-yelp:before { + content: "\f1e9"; +} +.fa-newspaper-o:before { + content: "\f1ea"; +} +.fa-wifi:before { + content: "\f1eb"; +} +.fa-calculator:before { + content: "\f1ec"; +} +.fa-paypal:before { + content: "\f1ed"; +} +.fa-google-wallet:before { + content: "\f1ee"; +} +.fa-cc-visa:before { + content: "\f1f0"; +} +.fa-cc-mastercard:before { + content: "\f1f1"; +} +.fa-cc-discover:before { + content: "\f1f2"; +} +.fa-cc-amex:before { + content: "\f1f3"; +} +.fa-cc-paypal:before { + content: "\f1f4"; +} +.fa-cc-stripe:before { + content: "\f1f5"; +} +.fa-bell-slash:before { + content: "\f1f6"; +} +.fa-bell-slash-o:before { + content: "\f1f7"; +} +.fa-trash:before { + content: "\f1f8"; +} +.fa-copyright:before { + content: "\f1f9"; +} +.fa-at:before { + content: "\f1fa"; +} +.fa-eyedropper:before { + content: "\f1fb"; +} +.fa-paint-brush:before { + content: "\f1fc"; +} +.fa-birthday-cake:before { + content: "\f1fd"; +} +.fa-area-chart:before { + content: "\f1fe"; +} +.fa-pie-chart:before { + content: "\f200"; +} +.fa-line-chart:before { + content: "\f201"; +} +.fa-lastfm:before { + content: "\f202"; +} +.fa-lastfm-square:before { + content: "\f203"; +} +.fa-toggle-off:before { + content: "\f204"; +} +.fa-toggle-on:before { + content: "\f205"; +} +.fa-bicycle:before { + content: "\f206"; +} +.fa-bus:before { + content: "\f207"; +} +.fa-ioxhost:before { + content: "\f208"; +} +.fa-angellist:before { + content: "\f209"; +} +.fa-cc:before { + content: "\f20a"; +} +.fa-shekel:before, +.fa-sheqel:before, +.fa-ils:before { + content: "\f20b"; +} +.fa-meanpath:before { + content: "\f20c"; +} +.fa-buysellads:before { + content: "\f20d"; +} +.fa-connectdevelop:before { + content: "\f20e"; +} +.fa-dashcube:before { + content: "\f210"; +} +.fa-forumbee:before { + content: "\f211"; +} +.fa-leanpub:before { + content: "\f212"; +} +.fa-sellsy:before { + content: "\f213"; +} +.fa-shirtsinbulk:before { + content: "\f214"; +} +.fa-simplybuilt:before { + content: "\f215"; +} +.fa-skyatlas:before { + content: "\f216"; +} +.fa-cart-plus:before { + content: "\f217"; +} +.fa-cart-arrow-down:before { + content: "\f218"; +} +.fa-diamond:before { + content: "\f219"; +} +.fa-ship:before { + content: "\f21a"; +} +.fa-user-secret:before { + content: "\f21b"; +} +.fa-motorcycle:before { + content: "\f21c"; +} +.fa-street-view:before { + content: "\f21d"; +} +.fa-heartbeat:before { + content: "\f21e"; +} +.fa-venus:before { + content: "\f221"; +} +.fa-mars:before { + content: "\f222"; +} +.fa-mercury:before { + content: "\f223"; +} +.fa-intersex:before, +.fa-transgender:before { + content: "\f224"; +} +.fa-transgender-alt:before { + content: "\f225"; +} +.fa-venus-double:before { + content: "\f226"; +} +.fa-mars-double:before { + content: "\f227"; +} +.fa-venus-mars:before { + content: "\f228"; +} +.fa-mars-stroke:before { + content: "\f229"; +} +.fa-mars-stroke-v:before { + content: "\f22a"; +} +.fa-mars-stroke-h:before { + content: "\f22b"; +} +.fa-neuter:before { + content: "\f22c"; +} +.fa-genderless:before { + content: "\f22d"; +} +.fa-facebook-official:before { + content: "\f230"; +} +.fa-pinterest-p:before { + content: "\f231"; +} +.fa-whatsapp:before { + content: "\f232"; +} +.fa-server:before { + content: "\f233"; +} +.fa-user-plus:before { + content: "\f234"; +} +.fa-user-times:before { + content: "\f235"; +} +.fa-hotel:before, +.fa-bed:before { + content: "\f236"; +} +.fa-viacoin:before { + content: "\f237"; +} +.fa-train:before { + content: "\f238"; +} +.fa-subway:before { + content: "\f239"; +} +.fa-medium:before { + content: "\f23a"; +} +.fa-yc:before, +.fa-y-combinator:before { + content: "\f23b"; +} +.fa-optin-monster:before { + content: "\f23c"; +} +.fa-opencart:before { + content: "\f23d"; +} +.fa-expeditedssl:before { + content: "\f23e"; +} +.fa-battery-4:before, +.fa-battery:before, +.fa-battery-full:before { + content: "\f240"; +} +.fa-battery-3:before, +.fa-battery-three-quarters:before { + content: "\f241"; +} +.fa-battery-2:before, +.fa-battery-half:before { + content: "\f242"; +} +.fa-battery-1:before, +.fa-battery-quarter:before { + content: "\f243"; +} +.fa-battery-0:before, +.fa-battery-empty:before { + content: "\f244"; +} +.fa-mouse-pointer:before { + content: "\f245"; +} +.fa-i-cursor:before { + content: "\f246"; +} +.fa-object-group:before { + content: "\f247"; +} +.fa-object-ungroup:before { + content: "\f248"; +} +.fa-sticky-note:before { + content: "\f249"; +} +.fa-sticky-note-o:before { + content: "\f24a"; +} +.fa-cc-jcb:before { + content: "\f24b"; +} +.fa-cc-diners-club:before { + content: "\f24c"; +} +.fa-clone:before { + content: "\f24d"; +} +.fa-balance-scale:before { + content: "\f24e"; +} +.fa-hourglass-o:before { + content: "\f250"; +} +.fa-hourglass-1:before, +.fa-hourglass-start:before { + content: "\f251"; +} +.fa-hourglass-2:before, +.fa-hourglass-half:before { + content: "\f252"; +} +.fa-hourglass-3:before, +.fa-hourglass-end:before { + content: "\f253"; +} +.fa-hourglass:before { + content: "\f254"; +} +.fa-hand-grab-o:before, +.fa-hand-rock-o:before { + content: "\f255"; +} +.fa-hand-stop-o:before, +.fa-hand-paper-o:before { + content: "\f256"; +} +.fa-hand-scissors-o:before { + content: "\f257"; +} +.fa-hand-lizard-o:before { + content: "\f258"; +} +.fa-hand-spock-o:before { + content: "\f259"; +} +.fa-hand-pointer-o:before { + content: "\f25a"; +} +.fa-hand-peace-o:before { + content: "\f25b"; +} +.fa-trademark:before { + content: "\f25c"; +} +.fa-registered:before { + content: "\f25d"; +} +.fa-creative-commons:before { + content: "\f25e"; +} +.fa-gg:before { + content: "\f260"; +} +.fa-gg-circle:before { + content: "\f261"; +} +.fa-tripadvisor:before { + content: "\f262"; +} +.fa-odnoklassniki:before { + content: "\f263"; +} +.fa-odnoklassniki-square:before { + content: "\f264"; +} +.fa-get-pocket:before { + content: "\f265"; +} +.fa-wikipedia-w:before { + content: "\f266"; +} +.fa-safari:before { + content: "\f267"; +} +.fa-chrome:before { + content: "\f268"; +} +.fa-firefox:before { + content: "\f269"; +} +.fa-opera:before { + content: "\f26a"; +} +.fa-internet-explorer:before { + content: "\f26b"; +} +.fa-tv:before, +.fa-television:before { + content: "\f26c"; +} +.fa-contao:before { + content: "\f26d"; +} +.fa-500px:before { + content: "\f26e"; +} +.fa-amazon:before { + content: "\f270"; +} +.fa-calendar-plus-o:before { + content: "\f271"; +} +.fa-calendar-minus-o:before { + content: "\f272"; +} +.fa-calendar-times-o:before { + content: "\f273"; +} +.fa-calendar-check-o:before { + content: "\f274"; +} +.fa-industry:before { + content: "\f275"; +} +.fa-map-pin:before { + content: "\f276"; +} +.fa-map-signs:before { + content: "\f277"; +} +.fa-map-o:before { + content: "\f278"; +} +.fa-map:before { + content: "\f279"; +} +.fa-commenting:before { + content: "\f27a"; +} +.fa-commenting-o:before { + content: "\f27b"; +} +.fa-houzz:before { + content: "\f27c"; +} +.fa-vimeo:before { + content: "\f27d"; +} +.fa-black-tie:before { + content: "\f27e"; +} +.fa-fonticons:before { + content: "\f280"; +} +.fa-reddit-alien:before { + content: "\f281"; +} +.fa-edge:before { + content: "\f282"; +} +.fa-credit-card-alt:before { + content: "\f283"; +} +.fa-codiepie:before { + content: "\f284"; +} +.fa-modx:before { + content: "\f285"; +} +.fa-fort-awesome:before { + content: "\f286"; +} +.fa-usb:before { + content: "\f287"; +} +.fa-product-hunt:before { + content: "\f288"; +} +.fa-mixcloud:before { + content: "\f289"; +} +.fa-scribd:before { + content: "\f28a"; +} +.fa-pause-circle:before { + content: "\f28b"; +} +.fa-pause-circle-o:before { + content: "\f28c"; +} +.fa-stop-circle:before { + content: "\f28d"; +} +.fa-stop-circle-o:before { + content: "\f28e"; +} +.fa-shopping-bag:before { + content: "\f290"; +} +.fa-shopping-basket:before { + content: "\f291"; +} +.fa-hashtag:before { + content: "\f292"; +} +.fa-bluetooth:before { + content: "\f293"; +} +.fa-bluetooth-b:before { + content: "\f294"; +} +.fa-percent:before { + content: "\f295"; +} +.fa-gitlab:before { + content: "\f296"; +} +.fa-wpbeginner:before { + content: "\f297"; +} +.fa-wpforms:before { + content: "\f298"; +} +.fa-envira:before { + content: "\f299"; +} +.fa-universal-access:before { + content: "\f29a"; +} +.fa-wheelchair-alt:before { + content: "\f29b"; +} +.fa-question-circle-o:before { + content: "\f29c"; +} +.fa-blind:before { + content: "\f29d"; +} +.fa-audio-description:before { + content: "\f29e"; +} +.fa-volume-control-phone:before { + content: "\f2a0"; +} +.fa-braille:before { + content: "\f2a1"; +} +.fa-assistive-listening-systems:before { + content: "\f2a2"; +} +.fa-asl-interpreting:before, +.fa-american-sign-language-interpreting:before { + content: "\f2a3"; +} +.fa-deafness:before, +.fa-hard-of-hearing:before, +.fa-deaf:before { + content: "\f2a4"; +} +.fa-glide:before { + content: "\f2a5"; +} +.fa-glide-g:before { + content: "\f2a6"; +} +.fa-signing:before, +.fa-sign-language:before { + content: "\f2a7"; +} +.fa-low-vision:before { + content: "\f2a8"; +} +.fa-viadeo:before { + content: "\f2a9"; +} +.fa-viadeo-square:before { + content: "\f2aa"; +} +.fa-snapchat:before { + content: "\f2ab"; +} +.fa-snapchat-ghost:before { + content: "\f2ac"; +} +.fa-snapchat-square:before { + content: "\f2ad"; +} +.fa-pied-piper:before { + content: "\f2ae"; +} +.fa-first-order:before { + content: "\f2b0"; +} +.fa-yoast:before { + content: "\f2b1"; +} +.fa-themeisle:before { + content: "\f2b2"; +} +.fa-google-plus-circle:before, +.fa-google-plus-official:before { + content: "\f2b3"; +} +.fa-fa:before, +.fa-font-awesome:before { + content: "\f2b4"; +} +.fa-handshake-o:before { + content: "\f2b5"; +} +.fa-envelope-open:before { + content: "\f2b6"; +} +.fa-envelope-open-o:before { + content: "\f2b7"; +} +.fa-linode:before { + content: "\f2b8"; +} +.fa-address-book:before { + content: "\f2b9"; +} +.fa-address-book-o:before { + content: "\f2ba"; +} +.fa-vcard:before, +.fa-address-card:before { + content: "\f2bb"; +} +.fa-vcard-o:before, +.fa-address-card-o:before { + content: "\f2bc"; +} +.fa-user-circle:before { + content: "\f2bd"; +} +.fa-user-circle-o:before { + content: "\f2be"; +} +.fa-user-o:before { + content: "\f2c0"; +} +.fa-id-badge:before { + content: "\f2c1"; +} +.fa-drivers-license:before, +.fa-id-card:before { + content: "\f2c2"; +} +.fa-drivers-license-o:before, +.fa-id-card-o:before { + content: "\f2c3"; +} +.fa-quora:before { + content: "\f2c4"; +} +.fa-free-code-camp:before { + content: "\f2c5"; +} +.fa-telegram:before { + content: "\f2c6"; +} +.fa-thermometer-4:before, +.fa-thermometer:before, +.fa-thermometer-full:before { + content: "\f2c7"; +} +.fa-thermometer-3:before, +.fa-thermometer-three-quarters:before { + content: "\f2c8"; +} +.fa-thermometer-2:before, +.fa-thermometer-half:before { + content: "\f2c9"; +} +.fa-thermometer-1:before, +.fa-thermometer-quarter:before { + content: "\f2ca"; +} +.fa-thermometer-0:before, +.fa-thermometer-empty:before { + content: "\f2cb"; +} +.fa-shower:before { + content: "\f2cc"; +} +.fa-bathtub:before, +.fa-s15:before, +.fa-bath:before { + content: "\f2cd"; +} +.fa-podcast:before { + content: "\f2ce"; +} +.fa-window-maximize:before { + content: "\f2d0"; +} +.fa-window-minimize:before { + content: "\f2d1"; +} +.fa-window-restore:before { + content: "\f2d2"; +} +.fa-times-rectangle:before, +.fa-window-close:before { + content: "\f2d3"; +} +.fa-times-rectangle-o:before, +.fa-window-close-o:before { + content: "\f2d4"; +} +.fa-bandcamp:before { + content: "\f2d5"; +} +.fa-grav:before { + content: "\f2d6"; +} +.fa-etsy:before { + content: "\f2d7"; +} +.fa-imdb:before { + content: "\f2d8"; +} +.fa-ravelry:before { + content: "\f2d9"; +} +.fa-eercast:before { + content: "\f2da"; +} +.fa-microchip:before { + content: "\f2db"; +} +.fa-snowflake-o:before { + content: "\f2dc"; +} +.fa-superpowers:before { + content: "\f2dd"; +} +.fa-wpexplorer:before { + content: "\f2de"; +} +.fa-meetup:before { + content: "\f2e0"; +} +.sr-only { + position: absolute; + width: 1px; + height: 1px; + padding: 0; + margin: -1px; + overflow: hidden; + clip: rect(0, 0, 0, 0); + border: 0; +} +.sr-only-focusable:active, +.sr-only-focusable:focus { + position: static; + width: auto; + height: auto; + margin: 0; + overflow: visible; + clip: auto; +} diff --git a/src/alertmanager/ui/app/lib/font-awesome-4.7.0/css/font-awesome.min.css b/src/alertmanager/ui/app/lib/font-awesome-4.7.0/css/font-awesome.min.css new file mode 100644 index 0000000..540440c --- /dev/null +++ b/src/alertmanager/ui/app/lib/font-awesome-4.7.0/css/font-awesome.min.css @@ -0,0 +1,4 @@ +/*! + * Font Awesome 4.7.0 by @davegandy - http://fontawesome.io - @fontawesome + * License - http://fontawesome.io/license (Font: SIL OFL 1.1, CSS: MIT License) + */@font-face{font-family:'FontAwesome';src:url('../fonts/fontawesome-webfont.eot?v=4.7.0');src:url('../fonts/fontawesome-webfont.eot?#iefix&v=4.7.0') format('embedded-opentype'),url('../fonts/fontawesome-webfont.woff2?v=4.7.0') format('woff2'),url('../fonts/fontawesome-webfont.woff?v=4.7.0') format('woff'),url('../fonts/fontawesome-webfont.ttf?v=4.7.0') format('truetype'),url('../fonts/fontawesome-webfont.svg?v=4.7.0#fontawesomeregular') format('svg');font-weight:normal;font-style:normal}.fa{display:inline-block;font:normal normal normal 14px/1 FontAwesome;font-size:inherit;text-rendering:auto;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.fa-lg{font-size:1.33333333em;line-height:.75em;vertical-align:-15%}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-fw{width:1.28571429em;text-align:center}.fa-ul{padding-left:0;margin-left:2.14285714em;list-style-type:none}.fa-ul>li{position:relative}.fa-li{position:absolute;left:-2.14285714em;width:2.14285714em;top:.14285714em;text-align:center}.fa-li.fa-lg{left:-1.85714286em}.fa-border{padding:.2em .25em .15em;border:solid .08em #eee;border-radius:.1em}.fa-pull-left{float:left}.fa-pull-right{float:right}.fa.fa-pull-left{margin-right:.3em}.fa.fa-pull-right{margin-left:.3em}.pull-right{float:right}.pull-left{float:left}.fa.pull-left{margin-right:.3em}.fa.pull-right{margin-left:.3em}.fa-spin{-webkit-animation:fa-spin 2s infinite linear;animation:fa-spin 2s infinite linear}.fa-pulse{-webkit-animation:fa-spin 1s infinite steps(8);animation:fa-spin 1s infinite steps(8)}@-webkit-keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}100%{-webkit-transform:rotate(359deg);transform:rotate(359deg)}}@keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}100%{-webkit-transform:rotate(359deg);transform:rotate(359deg)}}.fa-rotate-90{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=1)";-webkit-transform:rotate(90deg);-ms-transform:rotate(90deg);transform:rotate(90deg)}.fa-rotate-180{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2)";-webkit-transform:rotate(180deg);-ms-transform:rotate(180deg);transform:rotate(180deg)}.fa-rotate-270{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=3)";-webkit-transform:rotate(270deg);-ms-transform:rotate(270deg);transform:rotate(270deg)}.fa-flip-horizontal{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)";-webkit-transform:scale(-1, 1);-ms-transform:scale(-1, 1);transform:scale(-1, 1)}.fa-flip-vertical{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)";-webkit-transform:scale(1, -1);-ms-transform:scale(1, -1);transform:scale(1, -1)}:root .fa-rotate-90,:root .fa-rotate-180,:root .fa-rotate-270,:root .fa-flip-horizontal,:root .fa-flip-vertical{filter:none}.fa-stack{position:relative;display:inline-block;width:2em;height:2em;line-height:2em;vertical-align:middle}.fa-stack-1x,.fa-stack-2x{position:absolute;left:0;width:100%;text-align:center}.fa-stack-1x{line-height:inherit}.fa-stack-2x{font-size:2em}.fa-inverse{color:#fff}.fa-glass:before{content:"\f000"}.fa-music:before{content:"\f001"}.fa-search:before{content:"\f002"}.fa-envelope-o:before{content:"\f003"}.fa-heart:before{content:"\f004"}.fa-star:before{content:"\f005"}.fa-star-o:before{content:"\f006"}.fa-user:before{content:"\f007"}.fa-film:before{content:"\f008"}.fa-th-large:before{content:"\f009"}.fa-th:before{content:"\f00a"}.fa-th-list:before{content:"\f00b"}.fa-check:before{content:"\f00c"}.fa-remove:before,.fa-close:before,.fa-times:before{content:"\f00d"}.fa-search-plus:before{content:"\f00e"}.fa-search-minus:before{content:"\f010"}.fa-power-off:before{content:"\f011"}.fa-signal:before{content:"\f012"}.fa-gear:before,.fa-cog:before{content:"\f013"}.fa-trash-o:before{content:"\f014"}.fa-home:before{content:"\f015"}.fa-file-o:before{content:"\f016"}.fa-clock-o:before{content:"\f017"}.fa-road:before{content:"\f018"}.fa-download:before{content:"\f019"}.fa-arrow-circle-o-down:before{content:"\f01a"}.fa-arrow-circle-o-up:before{content:"\f01b"}.fa-inbox:before{content:"\f01c"}.fa-play-circle-o:before{content:"\f01d"}.fa-rotate-right:before,.fa-repeat:before{content:"\f01e"}.fa-refresh:before{content:"\f021"}.fa-list-alt:before{content:"\f022"}.fa-lock:before{content:"\f023"}.fa-flag:before{content:"\f024"}.fa-headphones:before{content:"\f025"}.fa-volume-off:before{content:"\f026"}.fa-volume-down:before{content:"\f027"}.fa-volume-up:before{content:"\f028"}.fa-qrcode:before{content:"\f029"}.fa-barcode:before{content:"\f02a"}.fa-tag:before{content:"\f02b"}.fa-tags:before{content:"\f02c"}.fa-book:before{content:"\f02d"}.fa-bookmark:before{content:"\f02e"}.fa-print:before{content:"\f02f"}.fa-camera:before{content:"\f030"}.fa-font:before{content:"\f031"}.fa-bold:before{content:"\f032"}.fa-italic:before{content:"\f033"}.fa-text-height:before{content:"\f034"}.fa-text-width:before{content:"\f035"}.fa-align-left:before{content:"\f036"}.fa-align-center:before{content:"\f037"}.fa-align-right:before{content:"\f038"}.fa-align-justify:before{content:"\f039"}.fa-list:before{content:"\f03a"}.fa-dedent:before,.fa-outdent:before{content:"\f03b"}.fa-indent:before{content:"\f03c"}.fa-video-camera:before{content:"\f03d"}.fa-photo:before,.fa-image:before,.fa-picture-o:before{content:"\f03e"}.fa-pencil:before{content:"\f040"}.fa-map-marker:before{content:"\f041"}.fa-adjust:before{content:"\f042"}.fa-tint:before{content:"\f043"}.fa-edit:before,.fa-pencil-square-o:before{content:"\f044"}.fa-share-square-o:before{content:"\f045"}.fa-check-square-o:before{content:"\f046"}.fa-arrows:before{content:"\f047"}.fa-step-backward:before{content:"\f048"}.fa-fast-backward:before{content:"\f049"}.fa-backward:before{content:"\f04a"}.fa-play:before{content:"\f04b"}.fa-pause:before{content:"\f04c"}.fa-stop:before{content:"\f04d"}.fa-forward:before{content:"\f04e"}.fa-fast-forward:before{content:"\f050"}.fa-step-forward:before{content:"\f051"}.fa-eject:before{content:"\f052"}.fa-chevron-left:before{content:"\f053"}.fa-chevron-right:before{content:"\f054"}.fa-plus-circle:before{content:"\f055"}.fa-minus-circle:before{content:"\f056"}.fa-times-circle:before{content:"\f057"}.fa-check-circle:before{content:"\f058"}.fa-question-circle:before{content:"\f059"}.fa-info-circle:before{content:"\f05a"}.fa-crosshairs:before{content:"\f05b"}.fa-times-circle-o:before{content:"\f05c"}.fa-check-circle-o:before{content:"\f05d"}.fa-ban:before{content:"\f05e"}.fa-arrow-left:before{content:"\f060"}.fa-arrow-right:before{content:"\f061"}.fa-arrow-up:before{content:"\f062"}.fa-arrow-down:before{content:"\f063"}.fa-mail-forward:before,.fa-share:before{content:"\f064"}.fa-expand:before{content:"\f065"}.fa-compress:before{content:"\f066"}.fa-plus:before{content:"\f067"}.fa-minus:before{content:"\f068"}.fa-asterisk:before{content:"\f069"}.fa-exclamation-circle:before{content:"\f06a"}.fa-gift:before{content:"\f06b"}.fa-leaf:before{content:"\f06c"}.fa-fire:before{content:"\f06d"}.fa-eye:before{content:"\f06e"}.fa-eye-slash:before{content:"\f070"}.fa-warning:before,.fa-exclamation-triangle:before{content:"\f071"}.fa-plane:before{content:"\f072"}.fa-calendar:before{content:"\f073"}.fa-random:before{content:"\f074"}.fa-comment:before{content:"\f075"}.fa-magnet:before{content:"\f076"}.fa-chevron-up:before{content:"\f077"}.fa-chevron-down:before{content:"\f078"}.fa-retweet:before{content:"\f079"}.fa-shopping-cart:before{content:"\f07a"}.fa-folder:before{content:"\f07b"}.fa-folder-open:before{content:"\f07c"}.fa-arrows-v:before{content:"\f07d"}.fa-arrows-h:before{content:"\f07e"}.fa-bar-chart-o:before,.fa-bar-chart:before{content:"\f080"}.fa-twitter-square:before{content:"\f081"}.fa-facebook-square:before{content:"\f082"}.fa-camera-retro:before{content:"\f083"}.fa-key:before{content:"\f084"}.fa-gears:before,.fa-cogs:before{content:"\f085"}.fa-comments:before{content:"\f086"}.fa-thumbs-o-up:before{content:"\f087"}.fa-thumbs-o-down:before{content:"\f088"}.fa-star-half:before{content:"\f089"}.fa-heart-o:before{content:"\f08a"}.fa-sign-out:before{content:"\f08b"}.fa-linkedin-square:before{content:"\f08c"}.fa-thumb-tack:before{content:"\f08d"}.fa-external-link:before{content:"\f08e"}.fa-sign-in:before{content:"\f090"}.fa-trophy:before{content:"\f091"}.fa-github-square:before{content:"\f092"}.fa-upload:before{content:"\f093"}.fa-lemon-o:before{content:"\f094"}.fa-phone:before{content:"\f095"}.fa-square-o:before{content:"\f096"}.fa-bookmark-o:before{content:"\f097"}.fa-phone-square:before{content:"\f098"}.fa-twitter:before{content:"\f099"}.fa-facebook-f:before,.fa-facebook:before{content:"\f09a"}.fa-github:before{content:"\f09b"}.fa-unlock:before{content:"\f09c"}.fa-credit-card:before{content:"\f09d"}.fa-feed:before,.fa-rss:before{content:"\f09e"}.fa-hdd-o:before{content:"\f0a0"}.fa-bullhorn:before{content:"\f0a1"}.fa-bell:before{content:"\f0f3"}.fa-certificate:before{content:"\f0a3"}.fa-hand-o-right:before{content:"\f0a4"}.fa-hand-o-left:before{content:"\f0a5"}.fa-hand-o-up:before{content:"\f0a6"}.fa-hand-o-down:before{content:"\f0a7"}.fa-arrow-circle-left:before{content:"\f0a8"}.fa-arrow-circle-right:before{content:"\f0a9"}.fa-arrow-circle-up:before{content:"\f0aa"}.fa-arrow-circle-down:before{content:"\f0ab"}.fa-globe:before{content:"\f0ac"}.fa-wrench:before{content:"\f0ad"}.fa-tasks:before{content:"\f0ae"}.fa-filter:before{content:"\f0b0"}.fa-briefcase:before{content:"\f0b1"}.fa-arrows-alt:before{content:"\f0b2"}.fa-group:before,.fa-users:before{content:"\f0c0"}.fa-chain:before,.fa-link:before{content:"\f0c1"}.fa-cloud:before{content:"\f0c2"}.fa-flask:before{content:"\f0c3"}.fa-cut:before,.fa-scissors:before{content:"\f0c4"}.fa-copy:before,.fa-files-o:before{content:"\f0c5"}.fa-paperclip:before{content:"\f0c6"}.fa-save:before,.fa-floppy-o:before{content:"\f0c7"}.fa-square:before{content:"\f0c8"}.fa-navicon:before,.fa-reorder:before,.fa-bars:before{content:"\f0c9"}.fa-list-ul:before{content:"\f0ca"}.fa-list-ol:before{content:"\f0cb"}.fa-strikethrough:before{content:"\f0cc"}.fa-underline:before{content:"\f0cd"}.fa-table:before{content:"\f0ce"}.fa-magic:before{content:"\f0d0"}.fa-truck:before{content:"\f0d1"}.fa-pinterest:before{content:"\f0d2"}.fa-pinterest-square:before{content:"\f0d3"}.fa-google-plus-square:before{content:"\f0d4"}.fa-google-plus:before{content:"\f0d5"}.fa-money:before{content:"\f0d6"}.fa-caret-down:before{content:"\f0d7"}.fa-caret-up:before{content:"\f0d8"}.fa-caret-left:before{content:"\f0d9"}.fa-caret-right:before{content:"\f0da"}.fa-columns:before{content:"\f0db"}.fa-unsorted:before,.fa-sort:before{content:"\f0dc"}.fa-sort-down:before,.fa-sort-desc:before{content:"\f0dd"}.fa-sort-up:before,.fa-sort-asc:before{content:"\f0de"}.fa-envelope:before{content:"\f0e0"}.fa-linkedin:before{content:"\f0e1"}.fa-rotate-left:before,.fa-undo:before{content:"\f0e2"}.fa-legal:before,.fa-gavel:before{content:"\f0e3"}.fa-dashboard:before,.fa-tachometer:before{content:"\f0e4"}.fa-comment-o:before{content:"\f0e5"}.fa-comments-o:before{content:"\f0e6"}.fa-flash:before,.fa-bolt:before{content:"\f0e7"}.fa-sitemap:before{content:"\f0e8"}.fa-umbrella:before{content:"\f0e9"}.fa-paste:before,.fa-clipboard:before{content:"\f0ea"}.fa-lightbulb-o:before{content:"\f0eb"}.fa-exchange:before{content:"\f0ec"}.fa-cloud-download:before{content:"\f0ed"}.fa-cloud-upload:before{content:"\f0ee"}.fa-user-md:before{content:"\f0f0"}.fa-stethoscope:before{content:"\f0f1"}.fa-suitcase:before{content:"\f0f2"}.fa-bell-o:before{content:"\f0a2"}.fa-coffee:before{content:"\f0f4"}.fa-cutlery:before{content:"\f0f5"}.fa-file-text-o:before{content:"\f0f6"}.fa-building-o:before{content:"\f0f7"}.fa-hospital-o:before{content:"\f0f8"}.fa-ambulance:before{content:"\f0f9"}.fa-medkit:before{content:"\f0fa"}.fa-fighter-jet:before{content:"\f0fb"}.fa-beer:before{content:"\f0fc"}.fa-h-square:before{content:"\f0fd"}.fa-plus-square:before{content:"\f0fe"}.fa-angle-double-left:before{content:"\f100"}.fa-angle-double-right:before{content:"\f101"}.fa-angle-double-up:before{content:"\f102"}.fa-angle-double-down:before{content:"\f103"}.fa-angle-left:before{content:"\f104"}.fa-angle-right:before{content:"\f105"}.fa-angle-up:before{content:"\f106"}.fa-angle-down:before{content:"\f107"}.fa-desktop:before{content:"\f108"}.fa-laptop:before{content:"\f109"}.fa-tablet:before{content:"\f10a"}.fa-mobile-phone:before,.fa-mobile:before{content:"\f10b"}.fa-circle-o:before{content:"\f10c"}.fa-quote-left:before{content:"\f10d"}.fa-quote-right:before{content:"\f10e"}.fa-spinner:before{content:"\f110"}.fa-circle:before{content:"\f111"}.fa-mail-reply:before,.fa-reply:before{content:"\f112"}.fa-github-alt:before{content:"\f113"}.fa-folder-o:before{content:"\f114"}.fa-folder-open-o:before{content:"\f115"}.fa-smile-o:before{content:"\f118"}.fa-frown-o:before{content:"\f119"}.fa-meh-o:before{content:"\f11a"}.fa-gamepad:before{content:"\f11b"}.fa-keyboard-o:before{content:"\f11c"}.fa-flag-o:before{content:"\f11d"}.fa-flag-checkered:before{content:"\f11e"}.fa-terminal:before{content:"\f120"}.fa-code:before{content:"\f121"}.fa-mail-reply-all:before,.fa-reply-all:before{content:"\f122"}.fa-star-half-empty:before,.fa-star-half-full:before,.fa-star-half-o:before{content:"\f123"}.fa-location-arrow:before{content:"\f124"}.fa-crop:before{content:"\f125"}.fa-code-fork:before{content:"\f126"}.fa-unlink:before,.fa-chain-broken:before{content:"\f127"}.fa-question:before{content:"\f128"}.fa-info:before{content:"\f129"}.fa-exclamation:before{content:"\f12a"}.fa-superscript:before{content:"\f12b"}.fa-subscript:before{content:"\f12c"}.fa-eraser:before{content:"\f12d"}.fa-puzzle-piece:before{content:"\f12e"}.fa-microphone:before{content:"\f130"}.fa-microphone-slash:before{content:"\f131"}.fa-shield:before{content:"\f132"}.fa-calendar-o:before{content:"\f133"}.fa-fire-extinguisher:before{content:"\f134"}.fa-rocket:before{content:"\f135"}.fa-maxcdn:before{content:"\f136"}.fa-chevron-circle-left:before{content:"\f137"}.fa-chevron-circle-right:before{content:"\f138"}.fa-chevron-circle-up:before{content:"\f139"}.fa-chevron-circle-down:before{content:"\f13a"}.fa-html5:before{content:"\f13b"}.fa-css3:before{content:"\f13c"}.fa-anchor:before{content:"\f13d"}.fa-unlock-alt:before{content:"\f13e"}.fa-bullseye:before{content:"\f140"}.fa-ellipsis-h:before{content:"\f141"}.fa-ellipsis-v:before{content:"\f142"}.fa-rss-square:before{content:"\f143"}.fa-play-circle:before{content:"\f144"}.fa-ticket:before{content:"\f145"}.fa-minus-square:before{content:"\f146"}.fa-minus-square-o:before{content:"\f147"}.fa-level-up:before{content:"\f148"}.fa-level-down:before{content:"\f149"}.fa-check-square:before{content:"\f14a"}.fa-pencil-square:before{content:"\f14b"}.fa-external-link-square:before{content:"\f14c"}.fa-share-square:before{content:"\f14d"}.fa-compass:before{content:"\f14e"}.fa-toggle-down:before,.fa-caret-square-o-down:before{content:"\f150"}.fa-toggle-up:before,.fa-caret-square-o-up:before{content:"\f151"}.fa-toggle-right:before,.fa-caret-square-o-right:before{content:"\f152"}.fa-euro:before,.fa-eur:before{content:"\f153"}.fa-gbp:before{content:"\f154"}.fa-dollar:before,.fa-usd:before{content:"\f155"}.fa-rupee:before,.fa-inr:before{content:"\f156"}.fa-cny:before,.fa-rmb:before,.fa-yen:before,.fa-jpy:before{content:"\f157"}.fa-ruble:before,.fa-rouble:before,.fa-rub:before{content:"\f158"}.fa-won:before,.fa-krw:before{content:"\f159"}.fa-bitcoin:before,.fa-btc:before{content:"\f15a"}.fa-file:before{content:"\f15b"}.fa-file-text:before{content:"\f15c"}.fa-sort-alpha-asc:before{content:"\f15d"}.fa-sort-alpha-desc:before{content:"\f15e"}.fa-sort-amount-asc:before{content:"\f160"}.fa-sort-amount-desc:before{content:"\f161"}.fa-sort-numeric-asc:before{content:"\f162"}.fa-sort-numeric-desc:before{content:"\f163"}.fa-thumbs-up:before{content:"\f164"}.fa-thumbs-down:before{content:"\f165"}.fa-youtube-square:before{content:"\f166"}.fa-youtube:before{content:"\f167"}.fa-xing:before{content:"\f168"}.fa-xing-square:before{content:"\f169"}.fa-youtube-play:before{content:"\f16a"}.fa-dropbox:before{content:"\f16b"}.fa-stack-overflow:before{content:"\f16c"}.fa-instagram:before{content:"\f16d"}.fa-flickr:before{content:"\f16e"}.fa-adn:before{content:"\f170"}.fa-bitbucket:before{content:"\f171"}.fa-bitbucket-square:before{content:"\f172"}.fa-tumblr:before{content:"\f173"}.fa-tumblr-square:before{content:"\f174"}.fa-long-arrow-down:before{content:"\f175"}.fa-long-arrow-up:before{content:"\f176"}.fa-long-arrow-left:before{content:"\f177"}.fa-long-arrow-right:before{content:"\f178"}.fa-apple:before{content:"\f179"}.fa-windows:before{content:"\f17a"}.fa-android:before{content:"\f17b"}.fa-linux:before{content:"\f17c"}.fa-dribbble:before{content:"\f17d"}.fa-skype:before{content:"\f17e"}.fa-foursquare:before{content:"\f180"}.fa-trello:before{content:"\f181"}.fa-female:before{content:"\f182"}.fa-male:before{content:"\f183"}.fa-gittip:before,.fa-gratipay:before{content:"\f184"}.fa-sun-o:before{content:"\f185"}.fa-moon-o:before{content:"\f186"}.fa-archive:before{content:"\f187"}.fa-bug:before{content:"\f188"}.fa-vk:before{content:"\f189"}.fa-weibo:before{content:"\f18a"}.fa-renren:before{content:"\f18b"}.fa-pagelines:before{content:"\f18c"}.fa-stack-exchange:before{content:"\f18d"}.fa-arrow-circle-o-right:before{content:"\f18e"}.fa-arrow-circle-o-left:before{content:"\f190"}.fa-toggle-left:before,.fa-caret-square-o-left:before{content:"\f191"}.fa-dot-circle-o:before{content:"\f192"}.fa-wheelchair:before{content:"\f193"}.fa-vimeo-square:before{content:"\f194"}.fa-turkish-lira:before,.fa-try:before{content:"\f195"}.fa-plus-square-o:before{content:"\f196"}.fa-space-shuttle:before{content:"\f197"}.fa-slack:before{content:"\f198"}.fa-envelope-square:before{content:"\f199"}.fa-wordpress:before{content:"\f19a"}.fa-openid:before{content:"\f19b"}.fa-institution:before,.fa-bank:before,.fa-university:before{content:"\f19c"}.fa-mortar-board:before,.fa-graduation-cap:before{content:"\f19d"}.fa-yahoo:before{content:"\f19e"}.fa-google:before{content:"\f1a0"}.fa-reddit:before{content:"\f1a1"}.fa-reddit-square:before{content:"\f1a2"}.fa-stumbleupon-circle:before{content:"\f1a3"}.fa-stumbleupon:before{content:"\f1a4"}.fa-delicious:before{content:"\f1a5"}.fa-digg:before{content:"\f1a6"}.fa-pied-piper-pp:before{content:"\f1a7"}.fa-pied-piper-alt:before{content:"\f1a8"}.fa-drupal:before{content:"\f1a9"}.fa-joomla:before{content:"\f1aa"}.fa-language:before{content:"\f1ab"}.fa-fax:before{content:"\f1ac"}.fa-building:before{content:"\f1ad"}.fa-child:before{content:"\f1ae"}.fa-paw:before{content:"\f1b0"}.fa-spoon:before{content:"\f1b1"}.fa-cube:before{content:"\f1b2"}.fa-cubes:before{content:"\f1b3"}.fa-behance:before{content:"\f1b4"}.fa-behance-square:before{content:"\f1b5"}.fa-steam:before{content:"\f1b6"}.fa-steam-square:before{content:"\f1b7"}.fa-recycle:before{content:"\f1b8"}.fa-automobile:before,.fa-car:before{content:"\f1b9"}.fa-cab:before,.fa-taxi:before{content:"\f1ba"}.fa-tree:before{content:"\f1bb"}.fa-spotify:before{content:"\f1bc"}.fa-deviantart:before{content:"\f1bd"}.fa-soundcloud:before{content:"\f1be"}.fa-database:before{content:"\f1c0"}.fa-file-pdf-o:before{content:"\f1c1"}.fa-file-word-o:before{content:"\f1c2"}.fa-file-excel-o:before{content:"\f1c3"}.fa-file-powerpoint-o:before{content:"\f1c4"}.fa-file-photo-o:before,.fa-file-picture-o:before,.fa-file-image-o:before{content:"\f1c5"}.fa-file-zip-o:before,.fa-file-archive-o:before{content:"\f1c6"}.fa-file-sound-o:before,.fa-file-audio-o:before{content:"\f1c7"}.fa-file-movie-o:before,.fa-file-video-o:before{content:"\f1c8"}.fa-file-code-o:before{content:"\f1c9"}.fa-vine:before{content:"\f1ca"}.fa-codepen:before{content:"\f1cb"}.fa-jsfiddle:before{content:"\f1cc"}.fa-life-bouy:before,.fa-life-buoy:before,.fa-life-saver:before,.fa-support:before,.fa-life-ring:before{content:"\f1cd"}.fa-circle-o-notch:before{content:"\f1ce"}.fa-ra:before,.fa-resistance:before,.fa-rebel:before{content:"\f1d0"}.fa-ge:before,.fa-empire:before{content:"\f1d1"}.fa-git-square:before{content:"\f1d2"}.fa-git:before{content:"\f1d3"}.fa-y-combinator-square:before,.fa-yc-square:before,.fa-hacker-news:before{content:"\f1d4"}.fa-tencent-weibo:before{content:"\f1d5"}.fa-qq:before{content:"\f1d6"}.fa-wechat:before,.fa-weixin:before{content:"\f1d7"}.fa-send:before,.fa-paper-plane:before{content:"\f1d8"}.fa-send-o:before,.fa-paper-plane-o:before{content:"\f1d9"}.fa-history:before{content:"\f1da"}.fa-circle-thin:before{content:"\f1db"}.fa-header:before{content:"\f1dc"}.fa-paragraph:before{content:"\f1dd"}.fa-sliders:before{content:"\f1de"}.fa-share-alt:before{content:"\f1e0"}.fa-share-alt-square:before{content:"\f1e1"}.fa-bomb:before{content:"\f1e2"}.fa-soccer-ball-o:before,.fa-futbol-o:before{content:"\f1e3"}.fa-tty:before{content:"\f1e4"}.fa-binoculars:before{content:"\f1e5"}.fa-plug:before{content:"\f1e6"}.fa-slideshare:before{content:"\f1e7"}.fa-twitch:before{content:"\f1e8"}.fa-yelp:before{content:"\f1e9"}.fa-newspaper-o:before{content:"\f1ea"}.fa-wifi:before{content:"\f1eb"}.fa-calculator:before{content:"\f1ec"}.fa-paypal:before{content:"\f1ed"}.fa-google-wallet:before{content:"\f1ee"}.fa-cc-visa:before{content:"\f1f0"}.fa-cc-mastercard:before{content:"\f1f1"}.fa-cc-discover:before{content:"\f1f2"}.fa-cc-amex:before{content:"\f1f3"}.fa-cc-paypal:before{content:"\f1f4"}.fa-cc-stripe:before{content:"\f1f5"}.fa-bell-slash:before{content:"\f1f6"}.fa-bell-slash-o:before{content:"\f1f7"}.fa-trash:before{content:"\f1f8"}.fa-copyright:before{content:"\f1f9"}.fa-at:before{content:"\f1fa"}.fa-eyedropper:before{content:"\f1fb"}.fa-paint-brush:before{content:"\f1fc"}.fa-birthday-cake:before{content:"\f1fd"}.fa-area-chart:before{content:"\f1fe"}.fa-pie-chart:before{content:"\f200"}.fa-line-chart:before{content:"\f201"}.fa-lastfm:before{content:"\f202"}.fa-lastfm-square:before{content:"\f203"}.fa-toggle-off:before{content:"\f204"}.fa-toggle-on:before{content:"\f205"}.fa-bicycle:before{content:"\f206"}.fa-bus:before{content:"\f207"}.fa-ioxhost:before{content:"\f208"}.fa-angellist:before{content:"\f209"}.fa-cc:before{content:"\f20a"}.fa-shekel:before,.fa-sheqel:before,.fa-ils:before{content:"\f20b"}.fa-meanpath:before{content:"\f20c"}.fa-buysellads:before{content:"\f20d"}.fa-connectdevelop:before{content:"\f20e"}.fa-dashcube:before{content:"\f210"}.fa-forumbee:before{content:"\f211"}.fa-leanpub:before{content:"\f212"}.fa-sellsy:before{content:"\f213"}.fa-shirtsinbulk:before{content:"\f214"}.fa-simplybuilt:before{content:"\f215"}.fa-skyatlas:before{content:"\f216"}.fa-cart-plus:before{content:"\f217"}.fa-cart-arrow-down:before{content:"\f218"}.fa-diamond:before{content:"\f219"}.fa-ship:before{content:"\f21a"}.fa-user-secret:before{content:"\f21b"}.fa-motorcycle:before{content:"\f21c"}.fa-street-view:before{content:"\f21d"}.fa-heartbeat:before{content:"\f21e"}.fa-venus:before{content:"\f221"}.fa-mars:before{content:"\f222"}.fa-mercury:before{content:"\f223"}.fa-intersex:before,.fa-transgender:before{content:"\f224"}.fa-transgender-alt:before{content:"\f225"}.fa-venus-double:before{content:"\f226"}.fa-mars-double:before{content:"\f227"}.fa-venus-mars:before{content:"\f228"}.fa-mars-stroke:before{content:"\f229"}.fa-mars-stroke-v:before{content:"\f22a"}.fa-mars-stroke-h:before{content:"\f22b"}.fa-neuter:before{content:"\f22c"}.fa-genderless:before{content:"\f22d"}.fa-facebook-official:before{content:"\f230"}.fa-pinterest-p:before{content:"\f231"}.fa-whatsapp:before{content:"\f232"}.fa-server:before{content:"\f233"}.fa-user-plus:before{content:"\f234"}.fa-user-times:before{content:"\f235"}.fa-hotel:before,.fa-bed:before{content:"\f236"}.fa-viacoin:before{content:"\f237"}.fa-train:before{content:"\f238"}.fa-subway:before{content:"\f239"}.fa-medium:before{content:"\f23a"}.fa-yc:before,.fa-y-combinator:before{content:"\f23b"}.fa-optin-monster:before{content:"\f23c"}.fa-opencart:before{content:"\f23d"}.fa-expeditedssl:before{content:"\f23e"}.fa-battery-4:before,.fa-battery:before,.fa-battery-full:before{content:"\f240"}.fa-battery-3:before,.fa-battery-three-quarters:before{content:"\f241"}.fa-battery-2:before,.fa-battery-half:before{content:"\f242"}.fa-battery-1:before,.fa-battery-quarter:before{content:"\f243"}.fa-battery-0:before,.fa-battery-empty:before{content:"\f244"}.fa-mouse-pointer:before{content:"\f245"}.fa-i-cursor:before{content:"\f246"}.fa-object-group:before{content:"\f247"}.fa-object-ungroup:before{content:"\f248"}.fa-sticky-note:before{content:"\f249"}.fa-sticky-note-o:before{content:"\f24a"}.fa-cc-jcb:before{content:"\f24b"}.fa-cc-diners-club:before{content:"\f24c"}.fa-clone:before{content:"\f24d"}.fa-balance-scale:before{content:"\f24e"}.fa-hourglass-o:before{content:"\f250"}.fa-hourglass-1:before,.fa-hourglass-start:before{content:"\f251"}.fa-hourglass-2:before,.fa-hourglass-half:before{content:"\f252"}.fa-hourglass-3:before,.fa-hourglass-end:before{content:"\f253"}.fa-hourglass:before{content:"\f254"}.fa-hand-grab-o:before,.fa-hand-rock-o:before{content:"\f255"}.fa-hand-stop-o:before,.fa-hand-paper-o:before{content:"\f256"}.fa-hand-scissors-o:before{content:"\f257"}.fa-hand-lizard-o:before{content:"\f258"}.fa-hand-spock-o:before{content:"\f259"}.fa-hand-pointer-o:before{content:"\f25a"}.fa-hand-peace-o:before{content:"\f25b"}.fa-trademark:before{content:"\f25c"}.fa-registered:before{content:"\f25d"}.fa-creative-commons:before{content:"\f25e"}.fa-gg:before{content:"\f260"}.fa-gg-circle:before{content:"\f261"}.fa-tripadvisor:before{content:"\f262"}.fa-odnoklassniki:before{content:"\f263"}.fa-odnoklassniki-square:before{content:"\f264"}.fa-get-pocket:before{content:"\f265"}.fa-wikipedia-w:before{content:"\f266"}.fa-safari:before{content:"\f267"}.fa-chrome:before{content:"\f268"}.fa-firefox:before{content:"\f269"}.fa-opera:before{content:"\f26a"}.fa-internet-explorer:before{content:"\f26b"}.fa-tv:before,.fa-television:before{content:"\f26c"}.fa-contao:before{content:"\f26d"}.fa-500px:before{content:"\f26e"}.fa-amazon:before{content:"\f270"}.fa-calendar-plus-o:before{content:"\f271"}.fa-calendar-minus-o:before{content:"\f272"}.fa-calendar-times-o:before{content:"\f273"}.fa-calendar-check-o:before{content:"\f274"}.fa-industry:before{content:"\f275"}.fa-map-pin:before{content:"\f276"}.fa-map-signs:before{content:"\f277"}.fa-map-o:before{content:"\f278"}.fa-map:before{content:"\f279"}.fa-commenting:before{content:"\f27a"}.fa-commenting-o:before{content:"\f27b"}.fa-houzz:before{content:"\f27c"}.fa-vimeo:before{content:"\f27d"}.fa-black-tie:before{content:"\f27e"}.fa-fonticons:before{content:"\f280"}.fa-reddit-alien:before{content:"\f281"}.fa-edge:before{content:"\f282"}.fa-credit-card-alt:before{content:"\f283"}.fa-codiepie:before{content:"\f284"}.fa-modx:before{content:"\f285"}.fa-fort-awesome:before{content:"\f286"}.fa-usb:before{content:"\f287"}.fa-product-hunt:before{content:"\f288"}.fa-mixcloud:before{content:"\f289"}.fa-scribd:before{content:"\f28a"}.fa-pause-circle:before{content:"\f28b"}.fa-pause-circle-o:before{content:"\f28c"}.fa-stop-circle:before{content:"\f28d"}.fa-stop-circle-o:before{content:"\f28e"}.fa-shopping-bag:before{content:"\f290"}.fa-shopping-basket:before{content:"\f291"}.fa-hashtag:before{content:"\f292"}.fa-bluetooth:before{content:"\f293"}.fa-bluetooth-b:before{content:"\f294"}.fa-percent:before{content:"\f295"}.fa-gitlab:before{content:"\f296"}.fa-wpbeginner:before{content:"\f297"}.fa-wpforms:before{content:"\f298"}.fa-envira:before{content:"\f299"}.fa-universal-access:before{content:"\f29a"}.fa-wheelchair-alt:before{content:"\f29b"}.fa-question-circle-o:before{content:"\f29c"}.fa-blind:before{content:"\f29d"}.fa-audio-description:before{content:"\f29e"}.fa-volume-control-phone:before{content:"\f2a0"}.fa-braille:before{content:"\f2a1"}.fa-assistive-listening-systems:before{content:"\f2a2"}.fa-asl-interpreting:before,.fa-american-sign-language-interpreting:before{content:"\f2a3"}.fa-deafness:before,.fa-hard-of-hearing:before,.fa-deaf:before{content:"\f2a4"}.fa-glide:before{content:"\f2a5"}.fa-glide-g:before{content:"\f2a6"}.fa-signing:before,.fa-sign-language:before{content:"\f2a7"}.fa-low-vision:before{content:"\f2a8"}.fa-viadeo:before{content:"\f2a9"}.fa-viadeo-square:before{content:"\f2aa"}.fa-snapchat:before{content:"\f2ab"}.fa-snapchat-ghost:before{content:"\f2ac"}.fa-snapchat-square:before{content:"\f2ad"}.fa-pied-piper:before{content:"\f2ae"}.fa-first-order:before{content:"\f2b0"}.fa-yoast:before{content:"\f2b1"}.fa-themeisle:before{content:"\f2b2"}.fa-google-plus-circle:before,.fa-google-plus-official:before{content:"\f2b3"}.fa-fa:before,.fa-font-awesome:before{content:"\f2b4"}.fa-handshake-o:before{content:"\f2b5"}.fa-envelope-open:before{content:"\f2b6"}.fa-envelope-open-o:before{content:"\f2b7"}.fa-linode:before{content:"\f2b8"}.fa-address-book:before{content:"\f2b9"}.fa-address-book-o:before{content:"\f2ba"}.fa-vcard:before,.fa-address-card:before{content:"\f2bb"}.fa-vcard-o:before,.fa-address-card-o:before{content:"\f2bc"}.fa-user-circle:before{content:"\f2bd"}.fa-user-circle-o:before{content:"\f2be"}.fa-user-o:before{content:"\f2c0"}.fa-id-badge:before{content:"\f2c1"}.fa-drivers-license:before,.fa-id-card:before{content:"\f2c2"}.fa-drivers-license-o:before,.fa-id-card-o:before{content:"\f2c3"}.fa-quora:before{content:"\f2c4"}.fa-free-code-camp:before{content:"\f2c5"}.fa-telegram:before{content:"\f2c6"}.fa-thermometer-4:before,.fa-thermometer:before,.fa-thermometer-full:before{content:"\f2c7"}.fa-thermometer-3:before,.fa-thermometer-three-quarters:before{content:"\f2c8"}.fa-thermometer-2:before,.fa-thermometer-half:before{content:"\f2c9"}.fa-thermometer-1:before,.fa-thermometer-quarter:before{content:"\f2ca"}.fa-thermometer-0:before,.fa-thermometer-empty:before{content:"\f2cb"}.fa-shower:before{content:"\f2cc"}.fa-bathtub:before,.fa-s15:before,.fa-bath:before{content:"\f2cd"}.fa-podcast:before{content:"\f2ce"}.fa-window-maximize:before{content:"\f2d0"}.fa-window-minimize:before{content:"\f2d1"}.fa-window-restore:before{content:"\f2d2"}.fa-times-rectangle:before,.fa-window-close:before{content:"\f2d3"}.fa-times-rectangle-o:before,.fa-window-close-o:before{content:"\f2d4"}.fa-bandcamp:before{content:"\f2d5"}.fa-grav:before{content:"\f2d6"}.fa-etsy:before{content:"\f2d7"}.fa-imdb:before{content:"\f2d8"}.fa-ravelry:before{content:"\f2d9"}.fa-eercast:before{content:"\f2da"}.fa-microchip:before{content:"\f2db"}.fa-snowflake-o:before{content:"\f2dc"}.fa-superpowers:before{content:"\f2dd"}.fa-wpexplorer:before{content:"\f2de"}.fa-meetup:before{content:"\f2e0"}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0, 0, 0, 0);border:0}.sr-only-focusable:active,.sr-only-focusable:focus{position:static;width:auto;height:auto;margin:0;overflow:visible;clip:auto} diff --git a/src/alertmanager/ui/app/lib/font-awesome-4.7.0/fonts/FontAwesome.otf b/src/alertmanager/ui/app/lib/font-awesome-4.7.0/fonts/FontAwesome.otf new file mode 100644 index 0000000..401ec0f Binary files /dev/null and b/src/alertmanager/ui/app/lib/font-awesome-4.7.0/fonts/FontAwesome.otf differ diff --git a/src/alertmanager/ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.eot b/src/alertmanager/ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.eot new file mode 100644 index 0000000..e9f60ca Binary files /dev/null and b/src/alertmanager/ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.eot differ diff --git a/src/alertmanager/ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.svg b/src/alertmanager/ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.svg new file mode 100644 index 0000000..855c845 --- /dev/null +++ b/src/alertmanager/ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.svg @@ -0,0 +1,2671 @@ + + + + +Created by FontForge 20120731 at Mon Oct 24 17:37:40 2016 + By ,,, +Copyright Dave Gandy 2016. All rights reserved. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/alertmanager/ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.ttf b/src/alertmanager/ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.ttf new file mode 100644 index 0000000..35acda2 Binary files /dev/null and b/src/alertmanager/ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.ttf differ diff --git a/src/alertmanager/ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.woff b/src/alertmanager/ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.woff new file mode 100644 index 0000000..400014a Binary files /dev/null and b/src/alertmanager/ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.woff differ diff --git a/src/alertmanager/ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.woff2 b/src/alertmanager/ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.woff2 new file mode 100644 index 0000000..4d13fc6 Binary files /dev/null and b/src/alertmanager/ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.woff2 differ diff --git a/src/alertmanager/ui/app/src/Alerts/Api.elm b/src/alertmanager/ui/app/src/Alerts/Api.elm new file mode 100644 index 0000000..e178624 --- /dev/null +++ b/src/alertmanager/ui/app/src/Alerts/Api.elm @@ -0,0 +1,51 @@ +module Alerts.Api exposing (..) + +import Alerts.Types exposing (Alert, Receiver) +import Json.Decode as Json exposing (..) +import Utils.Api exposing (iso8601Time) +import Utils.Filter exposing (Filter, generateQueryString) +import Utils.Types exposing (ApiData) +import Regex + + +fetchReceivers : String -> Cmd (ApiData (List Receiver)) +fetchReceivers apiUrl = + Utils.Api.send + (Utils.Api.get + (apiUrl ++ "/receivers") + (field "data" (list (Json.map (\receiver -> Receiver receiver (Regex.escape receiver)) string))) + ) + + +fetchAlerts : String -> Filter -> Cmd (ApiData (List Alert)) +fetchAlerts apiUrl filter = + let + url = + String.join "/" [ apiUrl, "alerts" ++ generateQueryString filter ] + in + Utils.Api.send (Utils.Api.get url alertsDecoder) + + +alertsDecoder : Json.Decoder (List Alert) +alertsDecoder = + Json.list alertDecoder + -- populate alerts with ids: + |> Json.map (List.indexedMap (toString >> (|>))) + |> field "data" + + +{-| TODO: decode alert id when provided +-} +alertDecoder : Json.Decoder (String -> Alert) +alertDecoder = + Json.map6 Alert + (Json.maybe (field "annotations" (Json.keyValuePairs Json.string)) + |> andThen (Maybe.withDefault [] >> Json.succeed) + ) + (field "labels" (Json.keyValuePairs Json.string)) + (Json.maybe (Json.at [ "status", "silencedBy", "0" ] Json.string)) + (Json.maybe (Json.at [ "status", "inhibitedBy", "0" ] Json.string) + |> Json.map ((/=) Nothing) + ) + (field "startsAt" iso8601Time) + (field "generatorURL" Json.string) diff --git a/src/alertmanager/ui/app/src/Alerts/Types.elm b/src/alertmanager/ui/app/src/Alerts/Types.elm new file mode 100644 index 0000000..8c329c8 --- /dev/null +++ b/src/alertmanager/ui/app/src/Alerts/Types.elm @@ -0,0 +1,21 @@ +module Alerts.Types exposing (Alert, Receiver) + +import Utils.Types exposing (Labels) +import Time exposing (Time) + + +type alias Alert = + { annotations : Labels + , labels : Labels + , silenceId : Maybe String + , isInhibited : Bool + , startsAt : Time + , generatorUrl : String + , id : String + } + + +type alias Receiver = + { name : String + , regex : String + } diff --git a/src/alertmanager/ui/app/src/Main.elm b/src/alertmanager/ui/app/src/Main.elm new file mode 100644 index 0000000..1c140a2 --- /dev/null +++ b/src/alertmanager/ui/app/src/Main.elm @@ -0,0 +1,129 @@ +module Main exposing (main) + +import Navigation +import Parsing +import Views +import Types + exposing + ( Route(..) + , Msg + ( NavigateToSilenceList + , NavigateToSilenceView + , NavigateToSilenceFormEdit + , NavigateToSilenceFormNew + , NavigateToAlerts + , NavigateToNotFound + , NavigateToStatus + , RedirectAlerts + ) + , Model + ) +import Utils.Filter exposing (nullFilter) +import Views.SilenceForm.Types exposing (initSilenceForm) +import Views.Status.Types exposing (StatusModel, initStatusModel) +import Views.AlertList.Types exposing (initAlertList) +import Views.SilenceList.Types exposing (initSilenceList) +import Views.SilenceView.Types exposing (initSilenceView) +import Updates exposing (update) +import Utils.Api as Api +import Utils.Types exposing (ApiData(Loading)) +import Json.Decode as Json + + +main : Program Json.Value Model Msg +main = + Navigation.programWithFlags urlUpdate + { init = init + , update = update + , view = Views.view + , subscriptions = always Sub.none + } + + +init : Json.Value -> Navigation.Location -> ( Model, Cmd Msg ) +init flags location = + let + route = + Parsing.urlParser location + + filter = + case route of + AlertsRoute filter -> + filter + + SilenceListRoute filter -> + filter + + _ -> + nullFilter + + prod = + flags + |> Json.decodeValue (Json.field "production" Json.bool) + |> Result.withDefault False + + defaultCreator = + flags + |> Json.decodeValue (Json.field "defaultCreator" Json.string) + |> Result.withDefault "" + + apiUrl = + if prod then + Api.makeApiUrl location.pathname + else + Api.makeApiUrl "http://localhost:9093/" + + libUrl = + if prod then + location.pathname + else + "/" + in + update (urlUpdate location) + (Model + initSilenceList + initSilenceView + initSilenceForm + initAlertList + route + filter + initStatusModel + location.pathname + apiUrl + libUrl + Loading + Loading + defaultCreator + ) + + +urlUpdate : Navigation.Location -> Msg +urlUpdate location = + let + route = + Parsing.urlParser location + in + case route of + SilenceListRoute maybeFilter -> + NavigateToSilenceList maybeFilter + + SilenceViewRoute silenceId -> + NavigateToSilenceView silenceId + + SilenceFormEditRoute silenceId -> + NavigateToSilenceFormEdit silenceId + + SilenceFormNewRoute matchers -> + NavigateToSilenceFormNew matchers + + AlertsRoute filter -> + NavigateToAlerts filter + + StatusRoute -> + NavigateToStatus + + TopLevelRoute -> + RedirectAlerts + + NotFoundRoute -> + NavigateToNotFound diff --git a/src/alertmanager/ui/app/src/Parsing.elm b/src/alertmanager/ui/app/src/Parsing.elm new file mode 100644 index 0000000..1833b85 --- /dev/null +++ b/src/alertmanager/ui/app/src/Parsing.elm @@ -0,0 +1,59 @@ +module Parsing exposing (..) + +import Views.AlertList.Parsing exposing (alertsParser) +import Views.SilenceList.Parsing exposing (silenceListParser) +import Views.SilenceView.Parsing exposing (silenceViewParser) +import Views.SilenceForm.Parsing exposing (silenceFormNewParser, silenceFormEditParser) +import Views.Status.Parsing exposing (statusParser) +import Navigation +import UrlParser exposing ((), (), Parser, int, map, oneOf, parseHash, s, string, stringParam, top) +import Regex +import Types exposing (Route(..)) + + +urlParser : Navigation.Location -> Route +urlParser location = + let + -- Parse a query string occurring after the hash if it exists, and use + -- it for routing. + hashAndQuery = + Regex.split (Regex.AtMost 1) (Regex.regex "\\?") (location.hash) + + hash = + case List.head hashAndQuery of + Just hash -> + hash + + Nothing -> + "" + + query = + if List.length hashAndQuery == 2 then + case List.head <| List.reverse hashAndQuery of + Just query -> + "?" ++ query + + Nothing -> + "" + else + "" + in + case parseHash routeParser { location | search = query, hash = hash } of + Just route -> + route + + Nothing -> + NotFoundRoute + + +routeParser : Parser (Route -> a) a +routeParser = + oneOf + [ map SilenceListRoute silenceListParser + , map StatusRoute statusParser + , map SilenceFormNewRoute silenceFormNewParser + , map SilenceViewRoute silenceViewParser + , map SilenceFormEditRoute silenceFormEditParser + , map AlertsRoute alertsParser + , map TopLevelRoute top + ] diff --git a/src/alertmanager/ui/app/src/Silences/Api.elm b/src/alertmanager/ui/app/src/Silences/Api.elm new file mode 100644 index 0000000..c984bc1 --- /dev/null +++ b/src/alertmanager/ui/app/src/Silences/Api.elm @@ -0,0 +1,61 @@ +module Silences.Api exposing (..) + +import Http +import Silences.Types exposing (Silence) +import Utils.Types exposing (ApiData(..)) +import Utils.Filter exposing (Filter) +import Utils.Api +import Silences.Decoders exposing (show, list, create, destroy) +import Silences.Encoders +import Utils.Filter exposing (generateQueryString) + + +getSilences : String -> Filter -> (ApiData (List Silence) -> msg) -> Cmd msg +getSilences apiUrl filter msg = + let + url = + String.join "/" [ apiUrl, "silences" ++ (generateQueryString filter) ] + in + Utils.Api.send (Utils.Api.get url list) + |> Cmd.map msg + + +getSilence : String -> String -> (ApiData Silence -> msg) -> Cmd msg +getSilence apiUrl uuid msg = + let + url = + String.join "/" [ apiUrl, "silence", uuid ] + in + Utils.Api.send (Utils.Api.get url show) + |> Cmd.map msg + + +create : String -> Silence -> Cmd (ApiData String) +create apiUrl silence = + let + url = + String.join "/" [ apiUrl, "silences" ] + + body = + Http.jsonBody <| Silences.Encoders.silence silence + in + -- TODO: This should return the silence, not just the ID, so that we can + -- redirect to the silence show page. + Utils.Api.send + (Utils.Api.post url body Silences.Decoders.create) + + +destroy : String -> Silence -> (ApiData String -> msg) -> Cmd msg +destroy apiUrl silence msg = + -- The incorrect route using "silences" receives a 405. The route seems to + -- be matching on /silences and ignoring the :sid, should be getting a 404. + let + url = + String.join "/" [ apiUrl, "silence", silence.id ] + + responseDecoder = + -- Silences.Encoders.silence silence + Silences.Decoders.destroy + in + Utils.Api.send (Utils.Api.delete url responseDecoder) + |> Cmd.map msg diff --git a/src/alertmanager/ui/app/src/Silences/Decoders.elm b/src/alertmanager/ui/app/src/Silences/Decoders.elm new file mode 100644 index 0000000..7b64758 --- /dev/null +++ b/src/alertmanager/ui/app/src/Silences/Decoders.elm @@ -0,0 +1,76 @@ +module Silences.Decoders exposing (show, list, create, destroy) + +import Json.Decode as Json exposing (field, succeed, fail) +import Utils.Api exposing (iso8601Time, (|:)) +import Silences.Types exposing (Silence, Status, State(Active, Pending, Expired)) +import Utils.Types exposing (Matcher, Time, ApiData(Initial)) + + +show : Json.Decoder Silence +show = + Json.at [ "data" ] silenceDecoder + + +list : Json.Decoder (List Silence) +list = + Json.at [ "data" ] (Json.list silenceDecoder) + + +create : Json.Decoder String +create = + Json.at [ "data", "silenceId" ] Json.string + + +destroy : Json.Decoder String +destroy = + Json.at [ "status" ] Json.string + + +silenceDecoder : Json.Decoder Silence +silenceDecoder = + Json.succeed Silence + |: (field "id" Json.string) + |: (field "createdBy" Json.string) + -- Remove this maybe once the api either disallows empty comments on + -- creation, or returns an empty string. + |: ((Json.maybe (field "comment" Json.string)) + |> Json.andThen (\x -> Json.succeed <| Maybe.withDefault "" x) + ) + |: (field "startsAt" iso8601Time) + |: (field "endsAt" iso8601Time) + |: (field "updatedAt" iso8601Time) + |: (field "matchers" (Json.list matcherDecoder)) + |: (field "status" statusDecoder) + + +statusDecoder : Json.Decoder Status +statusDecoder = + Json.succeed Status + |: (field "state" Json.string |> Json.andThen stateDecoder) + + +stateDecoder : String -> Json.Decoder State +stateDecoder state = + case state of + "active" -> + succeed Active + + "pending" -> + succeed Pending + + "expired" -> + succeed Expired + + _ -> + fail <| + "Silence.status.state must be one of 'active', 'pending' or 'expired' but was'" + ++ state + ++ "'." + + +matcherDecoder : Json.Decoder Matcher +matcherDecoder = + Json.map3 Matcher + (field "isRegex" Json.bool) + (field "name" Json.string) + (field "value" Json.string) diff --git a/src/alertmanager/ui/app/src/Silences/Encoders.elm b/src/alertmanager/ui/app/src/Silences/Encoders.elm new file mode 100644 index 0000000..96666b8 --- /dev/null +++ b/src/alertmanager/ui/app/src/Silences/Encoders.elm @@ -0,0 +1,27 @@ +module Silences.Encoders exposing (..) + +import Json.Encode as Encode +import Silences.Types exposing (Silence) +import Utils.Types exposing (Matcher) +import Utils.Date + + +silence : Silence -> Encode.Value +silence silence = + Encode.object + [ ( "id", Encode.string silence.id ) + , ( "createdBy", Encode.string silence.createdBy ) + , ( "comment", Encode.string silence.comment ) + , ( "startsAt", Encode.string (Utils.Date.encode silence.startsAt) ) + , ( "endsAt", Encode.string (Utils.Date.encode silence.endsAt) ) + , ( "matchers", Encode.list (List.map matcher silence.matchers) ) + ] + + +matcher : Matcher -> Encode.Value +matcher m = + Encode.object + [ ( "name", Encode.string m.name ) + , ( "value", Encode.string m.value ) + , ( "isRegex", Encode.bool m.isRegex ) + ] diff --git a/src/alertmanager/ui/app/src/Silences/Types.elm b/src/alertmanager/ui/app/src/Silences/Types.elm new file mode 100644 index 0000000..8780847 --- /dev/null +++ b/src/alertmanager/ui/app/src/Silences/Types.elm @@ -0,0 +1,84 @@ +module Silences.Types + exposing + ( Silence + , SilenceId + , Status + , State(Active, Pending, Expired) + , nullSilence + , nullSilenceStatus + , nullMatcher + , nullTime + , stateToString + ) + +import Utils.Types exposing (Matcher) +import Time exposing (Time) + + +nullSilence : Silence +nullSilence = + { id = "" + , createdBy = "" + , comment = "" + , startsAt = 0 + , endsAt = 0 + , updatedAt = 0 + , matchers = [ nullMatcher ] + , status = nullSilenceStatus + } + + +nullSilenceStatus : Status +nullSilenceStatus = + { state = Expired + } + + +nullMatcher : Matcher +nullMatcher = + Matcher False "" "" + + +nullTime : Time +nullTime = + 0 + + +type alias Silence = + { id : SilenceId + , createdBy : String + , comment : String + , startsAt : Time + , endsAt : Time + , updatedAt : Time + , matchers : List Matcher + , status : Status + } + + +type alias Status = + { state : State + } + + +type State + = Active + | Pending + | Expired + + +stateToString : State -> String +stateToString state = + case state of + Active -> + "active" + + Pending -> + "pending" + + Expired -> + "expired" + + +type alias SilenceId = + String diff --git a/src/alertmanager/ui/app/src/Status/Api.elm b/src/alertmanager/ui/app/src/Status/Api.elm new file mode 100644 index 0000000..9d1ff2f --- /dev/null +++ b/src/alertmanager/ui/app/src/Status/Api.elm @@ -0,0 +1,58 @@ +module Status.Api exposing (getStatus) + +import Utils.Api exposing (send, get) +import Utils.Types exposing (ApiData) +import Status.Types exposing (StatusResponse, VersionInfo, ClusterStatus, ClusterPeer) +import Json.Decode exposing (Decoder, map2, string, field, at, list, int, maybe, bool) + + +getStatus : String -> (ApiData StatusResponse -> msg) -> Cmd msg +getStatus apiUrl msg = + let + url = + String.join "/" [ apiUrl, "status" ] + + request = + get url decodeStatusResponse + in + Cmd.map msg <| send request + + +decodeStatusResponse : Decoder StatusResponse +decodeStatusResponse = + field "data" decodeData + + +decodeData : Decoder StatusResponse +decodeData = + Json.Decode.map4 StatusResponse + (field "configYAML" string) + (field "uptime" string) + (field "versionInfo" decodeVersionInfo) + (field "clusterStatus" (maybe decodeClusterStatus)) + + +decodeVersionInfo : Decoder VersionInfo +decodeVersionInfo = + Json.Decode.map6 VersionInfo + (field "branch" string) + (field "buildDate" string) + (field "buildUser" string) + (field "goVersion" string) + (field "revision" string) + (field "version" string) + + +decodeClusterStatus : Decoder ClusterStatus +decodeClusterStatus = + Json.Decode.map3 ClusterStatus + (field "name" string) + (field "status" string) + (field "peers" (list decodeClusterPeer)) + + +decodeClusterPeer : Decoder ClusterPeer +decodeClusterPeer = + Json.Decode.map2 ClusterPeer + (field "name" string) + (field "address" string) diff --git a/src/alertmanager/ui/app/src/Status/Types.elm b/src/alertmanager/ui/app/src/Status/Types.elm new file mode 100644 index 0000000..b09349b --- /dev/null +++ b/src/alertmanager/ui/app/src/Status/Types.elm @@ -0,0 +1,32 @@ +module Status.Types exposing (StatusResponse, VersionInfo, ClusterStatus, ClusterPeer) + + +type alias StatusResponse = + { config : String + , uptime : String + , versionInfo : VersionInfo + , clusterStatus : Maybe ClusterStatus + } + + +type alias VersionInfo = + { branch : String + , buildDate : String + , buildUser : String + , goVersion : String + , revision : String + , version : String + } + + +type alias ClusterStatus = + { name : String + , status : String + , peers : List ClusterPeer + } + + +type alias ClusterPeer = + { name : String + , address : String + } diff --git a/src/alertmanager/ui/app/src/Types.elm b/src/alertmanager/ui/app/src/Types.elm new file mode 100644 index 0000000..cb4169c --- /dev/null +++ b/src/alertmanager/ui/app/src/Types.elm @@ -0,0 +1,58 @@ +module Types exposing (Model, Msg(..), Route(..)) + +import Views.AlertList.Types as AlertList exposing (AlertListMsg) +import Views.SilenceList.Types as SilenceList exposing (SilenceListMsg) +import Views.SilenceView.Types as SilenceView exposing (SilenceViewMsg) +import Views.SilenceForm.Types as SilenceForm exposing (SilenceFormMsg) +import Views.Status.Types exposing (StatusModel, StatusMsg) +import Utils.Filter exposing (Filter, Matcher) +import Utils.Types exposing (ApiData) + + +type alias Model = + { silenceList : SilenceList.Model + , silenceView : SilenceView.Model + , silenceForm : SilenceForm.Model + , alertList : AlertList.Model + , route : Route + , filter : Filter + , status : StatusModel + , basePath : String + , apiUrl : String + , libUrl : String + , bootstrapCSS : ApiData String + , fontAwesomeCSS : ApiData String + , defaultCreator : String + } + + +type Msg + = MsgForAlertList AlertListMsg + | MsgForSilenceView SilenceViewMsg + | MsgForSilenceForm SilenceFormMsg + | MsgForSilenceList SilenceListMsg + | MsgForStatus StatusMsg + | NavigateToAlerts Filter + | NavigateToNotFound + | NavigateToSilenceView String + | NavigateToSilenceFormEdit String + | NavigateToSilenceFormNew (List Matcher) + | NavigateToSilenceList Filter + | NavigateToStatus + | Noop + | RedirectAlerts + | UpdateFilter String + | BootstrapCSSLoaded (ApiData String) + | FontAwesomeCSSLoaded (ApiData String) + | SetDefaultCreator String + + +type Route + = AlertsRoute Filter + | NotFoundRoute + | SilenceFormEditRoute String + | SilenceFormNewRoute (List Matcher) + | SilenceListRoute Filter + | SilenceViewRoute String + | StatusRoute + | TopLevelRoute diff --git a/src/alertmanager/ui/app/src/Updates.elm b/src/alertmanager/ui/app/src/Updates.elm new file mode 100644 index 0000000..982a805 --- /dev/null +++ b/src/alertmanager/ui/app/src/Updates.elm @@ -0,0 +1,123 @@ +module Updates exposing (update) + +import Navigation +import String exposing (trim) +import Task +import Types + exposing + ( Model + , Msg(..) + , Route(AlertsRoute, NotFoundRoute, SilenceFormEditRoute, SilenceFormNewRoute, SilenceListRoute, SilenceViewRoute, StatusRoute) + ) +import Views.AlertList.Types exposing (AlertListMsg(FetchAlerts)) +import Views.AlertList.Updates +import Views.SilenceForm.Types exposing (SilenceFormMsg(FetchSilence, NewSilenceFromMatchers)) +import Views.SilenceForm.Updates +import Views.SilenceList.Types exposing (SilenceListMsg(FetchSilences)) +import Views.SilenceList.Updates +import Views.SilenceView.Types exposing (SilenceViewMsg(InitSilenceView, SilenceFetched)) +import Views.SilenceView.Updates +import Views.Status.Types exposing (StatusMsg(InitStatusView)) +import Views.Status.Updates + + +update : Msg -> Model -> ( Model, Cmd Msg ) +update msg ({ basePath, apiUrl } as model) = + case msg of + NavigateToAlerts filter -> + let + ( alertList, cmd ) = + Views.AlertList.Updates.update FetchAlerts model.alertList filter apiUrl basePath + in + ( { model | alertList = alertList, route = AlertsRoute filter, filter = filter }, cmd ) + + NavigateToSilenceList filter -> + let + ( silenceList, cmd ) = + Views.SilenceList.Updates.update FetchSilences model.silenceList filter basePath apiUrl + in + ( { model | silenceList = silenceList, route = SilenceListRoute filter, filter = filter } + , Cmd.map MsgForSilenceList cmd + ) + + NavigateToStatus -> + ( { model | route = StatusRoute }, Task.perform identity (Task.succeed <| MsgForStatus InitStatusView) ) + + NavigateToSilenceView silenceId -> + let + ( silenceView, cmd ) = + Views.SilenceView.Updates.update (InitSilenceView silenceId) model.silenceView apiUrl + in + ( { model | route = SilenceViewRoute silenceId, silenceView = silenceView } + , Cmd.map MsgForSilenceView cmd + ) + + NavigateToSilenceFormNew matchers -> + ( { model | route = SilenceFormNewRoute matchers } + , Task.perform (NewSilenceFromMatchers model.defaultCreator >> MsgForSilenceForm) (Task.succeed matchers) + ) + + NavigateToSilenceFormEdit uuid -> + ( { model | route = SilenceFormEditRoute uuid }, Task.perform identity (Task.succeed <| (FetchSilence uuid |> MsgForSilenceForm)) ) + + NavigateToNotFound -> + ( { model | route = NotFoundRoute }, Cmd.none ) + + RedirectAlerts -> + ( model, Navigation.newUrl (basePath ++ "#/alerts") ) + + UpdateFilter text -> + let + t = + if trim text == "" then + Nothing + else + Just text + + prevFilter = + model.filter + in + ( { model | filter = { prevFilter | text = t } }, Cmd.none ) + + Noop -> + ( model, Cmd.none ) + + MsgForStatus msg -> + Views.Status.Updates.update msg model apiUrl + + MsgForAlertList msg -> + let + ( alertList, cmd ) = + Views.AlertList.Updates.update msg model.alertList model.filter apiUrl basePath + in + ( { model | alertList = alertList }, cmd ) + + MsgForSilenceList msg -> + let + ( silenceList, cmd ) = + Views.SilenceList.Updates.update msg model.silenceList model.filter basePath apiUrl + in + ( { model | silenceList = silenceList }, Cmd.map MsgForSilenceList cmd ) + + MsgForSilenceView msg -> + let + ( silenceView, cmd ) = + Views.SilenceView.Updates.update msg model.silenceView apiUrl + in + ( { model | silenceView = silenceView }, Cmd.map MsgForSilenceView cmd ) + + MsgForSilenceForm msg -> + let + ( silenceForm, cmd ) = + Views.SilenceForm.Updates.update msg model.silenceForm basePath apiUrl + in + ( { model | silenceForm = silenceForm }, cmd ) + + BootstrapCSSLoaded css -> + ( { model | bootstrapCSS = css }, Cmd.none ) + + FontAwesomeCSSLoaded css -> + ( { model | fontAwesomeCSS = css }, Cmd.none ) + + SetDefaultCreator name -> + ( { model | defaultCreator = name }, Cmd.none ) diff --git a/src/alertmanager/ui/app/src/Utils/Api.elm b/src/alertmanager/ui/app/src/Utils/Api.elm new file mode 100644 index 0000000..cb47434 --- /dev/null +++ b/src/alertmanager/ui/app/src/Utils/Api.elm @@ -0,0 +1,139 @@ +module Utils.Api exposing (..) + +import Http exposing (Error(..)) +import Json.Decode as Json exposing (field) +import Time exposing (Time) +import Utils.Date +import Utils.Types exposing (ApiData(..)) + + +map : (a -> b) -> ApiData a -> ApiData b +map fn response = + case response of + Success value -> + Success (fn value) + + Initial -> + Initial + + Loading -> + Loading + + Failure a -> + Failure a + + +withDefault : a -> ApiData a -> a +withDefault default response = + case response of + Success value -> + value + + _ -> + default + + +parseError : String -> Maybe String +parseError = + Json.decodeString (field "error" Json.string) >> Result.toMaybe + + +errorToString : Http.Error -> String +errorToString err = + case err of + Timeout -> + "Timeout exceeded" + + NetworkError -> + "Network error" + + BadStatus resp -> + parseError resp.body + |> Maybe.withDefault (toString resp.status.code ++ " " ++ resp.status.message) + + BadPayload err resp -> + -- OK status, unexpected payload + "Unexpected response from api: " ++ err + + BadUrl url -> + "Malformed url: " ++ url + + +fromResult : Result Http.Error a -> ApiData a +fromResult result = + case result of + Err e -> + Failure (errorToString e) + + Ok x -> + Success x + + +send : Http.Request a -> Cmd (ApiData a) +send = + Http.send fromResult + + +get : String -> Json.Decoder a -> Http.Request a +get url decoder = + request "GET" [] url Http.emptyBody decoder + + +post : String -> Http.Body -> Json.Decoder a -> Http.Request a +post url body decoder = + request "POST" [] url body decoder + + +delete : String -> Json.Decoder a -> Http.Request a +delete url decoder = + request "DELETE" [] url Http.emptyBody decoder + + +request : String -> List Http.Header -> String -> Http.Body -> Json.Decoder a -> Http.Request a +request method headers url body decoder = + Http.request + { method = method + , headers = headers + , url = url + , body = body + , expect = Http.expectJson decoder + , timeout = Nothing + , withCredentials = False + } + + +iso8601Time : Json.Decoder Time +iso8601Time = + Json.andThen + (\strTime -> + case Utils.Date.timeFromString strTime of + Ok time -> + Json.succeed time + + Err err -> + Json.fail ("Could not decode time " ++ strTime ++ ": " ++ err) + ) + Json.string + + +makeApiUrl : String -> String +makeApiUrl externalUrl = + let + url = + if String.endsWith "/" externalUrl then + String.dropRight 1 externalUrl + else + externalUrl + in + url ++ "/api/v1" + + +defaultTimeout : Time.Time +defaultTimeout = + 1000 * Time.millisecond + + +(|:) : Json.Decoder (a -> b) -> Json.Decoder a -> Json.Decoder b +(|:) = + -- Taken from elm-community/json-extra + flip (Json.map2 (|>)) diff --git a/src/alertmanager/ui/app/src/Utils/Date.elm b/src/alertmanager/ui/app/src/Utils/Date.elm new file mode 100644 index 0000000..ac9f1e0 --- /dev/null +++ b/src/alertmanager/ui/app/src/Utils/Date.elm @@ -0,0 +1,106 @@ +module Utils.Date exposing (..) + +import ISO8601 +import Parser exposing (Parser, (|.), (|=)) +import Time +import Utils.Types as Types +import Tuple +import Date +import Date.Extra.Format +import Date.Extra.Config.Config_en_us exposing (config) + + +parseDuration : String -> Result String Time.Time +parseDuration = + Parser.run durationParser >> Result.mapError (always "Wrong duration format") + + +durationParser : Parser Time.Time +durationParser = + Parser.succeed (List.foldr (+) 0) + |= Parser.repeat Parser.zeroOrMore term + |. Parser.end + + +units : List ( String, number ) +units = + [ ( "y", 31556926000 ) + , ( "d", 86400000 ) + , ( "h", 3600000 ) + , ( "m", 60000 ) + , ( "s", 1000 ) + ] + + +timeToString : Time.Time -> String +timeToString = + round >> ISO8601.fromTime >> ISO8601.toString + + +term : Parser Time.Time +term = + Parser.map2 (*) + Parser.float + (units + |> List.map (\( unit, ms ) -> Parser.succeed ms |. Parser.symbol unit) + |> Parser.oneOf + ) + |. Parser.ignore Parser.zeroOrMore ((==) ' ') + + +durationFormat : Time.Time -> Maybe String +durationFormat time = + if time >= 0 then + List.foldl + (\( unit, ms ) ( result, curr ) -> + ( if curr // ms == 0 then + result + else + result ++ toString (curr // ms) ++ unit ++ " " + , curr % ms + ) + ) + ( "", round time ) + units + |> Tuple.first + |> String.trim + |> Just + else + Nothing + + +dateFormat : Time.Time -> String +dateFormat = + Date.fromTime >> (Date.Extra.Format.formatUtc config Date.Extra.Format.isoDateFormat) + + +timeFormat : Time.Time -> String +timeFormat = + Date.fromTime >> (Date.Extra.Format.formatUtc config Date.Extra.Format.isoTimeFormat) + + +dateTimeFormat : Time.Time -> String +dateTimeFormat t = + (dateFormat t) ++ " " ++ (timeFormat t) + + +encode : Time.Time -> String +encode = + round >> ISO8601.fromTime >> ISO8601.toString + + +timeFromString : String -> Result String Time.Time +timeFromString string = + if string == "" then + Err "Should not be empty" + else + ISO8601.fromString string + |> Result.map (ISO8601.toTime >> toFloat) + |> Result.mapError (always "Wrong ISO8601 format") + + +fromTime : Time.Time -> Types.Time +fromTime time = + { s = round time |> ISO8601.fromTime |> ISO8601.toString + , t = Just time + } diff --git a/src/alertmanager/ui/app/src/Utils/Filter.elm b/src/alertmanager/ui/app/src/Utils/Filter.elm new file mode 100644 index 0000000..ac2f04c --- /dev/null +++ b/src/alertmanager/ui/app/src/Utils/Filter.elm @@ -0,0 +1,229 @@ +module Utils.Filter + exposing + ( Matcher + , MatchOperator(..) + , Filter + , nullFilter + , generateQueryParam + , generateQueryString + , stringifyMatcher + , stringifyFilter + , stringifyGroup + , parseGroup + , parseFilter + , parseMatcher + ) + +import Http exposing (encodeUri) +import Parser exposing (Parser, (|.), (|=), zeroOrMore, ignore) +import Parser.LanguageKit as Parser exposing (Trailing(..)) +import Char +import Set + + +type alias Filter = + { text : Maybe String + , group : Maybe String + , receiver : Maybe String + , showSilenced : Maybe Bool + , showInhibited : Maybe Bool + } + + +nullFilter : Filter +nullFilter = + { text = Nothing + , group = Nothing + , receiver = Nothing + , showSilenced = Nothing + , showInhibited = Nothing + } + + +generateQueryParam : String -> Maybe String -> Maybe String +generateQueryParam name = + Maybe.map (encodeUri >> (++) (name ++ "=")) + + +generateQueryString : Filter -> String +generateQueryString { receiver, showSilenced, showInhibited, text, group } = + let + parts = + [ ( "silenced", Maybe.withDefault False showSilenced |> toString |> String.toLower |> Just ) + , ( "inhibited", Maybe.withDefault False showInhibited |> toString |> String.toLower |> Just ) + , ( "filter", emptyToNothing text ) + , ( "receiver", emptyToNothing receiver ) + , ( "group", group ) + ] + |> List.filterMap (uncurry generateQueryParam) + in + if List.length parts > 0 then + parts + |> String.join "&" + |> (++) "?" + else + "" + + +emptyToNothing : Maybe String -> Maybe String +emptyToNothing str = + case str of + Just "" -> + Nothing + + _ -> + str + + +type alias Matcher = + { key : String + , op : MatchOperator + , value : String + } + + +type MatchOperator + = Eq + | NotEq + | RegexMatch + | NotRegexMatch + + +matchers : List ( String, MatchOperator ) +matchers = + [ ( "=~", RegexMatch ) + , ( "!~", NotRegexMatch ) + , ( "=", Eq ) + , ( "!=", NotEq ) + ] + + +parseFilter : String -> Maybe (List Matcher) +parseFilter = + Parser.run filter + >> Result.toMaybe + + +parseMatcher : String -> Maybe Matcher +parseMatcher = + Parser.run matcher + >> Result.toMaybe + + +stringifyGroup : List String -> Maybe String +stringifyGroup list = + if List.isEmpty list then + Just "" + else if list == [ "alertname" ] then + Nothing + else + Just (String.join "," list) + + +parseGroup : Maybe String -> List String +parseGroup maybeGroup = + case maybeGroup of + Nothing -> + [ "alertname" ] + + Just something -> + String.split "," something + |> List.filter (String.length >> (<) 0) + + +stringifyFilter : List Matcher -> String +stringifyFilter matchers = + case matchers of + [] -> + "" + + list -> + (list + |> List.map stringifyMatcher + |> String.join ", " + |> (++) "{" + ) + ++ "}" + + +stringifyMatcher : Matcher -> String +stringifyMatcher { key, op, value } = + key + ++ (matchers + |> List.filter (Tuple.second >> (==) op) + |> List.head + |> Maybe.map Tuple.first + |> Maybe.withDefault "" + ) + ++ "\"" + ++ value + ++ "\"" + + +filter : Parser (List Matcher) +filter = + Parser.succeed identity + |= Parser.record spaces item + |. Parser.end + + +matcher : Parser Matcher +matcher = + Parser.succeed identity + |. spaces + |= item + |. spaces + |. Parser.end + + +item : Parser Matcher +item = + Parser.succeed Matcher + |= Parser.variable isVarChar isVarChar Set.empty + |= (matchers + |> List.map + (\( keyword, matcher ) -> + Parser.succeed matcher + |. Parser.keyword keyword + ) + |> Parser.oneOf + ) + |= string '"' + + +spaces : Parser () +spaces = + ignore zeroOrMore (\char -> char == ' ' || char == '\t') + + +string : Char -> Parser String +string separator = + Parser.succeed identity + |. Parser.symbol (String.fromChar separator) + |= stringContents separator + |. Parser.symbol (String.fromChar separator) + + +stringContents : Char -> Parser String +stringContents separator = + Parser.oneOf + [ Parser.succeed (++) + |= keepOne (\char -> char == '\\') + |= keepOne (\char -> True) + , Parser.keep Parser.oneOrMore (\char -> char /= separator && char /= '\\') + ] + |> Parser.repeat Parser.zeroOrMore + |> Parser.map (String.join "") + + +isVarChar : Char -> Bool +isVarChar char = + Char.isLower char + || Char.isUpper char + || (char == '_') + || Char.isDigit char + + +keepOne : (Char -> Bool) -> Parser String +keepOne = + Parser.keep (Parser.Exactly 1) diff --git a/src/alertmanager/ui/app/src/Utils/FormValidation.elm b/src/alertmanager/ui/app/src/Utils/FormValidation.elm new file mode 100644 index 0000000..c4643b9 --- /dev/null +++ b/src/alertmanager/ui/app/src/Utils/FormValidation.elm @@ -0,0 +1,57 @@ +module Utils.FormValidation + exposing + ( initialField + , ValidationState(..) + , ValidatedField + , validate + , fromResult + , stringNotEmpty + , updateValue + ) + + +type ValidationState + = Initial + | Valid + | Invalid String + + +fromResult : Result String a -> ValidationState +fromResult result = + case result of + Ok _ -> + Valid + + Err str -> + Invalid str + + +type alias ValidatedField = + { value : String + , validationState : ValidationState + } + + +initialField : String -> ValidatedField +initialField value = + { value = value + , validationState = Initial + } + + +updateValue : String -> ValidatedField -> ValidatedField +updateValue value field = + { field | value = value, validationState = Initial } + + +validate : (String -> Result String a) -> ValidatedField -> ValidatedField +validate validator field = + { field | validationState = fromResult (validator field.value) } + + +stringNotEmpty : String -> Result String String +stringNotEmpty string = + if String.isEmpty (String.trim string) then + Err "Should not be empty" + else + Ok string diff --git a/src/alertmanager/ui/app/src/Utils/Keyboard.elm b/src/alertmanager/ui/app/src/Utils/Keyboard.elm new file mode 100644 index 0000000..789755a --- /dev/null +++ b/src/alertmanager/ui/app/src/Utils/Keyboard.elm @@ -0,0 +1,29 @@ +module Utils.Keyboard exposing (keys, onKeyDown, onKeyUp) + +import Html exposing (Attribute) +import Html.Events exposing (on, keyCode) +import Json.Decode as Json + + +keys : + { backspace : Int + , enter : Int + , up : Int + , down : Int + } +keys = + { backspace = 8 + , enter = 13 + , up = 38 + , down = 40 + } + + +onKeyDown : (Int -> msg) -> Attribute msg +onKeyDown tagger = + on "keydown" (Json.map tagger keyCode) + + +onKeyUp : (Int -> msg) -> Attribute msg +onKeyUp tagger = + on "keyup" (Json.map tagger keyCode) diff --git a/src/alertmanager/ui/app/src/Utils/List.elm b/src/alertmanager/ui/app/src/Utils/List.elm new file mode 100644 index 0000000..71b0bc5 --- /dev/null +++ b/src/alertmanager/ui/app/src/Utils/List.elm @@ -0,0 +1,88 @@ +module Utils.List exposing (..) + +import Utils.Types exposing (Matchers, Matcher) +import Dict exposing (Dict) + + +nextElem : a -> List a -> Maybe a +nextElem el list = + case list of + curr :: rest -> + if curr == el then + List.head rest + else + nextElem el rest + + [] -> + Nothing + + +lastElem : List a -> Maybe a +lastElem = + List.foldl (Just >> always) Nothing + + +replaceIf : (a -> Bool) -> a -> List a -> List a +replaceIf predicate replacement list = + List.map + (\item -> + if predicate item then + replacement + else + item + ) + list + + +replaceIndex : Int -> (a -> a) -> List a -> List a +replaceIndex index replacement list = + List.indexedMap + (\currentIndex item -> + if index == currentIndex then + replacement item + else + item + ) + list + + +mjoin : Matchers -> String +mjoin m = + String.join "," (List.map mstring m) + + +mstring : Matcher -> String +mstring m = + let + sep = + if m.isRegex then + "=~" + else + "=" + in + String.join sep [ m.name, toString m.value ] + + +{-| Takes a key-fn and a list. +Creates a `Dict` which maps the key to a list of matching elements. +mary = {id=1, name="Mary"} +jack = {id=2, name="Jack"} +jill = {id=1, name="Jill"} +groupBy .id [mary, jack, jill] == Dict.fromList [(1, [mary, jill]), (2, [jack])] + +Copied from + +-} +groupBy : (a -> comparable) -> List a -> Dict comparable (List a) +groupBy keyfn list = + List.foldr + (\x acc -> + Dict.update (keyfn x) (Maybe.map ((::) x) >> Maybe.withDefault [ x ] >> Just) acc + ) + Dict.empty + list + + +zip : List a -> List b -> List ( a, b ) +zip a b = + List.map2 (,) a b diff --git a/src/alertmanager/ui/app/src/Utils/Match.elm b/src/alertmanager/ui/app/src/Utils/Match.elm new file mode 100644 index 0000000..135aef4 --- /dev/null +++ b/src/alertmanager/ui/app/src/Utils/Match.elm @@ -0,0 +1,138 @@ +module Utils.Match exposing (jaro, jaroWinkler, consecutiveChars) + +import Utils.List exposing (zip) +import Char + + +{-| + + Adapted from https://blog.art-of-coding.eu/comparing-strings-with-metrics-in-haskell/ +-} +jaro : String -> String -> Float +jaro s1 s2 = + if s1 == s2 then + 1.0 + else + let + l1 = + String.length s1 + + l2 = + String.length s2 + + z2 = + zip (List.range 1 l2) (String.toList s2) + |> List.map (Tuple.mapSecond Char.toCode) + + searchLength = + -- A character must be within searchLength spaces of the + -- character we are matching against in order to be considered + -- a match. + -- (//) is integer division, which removes the need to floor + -- the result. + ((max l1 l2) // 2) - 1 + + m = + zip (List.range 1 l1) (String.toList s1) + |> List.map (Tuple.mapSecond Char.toCode) + |> List.concatMap (charMatch searchLength z2) + + ml = + List.length m + + t = + m + |> List.map (transposition z2 >> toFloat >> ((*) 0.5)) + |> List.sum + + ml1 = + toFloat ml / toFloat l1 + + ml2 = + toFloat ml / toFloat l2 + + mtm = + (toFloat ml - t) / toFloat ml + in + if ml == 0 then + 0 + else + (1 / 3) * (ml1 + ml2 + mtm) + + +winkler : String -> String -> Float -> Float +winkler s1 s2 jaro = + if s1 == "" || s2 == "" then + 0.0 + else if s1 == s2 then + 1.0 + else + let + l = + consecutiveChars s1 s2 + |> String.length + |> toFloat + + p = + 0.25 + in + jaro + ((l * p) * (1.0 - jaro)) + + +jaroWinkler : String -> String -> Float +jaroWinkler s1 s2 = + if s1 == "" || s2 == "" then + 0.0 + else if s1 == s2 then + 1.0 + else + jaro s1 s2 + |> winkler s1 s2 + + +consecutiveChars : String -> String -> String +consecutiveChars s1 s2 = + if s1 == "" || s2 == "" then + "" + else if s1 == s2 then + s1 + else + cp (String.toList s1) (String.toList s2) [] + |> String.fromList + + +cp : List Char -> List Char -> List Char -> List Char +cp l1 l2 acc = + case ( l1, l2 ) of + ( x :: xs, y :: ys ) -> + if x == y then + cp xs ys (acc ++ [ x ]) + else if List.length acc > 0 then + -- If we have already found matches, we bail. We only want + -- consecutive matches. + acc + else + -- Go through every character in l1 until it matches the first + -- character in l2, and then start counting from there. + cp l1 ys acc + + _ -> + acc + + +charMatch : number -> List ( number, number ) -> ( number, number ) -> List ( number, number ) +charMatch matchRange list ( p, q ) = + list + |> List.drop (p - matchRange - 1) + |> List.take (p + matchRange) + |> List.filter (Tuple.second >> (==) q) + + +transposition : List ( number, number ) -> ( number, number ) -> Int +transposition list ( p, q ) = + list + |> List.filter + (\( x, y ) -> + p /= x && q == y + ) + |> List.length diff --git a/src/alertmanager/ui/app/src/Utils/String.elm b/src/alertmanager/ui/app/src/Utils/String.elm new file mode 100644 index 0000000..0e65a6f --- /dev/null +++ b/src/alertmanager/ui/app/src/Utils/String.elm @@ -0,0 +1,57 @@ +module Utils.String exposing (capitalizeFirst, linkify) + +import String +import Char + + +capitalizeFirst : String -> String +capitalizeFirst string = + case String.uncons string of + Nothing -> + string + + Just ( char, rest ) -> + String.cons (Char.toUpper char) rest + + +linkify : String -> List (Result String String) +linkify string = + List.reverse (linkifyHelp (String.words string) []) + + +linkifyHelp : List String -> List (Result String String) -> List (Result String String) +linkifyHelp words linkified = + case words of + [] -> + linkified + + word :: restWords -> + if isUrl word then + case linkified of + (Err lastWord) :: restLinkified -> + -- append space to last word + linkifyHelp restWords (Ok word :: Err (lastWord ++ " ") :: restLinkified) + + (Ok lastWord) :: restLinkified -> + -- insert space between two links + linkifyHelp restWords (Ok word :: Err " " :: linkified) + + _ -> + linkifyHelp restWords (Ok word :: linkified) + else + case linkified of + (Err lastWord) :: restLinkified -> + -- concatenate with last word + linkifyHelp restWords (Err (lastWord ++ " " ++ word) :: restLinkified) + + (Ok lastWord) :: restLinkified -> + -- insert space after the link + linkifyHelp restWords (Err (" " ++ word) :: linkified) + + _ -> + linkifyHelp restWords (Err word :: linkified) + + +isUrl : String -> Bool +isUrl = + flip String.startsWith >> (flip List.any) [ "http://", "https://" ] diff --git a/src/alertmanager/ui/app/src/Utils/Types.elm b/src/alertmanager/ui/app/src/Utils/Types.elm new file mode 100644 index 0000000..8277467 --- /dev/null +++ b/src/alertmanager/ui/app/src/Utils/Types.elm @@ -0,0 +1,41 @@ +module Utils.Types exposing (..) + +import Time + + +type ApiData a + = Initial + | Loading + | Failure String + | Success a + + +type alias Matcher = + { isRegex : Bool + , name : String + , value : String + } + + +type alias Matchers = + List Matcher + + +type alias Labels = + List Label + + +type alias Label = + ( String, String ) + + +type alias Time = + { t : Maybe Time.Time + , s : String + } + + +type alias Duration = + { d : Maybe Time.Time + , s : String + } diff --git a/src/alertmanager/ui/app/src/Utils/Views.elm b/src/alertmanager/ui/app/src/Utils/Views.elm new file mode 100644 index 0000000..591481f --- /dev/null +++ b/src/alertmanager/ui/app/src/Utils/Views.elm @@ -0,0 +1,151 @@ +module Utils.Views exposing (..) + +import Html exposing (..) +import Html.Attributes exposing (..) +import Html.Events exposing (onCheck, onInput, onClick, onBlur) +import Utils.FormValidation exposing (ValidationState(..), ValidatedField) +import Utils.String + + +tab : tab -> tab -> (tab -> msg) -> List (Html msg) -> Html msg +tab tab currentTab msg content = + li [ class "nav-item" ] + [ if tab == currentTab then + span [ class "nav-link active" ] content + else + a [ class "nav-link", onClick (msg tab) ] content + ] + + +labelButton : Maybe msg -> String -> Html msg +labelButton maybeMsg labelText = + case maybeMsg of + Nothing -> + span + [ class "btn btn-sm bg-faded btn-secondary mr-2 mb-2" + , style + [ ( "user-select", "text" ) + , ( "-moz-user-select", "text" ) + , ( "-webkit-user-select", "text" ) + ] + ] + [ text labelText ] + + Just msg -> + button + [ class "btn btn-sm bg-faded btn-secondary mr-2 mb-2" + , onClick msg + ] + [ span [ class "text-muted" ] [ text labelText ] ] + + +linkifyText : String -> List (Html msg) +linkifyText str = + List.map + (\result -> + case result of + Ok link -> + a [ href link, target "_blank" ] [ text link ] + + Err txt -> + text txt + ) + (Utils.String.linkify str) + + +iconButtonMsg : String -> String -> msg -> Html msg +iconButtonMsg classString icon msg = + a [ class classString, onClick msg ] + [ i [ class <| "fa fa-3 " ++ icon ] [] + ] + + +checkbox : String -> Bool -> (Bool -> msg) -> Html msg +checkbox name status msg = + label [ class "f6 dib mb2 mr2 d-flex align-items-center" ] + [ input [ type_ "checkbox", checked status, onCheck msg ] [] + , span [ class "pl-2" ] [ text <| " " ++ name ] + ] + + +validatedField : (List (Attribute msg) -> List (Html msg) -> Html msg) -> String -> String -> (String -> msg) -> msg -> ValidatedField -> Html msg +validatedField htmlField labelText classes inputMsg blurMsg field = + case field.validationState of + Valid -> + div [ class <| "d-flex flex-column form-group has-success " ++ classes ] + [ label [] [ strong [] [ text labelText ] ] + , htmlField + [ value field.value + , onInput inputMsg + , onBlur blurMsg + , class "form-control form-control-success" + ] + [] + ] + + Initial -> + div [ class <| "d-flex flex-column form-group " ++ classes ] + [ label [] [ strong [] [ text labelText ] ] + , htmlField + [ value field.value + , onInput inputMsg + , onBlur blurMsg + , class "form-control" + ] + [] + ] + + Invalid error -> + div [ class <| "d-flex flex-column form-group has-danger " ++ classes ] + [ label [] [ strong [] [ text labelText ] ] + , htmlField + [ value field.value + , onInput inputMsg + , onBlur blurMsg + , class "form-control form-control-danger" + ] + [] + , div [ class "form-control-feedback" ] [ text error ] + ] + + +formField : String -> String -> String -> (String -> msg) -> Html msg +formField labelText content classes msg = + div [ class <| "d-flex flex-column " ++ classes ] + [ label [] [ strong [] [ text labelText ] ] + , input [ value content, onInput msg ] [] + ] + + +textField : String -> String -> String -> (String -> msg) -> Html msg +textField labelText content classes msg = + div [ class <| "d-flex flex-column " ++ classes ] + [ label [] [ strong [] [ text labelText ] ] + , textarea [ value content, onInput msg ] [] + ] + + +buttonLink : String -> String -> String -> msg -> Html msg +buttonLink icon link color msg = + a [ class <| "" ++ color, href link, onClick msg ] + [ i [ class <| "" ++ icon ] [] + ] + + +formInput : String -> String -> (String -> msg) -> Html msg +formInput inputValue classes msg = + Html.input [ class <| "w-100 " ++ classes, value inputValue, onInput msg ] [] + + +loading : Html msg +loading = + div [] + [ i [ class "fa fa-cog fa-spin fa-3x fa-fw" ] [] + , span [ class "sr-only" ] [ text "Loading..." ] + ] + + +error : String -> Html msg +error err = + div [ class "alert alert-warning" ] + [ text (Utils.String.capitalizeFirst err) ] diff --git a/src/alertmanager/ui/app/src/Views.elm b/src/alertmanager/ui/app/src/Views.elm new file mode 100644 index 0000000..be9f653 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views.elm @@ -0,0 +1,94 @@ +module Views exposing (..) + +import Html exposing (Html, node, text, div) +import Html.Attributes exposing (class, rel, href, src, style) +import Html.Events exposing (on) +import Json.Decode exposing (succeed) +import Types exposing (Msg(MsgForSilenceForm, MsgForSilenceView, BootstrapCSSLoaded, FontAwesomeCSSLoaded), Model, Route(..)) +import Utils.Views exposing (error, loading) +import Utils.Types exposing (ApiData(Failure, Success)) +import Views.SilenceList.Views as SilenceList +import Views.SilenceForm.Views as SilenceForm +import Views.AlertList.Views as AlertList +import Views.SilenceView.Views as SilenceView +import Views.NotFound.Views as NotFound +import Views.Status.Views as Status +import Views.NavBar.Views exposing (navBar) + + +view : Model -> Html Msg +view model = + div [] + [ renderCSS model.libUrl + , case ( model.bootstrapCSS, model.fontAwesomeCSS ) of + ( Success _, Success _ ) -> + div [] + [ navBar model.route + , div [ class "container pb-4" ] [ currentView model ] + ] + + ( Failure err, _ ) -> + failureView model err + + ( _, Failure err ) -> + failureView model err + + _ -> + text "" + ] + + +failureView : Model -> String -> Html Msg +failureView model err = + div [] + [ div [ style [ ( "padding", "40px" ), ( "color", "red" ) ] ] [ text err ] + , navBar model.route + , div [ class "container pb-4" ] [ currentView model ] + ] + + +renderCSS : String -> Html Msg +renderCSS assetsUrl = + div [] + [ cssNode (assetsUrl ++ "lib/bootstrap-4.0.0-alpha.6-dist/css/bootstrap.min.css") BootstrapCSSLoaded + , cssNode (assetsUrl ++ "lib/font-awesome-4.7.0/css/font-awesome.min.css") FontAwesomeCSSLoaded + ] + + +cssNode : String -> (ApiData String -> Msg) -> Html Msg +cssNode url msg = + node "link" + [ href url + , rel "stylesheet" + , on "load" (succeed (msg (Success url))) + , on "error" (succeed (msg (Failure ("Failed to load CSS from: " ++ url)))) + ] + [] + + +currentView : Model -> Html Msg +currentView model = + case model.route of + StatusRoute -> + Status.view model.status + + SilenceViewRoute silenceId -> + SilenceView.view model.silenceView + + AlertsRoute filter -> + AlertList.view model.alertList filter + + SilenceListRoute _ -> + SilenceList.view model.silenceList + + SilenceFormNewRoute matchers -> + SilenceForm.view Nothing matchers model.defaultCreator model.silenceForm |> Html.map MsgForSilenceForm + + SilenceFormEditRoute silenceId -> + SilenceForm.view (Just silenceId) [] "" model.silenceForm |> Html.map MsgForSilenceForm + + TopLevelRoute -> + Utils.Views.loading + + NotFoundRoute -> + NotFound.view diff --git a/src/alertmanager/ui/app/src/Views/AlertList/AlertView.elm b/src/alertmanager/ui/app/src/Views/AlertList/AlertView.elm new file mode 100644 index 0000000..ca64c51 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/AlertList/AlertView.elm @@ -0,0 +1,158 @@ +module Views.AlertList.AlertView exposing (view, addLabelMsg) + +import Alerts.Types exposing (Alert) +import Html exposing (..) +import Html.Attributes exposing (class, style, href, value, readonly, title) +import Html.Events exposing (onClick) +import Types exposing (Msg(Noop, MsgForAlertList)) +import Utils.Date +import Views.FilterBar.Types as FilterBarTypes +import Views.AlertList.Types exposing (AlertListMsg(MsgForFilterBar, SetActive)) +import Utils.Views +import Utils.Filter +import Views.SilenceForm.Parsing exposing (newSilenceFromAlertLabels) + + +view : List ( String, String ) -> Maybe String -> Alert -> Html Msg +view labels maybeActiveId alert = + let + -- remove the grouping labels, and bring the alertname to front + ungroupedLabels = + alert.labels + |> List.filter ((flip List.member) labels >> not) + |> List.partition (Tuple.first >> (==) "alertname") + |> uncurry (++) + in + li + [ -- speedup rendering in Chrome, because list-group-item className + -- creates a new layer in the rendering engine + style [ ( "position", "static" ) ] + , class "align-items-start list-group-item border-0 p-0 mb-4" + ] + [ div + [ class "w-100 mb-2 d-flex align-items-start" ] + [ titleView alert + , if List.length alert.annotations > 0 then + annotationsButton maybeActiveId alert + else + text "" + , generatorUrlButton alert.generatorUrl + , silenceButton alert + ] + , if maybeActiveId == Just alert.id then + table [ class "table w-100 mb-1" ] (List.map annotation alert.annotations) + else + text "" + , div [] (List.map labelButton ungroupedLabels) + ] + + +titleView : Alert -> Html Msg +titleView { startsAt, isInhibited } = + let + ( className, inhibited ) = + if isInhibited then + ( "text-muted", " (inhibited)" ) + else + ( "", "" ) + in + span + [ class ("align-self-center mr-2 " ++ className) ] + [ text + (Utils.Date.timeFormat startsAt + ++ ", " + ++ Utils.Date.dateFormat startsAt + ++ inhibited + ) + ] + + +annotationsButton : Maybe String -> Alert -> Html Msg +annotationsButton maybeActiveId alert = + if maybeActiveId == Just alert.id then + button + [ onClick (SetActive Nothing |> MsgForAlertList) + , class "btn btn-outline-info border-0 active" + ] + [ i [ class "fa fa-minus mr-2" ] [], text "Info" ] + else + button + [ onClick (SetActive (Just alert.id) |> MsgForAlertList) + , class "btn btn-outline-info border-0" + ] + [ i [ class "fa fa-plus mr-2" ] [], text "Info" ] + + +annotation : ( String, String ) -> Html Msg +annotation ( key, value ) = + tr [] + [ th [ class "text-nowrap" ] [ text (key ++ ":") ] + , td [ class "w-100" ] (Utils.Views.linkifyText value) + ] + + +labelButton : ( String, String ) -> Html Msg +labelButton ( key, val ) = + div + [ class "btn-group mr-2 mb-2" ] + [ span + [ class "btn btn-sm border-right-0 text-muted" + + -- have to reset bootstrap button styles to make the text selectable + , style + [ ( "user-select", "initial" ) + , ( "-moz-user-select", "initial" ) + , ( "-webkit-user-select", "initial" ) + , ( "border-color", "#ccc" ) + ] + ] + [ text (key ++ "=\"" ++ val ++ "\"") ] + , button + [ class "btn btn-sm bg-faded btn-outline-secondary" + , onClick (addLabelMsg ( key, val )) + , title "Filter by this label" + ] + [ text "+" ] + ] + + +addLabelMsg : ( String, String ) -> Msg +addLabelMsg ( key, value ) = + FilterBarTypes.AddFilterMatcher False + { key = key + , op = Utils.Filter.Eq + , value = value + } + |> MsgForFilterBar + |> MsgForAlertList + + +silenceButton : Alert -> Html Msg +silenceButton alert = + case alert.silenceId of + Just sId -> + a + [ class "btn btn-outline-danger border-0" + , href ("#/silences/" ++ sId) + ] + [ i [ class "fa fa-bell-slash mr-2" ] [] + , text "Silenced" + ] + + Nothing -> + a + [ class "btn btn-outline-info border-0" + , href (newSilenceFromAlertLabels alert.labels) + ] + [ i [ class "fa fa-bell-slash-o mr-2" ] [] + , text "Silence" + ] + + +generatorUrlButton : String -> Html Msg +generatorUrlButton url = + a + [ class "btn btn-outline-info border-0", href url ] + [ i [ class "fa fa-line-chart mr-2" ] [] + , text "Source" + ] diff --git a/src/alertmanager/ui/app/src/Views/AlertList/Filter.elm b/src/alertmanager/ui/app/src/Views/AlertList/Filter.elm new file mode 100644 index 0000000..dc28690 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/AlertList/Filter.elm @@ -0,0 +1,76 @@ +module Views.AlertList.Filter exposing (matchers) + +import Alerts.Types exposing (Alert, AlertGroup, Block) +import Utils.Types exposing (Matchers) +import Regex exposing (regex, contains) + + +matchers : Maybe Utils.Types.Matchers -> List AlertGroup -> List AlertGroup +matchers matchers alerts = + case matchers of + Just ms -> + by (filterAlertGroupLabels ms) alerts + + Nothing -> + alerts + + +alertsFromBlock : (Alert -> Bool) -> Block -> Maybe Block +alertsFromBlock fn block = + let + alerts = + List.filter fn block.alerts + in + if not <| List.isEmpty alerts then + Just { block | alerts = alerts } + else + Nothing + + +byLabel : Utils.Types.Matchers -> Block -> Maybe Block +byLabel matchers block = + alertsFromBlock + (\a -> + -- Check that all labels are present within the alert's label set. + List.all + (\m -> + -- Check for regex or direct match + if m.isRegex then + -- Check if key is present, then regex match value. + let + x = + List.head <| List.filter (\( key, value ) -> key == m.name) a.labels + + regex = + Regex.regex m.value + in + -- No regex match + case x of + Just ( _, value ) -> + Regex.contains regex value + + Nothing -> + False + else + List.member ( m.name, m.value ) a.labels + ) + matchers + ) + block + + +filterAlertGroupLabels : Utils.Types.Matchers -> AlertGroup -> Maybe AlertGroup +filterAlertGroupLabels matchers alertGroup = + let + blocks = + List.filterMap (byLabel matchers) alertGroup.blocks + in + if not <| List.isEmpty blocks then + Just { alertGroup | blocks = blocks } + else + Nothing + + +by : (a -> Maybe a) -> List a -> List a +by fn groups = + List.filterMap fn groups diff --git a/src/alertmanager/ui/app/src/Views/AlertList/Parsing.elm b/src/alertmanager/ui/app/src/Views/AlertList/Parsing.elm new file mode 100644 index 0000000..72bc0cf --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/AlertList/Parsing.elm @@ -0,0 +1,21 @@ +module Views.AlertList.Parsing exposing (alertsParser) + +import UrlParser exposing ((), (), Parser, int, map, oneOf, parseHash, s, string, stringParam) +import Utils.Filter exposing (Filter, parseMatcher, MatchOperator(RegexMatch)) + + +boolParam : String -> UrlParser.QueryParser (Maybe Bool -> a) a +boolParam name = + UrlParser.customParam name + (Maybe.map (String.toLower >> (/=) "false")) + + +alertsParser : Parser (Filter -> a) a +alertsParser = + s "alerts" + stringParam "filter" + stringParam "group" + stringParam "receiver" + boolParam "silenced" + boolParam "inhibited" + |> map Filter diff --git a/src/alertmanager/ui/app/src/Views/AlertList/Types.elm b/src/alertmanager/ui/app/src/Views/AlertList/Types.elm new file mode 100644 index 0000000..3f82364 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/AlertList/Types.elm @@ -0,0 +1,45 @@ +module Views.AlertList.Types exposing (AlertListMsg(..), Model, Tab(..), initAlertList) + +import Alerts.Types exposing (Alert) +import Utils.Types exposing (ApiData(Initial)) +import Views.FilterBar.Types as FilterBar +import Views.GroupBar.Types as GroupBar +import Views.ReceiverBar.Types as ReceiverBar + + +type AlertListMsg + = AlertsFetched (ApiData (List Alert)) + | FetchAlerts + | MsgForReceiverBar ReceiverBar.Msg + | MsgForFilterBar FilterBar.Msg + | MsgForGroupBar GroupBar.Msg + | ToggleSilenced Bool + | ToggleInhibited Bool + | SetActive (Maybe String) + | SetTab Tab + + +type Tab + = FilterTab + | GroupTab + + +type alias Model = + { alerts : ApiData (List Alert) + , receiverBar : ReceiverBar.Model + , groupBar : GroupBar.Model + , filterBar : FilterBar.Model + , tab : Tab + , activeId : Maybe String + } + + +initAlertList : Model +initAlertList = + { alerts = Initial + , receiverBar = ReceiverBar.initReceiverBar + , groupBar = GroupBar.initGroupBar + , filterBar = FilterBar.initFilterBar + , tab = FilterTab + , activeId = Nothing + } diff --git a/src/alertmanager/ui/app/src/Views/AlertList/Updates.elm b/src/alertmanager/ui/app/src/Views/AlertList/Updates.elm new file mode 100644 index 0000000..9d31a6f --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/AlertList/Updates.elm @@ -0,0 +1,92 @@ +module Views.AlertList.Updates exposing (..) + +import Alerts.Api as Api +import Views.AlertList.Types exposing (AlertListMsg(..), Model, Tab(FilterTab, GroupTab)) +import Views.FilterBar.Updates as FilterBar +import Utils.Filter exposing (Filter, parseFilter) +import Utils.Types exposing (ApiData(Initial, Loading, Success, Failure)) +import Types exposing (Msg(MsgForAlertList, Noop)) +import Set +import Navigation +import Utils.Filter exposing (generateQueryString) +import Views.GroupBar.Updates as GroupBar +import Views.ReceiverBar.Updates as ReceiverBar + + +update : AlertListMsg -> Model -> Filter -> String -> String -> ( Model, Cmd Types.Msg ) +update msg ({ groupBar, filterBar, receiverBar } as model) filter apiUrl basePath = + let + alertsUrl = + basePath ++ "#/alerts" + in + case msg of + AlertsFetched listOfAlerts -> + ( { model + | alerts = listOfAlerts + , groupBar = + case listOfAlerts of + Success alerts -> + { groupBar + | list = + List.concatMap .labels alerts + |> List.map Tuple.first + |> Set.fromList + } + + _ -> + groupBar + } + , Cmd.none + ) + + FetchAlerts -> + let + newGroupBar = + GroupBar.setFields filter groupBar + + newFilterBar = + FilterBar.setMatchers filter filterBar + in + ( { model | alerts = Loading, filterBar = newFilterBar, groupBar = newGroupBar, activeId = Nothing } + , Cmd.batch + [ Api.fetchAlerts apiUrl filter |> Cmd.map (AlertsFetched >> MsgForAlertList) + , ReceiverBar.fetchReceivers apiUrl |> Cmd.map (MsgForReceiverBar >> MsgForAlertList) + ] + ) + + ToggleSilenced showSilenced -> + ( model + , Navigation.newUrl (alertsUrl ++ generateQueryString { filter | showSilenced = Just showSilenced }) + ) + + ToggleInhibited showInhibited -> + ( model + , Navigation.newUrl (alertsUrl ++ generateQueryString { filter | showInhibited = Just showInhibited }) + ) + + SetTab tab -> + ( { model | tab = tab }, Cmd.none ) + + MsgForFilterBar msg -> + let + ( newFilterBar, cmd ) = + FilterBar.update alertsUrl filter msg filterBar + in + ( { model | filterBar = newFilterBar, tab = FilterTab }, Cmd.map (MsgForFilterBar >> MsgForAlertList) cmd ) + + MsgForGroupBar msg -> + let + ( newGroupBar, cmd ) = + GroupBar.update alertsUrl filter msg groupBar + in + ( { model | groupBar = newGroupBar }, Cmd.map (MsgForGroupBar >> MsgForAlertList) cmd ) + + MsgForReceiverBar msg -> + let + ( newReceiverBar, cmd ) = + ReceiverBar.update alertsUrl filter msg receiverBar + in + ( { model | receiverBar = newReceiverBar }, Cmd.map (MsgForReceiverBar >> MsgForAlertList) cmd ) + + SetActive maybeId -> + ( { model | activeId = maybeId }, Cmd.none ) diff --git a/src/alertmanager/ui/app/src/Views/AlertList/Views.elm b/src/alertmanager/ui/app/src/Views/AlertList/Views.elm new file mode 100644 index 0000000..ffc4e8b --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/AlertList/Views.elm @@ -0,0 +1,139 @@ +module Views.AlertList.Views exposing (view) + +import Alerts.Types exposing (Alert) +import Html exposing (..) +import Html.Attributes exposing (..) +import Html.Events exposing (..) +import Types exposing (Msg(Noop, MsgForAlertList)) +import Utils.Filter exposing (Filter) +import Views.FilterBar.Views as FilterBar +import Views.ReceiverBar.Views as ReceiverBar +import Utils.Types exposing (ApiData(Initial, Success, Loading, Failure), Labels) +import Utils.Views +import Utils.List +import Views.AlertList.AlertView as AlertView +import Views.GroupBar.Types as GroupBar +import Views.AlertList.Types exposing (AlertListMsg(..), Model, Tab(..)) +import Types exposing (Msg(Noop, MsgForAlertList)) +import Views.GroupBar.Views as GroupBar +import Dict exposing (Dict) + + +renderCheckbox : String -> Maybe Bool -> (Bool -> AlertListMsg) -> Html Msg +renderCheckbox textLabel maybeShowSilenced toggleMsg = + li [ class "nav-item" ] + [ label [ class "mt-1 ml-1 custom-control custom-checkbox" ] + [ input + [ type_ "checkbox" + , class "custom-control-input" + , checked (Maybe.withDefault False maybeShowSilenced) + , onCheck (toggleMsg >> MsgForAlertList) + ] + [] + , span [ class "custom-control-indicator" ] [] + , span [ class "custom-control-description" ] [ text textLabel ] + ] + ] + + +view : Model -> Filter -> Html Msg +view { alerts, groupBar, filterBar, receiverBar, tab, activeId } filter = + div [] + [ div + [ class "card mb-5" ] + [ div [ class "card-header" ] + [ ul [ class "nav nav-tabs card-header-tabs" ] + [ Utils.Views.tab FilterTab tab (SetTab >> MsgForAlertList) [ text "Filter" ] + , Utils.Views.tab GroupTab tab (SetTab >> MsgForAlertList) [ text "Group" ] + , receiverBar + |> ReceiverBar.view filter.receiver + |> Html.map (MsgForReceiverBar >> MsgForAlertList) + , renderCheckbox "Silenced" filter.showSilenced ToggleSilenced + , renderCheckbox "Inhibited" filter.showInhibited ToggleInhibited + ] + ] + , div [ class "card-block" ] + [ case tab of + FilterTab -> + Html.map (MsgForFilterBar >> MsgForAlertList) (FilterBar.view filterBar) + + GroupTab -> + Html.map (MsgForGroupBar >> MsgForAlertList) (GroupBar.view groupBar) + ] + ] + , case alerts of + Success alerts -> + alertGroups activeId filter groupBar alerts + + Loading -> + Utils.Views.loading + + Initial -> + Utils.Views.loading + + Failure msg -> + Utils.Views.error msg + ] + + +alertGroups : Maybe String -> Filter -> GroupBar.Model -> List Alert -> Html Msg +alertGroups activeId filter { fields } alerts = + let + grouped = + alerts + |> Utils.List.groupBy + (.labels >> List.filter (\( key, _ ) -> List.member key fields)) + in + grouped + |> Dict.keys + |> List.partition ((/=) []) + |> uncurry (++) + |> List.filterMap + (\labels -> + Maybe.map + (alertList activeId labels filter) + (Dict.get labels grouped) + ) + |> (\list -> + if List.isEmpty list then + [ Utils.Views.error "No alerts found" ] + else + list + ) + |> div [] + + +alertList : Maybe String -> Labels -> Filter -> List Alert -> Html Msg +alertList activeId labels filter alerts = + div [] + [ div [] + (case labels of + [] -> + [ span [ class "btn btn-secondary mr-1 mb-3" ] [ text "Not grouped" ] ] + + _ -> + List.map + (\( key, value ) -> + div [ class "btn-group mr-1 mb-3" ] + [ span + [ class "btn text-muted" + , style + [ ( "user-select", "initial" ) + , ( "-moz-user-select", "initial" ) + , ( "-webkit-user-select", "initial" ) + , ( "border-color", "#5bc0de" ) + ] + ] + [ text (key ++ "=\"" ++ value ++ "\"") ] + , button + [ class "btn btn-outline-info" + , onClick (AlertView.addLabelMsg ( key, value )) + , title "Filter by this label" + ] + [ text "+" ] + ] + ) + labels + ) + , ul [ class "list-group mb-4" ] (List.map (AlertView.view labels activeId) alerts) + ] diff --git a/src/alertmanager/ui/app/src/Views/FilterBar/Types.elm b/src/alertmanager/ui/app/src/Views/FilterBar/Types.elm new file mode 100644 index 0000000..26975e0 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/FilterBar/Types.elm @@ -0,0 +1,36 @@ +module Views.FilterBar.Types exposing (Model, Msg(..), initFilterBar) + +import Utils.Filter + + +type alias Model = + { matchers : List Utils.Filter.Matcher + , backspacePressed : Bool + , matcherText : String + } + + +type Msg + = AddFilterMatcher Bool Utils.Filter.Matcher + | DeleteFilterMatcher Bool Utils.Filter.Matcher + | PressingBackspace Bool + | UpdateMatcherText String + | Noop + + +{-| A note about the `backspacePressed` attribute: + +Holding down the backspace removes (one by one) each last character in the input, +and the whole time sends multiple keyDown events. This is a guard so that if a user +holds down backspace to remove the text in the input, they won't accidentally hold +backspace too long and then delete the preceding matcher as well. So, once a user holds +backspace to clear an input, they have to then lift up the key and press it again to +proceed to deleting the next matcher. + +-} +initFilterBar : Model +initFilterBar = + { matchers = [] + , backspacePressed = False + , matcherText = "" + } diff --git a/src/alertmanager/ui/app/src/Views/FilterBar/Updates.elm b/src/alertmanager/ui/app/src/Views/FilterBar/Updates.elm new file mode 100644 index 0000000..568d3ec --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/FilterBar/Updates.elm @@ -0,0 +1,72 @@ +module Views.FilterBar.Updates exposing (update, setMatchers) + +import Views.FilterBar.Types exposing (Msg(..), Model) +import Task +import Dom +import Navigation +import Utils.Filter exposing (Filter, generateQueryString, stringifyFilter, parseFilter) + + +update : String -> Filter -> Msg -> Model -> ( Model, Cmd Msg ) +update url filter msg model = + case msg of + AddFilterMatcher emptyMatcherText matcher -> + immediatelyFilter url + filter + { model + | matchers = + if List.member matcher model.matchers then + model.matchers + else + model.matchers ++ [ matcher ] + , matcherText = + if emptyMatcherText then + "" + else + model.matcherText + } + + DeleteFilterMatcher setMatcherText matcher -> + immediatelyFilter url + filter + { model + | matchers = List.filter ((/=) matcher) model.matchers + , matcherText = + if setMatcherText then + Utils.Filter.stringifyMatcher matcher + else + model.matcherText + } + + UpdateMatcherText value -> + ( { model | matcherText = value }, Cmd.none ) + + PressingBackspace isPressed -> + ( { model | backspacePressed = isPressed }, Cmd.none ) + + Noop -> + ( model, Cmd.none ) + + +immediatelyFilter : String -> Filter -> Model -> ( Model, Cmd Msg ) +immediatelyFilter url filter model = + let + newFilter = + { filter | text = Just (stringifyFilter model.matchers) } + in + ( { model | matchers = [] } + , Cmd.batch + [ Navigation.newUrl (url ++ generateQueryString newFilter) + , Dom.focus "filter-bar-matcher" |> Task.attempt (always Noop) + ] + ) + + +setMatchers : Filter -> Model -> Model +setMatchers filter model = + { model + | matchers = + filter.text + |> Maybe.andThen parseFilter + |> Maybe.withDefault [] + } diff --git a/src/alertmanager/ui/app/src/Views/FilterBar/Views.elm b/src/alertmanager/ui/app/src/Views/FilterBar/Views.elm new file mode 100644 index 0000000..698cf6e --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/FilterBar/Views.elm @@ -0,0 +1,136 @@ +module Views.FilterBar.Views exposing (view) + +import Html exposing (Html, Attribute, div, span, input, text, button, i, small) +import Html.Attributes exposing (value, class, style, disabled, id) +import Html.Events exposing (onClick, onInput, on, keyCode) +import Utils.Filter exposing (Matcher) +import Utils.List +import Utils.Keyboard exposing (keys, onKeyUp, onKeyDown) +import Views.FilterBar.Types exposing (Msg(..), Model) + + +keys : + { backspace : Int + , enter : Int + } +keys = + { backspace = 8 + , enter = 13 + } + + +viewMatcher : Matcher -> Html Msg +viewMatcher matcher = + div [ class "col col-auto" ] + [ div [ class "btn-group mr-2 mb-2" ] + [ button + [ class "btn btn-outline-info" + , onClick (DeleteFilterMatcher True matcher) + ] + [ text <| Utils.Filter.stringifyMatcher matcher + ] + , button + [ class "btn btn-outline-danger" + , onClick (DeleteFilterMatcher False matcher) + ] + [ text "×" ] + ] + ] + + +viewMatchers : List Matcher -> List (Html Msg) +viewMatchers matchers = + matchers + |> List.map viewMatcher + + +view : Model -> Html Msg +view { matchers, matcherText, backspacePressed } = + let + maybeMatcher = + Utils.Filter.parseMatcher matcherText + + maybeLastMatcher = + Utils.List.lastElem matchers + + className = + if matcherText == "" then + "" + else + case maybeMatcher of + Just _ -> + "has-success" + + Nothing -> + "has-danger" + + keyDown key = + if key == keys.enter then + maybeMatcher + |> Maybe.map (AddFilterMatcher True) + |> Maybe.withDefault Noop + else if key == keys.backspace then + if matcherText == "" then + case ( backspacePressed, maybeLastMatcher ) of + ( False, Just lastMatcher ) -> + DeleteFilterMatcher True lastMatcher + + _ -> + Noop + else + PressingBackspace True + else + Noop + + keyUp key = + if key == keys.backspace then + PressingBackspace False + else + Noop + + onClickAttr = + maybeMatcher + |> Maybe.map (AddFilterMatcher True) + |> Maybe.withDefault Noop + |> onClick + + isDisabled = + maybeMatcher == Nothing + in + div + [ class "row no-gutters align-items-start" ] + (viewMatchers matchers + ++ [ div + [ class ("col " ++ className) + , style [ ( "min-width", "200px" ) ] + ] + [ div [ class "input-group" ] + [ input + [ id "filter-bar-matcher" + , class "form-control" + , value matcherText + , onKeyDown keyDown + , onKeyUp keyUp + , onInput UpdateMatcherText + ] + [] + , span + [ class "input-group-btn" ] + [ button [ class "btn btn-primary", disabled isDisabled, onClickAttr ] [ text "+" ] ] + ] + , small [ class "form-text text-muted" ] + [ text "Custom matcher, e.g." + , button + [ class "btn btn-link btn-sm align-baseline" + , onClick (UpdateMatcherText exampleMatcher) + ] + [ text exampleMatcher ] + ] + ] + ] + ) + + +exampleMatcher : String +exampleMatcher = + "env=\"production\"" diff --git a/src/alertmanager/ui/app/src/Views/GroupBar/Types.elm b/src/alertmanager/ui/app/src/Views/GroupBar/Types.elm new file mode 100644 index 0000000..b71df54 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/GroupBar/Types.elm @@ -0,0 +1,39 @@ +module Views.GroupBar.Types exposing (Model, Msg(..), initGroupBar) + +import Set exposing (Set) + + +type alias Model = + { list : Set String + , fieldText : String + , fields : List String + , matches : List String + , backspacePressed : Bool + , focused : Bool + , resultsHovered : Bool + , maybeSelectedMatch : Maybe String + } + + +type Msg + = AddField Bool String + | DeleteField Bool String + | Select (Maybe String) + | PressingBackspace Bool + | Focus Bool + | ResultsHovered Bool + | UpdateFieldText String + | Noop + + +initGroupBar : Model +initGroupBar = + { list = Set.empty + , fieldText = "" + , fields = [] + , matches = [] + , focused = False + , resultsHovered = False + , backspacePressed = False + , maybeSelectedMatch = Nothing + } diff --git a/src/alertmanager/ui/app/src/Views/GroupBar/Updates.elm b/src/alertmanager/ui/app/src/Views/GroupBar/Updates.elm new file mode 100644 index 0000000..d5ff10a --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/GroupBar/Updates.elm @@ -0,0 +1,115 @@ +module Views.GroupBar.Updates exposing (update, setFields) + +import Views.GroupBar.Types exposing (Model, Msg(..)) +import Utils.Match exposing (jaroWinkler) +import Task +import Dom +import Set +import Utils.Filter exposing (Filter, generateQueryString, stringifyGroup, parseGroup) +import Navigation + + +update : String -> Filter -> Msg -> Model -> ( Model, Cmd Msg ) +update url filter msg model = + case msg of + AddField emptyFieldText text -> + immediatelyFilter url + filter + { model + | fields = model.fields ++ [ text ] + , matches = [] + , fieldText = + if emptyFieldText then + "" + else + model.fieldText + } + + DeleteField setFieldText text -> + immediatelyFilter url + filter + { model + | fields = List.filter ((/=) text) model.fields + , matches = [] + , fieldText = + if setFieldText then + text + else + model.fieldText + } + + Select maybeSelectedMatch -> + ( { model | maybeSelectedMatch = maybeSelectedMatch }, Cmd.none ) + + Focus focused -> + ( { model + | focused = focused + , maybeSelectedMatch = Nothing + } + , Cmd.none + ) + + ResultsHovered resultsHovered -> + ( { model + | resultsHovered = resultsHovered + } + , Cmd.none + ) + + PressingBackspace pressed -> + ( { model | backspacePressed = pressed }, Cmd.none ) + + UpdateFieldText text -> + updateAutoComplete + { model + | fieldText = text + } + + Noop -> + ( model, Cmd.none ) + + +immediatelyFilter : String -> Filter -> Model -> ( Model, Cmd Msg ) +immediatelyFilter url filter model = + let + newFilter = + { filter | group = stringifyGroup model.fields } + in + ( model + , Cmd.batch + [ Navigation.newUrl (url ++ generateQueryString newFilter) + , Dom.focus "group-by-field" |> Task.attempt (always Noop) + ] + ) + + +setFields : Filter -> Model -> Model +setFields filter model = + { model + | fields = + parseGroup filter.group + } + + +updateAutoComplete : Model -> ( Model, Cmd Msg ) +updateAutoComplete model = + ( { model + | matches = + if String.isEmpty model.fieldText then + [] + else if String.contains " " model.fieldText then + model.matches + else + -- TODO: How many matches do we want to show? + -- NOTE: List.reverse is used because our scale is (0.0, 1.0), + -- but we want the higher values to be in the front of the + -- list. + Set.toList model.list + |> List.filter ((flip List.member model.fields) >> not) + |> List.sortBy (jaroWinkler model.fieldText) + |> List.reverse + |> List.take 10 + , maybeSelectedMatch = Nothing + } + , Cmd.none + ) diff --git a/src/alertmanager/ui/app/src/Views/GroupBar/Views.elm b/src/alertmanager/ui/app/src/Views/GroupBar/Views.elm new file mode 100644 index 0000000..4e665e6 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/GroupBar/Views.elm @@ -0,0 +1,178 @@ +module Views.GroupBar.Views exposing (view) + +import Views.GroupBar.Types exposing (Msg(..), Model) +import Html exposing (Html, Attribute, div, span, input, text, button, i, small, ul, li, a) +import Html.Attributes exposing (value, class, style, disabled, id, href) +import Html.Events exposing (onClick, onInput, on, keyCode, onFocus, onBlur, onMouseEnter, onMouseLeave) +import Set +import Utils.List +import Utils.Keyboard exposing (keys, onKeyUp, onKeyDown) + + +view : Model -> Html Msg +view ({ list, fieldText, fields } as model) = + let + isDisabled = + not (Set.member fieldText list) || List.member fieldText fields + + className = + if String.isEmpty fieldText then + "" + else if isDisabled then + "has-danger" + else + "has-success" + in + div + [ class "row no-gutters align-items-start" ] + (List.map viewField fields + ++ [ div + [ class ("col " ++ className) + , style [ ( "min-width", "200px" ) ] + ] + [ textInputField isDisabled model + , exampleField fields + , autoCompleteResults model + ] + ] + ) + + +exampleField : List String -> Html Msg +exampleField fields = + if List.member "alertname" fields then + small [ class "form-text text-muted" ] + [ text "Label key for grouping alerts" + ] + else + small [ class "form-text text-muted" ] + [ text "Label key for grouping alerts, e.g." + , button + [ class "btn btn-link btn-sm align-baseline" + , onClick (UpdateFieldText "alertname") + ] + [ text "alertname" ] + ] + + +textInputField : Bool -> Model -> Html Msg +textInputField isDisabled { fieldText, matches, maybeSelectedMatch, fields, backspacePressed } = + let + onClickMsg = + if isDisabled then + Noop + else + AddField True fieldText + + nextMatch = + maybeSelectedMatch + |> Maybe.map (flip Utils.List.nextElem <| matches) + |> Maybe.withDefault (List.head matches) + + prevMatch = + maybeSelectedMatch + |> Maybe.map (flip Utils.List.nextElem <| List.reverse matches) + |> Maybe.withDefault (Utils.List.lastElem matches) + + keyDown key = + if key == keys.down then + Select nextMatch + else if key == keys.up then + Select prevMatch + else if key == keys.enter then + if not isDisabled then + AddField True fieldText + else + maybeSelectedMatch + |> Maybe.map (AddField True) + |> Maybe.withDefault Noop + else if key == keys.backspace then + if fieldText == "" then + case ( Utils.List.lastElem fields, backspacePressed ) of + ( Just lastField, False ) -> + DeleteField True lastField + + _ -> + Noop + else + PressingBackspace True + else + Noop + + keyUp key = + if key == keys.backspace then + PressingBackspace False + else + Noop + in + div [ class "input-group" ] + [ input + [ id "group-by-field" + , class "form-control" + , value fieldText + , onKeyDown keyDown + , onKeyUp keyUp + , onInput UpdateFieldText + , onFocus (Focus True) + , onBlur (Focus False) + ] + [] + , span + [ class "input-group-btn" ] + [ button [ class "btn btn-primary", disabled isDisabled, onClick onClickMsg ] [ text "+" ] ] + ] + + +autoCompleteResults : Model -> Html Msg +autoCompleteResults { maybeSelectedMatch, focused, resultsHovered, matches } = + let + autoCompleteClass = + if (focused || resultsHovered) && not (List.isEmpty matches) then + "show" + else + "" + in + div + [ class ("autocomplete-menu " ++ autoCompleteClass) + , onMouseEnter (ResultsHovered True) + , onMouseLeave (ResultsHovered False) + ] + [ matches + |> List.map (matchedField maybeSelectedMatch) + |> div [ class "dropdown-menu" ] + ] + + +matchedField : Maybe String -> String -> Html Msg +matchedField maybeSelectedMatch field = + let + className = + if maybeSelectedMatch == Just field then + "active" + else + "" + in + button + [ class ("dropdown-item " ++ className) + , onClick (AddField True field) + ] + [ text field ] + + +viewField : String -> Html Msg +viewField field = + div [ class "col col-auto" ] + [ div [ class "btn-group mr-2 mb-2" ] + [ button + [ class "btn btn-outline-info" + , onClick (DeleteField True field) + ] + [ text field + ] + , button + [ class "btn btn-outline-danger" + , onClick (DeleteField False field) + ] + [ text "×" ] + ] + ] diff --git a/src/alertmanager/ui/app/src/Views/NavBar/Types.elm b/src/alertmanager/ui/app/src/Views/NavBar/Types.elm new file mode 100644 index 0000000..17f2da7 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/NavBar/Types.elm @@ -0,0 +1,32 @@ +module Views.NavBar.Types exposing (Tab, alertsTab, silencesTab, statusTab, noneTab, tabs) + + +type alias Tab = + { link : String + , name : String + } + + +alertsTab : Tab +alertsTab = + { link = "#/alerts", name = "Alerts" } + + +silencesTab : Tab +silencesTab = + { link = "#/silences", name = "Silences" } + + +statusTab : Tab +statusTab = + { link = "#/status", name = "Status" } + + +noneTab : Tab +noneTab = + { link = "", name = "" } + + +tabs : List Tab +tabs = + [ alertsTab, silencesTab, statusTab ] diff --git a/src/alertmanager/ui/app/src/Views/NavBar/Views.elm b/src/alertmanager/ui/app/src/Views/NavBar/Views.elm new file mode 100644 index 0000000..c71bffa --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/NavBar/Views.elm @@ -0,0 +1,83 @@ +module Views.NavBar.Views exposing (navBar) + +import Html exposing (Html, header, text, a, nav, ul, li, div) +import Html.Attributes exposing (class, href, title, style) +import Types exposing (Route(..)) +import Views.NavBar.Types exposing (Tab, alertsTab, silencesTab, statusTab, noneTab, tabs) + + +navBar : Route -> Html msg +navBar currentRoute = + header + [ class "navbar navbar-toggleable-md navbar-light bg-faded mb-5 pt-3 pb-3" + , style [ ( "border-bottom", "1px solid rgba(0, 0, 0, .125)" ) ] + ] + [ nav [ class "container" ] + [ a [ class "navbar-brand", href "#" ] [ text "Alertmanager" ] + , ul [ class "navbar-nav" ] (navBarItems currentRoute) + , case currentRoute of + SilenceFormEditRoute _ -> + text "" + + SilenceFormNewRoute _ -> + text "" + + _ -> + div [ class "form-inline ml-auto" ] + [ a + [ class "btn btn-outline-info" + , href "#/silences/new" + ] + [ text "New Silence" ] + ] + ] + ] + + +navBarItems : Route -> List (Html msg) +navBarItems currentRoute = + List.map (navBarItem currentRoute) tabs + + +navBarItem : Route -> Tab -> Html msg +navBarItem currentRoute tab = + li [ class <| "nav-item" ++ (isActive currentRoute tab) ] + [ a [ class "nav-link", href tab.link, title tab.name ] + [ text tab.name ] + ] + + +isActive : Route -> Tab -> String +isActive currentRoute tab = + if routeToTab currentRoute == tab then + " active" + else + "" + + +routeToTab : Route -> Tab +routeToTab currentRoute = + case currentRoute of + AlertsRoute _ -> + alertsTab + + NotFoundRoute -> + noneTab + + SilenceFormEditRoute _ -> + silencesTab + + SilenceFormNewRoute _ -> + silencesTab + + SilenceListRoute _ -> + silencesTab + + SilenceViewRoute _ -> + silencesTab + + StatusRoute -> + statusTab + + TopLevelRoute -> + noneTab diff --git a/src/alertmanager/ui/app/src/Views/NotFound/Views.elm b/src/alertmanager/ui/app/src/Views/NotFound/Views.elm new file mode 100644 index 0000000..362b9da --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/NotFound/Views.elm @@ -0,0 +1,11 @@ +module Views.NotFound.Views exposing (view) + +import Html exposing (Html, div, h1, text) +import Types exposing (Msg) + + +view : Html Msg +view = + div [] + [ h1 [] [ text "not found" ] + ] diff --git a/src/alertmanager/ui/app/src/Views/ReceiverBar/Types.elm b/src/alertmanager/ui/app/src/Views/ReceiverBar/Types.elm new file mode 100644 index 0000000..e12f743 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/ReceiverBar/Types.elm @@ -0,0 +1,36 @@ +module Views.ReceiverBar.Types exposing (Model, Msg(..), initReceiverBar) + +import Utils.Types exposing (ApiData(Initial)) +import Alerts.Types exposing (Receiver) + + +type Msg + = ReceiversFetched (ApiData (List Receiver)) + | UpdateReceiver String + | EditReceivers + | FilterByReceiver String + | Select (Maybe Receiver) + | ResultsHovered Bool + | BlurReceiverField + | Noop + + +type alias Model = + { receivers : List Receiver + , matches : List Receiver + , fieldText : String + , selectedReceiver : Maybe Receiver + , showReceivers : Bool + , resultsHovered : Bool + } + + +initReceiverBar : Model +initReceiverBar = + { receivers = [] + , matches = [] + , fieldText = "" + , selectedReceiver = Nothing + , showReceivers = False + , resultsHovered = False + } diff --git a/src/alertmanager/ui/app/src/Views/ReceiverBar/Updates.elm b/src/alertmanager/ui/app/src/Views/ReceiverBar/Updates.elm new file mode 100644 index 0000000..38dc891 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/ReceiverBar/Updates.elm @@ -0,0 +1,81 @@ +module Views.ReceiverBar.Updates exposing (update, fetchReceivers) + +import Views.ReceiverBar.Types exposing (Model, Msg(..)) +import Utils.Types exposing (ApiData(Success)) +import Utils.Filter exposing (Filter, generateQueryString, stringifyGroup, parseGroup) +import Navigation +import Dom +import Task +import Alerts.Api as Api +import Utils.Match exposing (jaroWinkler) + + +update : String -> Filter -> Msg -> Model -> ( Model, Cmd Msg ) +update url filter msg model = + case msg of + ReceiversFetched (Success receivers) -> + ( { model | receivers = receivers }, Cmd.none ) + + ReceiversFetched _ -> + ( model, Cmd.none ) + + EditReceivers -> + ( { model + | showReceivers = True + , fieldText = "" + , matches = + model.receivers + |> List.take 10 + |> (::) { name = "All", regex = "" } + , selectedReceiver = Nothing + } + , Dom.focus "receiver-field" |> Task.attempt (always Noop) + ) + + ResultsHovered resultsHovered -> + ( { model | resultsHovered = resultsHovered }, Cmd.none ) + + UpdateReceiver receiver -> + let + matches = + model.receivers + |> List.sortBy (.name >> jaroWinkler receiver) + |> List.reverse + |> List.take 10 + |> (::) { name = "All", regex = "" } + in + ( { model + | fieldText = receiver + , matches = matches + } + , Cmd.none + ) + + BlurReceiverField -> + ( { model | showReceivers = False }, Cmd.none ) + + Select maybeReceiver -> + ( { model | selectedReceiver = maybeReceiver }, Cmd.none ) + + FilterByReceiver regex -> + ( { model | showReceivers = False, resultsHovered = False } + , Navigation.newUrl + (url + ++ generateQueryString + { filter + | receiver = + if regex == "" then + Nothing + else + Just regex + } + ) + ) + + Noop -> + ( model, Cmd.none ) + + +fetchReceivers : String -> Cmd Msg +fetchReceivers = + Api.fetchReceivers >> Cmd.map ReceiversFetched diff --git a/src/alertmanager/ui/app/src/Views/ReceiverBar/Views.elm b/src/alertmanager/ui/app/src/Views/ReceiverBar/Views.elm new file mode 100644 index 0000000..1f392ec --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/ReceiverBar/Views.elm @@ -0,0 +1,113 @@ +module Views.ReceiverBar.Views exposing (view) + +import Html exposing (Html, li, div, text, input) +import Html.Attributes exposing (class, style, tabindex, value, id) +import Html.Events exposing (onBlur, onClick, onInput, onMouseEnter, onMouseLeave) +import Views.ReceiverBar.Types exposing (Model, Msg(..)) +import Alerts.Types exposing (Receiver) +import Utils.Keyboard exposing (keys, onKeyUp, onKeyDown) +import Utils.List + + +view : Maybe String -> Model -> Html Msg +view maybeRegex model = + if model.showReceivers || model.resultsHovered then + viewDropdown model + else + viewResult maybeRegex model.receivers + + +viewResult : Maybe String -> List Receiver -> Html Msg +viewResult maybeRegex receivers = + let + unescapedReceiver = + receivers + |> List.filter (.regex >> Just >> (==) maybeRegex) + |> List.map (.name >> Just) + |> List.head + |> Maybe.withDefault maybeRegex + in + li + [ class ("nav-item ml-auto") + , tabindex 1 + , style + [ ( "position", "relative" ) + , ( "outline", "none" ) + ] + ] + [ div + [ onClick EditReceivers + , class "mt-1 mr-4" + , style [ ( "cursor", "pointer" ) ] + ] + [ text ("Receiver: " ++ Maybe.withDefault "All" unescapedReceiver) ] + ] + + +viewDropdown : Model -> Html Msg +viewDropdown { matches, fieldText, selectedReceiver } = + let + nextMatch = + selectedReceiver + |> Maybe.map (flip Utils.List.nextElem <| matches) + |> Maybe.withDefault (List.head matches) + + prevMatch = + selectedReceiver + |> Maybe.map (flip Utils.List.nextElem <| List.reverse matches) + |> Maybe.withDefault (Utils.List.lastElem matches) + + keyDown key = + if key == keys.down then + Select nextMatch + else if key == keys.up then + Select prevMatch + else if key == keys.enter then + selectedReceiver + |> Maybe.map .regex + |> Maybe.withDefault fieldText + |> FilterByReceiver + else + Noop + in + li + [ class ("nav-item ml-auto mr-4 autocomplete-menu show") + , onMouseEnter (ResultsHovered True) + , onMouseLeave (ResultsHovered False) + , style + [ ( "position", "relative" ) + , ( "outline", "none" ) + ] + ] + [ input + [ id "receiver-field" + , value fieldText + , onBlur BlurReceiverField + , onInput UpdateReceiver + , onKeyDown keyDown + , class "mr-4" + , style + [ ( "display", "block" ) + , ( "width", "100%" ) + ] + ] + [] + , matches + |> List.map (receiverField selectedReceiver) + |> div [ class "dropdown-menu dropdown-menu-right" ] + ] + + +receiverField : Maybe Receiver -> Receiver -> Html Msg +receiverField selected receiver = + let + attrs = + if selected == Just receiver then + [ class "dropdown-item active" ] + else + [ class "dropdown-item" + , style [ ( "cursor", "pointer" ) ] + , onClick (FilterByReceiver receiver.regex) + ] + in + div attrs [ text receiver.name ] diff --git a/src/alertmanager/ui/app/src/Views/Shared/AlertCompact.elm b/src/alertmanager/ui/app/src/Views/Shared/AlertCompact.elm new file mode 100644 index 0000000..d0e58d6 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/Shared/AlertCompact.elm @@ -0,0 +1,16 @@ +module Views.Shared.AlertCompact exposing (view) + +import Alerts.Types exposing (Alert) +import Html exposing (Html, span, div, text, li) +import Html.Attributes exposing (class) +import Utils.Views exposing (labelButton) + + +view : Alert -> Html msg +view alert = + li [ class "mb2 w-80-l w-100-m" ] <| + List.map + (\( key, value ) -> + labelButton Nothing (key ++ "=" ++ value) + ) + alert.labels diff --git a/src/alertmanager/ui/app/src/Views/Shared/AlertListCompact.elm b/src/alertmanager/ui/app/src/Views/Shared/AlertListCompact.elm new file mode 100644 index 0000000..8e1a6f9 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/Shared/AlertListCompact.elm @@ -0,0 +1,12 @@ +module Views.Shared.AlertListCompact exposing (view) + +import Alerts.Types exposing (Alert) +import Html exposing (Html, ol) +import Html.Attributes exposing (class) +import Views.Shared.AlertCompact + + +view : List Alert -> Html msg +view alerts = + List.map Views.Shared.AlertCompact.view alerts + |> ol [ class "list pa0 w-100" ] diff --git a/src/alertmanager/ui/app/src/Views/Shared/SilencePreview.elm b/src/alertmanager/ui/app/src/Views/Shared/SilencePreview.elm new file mode 100644 index 0000000..d0e2a81 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/Shared/SilencePreview.elm @@ -0,0 +1,31 @@ +module Views.Shared.SilencePreview exposing (view) + +import Alerts.Types exposing (Alert) +import Html exposing (Html, div, p, strong, text) +import Html.Attributes exposing (class) +import Utils.Types exposing (ApiData(Failure, Initial, Loading, Success)) +import Utils.Views exposing (loading) +import Views.Shared.AlertListCompact + + +view : ApiData (List Alert) -> Html msg +view alertsResponse = + case alertsResponse of + Success alerts -> + if List.isEmpty alerts then + div [ class "w-100" ] + [ p [] [ strong [] [ text "No silenced alerts" ] ] ] + else + div [ class "w-100" ] + [ p [] [ strong [] [ text ("Silenced alerts: " ++ toString (List.length alerts)) ] ] + , Views.Shared.AlertListCompact.view alerts + ] + + Initial -> + text "" + + Loading -> + loading + + Failure e -> + div [ class "alert alert-warning" ] [ text e ] diff --git a/src/alertmanager/ui/app/src/Views/SilenceForm/Parsing.elm b/src/alertmanager/ui/app/src/Views/SilenceForm/Parsing.elm new file mode 100644 index 0000000..6f8877e --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/SilenceForm/Parsing.elm @@ -0,0 +1,27 @@ +module Views.SilenceForm.Parsing exposing (newSilenceFromAlertLabels, silenceFormNewParser, silenceFormEditParser) + +import UrlParser exposing (Parser, s, (), (), string, stringParam, oneOf, map) +import Utils.Filter exposing (parseFilter, Matcher) +import Http exposing (encodeUri) + + +newSilenceFromAlertLabels : List ( String, String ) -> String +newSilenceFromAlertLabels labels = + labels + |> List.map (\( k, v ) -> Utils.Filter.Matcher k Utils.Filter.Eq v) + |> Utils.Filter.stringifyFilter + |> encodeUri + |> (++) "#/silences/new?filter=" + + +silenceFormNewParser : Parser (List Matcher -> a) a +silenceFormNewParser = + s "silences" + s "new" + stringParam "filter" + |> map (Maybe.andThen parseFilter >> Maybe.withDefault []) + + +silenceFormEditParser : Parser (String -> a) a +silenceFormEditParser = + s "silences" string s "edit" diff --git a/src/alertmanager/ui/app/src/Views/SilenceForm/Types.elm b/src/alertmanager/ui/app/src/Views/SilenceForm/Types.elm new file mode 100644 index 0000000..e098a10 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/SilenceForm/Types.elm @@ -0,0 +1,230 @@ +module Views.SilenceForm.Types + exposing + ( SilenceFormMsg(..) + , SilenceFormFieldMsg(..) + , Model + , SilenceForm + , MatcherForm + , fromMatchersAndTime + , fromSilence + , toSilence + , initSilenceForm + , emptyMatcher + , validateForm + , parseEndsAt + ) + +import Silences.Types exposing (Silence, SilenceId, nullSilence) +import Alerts.Types exposing (Alert) +import Utils.Types exposing (Matcher, Duration, ApiData(..)) +import Time exposing (Time) +import Utils.Date exposing (timeFromString, timeToString, durationFormat, parseDuration) +import Time exposing (Time) +import Utils.Filter +import Utils.FormValidation + exposing + ( initialField + , ValidationState(..) + , ValidatedField + , validate + , stringNotEmpty + ) + + +type alias Model = + { form : SilenceForm + , silenceId : ApiData String + , alerts : ApiData (List Alert) + } + + +type alias SilenceForm = + { id : String + , createdBy : ValidatedField + , comment : ValidatedField + , startsAt : ValidatedField + , endsAt : ValidatedField + , duration : ValidatedField + , matchers : List MatcherForm + } + + +type alias MatcherForm = + { name : ValidatedField + , value : ValidatedField + , isRegex : Bool + } + + +type SilenceFormMsg + = UpdateField SilenceFormFieldMsg + | CreateSilence + | PreviewSilence + | AlertGroupsPreview (ApiData (List Alert)) + | FetchSilence String + | NewSilenceFromMatchers String (List Utils.Filter.Matcher) + | NewSilenceFromMatchersAndTime String (List Utils.Filter.Matcher) Time + | SilenceFetch (ApiData Silence) + | SilenceCreate (ApiData SilenceId) + + +type SilenceFormFieldMsg + = AddMatcher + | DeleteMatcher Int + | UpdateStartsAt String + | UpdateEndsAt String + | UpdateDuration String + | ValidateTime + | UpdateCreatedBy String + | ValidateCreatedBy + | UpdateComment String + | ValidateComment + | UpdateMatcherName Int String + | ValidateMatcherName Int + | UpdateMatcherValue Int String + | ValidateMatcherValue Int + | UpdateMatcherRegex Int Bool + + +initSilenceForm : Model +initSilenceForm = + { form = empty + , silenceId = Utils.Types.Initial + , alerts = Utils.Types.Initial + } + + +toSilence : SilenceForm -> Maybe Silence +toSilence { id, comment, matchers, createdBy, startsAt, endsAt } = + Result.map5 + (\nonEmptyComment validMatchers nonEmptyCreatedBy parsedStartsAt parsedEndsAt -> + { nullSilence + | id = id + , comment = nonEmptyComment + , matchers = validMatchers + , createdBy = nonEmptyCreatedBy + , startsAt = parsedStartsAt + , endsAt = parsedEndsAt + } + ) + (stringNotEmpty comment.value) + (List.foldr appendMatcher (Ok []) matchers) + (stringNotEmpty createdBy.value) + (timeFromString startsAt.value) + (parseEndsAt startsAt.value endsAt.value) + |> Result.toMaybe + + +fromSilence : Silence -> SilenceForm +fromSilence { id, createdBy, comment, startsAt, endsAt, matchers } = + { id = id + , createdBy = initialField createdBy + , comment = initialField comment + , startsAt = initialField (timeToString startsAt) + , endsAt = initialField (timeToString endsAt) + , duration = initialField (durationFormat (endsAt - startsAt) |> Maybe.withDefault "") + , matchers = List.map fromMatcher matchers + } + + +validateForm : SilenceForm -> SilenceForm +validateForm { id, createdBy, comment, startsAt, endsAt, duration, matchers } = + { id = id + , createdBy = validate stringNotEmpty createdBy + , comment = validate stringNotEmpty comment + , startsAt = validate timeFromString startsAt + , endsAt = validate (parseEndsAt startsAt.value) endsAt + , duration = validate parseDuration duration + , matchers = List.map validateMatcherForm matchers + } + + +parseEndsAt : String -> String -> Result String Time.Time +parseEndsAt startsAt endsAt = + case ( timeFromString startsAt, timeFromString endsAt ) of + ( Ok starts, Ok ends ) -> + if starts > ends then + Err "Can't be in the past" + else + Ok ends + + ( _, endsResult ) -> + endsResult + + +validateMatcherForm : MatcherForm -> MatcherForm +validateMatcherForm { name, value, isRegex } = + { name = validate stringNotEmpty name + , value = value + , isRegex = isRegex + } + + +empty : SilenceForm +empty = + { id = "" + , createdBy = initialField "" + , comment = initialField "" + , startsAt = initialField "" + , endsAt = initialField "" + , duration = initialField "" + , matchers = [] + } + + +emptyMatcher : MatcherForm +emptyMatcher = + { isRegex = False + , name = initialField "" + , value = initialField "" + } + + +defaultDuration : Time +defaultDuration = + 2 * Time.hour + + +fromMatchersAndTime : String -> List Utils.Filter.Matcher -> Time -> SilenceForm +fromMatchersAndTime defaultCreator matchers now = + { empty + | startsAt = initialField (timeToString now) + , endsAt = initialField (timeToString (now + defaultDuration)) + , duration = initialField (durationFormat defaultDuration |> Maybe.withDefault "") + , createdBy = initialField defaultCreator + , matchers = + -- If no matchers were specified, add an empty row + if List.isEmpty matchers then + [ emptyMatcher ] + else + List.filterMap (filterMatcherToMatcher >> Maybe.map fromMatcher) matchers + } + + +appendMatcher : MatcherForm -> Result String (List Matcher) -> Result String (List Matcher) +appendMatcher { isRegex, name, value } = + Result.map2 (::) + (Result.map2 (Matcher isRegex) (stringNotEmpty name.value) (Ok value.value)) + + +filterMatcherToMatcher : Utils.Filter.Matcher -> Maybe Matcher +filterMatcherToMatcher { key, op, value } = + Maybe.map (\op -> Matcher op key value) <| + case op of + Utils.Filter.Eq -> + Just False + + Utils.Filter.RegexMatch -> + Just True + + -- we don't support negative matchers + _ -> + Nothing + + +fromMatcher : Matcher -> MatcherForm +fromMatcher { name, value, isRegex } = + { name = initialField name + , value = initialField value + , isRegex = isRegex + } diff --git a/src/alertmanager/ui/app/src/Views/SilenceForm/Updates.elm b/src/alertmanager/ui/app/src/Views/SilenceForm/Updates.elm new file mode 100644 index 0000000..0113f3b --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/SilenceForm/Updates.elm @@ -0,0 +1,264 @@ +port module Views.SilenceForm.Updates exposing (update) + +import Alerts.Api +import Silences.Api +import Task +import Time +import Types exposing (Msg(MsgForSilenceForm, SetDefaultCreator)) +import Navigation +import Utils.Date exposing (timeFromString) +import Utils.List +import Utils.Types exposing (ApiData(..)) +import Utils.Filter exposing (nullFilter) +import Utils.FormValidation exposing (updateValue, validate, stringNotEmpty, fromResult) +import Views.SilenceForm.Types + exposing + ( Model + , SilenceForm + , SilenceFormMsg(..) + , SilenceFormFieldMsg(..) + , fromMatchersAndTime + , fromSilence + , parseEndsAt + , validateForm + , toSilence + , emptyMatcher + ) + + +updateForm : SilenceFormFieldMsg -> SilenceForm -> SilenceForm +updateForm msg form = + case msg of + AddMatcher -> + { form | matchers = form.matchers ++ [ emptyMatcher ] } + + UpdateStartsAt time -> + let + startsAt = + Utils.Date.timeFromString time + + endsAt = + Utils.Date.timeFromString form.endsAt.value + + durationValue = + case Result.map2 (-) endsAt startsAt of + Ok duration -> + case Utils.Date.durationFormat duration of + Just value -> + value + + Nothing -> + form.duration.value + + Err _ -> + form.duration.value + in + { form + | startsAt = updateValue time form.startsAt + , duration = updateValue durationValue form.duration + } + + UpdateEndsAt time -> + let + endsAt = + Utils.Date.timeFromString time + + startsAt = + Utils.Date.timeFromString form.startsAt.value + + durationValue = + case Result.map2 (-) endsAt startsAt of + Ok duration -> + case Utils.Date.durationFormat duration of + Just value -> + value + + Nothing -> + form.duration.value + + Err _ -> + form.duration.value + in + { form + | endsAt = updateValue time form.endsAt + , duration = updateValue durationValue form.duration + } + + UpdateDuration time -> + let + duration = + Utils.Date.parseDuration time + + startsAt = + Utils.Date.timeFromString form.startsAt.value + + endsAtValue = + case Result.map2 (+) startsAt duration of + Ok endsAt -> + Utils.Date.timeToString endsAt + + Err _ -> + form.endsAt.value + in + { form + | endsAt = updateValue endsAtValue form.endsAt + , duration = updateValue time form.duration + } + + ValidateTime -> + { form + | startsAt = validate Utils.Date.timeFromString form.startsAt + , endsAt = validate (parseEndsAt form.startsAt.value) form.endsAt + , duration = validate Utils.Date.parseDuration form.duration + } + + UpdateCreatedBy createdBy -> + { form | createdBy = updateValue createdBy form.createdBy } + + ValidateCreatedBy -> + { form | createdBy = validate stringNotEmpty form.createdBy } + + UpdateComment comment -> + { form | comment = updateValue comment form.comment } + + ValidateComment -> + { form | comment = validate stringNotEmpty form.comment } + + DeleteMatcher index -> + { form | matchers = List.take index form.matchers ++ List.drop (index + 1) form.matchers } + + UpdateMatcherName index name -> + let + matchers = + Utils.List.replaceIndex index + (\matcher -> { matcher | name = updateValue name matcher.name }) + form.matchers + in + { form | matchers = matchers } + + ValidateMatcherName index -> + let + matchers = + Utils.List.replaceIndex index + (\matcher -> { matcher | name = validate stringNotEmpty matcher.name }) + form.matchers + in + { form | matchers = matchers } + + UpdateMatcherValue index value -> + let + matchers = + Utils.List.replaceIndex index + (\matcher -> { matcher | value = updateValue value matcher.value }) + form.matchers + in + { form | matchers = matchers } + + ValidateMatcherValue index -> + let + matchers = + Utils.List.replaceIndex index + (\matcher -> { matcher | value = matcher.value }) + form.matchers + in + { form | matchers = matchers } + + UpdateMatcherRegex index isRegex -> + let + matchers = + Utils.List.replaceIndex index + (\matcher -> { matcher | isRegex = isRegex }) + form.matchers + in + { form | matchers = matchers } + + +update : SilenceFormMsg -> Model -> String -> String -> ( Model, Cmd Msg ) +update msg model basePath apiUrl = + case msg of + CreateSilence -> + case toSilence model.form of + Just silence -> + ( { model | silenceId = Loading } + , Cmd.batch + [ Silences.Api.create apiUrl silence |> Cmd.map (SilenceCreate >> MsgForSilenceForm) + , persistDefaultCreator silence.createdBy + , Task.succeed silence.createdBy |> Task.perform SetDefaultCreator + ] + ) + + Nothing -> + ( { model + | silenceId = Failure "Could not submit the form, Silence is not yet valid." + , form = validateForm model.form + } + , Cmd.none + ) + + SilenceCreate silenceId -> + let + cmd = + case silenceId of + Success id -> + Navigation.newUrl (basePath ++ "#/silences/" ++ id) + + _ -> + Cmd.none + in + ( { model | silenceId = silenceId }, cmd ) + + NewSilenceFromMatchers defaultCreator matchers -> + ( model, Task.perform (NewSilenceFromMatchersAndTime defaultCreator matchers >> MsgForSilenceForm) Time.now ) + + NewSilenceFromMatchersAndTime defaultCreator matchers time -> + ( { form = fromMatchersAndTime defaultCreator matchers time + , alerts = Initial + , silenceId = Initial + } + , Cmd.none + ) + + FetchSilence silenceId -> + ( model, Silences.Api.getSilence apiUrl silenceId (SilenceFetch >> MsgForSilenceForm) ) + + SilenceFetch (Success silence) -> + ( { model | form = fromSilence silence } + , Task.perform identity (Task.succeed (MsgForSilenceForm PreviewSilence)) + ) + + SilenceFetch _ -> + ( model, Cmd.none ) + + PreviewSilence -> + case toSilence model.form of + Just silence -> + ( { model | alerts = Loading } + , Alerts.Api.fetchAlerts + apiUrl + { nullFilter | text = Just (Utils.List.mjoin silence.matchers) } + |> Cmd.map (AlertGroupsPreview >> MsgForSilenceForm) + ) + + Nothing -> + ( { model + | alerts = Failure "Can not display affected Alerts, Silence is not yet valid." + , form = validateForm model.form + } + , Cmd.none + ) + + AlertGroupsPreview alerts -> + ( { model | alerts = alerts } + , Cmd.none + ) + + UpdateField fieldMsg -> + ( { form = updateForm fieldMsg model.form + , alerts = Initial + , silenceId = Initial + } + , Cmd.none + ) + + +port persistDefaultCreator : String -> Cmd msg diff --git a/src/alertmanager/ui/app/src/Views/SilenceForm/Views.elm b/src/alertmanager/ui/app/src/Views/SilenceForm/Views.elm new file mode 100644 index 0000000..ec2875a --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/SilenceForm/Views.elm @@ -0,0 +1,165 @@ +module Views.SilenceForm.Views exposing (view) + +import Html exposing (Html, a, div, fieldset, label, legend, span, text, h1, strong, button, input, textarea) +import Html.Attributes exposing (class, href) +import Html.Events exposing (onClick) +import Silences.Types exposing (Silence, SilenceId) +import Alerts.Types exposing (Alert) +import Views.Shared.SilencePreview +import Views.SilenceForm.Types exposing (Model, SilenceFormMsg(..), MatcherForm) +import Utils.Types exposing (ApiData) +import Utils.Views exposing (checkbox, iconButtonMsg, validatedField, loading) +import Utils.FormValidation exposing (ValidationState(..), ValidatedField) +import Views.SilenceForm.Types exposing (Model, SilenceFormMsg(..), SilenceFormFieldMsg(..), SilenceForm) +import Utils.Filter + + +view : Maybe SilenceId -> List Utils.Filter.Matcher -> String -> Model -> Html SilenceFormMsg +view maybeId matchers defaultCreator { form, silenceId, alerts } = + let + ( title, resetClick ) = + case maybeId of + Just silenceId -> + ( "Edit Silence", FetchSilence silenceId ) + + Nothing -> + ( "New Silence", NewSilenceFromMatchers defaultCreator matchers ) + in + div [] + [ h1 [] [ text title ] + , timeInput form.startsAt form.endsAt form.duration + , matcherInput form.matchers + , validatedField input + "Creator" + inputSectionPadding + (UpdateCreatedBy >> UpdateField) + (ValidateCreatedBy |> UpdateField) + form.createdBy + , validatedField textarea + "Comment" + inputSectionPadding + (UpdateComment >> UpdateField) + (ValidateComment |> UpdateField) + form.comment + , div [ class inputSectionPadding ] + [ informationBlock silenceId alerts + , silenceActionButtons maybeId form resetClick + ] + ] + + +inputSectionPadding : String +inputSectionPadding = + "mt-5" + + +timeInput : ValidatedField -> ValidatedField -> ValidatedField -> Html SilenceFormMsg +timeInput startsAt endsAt duration = + div [ class <| "row " ++ inputSectionPadding ] + [ validatedField input + "Start" + "col-5" + (UpdateStartsAt >> UpdateField) + (ValidateTime |> UpdateField) + startsAt + , validatedField input + "Duration" + "col-2" + (UpdateDuration >> UpdateField) + (ValidateTime |> UpdateField) + duration + , validatedField input + "End" + "col-5" + (UpdateEndsAt >> UpdateField) + (ValidateTime |> UpdateField) + endsAt + ] + + +matcherInput : List MatcherForm -> Html SilenceFormMsg +matcherInput matchers = + div [ class inputSectionPadding ] + [ div [] + [ label [] + [ strong [] [ text "Matchers " ] + , span [ class "" ] [ text "Alerts affected by this silence." ] + ] + , div [ class "row" ] + [ label [ class "col-5" ] [ text "Name" ] + , label [ class "col-5" ] [ text "Value" ] + ] + ] + , div [] (List.indexedMap (matcherForm (List.length matchers > 1)) matchers) + , iconButtonMsg "btn btn-secondary" "fa-plus" (AddMatcher |> UpdateField) + ] + + +informationBlock : ApiData SilenceId -> ApiData (List Alert) -> Html SilenceFormMsg +informationBlock silence alerts = + case silence of + Utils.Types.Success _ -> + text "" + + Utils.Types.Initial -> + Views.Shared.SilencePreview.view alerts + + Utils.Types.Failure error -> + Utils.Views.error error + + Utils.Types.Loading -> + loading + + +silenceActionButtons : Maybe String -> SilenceForm -> SilenceFormMsg -> Html SilenceFormMsg +silenceActionButtons maybeId form resetClick = + div [ class ("mb-4 " ++ inputSectionPadding) ] + [ previewSilenceBtn + , createSilenceBtn maybeId + , button + [ class "ml-2 btn btn-danger", onClick resetClick ] + [ text "Reset" ] + ] + + +createSilenceBtn : Maybe String -> Html SilenceFormMsg +createSilenceBtn maybeId = + let + btnTxt = + case maybeId of + Just _ -> + "Update" + + Nothing -> + "Create" + in + button + [ class "ml-2 btn btn-primary" + , onClick CreateSilence + ] + [ text btnTxt ] + + +previewSilenceBtn : Html SilenceFormMsg +previewSilenceBtn = + button + [ class "btn btn-outline-success" + , onClick PreviewSilence + ] + [ text "Preview Alerts" ] + + +matcherForm : Bool -> Int -> MatcherForm -> Html SilenceFormMsg +matcherForm showDeleteButton index { name, value, isRegex } = + div [ class "row" ] + [ div [ class "col-5" ] [ validatedField input "" "" (UpdateMatcherName index) (ValidateMatcherName index) name ] + , div [ class "col-5" ] [ validatedField input "" "" (UpdateMatcherValue index) (ValidateMatcherValue index) value ] + , div [ class "col-2 d-flex align-items-center" ] + [ checkbox "Regex" isRegex (UpdateMatcherRegex index) + , if showDeleteButton then + iconButtonMsg "btn btn-secondary ml-auto" "fa-trash-o" (DeleteMatcher index) + else + text "" + ] + ] + |> Html.map UpdateField diff --git a/src/alertmanager/ui/app/src/Views/SilenceList/Parsing.elm b/src/alertmanager/ui/app/src/Views/SilenceList/Parsing.elm new file mode 100644 index 0000000..fa6180b --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/SilenceList/Parsing.elm @@ -0,0 +1,13 @@ +module Views.SilenceList.Parsing exposing (silenceListParser) + +import UrlParser exposing ((), Parser, s, stringParam, map) +import Utils.Filter exposing (Filter) + + +silenceListParser : Parser (Filter -> a) a +silenceListParser = + map + (\t -> + Filter t Nothing Nothing Nothing Nothing + ) + (s "silences" stringParam "filter") diff --git a/src/alertmanager/ui/app/src/Views/SilenceList/SilenceView.elm b/src/alertmanager/ui/app/src/Views/SilenceList/SilenceView.elm new file mode 100644 index 0000000..ebb8466 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/SilenceList/SilenceView.elm @@ -0,0 +1,153 @@ +module Views.SilenceList.SilenceView exposing (deleteButton, editButton, view) + +import Dialog +import Html exposing (Html, a, b, button, div, h3, i, li, p, small, span, text) +import Html.Attributes exposing (class, href, style) +import Html.Events exposing (onClick) +import Silences.Types exposing (Silence, State(Active, Expired, Pending)) +import Time exposing (Time) +import Types exposing (Msg(MsgForSilenceForm, MsgForSilenceList, Noop)) +import Utils.Date +import Utils.Filter +import Utils.List +import Utils.Types exposing (Matcher) +import Utils.Views exposing (buttonLink) +import Views.FilterBar.Types as FilterBarTypes +import Views.SilenceList.Types exposing (SilenceListMsg(ConfirmDestroySilence, DestroySilence, FetchSilences, MsgForFilterBar)) +import Views.SilenceForm.Parsing exposing (newSilenceFromAlertLabels) + + +view : Bool -> Silence -> Html Msg +view showConfirmationDialog silence = + li + [ -- speedup rendering in Chrome, because list-group-item className + -- creates a new layer in the rendering engine + style [ ( "position", "static" ) ] + , class "align-items-start list-group-item border-0 p-0 mb-4" + ] + [ div [ class "w-100 mb-2 d-flex align-items-start" ] + [ case silence.status.state of + Active -> + dateView "Ends" silence.endsAt + + Pending -> + dateView "Starts" silence.startsAt + + Expired -> + dateView "Expired" silence.endsAt + , detailsButton silence.id + , editButton silence + , deleteButton silence False + ] + , div [ class "" ] (List.map matcherButton silence.matchers) + , Dialog.view + (if showConfirmationDialog then + Just (confirmSilenceDeleteView silence False) + else + Nothing + ) + ] + + +confirmSilenceDeleteView : Silence -> Bool -> Dialog.Config Msg +confirmSilenceDeleteView silence refresh = + { closeMessage = Just (MsgForSilenceList Views.SilenceList.Types.FetchSilences) + , containerClass = Nothing + , header = Just (h3 [] [ text "Expire Silence" ]) + , body = Just (text "Are you sure you want to expire this silence?") + , footer = + Just + (button + [ class "btn btn-success" + , onClick (MsgForSilenceList (Views.SilenceList.Types.DestroySilence silence refresh)) + ] + [ text "Confirm" ] + ) + } + + +dateView : String -> Time -> Html Msg +dateView string time = + span + [ class "text-muted align-self-center mr-2" + ] + [ text (string ++ " " ++ Utils.Date.timeFormat time ++ ", " ++ Utils.Date.dateFormat time) + ] + + +matcherButton : Matcher -> Html Msg +matcherButton matcher = + let + op = + if matcher.isRegex then + Utils.Filter.RegexMatch + else + Utils.Filter.Eq + + msg = + FilterBarTypes.AddFilterMatcher False + { key = matcher.name + , op = op + , value = matcher.value + } + |> MsgForFilterBar + |> MsgForSilenceList + in + Utils.Views.labelButton (Just msg) (Utils.List.mstring matcher) + + +editButton : Silence -> Html Msg +editButton silence = + let + matchers = + List.map (\s -> ( s.name, s.value )) silence.matchers + in + case silence.status.state of + -- If the silence is expired, do not edit it, but instead create a new + -- one with the old matchers + Expired -> + a + [ class "btn btn-outline-info border-0" + , href (newSilenceFromAlertLabels matchers) + ] + [ text "Recreate" + ] + + _ -> + let + editUrl = + String.join "/" [ "#/silences", silence.id, "edit" ] + in + a [ class "btn btn-outline-info border-0", href editUrl ] + [ text "Edit" + ] + + +deleteButton : Silence -> Bool -> Html Msg +deleteButton silence refresh = + case silence.status.state of + Expired -> + text "" + + Active -> + button + [ class "btn btn-outline-danger border-0" + , onClick (MsgForSilenceList (ConfirmDestroySilence silence refresh)) + ] + [ text "Expire" + ] + + Pending -> + button + [ class "btn btn-outline-danger border-0" + , onClick (MsgForSilenceList (ConfirmDestroySilence silence refresh)) + ] + [ text "Delete" + ] + + +detailsButton : String -> Html Msg +detailsButton silenceId = + a [ class "btn btn-outline-info border-0", href ("#/silences/" ++ silenceId) ] + [ text "View" + ] diff --git a/src/alertmanager/ui/app/src/Views/SilenceList/Types.elm b/src/alertmanager/ui/app/src/Views/SilenceList/Types.elm new file mode 100644 index 0000000..7064120 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/SilenceList/Types.elm @@ -0,0 +1,38 @@ +module Views.SilenceList.Types exposing (Model, SilenceTab, SilenceListMsg(..), initSilenceList) + +import Silences.Types exposing (Silence, State(Active), SilenceId) +import Utils.Types exposing (ApiData(Initial)) +import Views.FilterBar.Types as FilterBar + + +type SilenceListMsg + = ConfirmDestroySilence Silence Bool + | DestroySilence Silence Bool + | SilencesFetch (ApiData (List Silence)) + | FetchSilences + | MsgForFilterBar FilterBar.Msg + | SetTab State + + +type alias SilenceTab = + { silences : List Silence + , tab : State + , count : Int + } + + +type alias Model = + { silences : ApiData (List SilenceTab) + , filterBar : FilterBar.Model + , tab : State + , showConfirmationDialog : Maybe SilenceId + } + + +initSilenceList : Model +initSilenceList = + { silences = Initial + , filterBar = FilterBar.initFilterBar + , tab = Active + , showConfirmationDialog = Nothing + } diff --git a/src/alertmanager/ui/app/src/Views/SilenceList/Updates.elm b/src/alertmanager/ui/app/src/Views/SilenceList/Updates.elm new file mode 100644 index 0000000..c965665 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/SilenceList/Updates.elm @@ -0,0 +1,96 @@ +module Views.SilenceList.Updates exposing (update, urlUpdate) + +import Navigation +import Silences.Api as Api +import Utils.Api as ApiData +import Utils.Filter exposing (Filter, generateQueryString) +import Utils.Types as Types exposing (ApiData(Failure, Loading, Success), Matchers, Time) +import Views.FilterBar.Updates as FilterBar +import Views.SilenceList.Types exposing (Model, SilenceTab, SilenceListMsg(..)) +import Silences.Types exposing (Silence, State(..)) + + +update : SilenceListMsg -> Model -> Filter -> String -> String -> ( Model, Cmd SilenceListMsg ) +update msg model filter basePath apiUrl = + case msg of + SilencesFetch fetchedSilences -> + ( { model + | silences = + ApiData.map + (\silences -> List.map (groupSilencesByState silences) states) + fetchedSilences + } + , Cmd.none + ) + + FetchSilences -> + ( { model + | filterBar = FilterBar.setMatchers filter model.filterBar + , silences = Loading + , showConfirmationDialog = Nothing + } + , Api.getSilences apiUrl filter SilencesFetch + ) + + ConfirmDestroySilence silence refresh -> + ( { model | showConfirmationDialog = Just silence.id } + , Cmd.none + ) + + DestroySilence silence refresh -> + -- TODO: "Deleted id: ID" growl + -- TODO: Check why POST isn't there but is accepted + { model | silences = Loading, showConfirmationDialog = Nothing } + ! [ Api.destroy apiUrl silence (always FetchSilences) + , if refresh then + Navigation.newUrl (basePath ++ "#/silences") + else + Cmd.none + ] + + MsgForFilterBar msg -> + let + ( filterBar, cmd ) = + FilterBar.update (basePath ++ "#/silences") filter msg model.filterBar + in + ( { model | filterBar = filterBar }, Cmd.map MsgForFilterBar cmd ) + + SetTab tab -> + ( { model | tab = tab }, Cmd.none ) + + +groupSilencesByState : List Silence -> State -> SilenceTab +groupSilencesByState silences state = + let + silencesInTab = + filterSilencesByState state silences + in + { tab = state + , silences = silencesInTab + , count = List.length silencesInTab + } + + +states : List State +states = + [ Active, Pending, Expired ] + + +filterSilencesByState : State -> List Silence -> List Silence +filterSilencesByState state = + List.filter (.status >> .state >> (==) state) + + +urlUpdate : Maybe String -> ( SilenceListMsg, Filter ) +urlUpdate maybeString = + ( FetchSilences, updateFilter maybeString ) + + +updateFilter : Maybe String -> Filter +updateFilter maybeFilter = + { receiver = Nothing + , showSilenced = Nothing + , showInhibited = Nothing + , group = Nothing + , text = maybeFilter + } diff --git a/src/alertmanager/ui/app/src/Views/SilenceList/Views.elm b/src/alertmanager/ui/app/src/Views/SilenceList/Views.elm new file mode 100644 index 0000000..687d66b --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/SilenceList/Views.elm @@ -0,0 +1,101 @@ +module Views.SilenceList.Views exposing (..) + +import Html exposing (..) +import Html.Attributes exposing (..) +import Silences.Types exposing (Silence, State(..), stateToString, SilenceId) +import Types exposing (Msg(MsgForSilenceList, Noop, UpdateFilter)) +import Utils.String as StringUtils +import Utils.Types exposing (ApiData(..), Matcher) +import Utils.Views exposing (buttonLink, checkbox, error, formField, formInput, iconButtonMsg, loading, textField) +import Views.FilterBar.Views as FilterBar +import Views.SilenceList.SilenceView +import Views.SilenceList.Types exposing (Model, SilenceListMsg(..), SilenceTab) +import Html.Lazy exposing (lazy, lazy2, lazy3) +import Html.Keyed + + +view : Model -> Html Msg +view { filterBar, tab, silences, showConfirmationDialog } = + div [] + [ div [ class "mb-4" ] + [ label [ class "mb-2", for "filter-bar-matcher" ] [ text "Filter" ] + , Html.map (MsgForFilterBar >> MsgForSilenceList) (FilterBar.view filterBar) + ] + , lazy2 tabsView tab silences + , lazy3 silencesView showConfirmationDialog tab silences + ] + + +tabsView : State -> ApiData (List SilenceTab) -> Html Msg +tabsView currentTab tabs = + case tabs of + Success silencesTabs -> + List.map (\{ tab, count } -> tabView currentTab count tab) silencesTabs + |> ul [ class "nav nav-tabs mb-4" ] + + _ -> + List.map (tabView currentTab 0) states + |> ul [ class "nav nav-tabs mb-4" ] + + +tabView : State -> Int -> State -> Html Msg +tabView currentTab count tab = + Utils.Views.tab tab currentTab (SetTab >> MsgForSilenceList) <| + case count of + 0 -> + [ text (StringUtils.capitalizeFirst (stateToString tab)) ] + + n -> + [ text (StringUtils.capitalizeFirst (stateToString tab)) + , span + [ class "badge badge-pillow badge-default align-text-top ml-2" ] + [ text (toString n) ] + ] + + +silencesView : Maybe SilenceId -> State -> ApiData (List SilenceTab) -> Html Msg +silencesView showConfirmationDialog tab silencesTab = + case silencesTab of + Success tabs -> + tabs + |> List.filter (.tab >> (==) tab) + |> List.head + |> Maybe.map .silences + |> Maybe.withDefault [] + |> (\silences -> + if List.isEmpty silences then + Utils.Views.error "No silences found" + else + Html.Keyed.ul [ class "list-group" ] + (List.map + (\silence -> + ( silence.id + , Views.SilenceList.SilenceView.view + (showConfirmationDialog == Just silence.id) + silence + ) + ) + silences + ) + ) + + Failure msg -> + error msg + + _ -> + loading + + +groupSilencesByState : List Silence -> List ( State, List Silence ) +groupSilencesByState silences = + List.map (\state -> ( state, filterSilencesByState state silences )) states + + +states : List State +states = + [ Active, Pending, Expired ] + + +filterSilencesByState : State -> List Silence -> List Silence +filterSilencesByState state = + List.filter (.status >> .state >> (==) state) diff --git a/src/alertmanager/ui/app/src/Views/SilenceView/Parsing.elm b/src/alertmanager/ui/app/src/Views/SilenceView/Parsing.elm new file mode 100644 index 0000000..e00d41e --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/SilenceView/Parsing.elm @@ -0,0 +1,8 @@ +module Views.SilenceView.Parsing exposing (silenceViewParser) + +import UrlParser exposing (Parser, s, string, ()) + + +silenceViewParser : Parser (String -> a) a +silenceViewParser = + s "silences" string diff --git a/src/alertmanager/ui/app/src/Views/SilenceView/Types.elm b/src/alertmanager/ui/app/src/Views/SilenceView/Types.elm new file mode 100644 index 0000000..3d23d73 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/SilenceView/Types.elm @@ -0,0 +1,29 @@ +module Views.SilenceView.Types exposing (Model, SilenceViewMsg(..), initSilenceView) + +import Alerts.Types exposing (Alert) +import Silences.Types exposing (Silence, SilenceId) +import Utils.Types exposing (ApiData(Initial)) + + +type SilenceViewMsg + = FetchSilence String + | SilenceFetched (ApiData Silence) + | AlertGroupsPreview (ApiData (List Alert)) + | InitSilenceView SilenceId + | ConfirmDestroySilence Silence Bool + | Reload String + + +type alias Model = + { silence : ApiData Silence + , alerts : ApiData (List Alert) + , showConfirmationDialog : Bool + } + + +initSilenceView : Model +initSilenceView = + { silence = Initial + , alerts = Initial + , showConfirmationDialog = False + } diff --git a/src/alertmanager/ui/app/src/Views/SilenceView/Updates.elm b/src/alertmanager/ui/app/src/Views/SilenceView/Updates.elm new file mode 100644 index 0000000..7982702 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/SilenceView/Updates.elm @@ -0,0 +1,46 @@ +module Views.SilenceView.Updates exposing (update) + +import Alerts.Api +import Navigation exposing (newUrl) +import Silences.Api exposing (getSilence) +import Utils.Filter exposing (nullFilter) +import Utils.List +import Utils.Types exposing (ApiData(..)) +import Views.SilenceView.Types exposing (Model, SilenceViewMsg(..)) + + +update : SilenceViewMsg -> Model -> String -> ( Model, Cmd SilenceViewMsg ) +update msg model apiUrl = + case msg of + FetchSilence id -> + ( model, getSilence apiUrl id SilenceFetched ) + + AlertGroupsPreview alerts -> + ( { model | alerts = alerts } + , Cmd.none + ) + + SilenceFetched (Success silence) -> + ( { model + | silence = Success silence + , alerts = Loading + } + , Alerts.Api.fetchAlerts + apiUrl + { nullFilter | text = Just (Utils.List.mjoin silence.matchers), showSilenced = Just True } + |> Cmd.map AlertGroupsPreview + ) + + ConfirmDestroySilence silence refresh -> + ( { model | showConfirmationDialog = True } + , Cmd.none + ) + + SilenceFetched silence -> + ( { model | silence = silence, alerts = Initial }, Cmd.none ) + + InitSilenceView silenceId -> + ( { model | showConfirmationDialog = False }, getSilence apiUrl silenceId SilenceFetched ) + + Reload silenceId -> + ( { model | showConfirmationDialog = False }, newUrl ("#/silences/" ++ silenceId) ) diff --git a/src/alertmanager/ui/app/src/Views/SilenceView/Views.elm b/src/alertmanager/ui/app/src/Views/SilenceView/Views.elm new file mode 100644 index 0000000..9234563 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/SilenceView/Views.elm @@ -0,0 +1,117 @@ +module Views.SilenceView.Views exposing (view) + +import Alerts.Types exposing (Alert) +import Dialog +import Html exposing (Html, b, button, div, h1, h2, h3, label, p, span, text) +import Html.Attributes exposing (class, href) +import Html.Events exposing (onClick) +import Silences.Types exposing (Silence, stateToString) +import Types exposing (Msg(MsgForSilenceList, MsgForSilenceView)) +import Utils.Date exposing (dateTimeFormat) +import Utils.List +import Utils.Types exposing (ApiData(Failure, Initial, Loading, Success)) +import Utils.Views exposing (error, loading) +import Views.Shared.SilencePreview +import Views.SilenceList.SilenceView exposing (editButton) +import Views.SilenceList.Types exposing (SilenceListMsg(DestroySilence)) +import Views.SilenceView.Types exposing (Model, SilenceViewMsg(ConfirmDestroySilence, Reload)) + + +view : Model -> Html Msg +view { silence, alerts, showConfirmationDialog } = + case silence of + Success sil -> + if showConfirmationDialog then + viewSilence alerts sil True + else + viewSilence alerts sil False + + Initial -> + loading + + Loading -> + loading + + Failure msg -> + error msg + + +viewSilence : ApiData (List Alert) -> Silence -> Bool -> Html Msg +viewSilence alerts silence showPromptDialog = + div [] + [ h1 [] + [ text "Silence" + , span + [ class "ml-3" ] + [ editButton silence + , expireButton silence False + ] + ] + , formGroup "ID" <| text silence.id + , formGroup "Starts at" <| text <| dateTimeFormat silence.startsAt + , formGroup "Ends at" <| text <| dateTimeFormat silence.endsAt + , formGroup "Updated at" <| text <| dateTimeFormat silence.updatedAt + , formGroup "Created by" <| text silence.createdBy + , formGroup "Comment" <| text silence.comment + , formGroup "State" <| text <| stateToString silence.status.state + , formGroup "Matchers" <| + div [] <| + List.map (Utils.List.mstring >> Utils.Views.labelButton Nothing) silence.matchers + , formGroup "Affected alerts" <| Views.Shared.SilencePreview.view alerts + , Dialog.view + (if showPromptDialog then + Just (confirmSilenceDeleteView silence True) + else + Nothing + ) + ] + + +confirmSilenceDeleteView : Silence -> Bool -> Dialog.Config Msg +confirmSilenceDeleteView silence refresh = + { closeMessage = Just (MsgForSilenceView (Reload silence.id)) + , containerClass = Nothing + , header = Just (h3 [] [ text "Expire Silence" ]) + , body = Just (text "Are you sure you want to expire this silence?") + , footer = + Just + (button + [ class "btn btn-success" + , onClick (MsgForSilenceList (DestroySilence silence refresh)) + ] + [ text "Confirm" ] + ) + } + + +formGroup : String -> Html Msg -> Html Msg +formGroup key content = + div [ class "form-group row" ] + [ label [ class "col-2 col-form-label" ] [ b [] [ text key ] ] + , div [ class "col-10 d-flex align-items-center" ] + [ content + ] + ] + + +expireButton : Silence -> Bool -> Html Msg +expireButton silence refresh = + case silence.status.state of + Silences.Types.Expired -> + text "" + + Silences.Types.Active -> + button + [ class "btn btn-outline-danger border-0" + , onClick (MsgForSilenceView (ConfirmDestroySilence silence refresh)) + ] + [ text "Expire" + ] + + Silences.Types.Pending -> + button + [ class "btn btn-outline-danger border-0" + , onClick (MsgForSilenceView (ConfirmDestroySilence silence refresh)) + ] + [ text "Delete" + ] diff --git a/src/alertmanager/ui/app/src/Views/Status/Parsing.elm b/src/alertmanager/ui/app/src/Views/Status/Parsing.elm new file mode 100644 index 0000000..75299d5 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/Status/Parsing.elm @@ -0,0 +1,8 @@ +module Views.Status.Parsing exposing (statusParser) + +import UrlParser exposing (Parser, s) + + +statusParser : Parser a a +statusParser = + s "status" diff --git a/src/alertmanager/ui/app/src/Views/Status/Types.elm b/src/alertmanager/ui/app/src/Views/Status/Types.elm new file mode 100644 index 0000000..f855725 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/Status/Types.elm @@ -0,0 +1,19 @@ +module Views.Status.Types exposing (StatusMsg(..), StatusModel, initStatusModel) + +import Status.Types exposing (StatusResponse) +import Utils.Types exposing (ApiData(Initial)) + + +type StatusMsg + = NewStatus (ApiData StatusResponse) + | InitStatusView + + +type alias StatusModel = + { statusInfo : ApiData StatusResponse + } + + +initStatusModel : StatusModel +initStatusModel = + { statusInfo = Initial } diff --git a/src/alertmanager/ui/app/src/Views/Status/Updates.elm b/src/alertmanager/ui/app/src/Views/Status/Updates.elm new file mode 100644 index 0000000..56db672 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/Status/Updates.elm @@ -0,0 +1,15 @@ +module Views.Status.Updates exposing (update) + +import Types exposing (Msg(MsgForStatus), Model) +import Views.Status.Types exposing (StatusMsg(..)) +import Status.Api exposing (getStatus) + + +update : StatusMsg -> Model -> String -> ( Model, Cmd Msg ) +update msg model basePath = + case msg of + NewStatus apiResponse -> + ( { model | status = { statusInfo = apiResponse } }, Cmd.none ) + + InitStatusView -> + ( model, getStatus basePath (NewStatus >> MsgForStatus) ) diff --git a/src/alertmanager/ui/app/src/Views/Status/Views.elm b/src/alertmanager/ui/app/src/Views/Status/Views.elm new file mode 100644 index 0000000..6df4035 --- /dev/null +++ b/src/alertmanager/ui/app/src/Views/Status/Views.elm @@ -0,0 +1,123 @@ +module Views.Status.Views exposing (view) + +import Html exposing (..) +import Html.Attributes exposing (class, style, classList) +import Status.Types exposing (StatusResponse, VersionInfo, ClusterStatus, ClusterPeer) +import Types exposing (Msg(MsgForStatus)) +import Utils.Types exposing (ApiData(Failure, Success, Loading, Initial)) +import Views.Status.Types exposing (StatusModel) +import Utils.Views + + +view : StatusModel -> Html Types.Msg +view { statusInfo } = + case statusInfo of + Success info -> + viewStatusInfo info + + Initial -> + Utils.Views.loading + + Loading -> + Utils.Views.loading + + Failure msg -> + Utils.Views.error msg + + +viewStatusInfo : StatusResponse -> Html Types.Msg +viewStatusInfo status = + div [] + [ h1 [] [ text "Status" ] + , div [ class "form-group row" ] + [ b [ class "col-sm-2" ] [ text "Uptime:" ] + , div [ class "col-sm-10" ] [ text status.uptime ] + ] + , viewClusterStatus status.clusterStatus + , viewVersionInformation status.versionInfo + , viewConfig status.config + ] + + +viewConfig : String -> Html Types.Msg +viewConfig config = + div [] + [ h2 [] [ text "Config" ] + , pre [ class "p-4", style [ ( "background", "#f7f7f9" ), ( "font-family", "monospace" ) ] ] + [ code [] + [ text config + ] + ] + ] + + +viewClusterStatus : Maybe ClusterStatus -> Html Types.Msg +viewClusterStatus clusterStatus = + case clusterStatus of + Just clusterStatus -> + span [] + [ h2 [] [ text "Cluster Status" ] + , div [ class "form-group row" ] + [ b [ class "col-sm-2" ] [ text "Name:" ] + , div [ class "col-sm-10" ] [ text clusterStatus.name ] + ] + , div [ class "form-group row" ] + [ b [ class "col-sm-2" ] [ text "Status:" ] + , div [ class "col-sm-10" ] + [ span + [ classList + [ ( "badge", True ) + , ( "badge-success", clusterStatus.status == "ready" ) + , ( "badge-warning", clusterStatus.status == "settling" ) + ] + ] + [ text clusterStatus.status ] + ] + ] + , div [ class "form-group row" ] + [ b [ class "col-sm-2" ] [ text "Peers:" ] + , ul [ class "col-sm-10" ] <| + List.map viewClusterPeer clusterStatus.peers + ] + ] + + Nothing -> + span [] + [ h2 [] [ text "Mesh Status" ] + , div [ class "form-group row" ] + [ div [ class "col-sm-10" ] [ text "Mesh not configured" ] + ] + ] + + +viewClusterPeer : ClusterPeer -> Html Types.Msg +viewClusterPeer peer = + li [] + [ div [ class "" ] + [ b [ class "" ] [ text "Name: " ] + , text peer.name + ] + , div [ class "" ] + [ b [ class "" ] [ text "Address: " ] + , text peer.address + ] + ] + + +viewVersionInformation : VersionInfo -> Html Types.Msg +viewVersionInformation versionInfo = + span [] + [ h2 [] [ text "Version Information" ] + , div [ class "form-group row" ] + [ b [ class "col-sm-2" ] [ text "Branch:" ], div [ class "col-sm-10" ] [ text versionInfo.branch ] ] + , div [ class "form-group row" ] + [ b [ class "col-sm-2" ] [ text "BuildDate:" ], div [ class "col-sm-10" ] [ text versionInfo.buildDate ] ] + , div [ class "form-group row" ] + [ b [ class "col-sm-2" ] [ text "BuildUser:" ], div [ class "col-sm-10" ] [ text versionInfo.buildUser ] ] + , div [ class "form-group row" ] + [ b [ class "col-sm-2" ] [ text "GoVersion:" ], div [ class "col-sm-10" ] [ text versionInfo.goVersion ] ] + , div [ class "form-group row" ] + [ b [ class "col-sm-2" ] [ text "Revision:" ], div [ class "col-sm-10" ] [ text versionInfo.revision ] ] + , div [ class "form-group row" ] + [ b [ class "col-sm-2" ] [ text "Version:" ], div [ class "col-sm-10" ] [ text versionInfo.version ] ] + ] diff --git a/src/alertmanager/ui/app/tests/.gitignore b/src/alertmanager/ui/app/tests/.gitignore new file mode 100644 index 0000000..aee9810 --- /dev/null +++ b/src/alertmanager/ui/app/tests/.gitignore @@ -0,0 +1 @@ +/elm-stuff/ diff --git a/src/alertmanager/ui/app/tests/Filter.elm b/src/alertmanager/ui/app/tests/Filter.elm new file mode 100644 index 0000000..bcaa3f3 --- /dev/null +++ b/src/alertmanager/ui/app/tests/Filter.elm @@ -0,0 +1,77 @@ +module Filter exposing (..) + +import Test exposing (..) +import Expect +import Fuzz exposing (list, int, tuple, string) +import Utils.Filter exposing (Matcher, MatchOperator(Eq, RegexMatch)) +import Helpers exposing (isNotEmptyTrimmedAlphabetWord) + + +parseMatcher : Test +parseMatcher = + describe "parseMatcher" + [ test "should parse empty matcher string" <| + \() -> + Expect.equal Nothing (Utils.Filter.parseMatcher "") + , test "should parse empty matcher value" <| + \() -> + Expect.equal (Just (Matcher "alertname" Eq "")) (Utils.Filter.parseMatcher "alertname=\"\"") + , fuzz (tuple ( string, string )) "should parse random matcher string" <| + \( key, value ) -> + if List.map isNotEmptyTrimmedAlphabetWord [ key, value ] /= [ True, True ] then + Expect.equal + Nothing + (Utils.Filter.parseMatcher <| String.join "" [ key, "=", value ]) + else + Expect.equal + (Just (Matcher key Eq value)) + (Utils.Filter.parseMatcher <| String.join "" [ key, "=", "\"", value, "\"" ]) + ] + + +generateQueryString : Test +generateQueryString = + describe "generateQueryString" + [ test "should default silenced & inhibited parameters to false if showSilenced is Nothing" <| + \() -> + Expect.equal "?silenced=false&inhibited=false" + (Utils.Filter.generateQueryString { receiver = Nothing, group = Nothing, text = Nothing, showSilenced = Nothing, showInhibited = Nothing }) + , test "should not render keys with Nothing value except the silenced and inhibited parameters" <| + \() -> + Expect.equal "?silenced=false&inhibited=false" + (Utils.Filter.generateQueryString { receiver = Nothing, group = Nothing, text = Nothing, showSilenced = Nothing, showInhibited = Nothing }) + , test "should not render filter key with empty value" <| + \() -> + Expect.equal "?silenced=false&inhibited=false" + (Utils.Filter.generateQueryString { receiver = Nothing, group = Nothing, text = Just "", showSilenced = Nothing, showInhibited = Nothing }) + , test "should render filter key with values" <| + \() -> + Expect.equal "?silenced=false&inhibited=false&filter=%7Bfoo%3D%22bar%22%2C%20baz%3D~%22quux.*%22%7D" + (Utils.Filter.generateQueryString { receiver = Nothing, group = Nothing, text = Just "{foo=\"bar\", baz=~\"quux.*\"}", showSilenced = Nothing, showInhibited = Nothing }) + , test "should render silenced key with bool" <| + \() -> + Expect.equal "?silenced=true&inhibited=false" + (Utils.Filter.generateQueryString { receiver = Nothing, group = Nothing, text = Nothing, showSilenced = Just True, showInhibited = Nothing }) + , test "should render inhibited key with bool" <| + \() -> + Expect.equal "?silenced=false&inhibited=true" + (Utils.Filter.generateQueryString { receiver = Nothing, group = Nothing, text = Nothing, showSilenced = Nothing, showInhibited = Just True }) + ] + + +stringifyFilter : Test +stringifyFilter = + describe "stringifyFilter" + [ test "empty" <| + \() -> + Expect.equal "" + (Utils.Filter.stringifyFilter []) + , test "non-empty" <| + \() -> + Expect.equal "{foo=\"bar\", baz=~\"quux.*\"}" + (Utils.Filter.stringifyFilter + [ { key = "foo", op = Eq, value = "bar" } + , { key = "baz", op = RegexMatch, value = "quux.*" } + ] + ) + ] diff --git a/src/alertmanager/ui/app/tests/Helpers.elm b/src/alertmanager/ui/app/tests/Helpers.elm new file mode 100644 index 0000000..491450b --- /dev/null +++ b/src/alertmanager/ui/app/tests/Helpers.elm @@ -0,0 +1,31 @@ +module Helpers exposing (isNotEmptyTrimmedAlphabetWord) + +import String + + +isNotEmptyTrimmedAlphabetWord : String -> Bool +isNotEmptyTrimmedAlphabetWord string = + let + stringLength = + String.length string + in + stringLength + /= 0 + && String.length (String.filter isLetter string) + == stringLength + + +isLetter : Char -> Bool +isLetter char = + String.contains (String.fromChar char) (lowerCaseAlphabet) + || String.contains (String.fromChar char) (upperCaseAlphabet) + + +lowerCaseAlphabet : String +lowerCaseAlphabet = + "abcdefghijklmnopqrstuvwxyz" + + +upperCaseAlphabet : String +upperCaseAlphabet = + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" diff --git a/src/alertmanager/ui/app/tests/Match.elm b/src/alertmanager/ui/app/tests/Match.elm new file mode 100644 index 0000000..37362cc --- /dev/null +++ b/src/alertmanager/ui/app/tests/Match.elm @@ -0,0 +1,53 @@ +module Match exposing (..) + +import Test exposing (..) +import Expect +import Utils.Match exposing (jaroWinkler, consecutiveChars) + + +testJaroWinkler : Test +testJaroWinkler = + describe "jaroWinkler" + [ test "should find the right values 1" <| + \() -> + Expect.greaterThan (jaroWinkler "zi" "zone") + (jaroWinkler "zo" "zone") + , test "should find the right values 2" <| + \() -> + Expect.greaterThan (jaroWinkler "hook" "alertname") + (jaroWinkler "de" "dev") + , test "should find the right values 3" <| + \() -> + Expect.equal 0.0 + (jaroWinkler "l" "zone") + , test "should find the right values 4" <| + \() -> + Expect.equal 1.0 + (jaroWinkler "zone" "zone") + , test "should find the right values 5" <| + \() -> + Expect.greaterThan 0.688 + (jaroWinkler "atleio3tefdoisahdf" "attributefdoiashfoihfeowfh9w8f9afaw9fahw") + ] + + +testConsecutiveChars : Test +testConsecutiveChars = + describe "consecutiveChars" + [ test "should find the consecutiveChars 1" <| + \() -> + Expect.equal "zo" + (consecutiveChars "zo" "bozo") + , test "should find the consecutiveChars 2" <| + \() -> + Expect.equal "zo" + (consecutiveChars "zol" "zone") + , test "should find the consecutiveChars 3" <| + \() -> + Expect.equal "oon" + (consecutiveChars "oon" "baboone") + , test "should find the consecutiveChars 4" <| + \() -> + Expect.equal "dom" + (consecutiveChars "dom" "random") + ] diff --git a/src/alertmanager/ui/app/tests/StringUtils.elm b/src/alertmanager/ui/app/tests/StringUtils.elm new file mode 100644 index 0000000..72bbca3 --- /dev/null +++ b/src/alertmanager/ui/app/tests/StringUtils.elm @@ -0,0 +1,23 @@ +module StringUtils exposing (testLinkify) + +import Utils.String exposing (linkify) +import Test exposing (..) +import Expect + + +testLinkify : Test +testLinkify = + describe "linkify" + [ test "should linkify a url in the middle" <| + \() -> + Expect.equal (linkify "word1 http://url word2") + [ Err "word1 ", Ok "http://url", Err " word2" ] + , test "should linkify a url in the beginning" <| + \() -> + Expect.equal (linkify "http://url word1 word2") + [ Ok "http://url", Err " word1 word2" ] + , test "should linkify a url in the end" <| + \() -> + Expect.equal (linkify "word1 word2 http://url") + [ Err "word1 word2 ", Ok "http://url" ] + ] diff --git a/src/alertmanager/ui/app/tests/elm-package.json b/src/alertmanager/ui/app/tests/elm-package.json new file mode 100644 index 0000000..abf572d --- /dev/null +++ b/src/alertmanager/ui/app/tests/elm-package.json @@ -0,0 +1,22 @@ +{ + "version": "1.0.0", + "summary": "Test Suites", + "repository": "https://github.com/prometheus/alertmanager.git", + "license": "Apache-2.0", + "source-directories": [ + "../src", + "." + ], + "exposed-modules": [], + "dependencies": { + "elm-lang/core": "5.0.0 <= v < 6.0.0", + "elm-community/elm-test": "4.0.0 <= v < 5.0.0", + "elm-lang/dom": "1.1.1 <= v < 2.0.0", + "elm-lang/html": "2.0.0 <= v < 3.0.0", + "elm-lang/http": "1.0.0 <= v < 2.0.0", + "elm-lang/navigation": "2.0.1 <= v < 3.0.0", + "elm-tools/parser": "2.0.0 <= v < 3.0.0", + "evancz/url-parser": "2.0.1 <= v < 3.0.0" + }, + "elm-version": "0.18.0 <= v < 0.19.0" +} diff --git a/src/alertmanager/ui/bindata.go b/src/alertmanager/ui/bindata.go new file mode 100644 index 0000000..48d9125 --- /dev/null +++ b/src/alertmanager/ui/bindata.go @@ -0,0 +1,527 @@ +// Code generated by go-bindata. +// sources: +// ui/app/script.js +// ui/app/index.html +// ui/app/favicon.ico +// ui/app/lib/bootstrap-4.0.0-alpha.6-dist/css/bootstrap.min.css +// ui/app/lib/bootstrap-4.0.0-alpha.6-dist/css/bootstrap.min.css.map +// ui/app/lib/font-awesome-4.7.0/css/font-awesome.css +// ui/app/lib/font-awesome-4.7.0/css/font-awesome.min.css +// ui/app/lib/font-awesome-4.7.0/fonts/FontAwesome.otf +// ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.eot +// ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.svg +// ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.ttf +// ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.woff +// ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.woff2 +// DO NOT EDIT! + +package ui + +import ( + "bytes" + "compress/gzip" + "fmt" + "io" + "io/ioutil" + "os" + "path/filepath" + "strings" + "time" +) + +func bindataRead(data []byte, name string) ([]byte, error) { + gz, err := gzip.NewReader(bytes.NewBuffer(data)) + if err != nil { + return nil, fmt.Errorf("Read %q: %v", name, err) + } + + var buf bytes.Buffer + _, err = io.Copy(&buf, gz) + clErr := gz.Close() + + if err != nil { + return nil, fmt.Errorf("Read %q: %v", name, err) + } + if clErr != nil { + return nil, err + } + + return buf.Bytes(), nil +} + +type asset struct { + bytes []byte + info os.FileInfo +} + +type bindataFileInfo struct { + name string + size int64 + mode os.FileMode + modTime time.Time +} + +func (fi bindataFileInfo) Name() string { + return fi.name +} +func (fi bindataFileInfo) Size() int64 { + return fi.size +} +func (fi bindataFileInfo) Mode() os.FileMode { + return fi.mode +} +func (fi bindataFileInfo) ModTime() time.Time { + return fi.modTime +} +func (fi bindataFileInfo) IsDir() bool { + return false +} +func (fi bindataFileInfo) Sys() interface{} { + return nil +} + +var _uiAppScriptJs = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\xfd\x7d\x77\xdb\x36\xb2\x38\x8e\xbf\x15\x9a\xbf\x5e\x15\x58\x8d\x15\x29\x49\x77\xef\xa5\x8c\xf8\xe4\xb1\x4d\x9b\x38\x69\x92\x36\xbb\xab\xf8\x2a\x34\x05\x49\xac\x29\x40\x01\x41\x39\x8e\xad\xf7\xfe\x3b\x78\x24\x48\x51\x76\xda\xed\xd9\xbb\x9f\x73\xbe\xfe\xc3\x22\x41\x3c\xcc\x0c\x06\x83\x01\x30\x33\x40\xf3\x8a\x65\x32\xe7\x0c\xe1\xab\xb8\x2a\x69\x54\x4a\x91\x67\x32\x1e\xbb\xf4\x48\x22\x89\xaf\xfc\x9b\x40\x02\x5f\x09\x2a\x2b\xc1\x22\x5f\x94\xfa\x24\x89\x04\x50\xbc\xdd\xda\x57\x31\x48\x45\x2e\x2f\xc9\x5d\x10\x03\x95\x9b\x48\x10\xdb\xa0\xae\xdf\x51\xb3\x4f\x62\xcd\xc6\x80\xe1\xed\x4e\x7b\xf7\x3a\xdb\xa3\xff\x62\x7b\x3e\x89\xb7\x41\x00\xae\x80\x68\x43\x71\xbf\x13\x0a\xf6\xe7\x43\xe1\x93\xb2\x5d\xc0\x20\xd3\xa0\xb5\x61\xfb\xae\x13\x36\xfe\x6f\x81\xcd\x27\x55\x5d\xe0\x42\x65\x00\x6e\x43\xfc\xd7\x4e\x88\xb3\xff\x2b\x88\x7d\xd2\xb4\x1b\x09\x98\x5a\x34\xda\x78\xfc\xad\x13\x8f\xea\x3f\x08\x0f\x9f\x94\xef\x43\x0d\x72\x87\x5c\x1b\xbb\xff\xee\xc4\x6e\xfa\x9f\x8d\x9d\x4f\x4a\xf7\x23\x0c\xa9\x47\xb9\x8d\xf3\xff\x74\xe2\x9c\x23\x09\x4a\x18\xba\x1a\xef\x12\x42\xa4\x29\x71\x2c\x75\x7e\x2d\x2b\x13\x89\x04\x46\x14\xd7\x05\x53\x53\x10\x6a\xf4\xef\x75\x16\x05\xe6\x0b\x23\x16\x94\x2f\x5d\x79\xa8\xa9\x75\x7f\x4f\x0d\xc0\xc3\x3a\x10\x0f\xaa\x99\xd7\xd5\x40\x4d\xe3\xef\xf6\x56\x04\x59\xab\x2a\x94\x05\xb5\x15\x61\x6d\x50\x77\xd0\x5f\x6f\xa8\x0f\xaa\xdd\x1a\x51\x15\x54\x3a\x6b\x56\x0a\x75\x27\xff\xed\xc6\x6a\x61\xda\x59\x31\x9a\x06\x75\xaf\xdb\x75\x43\xcd\x2f\xff\x7d\x4b\xed\x90\xef\xab\x1f\xe5\x78\xbb\x49\x45\xb4\x24\xc1\xbc\x1b\x4e\x50\x20\xf0\x55\x3e\x47\xf2\x68\x78\x7d\x2d\x1f\x90\xe7\x48\x60\x2c\x97\x82\x5f\x44\x8c\x5e\x44\x4f\x85\xe0\x02\xc5\xcf\xd9\x8c\x7e\x8e\xe2\xbe\xec\xc7\x51\x5e\x46\xbc\x92\x11\x9f\x47\x22\x65\x0b\x3a\x88\x1e\x2f\x69\x76\x1e\xc9\x25\x8d\x0a\xca\x16\x72\xa9\x3e\x5d\xf2\x4a\x44\xa9\x10\xe9\x65\x34\xcf\x45\x29\x23\x2e\x22\x35\xd9\x2f\xa8\x7c\x99\x5e\x9e\x51\xf5\xbe\xa0\xf2\x7d\x2e\x97\x4f\xe8\x3c\xad\x0a\x39\x88\xf1\xd8\x62\xcb\x34\x54\x8d\x09\x4c\x41\x39\xe7\x02\x29\x54\x28\x11\x83\x25\xcd\x17\x4b\x39\xa6\x0f\x86\x63\x7a\x78\x58\x7f\x63\x44\x3e\x78\xf0\xdd\x5f\xe8\x58\x0c\x0c\x30\xe5\x84\x9d\x1e\x11\x39\xc6\xac\xdf\x1f\xb3\x07\xc3\x5e\x0f\xc9\x43\x12\x7c\x3d\x1c\x9d\x62\x10\x44\x0c\x64\x7a\x56\xd0\x09\x3b\xad\x07\x9b\x49\x91\xa7\x8d\xe9\xaa\x31\xc4\x34\xd5\x9e\x23\x8a\x8f\x88\x3c\xa6\x49\x66\x3f\x37\x66\x0b\x53\x20\x9f\xa3\x21\x21\x04\x51\xf2\x02\x51\x8c\x2d\x02\x98\xfa\x46\x88\x18\xd3\xa2\xa4\x57\x06\x8b\x57\x48\x02\xc5\x35\xc0\xb4\x05\x30\xf5\xe0\x12\xdb\x84\x4f\xc0\x0e\x01\xda\x10\xf6\x20\x02\xa8\xc9\xf0\xf8\xe7\x64\x8a\x04\xbc\x4c\xe5\x72\x30\x2f\x38\x17\x48\x3f\x16\x7c\x81\x24\xbe\xe3\x9f\xbf\x60\x0c\x43\x90\xb8\x21\x59\x9d\xb0\xb0\x38\x05\x5d\xc3\x89\x62\x9a\x87\xaa\xdf\x11\x62\x87\x14\xff\x17\xfa\xd2\x1f\x61\x0c\x19\x19\x8e\xb3\x23\x6e\xb1\x18\x67\xfd\x3e\xe6\x93\xec\x94\x48\x44\xfb\x99\xeb\xf8\xab\x4c\x72\x91\xc4\x53\x5d\x3e\x06\x43\xa2\x64\x08\x1a\xb3\x84\x6f\xb7\xae\x99\x8a\x68\x00\xd7\xfc\x02\x7d\x01\x81\x21\x6c\x56\x7f\xc9\x68\x5e\x18\x00\xee\x54\x18\x43\x1e\x7c\x77\x30\xec\x87\x49\x63\x78\x38\x02\xda\xcf\xfe\x52\x19\x0a\xad\x72\x86\x68\x1f\x65\xfd\x11\xfe\x4b\x05\x4c\x55\xa9\x72\x3e\x47\xaa\x00\xee\xa3\xec\xc1\xf0\x38\x9f\x64\x87\xa3\xd3\x64\x78\x33\x36\xc2\x61\x03\xb6\x43\x93\x7c\xdb\x90\xc4\x9a\xac\xf1\xe4\x34\xd6\x43\x5e\xd5\x81\x6d\xb7\xfd\x3c\x76\xf8\x8b\x00\x9f\x2f\x18\x28\x99\x9c\x02\x23\xc3\xb1\x2a\x76\xe0\x8a\x8d\xb1\x50\xec\x21\x07\xd3\x21\x48\xf5\x33\x82\x7e\x9f\x11\x42\xbe\xf4\x7a\xa8\x44\x9c\xdc\x4c\x6e\xb1\x05\xaa\x06\x46\xa3\x25\x46\x86\x78\x9c\xcf\x11\x7b\x30\xc4\x57\xa6\xc3\x6f\xa9\x65\x50\xae\x8b\x3c\xa3\x68\xa8\xd4\xe6\x71\x89\xb8\x1e\x1e\x16\x0f\xd3\x03\x8e\xb7\x0f\x47\xba\x0f\xe8\x24\x3b\x35\xcc\x6c\xd3\xd5\x18\x28\x91\x4a\x56\x43\xc2\xf4\x3f\x9d\xd4\xa5\x4e\x9d\xdc\xa8\xec\xa8\x52\x05\x46\x84\x90\xaa\x51\xcd\xb1\x7d\x9d\x0c\x4f\x93\xaa\x35\x79\x19\x64\x28\x91\x4e\xb0\xe4\x73\xe4\x64\x04\x21\x84\x62\x3b\x2c\xbb\x91\xa5\xfd\x91\x45\x77\x72\xea\xbb\x75\x72\xba\x1d\x8b\xc1\xba\x2a\x97\x6a\xae\x14\x13\xea\x90\xd2\x49\xd2\x20\xc2\xc9\x73\xf5\xa8\xbf\xda\x82\x01\xd2\x88\xf7\x49\xf8\x69\xd2\x91\xcf\x88\xaf\x30\x5d\xd7\xcf\x6d\x62\x48\x00\xdf\xf5\xea\x8b\x1a\x36\xea\xf7\x77\xa2\xd4\x9e\xae\x1d\xe1\xf4\x6c\x5b\x0b\xf0\xaa\x28\x0e\x08\xa1\xc7\x34\xf9\x05\x09\x78\xad\x3e\x3a\x89\xd7\x9e\xa2\x6b\x31\xe2\x72\x34\xe5\xaf\x05\xfe\xe8\xcb\x31\xba\x9d\x67\x6d\x91\x52\xb3\x1c\xde\xe2\x26\xc9\x95\xee\xa1\x40\x1b\xd7\x30\x7f\x52\xd3\x9d\xe6\x68\x0b\xb2\x6d\x1d\x71\xf2\x42\x7d\xb2\x2c\xc3\x1b\xb0\x1c\x8e\x4e\x09\x05\xee\xbb\x85\xef\xf6\x49\xbf\x0f\xdc\x30\x51\x13\x09\xc7\x48\x21\x49\x0e\x47\x4a\x82\xa9\xe6\x1c\xfd\x78\x08\x37\xc3\x75\x53\xb6\x73\x6f\x6c\xf9\x39\x52\xf2\x89\x6f\x83\xbe\x68\x28\x30\x7e\x1a\x58\xa3\x1f\x07\x27\x79\xd1\x90\xee\xeb\xdd\xa9\xb6\x89\xf9\x98\x3e\x20\x66\xce\x95\x24\xec\xb5\xe3\x1f\x07\x8f\x39\x2b\x1d\xc2\x8a\xc3\x24\x4e\x74\x75\x3e\xc5\xe3\x27\xeb\x06\x97\x21\x17\xed\x11\x99\xb6\x09\xdb\xc9\xb5\x40\x6a\xc2\x86\xd5\x78\xab\x05\x00\xf2\x53\x66\x3d\xdb\xe3\x71\xad\x27\x0c\xc7\xec\xa8\x59\xc1\x98\x29\xe9\x53\x4f\xac\x0d\xf4\x24\xaa\x35\x04\x9c\x2c\x03\xbc\x58\x8d\x57\x30\xe3\x6e\x1a\x33\xee\x4a\x4f\x9a\xc3\x80\xd0\x2b\xa7\x18\xdc\x24\x58\xfe\x20\xe6\xec\x26\xcc\x39\x19\x8e\x79\x1b\x73\xde\xef\x63\xe6\x78\xbd\x85\xb9\x5a\x56\xd0\x3e\xf7\xf8\xf2\x53\x9c\xac\x02\xfc\xf9\x29\x0c\x09\xe1\xc7\x34\xa1\xfd\x5a\xaf\xe2\x4a\x30\x79\x79\x50\xe3\xbd\x68\x29\x44\xd4\x8d\x7a\x05\x9f\xe9\x15\xba\xdb\x2b\x82\x68\x28\x3c\xc5\x95\xac\x51\xda\x52\xd4\xec\xcf\xce\x92\x8b\xb6\x7e\xe4\xa0\x0a\x96\x4e\x67\x37\x43\xd5\xae\xf7\xf0\x70\xfc\x35\x20\x75\x17\x3b\xfb\x0a\x78\x2e\x77\xf5\x4c\xa5\x07\xf6\x89\xd2\x35\x31\x08\xfd\x2a\xdc\xeb\x05\x92\xf0\x4e\xaf\xed\x02\x06\x7b\x57\xab\xf6\x84\x18\xb5\xde\xb5\x33\xee\x96\xb8\xfb\xc5\xab\x13\xa4\xa4\x29\x60\x95\x62\x08\xdc\x4a\xd3\x57\xba\x3d\x60\xe4\x1d\x92\x87\x88\x3e\x18\x1e\xd7\xcc\x40\x8d\x62\xd4\x10\x05\x8e\xd2\x0e\x2a\x36\xbe\x49\x9f\x68\x8d\x84\x36\x1c\x14\xfb\x49\xca\xb7\x1a\x7c\xdc\x7a\x46\xdc\x51\x2c\x10\xf7\x30\x11\x16\xc8\x74\xaa\xb4\x3b\x86\xfb\x1a\x13\xde\xc6\x44\xc9\x57\x4f\xe9\x8b\xc6\x34\x26\xff\x74\x32\xfb\xa1\x66\xa1\xe8\x8f\x3a\xa8\x7e\xf1\xd5\x54\xa7\x1a\xa4\xa6\x54\xff\x13\x3a\x81\x76\x40\xe9\xfa\x64\x9f\xe0\x3a\x54\x5d\xc3\xbd\x5a\x46\xd8\x38\xd0\x0c\xa1\x22\xc3\x71\x75\xd4\x9c\x7a\xc7\x55\xbf\x8f\x33\xc5\xf8\xae\x58\x75\x1a\xcc\x8f\x93\xea\x94\x64\x7e\x16\xad\xbb\xe8\xbc\xd9\x45\x4d\xe9\xb9\xdb\x5f\x5d\x9f\xa5\xa5\xf8\x5b\xa3\xe9\x28\x42\x4e\x86\x4d\x05\xab\x4f\x27\xa3\x66\xca\x11\xf9\x52\xcb\x94\x76\x76\x57\xb3\x2a\xe5\x87\x43\xbb\x86\x3a\xd3\xf0\xb4\xd9\x68\x58\x61\xc6\x59\x96\x4a\x54\x97\xc6\xa0\xbf\xba\x49\x21\x5c\x20\x3f\xd7\x75\x28\x95\x43\x4d\x04\xba\x48\x53\x89\xd0\xb3\x41\x98\x3e\xe1\xa7\x7d\xc2\xc6\xba\x46\x37\xb3\x84\x2f\x8d\xe6\xdd\x84\xb3\x0d\x00\xdf\x3a\xc0\x6b\x78\x4c\x27\x3f\x34\xc4\xcc\x1e\x7c\xaf\x26\x6c\xf2\x58\xe7\x02\x55\x0f\x64\xd8\x57\xf1\x4b\x9d\x1c\x08\xb8\xb7\xad\x3e\x35\x75\xf7\x7a\x1d\x43\x6e\x22\x41\x68\xea\x8d\x0e\xea\x9c\xd7\xd7\xea\xcd\xe7\x54\x82\xd2\x3e\x87\x15\x48\xf2\x42\x69\x8e\x42\xeb\x67\xf0\x19\x49\x40\x8a\x07\x3e\xa9\xc4\x67\x4a\xa8\x62\x05\x15\x3c\x52\xe2\x57\x91\xd5\xcc\x01\x41\x65\x0f\x7c\x55\x9f\x91\xad\xac\xae\x41\x60\xac\xfb\x42\x90\x27\x9a\x7a\x1a\x47\x9b\xbf\x3f\xc2\xf5\x8e\x80\xe1\xbb\x67\xc8\xc0\x81\xf5\x4a\xac\x8b\xa7\x8e\x87\xc9\x48\xf5\x2c\x21\x84\x1d\x8f\x92\xe1\xd8\x00\xc6\x4e\x31\x48\xdd\x06\x57\x6d\xf0\xa0\x8d\x6d\xe7\xa0\xb8\xbe\xde\x3b\x12\x0c\x31\x1b\xfd\x67\xfb\x29\x3b\x22\xdf\x1f\xeb\xcf\xc9\x63\x3d\x81\x85\xfb\x71\x9f\x9b\xeb\xac\x96\x56\x29\x6b\x29\x2c\x40\x36\xa5\xb0\xc0\x8d\x94\x3e\x51\x62\x4e\xb6\xc4\x5c\xdd\xd0\x23\xcf\x17\xa2\x25\xed\xf1\x95\xac\x65\x4d\xd8\xcc\xd0\x34\x33\xae\xd5\xde\xe7\xa8\xce\xaa\x88\x3d\x1a\xb3\x23\xd9\x1e\x27\x5a\x5f\xec\x07\x79\x35\x99\x83\x8d\x27\x42\xb7\xba\x07\x1d\xba\xe5\x32\x9f\x4b\x64\xda\xb9\xa1\xce\x46\x15\xe1\xcb\x61\x08\xf2\xb8\x2e\x6b\xeb\x0d\x36\x12\x1e\xb6\xf5\xf8\x21\x18\x15\x49\x76\xa8\xbc\x7d\x52\x23\xd0\xfc\x5c\x2b\x65\x5d\xaa\x72\x3f\xd8\x35\x6b\x7e\x76\x32\xb3\x29\x1e\x5b\xc2\x1f\x05\x9b\x4f\x88\x1e\x8e\xf0\x9d\x2f\x58\x31\xa4\x47\xe2\xa4\xa5\x05\x51\x4f\xae\x63\x39\xa1\xa7\x89\x98\x50\x4f\x91\x60\x93\xee\x4d\xbd\x43\xd5\x2a\x41\x58\xb3\x0c\x09\x14\xd3\xa7\x75\xa9\x37\xae\x43\xdd\x94\xa6\x93\xed\xd4\xa8\x87\xdd\xf5\x35\xd5\x43\xa6\xd9\x79\xc7\xc3\xe4\x04\xf9\xc4\x9a\x13\x40\x21\x37\x7e\x13\x7c\x12\xf5\x27\xe0\x66\xc5\x56\x43\xf2\xd2\x2e\x1d\x8c\x92\x47\x86\x78\x7c\xd3\xea\xa8\x63\x71\x50\xeb\x3b\xed\x95\x50\x98\x09\x43\xb0\x5c\x79\xec\x48\x5d\xcf\x13\x2f\xbd\x08\xab\xf7\xc0\xbe\xc0\xcd\x5d\xaa\xb4\x51\x1e\x96\x64\xad\x2e\xbf\xbd\x78\x46\x86\xe3\x93\x9d\x0e\xc8\x70\x23\xe7\x7f\x7d\x21\x64\x38\xc6\x6f\x90\xad\x1f\xb8\xcb\x07\x5d\x65\x31\xbc\xa9\x17\x45\xb5\xb6\x60\x73\xef\x76\x8a\x2a\x91\xf5\xfb\xe3\x7a\xbf\x31\x83\xa9\x26\x5e\x8d\xda\xe1\x08\x86\x18\x72\x32\x1c\x67\x87\xd5\x21\x9a\xb6\x64\x8d\x12\xbe\xf8\x88\x8e\x8d\xc4\x4b\x49\x17\x58\x50\x92\x9a\xb2\x87\xcd\x1a\x20\x6d\xca\x5e\x35\x7b\xd9\x1c\x64\xda\x9c\xf5\xd3\x86\x1e\x96\x43\x89\x31\x4c\xeb\xa9\xd6\x21\x31\x27\xd3\x16\xbf\x42\x41\xe6\xe3\xe2\x68\xde\x2f\x0f\xf3\x71\xd1\xef\x63\x9f\x61\x52\x28\x89\x68\xdb\x99\x14\xa7\xaa\xc2\xfa\x53\x9f\x14\x0f\x86\xc7\x41\x8a\x96\xc0\xe3\xbc\x4f\xca\x16\xd8\x47\xa4\xec\xf5\x50\xd6\xef\x2b\x42\xa9\x4a\x3a\xf6\xa3\x9e\x22\x06\x5c\x1f\x91\xc0\x94\xb4\xe9\xab\xd4\x3d\xbd\x5d\xd8\xa6\x6f\xb3\xa0\xca\x36\xce\x8e\x6e\xe4\xae\x31\x76\x05\xba\x59\x44\x41\x59\xf5\xfb\x76\xe8\x4c\x18\xf0\x40\xa6\x7c\x0a\xf6\x4d\x9c\xb0\x6c\x4f\x62\x41\xf6\x67\x1d\xd9\x87\xc1\x77\xa5\x06\x5c\x99\x9d\xdc\x3d\xa3\xba\xa9\x6a\xcb\xd6\xc6\x56\x2d\x60\x83\x65\xbf\xe7\xdf\x40\x30\xd9\x02\x38\x3c\x27\x7c\x1e\x00\x17\xaa\x4e\xc7\x4d\x84\x92\x7a\xb2\x69\x0b\xba\x06\xae\xaf\xda\x53\x8d\x3e\x81\xf1\x47\x34\xc1\x7a\xc4\x1c\xc4\x50\x4f\xe3\x70\xbf\xe4\x75\x63\xbf\x44\x2b\x1f\xc7\x37\x6f\xf6\x4d\xe4\xe9\x36\xb9\x79\x93\x7d\xf2\xda\x6c\xe5\xe3\x60\x0f\x73\x74\x1a\x4c\x93\x4f\x1a\xad\x8a\x06\x31\x6e\xab\xfb\xc9\x6e\xdd\x8a\xb2\x61\xf5\xbf\x84\xd5\xdf\xdc\xd1\xf5\x7e\xab\xd2\x9f\x9a\x55\x82\xfa\xd7\x57\x1a\x4a\x58\xf9\xaf\x35\x0f\xd5\x62\x5d\xe5\xf4\xfa\xd8\x7b\x24\xf4\xe1\x4d\xd8\xf9\xef\x77\x05\xfd\x9e\x9d\x93\x70\x1f\xe4\x58\x4e\x44\x5f\xe9\x33\x7e\xbe\x4f\x74\x45\x7d\x64\x34\xcd\x61\xb2\xff\x80\x2a\x98\xd9\x7e\xd8\xe1\x3c\x3b\x71\xfe\x9c\xfc\x86\x64\xf7\x61\x94\x13\x80\x3b\x67\x52\x7e\xf3\xcb\x57\xff\x5b\xc7\xd1\xd4\xd7\x9c\x2c\x49\xbf\x84\x65\x78\x1b\x6c\x94\x35\x0f\x99\xb2\x1b\x0e\x99\x38\xc6\x50\x05\xdf\x33\x07\x1c\x4c\xc9\x70\x3c\x3d\x72\xef\xe3\xa9\x5a\xbe\x4e\xa6\xa7\xe4\x37\x7f\xc8\x34\xfd\x0b\x6f\x1c\x32\x4d\xfb\x23\xfc\x17\xae\x0f\x99\x2a\x95\xf3\x39\x52\x05\x70\x1f\x4d\x1f\x0c\x8f\xab\xc9\xf4\x77\x1c\x32\x65\x9e\x8f\xaa\xad\x3e\x05\xfe\x42\xee\xdd\x85\xef\xc9\x5d\xf8\xf9\x96\x9d\x74\x7d\x7a\x61\x5a\xa0\xab\xb5\xbc\x4c\x7e\x86\xb9\xe0\xab\x17\x79\x29\x93\x14\x24\xd7\x0f\x33\xc8\x59\x2e\xf3\xb4\xc8\xbf\xd0\x44\xa2\x0a\x43\xba\x5e\x53\x36\x4b\x24\x3a\xc7\xb0\xae\xca\x65\x22\xd1\x1c\x83\xa6\x6e\x22\xd0\x25\x86\x05\x95\x89\x44\x14\x43\x49\x65\x22\x10\xc7\xb0\x4a\xd7\x89\x44\x4b\x0c\x39\x9b\xd1\xcf\x74\xf6\x52\xbf\x6f\x30\xcc\x79\x31\x2b\x12\x81\x16\xe6\x51\x24\x02\x9d\xb9\x2d\x85\xe4\x39\x48\xfe\xe3\x5b\x0d\x7b\xf2\xab\x06\xcd\xbd\xfd\xb0\xdd\x22\x0c\x9b\x9b\x8e\xbb\x9d\xf0\xbc\x23\xae\x87\x3b\xa7\xcc\xee\xe3\x7f\x89\xd6\xb1\x6f\xc0\x54\x3b\xe7\xe3\x8f\x53\xc6\xb8\x8c\xd6\x54\xcc\xb9\x58\x45\x2b\x3e\x8b\x86\x83\xe8\x49\xbe\xc9\x4b\xbd\xbd\x78\x19\x7d\xa1\x82\x47\x54\xe5\x1e\xc4\x4e\xa1\x93\xff\x25\xec\x3a\x4e\x1e\x0f\x13\xa1\x56\x35\x0f\xc8\xd0\x6c\xa4\x26\x87\x1c\x1d\x4a\x38\x0c\x0e\x55\xb4\x4c\x1c\x26\xac\x75\xba\xec\x41\xf6\x03\x44\x04\x83\x25\xdc\xdc\xaf\xea\xe1\x77\x28\x5b\xb6\x32\xf5\x46\xe3\xf1\xa1\x4c\x64\xcb\xaa\xa4\xde\xc8\x1e\x64\x2b\x73\x46\x70\x34\x3c\x96\x89\x68\x19\x91\x74\xe4\x7b\xd0\xca\x57\xb6\x94\x7a\x93\x93\x82\x34\x35\xba\x57\x5d\x50\x24\x74\xe7\xbc\x29\xe4\xfb\x77\x93\xba\x9d\x7e\x43\xb0\x17\xcd\xce\x54\x0b\xfd\xce\x43\x90\x03\xd9\x38\xfb\xa8\x4b\x10\x42\x46\x77\x86\xd7\xd7\xea\xe1\x70\x74\x67\xd8\x38\xb1\xa8\x85\xd8\xb5\x6c\x6c\xf9\xd7\xe5\xff\xa2\x7b\xe0\xf5\xf3\x3b\xa3\xff\x1e\x36\x76\xbf\x6b\xf3\x1c\x97\xe5\x2f\xb2\xb1\x11\xed\x84\xba\x3e\xb8\xa5\xfa\xe0\x76\xec\x69\xf5\xae\x5a\x17\xf4\x2e\x12\xa6\x6c\xc6\x4b\x35\x96\xec\x5b\xa9\xe4\x47\xb8\x90\xb8\xfc\xba\xca\x4c\xe1\x4f\x42\x22\xf1\x17\xd1\xa7\x7f\xa1\xd8\xc8\xa3\x54\xa6\xec\xae\xee\x0a\x63\x42\xf2\x8e\x4c\xe2\x17\xef\x62\x88\x9f\xfe\x1c\x43\xfc\xfd\xbb\xd8\x1d\xbc\x5e\xcd\xf2\x8d\x19\xd5\x82\xae\x12\x89\x18\x86\x15\x57\x52\x80\x63\x58\xe7\x89\x45\x13\xa8\x79\x7a\x0a\x19\x2f\x13\x07\x3f\x94\x39\x4b\x1c\xf8\x20\x53\xfb\x22\x53\x06\xa9\xcf\xa7\x9e\x20\xf5\x39\xd5\x13\xa4\x3e\x6f\xaa\x33\x2b\x60\x13\x89\x6a\xc8\x31\xcc\xe8\x42\x50\x5a\x26\x1b\x50\x50\x96\xc9\x42\x0b\x8a\xd7\xbc\x48\x45\x72\x06\x92\x9b\xa7\x4b\x50\xb8\x27\x9e\x0a\x50\xf0\xc5\xa3\xb4\x54\x12\x2d\xc3\xc0\xe8\x22\x95\x34\xa9\x20\x3d\x2b\x93\x29\xac\x72\x96\x48\x94\x2b\xb1\xf5\x39\x91\x28\xc5\x90\x15\xe9\x6a\x9d\x08\x54\x62\xc8\xf8\x6a\x9d\x0a\x6a\x84\xde\x67\x2e\x12\x89\x0a\x0c\x8c\x2b\x49\x29\x45\xa5\x94\x75\x9a\x2c\x41\xcd\x1b\x39\x5b\x24\x7e\x12\x01\x3d\xe7\x25\xf5\xf4\x07\x82\x57\x6c\x66\x12\xf4\x23\x48\xfe\xac\xe0\xa9\x4c\xbc\x54\x0b\x58\x6d\x0b\x79\x79\x92\x9e\x24\xfa\x3f\xe4\xe5\x73\x36\x57\x72\x99\x26\x6b\x2d\x0a\x57\x9d\xa2\x50\x34\xb5\x36\x06\x9c\x4c\x4e\x21\x23\xd4\x9c\x54\x01\xc7\xe3\xac\xd7\x43\x8c\xf0\xc1\x9a\xaf\x11\xc6\x63\xac\x3e\xb2\xc1\x67\x60\x83\x4b\x93\xc1\x6d\xfb\x6c\x9b\x02\xd6\xd8\x81\x69\x2b\x81\xd1\x70\x88\xfd\x99\xa6\x3e\xbb\xbc\xfa\x9c\x48\xb8\x4c\xc4\x16\xc3\xc1\x70\x6c\x4f\x27\xdc\x34\x6d\x52\x62\x7e\xf6\x1b\xcd\x64\x7c\x40\xe4\xe5\x9a\xf2\x79\x64\x6d\x22\x5c\x2b\x31\xa9\x3f\xb4\x25\xf1\xb7\xef\xc4\x65\xce\x16\x91\xe4\xda\xdc\xe8\x23\x22\x04\x7f\x8c\x78\x6d\x71\x57\x0e\xa2\x77\x4b\x2a\x68\x94\x97\x11\xe3\xd1\x45\x7a\xa9\xf2\x9e\x33\x7e\x11\xe5\xf3\x3a\x57\x94\x0a\x1a\xc5\x72\x49\xa3\x32\x5d\xd1\x38\xca\x99\x36\x70\x7a\x5a\xac\xa2\x92\xb2\x92\x0e\xa2\x37\x34\x9d\x45\x2b\x2e\x68\x94\x9e\xf1\x4a\x46\x72\x99\x97\x51\x2a\xa3\xa5\x94\xeb\xe4\xce\x9d\x75\x9a\x9d\xa7\x0b\x3a\xa0\xc5\xea\xb0\x48\xd9\x62\xc0\xc5\xc2\x25\x96\x77\x5c\xea\x9d\x8c\x0b\x7a\xa7\x48\x25\x2d\xe5\x9d\x47\x69\x99\x67\xe5\xff\x8f\x90\xe8\x62\x99\x67\xcb\x68\x46\xcb\x4c\xe4\x67\xb4\x8c\x2e\x96\x97\x51\x2e\x15\xc8\xba\x15\x05\x74\xca\x66\xd1\xc5\x32\x95\x1a\xac\x33\x2a\x25\x15\xd1\x86\x0a\x3d\xdd\x5c\xe4\x45\x11\x15\x9c\x9f\x47\x45\x7e\x4e\x07\xdf\xba\x9e\x3a\x18\x6d\xed\x49\xb7\x9a\x72\xae\xaf\xed\x93\xa7\xfe\x48\xf7\x47\x94\xb3\x52\xa6\x2c\x53\x04\x7e\x92\x4a\x7f\x40\x23\x07\x0b\x2a\xdf\xe5\x2b\x8a\xb0\xde\x1a\xf4\x6f\xaa\xd4\x01\x8a\x95\x44\x8e\x15\x9d\x70\xcd\x56\x99\x26\x1c\x56\x19\x28\x92\x93\xec\x14\x84\xfa\xc7\xfa\x23\xe0\xb8\x6e\xd6\xf5\xbe\x02\x2f\x7e\xf3\xe8\x84\xcf\xe8\x94\x16\xab\xe9\x59\x95\x17\x32\x67\xb5\x4d\x4b\xaf\x17\xbf\x79\xf4\x54\x29\x24\xdd\xdf\xaf\xaf\x91\x24\x2f\x84\xdd\xb1\x15\x7a\x97\x23\x7e\x4b\x65\x23\x37\xa9\x6b\x53\xb9\x99\xcd\xcd\x4c\xee\x24\x09\x2c\x6f\xae\xea\x1d\x00\x09\x53\x22\xc6\xf6\x73\xe5\xa0\x31\xaf\x53\x6b\x70\x73\x65\x10\xad\x94\xb0\x9d\xaa\x7f\x6d\x44\x2b\x52\x0d\xa6\x23\x98\x92\xe9\x60\x3a\xda\x7a\xb3\x15\x55\xda\x57\xa3\x89\x60\xd5\xb2\x00\x12\x05\x45\x4e\x96\x03\xaf\xf7\x28\xb0\xd3\x46\x82\x39\x96\xc8\xad\xae\x79\x40\x48\xda\xdc\xb9\x3d\x18\x79\xe5\xb6\x24\xc3\x71\x79\xe4\xb2\x8e\xcb\x7e\xdf\x76\x52\x3e\x29\x4f\x21\x55\xff\x6e\xea\x24\xd5\x9b\x1a\x2e\x10\xe6\xa7\x9d\xf9\x8f\x32\x40\x5b\x1b\xeb\x16\x07\xc1\x24\x2d\x8e\x57\x89\x3c\x12\xc7\x9b\x64\xb1\xc3\xbd\x6f\xa5\xc8\xd9\xa2\xde\x73\xde\xa4\x45\x45\x5f\xcd\x11\x06\x4e\x44\xfd\xe6\x57\xa3\x84\x10\x7e\xbc\x4a\xe8\x11\x57\xd5\xe9\x7e\x08\xb9\xe1\xfa\xba\x69\x96\xa5\x99\x63\xdc\xc8\xe2\x39\x42\x04\x1c\x81\x32\xc2\x90\x9e\x80\xc5\x60\x3a\xc4\xf8\x80\x90\x95\x43\x21\x1b\x5b\xd3\x2c\x41\x44\xc0\x12\xd2\xb1\x84\xa9\xe7\x78\x95\x34\x9a\xf6\xe0\x4d\xf5\x14\x5e\x7f\xf0\x67\x9e\x7f\xc5\xf6\x88\x05\xaa\xe6\xa7\xbf\xe2\xc3\xa1\x3b\x6c\xaa\x1c\x14\x2b\x95\x52\x3d\x20\xa3\xaf\x80\xd7\xe4\xbc\xdb\xc8\x39\x52\x39\x47\xdd\x39\xef\x35\x72\xde\x55\x39\xef\x76\xe7\xbc\xdf\xc8\x79\x4f\xe5\xbc\xd7\x9d\xf3\xbb\x46\xce\xfb\x2a\xe7\xfd\xee\x9c\x7f\x6d\xe4\xfc\x4e\xe5\xfc\xae\x3b\xe7\xdf\x3a\xb4\x7a\x3d\x9f\xe7\xa5\x9a\xd8\x54\x4a\x12\x65\x46\xcf\xb7\x13\x7d\x24\x15\xf5\xcb\xe8\x22\x97\x4b\x33\x15\xc8\x65\xca\xa2\xbf\x46\xb4\xa0\x2b\xca\x64\x39\x88\x9b\x9e\x05\xab\xed\xd7\xb4\x51\xa7\xe4\x65\xc4\x59\x71\x19\xcd\xe8\x3c\x67\x74\xa6\xe6\xb1\x9c\xc9\x12\xa2\xb9\x52\x06\x4a\x88\x64\xbe\xa2\x25\x44\xd9\x32\x15\x25\x68\x4f\x1a\xb6\x28\x21\x2a\xf2\x52\x96\x11\x9f\xdb\xba\xd4\x8a\x2e\xd2\xec\x5e\x82\x9e\x38\x2c\xdc\x5d\x19\x14\xc8\xed\x75\x4f\x73\xa9\x69\xb4\xc6\x18\xa6\xc3\x44\xc2\x74\x94\x88\x6d\xcb\x39\xc2\xad\x57\xe8\x85\x1d\x81\xfb\x16\x21\xd1\x59\xbf\xdf\x32\x2c\xf5\x96\x40\xf5\x3a\x9c\x19\x11\xa2\x4d\x72\xe4\x84\x9d\x36\x3f\x08\xf3\x41\xa8\x0f\xbb\xbb\x4a\x79\x07\x02\x49\xd2\x0d\x7b\x5a\x4b\x1c\x43\xc8\x50\xcf\x70\xe3\xb2\xaf\x4f\x89\x3b\xcd\x33\x85\x5d\xd5\xe5\x66\xec\x5c\x62\x60\x84\x6a\x60\xcd\x10\x6f\x5b\x67\xb2\xc1\x74\x14\x64\xb6\x72\x80\x11\x16\xe8\xe8\x3a\x8f\x08\x37\xea\xcb\xc6\xc2\x26\x74\x66\xd8\x61\xad\x37\xa9\x66\x17\x1e\xa5\xd1\xc7\x27\xf4\xac\x5a\x0c\x32\x91\x96\xcb\x8f\x8a\x6c\x2b\x3e\xab\x0a\x1a\x7d\xd4\x26\xdd\x1f\xa3\xb8\x5f\x20\x81\xfb\xf1\x07\xf6\x6e\x49\xa3\x15\x2d\xcb\x74\x41\xa3\xb5\xe0\x9b\x7c\x46\x67\x6a\xfd\xaa\xd4\x8c\x8c\xcf\x68\x94\x56\x72\xc9\x45\x94\x97\xc9\x07\xf6\x81\x45\x51\x14\xc5\x7d\x1a\x1e\x3d\xcd\x5b\x0b\xbc\xd0\xbb\xe2\x5f\x80\x51\xb5\xf6\xce\x68\x3f\x65\x94\xa5\x55\x59\xc3\xf5\x31\x4b\x4b\xfa\x31\xa2\x9f\xd7\x82\x96\x5a\x03\x72\xf8\x0c\x3e\xb0\x57\x8c\x2a\x46\xd7\x6a\x92\x48\x59\xb6\xa4\x65\x44\x99\xc2\x4a\x0f\xdb\x34\xd2\x0d\x9a\x61\xb1\xa4\xd1\x9c\x17\x05\xbf\x50\x2a\xa4\x1e\x0f\xd1\x82\x2b\x15\x4b\xf0\x6a\xb1\x0c\x10\x9e\x21\xaa\xa9\xf5\x07\xe9\xc5\x70\x73\xa9\x1a\xec\x15\x97\x32\x15\x72\x50\xe4\x8c\x2a\x4e\xa1\x6c\xa6\x9f\x8f\x63\x95\x31\x67\x34\x8a\xfb\x61\x9e\x24\x3e\xa3\xf2\x82\x52\xf3\xb1\x6c\x7d\xed\xc7\x1a\x2d\x95\xe8\x2a\x6a\x2d\x82\xed\xe2\xd0\x72\xf9\xb8\xa5\x65\x7b\xcd\x30\x3e\x72\xa9\x0f\x62\x9d\xe9\x8c\xf3\x82\xa6\x8d\x3c\x91\x3c\x8e\xdf\x89\x8a\xc6\x49\xfc\x2c\x2d\x4a\x6a\x32\xb2\x6a\x75\x46\x45\x33\x5f\x3f\x8e\xf7\x4d\xd5\xb6\xb9\x6f\xe3\xbe\x5a\xd4\x1f\x0c\x71\x3f\xfe\xd6\x54\xe4\x87\xa4\xaf\xe8\xdb\xf8\x5b\x93\x6b\x84\xfb\xdf\xc6\xdf\x8e\x03\xd5\xd6\xd5\xa3\xde\xe3\x70\x49\xa1\x8a\xf7\x7a\x81\xaa\xea\x75\x03\x33\x45\x56\x67\xa6\x1d\x34\x84\xef\xb4\x32\x65\xc4\x5d\x6c\x6c\x80\xa7\x64\x72\xda\x16\x4b\xa6\xae\x03\x42\x58\xaf\x37\x35\x4b\x9c\x19\x52\x62\xca\x6f\xc3\xc6\x28\xee\x4f\x07\xbf\xf1\x9c\xa1\x18\x62\xdc\x8f\x71\x6c\xe7\xee\xb4\x3c\x8f\x03\x13\xa8\xf8\x48\xa6\xe5\xb9\xa5\xf0\x8e\x02\x68\xf3\xe8\xe4\x81\xdb\x8b\xd3\xac\xb8\x94\x7a\xd3\x57\x95\x3a\x9a\x51\xc5\x74\xe2\xc1\x6e\xc1\xfa\x93\xa9\xff\xb5\xe0\x19\x2d\xcb\x8e\x8c\x6b\xf3\x25\x51\x7c\x93\xcf\xfa\xb1\x2d\xd1\x54\x8c\xa7\x24\x9e\xa8\xc6\x95\xf8\xc2\x0d\x29\x17\xe6\x1b\xe3\x69\x9f\xc4\xe0\x33\x5a\x29\xe7\xc4\xdb\xb4\x1f\x9f\x1a\x62\x74\x08\x54\x95\xa6\x1b\xde\xab\xbf\xbb\x8c\x6f\xa9\x6c\x52\x44\xeb\xf4\x86\x22\x1d\xab\x89\x50\xa1\xeb\x5a\x4d\xec\xd4\xff\x24\xcf\xda\x0d\x08\xdd\xc0\x94\xc4\x71\xbd\x5f\xec\x55\x5d\xcf\x13\xdc\xd9\xb9\x28\x96\xe0\xa7\x18\x2a\x92\x4d\x86\xa7\x63\x45\x94\x28\xee\xa3\xf8\x4a\x2f\x26\xae\xaf\x63\xe4\x1e\x8e\xec\xc3\xb7\xf1\xb7\xe6\x21\x1b\xe8\x8d\xd1\x57\x73\x14\x47\x31\x3e\x1a\x1e\x67\x89\xe2\xa8\x4c\xf1\x11\x6e\xea\x8b\xfd\xe9\xb6\xc5\xeb\xc6\xfe\x6f\xcf\x8a\x2e\x3e\x52\x3d\x2c\xb9\x9d\xa4\xb1\xeb\x69\xa9\x16\xad\xd3\x0b\x7a\x36\x2d\x79\x76\x4e\xfd\x68\x3a\xba\xa0\x67\x26\xe5\x41\xac\xe7\xba\xae\xf1\x60\xc7\x00\xeb\xc7\x11\xd1\xa4\x6a\x8c\x05\xbd\xeb\xef\x0e\x0e\x8f\xe3\xab\x6d\x9c\xc4\x57\x51\x30\x3e\x22\x35\x40\xa2\x6d\xbc\x75\x6d\xe6\x4c\x52\xc1\xd2\x42\x29\x37\x55\x26\x2b\x41\x1f\xc4\x3b\xe6\xca\x6e\x10\x0b\xba\x2e\xd2\x8c\xa2\x3b\x1f\x3e\xdc\x59\x40\xfc\xe1\xc3\x87\x0f\x31\x0e\x52\x99\x49\x65\x8d\x44\x69\x12\x65\x23\x51\x98\x44\xd1\x48\xdc\x98\xc4\x4d\x23\x71\x68\x12\x87\xb5\xfb\x92\x38\xa6\xc1\xf7\x6f\xcd\xf7\x6f\x63\x9c\x84\xc9\xf1\x9d\x05\x7c\xfb\xe1\x43\xfc\xad\xd9\x5b\xdb\x90\xc3\x11\xac\xc8\x10\x16\x64\x04\x67\x64\x08\x97\x6e\x83\x7e\x72\x1a\xd7\x5b\xf1\x9f\x12\x01\xd9\x6a\x9d\x30\xd0\x5a\xd8\x30\x69\x28\x65\xc3\x78\x6b\xd2\xef\x26\x1c\xb2\xa5\x48\x32\xa8\xd6\xb3\x54\xd2\x64\x0a\x8b\x2a\x9f\x25\x55\xbd\x41\x9f\x62\xd0\x13\x5f\x52\x9a\xdf\xc7\x69\x49\x93\x39\x38\x6e\x48\x66\x7a\xef\x68\x41\x64\xed\xaf\x1d\x90\x5a\x38\x5c\x8d\x0d\xec\x74\xa8\xfe\x8d\xf0\x16\xc3\x19\x41\xa2\x51\x24\xb4\x62\x45\x1d\x3a\xa4\x50\x7a\x18\xdd\xaa\xb2\x7b\x0b\xea\x56\x40\xe0\x2d\xc6\x70\xb9\x03\x92\xdf\x07\xc3\xf0\x8e\x74\x6f\x90\x5d\x90\x8b\xeb\xeb\xab\xed\xf8\x62\x12\x1f\x5d\xc7\xa7\x7b\xab\x40\xaa\x0d\x40\x36\x3b\x9e\xc4\xd7\x0f\xf6\xe7\x56\x32\xa0\x99\xfb\x81\xca\xbd\x17\x0b\x81\xa4\xde\x9f\x6d\x14\x39\x3a\xba\xa9\x88\x44\x62\xb7\x48\xbf\x1f\x9f\x92\xd5\xc0\x74\xa5\x1e\x88\xe7\x64\xe5\xc7\x31\xbc\x25\x68\x33\xa8\x77\x01\x41\xbd\x9c\xa4\x27\xb0\x19\xd8\x4d\x44\x0c\x9f\x55\x16\xbb\x0d\x09\x1b\xb3\xe7\x88\xe1\x91\x4a\x75\xfb\x94\xb0\x31\x3b\x8f\x78\xbc\x19\x30\x2e\x61\x33\xf8\xcc\xc5\x38\xa4\x8c\xa2\xe3\x66\xc0\x45\x08\x5a\xaf\xa7\x13\x53\x0b\xd7\x43\xb2\x19\xac\xd2\xcf\x70\xa2\x6a\x5e\xe5\x0c\x36\x03\xbb\x74\xc2\x61\x55\x0f\x88\x2e\xb5\xa0\x0d\xc2\x98\xc4\xa2\x91\xf8\xc0\x64\x94\x8d\x8c\x26\x5f\x23\xed\x8e\x29\xcc\xe8\xa7\x30\x95\x98\x54\xfa\x69\xbc\x19\x28\x04\xd7\xb9\x86\xf2\x0d\xd9\x0c\xf4\x2e\x2e\x3c\x55\x70\xda\xed\x5f\xd8\x0c\xd2\xb3\x12\xc3\x4b\x5d\xcf\x22\x95\x74\xbc\x31\xfb\xc3\x1b\xb3\xbf\x6c\x7f\xd5\x4f\xa9\x51\xd3\xbb\xd4\x9b\x81\x49\x2b\x2d\xb6\x65\x88\xe8\xff\x9a\xf6\x3f\xaf\x43\xa8\xfe\x4b\x27\xae\xf8\x6c\xbc\x19\x08\xba\x0a\xf3\xdf\xb9\xa3\xbf\xcd\xf2\x4d\x03\x39\x9d\xa8\x97\x80\x4f\x9a\x5f\xfe\x62\xaa\xaa\x8a\x30\xf1\x50\x27\x96\xd5\x59\x83\x87\x4c\x3f\xcd\x54\xa3\x76\x23\x5c\x31\x82\xdb\x1e\x57\x68\x54\x82\x29\x74\xec\x26\xba\xa6\xd4\xe3\x5b\xc4\x41\xfc\x63\x55\xea\x89\x87\x9a\x6d\x0a\x25\x19\x12\x35\x2e\x3f\x39\x69\x76\xc2\xe5\x52\xe9\x71\x5b\x78\xf6\x3b\xeb\x92\x48\xd5\x86\x93\x4f\x5b\x0c\x2f\x3a\x86\xb9\x6d\x40\x97\xd2\xeb\xbb\xed\x16\x9e\xff\xce\x36\x5e\x20\xdb\x8a\x69\xe6\x55\xc7\xc0\x6c\xba\x6b\xec\xca\x31\x57\xb3\xfb\x44\x08\x61\x6e\x6b\xc8\xb5\xc6\x06\xd3\x61\x47\xda\xc8\x01\xa1\xc4\x9d\xce\x33\x1d\x82\x4e\xf7\x10\xfd\x48\x10\x6d\x81\x04\xac\xed\x89\xa7\x5b\xbe\x17\x00\x05\xd3\xbb\x09\x6b\x41\x76\x4f\x35\xca\xdb\x50\xf0\x0e\xc8\xb8\x83\xac\x99\x76\xd7\x41\xab\xd6\xcd\xdc\x42\xcb\x0d\xb4\xa0\xbf\x7b\xa8\xd9\x0e\xc8\xe0\x35\xa3\x06\xd0\xf7\xdb\x40\xc3\xf4\x5e\xc2\x5b\x90\xdf\x57\x00\x64\x6d\x88\xb2\x0e\xc8\xb3\x0e\xc8\x33\x07\x79\x33\xed\x9e\xc3\x46\xad\xaf\x33\x8b\x4d\x66\xb1\xc9\x0c\x36\xa0\xf3\x79\xac\x78\x07\x56\x90\x19\xbc\xaa\x26\x5e\xdf\x75\xe2\x05\xd3\xfb\x49\xd6\x42\xee\xbb\xc6\xee\xb2\x03\xb0\xea\x40\xae\xea\x40\xae\xea\x40\xae\x72\xc8\x35\xd3\xee\x3b\x84\xd5\x72\xbd\xb2\x08\x57\x16\xe1\xca\x22\x5c\x19\x84\x41\xe7\xf7\x88\x77\x1d\x27\x65\xbf\x63\xa3\xc5\x44\x9e\xf0\xae\xac\x97\xfa\x5c\xd2\x6e\x44\x53\xe3\x23\x93\x21\x69\x7c\x14\x3b\x7c\x63\xa6\xcd\xe2\x93\xd3\x1d\xb7\x57\xeb\xef\xd7\xb1\xe0\x10\x3b\xf1\x01\x42\x43\x98\x29\xa2\x7a\x6b\x18\x32\xe2\xac\x05\xc7\x99\x02\x88\x6b\x5f\x1f\x36\xc9\x4e\x83\x63\x2f\xbe\x13\x16\x20\xac\xab\x06\x4b\x38\xea\x9b\x57\xea\xb7\x7f\x34\x94\x7a\x87\xca\x2a\x50\x43\x8c\xed\x3e\x30\x50\x42\x03\xb0\xab\x46\xb8\x85\x75\x3d\xf0\x6b\x5b\x95\x5b\xda\xf3\xaf\xcc\x36\x6f\x8f\xe3\xd2\xb0\x79\x2d\x74\xda\x30\xb4\x76\xa4\xaa\x46\xc8\x86\x65\x38\xa0\x6b\xdf\x8d\xdf\x07\x8c\x7f\xe5\x16\xb6\xcc\xc0\x56\xee\xc0\xa6\xe5\xcc\x1e\x00\x81\x6b\x49\x55\xc3\x19\x1a\x9f\x6f\x9a\x43\xd4\x41\x3a\xfd\xd7\x20\xf5\xaf\x99\x5b\xec\x1a\xc0\xe7\xdd\x80\x6b\xb9\x72\x33\xf4\x90\x69\xa1\x55\x23\x11\x06\x88\x58\x34\xb4\xcf\x0a\x4d\x91\xc0\x83\x92\x8b\x60\x8e\xdb\x35\xac\x90\xda\x7c\xde\x28\x91\xb8\xe5\xf0\xf6\x15\x75\xd9\x98\x0a\x26\xb4\x84\xc1\xd2\xca\xab\xa7\x3f\xc7\xd6\xf4\x2b\x7e\xf1\xce\x3c\x1e\x8e\x92\xd1\xd6\x1a\x0b\x74\xae\x5f\x4e\xf2\x22\xb9\x84\xc7\x9c\x95\x49\x06\x99\xfa\xd1\x67\xec\x92\x1b\xd3\x9d\xa9\x3e\x9f\x37\xcf\x95\x37\xfa\x29\xb4\x8d\xd0\xdd\x44\xa0\x99\x7e\xba\x97\x50\xb4\xd6\x4f\xf7\x13\x86\x96\xfa\xe9\xbb\x84\xa3\x0d\x06\x85\xc0\xa3\xcb\x44\xa2\x85\x79\x7e\x9f\xcb\x65\x22\xd1\x19\x56\x8b\x19\x0c\xaf\x09\xfa\x71\xe0\xd2\xc1\x3c\x3e\xba\xc4\xf0\x64\x47\x4d\xd0\x27\x3b\xe6\xf4\xc6\x59\x98\x0c\xf1\xd1\xa8\xbd\xd5\x1b\x6e\x06\xd3\xd6\x66\xb0\x24\xf2\x70\x04\x42\x77\xf2\x76\x8b\xe1\x17\xd5\xb8\x02\x15\xf4\xcf\x7d\xf3\x73\xcf\xfc\xdc\xc5\xf0\xeb\x5e\x20\x6e\x69\xcb\x1e\xdb\x5a\xc5\xc5\x1f\xa4\x4b\x22\x83\xd6\xdf\x13\xd4\xbd\x8a\x39\xc8\xd1\xaf\xb5\x44\xaf\x93\xf5\x52\x48\x2f\xb9\xe0\xc7\x81\xee\x0a\x0c\x3f\x74\xe8\x43\x21\x90\x8c\xd0\x00\x48\xd6\xb1\x3b\xce\x89\x84\x8c\x38\xfd\x46\xc9\x77\x49\x38\x08\x92\x01\xd5\xc3\x40\x81\xfa\x1b\xd9\x05\x27\x4a\xd1\x0f\xb0\x6f\x19\xd6\x1f\x6d\x31\xa8\xca\xb6\xf0\xe5\x77\x96\x95\x7d\xe1\xcb\x7e\xbf\x6f\x9d\xd7\x4d\xa1\x68\x35\xa0\x9f\x90\x00\xe9\xc8\xf4\x73\x87\x52\xda\xd8\xd7\xda\xc2\x3f\x1a\x59\xec\xe6\xab\x1b\x50\xe1\xc1\xe1\xf1\x0b\x24\xac\xb6\x0b\x3f\x91\x9f\xf4\xda\xf5\xa7\x89\xca\x72\x4a\x7e\x1c\xa8\x91\xa3\xc9\xf9\x4f\xb2\x67\xec\xa7\xe8\x7d\x13\x65\xda\x3d\x37\xeb\x93\x72\xad\xb7\x6e\x31\x04\x03\x16\xa8\xc2\xe8\xef\x3b\xd5\x3b\x71\xd0\x55\xb3\x5e\x0f\x1f\x77\xcc\xfd\x74\xab\xd6\xf7\xe3\x00\x34\xb6\xdb\xd6\x37\x7b\x75\x6d\x59\x3b\xc6\x07\xda\xb2\xa6\x52\xb3\x31\xcd\x52\xbe\x3d\x90\x72\x5f\x87\x2a\x10\xbe\x51\x98\x87\x50\xe8\x3e\x14\xf2\xf7\x31\x50\xb7\xa6\xb3\x53\x31\x50\xd9\xd8\x16\x69\xa8\xed\x6d\x6a\xba\x91\xd4\x60\x8b\x4e\x84\x73\xc5\x7e\x66\xd2\xb6\x78\x07\xed\xd6\x14\x17\x12\x29\x0c\x38\x34\x4b\x53\x55\x26\x2c\x00\x4c\xef\x34\x74\xb3\x54\x43\xf2\x1c\x8b\x64\x87\xc3\x6e\xa5\x89\xdb\xc0\x61\xb2\x6b\x93\x46\xd5\x47\x65\x83\x70\x6a\x64\xf1\xbd\x9d\xc8\x24\xca\xd1\x3f\x41\x6a\xf3\x34\x0c\x99\xfc\x4a\x66\xb5\xe4\x05\xae\x97\x61\x5a\xd5\x0b\xf4\xc3\x80\x85\xc3\xc5\x5d\x07\x4e\x7c\xab\xfe\x67\xdb\xa4\x23\x3b\x0f\x48\x1b\x96\xc9\xb6\xdb\x3d\x03\xa1\xa3\x31\x4d\x83\x76\x17\xe9\xb1\x52\xc9\x86\x34\x17\x21\xd7\xec\x91\xbf\xe1\x64\xdc\xcd\x76\x9d\xe2\x61\x0f\x1e\x54\xe1\x01\x19\x51\x28\xf0\x46\x9f\x29\x62\xb6\x6c\x93\x5b\xa3\x33\xdb\x76\xee\xf4\xdd\x32\xe3\xd2\xb1\x41\x50\xec\x9d\x60\xa8\x9f\x71\x99\xd1\xae\xf6\x09\x87\xad\x62\xc2\xe9\x5e\xbe\xd2\xa3\xa5\x92\x8a\xb1\x42\xcc\x34\x93\xe5\xb2\x43\x4a\x79\x88\x45\x08\x71\x9b\xe0\x37\xee\x19\xc8\x64\xc6\xaf\x84\xfa\x57\x1b\x75\xdc\xad\xd5\x4e\x7c\x26\x68\x7a\x6e\xcf\xe7\x1c\xee\x76\xf5\x57\xa3\x6f\xcf\x68\x0e\xec\x47\xf7\x5d\x55\x39\xb2\x9b\x0e\xb6\x22\x31\xb6\x15\x6e\xcb\x8b\x5c\x66\x4b\xa4\xbf\x5d\x65\x69\x49\xa3\x51\xe2\xf2\xe8\xd7\xbb\xc9\x9e\xbe\x1c\x59\x7a\x76\x7d\x68\x7d\xd3\x9c\xbb\x35\xf5\xdd\x4b\xea\xa3\x24\x9f\x79\xd4\xc1\xa9\x7f\xa8\xa5\xf6\xb7\x4e\x40\xb6\x0e\xfb\xf1\xcc\x44\x1e\xdb\x0f\x92\x37\xe7\x09\x6b\x1c\x05\x06\x59\x9c\x34\xdb\xca\x48\x00\x57\x45\x3c\xf4\xad\x0a\xa6\x43\x28\xdb\x49\x81\x5d\xae\x61\xff\x11\xbd\x87\x1f\x0c\x5b\x22\xbf\xda\xc5\x36\xdb\x4d\xea\x90\x3f\x53\x95\x94\xa3\xa9\x04\x71\x78\x1f\x4a\x6d\x97\x92\xfc\x99\x75\xa7\x28\x97\x20\xfb\xa3\xa0\xfe\xad\x63\xb3\xed\xc5\x32\x2f\x28\x3a\xd8\x2f\x1a\x3a\x7b\xaa\x5d\x2a\x52\xd3\x7a\x7a\xc3\xb4\x9e\x4b\x18\xea\x19\x61\x8b\xa1\xec\x1a\xab\x3b\x52\xa6\x31\x66\x23\x39\x96\xa4\x63\x92\x94\x5b\xb5\x66\x3b\xd4\x4b\x36\x25\xbd\xe6\x72\x9f\x36\x1d\xa5\xa8\x6c\x4d\x62\x56\xb1\xb8\x09\x94\x03\x14\x98\xd5\x8f\x70\x5b\xe6\x75\xc8\x64\x25\x33\xb4\x7e\x6f\xa0\x62\x5a\xa6\x15\x37\x50\x66\xbe\x2b\xd0\xb6\x18\x66\x37\x94\xf8\x05\x24\xe4\xa8\x50\x14\xfd\x0d\x09\x7c\x38\xc2\x06\x93\xb5\x24\x68\x69\x0f\x1f\x60\xe9\x3c\x09\x97\xc6\xbc\x4c\xfd\x52\xb9\x4f\xdb\x36\x58\x0e\x41\xe2\xa3\x51\xaf\xe7\x70\x76\x75\x20\x81\xf1\xd1\x50\x6f\x7f\x2e\x07\x0b\x2a\xcd\xd4\x9e\x7c\x52\xa8\x2d\x75\xa3\x6a\x71\x0d\xcb\x81\x76\x48\xd9\x51\x53\x6e\x57\x4d\x73\x57\x85\xfa\xd2\x54\x49\x97\x7a\x89\x53\x00\xf3\xd5\xeb\x89\xd6\x24\x0b\x70\x9f\x97\x83\xda\x49\x05\x96\x6a\xe1\x06\xcb\x81\x71\x86\xc1\xb0\x91\x64\xe9\x4f\x89\x61\xa5\xde\x6a\xf7\x18\x58\xec\xe7\x99\x1c\xad\x14\xb2\xda\x27\xb7\xb9\xbd\x66\x07\x8b\xaa\xf4\x31\x9f\xd1\x2e\xeb\xef\xd5\x20\x5b\x0a\x64\x8e\x7e\x74\xeb\x8f\x97\xa9\x50\x99\x91\xc4\x78\x0b\x92\xef\x2b\x28\x07\x99\xcd\xf9\x50\xa2\xa1\xce\xfa\xcb\x7a\x4d\xc5\xfe\x46\xe4\xc0\x66\x79\x9c\x96\x14\x99\xda\x5f\xf0\x8b\xdb\x8a\xe8\x2c\x8d\x22\x59\x5a\xd0\xaf\x68\x2b\xc8\xb8\x53\xfc\xab\xda\xf5\x19\x5d\x71\xb3\x0d\x70\x26\x09\x5a\x98\x03\x7d\x85\x3e\x2c\x54\x6e\xf5\x84\xe1\xd2\x7c\x6a\x14\x86\x45\x0b\x18\x97\xe0\xbf\xe9\x54\x0c\xef\xba\x24\x8e\x61\xcb\x33\x89\x28\x6e\x0a\x78\x06\x67\xda\x6e\xe3\xc1\xa1\x1f\x0b\x3a\x49\x8d\x02\xb5\xa0\xbd\x90\x24\x47\xef\x24\x18\x84\xe2\x87\x31\x76\x8f\xff\x8c\x31\x86\xf3\xe6\xe7\xb4\xfe\xfc\x45\x7d\x7e\xdb\xfc\x3c\xac\x3f\xff\x8f\xfa\xfc\x59\x12\xb4\xe7\xfb\xdf\xd4\xf7\x0e\xc2\xbe\x55\xd0\x5e\x5f\xa7\xdd\x8d\xce\x63\x0c\xed\xcf\x01\xc8\xcf\xf4\xe7\x2d\x86\x47\xb2\xd3\x1b\x41\x36\x7d\x19\x9f\xa4\x92\xea\xb8\x78\x76\x80\x94\x27\xe9\x09\x0a\x2c\xce\xf1\xf1\x6b\x89\xe2\x5f\x98\xb6\x5b\x94\x3c\x5a\xa7\xa2\xa4\xd1\xb7\xda\x50\xec\xdb\x28\x2d\xa3\x34\x9a\xa5\x92\x0e\x74\x45\x65\xb4\xaa\x4a\x19\x9d\x51\x67\xc4\xff\xfc\xed\xab\xe8\xbf\xff\x3a\x1c\x45\x73\x2e\x56\xa9\x1c\xc4\x38\x79\xa2\xb7\x3b\xec\x86\x72\xfc\xb6\x62\x31\xc4\x2f\xb9\xfa\xff\xae\xa2\x31\xc4\xef\xe9\x4c\x3d\x2f\xab\x18\xe2\x67\x22\x8f\x21\x7e\x9b\xca\xf8\x14\x28\x99\xc4\x3f\xa6\x2a\xdf\x33\x7a\xa6\xca\xa4\x22\x86\xf8\xe1\x5a\xe8\xe7\xcb\x18\xe2\x1f\x75\x5d\x3f\x56\x85\x4a\xaf\x16\xaa\x24\x5d\xc7\x10\xbf\xca\x64\x0c\xf1\x09\xdf\xc4\x10\x3f\xa1\x59\xed\x4b\xa3\xd8\xd2\x9e\xc1\x4b\xb8\xa4\x69\x27\x97\x6b\x5b\xfc\x67\x55\x51\xfc\x83\xa6\x02\xe1\x2d\xac\x38\x93\xcb\x8e\x9c\x46\xe0\xd3\x89\x2e\xf0\x52\x65\x42\xf8\x74\xbb\x85\x59\x7a\xb9\xb7\x5e\x4d\x7d\xbc\x85\x25\xaf\xf6\x37\xfe\x03\xaf\x44\xa9\x5b\xce\x59\x25\xf7\x48\x18\xd5\xa6\xfe\xac\x73\x96\x34\xe3\x6c\xb6\x37\xe7\x5b\xfd\xd9\xd6\x59\x14\xf9\x2d\xd9\x5f\xd6\x79\x74\x19\xc9\x15\x6f\xec\xcd\x6e\x18\x67\xab\x77\x18\xf7\x65\x0c\x58\x4f\x53\xe8\xd5\xfc\x3d\xa5\xe7\x7b\xa9\x2a\x26\x96\x5c\x97\x9a\xa6\xda\x60\xe2\x61\x37\x7f\x8b\x9d\x73\x4a\x6d\xfd\x35\x2d\xab\x2c\xa3\x8a\xb7\xb4\xb1\x61\x22\xb7\xad\xd8\xf1\x1d\x45\xe6\x69\x5e\x74\xe5\xdf\x3d\x0a\x35\xf9\x59\x2a\xf3\x0d\x7d\x94\xb3\x59\xce\x16\x31\x64\x69\x51\x9c\xa5\xd9\x79\x22\x21\x4b\x59\x46\x0b\x1d\x11\x71\x7b\x9b\xcd\xaf\xaa\x29\x65\xb3\x77\x4b\xca\x1a\x75\xc8\xb4\x3c\x6f\x5b\x00\xef\x29\xce\x99\xb6\xf9\xbc\xb9\x78\xb5\x07\x0b\x41\x33\x9a\x6f\x68\x58\x78\xdb\x3a\x12\x6a\xba\xd3\x3b\xf3\x36\xc8\x67\xc9\x6a\xb0\xa8\xf2\x19\xc2\x20\x38\x97\x89\x84\x52\xaa\x0a\x14\xde\xb0\x4a\xf3\xe2\x8c\x7f\x0e\xfc\x5d\xa3\x35\x12\xb8\x15\x56\xbb\xe6\x10\x14\x5a\xdc\x52\x24\x90\x6a\x5a\x4d\xdb\x3b\x76\xc4\x72\x60\xeb\x36\x67\x02\x02\xc3\xba\x61\x07\x5d\x36\x14\x94\xa0\x62\x86\xaf\x52\xfd\x0d\x18\x12\xc8\x7a\xe9\x0d\x9b\x6d\xcc\xf7\xc2\x64\xd5\xa0\x81\x42\x75\xdc\xc9\x02\xc1\x89\x34\x1b\x18\x1e\xa8\x9f\x10\x06\x53\x96\x68\xf2\xd0\xbd\x10\x14\xb7\x40\x50\x9a\x21\xc7\x2b\x19\x5e\xf8\xd0\xaa\x0f\x6a\x19\x1f\x64\xca\x0a\x9a\x0a\x57\x98\xe1\xed\xb6\x1d\x80\xdb\x2a\xcf\xf2\x68\x53\xef\x8e\x6b\xa0\xcd\x01\x85\x37\xae\xf4\xc3\x4b\x07\xf6\xac\x93\xf5\x10\x6a\xa5\x39\xe6\x6e\x25\x3b\xa6\xd5\xc9\x57\x75\xfa\x0e\x49\x55\x57\x5a\x18\x34\x21\x3d\x44\x96\x5f\x51\x43\x8a\x18\x12\x4b\x58\x6b\x83\x23\xb3\x20\xad\x8d\x42\x3d\xb7\xeb\x56\xdb\x36\xd3\x36\x06\x2e\x23\xc2\x71\x98\xf3\xe7\x70\x87\x96\x66\x99\x3f\xb6\xad\xb4\x01\x61\x2e\x5c\x10\x86\x7e\x5f\xea\x00\x45\x91\x18\xe8\x31\x41\x6e\x19\xb0\xad\xaa\x40\xd0\x52\x26\xb6\xec\x16\x9a\xed\xa9\xa1\xad\x1a\x18\xef\x6f\x60\x57\xa0\xfc\xe1\x06\x0c\x47\xd8\x9c\xbd\x5e\xab\x01\xbd\xaf\xae\x3f\xf9\x23\x62\x03\x8e\x4b\x55\xed\x04\x06\xc4\x36\xb9\x4d\x47\x5b\x83\x23\xa4\x85\x43\x8b\x62\x0c\x5d\x55\x7a\x02\x77\x83\xe7\x08\xfc\x7f\x0a\x9e\x37\x21\x3d\xda\x1c\xcb\xfe\x28\x41\x5a\xfe\xb5\x62\xc2\xe2\xab\x33\x1f\x44\x77\x71\x7d\x8d\x82\xd1\xbd\x84\x21\x86\x05\x39\x18\x36\x8e\x85\xeb\x33\x56\xb5\x4a\x1d\x8e\xc5\xd1\x46\x7b\xdb\x9d\x79\xe6\x1b\x63\x23\x68\x74\x8c\xa3\x99\x3e\x48\xc1\x63\x79\xdc\xaa\x39\x59\x90\x83\x91\xb5\x90\x1c\xd1\xfb\xaa\xa1\x11\x9c\x91\x89\x57\x97\xec\x10\x4f\x04\xa8\x51\x9d\x50\x68\x8c\xcc\x84\x81\xe5\x01\xe3\x8d\x6c\x29\x6e\x8e\x1d\xed\x28\x4b\x2a\x28\xd7\xe9\x05\x4b\x72\x38\xcf\x8b\x22\x99\x43\x59\x50\xba\x4e\x0a\x28\x8d\xa9\x64\x89\x41\xa4\x17\x6f\x75\x9e\xa9\x7e\x54\xe9\xa9\x9e\xef\x4f\xba\xe7\xfb\x60\xf2\x8e\x3a\x0e\x14\x5a\x1b\xec\x83\x0b\x2e\xce\xa9\x68\x1c\x3d\xe4\x73\xb4\xe1\xf9\x2c\x1a\x1e\x74\x06\x1c\x78\xb7\xd4\x8e\x11\xb4\x1f\x7f\x74\x7e\x12\x33\x4e\xcb\x88\x71\x19\x31\x4a\x67\xd1\xbc\x48\x17\xe5\xe0\x03\x7b\x9c\x16\x45\xa4\x33\xda\x56\x10\x36\x8e\x0f\x8c\x47\xa9\x58\x54\xda\x4f\x49\xbb\x09\x5c\xf2\x2a\x2a\x97\xbc\x2a\x66\x4a\x57\x56\xc5\x4a\x2a\x0f\x6a\xb3\xd6\x0a\x49\xbd\xa0\x05\x39\x30\x56\xa5\x20\xb5\xc1\x7c\x26\xf2\xb5\x82\xba\xb4\x77\xd2\x74\x69\x24\x37\x12\xc1\x44\xea\xda\x21\x02\x0d\x88\xd0\x1d\x75\xe1\xa1\xa0\x1a\x6a\xe9\x7d\x7e\x4b\x46\xd3\xf3\x28\x8d\x4e\xe8\x86\x0a\xeb\xc1\xa1\xdd\x4b\x9e\x16\xab\xe3\xe8\x9d\xc8\xb3\xf3\x52\x52\x71\xf0\x81\x3d\x97\xda\x43\xb6\xd4\x2e\xb2\x51\xdc\x67\xfd\x58\x89\x53\xed\x73\xe5\xdc\xad\x34\x9d\x3e\xae\x05\x5f\x88\x74\xf5\x3e\x97\xcb\x67\x8a\xa8\x1f\xa3\xb3\x4a\x46\xcb\xb4\x8c\xe4\xe5\x9a\x46\x1f\x5f\x9b\xef\xa6\xcd\x8f\x83\x0f\xec\x97\x92\xfa\x52\x1f\xb5\xed\x35\x4d\x67\x51\xae\x2f\x45\x88\x66\x5c\xf7\xd1\x45\xca\xa4\xed\x23\x1b\x0e\x22\x23\x39\xfa\x89\x0e\x44\xc5\xf4\xc2\x51\xcf\x62\x4f\x85\xa8\x8d\x9d\x76\xf0\x67\x75\x9f\x0e\x06\x03\x6c\x1d\x63\x8a\xc2\xbb\xb6\xb0\xa8\x62\xf4\xf3\x9a\x66\x92\xce\x7c\x67\x0f\x3e\xb0\xe7\x91\x14\x39\x9d\x29\x82\x65\x9c\x6d\xa8\x90\x51\x2e\xd5\x5b\xca\xb4\x87\xb3\xa6\x1b\x68\x34\x85\xf3\xcf\xd1\x8e\xc7\x6b\xc1\xcf\x0a\xba\xd2\x9e\x2c\x71\x5f\x9b\x33\xb4\xb9\x03\x65\xc6\xec\xe6\x2b\x79\x84\x77\xbb\x33\x49\x7c\xd5\xd0\x29\xbd\xe5\xde\xc6\xc4\xac\xc6\xc0\x88\x8f\x5f\xe0\x14\x0a\xa8\x97\xd8\x5f\x18\xba\x52\xd0\x24\x0c\x36\x39\xbd\xe8\xdc\x28\x48\x73\xb6\x75\xf6\xd1\xfb\xce\x98\xb6\x18\x1a\xe0\x77\x55\x44\x1b\x0a\x4a\x15\x18\xe7\x84\x48\xd6\x77\xab\x3c\x94\x83\x86\x8c\xaa\x9b\xf6\x46\x71\xf6\x60\x0f\x8f\x99\xb6\x6b\x83\x0a\xd9\xf0\x73\x53\x6d\x1e\x02\x25\xa1\x2a\xe5\x0c\xa5\x30\x85\x12\x03\x47\x0f\x15\x9d\xb5\x24\xd4\xb1\xe4\x70\xcb\x25\xef\xa1\x1c\x58\xb9\x85\x4a\x25\xdb\xb5\x8d\x1a\xa4\xe4\x6a\x0b\x25\x59\xa3\xfd\x20\xf9\x7d\x6e\x39\x98\x0e\xc7\x15\x61\x28\x03\xee\x60\xd1\x0e\x6b\x39\xa1\x88\x3b\x58\x72\x0c\x22\x84\x85\xeb\x1d\x2d\x8e\x61\x4e\xa6\x28\x85\xac\x56\xf7\x8e\xaf\xd6\x5c\xc8\x32\x99\x6f\x93\xab\x6d\xb7\x13\x60\xd3\xb5\xe0\xc4\x41\x72\x32\x61\xa7\x63\x3e\xc8\xcb\x67\x5c\xd0\x7c\xc1\x7a\x3d\x84\x28\xa1\xc6\xb0\x95\x9d\x92\x38\x5b\xcd\x8c\x8d\xa2\x4c\x17\xc7\x9f\x11\xc3\xc9\x43\xc4\x40\x60\x0c\x52\x7d\x9f\x23\x0e\xa2\xeb\x92\x0c\x1b\x60\x24\x14\xe2\xde\x21\x90\x16\xf3\x5d\x8f\xbf\x14\x55\xc0\x40\x5a\x4b\x06\xe7\x84\x30\x1d\x8e\xed\xb1\x0a\x37\x67\x2a\x1a\xa0\xc4\x97\xc9\x80\x01\x1d\x64\xab\x59\xa9\x43\x9f\xaa\x0c\x65\x75\xb6\x93\x41\xf1\x9d\xcf\x30\xff\xec\xbf\x97\x61\x05\x3e\x9b\x09\xef\xc3\xc8\x95\x62\xeb\x44\x80\x02\x38\x31\xb2\x73\x0b\x5c\xc7\x77\x5c\x40\x46\xe4\x80\xb3\xa7\xf3\x39\xcd\x64\xa9\x1d\x83\x39\x7b\x4b\x8b\xf9\xcb\x72\x01\x53\xb2\x76\xf2\xbd\x1e\x46\x6c\xa0\xea\x21\x53\x98\xee\x8b\xac\xb2\x9f\x73\xa8\x5d\x02\x29\x1e\x02\x1a\x32\x45\xf7\x82\x62\xd6\xda\x13\x55\x05\x28\x9b\x29\x01\x42\x8b\xb9\xdb\xb9\xd6\x1d\xa1\xb7\xc1\xb7\x1d\x51\xeb\x1b\xd3\xaf\xe1\x16\xc5\xf9\x66\x9e\x6f\x80\xe6\xf7\x85\xa9\xde\x97\xaa\xdd\x19\x18\x50\x25\xa3\x0c\x35\x1f\xca\x81\x55\x1f\x80\x13\xf3\xad\x5e\xb1\xd8\x31\xa5\xd4\x82\xb6\x4d\xdc\x0d\xd3\xde\x95\x9a\x34\x92\xb8\xa0\xe9\x3c\x86\x25\x5f\xd1\x44\xda\xc5\xbc\x08\xe5\x62\x10\x4b\xc6\x96\x60\x7c\x46\x63\x70\x2e\x8c\x8d\xe5\x6f\xc3\x30\xcc\x66\x5f\xa5\xeb\x18\x64\xba\x58\x50\xa1\xd6\xd9\x82\xd2\xc6\x3a\xfb\xac\x65\xcf\xbc\x1d\x5f\xa2\x83\xa1\x8e\xdd\xa1\x94\x4c\x0c\x97\xe8\x60\xa4\x0d\xe6\xf4\x6b\xdb\xc9\xc9\xca\x29\xfd\xc6\x8e\xd9\x84\x9f\x26\x57\x8a\x21\x13\x73\xa3\x80\x62\x4a\xf3\xb8\x1d\x07\xa2\x47\x4e\xf8\xa9\xeb\xc8\xf9\x67\x73\xc0\xb4\x0d\x5d\x21\x2f\x6b\xe1\x69\x87\x90\x18\x28\x74\xec\x38\xd2\x44\x4b\x4c\xbf\x8a\x81\x22\x1e\x64\xe4\x1d\x92\xc0\x81\x81\x75\xe8\xf7\xdd\xa3\x98\x5f\xc7\xbb\x25\x17\x48\x42\xa6\xa3\xde\x62\x3b\x9c\x34\x2d\x93\x3a\xb6\x83\x18\x38\xba\x3a\x6b\xc0\xca\x6a\xe2\x97\xd6\x3a\x56\x03\x05\x26\x7c\x83\x6d\xc1\x54\xa5\xe8\x9c\x04\x4d\x1a\x1c\x06\x8a\xe0\x40\xe1\xca\xf6\x80\x18\x98\x07\xb3\xa0\x61\x0d\xa4\xdf\x75\xcf\x18\xa1\x8d\x2b\x1d\x8b\x31\x96\xc4\xd5\x62\x02\x56\x08\xb3\x2c\x70\xea\xfb\xd6\xb3\xb0\x3c\x3e\x99\x88\x53\x25\x20\x5e\xa6\xeb\x44\x3f\x97\xd5\xd9\xcb\x74\xad\xe8\x84\x5b\x71\xcb\xc3\xf0\xaa\x5a\x88\x76\x77\x23\xc8\x63\x64\x64\x0e\x71\x17\x3d\x58\x19\x84\x81\xe2\x04\x19\x41\x14\x7e\x53\xef\xb8\x71\x17\xd2\xb9\xbd\xdc\x46\x1a\x71\xde\xa5\xd3\x0a\x1a\x65\x29\x33\x4e\xef\x67\x34\xe2\x8c\x46\x6a\x9a\x88\x58\xba\xa2\x33\xe7\x09\x6c\x34\x13\x7d\xc3\x94\xd5\xb2\xb4\x36\xb6\xaa\x0a\x99\xaf\x0b\xda\xf0\x60\x7f\xdb\x90\x2a\x0a\x02\x38\x99\xc8\x53\xa2\x3a\x26\xd1\x82\x19\x2c\x9d\xde\x80\xd5\x85\x54\x77\x81\x9f\x5d\x92\x83\xe1\x16\x96\x8d\x9d\x9b\xcf\x8d\xbb\xe5\x68\xe3\x40\xaf\x61\x4c\x3a\x0e\x0d\x82\x33\xe0\xa4\x32\x56\x5d\x3a\x6a\x68\x7e\xe4\x6d\x8c\xf3\x7e\x1f\xb3\x49\x7e\xaa\xe6\xd1\x66\x1c\x88\x69\x4b\x9b\xce\xdc\x2a\xac\x75\x83\xa2\x61\x13\x94\x91\xcc\x47\x7c\xf4\x6e\x83\x4a\x62\x3d\x20\xc3\x5e\x2f\x73\x77\xf1\x08\x18\x19\x09\x97\x91\xc9\x29\x54\x44\x51\x64\xe0\xb1\x87\x29\x09\xb5\x09\x3d\xfc\x2d\x38\x3a\xa3\x9a\x23\xc8\x54\x93\xb1\x9e\x4d\x88\x40\x14\xc3\x95\x55\x96\xce\x68\xc2\xa0\x62\xf5\x1b\xdf\xee\xc4\x67\xde\xd3\x25\x6a\x2a\x04\xc3\xae\xc9\xd3\xaf\xee\x92\x87\x66\x33\x2d\x24\x56\xdb\x20\xdb\x5d\xdd\x65\xaf\x7d\xf2\x01\x97\xb3\x7e\x1f\x4f\x51\x39\xc9\xea\x8b\x18\x4a\xb3\xf9\xb5\x26\x53\x98\x11\x0e\x6c\xff\xfd\x5f\x73\x22\x60\xd9\x71\xdb\x97\xfd\xec\xec\xc2\x5b\xfb\x9b\xe5\x6e\x2f\xb6\x8c\xda\xe7\x6d\x46\xa2\x9a\x73\x90\xf4\xe6\xc3\xe1\x7e\xa3\xd7\x8e\x73\x54\x31\x28\x6c\x78\x7a\xb7\x7a\xa0\xdd\xab\x87\xb8\x8e\x94\xa4\xe6\xd9\xd6\x6a\x41\x2f\x6d\xf8\xdc\x2e\xa1\xac\x03\xbc\x19\x8b\x76\x14\x26\x6a\x09\xa0\x6d\x4e\xc7\x6b\x63\x7b\xba\x35\x81\x65\x26\xa7\x30\x27\x46\x80\x14\x6d\xd6\x9a\x11\x06\x6b\x52\xc1\xf2\x2b\x58\x6c\xb9\xcb\x62\x99\x62\x31\xbb\xf8\x56\x8d\x9d\x28\x05\xf6\xcd\x5e\x4b\x9e\x2d\x86\xa7\xfb\x3e\x76\x28\x03\xce\xd9\xce\xab\x03\xba\xad\x77\xfc\xe1\x7a\x6d\x22\x79\x99\x57\xa5\x31\x25\x12\xcd\x30\x50\x0d\xd8\xcb\x94\xa5\x0b\x2a\xca\xe4\x04\x78\x25\x17\x3c\x67\x8b\xd7\x5c\xc8\xe4\x2d\xe4\x2c\xe3\x2b\xf7\xfa\x08\x96\x72\x55\xbc\xe3\x76\xb9\x98\x64\x60\x85\x57\x42\xa1\xbd\xc4\x4c\x58\x18\x59\xb1\x02\x35\xf1\x25\x4b\x38\x4b\x65\xb6\x4c\x36\x36\x64\xe2\x42\x5b\x35\xc3\x1b\x49\x4e\xe4\x40\x7f\x82\xa7\x92\xbc\xf1\x4e\x96\xfa\x90\x1f\x5e\x4a\xf2\x52\x6a\xfb\xd1\x97\x72\x12\x1f\xec\xf5\x66\xdc\x17\xdd\xe3\x8d\x3e\x19\xdb\x1a\xf5\xf6\xb1\x6e\x6b\x95\xae\xe1\x53\xd0\xea\x33\x49\x3e\xb5\x5a\x7d\x21\x09\xb2\x39\xeb\x8e\x86\x13\xa3\xd2\x19\x12\x62\x78\xae\xeb\xf0\x34\x86\x57\xa6\x50\x9b\x18\x50\xa7\x35\xce\x25\x5b\xe6\xb3\xaf\xce\x3b\xcd\x67\x31\xfc\xb8\x6b\xe4\xd0\xf2\x02\x33\x45\xdb\x3e\x6b\xaf\xbb\xec\x14\x2d\x96\x6a\x68\x39\x27\xb3\x27\x1d\x27\xfb\x37\x35\xe0\x1c\xd9\x5e\xdb\x87\x6d\xd7\x71\xab\x6d\xe7\xd5\xb9\x6b\x06\xc3\x2f\xbf\x0f\x8f\x27\xb2\x76\x66\x0b\x9a\xfa\x75\xff\x21\xf5\xed\x4e\x6d\xa6\x01\xef\xbe\x76\x5c\x27\x8c\x7c\xa3\xdd\xce\x6b\xaf\x25\x72\x2f\xf6\x79\x68\x01\x7a\x2f\xff\x04\x9f\x36\x03\x07\x6f\x03\xe6\x5d\xd7\x82\x84\xbb\x1e\xd2\x9b\x1d\xd7\x5e\x4b\xe4\x5e\xec\xf3\x28\x78\x76\xd0\xff\x59\xae\x6d\x06\xbc\xac\x8d\x40\xd6\x46\xc0\xbb\xaf\x05\x09\xf7\x3c\x46\x5f\xe7\xbc\xf6\x5a\x6f\xd2\xdc\x73\xd8\x64\x01\x96\x59\x80\x65\x56\x63\xf9\x27\xbb\xba\x19\xc8\xab\x36\xb2\x55\x1b\xd9\xaa\x8d\xac\xf7\x65\x0b\x12\xee\x7b\xec\x7f\x9f\x27\xdb\x6b\x89\xdc\x8b\x7d\xbe\x17\x3c\xdf\x0d\x9e\x47\xc1\xb3\xa5\x08\x86\x1f\x7e\xf7\x68\xf4\xa3\xde\x0d\xcb\x2d\x86\xdf\x6e\x97\x1d\x2d\x17\xd5\x46\x45\xaa\x8a\x87\x7a\x4d\xaf\xa6\x74\x0c\x5f\x64\xb8\x64\xfd\xfe\x36\x10\xd5\x12\x56\x6f\x7d\xa3\x1c\x7d\x91\xf0\x5c\xd5\x08\x1e\xb6\x9f\x75\x65\xf3\x34\x2f\xe0\x1f\x37\x19\x2f\xfd\x26\xbb\xbc\x23\x7e\x96\xda\xf5\xc8\x39\x47\xd4\xb3\x00\x86\x9f\xf6\x5a\x9d\x69\x30\x3a\x2a\xfb\x47\xb3\xb2\x7f\x76\xc9\xb0\x5b\xaa\x68\xa6\xd3\xb0\x6a\x77\x6f\x32\xd6\xe6\xd5\xa6\x89\xbf\xef\x91\x4a\x7f\xb0\x95\x66\x3a\x0b\x5b\xaf\x2f\x5f\xc6\x5b\xb5\x3c\xab\x61\xe8\x96\x2d\x7f\x32\x04\xcd\x74\x1e\x42\x16\x5e\xeb\x8c\xb7\xc0\xdb\xf0\xed\x93\x0a\xff\x26\x08\x9b\xe9\x59\x08\x79\xf3\x26\x69\xbc\x85\xac\x0b\xfe\xf6\x26\x67\x30\xe8\x1a\xce\x0e\xff\x68\x2a\x37\x49\x8a\xfe\xb9\xcf\xc4\x71\xaf\xef\x83\x92\x3d\x7f\xd7\x43\x77\xa4\x07\xd7\x37\x37\xb2\xf0\x4f\x72\xbf\x4a\xe0\x43\x7d\x6c\x55\x85\x39\xfa\x27\x7c\x2f\xed\x55\x42\xda\x7b\x43\x90\x7f\xb4\xe2\x6c\x0c\x95\x46\x26\xc4\xfe\x06\xbb\x0a\x28\xa0\x85\xd2\xcf\x94\xee\x89\x62\x1d\xab\x08\x03\x13\xfb\x75\xa2\xd7\x26\xf8\xb5\xd7\x8b\xb8\xd8\x37\xcc\xa9\x40\x4c\x20\x8d\xa6\x74\x70\x67\xb7\xe6\xee\x96\x33\x5a\x34\xbc\xd6\xd2\x01\x6f\xe1\x46\x01\xf2\xc4\xe5\x52\xff\xb5\x1f\xc5\xde\x36\x03\xf0\xac\x38\x1c\x9f\xc8\x41\x53\xdf\x1f\x28\x9a\x90\xab\xf5\xf9\x22\x89\x1b\xf1\x5c\x63\xad\xbc\x27\x52\x80\x5f\xbb\x24\xdf\x48\xf0\x7b\xad\x89\x10\xb0\xb3\xfd\x50\x09\xe3\x27\x30\x15\x37\x85\xeb\xb5\x7b\xcc\xfd\x38\x89\xe2\x7e\x1d\xf3\x03\xe9\x2b\xe0\x98\x56\xf3\xeb\xad\x5b\x39\xe3\x95\x3c\x76\x0f\x83\x0b\x91\x4b\x8a\x28\x4e\x32\xce\x4a\x5e\x50\x1d\x1e\x9c\x36\x4c\x5d\xf4\xbe\x69\x7b\xa1\x28\xdd\x5e\xf9\x95\x09\x18\x43\xa1\xe0\x8b\xc4\x2c\x0b\x10\x86\xbc\x1b\x60\xba\x27\xd4\xff\xde\x78\xeb\x7d\xd1\xb9\xa7\x21\x27\xc3\xd3\x3a\xb0\xce\x0b\x14\x9c\xfa\x64\x4b\x61\xee\x86\x32\x5b\x1e\x23\xac\xad\x85\xbb\x2d\x91\x9a\xf5\x87\x31\x08\x7f\x1c\x58\xf7\x53\x24\xb1\x8d\x42\x14\xb7\x17\xe6\xde\x90\xac\x8d\x43\x8a\x76\xae\x4b\x2d\xd7\x45\x2e\x55\x1d\xc0\x48\xf3\xea\x47\x13\xc1\xd0\x02\x4e\x1b\x61\x91\x68\x47\xcb\xcd\x48\x7f\x41\xc5\x6a\x59\x65\x6a\xc1\x83\x79\x5e\x48\xbd\x21\xd8\x51\xc1\xbc\x19\x58\xce\x17\x17\x74\x43\x45\x49\x51\x57\x99\x0e\xaf\x78\x7f\x23\x8d\xb9\x30\x8e\x8d\xfb\x7d\x6e\x6f\xbf\x74\xa8\xf0\x53\xdc\xed\xab\xdf\xe1\x18\xdf\x75\x8b\x66\x40\x92\xee\x7a\xd6\x0d\x5a\xfc\x38\xf0\x7e\xc2\xc8\xd1\xa5\x71\xb1\xf0\xb2\x95\xdd\xf5\xb0\xb0\x28\xcb\xb6\x6b\x78\xd8\x85\x71\x3c\x96\x0f\x86\x63\x3c\xea\xc9\x5e\x0f\xd1\x3e\x51\x3c\xf6\xe0\x01\x19\x81\xe8\xd7\xaa\x13\xed\xb8\xd2\xd4\x77\xa6\xbf\xb7\x71\xaf\xc7\xb5\x3c\x1a\x1d\xc7\x71\x22\x82\x9b\x34\x5b\xdb\xe0\xfb\xb2\x1e\xca\xdd\x4b\x3e\x83\x9c\xc2\x67\x94\xed\xad\xde\x3d\xf9\x86\xd0\xa8\xf2\xbc\xb9\x28\x44\xf2\xd0\xdf\x41\x74\xe7\xae\xdf\x5c\x0f\x6e\xc0\x60\xaa\xcf\xfa\xb4\xbf\x41\xc3\x6b\xd6\x40\xf9\x6d\x9b\x30\xfd\x4d\x50\x5d\x23\xeb\xe7\x56\xd6\x56\xc6\x3e\x6d\xec\x1f\x06\x6c\x2d\x45\xbe\x42\xcd\x9d\xc0\xe0\xab\x8f\xb7\xf5\xbf\x1f\xca\xfe\x1d\x68\xb0\xfa\x49\x77\xce\x0f\x65\xff\x9b\x56\xce\x37\x0d\x71\x51\xf3\x9e\x6b\xdd\xb2\xa0\x2a\x7a\x67\x11\xf2\xe1\xd3\xbd\x05\x5d\x09\xf1\x81\x5d\x7f\x10\xd7\x1f\x58\xb3\xe0\xcb\x26\x8e\xa1\xd9\x7d\xe3\xce\xae\x46\xa6\xc0\xd4\xbd\x71\x13\x51\x5b\x42\x85\xa1\x36\xb4\xe7\xb8\x15\xa5\x13\x7a\x8a\x03\x07\x72\xfb\x30\x6a\x5c\x1c\x74\x4b\x5d\x07\xdd\x95\x75\x05\x78\x7e\xd5\x12\x6f\xf5\x76\xf5\x83\xc3\xd1\x8d\xf7\x02\x05\x59\xf7\xde\xe4\xe3\xee\x89\xf2\xf3\x4e\xaf\x27\x06\x45\x5a\xca\xe7\xbe\xac\xae\xca\xde\x67\xb4\x2b\xd9\x7f\x69\x4c\xb8\x7e\xa7\x7e\x8e\x68\xed\x2e\xa4\x37\x39\xc3\x2b\xa5\x75\x10\xfd\x31\x62\x21\x8c\x4a\xb1\x7f\x70\x38\xf2\x11\x37\x18\x06\xd6\xf7\xee\xbd\x0d\xb6\x08\x4f\x11\x7f\x0d\xef\x6e\xa8\x5b\x0f\x2f\xb5\x89\xde\xbb\x6b\xe4\xa9\x99\x26\xf3\x39\x8a\x87\x5a\x71\xed\xf5\xe2\xcf\xfa\xbc\x7a\x32\x3a\x35\x1d\xc6\xc8\xdd\x31\x3b\x12\xe3\x7e\x9f\x61\x13\xaf\x7d\x18\x1f\x11\x44\x75\x48\x5d\xdc\xeb\xd1\x23\x12\xff\x4f\x7c\x7d\x1d\x3f\x8c\x8f\x54\x79\xf5\xfe\x4c\xbd\xa7\xf5\xfb\x3c\xc6\x8d\xa6\xed\xf3\x13\x89\xb4\x01\xfe\x73\x26\x91\x84\xd1\x5f\xb1\xbe\x53\x92\x3e\xd0\xf5\xd1\xa3\x78\x18\xf7\x7a\xf1\xa1\x36\x66\xec\xf5\xe2\x7e\x1c\x5c\xb3\x6e\xea\xa9\x29\x38\x0a\x61\x74\xc0\xa9\x1a\xae\xaf\xe3\xff\x89\x8f\xe8\x57\x34\x3f\x0c\xc7\xd1\xfb\x60\x88\xbc\x96\x28\xce\xb4\x79\x93\x09\xe1\x6c\x0c\x5f\x4c\xbc\x4f\xef\x3b\x60\x8c\x60\x9e\x33\x19\xb7\xaf\x2d\xf2\xd7\x64\xba\x0b\x32\xef\x4c\x3e\x94\x9f\xcf\xf8\xe9\x9d\x81\xa4\xa5\x9e\x80\x6c\x43\xbf\xb9\x6e\x11\xa4\xef\xcf\xe7\x74\x30\xef\x63\xad\x82\x26\xbf\x35\x38\xf7\xb7\x3f\x02\x63\xa4\x23\xb9\x85\x40\x7e\xb9\x45\xd6\x34\x15\x87\xa0\xe0\xf7\xb7\x2a\x43\x56\xfd\xcb\x4b\x1d\x2b\x33\xa1\x2e\x74\x07\xc3\x50\x31\xfd\xcc\xeb\xc0\x82\x19\x06\x73\x2f\x9d\xde\xb7\xd6\x97\xf5\x4c\xed\x8e\x75\x8a\xc1\xe8\x2b\xd6\xa8\xce\xe8\x21\xc9\xdc\x5f\xf5\x53\xd4\x57\xfd\xcc\x30\x68\xb8\x13\x89\xd6\x18\x14\x28\xe6\x96\x20\x41\xd7\x34\x95\xe6\x86\x20\x77\xaf\xd0\x02\x43\x41\xe7\x52\x47\xfa\x00\x61\xae\xd5\x42\x97\x18\x66\x82\xaf\x5f\x98\x0f\xef\xcc\xdb\x1b\xfb\xf1\x02\xc3\x3a\x9d\x25\x42\xdf\x53\x94\xce\x74\x26\x81\x3e\xeb\x17\x93\x47\xa0\xb7\x6a\x31\x95\xaf\x92\x47\xfa\x47\x67\x79\xa8\x1f\x4d\x86\x13\xb8\xe0\x62\x56\x26\x6f\x40\x87\xde\x4d\x9e\x7a\x07\xaa\x97\xde\x2f\xea\x31\xa4\xec\x32\x91\xe8\x19\x86\xb4\x28\x12\x89\x9e\x6b\xe2\xc8\x34\xd7\xf4\x7b\x85\x41\x07\xeb\x2d\x6d\x9c\x92\xd7\x18\x28\x9b\xb9\xb7\x27\xee\x4a\x24\x95\xf5\x17\x0c\x92\x3f\x67\x32\xf9\xd5\x5f\x05\xf2\x83\xbb\x86\xe9\x4b\x7d\x35\xd3\xf7\x5a\x25\x4f\x05\xc9\x45\xed\x8a\x56\xea\x57\x93\x19\xe6\xf6\x45\xd7\x01\x85\x7d\x7b\xce\x24\xcc\x04\x41\xb9\x15\x5c\xb4\x84\xe6\xa3\x83\x0b\xc3\x5a\x17\xa9\xe1\x86\xa5\x4e\x70\x68\xc1\xc6\x54\x93\x16\x85\x2a\x97\xb2\x4b\x30\x8d\x2b\x82\x60\x58\xd9\x06\xad\x23\x95\xc9\xab\x09\xa8\xb2\x69\x8a\x62\x38\x33\xc9\x9e\xd6\x60\x5f\x54\x1f\xb8\x67\x0c\x97\x26\x97\xeb\x31\x30\xcf\x2a\x0f\x86\x77\xfe\x9b\x4a\xf6\x3d\x8f\xe1\x42\xb7\xef\x18\x03\xce\xf5\xab\x66\x19\x78\x6b\x81\xb1\x8d\x68\xe6\xc2\xf0\xd9\xa4\x1a\xb6\x53\xe9\x8a\x15\x31\x3c\x32\x54\x50\x1c\x0a\x0f\x4d\x16\xe3\x2a\x68\x1f\x34\xf2\x96\xc1\x75\x9a\xe6\x7b\xf5\xb4\x4a\xd7\x90\x0b\x7f\x3f\xd8\x89\xa3\x5e\x96\x4a\x78\x63\x69\x67\x9c\x2b\x73\x31\x30\xc3\x0b\xc3\x53\x97\xab\x84\x97\x5d\x4b\xf0\x28\x47\x4f\x05\x48\xad\xb6\xc0\x63\x9d\xd9\x8e\x56\xf8\xd4\xb5\xf0\xef\x8a\xda\xb2\x27\x14\xee\xfe\x30\x2e\xa9\xd9\xe9\x1f\xa9\x7f\x77\x21\x45\x9f\x84\xf6\x31\x65\x3a\x18\x7f\x33\xb0\xcb\xbd\xed\x16\xc3\xb3\x4e\xc8\x75\xb9\x7d\x5b\x13\xdd\xb1\x07\xf0\x4e\x98\x88\x17\xff\x6a\xd5\xfb\x83\xdb\xef\x6d\xf3\xf9\xbf\x8d\xb0\xcf\x3d\x61\xef\xb5\x09\x7b\x5f\x41\xf6\x4a\x90\x60\x2f\xce\x6e\x7b\xe9\x8b\x31\xed\xad\x21\x2d\x38\xb3\x26\x9c\xe6\x76\xd3\xca\x18\xf3\x69\x63\x97\x39\xc9\x83\x58\x03\xf3\x0e\xf7\xfc\x90\x50\xb9\x71\xff\xe6\x1a\xc8\x29\x36\xfb\x18\x05\x99\xab\x0a\x67\xea\x67\xa8\x9e\xd6\xf6\x69\x38\x0e\x3c\x9e\xd7\xfa\xda\x2f\x3f\x73\xd6\x89\xb5\xe3\xfb\x4d\x2d\x75\x75\x5b\xa1\xf2\x94\x88\xc1\x1a\x66\x16\x1e\xeb\x2a\x0d\x59\xd7\x11\x57\x61\xea\xa4\x3a\xff\x14\xeb\xc8\x16\x73\xa2\x89\x9e\x77\x45\xe7\x78\xa1\x8f\xa1\xa7\xa3\x64\xba\x85\x0a\x83\xc6\x73\x68\xf0\x1c\xd5\x0e\xc5\xbb\x01\x63\xac\x63\x4e\x9d\x85\x9a\x18\x48\xba\xa3\xf5\x7e\xe4\x0c\x0a\x1d\x6e\x49\x90\x1b\x76\x9e\xa7\xc2\x44\xc8\x47\x27\x02\x35\x59\x38\x7e\xee\x42\x25\x0b\x3a\x3b\x3c\x2b\xd2\xec\x3c\x92\x82\xd2\x28\x67\x9b\x54\xe4\x29\x93\xd1\x26\xe7\x45\x2a\xe9\x0c\x22\x7f\xd0\x1f\xef\x09\xf1\xd1\xaa\x5b\x5b\x88\x2f\xb8\xec\xca\x7f\x8e\x04\xee\x28\x72\xa7\x23\x2b\xfd\xca\x7c\xac\x23\xdf\x07\xf6\xba\xa0\x69\x49\x23\x41\xb5\x1d\x82\xb6\x48\x3e\xab\xb4\x05\xc3\xd1\x52\xca\x75\x99\xdc\xb9\xb3\xc8\xe5\xb2\x3a\x1b\x64\x7c\xd5\xba\x63\x29\x2f\xcb\x8a\x96\x0f\xe2\xdd\x70\x10\xe6\x4f\x6f\x08\xbe\x16\x9d\x01\x9a\xa4\x8b\xcc\xd1\x1d\x4c\x5c\xd4\x81\x36\xe2\x47\x8f\x14\xdd\x4d\xaa\x3d\xde\xaa\x57\x54\x2e\x1c\x82\xca\xf8\xe2\xab\x72\xb6\x23\x20\x1c\x8c\xb6\xf0\x64\x77\xd7\xb2\x2b\x52\xd8\x1e\xa9\xd3\x0c\x53\x26\xc7\x92\xe4\xe8\x89\xd0\x81\x1b\xa8\x12\xdc\x26\x66\x98\x96\xd7\xbf\xec\x36\x24\x93\x3f\xdc\xd4\x27\x67\x15\x9b\xa3\x13\x90\x26\x5e\xb4\x25\x9c\x36\xa4\x7b\xf1\x2e\x4e\x7c\xcc\xb2\x7b\x63\xa5\x4f\xe4\xac\xa2\x91\x34\x76\x76\x4f\x7f\xf6\x66\x76\x2f\x10\x1d\x4c\xef\x62\x1f\xbe\xc3\x97\xba\x1f\x94\xd2\xe3\xf8\xd7\x7d\x1b\xbc\xfe\x54\x2d\x47\xbf\x68\xe1\x6a\x40\xd9\x62\x78\xff\x67\x4a\xf5\xfd\xb3\xca\x58\x9a\x30\x35\x3a\x5a\xcd\xdd\x40\x96\xff\xe0\x5d\x18\x4f\x0c\x83\x6c\xe1\x37\x9f\xf4\xc8\x25\x7d\xa9\x93\x6c\xca\xf7\xdd\xac\x7b\x3b\xd7\xba\x95\xfc\x74\x58\xfb\xa7\xd3\x4f\x88\xc2\x17\x81\xaf\xaf\xed\xf3\x6f\xde\x60\xfa\x60\xb8\x85\x9f\x7d\xeb\x6f\xe8\x2c\xde\xc2\x3f\x9a\x6d\xdb\x7e\x96\x61\xef\x1a\x30\x5d\x0f\xfe\x66\xa2\xcb\xe8\xe2\x2e\xed\x8b\x4d\x3b\x69\x66\xfd\x59\xf8\x7e\x6e\x4b\xc0\xf8\x71\xca\xbe\x95\xd1\x2a\x3d\xa7\x51\x1a\xcd\x78\x75\x56\xd0\xc8\xc8\x3d\xc6\x67\xd4\xdc\xc8\xa3\xdf\x0f\x62\xbc\xdd\xc2\x4f\x5f\x01\x66\xb3\x71\x07\xd3\x0e\x48\x3b\xd0\xff\xf0\xb5\x60\xea\x50\xd2\xf9\xa6\x01\x68\x41\xcb\x32\x04\xf4\x9f\x9e\xbe\x2f\x7c\x8f\xff\x3d\x48\xb3\x49\xdf\xdc\x70\x18\xd3\xc5\x9d\xee\x60\x46\x52\xf2\x8d\x40\x7f\x17\x6a\x31\x45\x6e\x3a\x64\xf4\x75\xed\xf0\x4f\xcd\xc9\x30\xbd\xab\xa4\xfa\x3d\x25\xb2\xef\x27\x5c\x1f\x76\xd1\x9b\xc2\xdc\xdd\xc4\x8d\xbd\x9e\x26\x6a\x28\x13\x8f\xe7\x48\x28\x5e\xd4\x37\x4c\xe9\xcb\xa3\xf4\xbd\x50\xe6\xca\xa7\x44\x6e\x81\xfd\xe1\xd6\x4c\xd5\x3f\x09\x6b\x94\xd9\xd9\x80\x21\xd4\x16\x38\xed\x52\x30\x3b\x4e\x9a\x3a\x0e\x36\x3b\xce\x34\x3b\x8e\x33\x3b\x4e\x32\x7d\x52\xb5\x9b\x34\xdd\x4d\xca\x77\x93\xd2\xdd\xa4\xb2\x4e\xb2\xe8\x4b\xac\x35\x46\x4f\x68\xa0\xc6\x93\xc3\x25\x28\x55\x32\x85\x12\xe3\x7a\xb6\xdc\x42\x76\x0b\xd9\x3b\x85\xa3\xa5\xbb\x21\x6a\x72\x53\xcf\x6e\xa1\xfa\x17\x1a\xa8\xc7\x5e\x16\x8e\xbd\x17\x34\x9d\x2b\xe5\x28\xb6\x6d\xff\xbc\xaf\xed\x69\x77\xdb\x75\x98\x2e\xaa\xfe\x31\xf5\x8f\xab\x7f\x99\xfa\x57\xdd\xa0\x25\x78\x4b\xce\x46\x28\xaf\x7d\xcc\x69\x8d\x5c\xf0\x8d\x79\x8c\xdd\x0b\xf6\x76\xf2\xda\x7c\x25\x94\x65\x5a\x3c\xd5\x9f\xef\x77\x7d\xbe\x05\x8a\x3a\x72\x74\x3d\x2c\xef\x85\x2d\x19\x6c\xaa\xdb\xb0\xb1\xc0\xb6\xeb\xb9\xdf\xaa\x27\xbb\xb9\x9e\xfb\x9d\xf0\xdc\xdf\x85\x87\xdf\x5a\x4f\x07\x3c\xf7\x77\xe1\x61\x3e\x52\x58\x63\x66\xfa\x4f\x24\x5a\x87\x36\xa9\xef\xca\xfc\x0a\x52\x86\x25\x43\x62\xde\x52\xfe\xfe\x9e\xf2\x6d\xf8\x68\x67\xb8\xb5\xff\x24\xfa\x39\x65\xbb\xd1\xc9\xff\xca\xc0\xf9\x3f\x60\xd4\x3f\xc0\x03\xf7\xf6\xf0\xc0\xbd\xaf\xe4\x81\x7b\x7b\x78\xa0\x83\xc6\x62\xff\x40\xea\x5a\x06\xdd\xb8\xd6\xfa\xf7\xf2\xee\x57\xf3\xea\xbf\x8b\x82\xdb\xae\xd1\xf4\xff\x40\xcf\x6f\x1d\xbc\xff\x8f\x0d\xac\xdf\xc3\xb8\xff\xb1\x12\xd7\xc7\x61\xd4\xb1\x38\x6e\x51\x19\xfe\x43\xc5\xf3\xbf\xdc\x03\xff\x27\xf2\xae\xdd\x03\x3a\x18\xc8\x4d\x4a\xa2\xd3\xeb\x5c\x05\xff\xdf\x70\xf9\x3f\x1c\x2e\xbb\x11\x48\xb9\x71\xc4\xc2\xc8\x33\xce\x28\x78\xbe\xeb\x9e\x7d\xa2\x49\x31\xaf\x77\x83\x9c\xf7\x82\xe7\xfb\xee\xd9\x3c\xdc\xc7\xb7\x36\xdb\xaa\xde\x70\xe0\x28\x78\xee\x6e\x36\xc8\x10\x3e\x7f\x5d\xb3\x61\x65\xf7\x03\x28\xee\x07\x80\xdc\x0f\x12\x6d\xb3\x41\x9e\xf0\xf9\xbe\x7b\xfe\x9d\xcd\xb6\xaa\xbf\xdf\x4c\xec\x68\x36\xf8\x14\x3e\x77\x35\x1b\xac\x47\x2d\x82\xf5\xe3\x5d\xb8\x61\xb5\x6a\xb1\x83\x39\xca\x83\x0a\x5c\xe9\xbb\x75\x9e\xfb\x50\x51\x8f\x37\xbe\x19\x84\x7b\x75\x25\xb6\x4f\xc3\xfa\xef\xd5\x9f\xee\xda\x4a\x0d\x0c\x41\x0f\xef\x01\xd9\x34\x6f\xef\xcc\xde\x05\x41\x6e\x21\xdf\xb7\x2d\x64\xfc\x5a\x74\xb5\x75\xaa\x2b\xf8\xbd\x40\x19\x3e\x9e\x52\x94\xe1\x24\xdb\x62\x48\x6f\xde\x5c\x8a\x5e\x0b\xc4\xf0\xf5\xf5\x6b\x81\x38\x3e\xd6\xa8\xfd\xc3\x78\x36\xab\x7c\x54\xdb\xc9\x50\xc4\xb1\x5d\xab\xd7\xe5\xb7\x18\xca\x9b\x01\xe4\xb7\xec\x12\x98\x78\x2a\xc7\x29\x9a\xab\x7a\x55\xc1\x64\x8e\xd2\xba\x8d\x39\x2a\xa9\xf6\xa3\xd1\x4e\x34\xda\x83\x46\xbb\xcf\xa8\x7f\xf7\x4d\x8c\x56\xfa\x47\xbc\xa8\xf6\x6d\x1b\x1f\x04\x3e\x55\x4e\xf9\xdd\xb3\xb9\xdc\x19\x7d\xda\xc6\x9d\x36\x8e\x2f\x5d\x2e\x53\x26\xf8\x3c\x4c\xef\xee\x5c\xa6\x75\x2f\x0e\xef\x9b\xf2\x92\x32\xbc\x70\xca\x4a\xfc\xf0\xbe\xa9\x17\x61\xc6\xbb\xcd\x7d\x3a\x66\xcf\xfb\xcc\xef\x5d\xfb\x7b\xcf\xfe\xde\xc7\x49\x89\x7e\x14\x60\x9a\xba\xf3\x86\xce\xee\xd8\xca\x40\xc2\x39\xca\x30\x9c\xeb\xa0\x21\x26\xc0\x88\xab\x23\xb7\x4f\xf7\xa1\x20\xae\xfe\x19\xd1\xdd\xe4\xf0\x2e\x60\xea\x9b\xca\x31\xac\x49\x8a\xde\x0b\x9d\x9a\x63\x58\x92\xb5\xca\xb3\x51\x3f\xa3\x7a\xac\xe9\x2e\x5f\xc2\x06\x66\x40\xb5\xcd\xd2\x0d\xbd\x13\xd2\x7d\xe5\xe9\xbe\xf0\x74\x3f\xdb\x4b\xf7\x85\xa2\xfb\xaa\x8b\xee\x67\x3b\x74\x3f\x0b\xe8\xfe\x22\x4c\x1d\xb5\x7a\xe3\xac\x8b\xee\x23\x4b\xf7\x91\xa5\xfb\xc8\xd2\x7d\xb4\x43\xf7\x17\x9e\xfc\x86\xee\x0b\x45\xf7\x15\xc6\xdb\xae\x4d\xf1\x70\x9f\xdb\x6c\xdd\x75\xed\x8a\x7f\x23\xd0\x3f\x05\xde\xbf\x0b\x6e\xaf\xce\x5f\xa6\x1b\x1a\x9d\x99\xcd\x6f\x2e\x22\x56\x6f\x83\x97\x51\x6a\x0f\xf5\xd6\x3c\xd7\x06\x58\x5b\x0c\x05\xdd\xeb\xc3\xf4\xd5\x27\x4f\x16\x66\x67\x7e\x1c\x72\x80\xa0\xf6\x8e\x26\xd0\x6e\x8b\xa0\x0f\x96\x20\x47\x05\x35\x47\x54\xf7\xc2\x17\x33\xf4\x67\xfe\x66\x81\xb7\xe9\x8a\xc6\x5b\x58\xd3\xfa\x34\x64\xc5\x37\x2a\x69\xe9\x93\x9e\xb3\x92\x0a\x19\x6f\x61\xb3\x5f\x62\x84\x5b\xc6\x66\x58\xdf\x78\xc2\xc4\x03\x4e\xcc\x88\x40\x9f\xfc\xed\x28\xee\x72\xc5\x5a\xc4\x75\x08\xa3\x99\x09\x69\x4e\x3b\x0f\xcf\x97\xfa\xa3\xdb\x1c\x35\xce\x84\x20\x29\x48\x6a\x23\xcc\x54\xda\x85\x12\xa6\xea\xe7\x3e\x94\xea\xe7\x1e\x14\xe6\xee\xaa\x99\x76\xc0\x6c\x1e\xf3\x15\x8d\x33\xbe\xa7\x3f\x9b\xf0\x1d\x6b\x22\xd0\x0b\x54\xe1\x2e\xc8\xd7\x7b\x21\x5f\x53\x73\x54\x3f\xa7\x30\x83\x72\xdf\xf9\xff\xac\x46\x61\x06\x05\xe8\x81\xaf\x33\x8f\xfd\x31\xa3\x02\x61\x49\x18\x2a\x31\x6c\xc8\x52\x65\x58\xa9\x9f\x91\x03\x7d\x13\xc2\xac\x7b\x39\xd9\x7b\x9e\xd7\x6a\xae\x82\x55\xdd\x96\xed\xfc\xfd\x85\x1d\xb9\xf3\x66\xe1\xe6\x18\xda\x4b\x09\x2d\xc0\x82\x72\x7e\x89\xad\xf0\x5b\x10\x86\xa6\x0a\xbf\x85\x91\x4e\x8b\x3f\x0b\xbf\x12\xce\xfe\x38\x7e\xa6\xf0\xef\xc7\x4f\x97\xdb\x6e\xb7\xc0\x89\x1a\x26\x90\x69\x56\x83\xca\x5c\xf9\x66\xd1\xca\xf6\xa1\x15\x55\x5d\xf0\x46\x94\xa2\x6a\x47\x60\x65\x2a\x51\x49\x9e\x55\xd7\x80\xf5\xc6\x1b\x1b\xaa\x23\xb6\xbf\x40\x02\x63\x13\x2b\x7e\x41\x6f\xb8\x14\x60\x65\x94\x0b\x49\x5b\x17\xec\x34\x73\x3d\x17\xb0\xa2\xa0\xaf\x94\xc2\x18\xce\xe8\x9e\xbb\x6b\x76\x2f\x12\xf2\x46\x60\x06\xcc\x63\xdd\xa0\xf9\x96\xb0\x30\xce\xfd\x73\x01\x4c\x8d\x67\x0d\xc7\x25\xdd\x77\x7d\x54\x8e\xce\xe8\x3e\x30\x73\xf4\xab\xd0\x11\xf4\xb7\xf6\x42\x80\x77\x5f\x0f\xa7\x55\x5a\x4c\xf7\x8d\x4c\xf7\x0d\xc7\x6d\xe8\x3b\x18\xc2\x23\x54\xe1\xfd\xb7\xee\x54\x46\x3c\xd8\x9c\x19\xde\xee\x60\xde\x75\x1e\xef\xc4\xa1\xc1\xe8\x82\x7e\xed\x05\x50\xd6\xee\x7a\x1c\xf6\xb1\xbf\x09\xdb\x50\x46\xea\x2b\x8f\xe0\x7c\x77\x0e\x6b\xf3\xd1\x27\x4b\xcb\xb7\xbb\xb4\x0c\x31\xb8\xc1\x65\xf0\x9c\xba\x4e\xb1\x3f\x9f\xe9\x4d\x8e\x64\xb6\xdc\x8d\xe1\xbb\x7c\x20\x5f\x6d\x58\xb4\x49\x8b\x30\x92\x6f\x18\xfd\x4a\xdc\x18\xc9\xd7\x97\x36\xa1\x7c\xed\xa0\x67\xfc\x22\xd9\xdf\xba\xc4\x57\x32\x0c\x19\xf6\x24\x95\x74\xc0\xf8\x05\x32\x8e\x7b\x01\x4c\xd3\xda\x13\xed\x11\x25\x9f\xe9\x20\xfc\x06\x0f\xf7\xcf\xba\xfb\x6f\x12\xfa\x87\x74\x31\x76\xfd\x1d\x51\x9d\x3c\xf1\x90\x82\xb5\xd3\xd3\x9d\xcf\x9d\x13\x71\x45\x02\xbf\xea\x47\xea\x43\x8e\x5e\x48\x90\xc0\x31\x0e\x22\x8d\x7d\x91\x90\x41\xa5\xd0\x39\xd9\xa7\xe4\x48\x30\x0a\x0b\x70\x42\x0d\x20\xda\x5e\x85\xd7\x4e\x52\x1d\x73\xbe\x05\x66\xbf\x41\x95\xb9\x49\x4a\xe0\x64\x7f\x4e\x35\xef\x5b\x2f\xd9\x37\x9a\xaa\x8c\x5f\xc0\xd3\xfd\xc4\xd4\x60\x09\xa0\x36\x40\x55\xd9\x05\x1e\xf3\xde\xb4\x14\x27\x4d\x47\x4d\x19\x3a\x6a\xd2\x1b\xfc\x38\xad\xc7\x6b\xc7\x21\x7b\x8e\x9e\x2b\x12\x53\xe3\x26\x6e\x2e\x32\xdd\xc2\x1b\x73\x79\xfa\x4b\x1a\x78\xb2\xe6\x2b\x1a\x63\x78\xbc\x6f\x50\xda\x90\x5d\x65\x22\x61\x6d\x62\x88\xd3\xd2\x38\xf1\x7e\xa2\x44\x7b\x8b\x3f\xa6\x56\x25\xc2\xf0\xac\x45\x92\x70\x11\x0a\xd5\x5e\x72\xd1\x71\xc7\xd4\x77\xaf\x71\x4f\x95\xe6\xab\xe9\xdd\xbd\x84\x62\x83\xe9\xdd\x2d\x3c\x94\x83\xf3\xbc\x28\x34\xd2\x5b\x0c\xd3\x4e\xcb\x41\xcb\xc9\xfb\xdb\xe4\xb6\x4d\x3b\x4f\x51\x1d\x0d\x03\xeb\xe5\xa2\x6a\x45\x0d\xb8\x3f\x82\x4a\x87\x55\x21\xd3\x7c\x15\xa0\xc7\x6c\x03\x73\xa2\x64\xec\x89\xa6\x2c\xc3\x30\x23\x05\x7a\x25\x94\xde\x06\x15\xcc\x21\x1b\xf8\xae\x80\xfd\x0d\xb9\x0b\xd3\xa4\x0e\x3c\xb1\xc7\xa9\x79\x4d\x66\x0a\xdb\xa5\xfa\x19\xc1\x46\xfd\xdc\x6d\x8c\xc9\x6e\xa6\xd4\xbd\x3e\x07\x79\x93\x93\xb1\x95\x08\x6b\x58\xe2\x2d\x6c\x34\xe3\xbd\xd8\xcb\x65\x06\xb4\xa7\x1b\x2a\x2e\x5b\xbe\xe2\xcf\xf7\x2b\x12\x2f\x29\xca\xd1\x0b\xea\x2f\xbd\xbb\x25\xbc\x83\xce\xab\x05\x47\x07\xb4\xc6\x19\xdd\xdc\x39\xb3\xc5\x9d\xfe\xcd\xf9\x8a\xde\xe0\xdf\xfc\x89\x06\xfe\xcd\xcf\x68\xe0\xdf\xfc\x94\xc2\x4e\x2c\xaf\xe7\xd4\xd8\x05\xbf\xa2\xf0\x23\x25\x8f\xe4\x20\xb8\xe3\x01\x5e\xeb\x14\xfb\xf2\xc4\x7e\x66\x95\xa4\xf0\x8b\x7e\x59\xf2\x4a\xc0\xaf\xfa\xd1\x5f\xcb\x00\xef\xdd\x3b\xfc\x60\x4a\x70\x26\x97\xf0\x9b\x7e\xbe\xa4\xa9\x80\x2f\xfa\xd1\x5d\xf8\x00\xdf\xeb\x57\x73\x4d\x04\xfc\x4c\x09\xb2\x1f\x8d\x0b\x35\x68\x7f\xef\x2f\x54\x89\x0c\xc7\x63\x6f\x2b\x16\x6f\x31\xfc\xc3\xaf\xe6\x7e\x4c\x59\xbc\x85\x9f\x28\x41\x6e\x5d\x0b\x53\x31\x28\xf8\xa2\xf3\x4e\xec\x7c\xc7\x2a\xeb\x68\x46\x33\x3e\xa3\xe2\x41\xec\x08\x64\xaf\x7f\x58\x95\x8b\x46\x44\xc7\xf4\xd6\xa2\xe6\x1a\x88\x76\xb9\xf2\xb6\x72\x61\xe6\x79\x07\x43\xb6\xb3\x83\x7d\x6f\x04\x8f\x2c\x6e\x85\x8e\x55\x45\xe7\x25\x15\xb3\xdb\x9b\x8c\xe7\x39\x2d\x66\x31\xe8\x9f\x3d\x00\xac\xbf\xa2\x1a\xed\xbc\x12\x1b\x17\x9a\x3d\xd5\x6c\x6e\xc5\xe3\x9c\x5e\x1e\x6a\x2c\x62\x5f\xc1\xfe\xc0\x9b\xdd\x55\xac\xd2\xf5\xe1\x2a\x65\x97\xb1\xe6\x91\x1a\x92\x72\x37\x1e\xe7\x2d\x35\xf9\x70\xf9\x1e\x97\xee\xdb\x30\x2e\x6f\x45\x8b\x33\xfa\x6a\x1e\xd7\x90\xc8\x76\x38\x4a\x2f\x25\x14\x86\x13\x71\x7a\x43\xd4\x48\x93\x03\xe8\xe9\xae\x0f\x71\xb0\x34\x71\xb9\x80\x9d\xee\x3a\x08\x37\xb6\x85\xeb\x9c\xc0\x4f\x77\x3d\x84\x5b\x41\x46\xc2\xdc\x90\x85\xf9\x1f\x85\xf9\xa1\xda\x53\x02\xaa\xd3\x56\x18\xc1\xe0\x13\x4c\xf7\x96\x82\xe9\x69\xd3\x95\xb8\x59\x0e\xf2\x1b\x4a\x42\x7e\xda\xed\x5c\x6c\x22\x20\xf2\xf3\xae\x91\xf3\xb4\xad\xa3\x24\xf1\x5a\xe4\xab\x5c\xea\x5b\x51\x74\xcc\xd7\x20\x90\x6c\xe8\x48\xdc\x2e\xd6\x1a\x18\xe6\x8a\x85\x6d\xc3\xad\xb8\x5d\xa4\x35\x24\x77\x8a\xfc\x81\x56\x9e\xed\xa0\x6d\x78\xd2\x86\x18\x6f\xf2\xe4\xf3\x76\xe6\x6e\xe9\xf7\xaa\x19\x44\x31\x9e\xc6\x63\x39\xc6\x7e\x4b\x53\xa6\x0b\xbb\x39\x50\x53\xce\x2e\xfb\xe3\xa7\xda\x1f\x22\x67\x8b\x28\xee\x4b\x1d\x73\xb6\x8f\xe2\xa9\x3e\x34\x3c\x8e\xe3\x24\x8e\x52\x19\xc5\x7d\x81\xfb\xb1\x0e\x3e\xea\x82\xba\x2f\xb8\x4c\xa2\xb8\xff\x1a\xb9\x7b\x16\xcc\x46\x83\x41\x3e\x11\x7d\x12\x4f\x54\x7d\xfa\xbd\x1f\x9f\xc6\x20\x89\x34\x61\x5b\xcd\xdd\x0d\x26\xb8\xb3\xa6\xae\xce\x3d\x50\xb9\xf5\x7b\x67\x4e\x43\xa3\xa4\x76\xc0\xd6\x91\xf1\x34\xbd\x80\x91\xe1\x98\x1d\xd5\xd1\x15\xfa\x7d\x13\x70\xe2\x95\x89\xab\xe0\x14\xf2\xe7\x61\x48\x77\x1a\xcd\x79\x51\xf0\x0b\x85\xb7\xab\x28\xde\x87\xb8\x8d\xfa\xee\x42\x55\x7c\x60\xb1\x0b\x4e\xad\x3a\x23\xd9\xad\x3f\x8d\x3e\xaa\x4f\x1f\x23\x2b\x67\xf6\xd7\xac\x89\xbe\x2a\x17\xdb\x86\xdf\x77\x1d\x0c\xc0\xdd\x01\x20\x8f\xe3\x8a\xd9\xe8\xfc\x71\xf2\xe3\xdb\x57\x27\x03\xe3\x1b\x9b\xcf\x2f\xbb\xbc\xc1\x4d\x18\x71\x29\x2e\xaf\x28\xd1\xb9\xb5\xa3\xb0\x5a\x2f\x66\xa9\xe6\x89\x86\xe3\xed\xf7\xf9\x86\xb2\x48\x43\xbf\x49\x8b\x7c\x16\xa9\x22\x16\x36\x5a\x96\xe9\x82\xfa\xa8\xe1\xbf\xe8\xb5\xf9\x1e\x6f\xf1\x5f\xf5\x8b\x23\x38\xb7\x61\xc0\x64\xba\x30\xc1\xbb\x0c\xa3\x24\xaf\x25\x7a\xa5\xc3\x4d\x86\x2e\xdf\xaa\x92\x0e\x7e\x3d\xe3\xbc\xa6\xb0\x7a\xa1\x29\x8b\x09\x51\x6c\xca\xe7\x91\x38\x7e\x83\x04\x4e\x9e\xa2\x38\x8d\x1e\xa9\x9c\x3e\x6c\x78\xce\xfc\x6e\x57\xcc\xaa\xd5\x19\x15\xf1\x41\x5d\x4a\x15\x30\xbe\xce\x6a\x31\x78\x78\x77\x74\xff\x6f\xf7\xff\xfb\xde\x5f\xef\xff\xed\x48\xf4\x7a\xe2\xa8\x7e\xef\xf5\xd0\xf0\x5a\x68\x87\x79\xd3\xd4\x41\x5e\x3e\x53\x3a\xa0\x22\xe5\xf5\xb5\xf8\xaf\x51\xab\x2e\x95\xc9\xf2\x86\x76\x53\x6e\xc1\xd0\x09\xb9\x71\x68\xae\x43\xa2\xeb\x7e\xf5\x25\xed\x6b\xbb\xa4\xd0\x23\x31\x65\x99\x4a\x33\x8a\x9c\xfa\xd0\x8f\x63\x5b\xab\x49\xab\xab\xd5\x8a\x89\xdb\xeb\x73\xd7\xa9\x1c\xbf\xf1\xe3\x57\x95\x32\xca\x8b\x2b\x61\xa6\x7f\x57\xa4\xc6\xac\xc8\x4b\xa9\x4d\x1b\x0e\x50\x03\x0a\xed\x3e\xed\x3d\xda\x34\x10\x2f\x54\x56\x55\x61\x3d\x70\x4d\x7c\x54\x56\x47\x50\xd0\xd1\x50\xf4\xd9\x1f\x3f\x8f\x0f\x08\x41\x1b\xc5\x47\x03\x3b\x74\x40\xe8\x70\x31\x9a\x25\xdc\x5a\x00\x31\xd8\xe0\x31\x75\x31\x97\x37\x06\x03\xa8\x99\xf4\x0d\x72\xf2\x28\x55\x30\x7d\x1d\xb0\xcc\xa4\x35\xc0\xe5\x1e\x4c\xc8\xf4\xfd\x7c\x2e\x5c\x01\x30\xc2\xff\x30\xe4\x99\x92\x4e\x16\xea\x1a\x64\x73\x85\xe6\x8f\x6f\x4d\x13\x99\x8b\xd8\xbd\x4a\x2f\xcf\xc2\x5e\xb0\xc3\xaa\xdd\x96\x69\xe8\xf8\x85\xa3\x06\x4e\x3e\xe1\x86\x90\x35\x67\x18\x56\xc6\xfa\x21\x7a\xf6\x1b\xcd\x64\xc0\x5c\xbd\x9e\xe2\x81\x03\x42\x44\xaf\x57\x45\x39\x8b\xc4\xf1\x9e\x06\x27\x95\x45\xee\x78\x93\x3c\x46\x15\x6c\x0c\xdf\xb1\xc8\xd4\x69\x2f\xe2\x88\x74\x73\x75\x14\xeb\xaa\x1f\x7f\x0c\x47\xa9\x9e\x2d\xdc\x9d\x0a\xfa\xd5\x87\x0d\xd8\xe9\xad\xe3\xe9\x03\xdf\x1d\x7a\xd8\x45\x05\x67\x0b\x2a\x22\xdd\xc9\x83\xe8\x84\xd2\x59\xa4\xeb\x88\xe2\xfe\xd4\xce\x57\x52\x87\xd6\x4e\x05\x35\xa1\xb5\xe3\xbe\xab\xa1\x1f\x47\x94\x49\x91\xd3\x52\x0f\xdc\x7d\x58\x4e\x6b\x2c\x5f\xa2\x69\x8d\x65\xea\x79\x45\x63\x52\xab\xcb\xda\xe6\xc7\xd2\xb5\x16\x39\xd7\xd7\x6e\xc8\x5d\x5f\x77\xf0\x61\x83\x0d\x6d\x61\x77\xb3\x42\x4e\x9a\xd1\x36\x52\xdd\x2d\x37\xf2\x5d\xda\xe2\xbb\xc7\x28\x55\x7c\x67\xa2\x14\xfb\x38\x52\x29\x38\x5e\x19\xe7\x6e\x2c\x95\x90\x07\xa3\x28\xf7\x3c\x68\x35\x79\x3f\x01\xcf\x15\x27\x55\x2c\x83\x82\xf8\x86\xdd\x4c\x5c\x84\x33\x71\x1b\xcc\x62\xc2\x4e\x1d\xb7\x3a\xf0\x36\xe3\x39\x99\x7b\xc6\xad\x9b\x9f\xbb\x41\x6c\xd5\xff\xa4\x9e\x58\x3a\xb0\xf6\xfd\xa4\x52\xfd\x5d\x50\x1b\x7f\x0d\x14\xee\xd4\x24\x66\x64\x72\x0a\xeb\x00\x09\x17\x7f\xda\x9c\xc6\x59\xd7\x37\xd5\xd4\xda\xde\x76\x61\x11\x22\x84\x6c\x9a\x48\xcc\x4c\x98\x93\x0d\x86\xb5\x3e\x6e\x77\x88\x3c\x43\xb3\x0e\x7d\x41\xa9\x76\x6a\xe6\xf7\x17\x61\x98\x05\x71\x3d\xd0\xcd\xd7\x6d\x23\xa4\x87\xbd\x95\x43\x06\xb1\x50\x0e\xb4\x5b\xb1\x9e\x33\xb5\x19\x5d\x0d\xd2\x81\x3f\x1f\x0a\x67\x54\xdf\xd0\x2e\x44\xba\x45\x6d\x2d\xb6\x2a\x17\xe3\x60\xfe\xad\xa7\xd4\x70\x6a\x6b\xcc\x56\xbb\x33\xc6\xc1\xb0\x63\xe2\xb1\xb3\x8d\x6e\x44\x3f\x85\x53\x4a\x28\xb1\x43\xd9\xd7\x1e\x61\xb6\xae\xf7\x61\xef\xbb\xa7\xa6\xd0\xf3\xad\xea\x77\xdd\xaa\x7e\xea\xf5\x6e\x2a\xec\x94\x58\x57\x58\xbf\xd7\xf1\x77\x6e\x2e\x5c\x8f\x95\xba\xf1\x8a\x65\xa6\xed\x8a\x65\xbd\xde\x0f\x28\x18\x32\xbe\x78\xd9\xcd\xec\x51\xcd\xcb\xc6\xcb\xc7\xbe\xdc\x0c\x84\x65\x72\x5b\xc5\xbe\x06\xb7\x8d\x40\x2f\x7b\x82\xfe\x1c\xd4\xc1\x82\x6a\xbe\x0a\x22\xff\x28\xd5\x5b\x8f\x74\x35\xc7\xbe\x47\x52\x8f\x6f\x3d\xf3\xf9\xdc\x8e\x1f\x1a\x91\x5f\xc2\x30\x65\x4d\x75\x56\xe8\x9b\x37\x1a\x71\xc1\xc2\x10\x2f\xb2\x15\xc0\xa5\x5e\xf6\x5c\x6d\xdd\xe0\x95\xe1\xe0\xb5\x57\xd3\x88\x09\x1d\x4c\x87\xa7\xe6\x58\x41\xea\x2b\x7c\xdc\x08\x15\xee\x6c\x86\x32\x45\x9a\x44\xa2\xdf\x30\x88\x8a\xbd\x62\xee\x3e\x5a\xf4\x44\x27\x98\x78\x24\x86\x80\x27\x55\x51\x24\x85\x7d\x79\xed\xd6\x55\x49\x69\x53\x1e\x9b\xb0\x20\x3a\xe4\xcb\xdc\x95\x79\x66\xd6\x91\x68\xe6\x12\x9e\x9b\x55\x22\x5a\x63\x58\xa5\xeb\x91\x89\xd7\xb2\x4a\xd7\x77\x13\x81\x2e\xf4\xd3\xbd\x84\xa2\x73\xfd\x74\x3f\x61\xe8\xad\x7e\xfa\x2e\xe1\xe8\xb3\x7e\xfa\x6b\x92\xa1\x47\xfa\xe9\x6f\x49\x85\x1e\xea\xa7\xff\x4e\xa6\xe8\xc4\x35\xf0\x13\xbd\xfc\x55\x8d\x9a\xd7\x69\x2e\xca\x64\x13\x5c\x0a\x77\x86\xcd\xc5\x71\x29\xb8\x9b\xe4\x72\xd0\x7c\x93\x5c\x42\x3e\xa3\x4c\xe6\xf2\x32\xf9\x02\x86\x24\x1a\x59\x73\x31\xa6\x7e\xd7\xd3\x56\xb2\x1c\x48\x6e\x15\x16\x9b\xae\x63\xb1\xf8\x58\x3a\x36\xf1\x95\x9e\xd0\x92\xef\x81\x7e\xaa\xd2\x42\x55\xfb\xde\xdc\x47\xfd\x4f\x4a\x7e\xa2\x83\xba\x24\xfc\x9d\x12\xe4\x53\x4c\x15\xfe\xd5\xd4\x82\xe1\x9b\x30\x8f\x82\x4b\x65\x71\x00\x63\x90\x4c\x7f\x76\x09\xb0\xe7\x19\x83\x60\x75\xe3\x40\x4d\xa9\xba\x67\xc1\xbf\xf9\xae\x45\x56\xbe\x61\x0c\x4c\x97\xf5\x37\xe4\xe8\x37\x1d\x2f\x38\xd3\x8f\x2e\xec\x7b\xa5\xdf\x44\xc5\x60\xea\x9e\x1c\x4b\x41\x6a\x5a\x54\xfd\x05\xe6\xf7\x6f\xf6\xf7\xaf\x18\x4a\xff\xf1\x3b\x9b\x78\x1f\xc3\x5c\xd7\xa1\x58\x02\x0a\xf7\x78\x17\x66\xee\x71\x04\x6b\x53\x4a\x77\x62\xd7\x6e\x7e\x5e\xa3\xe8\xb9\x13\xac\x90\x35\x97\x54\x2f\x43\x32\x68\xde\xac\xe9\xa0\x79\x17\xc3\x86\xed\x3f\xd3\x7d\x0f\x4b\x66\x4f\xf1\x61\xa5\xe1\xea\x60\x42\x58\xb0\xee\x38\x2e\x5d\xc0\xe9\x89\x41\x07\x1d\x39\x0b\x41\x0b\xfa\xc4\x4c\x46\xb8\xb3\xbf\xb4\x31\x15\x86\xcb\x00\x94\xe0\xab\x9e\xdb\x30\xbc\xeb\xfe\x6a\x27\x36\x0c\x17\xac\xf3\x38\x99\x75\x07\xd1\x9b\x1c\x7e\xb8\xf3\xe1\xc3\xff\x7e\xf3\x97\xfe\xf1\x00\xe1\xeb\xc9\x87\xd3\xab\xed\xe9\x9d\x05\xc4\x1f\x3e\x7c\xd3\x8b\xdb\xb7\x97\xb8\xe5\x18\xbd\x88\xde\xd0\xc5\xd3\xcf\x6b\x24\x07\x25\xaf\x44\x46\x21\x5e\xe4\x71\xfb\x32\xb3\x8e\xec\x10\x2f\xe2\xf6\x25\x6c\x75\x46\xab\xcb\x0f\x56\x76\xd1\xdf\xba\x6e\x0c\x28\xbe\x92\x24\x7e\x58\x14\xb1\xbf\xe2\xeb\x78\x74\x67\x98\x68\x81\xe9\x85\xbc\x0e\xee\x06\x19\x19\x42\x45\x28\x4c\x49\x10\x4f\x0e\x72\x72\x38\x1a\x67\xfd\xfe\x91\xec\xf5\x74\xf8\x37\xfa\x99\x66\xa8\xc2\xb8\xd7\xcb\xcd\xd4\xe1\xb2\x06\x77\xc2\xa4\xfe\xc2\xd6\xc3\x11\x94\xc1\xc2\x2a\xc5\xe3\xf4\xc1\xd0\xca\xed\x39\x61\x93\xf4\x74\x5c\x4e\x0e\x0f\xd3\x53\xe2\xb7\x42\xe6\xc7\x9f\x92\x17\x68\x8e\xb7\x36\xac\xdc\x95\x46\x2e\x61\x93\xe1\x29\x94\xd5\x99\x7e\xa3\x65\x12\x46\x02\x2b\x6d\x40\xa9\x84\x99\x19\x1c\xcc\x72\x5c\x1b\xeb\xe6\x21\x8c\x7e\x42\xa8\x93\xc8\x14\xf6\x45\xaa\xcb\x51\xd7\xfd\x45\x46\x45\xcb\xfa\xfd\x07\x44\xd6\x31\x6e\xea\x19\xd3\xdf\x3d\xe9\x48\x70\x0f\x78\x40\x02\x86\xc7\xcc\x93\xa0\xaa\x73\xeb\xbb\xdf\x26\x87\x87\x2c\x20\x45\xa5\x49\x51\xd5\x57\xba\x39\x62\x88\x7d\x94\xe0\x8e\x12\x75\xbd\x3b\xf0\xdc\x3d\x0d\xe8\xb3\xdd\xcf\x1f\xe6\xb4\x77\x58\xc7\xdd\x75\x83\x40\x00\x6f\xdf\x0a\x0d\xe6\x4e\x4b\xb4\xb7\x36\x4c\x08\x19\xdd\x19\xd6\x01\x06\x6b\x98\xa9\x8d\xe3\x26\x30\x6e\xf0\x24\x05\x7b\x8b\x4f\xc8\x8f\x0d\xee\x1c\xcb\xc3\xc3\x90\x2d\x39\xc6\x63\x6c\x6f\x12\xe2\x36\x08\x68\x05\x96\x29\x30\x6e\x56\xe5\xf0\x6a\xe7\xc7\x18\xf6\xb3\x47\xe6\xcd\x3c\x04\x5d\xd0\xcf\x49\x06\x4a\x1f\x7b\xce\x4a\xca\x4a\xa3\x1f\x70\xa0\x65\x96\xae\x69\xc2\xc2\x80\x68\x15\x86\x79\xce\x66\x89\x40\x53\x1d\xe9\x4d\xd1\x31\xa1\x28\x77\xb1\xe0\x04\x4a\x8d\xa9\xc7\xb9\xbe\x9b\xed\x3c\x2f\x0a\x78\xcb\x88\xb6\x14\x29\x28\x35\x97\x8d\xac\xd3\x0b\x86\xe1\xf3\xae\x80\x6e\x9e\x8e\x76\xd8\x02\x51\x7b\x0e\x6e\xe3\x74\x6f\xb7\x18\x1e\xb1\xdb\x02\xf4\x77\xd9\x14\x99\x10\xfd\xda\xea\x5b\xe9\x57\x9d\x37\x7c\x44\x5a\xf5\xc2\xf0\xb0\x73\x1e\x90\xfa\xa0\xfc\x84\x91\x0b\x66\xa3\x8c\xbd\xd1\xcf\x96\x28\xf0\x54\xbf\x29\x62\xc1\x4b\x46\xd0\x05\xab\x03\xb0\xa9\xe7\x26\xb5\x41\x17\x5c\xd0\xcf\x18\x1e\xeb\x72\x86\xf6\xf0\x89\xdd\x14\xe4\xde\x0e\x22\x19\x0e\x22\x61\xc7\x0d\x75\x63\x83\x75\x23\x67\x89\xf2\x50\xbe\xe4\x6a\xe6\x72\x57\x98\x3c\xf3\xe6\xf1\x8a\xfd\xb7\xf0\x82\x11\xd4\x30\x2c\xe8\xb0\x57\xd8\x89\xe2\xd5\x65\xf3\xc6\x74\xbc\x72\x7d\x9b\x87\xb6\x4b\xbb\xbd\xce\xe7\xbf\xb7\xce\x8e\x4e\x7a\x26\x90\xb4\x5f\x9f\xef\xd5\x07\xac\xbd\x9c\xb0\x19\x5f\x75\x75\xb7\x3b\x6f\xa6\xb2\x33\x60\xc7\x8f\x8c\xbc\x62\x48\x52\x0c\xaf\xf7\x36\xf3\x8a\x21\x6b\xbe\xd1\xb6\x7a\xf0\x21\xcc\xe1\x49\x27\xab\xa5\xe8\x07\x78\xcd\xe0\x47\xa6\x15\x8c\x5f\x3a\x18\xde\x66\x7c\xc2\xb4\xf1\x8d\x84\x17\x0c\xb9\x68\xf3\x7b\x81\xb1\x16\x69\xbe\xed\x5b\x4c\x15\x74\x89\x05\x35\x97\x69\xd2\xdf\x53\xe8\xf2\x8f\x14\x7a\x7b\x43\xa1\x0e\xe3\x16\x53\xa8\x6d\x13\x19\x5e\x23\xa9\x95\x3d\x76\x4b\x6d\xfa\x12\xc9\x77\x5f\x55\x4b\xcb\xc2\x75\xaf\xa8\x79\xc5\x6c\x34\xb2\x57\xcc\xda\xad\x76\x69\x69\xdd\xd7\x51\x37\x78\xfe\xc6\x5b\x69\x9b\xfa\x97\x59\x66\xea\xbb\xc6\xf4\x7d\x98\x8d\xab\x97\x7a\xbd\xd0\x32\x90\x21\xcb\x00\x5e\xac\xa5\xb3\xd9\xd3\x0d\x65\x52\x2d\x74\x28\xa3\x02\x09\xc8\x1a\x40\x2b\x2d\x72\xc5\x37\x74\x37\xd7\xb6\x71\x6d\x22\xfb\x7a\x43\xc6\xb3\xd0\x70\xd1\xf4\xc5\x8c\x67\xe6\x36\xe4\x05\x95\x4f\x0b\xaa\x1e\x1f\x5d\x3e\x9f\x21\x89\xc7\x14\x59\x85\x91\x1d\x07\x16\x88\x02\x31\x8c\x13\x7b\x21\x8a\xb3\x2c\x3a\xe1\xf2\x19\xaf\xd8\xcc\x8e\x54\x63\x4a\xb3\x47\xb9\x45\x9d\xa6\x45\x72\x30\xe7\x59\x55\x22\x0c\xee\x56\xd4\x9d\xbb\x7b\x6f\xab\xe0\xac\xa8\xc4\x9e\xf2\xd5\xd7\x94\x2f\x33\xc1\x8b\xe2\x1d\x5f\x6f\xdb\x8a\xf1\xef\x28\x4b\x44\x27\x00\xe9\xef\x02\x80\xb8\xe7\x1f\xa8\x8e\xc8\xd9\x55\x63\xf9\xf5\x35\xbe\xa0\x73\xb9\xc5\x7b\xec\x5d\xbe\xa6\xf0\x1e\xa4\x8a\xdf\x07\x82\xc7\xea\x7d\x3e\x93\xcb\xce\x1a\x67\x2d\xc8\x44\xc3\x60\xab\xcb\x27\x47\x2d\x0e\x69\x7d\xba\x17\x89\xb0\x0d\xb3\xfb\xf5\x6b\x5e\xe6\x67\x05\xdd\xcd\x99\x15\x39\x65\x72\x6f\xce\xf7\xb9\x5c\x3e\xe2\x62\x46\x45\x19\x14\xe2\xf3\x79\x49\xbf\xaa\xd0\x43\x36\x7b\x99\x8a\x45\xce\x4a\x73\xa6\x41\x89\x50\xa3\xec\x91\x1a\x28\x39\x5b\x3c\xd6\xad\xbf\xa1\x99\x44\xc1\xf5\x07\x3a\x04\xab\x8e\xf8\x3e\x97\xdb\x8e\xab\x7d\xff\x04\xd2\x18\xa6\xfa\x2a\xda\xec\xcf\x7a\x13\x71\xbe\xaa\xd4\x1f\xa2\xce\x19\x97\x92\xaf\x0e\xe9\x40\xf2\xb5\xa2\x8e\x71\x60\xb9\x6a\xcb\xd2\x24\x10\x73\x5b\xe8\x10\xa3\x8d\x0c\x5b\xd8\x10\x8a\x82\x03\x75\x7f\x4e\xe3\x84\xe3\xb1\x7b\x48\x96\x18\x16\x7b\x32\x5f\xe4\x6c\xc6\x2f\x8e\xcd\x8f\xca\x78\x46\xba\xb2\x09\xfa\xa9\xa2\xa5\x7c\xc8\xf2\x55\xaa\x20\x78\x26\xd2\x15\x3d\xee\x4c\x4d\x9a\x66\xe0\xd8\xb9\xce\x5d\x71\xf6\xc4\x01\x24\xd0\x06\x03\x67\xef\x4d\xab\x3a\x04\xb4\x16\xa4\x09\x07\x25\x0f\x93\x0c\x16\x54\xbe\x75\x82\x25\xa9\xa0\x0c\x5f\xa5\x5a\x5f\xf8\x0c\x3a\xb4\x73\x59\xe7\xb0\x21\xa3\xe7\x18\x24\x7f\xa4\x29\x9f\xa4\x20\xb9\x09\xfb\x5c\xc0\x92\xda\x20\xd2\x6b\x0c\x17\x6a\x3c\xe8\x9d\x4c\xb3\x95\xf7\x2b\x23\xe8\x17\xa6\x45\x32\xfc\xc2\x8c\x6c\xc7\xf0\x9e\x91\x5f\xd8\xc0\x41\x0b\x3f\x98\x4c\x35\x36\x9d\x73\x36\xdb\xb9\x01\x5a\xd2\xcf\x32\x06\xf5\xbf\x61\xf5\xc2\x1b\x46\x9d\x9d\x9a\x45\x86\x9c\xcb\x46\xc7\x5d\xa5\xf5\x9a\x7c\x89\x04\x56\xab\xf0\x01\x4b\x57\xb4\x5c\xab\x75\x46\x46\xd8\x60\x9e\x9a\xeb\xc2\x27\xa7\x30\x25\x43\xb7\xb9\x4c\xc3\xcd\xe5\x5c\xdb\xa7\x8f\xa7\x7d\x92\x0f\x66\xb4\xcc\x28\x9b\xa5\x4c\x96\x8f\x79\xc5\xe4\xf5\xf5\x10\x2a\xb3\x7a\xcc\x31\x50\xbd\xf3\xec\xef\xb7\xed\x93\xca\x1d\x2d\x37\xee\xb9\x36\xc6\x87\xba\x65\xb5\x7a\x5c\xe6\xc5\x4c\x50\x96\x54\xe0\x41\x4b\x38\xb4\x5b\x4a\xa6\xdb\x9d\x8b\xf8\xff\x7c\xfc\xa6\xa3\x7f\x15\xc5\x73\x7a\x49\x67\x87\x7f\x16\xa2\xd3\x56\x5c\x63\xd3\x46\x56\x95\x92\xaf\x62\x5b\xf3\x12\x49\x6c\xf1\x5c\xf1\x19\x2d\xd4\x42\x6e\xb5\x2e\x12\xba\xdd\x73\xdf\x8c\x63\x39\x6d\x0b\x1f\x5c\x24\xae\x80\x4e\xc4\x2e\x40\xa3\x3e\x12\x5d\x64\xc1\x6d\x7b\xd3\x1d\x40\xe5\xb2\x62\xe7\xde\x38\x32\x15\x0b\xb5\xca\xd4\x89\x6a\x95\xa9\x9a\xb3\xd7\xd8\xef\xbb\x82\x7e\x6e\x4c\x14\xc3\x41\xe4\x47\x83\xd8\xbd\x62\x3e\xbc\xbd\xd7\x99\x2e\x76\x94\x75\xde\x48\x3b\x73\x51\x43\x6b\x9e\xd7\x66\x8d\x1d\x75\xd4\x57\xbb\x6d\xdb\xf7\xc3\xfb\xe3\x1a\xa0\xfb\x0e\x6c\x98\x3e\xb0\xd1\xfc\x7a\x4e\x2f\xc7\xf9\x1c\x71\x42\xc8\x4c\x5e\x5f\xab\xdf\xb5\xfd\x2d\xfc\x65\xec\x74\xc2\x4f\xf5\x0d\x50\xd9\x44\x2d\xf7\xd3\xe2\x27\x7a\x79\x4a\x98\x33\x0b\x99\xf0\x53\x92\x99\x00\x30\xb6\xaa\x79\x00\x47\xe5\x8b\xc3\xd4\x95\x71\x50\x4d\x9b\x23\x61\xaa\x46\x42\x35\xc9\xf5\x31\x52\xae\xed\xf8\x55\xda\x68\xab\x9b\xa8\x7c\x13\xb1\xe7\x60\xed\xb5\x8a\x85\xaf\xd7\xe7\xc8\x8a\xb4\x2c\x4f\xd2\x95\xcd\x71\x65\x76\x45\x55\x3d\x63\x5d\x99\xdf\xe2\x4b\x8f\x6d\xd9\x24\xed\xc7\x51\xdc\xb7\x6f\xa6\x2d\x9d\xd5\xd5\xdd\x38\xd2\xba\x32\xdc\x4f\x83\xc1\xb4\xcf\xfe\xf7\x9c\x5e\x26\x73\xd9\x61\x78\xd9\xb4\xf1\x55\xd9\xba\xec\x2c\xcf\x76\x72\xcd\x24\xd8\x4e\xe8\x2c\x70\xd9\x1a\x0c\xaa\xc8\xba\x2e\x22\x6c\x91\x2b\xf3\x13\x62\x20\xb7\xbb\x97\xc7\x37\xaa\x29\x76\x5b\xbe\xe2\x6b\x95\xbd\xd4\x43\xd7\x18\x0f\xd3\xb0\x9a\xc6\xfd\x40\x48\x0e\x6c\x76\xbd\xaa\xb3\xcf\xd7\xd7\x3e\x79\x50\x4a\xbe\x7e\x2d\xf8\x3a\x5d\xe8\x59\x3b\xcc\xd6\xfe\xd6\xeb\xd5\xc5\xd6\x82\x2a\x6d\xe4\x89\xf1\xb8\x6c\x94\x6a\x7e\xc2\xbd\xde\x4f\x74\xe0\xce\xc9\x3a\x4f\x78\x5b\xc6\xc6\xf5\x22\x5a\x0d\x96\x03\x35\x2e\x8e\x45\xf2\x0e\x09\x37\x12\xc0\x9e\xb4\xbb\x16\x21\x47\x33\xa6\x37\x28\x4c\xb2\xab\x77\xf7\xee\xf8\xda\x7a\xe0\x72\x4d\xad\x8e\x69\x84\x56\x7d\x38\xad\xe4\xd4\xf5\x35\x32\x0f\x44\x0e\xf4\x77\xa5\x10\xbc\xb5\x69\xde\xf0\xc2\x4a\xd4\x86\x0d\xa7\xce\xa0\x86\xbb\xf9\x38\x76\x99\x8c\xdd\xe0\xe5\x9a\x8e\xf1\x8e\x2d\x0d\x3b\x66\x64\xc2\xbc\xc7\xd5\x69\xc2\xcc\xfc\xe3\x12\xcc\x34\xa4\x6a\xb6\x9e\x6c\xd6\xaf\x29\x61\xb0\x4e\x85\x56\xa1\x9c\x5e\x85\xa6\xe4\x2d\xa2\xc0\x31\x1e\xd0\x62\x35\xd5\x1d\x31\x55\x25\xa7\x82\xce\x09\x87\xa9\x85\x5c\xa9\x1f\x0e\xe5\xa5\x1c\x64\x82\xa6\x92\xbe\xa3\x9f\xe5\x09\x9f\x51\x45\x1f\xfa\x59\x3a\x33\x3b\x35\xb7\x25\x9f\xd1\x54\x61\xe7\x38\xf7\xd8\x17\xb2\x2b\xee\x13\x4d\x1d\x3f\x17\x1b\xfb\x8c\xa4\x9d\xcb\xda\x6d\x80\x00\x69\xa6\xb0\x7a\xff\x3b\x53\x12\xd3\x4e\x99\x50\x91\xe1\xb8\x3a\xca\xdc\xa9\x7d\xd5\xef\xe3\xa9\xbd\x4a\xe1\xb1\xca\x83\xde\xa2\x6c\x52\x69\xb3\x1b\xa7\x59\x4f\xbd\xd9\x92\x9b\x8f\xff\x33\x61\x36\x1e\xa5\x6d\xb0\xed\x14\x5f\x1b\x8e\xad\xd6\xc5\x40\x50\x36\xa3\x02\xc9\x81\x9e\xe7\x7d\x91\xcf\x68\x1a\x00\x03\xa1\xfe\xf0\x79\x47\x51\x8a\x72\x16\xd5\xb1\x08\x26\xec\xd4\x59\xd0\x30\xc3\xfe\xd1\x5c\x26\x8f\x90\x04\x8e\x03\xe3\xe4\xa8\x90\x89\xb1\x9f\x6f\x26\xcf\x64\xf2\x66\x27\xef\x5a\x26\x4f\xdb\x89\xce\x6e\x46\x4e\xd8\xe9\x01\x21\xbc\xd7\xd3\x66\x14\xc4\x67\xf2\xf1\xbe\x75\x6a\x28\xbe\x1e\x35\xed\x36\x4a\x79\x59\xd0\x71\x03\x1d\x61\x8c\xa1\xc5\x84\x9d\xee\x98\xfb\xd7\xd3\xad\x62\xff\x65\xca\x66\x05\x15\xa5\x9e\x4a\xbd\x05\x64\x40\x92\x8c\xb0\x09\x3f\x05\x33\x63\xaa\x69\xb9\x3e\x88\xc2\xdd\x9b\x57\x1c\x32\x0c\xac\x9e\xd0\xfc\x04\xe8\x4b\x66\xf8\x2a\x23\x27\x48\x40\x85\xc7\x1d\x7b\x64\x75\x05\x76\x06\xcf\x06\x39\x9b\x73\x52\x6d\x9b\x30\x13\xd6\xf2\x49\x68\xec\x01\xfa\x4b\x08\xa8\x2e\xad\x77\x23\xed\xc1\x3c\x0b\x0c\xc8\xb4\x69\x97\xbb\x2e\x3b\x0c\x35\xc1\x9c\xec\x1c\x67\xbb\x52\x5e\xb4\x93\x10\xd6\x6e\x7b\xa1\x58\x57\xb9\x9a\x29\xa8\x1e\x17\xc6\x19\x1c\xa6\x44\x8e\xa7\x63\xa7\x0a\x4c\x9d\x48\x54\x30\x39\x54\x6a\x43\xcd\x14\x57\x24\x45\x15\x36\x04\x75\x35\x95\x24\x75\x03\xaa\x3c\x3c\x1c\xab\x3c\x93\xf2\x54\x65\x53\x8a\x8a\x91\x7e\xdb\xad\x3f\x2d\x34\xa4\x14\x40\x1b\x3e\x19\x8d\x8b\xce\xac\xad\xa1\x75\x1c\x9e\xd0\xd3\xb1\xef\x39\x76\xec\xfa\xfc\xa1\x94\x22\x3f\xab\xcc\x1d\x9b\x72\x50\x52\x19\xa4\x28\x1d\x70\xc7\x99\x63\x7f\xfd\x1d\xab\x14\xa3\xde\xd4\x1c\xb3\xdb\xee\xc9\x5b\xc4\x61\xa7\x6d\x93\xaa\xb7\x4f\xdb\xfe\x1a\x66\xbc\x4c\xfc\xfd\x9a\x9f\xac\xbe\x3a\xc4\x21\x31\x1e\xb7\x54\x0c\x73\x02\x24\x9c\xcf\xc9\x2c\x95\x69\x42\x61\xc6\x57\x27\xb5\xb2\x0e\xba\x93\x4f\x3a\xb5\xf7\x4f\xb5\x16\x9d\xcf\x91\x3c\x20\xc4\x87\x33\x32\x73\x2c\x64\x44\x98\x69\xcf\x2a\xaa\x99\xf3\xe1\xc8\x9a\xd3\x6f\xcd\x3a\x72\xa0\x16\x0e\xfa\xd8\x53\x3f\xe4\xf5\x9a\x2b\x25\x3b\xa6\x67\x39\x51\x4a\xad\x65\x91\xb4\xd7\xcb\x15\x97\xa4\xa4\x9a\xe4\xa7\xea\xcb\x24\xd7\xc3\x3a\xf5\x36\x8d\x3c\x9f\x21\xe1\xa6\x76\xf5\x83\xc7\xf6\x55\xb8\x99\xde\x5a\x95\x36\x68\x69\x27\x7e\xf3\x53\x2a\xaa\xea\x9a\xdc\x09\xf3\x83\x61\xaf\x47\xcd\xa4\xfd\x18\xc5\xeb\x43\xbb\x10\x62\x50\x62\xbc\x47\x59\x98\x7b\x1d\x01\x0a\x63\xe4\xa8\x1e\x67\xe4\x60\xa4\x8d\x37\xf5\x6c\x1f\x28\x0f\x6b\xab\x3c\xcc\xc8\xc1\x10\x76\x34\x88\xf9\xf1\x9c\x4c\xe6\xb0\xf6\x1a\xc4\xdc\x00\xb3\xf6\x1a\xc4\x9a\xac\x4d\x9d\xae\xfd\x25\x11\x3b\x8d\x2c\x6f\x6c\xa4\x38\x2e\xc8\xa4\x80\xa5\x6f\xa4\x30\x8d\x2c\x7d\x23\x4b\xb2\x34\x75\x5a\xc2\xcd\x7a\xbd\xb9\xa5\x90\x52\xe3\x9c\xa5\xb3\x66\xa3\x90\x5c\x82\xce\x44\x7a\xa1\xe8\x25\x30\x4e\x10\x9a\x1d\x3f\x43\x73\x28\x70\x32\x57\xab\x22\x7c\x7d\xdd\xa0\xad\x5d\xc7\x32\x28\xb0\xe9\x86\xe8\x13\x5a\xc3\x52\xb1\x61\x7f\xe4\xc9\xad\x35\x1c\x63\x47\x4a\x3f\x4b\x63\x48\xaa\x94\x9a\x80\x11\x1a\x30\x98\x1d\x19\x06\x36\x9b\x9b\x6d\x43\x1d\xc8\xab\x88\x81\x65\xaa\x52\xa5\xfd\xe0\xd6\x89\xb5\xbe\x71\x1b\x9e\x66\x38\x19\xc3\xdf\x17\xc8\x4e\xe8\x20\xec\xc4\x8e\x9b\x2c\xa5\x13\x55\xd1\x8d\xc3\xfa\xb9\x1f\x7c\x78\x57\xf7\xf9\x0f\x83\xf5\x55\x1b\x56\xa7\xf0\xe8\x1e\x52\xda\x8e\x86\x47\x3d\xec\xed\xa1\x06\x44\x63\x63\xc4\xbc\x0b\xca\xd8\x43\xba\xd9\x0f\xd4\xd8\x84\xfe\x32\x0d\x0e\x66\xf9\xdc\x9c\x27\x28\x51\xb1\xda\xdb\xbe\xdb\x86\x61\xb0\xf2\xec\x61\x57\xad\xfb\xa0\xdc\xde\x70\x79\xe7\x70\x4c\x8f\xbc\x5d\x2a\x35\xe6\xa6\x72\x42\x95\xbe\xa4\x6f\xdc\xbc\xc1\xd8\xf4\x45\x43\xd9\x69\x6a\x36\x52\xd5\xc3\x0f\x08\x99\xcb\x5e\x8f\xeb\xd5\x93\xf9\x9d\xd9\xdf\xb5\xc9\x11\xcc\x53\x19\x91\x46\x0b\x12\x4a\x0b\x52\xd2\xb5\xea\xf5\xac\x0a\xa7\xb4\xb7\xeb\x6b\x4a\x4c\x3d\x17\x28\x83\x0a\x5f\x5f\x23\x64\xaf\xa8\xc6\x7a\x9f\x00\x6b\x32\x34\xd2\xfc\xe4\x46\x8f\x77\x1c\x7e\x54\x6b\xc7\x71\xac\xad\x2f\x13\xaa\x77\x2f\xd4\xab\x69\xc4\x34\x36\x93\x86\x23\x87\xc9\x55\xb0\x5a\x9e\xf0\xd3\x60\x26\x35\xcb\x61\x3b\x27\x69\xb5\xe1\xca\xa8\xcf\x2f\x90\xc6\x47\xb8\x5d\x10\x8e\xc7\xd3\x5e\xaf\x09\xf3\x14\x6f\x1d\xd9\x72\x43\x0a\xfd\x23\x1b\xb8\xe5\x4a\xcb\xcc\xbd\xc3\x5d\xc4\x5a\xf7\xa7\x86\xf6\x08\xc1\x4a\x40\xcd\x79\xc1\xb2\x80\xbb\xe9\x6b\x4a\xea\xd5\xc1\x83\xe9\x71\x93\x6b\xd4\xf4\x7f\x58\xa4\xa5\x16\x42\xd5\xe1\x14\xe3\xa4\x3a\x9a\x36\x59\xd8\xac\x26\x54\x86\xac\xb6\xdd\xa9\xd5\xae\x9c\x30\x48\x49\x75\x34\x3d\xae\x92\x29\x94\x64\x38\x2e\x8f\xd2\x71\xa9\x7d\x16\xfa\xfd\xb1\x99\x75\xf8\xa4\x3c\x1d\x7f\x42\x73\xc8\x26\xe5\x29\x50\xc8\x31\xe4\x7d\x32\xef\xda\xf0\xdb\xb6\x6e\x78\xb5\x86\x61\xde\x93\x48\x9b\xd0\x5d\x6d\xdd\x76\x6b\x40\x81\x3c\xa4\x40\xea\x27\x68\x28\x49\xee\x1e\xe7\x64\x08\x05\x19\xc2\x8c\xb0\xf1\xfc\x28\xed\xf5\x8a\xa3\xd2\xea\x8a\x6b\x32\x9d\xcc\x4f\x61\x49\xf2\x49\x71\x6a\x22\xfd\xd9\xb0\x5e\x43\x58\x68\x47\x04\x38\x33\x41\xbe\x94\xde\x7d\x40\xc8\xca\x94\xbb\x24\xf3\xfe\xe8\x28\x85\x77\xa4\xe8\x8f\x8e\x4a\xf5\xf5\x12\xab\x0f\x17\xaa\xc2\xfe\xe8\x14\xce\xc9\x85\xaa\xe4\xad\xfa\x19\xc1\x67\xb2\x22\x84\x9c\xab\x7c\xef\x74\xbe\x47\xaa\x45\x95\xef\x21\x79\xa4\xf2\x9d\xa8\x9f\x11\xbc\x21\x1b\x42\xc8\x43\x5d\x5f\xaf\xf7\xae\xd7\x7b\xd3\xeb\x7d\xc6\x9f\xd0\x02\x4e\x80\x43\xbf\x3f\xc3\xf0\x23\xca\x80\xc3\x06\xce\xa0\x80\x0a\xc3\xac\x4f\x16\x9d\x3b\xcb\xaf\x6d\xbe\xb7\xa6\xd8\xac\x4f\xde\x76\xe6\x9b\xf7\xc9\x5d\x28\xfa\xe4\xae\x5f\x5f\xa8\x66\xf1\xac\xdf\xb7\x4d\xad\x5c\x53\x0e\x8c\xd9\x0d\xad\xce\xfb\x64\xd4\xac\xed\x52\x61\xe0\x80\x59\x78\x60\xba\x8b\x7f\x42\x6f\xe1\xcc\x61\x7a\x2b\xc8\xa3\xb1\x0b\x8c\x7c\x70\x79\x7d\x7d\xf0\xee\xfa\xfa\xfc\x80\x90\x87\x26\x42\xef\xb8\xd5\x66\x0b\x99\x1b\x41\x38\xf9\x6a\x10\xee\xda\xe8\xd8\x8a\x36\x21\xe0\xfb\xa8\xd3\x87\xa2\xdf\xd7\xf2\x40\xb1\xe2\x18\x5f\xcd\xfa\xfd\xf1\x82\x20\xc3\x88\x58\x71\x9a\x81\x5b\x73\xe2\xe2\x16\x5a\xf7\xbd\x64\x79\x3a\xd6\x4c\xfd\x94\x3c\xbd\xbe\x9e\x9c\x5a\x64\x91\xe1\x6b\xac\x43\x97\xe8\xc0\x25\x46\xcd\x7e\x8a\x15\x14\x63\xc4\xbd\x4e\x79\x7d\x5d\x05\xcf\x7e\x5e\x7b\xda\x9a\x6d\x05\xd5\xc7\x91\x4a\x2c\x5c\xad\xad\x71\x17\x87\x5c\x07\x48\x2b\x93\x0a\x28\x9b\x3d\xb7\x2f\x4f\xb7\xe1\xa6\xd8\x8f\x4d\x37\x7c\xab\x7e\xab\x25\x51\x73\x25\x6c\xa5\x5f\x45\x9c\x3b\xb8\x0e\xbd\x06\x1b\xbd\xa3\xcf\xac\x19\x19\x37\xab\x07\x2b\x8e\xc1\xda\x18\x5e\xb9\x8f\x94\x49\x71\x99\x54\x5b\xab\x38\xab\x56\x48\x65\xd6\xa7\x46\xf6\x99\x08\xa4\xc6\xab\x67\x6f\x59\x9d\x81\xc4\x3a\xff\xd8\x08\xfb\x50\x4d\xaf\x06\x1b\xb3\xff\x06\x53\xa8\xac\x0d\xa4\x7b\x20\xdc\xb4\x5c\x0d\x14\x9c\xfa\x1f\xf1\xe4\x9a\xd6\x6d\x6c\x2d\x55\xfa\x1b\x69\x09\xd3\xba\xc0\xba\x19\x9f\x76\x87\x5c\x19\xbe\x9a\x92\x40\xa6\xc7\xc0\x6d\x0f\xd7\x97\xe1\x1b\xfc\xa6\x21\x2d\x0c\x69\x5d\x91\x4e\xd2\x4e\xb7\x26\xb0\xa9\xa5\xff\x01\x21\x99\xa6\xd7\xeb\x06\xc0\x66\x01\x7d\x95\xb5\x29\xa5\x84\xf4\xf8\x13\x52\x53\x87\x21\x52\xa5\xf2\x1a\x1a\xb6\xc0\xf5\x64\xa9\x2c\x59\xb2\xad\x5a\x25\x59\xa0\xb7\x2d\xd7\x6c\x33\x2b\xfc\xe2\xd6\x9b\x30\x84\xdd\xd3\x23\xb5\x64\x6e\x3a\x58\x87\xd1\x1c\xdc\x70\x99\xea\x0d\x2a\xc8\xc9\xd4\x3a\x4e\xaa\xc5\x1d\x0f\x37\x10\xec\x42\xd2\xaf\xb0\x08\x21\x29\xd6\x50\x98\x95\xd9\x54\xf7\x2b\xb8\x5d\x04\x93\xd5\x8d\x0f\x9d\x79\x3a\xb0\xab\x5b\x22\x61\x3a\xf0\x4b\x5b\x52\x01\x9a\x13\x53\x7c\x60\xd1\xc7\xc1\xe2\xce\xc0\x3c\x87\xa1\x85\xb9\x59\xbf\xe3\xdf\x14\x5f\xed\xad\xdf\xae\x2a\x4d\x13\x35\xc7\x1c\x10\x52\xe2\xab\x72\xa0\x09\x6d\xb8\x52\xda\x99\xba\x74\x80\x8c\xe7\x37\x40\x62\x45\xdd\xfe\x76\xf3\x39\x62\xfd\x3e\x1c\x20\x43\x5e\xa5\xbd\x79\x0a\xe3\x07\x19\xf6\xba\x8d\x0f\x4f\x1f\x6e\x8e\xb7\x56\xad\x45\xc7\xaa\xb1\xb0\xab\xc6\x82\x14\x8d\xd5\x9f\x82\xb4\x30\xfd\xdc\x1f\x41\x06\xb2\x63\x4b\xba\xb1\xc7\x5c\x7b\x30\x06\xda\xc3\xda\xe9\x15\x0a\x9d\x12\x96\x64\x38\x5e\x1e\xcd\x9c\x1e\xb5\x54\xca\xcd\x8a\xf4\xfb\xbc\x8f\xd0\x86\xcc\x26\xcb\x53\xdc\x79\x76\xa9\xf7\x1f\x8e\x48\xde\xeb\xe5\x47\x64\xa5\x4d\xa8\x7f\x41\xeb\xc9\xf2\x14\x36\x96\x15\x57\x6a\x02\xda\x4b\x25\x4f\xa6\x31\x27\xab\xad\x7f\xd9\x59\x77\xfd\x51\x1c\xb8\x55\xd0\x0c\x0e\x6a\x5a\x58\x11\xde\x47\x9b\x7f\x3b\x32\x66\xe1\x1c\x6e\xcd\xc8\xa5\xe0\x17\xda\x45\xe3\xa9\x10\x5c\xa0\xb8\x5c\x9a\x6b\xcd\xe9\x86\x8a\x48\x8a\x54\xdf\x8c\x1c\x7d\x54\x25\x3f\x46\x5c\x44\x1f\x75\xc1\x8f\x36\x12\x70\x91\x9f\x53\x1d\x0b\x38\x0e\x45\xc7\xaf\x3b\xe7\xaf\x7a\xb1\xe0\xb6\x08\x64\x82\x6a\xe1\x02\xef\xb5\x05\x04\xde\x71\x1c\x6d\x2e\xa6\x44\xb8\x98\x6a\x6f\xc0\xd9\xd1\x01\x19\xf9\x01\x71\x60\x78\xcc\x09\x21\xb2\xd7\x43\x92\x64\xb5\x49\xe3\x8e\xfb\x60\xd7\x98\xf0\x6b\x3c\x7f\x05\xa2\x16\x40\x5a\xf2\x88\x7a\xe8\x59\xd6\x76\x0b\xcf\xc4\xef\xde\xcb\x30\x97\x2d\x88\x41\xba\xec\x8d\xb3\x19\xef\x87\xf3\x24\x95\x29\x1a\x82\x5b\x30\x76\x14\x6b\x1c\x63\xbd\xf7\x20\x79\x30\xdc\x50\x0e\x97\xb7\x43\x7d\x50\xbd\x3b\x2c\x8f\xbb\x12\xed\x36\x0f\x31\xf5\x26\x5d\x59\xfc\xc9\x94\x25\x87\x3b\x9e\xaa\xf1\xdd\xd6\x10\x87\x6b\x1e\x3d\x6e\x98\xad\xda\x84\x21\x70\x7b\xa2\xe6\xf0\x44\x6a\x07\x05\xfd\x5c\x87\xb7\x77\x35\xd9\x75\x51\x70\x10\x67\xdb\xef\x08\xa4\x22\x5b\x67\x32\x7a\xca\x09\xbb\x6d\xb7\x7a\x2b\xe0\x13\x17\x3f\xa1\x29\xc1\xcd\x81\xb8\xeb\x2e\x83\xb1\xaa\xa8\x09\xbe\xea\x29\x1b\x4c\xd0\xc8\xfa\x71\xbb\x1f\x32\xe7\x8b\x7b\x53\x25\x99\x99\x22\x54\xf7\x72\x3f\x4f\x85\x24\x35\x53\x9d\xbf\xf4\xd2\x6c\x6b\xd8\xaf\xe1\x21\x53\xe5\xf0\x70\xca\x9d\x22\x4b\x71\xf9\xda\xb8\x55\x41\x65\x79\xc7\x9f\xd3\xb4\x65\xc0\x1b\x1f\x19\x86\x45\x15\x3b\x67\xfc\x82\x45\x1a\x9e\x83\xc6\x30\xff\xad\x7d\x2c\x53\xa3\x06\x9c\xbc\xd5\x26\xd5\x4d\x4a\xe8\xa3\x8a\x5d\xce\xea\xf5\x50\x57\x72\x27\xf7\x62\x60\x66\xab\x43\xf6\x7a\xde\xcd\xc2\x90\x90\x83\xc4\xc0\x1b\x6e\xb8\x81\x5d\xb9\x63\x9a\xef\x11\x1d\xd4\x5a\xb3\xa2\xa0\xd4\x24\xa7\x9e\xe4\x41\x3c\x0d\x3a\xb0\xaa\x36\x64\x64\x38\xce\x8e\x9c\xfe\x3e\xce\x9c\x18\xaa\x08\x9f\x64\xa7\xfa\x5e\x6e\xdd\xf5\x90\x5b\xc5\x4c\xef\x5d\xcb\x74\x71\x6c\xb4\x82\xe4\x2d\x9a\x5a\xe5\xac\x21\x47\xa4\x6d\xe1\x11\x9d\x73\x41\x51\x0e\xe1\x6c\x32\xb1\xfa\xed\xa9\x97\x62\x9e\xa3\xf4\x81\x7d\xc8\xed\x0c\x43\xd3\xd7\xd8\x7a\xdf\xd7\xb2\x20\x94\xa9\xfe\x20\xd4\xd9\xb6\x3d\x13\xe9\x42\x9f\x88\x62\x3b\xb0\x64\x23\x2e\x82\xdd\x07\x99\xb0\x53\xcb\xe1\xb4\xd1\xb8\x47\x99\x6b\x94\xb9\x43\x99\x77\xa0\x5c\xfb\x7f\x05\xbc\xf4\xf3\xed\xc6\x71\x3e\xb1\xeb\x7a\x4e\xa3\x6c\x1a\x45\x53\x28\x45\x18\x8f\x03\xbf\xb3\x6f\x10\xd5\x1a\xd5\x14\x27\x54\xa2\x5c\x8d\x01\xa0\xd8\x26\x6d\x1b\x76\xac\xff\x40\x9e\x65\x7c\xe8\x09\x67\x0a\x0c\x4f\x65\x10\x17\x76\x25\xe1\x15\x85\x2b\x1d\x63\x91\xc2\x26\xa7\x17\xc9\xae\x69\x91\xd8\x42\xb5\x9e\xa5\x92\x26\x12\xed\x7e\xa5\x5b\x0c\x65\x75\x56\x66\x22\xb7\x76\x1f\xbb\x79\x9e\xc9\xed\x16\xa3\x00\xc2\x9f\x9a\x56\x55\x2d\x07\x9a\x50\x74\xd1\xfa\xfa\xe8\xbf\xa3\xf8\xdd\x92\x46\x1f\xe3\xbe\xe8\xc7\x1f\xa3\x15\x9f\x55\x05\x8d\x66\x9c\x96\x11\xe3\x32\x62\x94\xce\xa2\x79\x91\x2e\xca\xc1\x07\xf6\x9c\xe5\x32\x4f\x8b\xfc\x0b\x8d\x72\x1b\x19\x85\xf1\xc8\x3b\xde\xe9\x2b\xc6\x2f\x79\x15\x59\x55\xe1\x8c\x46\x69\x51\x44\x25\x95\x07\x71\xf3\xf8\xec\x9f\xdd\x90\xba\x35\x96\x8f\x16\xd5\xeb\xfd\x1d\x55\x24\x7e\x28\xa8\xae\x57\x8a\xcb\x9c\xe9\xeb\xc2\x4b\x46\xd3\xf3\x28\x8d\x4e\xb4\x36\xa2\xf7\x04\x8d\x60\x7a\x5a\xac\x8e\xa3\x77\x22\xcf\xce\x4b\x49\xc5\xc1\x07\xf6\x5c\x46\x05\xe7\xe7\x56\x23\xd1\x58\x0e\x56\x69\xce\xa2\xbc\x8c\xac\x8d\xab\xc1\xe4\xe3\x5a\xf0\x85\x48\x57\xef\x73\xb9\x7c\xa6\x10\xfe\xa8\x03\xaf\x2c\xd3\x32\x52\x6a\x40\xf4\xf1\xb5\xf9\x6e\xda\xfc\x38\xf8\xc0\x7e\x51\xfa\x8f\x2d\xf5\xd1\x47\x14\xcb\xe7\x1a\xd6\x19\xd7\xf4\xbb\x48\x99\xb4\xf4\x8b\xdd\xd2\x2b\xab\x8f\x6d\xd5\x1a\x29\x38\xae\xcd\x1a\x61\x8c\x29\xca\x06\xd3\x21\xb6\x0b\xb9\xf8\x9d\xc7\x3e\xaf\xfb\x41\xee\xf6\x9d\x89\x58\xa3\x04\xb4\xbf\x23\x5e\x01\xa0\xfa\x2f\x92\x22\xa7\x33\x55\x45\xc6\xd9\x86\x0a\xa9\xfa\xd1\x88\xf3\xa7\xc5\xca\xd0\x11\x34\xda\x41\x8c\xb1\xbc\x74\xa1\xc5\x6c\x00\x31\x05\xd5\xf8\xef\x48\x2d\x25\x83\x3e\xfd\xbb\xe9\x53\x33\x67\x88\x5e\x0f\x89\x41\xce\x18\x15\x3f\xbc\x7b\xf9\x82\x7c\x7b\x34\xcb\x37\x91\x3e\xd6\x27\xf1\x3a\x9d\xcd\x72\xb6\x38\x2c\xe8\x5c\x26\x23\xba\x1a\xc7\x0f\x8e\x96\x77\xdd\xd7\x39\x67\xf2\xf0\xc2\x98\xe8\x32\x2e\x56\x69\xa1\xbe\x9f\x3d\x78\xc5\xd7\xe5\xc1\xd1\x9d\xb3\x07\xd1\x5b\xbe\xa2\x3a\x28\x71\x74\x41\x99\x8c\x2e\x04\x57\x8f\x4b\xca\xa2\x52\xa6\x42\xc7\x80\xbb\xe4\x95\xd0\x28\xd9\xee\x19\x1c\xdd\x59\xde\x7d\x70\xb4\x16\xf4\x06\x20\xbe\xed\xcb\x7e\x7c\x74\x67\x2d\xe8\x83\xa3\x3b\xb3\x7c\xf3\x20\xc6\x50\x4f\x7e\xa1\xd7\xf1\x37\x81\x1e\x3b\xa0\xab\x33\x3a\x23\x4d\x7f\x21\xbd\xab\x24\x6a\xed\x65\x8c\x45\x63\x52\x17\x1d\x8a\xcd\x89\x92\xf8\xae\x63\x11\x43\xe6\x15\x28\x08\x0c\x72\x60\x84\x05\xc8\x41\x43\x2c\x80\x94\x48\x80\x1c\x28\x21\x83\xf1\x16\xc4\x60\x5e\x15\x45\x99\x09\x4a\x59\x57\xcc\xeb\x3d\x6d\x08\xf0\xee\x34\x67\x7c\x76\x79\x73\x7b\x8d\xac\x75\xdb\x35\x75\xa4\xdc\x3b\xbc\xdd\x7c\xe1\x34\x46\xea\x94\x45\xbf\x83\xa4\x84\x34\x86\x8a\xbc\x45\x59\x70\x35\x51\x73\x46\xab\x30\x08\x89\x2a\x10\x90\x35\x79\x50\xc8\x4e\x57\x66\xaf\xd1\x57\x56\x99\x3f\x79\x35\x7d\xf3\xf4\xe7\x5f\x9e\xbe\x7d\xd7\xb1\xd0\xf9\xa5\x1e\x37\x4a\xe1\x8f\x5c\xa8\x92\xc1\x07\xf6\xba\xa0\x69\x49\x23\x41\xd7\x5c\xd8\xab\x4e\x24\x8f\x8e\x96\x52\xae\xcb\xe4\xce\x9d\x45\x2e\x97\xd5\xd9\x20\xe3\xab\x3b\x3e\xde\xee\x26\x17\xb2\x4a\x8b\xc3\x19\x5f\xdd\xc9\xcb\xb2\xa2\xe5\x83\x81\x8b\xbb\xf7\xfa\xe9\xc9\x93\xe7\x27\xdf\xd7\xb0\x9c\x49\xc4\x15\xf2\xf1\xd3\xbf\xbf\x7b\xf3\xd0\xa7\x8f\xad\xa6\x82\x32\x0c\x39\x79\x89\xa6\x81\xfe\x24\x75\xb4\xba\x29\xe4\x6a\xc9\xa4\x77\x96\xa6\xc4\xad\x42\x9a\xb5\x84\x6b\x00\x25\x55\x03\x22\xd8\xbb\x41\x32\x68\x26\xc3\xb4\x76\xa0\x0b\x4d\xfa\xc3\x3c\xe6\xdc\xc8\x03\xde\x46\x09\x32\x12\xda\x62\x52\x19\x8e\x9c\x3d\xbc\x6a\x59\x64\xc6\x33\x7f\xce\xf3\x07\xd9\xf7\xff\xcf\xde\x9b\xa8\xb7\x8d\x63\x09\xa3\xaf\xa2\x70\xaa\x32\x60\xf9\x48\x91\x9c\x54\xaa\x8a\x69\xb6\xc7\xb1\x9d\xc4\x89\x9d\xcd\xce\x5a\x55\xc3\x4b\x91\x90\xc5\x98\x22\x64\x10\xf4\x12\x9b\xf3\x1a\xf7\x81\xee\x8b\xdd\x0f\x1b\x57\x90\x92\x93\xea\x9e\xe9\xff\x9f\xea\xfe\x62\x0a\x3b\x0e\x0e\x0e\x0e\x0e\xce\x82\x12\x3e\x2e\xbb\x85\xc5\x84\x21\x5c\xaf\x03\x44\x61\xb2\xfa\xb3\x9f\xa8\x8f\x57\x19\x93\x1b\xab\xb5\xcd\x0b\x69\xe0\x2d\x46\x4a\xaa\x9b\x99\x8f\x2e\xe8\x1a\x1d\x15\xb2\x93\xee\x11\x55\xec\xe8\x58\xc5\x6e\xa9\xdb\x8c\xae\xa2\x5e\x15\x12\x11\x73\xb8\xb4\x6b\xac\x18\xd1\xa5\x8f\xaf\x76\xb4\x52\x2f\xb2\x42\x3c\xcd\xf8\x46\x1d\xa6\x51\x88\xa7\x3e\x1d\x2a\x3f\x8a\xa9\x65\xff\x3e\xfe\xf3\x51\x72\xf7\x2e\x4a\x2a\xe6\x5f\x49\xcd\x52\xc7\xce\x69\x35\x04\x80\x66\x96\xec\xba\x89\x1d\x33\xba\x85\x2d\x86\x2d\x7c\xb8\xca\x77\x2e\x4d\x34\xb2\x26\xd1\xf0\xbb\xb3\x52\x19\x45\x65\xe6\x1e\x09\x9f\x60\x8f\x68\x8d\x90\xcc\xe4\xe1\x1a\xbb\x94\xa1\x19\x24\xc0\x8b\x40\xe8\x12\xe4\xd9\x23\x6f\x02\x4b\xf7\x08\x85\xe0\x37\x6b\x2d\x65\xad\x39\xaf\xb5\x04\x8f\xa1\x08\x96\x40\x6c\xe0\x45\xe1\xdc\x0d\x18\xf2\x20\x00\x1f\xa4\xc9\x86\x69\x03\xc5\xfc\x56\x37\xe7\xff\x9c\xf3\x73\xa5\xb2\x98\x01\x33\x88\xe7\xc1\x33\x35\x22\x1f\xd1\xd3\x5d\xb5\x44\xaf\x96\x58\x72\x79\x77\x02\xbe\xc0\xa5\xfc\x5e\xc4\x64\x53\x94\x21\x63\x92\x23\x06\x7e\xe3\x9d\x33\x57\x14\x55\x81\x95\x44\x39\x4e\x5e\x32\xce\x94\x78\xee\x7b\xe4\x41\x06\x11\xe7\x87\x33\x37\x81\x39\x2b\x6c\x2e\xab\x03\xce\xba\x48\x2e\xe5\x4d\xab\x17\x61\xf0\x46\x41\x4c\x52\x8c\xa4\xe5\x53\xe0\xca\x5d\x3f\x12\xd6\x37\xc3\xdf\xc6\x63\xc8\x74\x92\x34\xce\x19\xde\x7f\x38\x06\xcf\x95\x36\x49\x23\xb2\xc4\x09\xb2\x2c\xe0\xff\x17\x55\x5c\x5e\x45\x96\x74\x79\x49\x7e\x88\xbb\xd6\x46\xb0\x61\x01\x23\x4b\xd7\xda\xc8\xc4\xec\xbc\x91\x1e\x31\xc8\xd1\xcc\x19\xcc\xd9\x88\x45\x8c\x73\x00\x1a\x70\x83\xe1\xc0\xda\x10\x19\x9c\x10\x48\xdd\xc3\xd1\x42\x98\x78\xb9\xd6\xd8\x6a\x64\x28\xbe\x81\xe7\x28\xb7\x76\x47\xe2\x60\x7b\x54\xea\xd5\x8a\xd2\x55\x84\x89\x6c\xde\x48\x4b\x29\xd0\x3a\xc5\x57\x21\xb9\x48\xac\x9a\x01\x22\x1b\x2d\x30\xf3\x5f\xe0\xab\xbb\x77\x7f\xdd\x14\x0e\x26\x2e\xe6\x51\x30\xbf\x7b\x57\x01\x23\x26\x81\x50\xcf\x1b\x51\x1c\x13\x3f\x44\x36\xdc\xff\xb5\x5a\x0c\x25\x4a\x64\xa3\x6d\x5c\xdf\x2d\xad\x9c\x13\x99\xa6\xe2\x9e\x0d\x0f\xc6\xbd\x15\x77\xf9\xd8\xcc\x55\x73\x1b\xd4\x70\xda\xb3\xca\x12\x3e\x2e\xce\xed\x82\xd7\x93\x5d\xbd\xd0\x54\x51\x45\xb5\x6b\x52\xc3\xac\x36\xdd\x1c\xec\x0e\xc7\x2f\x19\x21\xa0\x82\xa9\x10\x55\xcc\x6c\x58\x4d\x2c\x01\xc4\x4d\x19\xa2\x36\x04\xae\xf5\x52\xf0\x99\x16\x64\xa5\x7a\x96\x57\xf5\x96\x93\xb7\xf6\x1f\x2d\xcc\x8a\x78\x13\xbe\x1b\xe9\xb8\x6f\x8f\xaa\x3a\x38\x27\x98\x16\x8d\x0b\x23\x88\xcc\xf1\x20\xb8\xe3\xba\xfe\xdd\xbb\x28\x62\xfa\x15\xac\x36\x4b\x4b\x6c\x7c\xe0\xb9\x4d\xe0\xf1\x2c\xdf\x86\x4a\x8b\x81\x10\x03\xd7\x4e\x32\x85\xa7\xe4\x1c\xd3\x59\x4c\x2e\xa0\x2f\xd3\xb5\xe6\x51\x18\xe2\xc4\xaa\x35\xca\x07\xd7\x5b\x2b\xe1\x40\xf3\x6d\x88\x84\x6f\x8c\x02\xc0\x51\x01\x60\xc5\x6e\x69\xd9\xa9\x6a\xda\xa9\x2a\x57\xbd\xf6\xb3\xb4\xd4\x58\xf2\x65\xd5\x2b\xad\x7e\x7e\x28\x8f\x99\x66\xfe\x31\xab\x1e\x7c\x3e\x6b\x5b\x88\xb5\x24\x7f\xb5\x89\xfc\xce\xfe\x54\xa2\x3f\xb8\x33\xae\xda\x24\x33\xa3\x7d\xbd\xf4\xfa\xa8\x77\xa9\x54\xa8\xba\x5a\xe2\x9b\x9b\x3b\x54\x6f\xd2\x9b\x9b\x5f\x37\x45\x86\xd8\x44\x55\x41\x8a\x25\x8f\x42\x69\x58\x2f\xab\x59\x17\x73\x8c\x2b\x29\xc2\x7d\x2c\xf3\xe9\x09\x66\x8f\xb4\xc9\xba\xf2\xc4\xca\xf9\x47\x0e\xef\xd8\xbf\xd2\x67\xee\x30\xc4\xcc\x8f\xe2\x54\x85\x62\xd1\x87\xf4\xdd\xbb\xfa\x36\x2f\x1e\x7d\xe4\xb5\xf9\x4e\x91\x96\xb8\x49\x45\xfc\x96\x9b\xb4\x7c\xdb\x3a\xbd\xb9\xe4\x07\x39\x51\x3d\x3a\xfe\x74\xb0\x67\x41\xcc\x5c\x6b\xef\xfd\xde\xcb\x63\x0b\x42\xe6\x5a\xdb\xc7\xc7\x6f\x2d\x58\xaa\x2f\xef\xe5\x11\x27\x93\x46\xb3\xd1\xb6\x29\xea\x75\x0e\xe7\xcc\xb5\x3c\x1c\x2f\x3e\x3c\x7c\x7c\x60\xc1\x82\xb9\x6f\xd0\x0b\x1b\x4e\xf8\xdf\xcf\x36\x4c\xcd\x2d\x7d\xab\x01\x6a\x8a\xd9\x71\xb4\xc0\x44\x9c\x54\x13\x7c\xff\xde\xc3\xb1\x9d\xc3\x15\x73\x7f\xb7\x82\x38\x0a\x4e\x2d\xb0\xc2\x69\xac\x3f\x17\x24\x4b\xd5\x9b\xa8\xfc\xce\x96\xfa\x4b\xd2\x6a\xf9\x8d\x13\xc6\xf7\xa3\xfc\x11\x63\x5f\x94\x67\x24\x0b\xe6\xe2\x0e\xaa\x7f\x08\xc5\x1d\xf9\x19\xf8\x49\x80\x63\xfd\x4b\xf5\x20\x02\x25\x62\xaa\x5a\x56\xbf\x44\x8f\xea\x9b\xe3\x40\xe5\x57\xc6\xca\x1f\x7a\x08\xea\xa7\x1e\x84\xfa\x59\xef\xa0\xe8\x3c\xa4\xfe\x89\x1e\x21\xff\x56\x7f\xe4\x38\xe5\x97\x6c\x95\x7f\xab\xce\xf9\xa7\x6e\x3d\xa4\x84\x8f\xee\x14\x5f\x65\xea\xaf\x1a\xfb\x29\xbe\x5a\x52\x9c\xa6\x16\x58\x51\xb2\x14\xe3\x0c\xe6\x7e\x72\xc2\x2b\x09\x2b\x5a\x0b\xac\x69\x9c\x51\xeb\x4f\x38\x66\xee\x15\x1b\x05\x24\x09\x7c\x86\xd4\x9e\x00\xbd\x5d\xf4\x41\x7a\x2d\x1e\xc3\x89\xb4\x96\x4d\x40\x4a\xb1\x1d\x0f\x16\xfe\xd2\x61\x28\xb5\x81\x24\x0e\x45\xc7\x36\x08\xda\xe4\x9c\xc3\x92\x92\x25\xa6\xec\xca\x61\xe8\xc4\x06\x5f\x6b\x4f\x4b\x0f\x81\x7e\xa9\x4c\xed\x50\x74\x25\xfc\x0b\xbe\x2e\x2b\x9c\xda\x10\xfb\x5f\xf9\x57\x2c\xbf\x36\x1d\x8a\x42\xf9\x79\xdf\xc1\x68\x69\x83\x78\xee\x13\xfa\xd0\x94\xdf\x3f\x95\x5c\xc1\x59\x30\x68\xca\x8d\x9c\x13\x06\x29\xf3\x59\x14\x28\x89\x91\xf3\x49\xda\x16\x7f\xe9\x70\x18\xf7\x2c\x19\x35\xdb\xd0\xea\x21\xcc\xce\xe1\xeb\xca\x6a\xf0\x0a\x8b\x92\x4f\x13\xf7\x99\xb0\x35\x94\x23\x85\x37\xe2\xb7\x98\x04\x7c\x2a\xbe\x37\xe1\x45\xe2\x22\xf5\x03\xae\x1b\xf4\xc0\xb9\x33\x81\x3a\x39\x70\xee\x4c\x72\x1b\x3e\x8b\xfa\x24\x81\x8f\x3d\x8e\xf3\x3e\x27\xc0\xe0\x45\x22\xe3\x4e\xfd\x20\x6a\x88\xe5\x01\x46\x44\x8f\x15\xa8\xc3\xb3\x64\x54\x59\x95\xda\x4f\x1b\x28\x71\xe5\xf4\x64\x59\x2c\x7e\x2e\xfc\x25\x24\xe2\x8b\x23\x05\x10\xf1\x29\xa4\xc8\x01\xe9\xf2\x79\xd3\x9a\x1e\x6b\xce\x4e\x84\xec\xf9\x92\xd8\x90\x11\xf7\x6b\x02\x1e\x71\x31\x81\x88\xb8\x09\x01\x9f\xb8\x84\x40\x4a\x5c\xe4\x13\x64\xf1\x03\xc4\xb2\x81\x7f\xa6\x58\xda\x31\xc8\x5f\x89\x7f\x6e\xd9\x36\xcc\x54\x39\x9f\xb2\x28\x88\xb1\xca\xf4\xf9\xcd\x49\x7d\xcf\x27\xbc\x5c\x4c\x5c\xf1\x63\xd3\xb2\x61\xa9\xbe\xef\x5b\x36\xcc\x55\xfd\xf9\x03\x5d\xfc\x67\xfd\xf1\x50\x7f\x60\x3f\xc4\xd4\x12\xfa\xb5\xb2\xf0\x8c\x10\xbe\x5f\x55\x5f\x61\x28\xb6\xa0\xfc\xb5\xf0\x23\x3d\xc2\x25\xaf\xb2\xd0\xed\xeb\xe2\x4b\x2a\x9c\x40\x9e\xe8\xf9\xc5\x24\x38\x3d\xcb\x08\xd3\xc3\x25\x31\xcf\x9e\xca\x21\x66\xb1\x65\xc3\x95\xfc\x8e\x23\xcb\x86\x63\x55\x2d\x8c\x55\xf1\x90\xe9\x8f\x50\x7d\xcc\xa2\x93\x8c\xe2\xf2\x47\xe0\x2f\x2b\x60\x0b\x23\x01\xb6\x0b\xd9\xa6\x6f\xd9\x70\xaa\x9a\xc4\x0b\x0d\x67\x46\x49\x72\xc2\x4b\x1d\xc9\x52\xe9\xc2\xe7\x34\x02\x2e\x55\x49\x3d\xd7\x20\x2a\x46\x7d\xa6\x9b\x9f\xe9\x8e\xfc\xe9\x54\x4f\x99\xc9\xd8\x61\xa2\x0a\x09\xc5\xf4\x1f\xab\xa6\xce\x7d\x5d\x28\xf5\x17\x4b\xf5\x79\x3a\xd5\x73\x49\xb3\x69\xf1\xa5\x73\x23\x5e\x7f\x5b\x8e\x8c\xe7\xbe\x54\x4d\x65\xc5\x0a\xd0\x53\xf5\x49\xb3\xa9\x46\x1e\xaa\xe1\x44\x75\x3b\xd3\x30\x2a\xbe\x88\xee\x65\xe9\x27\xbc\xf9\xb7\x7a\x75\xf4\xe8\x2e\x8a\xaf\x28\xd1\xd3\x0f\xb1\x5e\x84\x68\x71\xa2\xbf\x66\xfc\x24\xe4\x4d\xec\x15\x60\x9d\x62\x3d\x1d\xa5\xe6\xaf\x10\xc1\xa7\xbe\x06\xf9\x79\x14\x62\x3d\x06\x3f\x0b\xa3\x62\x3c\xc2\x9d\xa3\x06\x23\xf5\x03\x3d\xb3\xc0\x4f\xce\xfd\x12\xe7\xd8\x5c\x97\xf1\xa7\xb1\xe8\xfe\x50\x75\x5f\x5f\xfd\x80\xc4\x27\x94\x14\xa0\x0c\x88\x9e\x01\xab\xec\x33\xc6\x11\x5e\x7f\x73\x54\x2f\xfa\xe7\x0d\xef\x48\xc8\x33\x5e\xe2\x4c\x7d\xf3\xde\x9f\x14\x7b\x83\x2e\x0a\xe4\xc3\x71\x98\x62\x5d\x3f\xc6\xe2\xc4\x53\x3f\xfc\x29\x16\x98\x7e\x20\xdb\x90\xc7\x97\x0d\xfb\x6a\x61\x33\xc6\xc4\xa8\x5f\x69\x9c\xc3\x71\x09\xba\xd0\x67\xbe\x70\xee\xa9\xc0\xba\x64\xd5\x59\x91\xea\x8c\x39\xd1\xf2\x29\xf6\x79\x57\xcf\x55\x5b\xa7\xf8\xea\x04\xeb\x02\x24\x63\xb2\x67\xb9\x39\xc9\x49\x75\x33\xe3\x72\x9b\x6b\x3e\x50\xa3\xe3\x62\xe1\xd3\xab\xa2\x5c\x92\x45\xac\xd8\x40\xfc\xa7\x65\x03\x23\x36\xbc\x26\xe6\x63\xe4\x39\x01\xbe\x56\xfb\x32\xdc\xcb\x29\x12\xe2\xae\xdd\x9e\xc2\x94\x1f\xd7\xc2\xd3\x18\x71\x29\x81\xf7\xa4\xdb\x71\xda\x3b\x02\x0c\x58\x22\x63\x94\xc1\x87\x8e\x46\xdf\x13\xa8\x18\x92\x8b\xa6\x9f\xf5\x14\x8d\x42\x59\xe6\x4b\x4f\x19\x71\xc5\x97\xc5\xbe\xf6\x14\x4b\x69\x20\x0b\x3d\xed\x6b\xeb\x6a\xa9\x9a\x7a\xd3\x53\x4a\x05\x99\xe2\xc5\x3e\xf5\x14\x9b\xb3\x45\xfc\x84\x50\x59\xf0\x45\x5f\x41\x8a\x67\xb2\xd4\xe7\xbe\xb1\x89\xcb\x83\x2c\xf7\x71\xd5\x42\xfc\x80\xd5\x42\xfc\xd0\xd1\xe2\x47\xbe\x10\x73\x1c\x9c\x62\x05\x62\x16\x74\x17\x0c\xa3\x94\xef\x70\x55\x92\x1a\x4b\x7e\x20\x28\x42\x97\x14\xac\x81\x05\x11\xfa\x0c\xdb\x09\x44\xe8\x23\x3c\x4e\x80\xd9\x36\xc7\x33\x1c\xb8\x3f\x24\x90\x04\x6e\x84\xe6\x89\x60\x22\x77\x84\x53\x8d\x69\x62\x03\xe1\xa9\xe7\x49\x23\xba\x65\x31\xe5\x32\x1c\xa6\xce\x29\x86\xde\x88\x94\x99\xc3\x15\xbf\xb1\xde\xb6\x39\xb5\xa2\xad\xc6\x8e\x39\xaf\x10\xb8\x2f\x12\xf0\x02\xf7\x63\x02\x51\x07\x90\xbc\xa0\xe0\x7c\x83\x44\x6e\x2b\xbf\xa7\xa8\x60\x8e\x8b\x92\x69\xe0\xa2\x85\x96\x13\x67\x01\x5c\x37\x79\xb2\xb1\xd9\xa3\xa1\x6c\x4b\x73\xde\xca\x44\x9e\x04\x62\xd9\x67\x3d\xbd\x2b\x9e\x5d\x55\x08\x78\x05\x88\x7b\xca\x57\xef\x3d\x7a\xcc\xe1\xaa\xf2\xea\x6e\xa1\xcb\x2f\x7b\xca\xab\xeb\x98\x2e\x3a\x0f\xbe\x93\xc1\x7b\x9a\xd8\x70\x1e\xb8\x68\x1e\x48\xbe\x06\xf8\x47\x26\xc8\xfe\x22\x70\xdf\x24\x70\x12\xb8\x9f\x12\x98\x06\x5d\x31\x77\xcb\xa7\x79\xe1\x69\xfb\xdd\xdb\xfd\x1d\xb2\x58\x92\x44\xd8\x8a\x57\x44\x09\xc2\x53\x1f\xa3\x57\xba\xf8\x01\x92\x86\xb9\x8d\x0a\xed\x00\x46\x67\xdf\xe6\x1a\x4f\x8a\x3d\x12\x7c\x31\xf8\x78\x78\xf0\x8c\xb1\xe5\x5b\x79\x21\x7e\x44\x10\xe7\xc3\x21\x31\x88\xe0\x30\xa5\x9c\x04\x55\x66\x8a\x51\xd3\x31\x1e\x66\x17\x84\x9e\x8a\x27\x31\x4b\xf8\xc5\x33\xb6\xc4\xe4\xc5\xba\xbf\x2d\x75\xfb\xee\x69\xa6\x25\x11\xc4\xc8\x43\x09\xb0\x91\x7c\x89\x1b\x51\x9c\x2e\x49\x92\xe2\x63\xf2\x16\xa7\x59\xcc\xc1\x67\x8b\xa8\x50\x89\x94\x0d\x0b\x99\xe9\x9c\x84\xc0\x46\x19\x8d\x85\x6c\x47\x82\xb7\x04\x62\x6b\x54\x8f\xfd\xf0\x1d\x8d\xa5\xe3\x3f\x5e\x2b\x2f\xf5\x4f\x02\xde\xb7\x0d\x99\x18\x82\x7c\x51\xaa\x8c\x2d\x19\xf9\x53\x42\x85\x94\xa4\xee\x2a\x90\x2f\x59\x11\x2f\xf7\x4e\xe9\x4f\xd1\x24\xfa\x2d\x8e\xf7\x86\xec\x57\x4a\xae\x38\xa6\x64\x82\x81\xaa\x7b\x63\xa4\x23\x6f\x8c\xae\xa7\x57\x0c\xa7\x0e\x1b\x71\xa8\xe1\x10\xc4\xcf\x3d\xf5\x64\xe9\xb0\x11\x23\xcc\x8f\x73\xbb\xed\x2b\xaa\x69\x4b\x2e\xcc\x8c\x15\xba\x3c\x13\x37\x0b\xd1\x01\x50\xe1\x3b\x97\xd3\x6b\x0c\x74\x24\xef\x1c\xa9\x0d\x95\x65\xb8\x5a\x62\xe1\x8b\xb8\xbe\x38\x57\x4b\x0c\x6c\x74\x11\xb1\xf9\x0e\xc5\xc2\x3f\xbd\x1f\xa7\x2e\x6d\xa6\x80\xf5\x3c\x4b\x99\x92\x82\x49\xd4\x50\x80\x42\x4c\x27\x54\xb2\xbc\x71\xdb\x2f\x78\xa1\xa0\x59\xf1\x1a\xb7\xb7\x58\xb2\xab\xc7\x9c\x77\xac\x29\x3b\xf2\x49\x26\x21\x52\x72\x45\xe9\xb4\xbe\x56\xca\x00\x05\xed\x81\x6e\x78\x2c\x8e\x7e\xe1\x01\x13\xaa\xad\x09\x08\xc9\x16\x9f\x10\xba\xd8\xf5\x99\xdf\xd9\xb3\xf4\x1b\xdb\x72\xcc\x28\x85\x84\x29\x62\xb6\x8c\x7b\x92\x32\x9f\x65\xe9\xdf\x36\xc7\xe3\x9b\x9b\xfb\xe3\xf1\xdf\x5c\x9d\x54\x68\x83\x08\x4c\x74\x2b\xf0\xe6\x97\xe0\x36\x52\x1f\x89\x5a\xd2\x1d\x72\x6e\x17\x6f\x3b\xc5\x43\x94\x52\x35\x51\xc1\x9c\x2b\xef\x73\xc2\x6d\xa9\x83\xd6\xed\xe7\xb5\x7f\x25\xb7\x6d\x25\xe6\x31\xae\x59\x9a\x54\x63\x99\xca\xb9\x38\xd7\x32\x2e\x85\x9a\x1a\x28\xc9\x66\x91\xc0\xbb\xca\x41\x61\x9c\xc3\xc1\x72\x82\xd9\x76\x1c\xbf\x55\x43\x91\xeb\x93\x22\xdb\x86\x8c\xc6\x4e\x39\xc6\x77\x6f\x0f\x80\x0f\xbb\x92\x54\xf7\x5b\xa5\x9d\x9e\x32\x61\x4a\x70\xc7\xe0\xd1\x5c\xf8\x9d\x10\x0e\xba\xad\x3f\xe8\x1f\x9c\x27\x4f\x5c\x5c\x0f\xee\x55\xfa\xd3\x10\xde\x5d\x85\x06\xde\xab\x19\xb2\x9c\x81\x25\x56\x31\xf8\xfb\xb8\xd0\xfd\x13\x6f\xba\x02\xdb\xd0\x18\x02\x1b\xbc\x5a\x52\xb0\xb1\x69\x3f\xa2\xae\x08\x1f\x9f\x99\xce\xf1\x03\x54\xec\x12\xe5\x61\xdc\xdb\xb0\x40\x84\xb2\xf3\xc6\x8e\x67\x8b\xd8\xde\x65\xdc\x8f\x62\xaa\xd5\xc8\xae\xd5\x8d\xa9\x9d\xcf\x35\x29\x69\x4f\x70\xd7\x5a\x75\x5a\xdf\xe6\xad\x66\xda\x47\x12\x6d\x51\xed\x12\x07\x39\x47\xca\x84\xf2\x53\x5e\x0f\x0a\x5b\x0d\x83\xc2\xcf\x34\xbd\xbb\x7a\x03\xa2\xa8\xb7\x36\x54\x04\xef\xb7\xeb\x71\x51\x14\xce\xd6\x76\x2a\xc7\x5a\xaa\x01\x78\xcd\xc8\xb1\x9f\x9e\x3a\x0c\x25\x36\x48\xaa\x26\x09\x85\xc6\x3b\x27\x86\x85\xbf\x94\x34\x56\x86\x3d\x59\x64\x31\x8b\x96\x3e\x65\xce\x52\x45\x07\x79\x47\xa3\xc2\x39\x13\xff\xc6\xc2\xcf\xf9\x55\x27\xe3\x32\x28\xd8\x3b\x0a\xd7\xb2\x53\x27\x42\xd3\x60\x54\xf4\x24\x9c\x1b\xc9\x1c\xe1\x97\x16\x82\x96\xab\xef\x7a\x68\xd4\x6b\x79\x0a\x3a\xac\xd8\x42\x54\xec\x13\x2c\xf7\x46\xa2\xe6\xe6\x10\x50\xc4\xd5\x09\xa0\x41\x9c\x9d\xac\xd7\x1f\xb8\xa2\x93\xa5\x43\xf0\xe3\xa0\x3f\x3e\x76\x85\xe0\xd6\x83\x64\x5f\x04\xda\x93\x78\x49\xb8\x73\x38\xed\xe6\xf3\x64\x61\x49\x01\x1a\x6d\x4d\x83\x51\x01\x77\x1b\x8e\x02\x77\x1a\x8c\x8a\x45\x81\x4b\xf9\xdb\xb0\xac\xf0\xd8\xc8\x81\x5e\x06\xc8\xa0\x3a\x15\x21\x4f\xba\x9b\x12\x0c\x41\x6e\xe7\xb0\x1d\xb8\xa8\x5a\xb6\x6c\x61\x97\x21\xa6\xcb\xf1\xd1\x15\xd8\x62\x66\xd9\x8f\x03\xb0\xfc\xe5\x32\x8e\xe4\xcb\xee\xbd\x2f\x29\x49\x38\x2f\x4e\x13\x18\x8b\x88\xe5\x36\xbc\x0c\xdc\x8b\x00\xde\x06\xee\x55\x00\x7b\x41\xc3\xe9\x7a\xd5\x25\xde\xdb\x00\x69\x34\xb0\x5e\xbf\x3a\x3a\xb6\x0a\x5c\xa8\x06\x59\x17\xd4\x53\x62\x05\xd5\x58\xf1\x38\x40\xd8\x2e\x30\xe3\xac\x85\x19\x77\x26\x79\x8f\xc7\xf0\x6a\xbf\x4f\xf7\x56\x77\xfb\x32\xa8\xf4\x4b\xd7\xe8\xb7\x0a\x39\x45\xcb\x4b\x6a\x32\x0d\x46\x72\x0f\x8b\xc3\x1a\xce\x78\x85\xc3\x2e\xd4\x1c\x44\x28\xa0\xc0\x60\x2f\x50\xf7\xe1\x9d\xa0\xd7\x8d\xbe\x1c\xb5\x3a\xc1\x68\x31\x31\xbd\xab\xf2\x4e\xa0\x98\x0f\xcb\x12\x6f\xd7\xd8\x39\xaf\xc5\x53\x4d\xad\x96\xe9\x82\xb2\xb6\x0a\xd0\x58\x2a\xc8\xcf\xa3\x94\x11\x7a\x35\x3a\x21\x88\xd9\xb0\x86\x9a\x0e\x5d\xb7\x03\xdd\xf2\x32\x4b\xe7\x9c\x15\xc1\xe8\x3a\x07\xcb\x82\x66\x37\x01\xb2\xeb\x3d\xe0\xdb\xf6\xa0\x54\xfc\x6f\xd5\x49\xb2\x6e\x27\xc5\xb3\x71\x53\xdd\x62\x3d\x70\x91\x75\xfb\xe1\x97\x98\x86\x62\x87\xcb\xca\xbb\x61\xe7\x30\xee\x4c\xd6\xd2\xae\x0a\x94\xbf\xf4\x52\x23\xa2\x68\x49\xbf\xb3\xcd\x29\x9e\x39\x6c\xc4\xff\xc0\x9c\xa4\x8c\x7f\x93\x94\x89\xef\xc4\x5f\x60\xf5\x9b\x7f\xc2\x92\x12\x46\x02\xc2\x39\x2f\xfd\x09\x84\x46\x27\x51\xe2\xb0\x91\xfc\x80\x25\xa1\xcc\xe3\x05\x08\x65\xb0\xf4\xd9\x5c\x35\xa2\x3f\x21\xc5\x3e\x0d\xe6\xc2\xc9\x11\xff\x80\xb9\x9f\xf2\x5f\xfc\x0f\x64\x29\xa6\xaa\xbc\xfe\x84\xa5\x9f\xa6\x17\x84\x86\xa2\x0d\xf9\x59\xf3\x12\xab\x01\x3d\x9c\xdc\x71\xb5\xc6\x50\xe2\x9f\x47\x27\x3e\x23\x54\x34\xb3\x7d\xc2\x27\x5e\xb0\x6b\xc7\x54\x44\xcf\xb2\x8a\x18\x27\x27\x84\xef\x6f\xcc\x0e\x14\x68\x1c\x02\x12\xcc\xaf\x39\x73\x9a\x40\x81\xcb\x0e\x85\x2a\xd6\x39\x18\x4e\x2a\xb5\x02\x88\xd2\xfd\x84\x61\x9a\x60\xb6\x77\xb9\x8c\x09\xc5\x74\x32\xe1\x27\x2a\x67\x58\xcf\x02\x77\x27\xa8\x21\x2d\x3c\x11\x49\x45\xeb\x70\x20\x7e\x9f\x10\xd8\x57\x65\xf5\x18\xe0\x95\x48\xa8\x0c\x11\x9e\x07\xee\xf3\x40\xb8\x38\x7b\x1e\xfc\x6e\xdd\xfd\xbb\xf5\x67\x37\xb5\xfb\x6a\x3c\x77\x68\x2e\x22\x5c\x89\x1b\xc2\xeb\xc0\x6d\x9f\x28\x92\x8f\x33\x1e\x85\xfb\x4c\x85\x86\x10\x01\x90\x4b\x3a\xac\xc7\x02\x1f\x99\x08\x35\x21\xfc\xa1\xc0\x27\x86\x9a\x31\x2d\x64\x38\x8b\xee\x5e\x71\xe1\xb1\xae\x7a\xc7\x7b\x9e\x2d\x96\xc5\x25\xeb\x20\x90\x57\x16\x79\x0f\x7b\x89\x4b\xd3\x3c\x31\xe3\x08\xbd\x0e\xf8\x20\x6d\x78\xa2\x0a\x6a\xdd\x12\x12\x46\xb3\xab\xae\xc2\x67\xf5\xc2\xef\xa3\x34\x2a\x0d\xf3\x5e\xe9\x2e\xb5\x85\x94\x4a\xdf\x57\xe9\x9c\x3c\xbf\xab\xf3\x14\xf5\xa3\xaa\xa2\x65\x23\x2f\xaf\x5b\xa7\x2a\xc2\x82\x53\x01\x9e\x4e\x53\x1f\x13\xdb\xce\xe1\xbd\x09\x56\x6d\xb8\xfb\x72\x22\x58\xdc\x35\xf8\x7c\x3e\x31\xb1\x44\x36\x7c\x08\xdc\x97\x6c\x14\x63\x7f\x86\xac\x97\x72\x7b\xc8\xb7\x89\x67\x5d\x19\x5f\x3a\x79\x3b\xde\xb8\xc3\x60\x49\x96\x1f\x84\x69\x14\x95\x27\xd3\xd7\xc0\xfd\xc4\xd7\xfd\x4b\x00\xd5\x53\xff\xcc\xb6\xe1\xa9\x89\xd3\x2a\x98\xca\xf2\x6c\xcc\x73\x78\x13\xb8\xe8\x59\x80\x9e\x06\x9c\xc8\xf1\xe1\x89\xcf\xb1\xdd\xc3\x96\xca\x55\x2a\x98\xd2\x4f\x3d\x9d\xa9\xd5\xd7\x9d\xbd\xe8\x29\xca\x51\x4a\x97\xfb\x6c\xe4\x14\x9f\x05\xe8\x45\x20\x25\x94\x1f\x7b\x1a\x12\x68\xab\x5b\xfa\xa1\x0d\x55\x1d\xe0\x44\xab\x4d\x75\xa2\xfc\xc7\x40\x06\x26\x6a\xa3\xfc\x8b\x5a\x4e\x03\xc5\x3f\xd5\x32\xeb\x28\xfd\x46\xe7\x35\x50\xfa\xa9\x4a\x17\x7c\x4a\xd6\x07\xcf\x24\x62\x84\x16\xd3\xa3\x59\x67\xbc\x25\xa1\x02\x8d\x38\x85\x2b\xe9\x98\x81\x30\x40\x85\xe6\x94\x38\x7e\x56\xd0\x10\x25\x9f\xff\x10\x20\x96\x71\xd8\xb7\x45\xf7\xb4\xae\x50\xcd\xd9\xda\xa6\x14\xbf\x24\x5a\x19\x41\x35\x53\x2d\x2a\x95\xae\x95\x71\x16\xd5\x86\x10\x75\x6b\xac\xc4\xc8\x0a\xcb\x79\xfe\x33\x07\x1f\xe8\xc1\x1b\xef\x15\x12\xe2\xc0\x60\x25\xcc\xf3\x5b\xcc\x1d\xf3\xb9\xdb\x80\xb3\x15\xf1\xb9\x06\x2c\x33\xdd\xa3\x64\x6c\x2d\xc9\x79\xe7\x36\x24\xed\x66\x6a\xf8\xd5\x3c\x50\x1b\xcc\x30\xe9\x41\x4d\xad\xd5\xa9\x30\x33\xc8\x0c\x84\xd9\x78\xba\x1d\xac\x07\x33\x3d\xcf\x9d\x60\x64\x3a\xf8\xdb\x55\xb6\x7c\xf4\x99\x41\x92\xc1\x51\x82\x7c\xf4\x21\x01\x6b\x49\x96\xfc\x5e\x81\x2d\xc0\xf2\xa8\x2c\x72\x38\x3b\xa4\x9f\x71\x64\x1e\x3f\x22\x5e\x30\x20\x3d\xd5\xed\x1c\xb2\xcc\x35\x5d\x65\xa4\xe8\x2a\x19\x95\x24\x1b\x6a\x4f\x1d\x12\x1a\xa6\x90\x6a\x1c\xd4\x24\x7f\xc4\x9c\x90\x08\xcd\xc4\xdf\xff\x94\xa7\x97\xd2\x77\x95\xea\x8a\xa5\x44\xd7\x9b\xd4\x6c\xd8\x2a\x47\xd3\xbb\x40\x1c\x66\xe2\x60\xd3\xc7\x04\xe6\x87\x83\x72\x0f\x3b\x60\xc2\xd1\x89\x16\xa0\x9b\x5b\x7b\xd1\x71\x85\x16\x6d\x1d\x48\x52\x1c\x88\x9d\x55\x34\x7a\x31\x8f\x62\xcc\xcf\x12\xbd\x5e\x65\xe7\xc4\xb6\x73\x64\x77\xb3\x2f\x11\xda\x15\xa7\xa9\x2d\xd6\x26\xe0\xdc\xd2\x4b\x36\xc2\xb3\x19\x0e\xd8\xa1\x9f\xf8\x27\x98\xa6\xa3\xf2\xcc\x74\xaf\x97\xa7\x27\x8e\x55\xd8\xfe\x24\xe5\x69\x0a\x62\x97\x7e\x0d\x80\x24\x7b\xa2\x7a\xea\x64\x19\x90\xe4\x08\xc7\xb3\xc3\xf4\xc4\x79\x1f\x88\x40\x02\xd6\xec\xd2\x82\x60\x11\x1e\xfa\x4b\xe7\x87\x80\x6f\x3c\xfe\x85\xb3\x5c\xfa\x6c\xc9\x8c\xaf\x53\x52\x0d\xb6\xee\xcf\xa7\x12\xfa\x58\xbb\x1f\x1b\xd2\xbf\x65\xa5\x69\xe1\x70\x22\xfd\xc6\x94\x6e\x58\xc6\x8f\xbc\xbf\x65\x8f\x3c\x6d\xd4\x1b\xb9\xec\x77\x4f\x78\xb9\x89\xee\xb8\x6e\xf0\x3b\xdd\xf0\xfe\x6c\x57\x8f\x66\xe8\xe7\x9f\x37\x7f\x7b\x78\xc7\x45\x0f\xef\x3f\xf8\xf5\xd7\xbb\xc1\x28\x98\xfb\x74\x87\x84\x78\x5b\x84\x3a\xb4\xad\x3f\x84\xea\x6c\xb4\x45\x36\x36\x1c\xe1\x94\x84\xb8\x13\xbb\x70\x17\xe5\x6d\x6c\x00\xef\xa8\xa7\x0f\xb2\xb1\x51\x3a\x7b\x45\x74\x23\x13\xc9\xb5\x9b\x63\xcd\xbf\x69\x15\x89\xef\x57\xe8\x05\x78\x9b\xb5\x78\x09\x41\x25\xa2\x23\xfd\x7b\x21\xec\xb5\xf5\x75\xa2\x98\x9c\xab\x27\x87\x9b\x93\x2b\x68\x9a\x87\xb0\x12\xef\x22\x0a\x9b\xb6\x6d\x6f\xd1\x8d\x4d\x67\x38\x51\xf2\x77\xfc\x3b\x2d\x3c\x16\xf1\xc2\x89\x6d\x6f\x71\xc0\x08\xff\xb3\xc3\x4d\x87\x6e\x4c\x9c\xe1\xa4\x19\xfb\xa2\x10\xef\xc9\x05\xca\x8a\x2b\x0c\x55\x66\xa3\xc3\x89\xeb\xba\x5e\x0d\x62\x1c\x09\x2a\xbe\xe1\xd8\x96\xe7\x78\x1b\x85\x93\x8c\xe4\x6f\xd1\x23\xbd\x22\xd9\xef\xc9\x9f\x5b\xf5\xc5\xcb\xaa\xf3\xe3\x63\x14\xeb\x15\x6c\x6c\xd8\x7c\xe5\xdc\xcd\xe2\x73\x03\x08\xcf\x70\xcb\x4d\x85\x91\xf2\x9b\x24\xc7\xba\x18\x05\xf3\x22\xc0\x62\x94\x1e\x65\x53\x15\x82\x3a\x11\x56\x26\x3c\x61\x67\xee\x53\x47\xd8\xb4\xcd\xa2\x24\x2c\x4b\x10\x11\x07\x0d\xd9\x10\x65\x2e\xf2\xb2\x51\x2d\x17\xbc\x6c\x54\xd4\xb6\xc1\xcf\x5c\x9d\xa0\xf2\x53\xd3\x81\x30\x58\x8c\xf0\x19\x62\x20\x46\x85\xac\x0d\xcb\xb6\x6f\x6e\xea\x69\x43\x8b\x93\x8e\xd9\x1a\xb5\xc7\xa2\x64\xbc\x46\x49\x6c\xe8\x67\x4f\xd4\x0e\xd7\xa8\x3d\x12\x25\x97\xc6\x92\x47\x0c\x31\xfb\xe6\xe6\x42\xfe\x39\x95\x7f\x4c\xd5\xe7\x99\xe1\xda\x20\xac\x53\x8b\x20\x15\x3e\x8a\x32\x90\x39\xc2\x15\xe6\x28\x58\x2c\x51\x02\x63\xfb\x6f\xe3\xf2\x95\x84\xb9\x0c\xa8\x9b\x00\x76\x31\x3f\x76\xcf\x4d\xcd\xea\xe6\xe6\x45\x73\xd5\x79\xf1\x03\x6a\xeb\x35\x47\x2b\x47\xfc\x16\xdd\x2e\xf9\x5e\xc6\x36\x0c\x27\xf6\xd6\xae\xc8\x13\x25\x72\x1b\x16\x5d\xec\x85\xa8\x17\x8b\x2e\xd4\x78\xf1\x19\xc2\xbc\x05\xbb\x22\x7d\xd5\x0f\x5f\xa2\x74\x9a\x49\x2b\x5a\xe2\xaa\x91\xf0\xee\xb0\x93\xd4\xc6\x27\x4a\xce\x32\x69\xa2\xc7\x0b\x94\xa9\x47\xac\x4c\x7d\xcd\x10\xb1\x1d\x1f\x9d\x17\xc9\x8e\x48\xca\x6d\x38\xe9\x1d\x72\xa8\x86\x5c\xed\x53\x0c\x7b\x2b\x42\x0b\x99\xe7\x88\x2f\x01\xc0\x23\x65\xf8\x2b\x34\x69\xa7\x99\x8b\x88\x51\xf6\x5f\xde\xc8\x84\x7a\x9e\xc3\x40\x46\xb2\x52\x71\x3e\x13\xce\xd5\x06\x24\x51\x4a\xd4\x94\x5c\x38\x04\x02\x12\x3b\x41\xaf\x94\xff\xb5\x4f\x53\x4c\xcb\xfb\xd4\xd5\x0a\x1e\xed\x71\x4b\xb2\x79\xbc\xa2\xc6\x53\x42\x9a\x55\x2e\x56\xf1\x93\x7a\x8e\x58\x87\x96\x56\x53\xc5\x2a\x7a\x57\x31\xe3\x91\xfc\x28\x26\xce\xc4\xc4\xf1\x88\x92\x0b\x31\x79\x3c\x0a\x48\xcc\xbb\x3c\x5d\xc9\xc2\x4e\xb3\x96\x01\x65\xe2\x52\x20\x22\x9a\x10\x52\xb6\xfb\x7c\xfa\xa5\xaf\xf5\x82\x99\xb8\xca\x44\xe8\x51\xfe\xcf\xc4\x2e\xdc\xc0\x78\x13\xc8\x5c\x1f\x1d\x51\x48\xf4\xb8\x03\xfd\x91\xa8\x99\x55\x38\x92\xe3\x0c\xa4\x57\x0a\x22\x83\x4a\x4a\xa6\xf9\xc8\x48\x14\x22\x74\x9a\xc1\x95\x50\xc7\xba\x34\xed\xcf\x62\x73\x53\x18\xdb\x7f\x1f\x4e\xca\xa1\x9e\x64\x72\xbf\x56\x76\xf0\x11\x93\x8c\x0f\x71\x45\xb6\xd8\xa5\x81\x4b\xc4\x84\xf7\x28\x6d\x7b\x2b\x20\xca\x4f\x81\xf0\x0e\x50\x45\xf2\x0c\x98\xd8\x36\x99\xed\x90\xdc\x86\xc7\x6b\x90\xbe\x4b\x41\xbb\xb6\xd7\x26\xc6\x2f\x4d\xd3\xad\x96\xa7\x62\xa3\xe9\x5d\xcb\x27\x56\x21\x42\x8f\xe5\xec\x1b\x9b\x7e\x59\x49\xdd\xe5\xa7\x3d\xdf\xe7\x54\x6d\xfd\x4b\x06\x6c\x63\x53\x44\x17\x82\xb7\x5d\xb8\x5e\xc3\x9e\x5a\x10\x51\xbd\xd0\x9c\x07\x47\x3e\xef\x28\x29\x71\x80\xa3\x69\x32\x12\xa2\x55\x1b\x24\x3c\x85\x13\x59\x6f\x02\x3e\xff\xb3\xd9\x80\xae\x24\x21\x57\x19\x08\x6b\xb6\x84\x53\x91\xe3\xac\x1d\x44\x56\x6f\x1f\xa2\xf7\x4d\xa6\x37\x4c\xd2\xdc\x30\x32\x16\x31\xbe\x94\x1b\xc7\x13\x9b\xc6\xcf\x25\xea\xed\x75\x53\x7e\xb1\x2f\x7a\x76\x0e\x76\x13\x79\xf3\xab\xee\x1a\xdc\xde\x35\xe2\x1d\x97\xea\x2d\x83\xe5\x96\xe1\xf8\x8f\x02\x59\x55\x50\x0f\xe1\x39\xb2\x5e\x57\x6d\x16\x51\x3f\x13\xfb\x25\x2b\xf6\x1e\x67\x9f\xbc\x31\xf8\xfc\xcf\xa4\x06\xc1\x40\x40\xdc\xe7\xff\xda\x77\xef\xaa\x24\x0e\x7e\x9f\xff\xab\x60\xeb\x49\xf2\x2c\xbe\x7c\x09\x89\xc3\xba\xa4\xa3\x8a\x73\x3e\xda\xcb\xba\x1e\xca\x68\x6e\xab\xb8\x54\xa6\x9b\xcc\xd4\x74\x67\x46\x63\x30\x48\x50\xf9\x04\x65\x7c\x2c\x1b\x76\xbe\x8d\x92\xa9\x9b\xb8\x16\x4e\xaa\x25\x51\xaa\x21\x62\xb6\x42\xb3\x23\xe1\x50\x74\xc4\x28\x84\x98\x53\xf4\x2c\x12\x45\xe7\x67\x9d\x1b\x40\xc6\xef\x82\x27\xff\x24\x9c\xc1\x75\x4a\x3b\x96\x51\xc0\x1b\xb3\x0b\x2a\xb3\x13\x7b\x2b\x10\xb3\xab\x63\x4f\x20\xa9\x6d\x31\xc5\x83\xcc\x3d\xc8\x84\xb4\xfd\x20\xfb\xdd\xba\x71\xbb\xa5\xed\x3e\x7a\x92\xc1\x99\x3c\xcf\x73\x1b\x50\x51\xd3\xfe\xdd\xba\x19\xad\xa8\x77\xa5\xaa\x89\x39\xec\xff\x25\x6b\xaa\xf7\x4a\xb1\xa8\xc7\x99\x5e\x46\xb5\xae\x8d\x75\x16\xf3\x7d\x65\x24\xbd\x46\xe4\x94\xfb\x4e\x8e\x3b\x87\xe7\x5d\x83\xd6\xe4\x87\x6a\xf2\x33\xd6\xe4\x67\x52\xd0\x9d\xaa\xd0\x98\x53\x9e\x89\xa0\x3c\x93\x1c\x64\x24\xb5\x8a\x0e\x53\x63\x56\xbb\x6a\x46\x9c\x44\x5f\xf3\x9a\x7c\x26\xc5\x79\x2f\x7e\xf0\x0d\x5d\x0c\x41\xfb\xb3\x11\xb3\x2e\xa9\x9e\x28\x26\x7e\x08\x20\xbc\xce\x5c\x94\x18\xd8\xae\x52\x43\x86\x5c\x38\x4c\x74\x41\x75\xdb\xb8\x6c\xbb\x68\x98\xe4\xcd\x88\xe6\xd5\xdb\x6a\xb5\x91\x10\x17\x72\x36\x7e\x53\xb5\x6d\xd8\xed\x16\xa7\xae\xe4\x51\x4a\x32\x1e\xb8\x11\xba\xc8\x1a\xaa\xcf\x3e\x7a\x9d\xd5\x8e\x1b\x66\x4b\x59\x0f\x08\x07\x2c\x58\x11\xdc\x06\xc4\xb3\x0a\x1e\x09\x8a\x2a\x5a\x26\x92\xd2\xda\xc2\x97\x6e\x0f\x67\xf9\xc4\x8f\xe2\x92\xaf\x7c\x77\x2b\x2c\xbb\xca\x60\x37\x13\xef\xaf\x02\xd3\xde\x67\x85\x02\x89\xd0\x23\x88\x92\x93\xf7\x3e\x8d\x84\xd5\x49\x0e\x1f\x7a\xe4\x82\x45\xf9\x17\xf8\xea\x82\xd0\xf2\xe5\xe1\x59\x07\x5b\xf5\x36\x83\x0f\x99\xb4\x39\x58\xa7\xd9\xa3\xab\xc5\x94\x94\x72\xc7\xaf\xdd\xad\x7e\x91\xad\x3e\x6d\x4f\x65\x2f\x09\xad\x1c\xde\x64\x6e\x15\x1a\x0d\x26\x68\x9b\x22\xa6\x39\x46\x60\x8a\x81\xb0\xb7\xcc\xc7\x3f\x53\x1b\xfd\xa9\xe8\xd2\x86\x4f\x45\x9f\x8f\xfd\xf0\x2d\x5e\x62\x9f\x59\x39\xbc\x30\x4b\x0f\xf5\x85\xb1\xe0\x20\x19\xbf\x1e\x4e\x6a\x27\x2f\x65\x08\x73\xf6\x43\x45\x2b\xa3\x9c\x3b\xbe\x2e\x4e\xeb\x3b\xeb\xf3\xc7\xc5\xa5\x4e\xe2\x66\x50\x3d\x98\x25\xa2\x8a\xe3\xd9\xae\xb5\xf4\x29\x83\xc0\xe6\xb7\xd4\xe1\x04\xa8\x2b\x82\x32\xd6\x90\x9d\x14\x1a\x8a\x90\xb8\x41\xce\xb1\xef\x73\xff\x5c\x57\x4c\xe3\xba\x32\xe0\xda\x35\xb7\x7f\xd0\x3c\xa9\x04\xe0\x56\x0d\x72\x4e\x09\x13\x25\x47\xc9\x4c\x00\xc9\xda\x6d\x67\x46\x80\x64\x6b\x03\x24\x13\x00\xf9\xd8\x79\xe0\x88\xc3\xa1\xd4\xb7\x99\x66\xc8\xda\xbb\xf4\x03\x16\x5f\x55\x88\xb0\x01\x4d\x53\xf4\x42\x1d\x2d\xb8\xf6\x22\xc8\xec\xdc\xf4\x62\x91\xa2\xcf\x5d\xc5\x85\xd9\x4a\xe6\x66\x1d\x1a\x70\xe0\xad\x87\xa4\x9d\x5c\x71\x71\x9b\x4c\xf4\xb1\x44\x0a\xfa\x1d\x88\xc3\x28\x13\x34\xda\xcb\x75\xa4\x20\x71\x49\xa0\xe2\x62\x54\x2c\x50\x5a\x15\x43\xe8\x65\xf8\x96\x2e\x2a\x0d\x6e\xda\xf6\x75\x75\x19\x31\x24\x6e\xb2\x31\x01\xe2\x12\x08\xdc\x00\x32\x37\xdb\x98\x80\xe7\x4e\xa4\x4b\xe8\x66\xd1\xb4\x5a\x10\x3c\xd7\xdb\x98\x88\x27\x3d\x6f\x2d\x58\xae\x9a\xea\xb5\x74\x5a\x7d\xfb\x29\x96\x7b\xa6\xb9\x1b\x5a\x4b\x34\x53\x1b\xe3\x53\x06\x33\xe1\x0b\xfd\x1f\x0b\x19\xea\x75\xec\x82\x2e\xf4\xc7\x6d\xf4\x57\x7e\x4f\x75\x85\x25\xfa\x41\xdf\x6a\x8a\x3b\x7e\xf5\xc6\xa7\xae\x5f\xe5\x79\x5d\x39\x95\x1b\x3b\xa5\xd5\x32\xf3\xbe\xbd\x65\xbe\xa9\x70\x7b\xba\x5a\xc6\x98\xa1\x08\x51\x4f\xb0\x76\xe2\xa5\xce\xab\x9c\x18\x4f\x62\x22\x0e\x0c\xe2\x35\x4f\x28\xa5\xf0\x00\x9c\x6c\xe8\x01\xb9\x54\x74\x4b\x5c\x5a\xc8\x3c\xc4\x73\xb0\x18\x5c\xe6\xd2\x62\x78\x9e\xf8\x8e\x81\xe3\xdc\x25\x67\x2b\x04\xea\x6d\xf3\x2f\x6c\x2b\xf4\xd3\xe2\x87\xb4\x42\x88\x67\x6e\x5a\x11\x3b\x48\x8e\xd6\x6b\xef\xbc\x99\x46\xcb\xa0\x40\xcb\x4c\xa0\x65\x22\xd1\x72\x03\xcd\x86\xc4\x56\xf1\xd9\x63\xd1\x26\x84\xee\x8c\x22\x21\xb0\x21\x10\x43\xe9\x29\x58\x0f\x23\x94\xcb\xbf\x18\x05\xd4\x4f\xe7\x3b\x7e\x8a\x51\x21\x40\xbb\x16\xae\x16\x9c\xeb\x38\x4a\xb0\xf3\xcb\xfd\xfb\xbc\x97\x6c\x91\x38\xbf\xe5\x80\x93\x50\xa7\x3f\xf8\x59\xa7\x4f\x1e\xe6\x39\x84\xb6\x72\xc9\x29\x5b\x19\xcd\x38\xa8\xff\x9f\xc1\x52\xfc\x1a\xa4\x18\x2f\x84\xd7\xb9\xb9\x7f\x8e\x07\xfe\x60\x9a\x9d\xb4\x1c\xd3\xf9\xc9\xe0\xe8\x68\x67\x67\xaf\xcf\x39\x1d\x23\x24\x4e\xef\xc9\x46\x2b\x8e\xe9\xe4\x3d\x28\xe4\x13\x6f\x41\x2f\x5e\x09\xbd\x58\x42\xcf\x86\xa0\x8a\x2b\xfb\x09\xc7\x94\xcc\x73\xd1\x3f\x0a\x55\x5e\x7e\x1f\xaa\x04\x7f\x19\xaa\xc4\x7f\x0d\xaa\x3c\xbc\xff\xab\x11\x55\x1e\xfe\x3c\xee\x45\x95\x28\xf9\x57\x43\x94\x4e\x6e\xfa\xb1\x1f\xbe\x4a\xf0\xab\x59\x79\x5b\xf0\xbc\x95\x4f\x19\x32\x4e\x84\x7c\xa1\x4e\xda\xec\x66\xe6\x21\x2a\xde\xed\x80\x69\x36\x95\x73\x1b\xfc\xa2\xc3\xea\x92\x25\xd2\x10\x6d\x0a\xbf\x6a\x52\xf2\x28\xd1\x53\xdd\x2f\xed\x9b\x1b\x9d\x2c\x04\x76\xea\xa6\x69\x97\x35\xe5\xc3\x89\x99\xf7\xa2\x39\x08\xf9\xc6\x44\xb0\x5f\x91\xb7\xfe\x6d\xc8\x47\x9e\x07\xb4\xcd\x24\x81\x6f\x6a\xa4\xb8\x5c\xc8\x33\x4b\x5f\x4c\xd2\x9e\xb2\xdb\xec\x00\xfb\xa5\xa2\x3f\xcc\x3c\x37\xf5\xd0\xd8\x86\x58\x7c\x4c\x6c\x08\x4d\xb5\xef\x8c\x73\x58\x7a\xae\x3c\x38\x66\x9e\x49\xc2\x55\x97\xdf\x0e\x0c\x4f\x64\x7f\x24\xa6\x44\x6a\xd9\x3d\xea\xe7\x94\x5f\x96\xe7\x9d\x67\x99\x90\xae\x2c\x3d\x2d\x95\x39\xf7\xdc\x73\x4f\x88\x73\xce\xbd\xdf\xad\x9b\xa1\xf5\xa7\x3b\xf7\x64\x78\x38\xcf\xed\xbb\xf2\x0f\x22\xaf\xa1\xc9\x13\xa1\x9d\x8a\x01\x4f\xc5\x81\x21\x5a\x78\xa0\xeb\xd7\xab\x04\xf2\x9a\x6d\xe7\x10\x21\x21\x4e\x1a\x59\x7f\x76\x7c\x8a\x37\xa0\xaf\x19\x4a\x6c\xa9\x82\xd0\xd2\x16\x8a\x90\x9e\x01\x2f\xc6\x6c\x78\x95\x71\x1c\x27\xb6\x6d\x52\x1b\xb2\xe1\xa4\x6b\x7e\xf2\x3a\x63\x9c\xc8\xc9\xca\x89\x94\xd4\x74\xce\xd1\xd2\x00\xa4\x62\x94\xf5\x01\x27\x7c\x5a\x20\x60\x18\x70\x82\xf9\x9d\x13\x14\x8f\x65\xdf\x30\xc3\xe9\xea\xa5\xca\xdc\xfa\x4a\x97\x08\x5d\x0c\x28\x97\x23\xb4\xbf\x17\x1a\x46\x14\xe3\xe0\x69\x43\x27\x33\xc0\x60\xbd\x52\xb9\x0d\x57\xdf\x8d\xeb\x4a\x61\x91\x54\x15\x16\x9f\x10\x3a\x95\x4e\xe5\x9c\x35\x31\xa8\x3a\x32\xa5\xa3\xf8\x4a\xc8\xc0\x4a\x9f\x71\x2b\xd7\xa8\xde\x46\x43\x97\xd1\x0c\xf0\xca\x27\x2d\xf7\x18\xac\xda\xb8\xb5\x9e\xec\x3c\x37\xae\x8b\x09\x6b\x2b\x15\x3b\x36\xe7\xb1\x67\x94\x48\xa8\x59\x1c\x56\x4e\x82\xca\x22\x71\x24\xd3\xe4\x96\x19\xb1\x67\xee\xf1\x41\x60\x1b\xd4\xeb\xf7\xc4\xde\x2a\x87\x53\xbe\x27\x38\x29\x3a\x2e\x66\xce\x2f\x77\xa6\x69\xc9\xb6\xa8\x0d\xd5\xc2\x1b\xdd\x85\xc5\xc8\x7c\x75\x60\xd4\x6b\x19\x80\x90\x2b\xa5\xc0\x0b\xaf\x4b\xea\x69\xd0\x50\x7b\x2b\x1c\x97\x7a\x13\xfe\x41\xed\xfc\x51\x43\x89\x0c\x17\x9a\x6a\x0a\x62\xef\x32\x54\xf1\xa5\x2e\x18\x9b\x81\x3f\x10\x26\x5a\x43\xce\x65\x0d\x02\xb2\x10\xbe\x23\x85\x23\x74\x36\xc7\xd2\xad\xf8\x80\x91\x53\x9c\x0c\x02\x3f\x49\x08\x1b\x4c\xa5\xeb\x75\xbc\x58\xb2\xab\x81\x34\xea\xbc\x23\x8d\x40\x1b\x7d\x4f\xbe\xb3\x6f\x9c\x84\x6b\xf5\xdc\x50\xd6\x2f\x4f\x64\x75\x8c\x62\xc9\xe8\x8c\xbc\xb1\x7d\xf7\x6e\x25\x71\xa2\x12\x2b\x34\xbc\x38\x7d\x24\xea\x8a\x35\x13\xa6\x6f\x30\xb1\x3b\x2c\xb1\x24\x0b\xbf\xf4\x03\x9c\x3e\xea\xdd\x74\x1c\x79\x46\x02\x9e\x9c\x47\x87\x19\xba\xf2\x80\x8e\x70\x12\x0a\x5b\xf3\x88\xe1\x05\xd0\x51\x8a\x97\x3e\xf5\x19\xa1\x40\x47\x8c\xfa\x51\x1c\x25\x27\xa2\xe7\x53\xcf\xed\xb6\x81\xac\xb2\x82\x5e\xa9\xd5\x42\x4a\x99\x85\x57\x11\xcf\xb4\x9e\x43\x69\x17\xd3\x8a\xe5\x23\x42\x5e\x6d\x46\x89\x1e\x80\xba\x74\x63\x02\xd8\xc5\x1b\x13\x48\xdc\x9a\xe8\xa1\x10\x3a\x00\x75\x3d\xb3\x74\x82\x73\x7d\x47\x26\xae\xd6\xc0\xfb\x95\x3a\x9c\x10\xb8\x44\x3c\x88\xaa\x2b\x93\xe7\x12\xc1\x93\xa6\x2e\xd1\x57\xa6\x99\xb2\x4e\x4e\x18\xc4\x9c\x97\x55\x57\xa6\xa5\x86\x4a\x0a\x59\x09\x95\x65\x4b\x68\xf5\x5e\x08\x53\xa5\x8f\x63\x5d\x64\xd3\xde\x0a\xd1\x29\x3f\xcf\xd2\x8d\x09\x78\x1b\x13\x98\x40\x06\x22\x5e\xb3\x4a\x5f\x82\x07\xbc\xaf\x78\x43\xe7\xc0\xb9\xd4\x74\x48\x61\xae\x47\x96\x55\x4e\xc7\xfd\x04\xce\x01\xab\x07\x56\xd1\xa7\xbc\x54\x9c\xc3\x5c\x92\x81\xcb\xe2\x16\x59\x1e\x2a\x39\x3c\x36\x10\x07\xd5\xe6\x85\x87\xd4\x3d\xca\xfa\xdd\x82\x02\x8d\x1c\x0b\x2c\x71\x8b\xb2\xfe\xb4\x40\x62\xa9\xc3\x80\x23\x9b\x43\x41\x23\x98\x73\xe9\xf5\xd9\x37\x56\x9a\xbe\x36\x36\x9d\xaf\x6c\xda\x86\xed\xb5\x86\x8e\x8c\xed\xdb\xdf\x3a\x74\xed\x06\x38\x49\x70\x2a\x7c\x4a\xec\x48\x1a\x73\x1b\x63\xc4\x97\xbd\x55\xdb\x8f\xb6\x11\x7a\x4c\xc1\x72\xad\x52\xe1\x89\x9f\x0a\x85\xb0\xec\xee\xdd\xe2\xa7\x22\x90\x77\xef\xaa\x6b\x9b\x24\x49\x32\x71\xcb\x47\xaf\xfa\xc7\x55\x3d\x07\xca\xf1\x9c\x2a\xdb\x05\xf5\x21\x54\x8e\x6d\xe7\x2c\xb7\xe1\xa5\xf1\x8e\x75\x81\x51\x84\x18\x83\x6d\x7e\x5e\xf1\x81\xdf\xb5\x20\x42\x17\x14\x26\xda\x4f\xd1\x5b\xcf\xa0\x3b\x2e\xcb\xde\xb3\x80\x35\x26\xa9\x1d\x7f\x58\x5a\x53\x7a\x8b\x8e\xe4\x75\x6f\xaf\xde\x4e\x95\x64\x51\x97\x3d\xaa\xea\x57\x57\x8f\x8d\xb3\x47\x35\x41\x3c\x1e\x65\xc9\x79\x94\x46\x0c\x87\x9d\x17\xde\x03\x84\x47\xc2\x83\x91\x3c\x94\x64\x01\x6f\x5c\xc0\x39\x69\x1e\x4d\x95\x0a\x4c\x68\x5e\xe7\x39\x1c\xf6\x10\xa7\x3d\x0f\x89\x47\xd9\x6b\x35\x92\xba\xa1\xaf\x1e\x9f\xf3\xd6\xe3\xdc\x82\xf0\x30\x97\x3a\x3a\x7c\xf3\xb1\x64\x40\x77\x7a\xee\x6b\x87\x9c\x4f\x50\x8b\x40\x85\x71\x20\x5f\x3d\x7e\x78\x08\xab\x41\x51\xff\xac\x7b\x3b\xa9\x06\x68\x69\x76\xd8\xac\xbc\x42\xd9\x4c\x8f\x1f\x8f\xd4\x57\x65\x4e\x15\xf8\x17\x33\x1b\xc9\x0f\x35\x41\x56\x00\x53\x70\xe4\x4f\xfa\x18\xbb\xa2\x2b\x56\xe9\x82\x36\x41\x26\xcc\x8c\x0f\x7a\x6e\xec\x75\xa5\x3d\xd8\x37\x62\xfa\x81\x67\xd0\xb0\xa0\xeb\xa1\x54\x65\x7d\x2b\xc2\x93\xda\xe3\x17\x01\x66\x6f\xd5\xb9\xc0\x14\x3d\xf1\x1a\x6c\x34\x11\xef\x4e\x1a\xae\xb9\x50\x3b\x80\x02\x80\x1a\x70\x4d\xe6\xb0\xce\x78\xe7\xf0\xaa\x13\x79\xaa\x93\x64\x85\xf4\xfe\x7b\x26\x29\xc2\x92\x90\x86\x07\x15\xa5\x48\xf2\xd7\x4c\x57\x86\xfa\x59\x35\x69\x1b\x9e\x7b\x6e\x84\x5e\x79\x60\x1d\x1d\xbf\xdd\x7f\xf9\xd4\x82\x5d\x66\xc3\x6b\x21\x71\xe1\xa9\x2f\xdf\x1d\x3e\xde\x7b\x6b\x41\x4c\x79\xaa\x50\x3b\x79\xf4\xda\xfb\xdd\xfa\xdb\x3d\x93\x81\x68\x09\x99\x42\x99\xa0\x01\xbb\xe2\xac\x26\x4c\x3d\xcc\x49\x61\x99\x38\x9f\x05\x80\x76\xbb\x9e\x4b\x8c\x4d\x96\xfa\x09\x25\x1b\xf0\x19\xce\x3c\x94\xe8\x55\xc7\x35\x9a\x92\x18\x76\x5f\xd2\xde\x7d\x49\x63\xf7\xe9\x7b\xc4\x3b\xcf\x35\x4e\xa8\xbe\x40\xac\x7d\x19\x7b\x84\x5e\x7b\xae\x02\xe0\xef\xd6\xdf\xb6\xfe\x51\xd0\x7b\xdf\xb3\xa1\xdf\x64\x98\x5e\x35\x76\xf5\x87\x4e\xa4\x7f\xef\x75\xea\x1a\x4a\xd8\x3c\x32\x4d\x5d\xa0\x6b\x09\xe4\x2a\x68\x09\xa8\x35\x41\x14\x45\xe8\x1d\x05\x06\xc4\xee\x12\x2b\x3d\x33\x52\x9b\x08\x7d\xe0\x44\xf8\xd8\xce\xe1\x8b\xe7\x9e\x37\x8d\xe0\x0c\x86\x1a\xd6\x73\x3f\xc9\x7c\x7a\x25\xdc\xee\xdd\x9f\x80\xb7\xe9\xdc\x9f\xe4\xed\xbb\xa5\xa9\xea\x13\x3c\xa5\x45\xdd\xcd\x5f\x79\xdd\xcd\xdf\xd6\xac\x7b\xc8\x8f\x85\x6f\xe9\x74\x7b\x49\x85\x46\xcb\xc4\xb9\x3f\x16\x15\xc7\x6b\xf7\xf8\x4d\x93\x7c\x9e\x25\xf8\x5b\xba\x7b\x9e\xc5\xdf\xd4\xdf\x76\x76\x92\xa5\xec\x5b\x6a\x1e\xe1\x25\xc3\x8b\xa9\x40\xde\x5b\x0f\xf7\x55\xc0\x48\x51\xf5\x76\xfd\xbe\x24\xe7\xdf\xdc\xed\x2e\x0e\x2a\x75\x0d\xfd\x2a\x31\x45\xf1\x9f\x0d\x5f\x4d\x9c\xa1\x38\x0c\x85\x6a\xd4\xef\xd6\x8f\xd6\x9f\xc0\xe0\xc1\x98\x53\x77\x6c\xc8\x99\x88\x9c\xa4\xf1\x44\x60\x68\xc1\x24\x63\xc1\x06\xfb\xd1\xf6\x70\x4b\xe3\x3d\xc9\x9f\x26\x8a\x3f\xbd\x33\x2e\xb9\x42\x9d\xa3\xb9\x42\xf1\xe2\x31\xd1\x49\xde\xd8\xae\xd5\x2f\x79\xf4\x3a\x43\x59\xa6\xdb\xfa\x41\xa0\x66\xdc\xd7\xae\x2f\x3b\x1a\x57\x1b\x50\x7d\xdd\xa2\xd9\xde\xa2\x93\xa2\x68\xf3\x6f\xd3\x32\xf0\xce\x24\x87\xa7\x5d\xe7\x59\x84\x96\x0c\xe8\x70\x02\x5f\xbc\x82\x11\xd0\x66\x8f\x4a\x05\xe0\xab\x87\x98\xbd\x25\x25\x2d\x9b\x8e\xfc\x3b\x71\xc6\xb9\x0d\x6f\xd6\x78\xbb\x1a\x46\xe8\xa9\x7c\xa1\x90\xcf\x4d\x15\x4b\x9c\xbf\x8f\x6d\xbb\xf3\xde\x43\xa5\x1a\xcf\xa3\xaa\x3c\x22\x11\xb8\xf9\xc9\x48\x95\xe5\x28\xef\x3f\x7c\xe8\xdc\x7f\xf8\x73\x0e\x2f\x3c\x93\x37\xa1\x8a\x32\xcd\x9d\x42\x9d\x86\x56\x06\x32\xc0\x4a\xe4\xc4\x80\x88\x4e\x03\xf7\x13\x67\xf5\x1f\x31\x37\x01\xea\x12\xc0\x6e\x87\x91\xc9\x20\x42\x3b\x30\x86\x57\x0c\xc5\x94\x1f\x86\xfc\xfc\xf8\x5c\xdc\xf4\xb7\x67\x0c\x53\x2b\x87\x8f\xe5\x0b\xb2\x08\x80\x6a\xe5\xf0\x83\x09\x88\xcc\xa9\x0c\x55\xd5\x2e\x9c\xa6\xd9\xd7\x1c\xae\x72\x5c\x35\xd3\xa6\xbf\x8f\xed\x6b\xe6\x7e\xf6\x4a\x80\x3d\x0a\x48\xc2\xa2\x24\xc3\x03\x96\xd7\xf4\xb9\x60\x5c\xb0\xb4\x35\xa8\x6f\x4c\x40\x2c\xae\xd3\xbd\x24\xb9\x5a\xd9\x8d\x62\x04\x77\xea\xe6\x55\x2b\x16\x55\x54\xdb\x10\x4b\xfb\x51\x0c\x75\xa8\xd6\xd6\x06\x16\x99\xbc\x4c\x8c\x52\x1c\x90\x24\x04\xec\xb2\xd1\x22\x4a\x32\x86\x85\xea\xec\x9c\x64\xb4\x61\x8b\xb5\xf9\xa0\x50\x45\xc3\x1b\xc2\x1e\x64\xbc\xf5\x9a\x21\x8b\x17\x1d\x44\xe9\x80\x64\x6c\x40\x66\x03\x2a\x0c\x90\x6d\xa7\x3a\xea\x9b\x1b\xfd\x6b\xf3\xc1\x5a\xd5\x70\xad\x1a\x86\x9f\x7f\xd3\xd5\xe4\x18\x3b\x2b\xd2\x5a\x45\x5a\xa9\x28\xe7\x69\xa8\x28\x6c\xbf\x72\xa0\x91\xd9\x74\x44\xe0\xf1\x68\x41\x12\x36\x87\x49\xa5\xed\x22\x6d\xb3\x18\x1a\xff\xdd\x39\x32\x36\x0a\xfd\xab\x46\x0b\x3c\x45\x6e\xe1\xd1\x15\xf6\x29\xa8\x36\x6d\xdd\x62\xe8\x5f\x19\xda\x63\x91\x18\x30\x8e\x5a\x21\xf0\x70\x8b\x10\xa9\xe7\x16\xa6\x5e\x5a\x36\x8a\xd7\x11\x2a\x5f\x4d\x86\x15\xa7\x26\x17\xbf\x5b\x1b\x1b\xe2\xe0\xa0\xad\xf7\x10\x21\x24\x49\x5c\x1f\xed\x25\x70\x96\xa0\x89\x0d\x87\x09\xb2\xd0\xef\xc3\x8d\x3f\x6d\xf4\xc7\x1f\xe1\x1f\x7f\x84\xb6\xb3\xa5\xbf\x2c\xf1\x40\x07\x96\x25\x5e\x20\x89\xcb\x39\x76\x03\x70\x45\x14\xbb\x85\x8c\x94\x2c\x54\x88\x03\x17\x89\x66\x3f\xdf\xa0\xdf\x37\x86\x7f\xfe\xf1\x47\x78\xbd\x99\x3b\x5b\xf2\xaf\x6d\x6f\x59\x36\x10\xbb\x79\x34\x05\x75\xf9\x50\xa0\x85\xf7\x77\xef\x16\xc4\x36\x50\x92\xec\x76\xc1\xf2\x48\xaa\x97\x9d\xd4\x8d\xd5\xeb\x35\xaa\xe7\x50\xbb\xde\xa4\xd2\x93\x3c\x65\xaa\x59\x93\x56\xd6\xc4\x70\x99\xac\xee\xeb\x17\x1e\x8a\x10\x86\xa0\x90\xc6\x43\x65\x88\xfa\x06\xf8\xc2\x43\xf5\x01\x08\xf9\x7c\xfb\xc0\xfb\xab\xfa\x1b\xe7\xad\x23\xb2\x79\x34\x1a\x9a\x1e\xcb\xaa\x39\x24\x46\x5a\xd4\x7c\x0b\xa9\x4b\xb4\xc6\x8f\xb4\x03\xd4\xb7\x55\x1c\xfc\x1d\x46\x7f\x5a\xa6\x43\xc3\x1a\x8f\xac\x5c\x79\x62\x4d\xdc\xe2\x04\x99\x51\x84\xed\xf2\xc5\xf5\x31\x9a\xe0\xfb\x3f\x25\x76\x0e\x24\x72\xa3\x1a\x7a\x97\x3b\xc2\xe2\x88\x7d\xfd\x20\xb7\xb7\x86\x5b\x16\x34\xd3\x37\x7b\xd2\x6b\xa9\xc7\x1d\x85\x9c\x5b\xa6\xd7\x53\x7f\x1f\x81\xd8\x29\x13\x68\x65\x7d\xbe\x31\x6c\xa3\x2d\x0b\x2c\x34\xfa\x89\xef\xa6\xf2\x3f\x08\xd6\xa1\x26\x0a\x66\x02\x43\x76\x80\x2a\x47\x83\xc9\x7a\xfb\x9b\x44\x88\xda\x0d\xb1\x67\x52\xdf\x92\x49\x6b\x93\x26\xf5\x4d\x5a\x4f\xec\x49\xef\xcf\x5a\x99\xbb\x4e\x81\x35\xcb\xac\x5f\xcc\xc0\x1e\x77\x97\x34\xf2\xd2\x82\xa5\x2c\x28\x52\x7f\x7d\x09\x68\x71\xcc\x54\xc2\x3e\x0b\x97\xaf\xb6\x43\x23\x74\xcd\x4f\x24\x87\x53\x02\xa5\xf0\x04\xd6\xd8\xb2\x41\x1c\x50\x95\xe4\x89\xc8\x99\x58\x36\x84\xfe\x55\x3d\xbd\xcc\xe2\x67\x7d\x2b\x6f\x52\xb6\x29\xce\x74\x53\x81\xb2\x8c\x3c\xbe\x3b\xca\x54\x9b\x8a\xe3\x48\x95\x4d\x22\xd4\x05\x82\xb1\x5d\x98\x02\x77\x17\x12\xe5\x72\x61\x21\x64\x65\xc9\x69\x42\x2e\x92\x81\xf4\x83\x6e\xe7\x90\x75\xb0\x0b\xe2\x91\x74\x6c\x6f\x59\x96\x3e\xf7\x61\xc2\x59\x92\xad\xca\xbe\x1c\x8d\xc7\x2a\x6c\x46\xa5\x4c\xbb\x90\x2e\x53\x4d\x2c\xc2\x6d\x78\x26\x0a\xca\xf3\x9a\x6a\xd2\xad\xde\xc7\xbc\x77\xda\xd7\x75\xb3\x00\xbe\xdf\x2c\x20\xf2\x69\x0e\x51\x1f\xd3\x64\xe8\x5a\x4f\xe9\x54\x70\x30\x7e\xe7\x29\x30\x56\xaf\x20\x77\xef\xaa\x2f\xad\x93\x6f\x7d\xb6\xea\x0f\x1b\x25\xbf\xf8\xf7\xe1\x64\x8b\x33\x38\xd6\xd0\x7a\xd4\xe2\x69\x92\x0a\x5d\x8c\x22\xb4\xc7\xcf\x00\xfe\x21\x7d\xa5\xd9\x39\xa4\xc6\x99\xc8\x50\x14\x56\x43\x3c\xeb\x45\x48\x32\x6c\x86\xeb\xb5\x35\x34\x04\x86\x88\x22\xcd\x2e\xde\xaa\x46\xe8\x5f\x99\xca\x1f\x77\x95\xe7\xdb\xcc\x54\xc1\xe9\x1c\x92\xd8\x78\xb7\xaa\x22\xf7\x96\x49\x63\x48\x36\x58\x6c\x3f\x43\x11\x9f\x17\x51\x36\x47\x3d\x12\x92\xdc\xce\x61\x16\xb9\x92\x00\x8d\x15\xc5\x99\x08\xfa\x32\x91\xa4\x64\xac\x49\xc6\x58\xd3\x85\x71\x6d\xe7\x8f\xf5\xee\xee\xe3\x41\x62\xf3\x7d\x48\xd6\xd4\x18\x74\xff\x21\xfe\xf9\x27\x8e\x6a\x1b\x0f\xf1\x83\x9f\xc4\x1b\x17\x84\xf5\x8a\x5a\xea\xa1\x99\x7a\xc1\xc9\x4f\x7e\xfb\x45\x1a\xcc\xab\x76\xbf\x0a\xe7\x40\x4f\xbd\x02\x71\x22\x14\x33\x98\x94\x1c\xbf\x0d\x58\x1c\xa3\x9f\x3c\x99\x25\xcb\x6d\x4c\x60\xf2\xdb\xc3\xdf\x0c\xd2\x9e\x5f\x1f\x3e\xc0\x3f\xff\xf4\x15\x99\x56\x4f\xe6\xa1\x4f\x45\x6f\x43\x13\x5a\xa8\x52\xa6\xfb\xc7\xb0\x0b\xf7\x7e\xdd\xfc\x15\xff\x3c\x14\x40\x91\xe8\xd6\x2e\x72\xff\xe7\x07\xf8\xc1\x90\x43\xab\xb8\x50\xb6\xca\x3c\xc4\x0f\x86\x9c\xed\x2a\x6e\x9f\xad\x12\x71\x84\xba\x70\x44\x2f\xcd\x78\x88\xbe\xa2\x84\x8f\xb5\x8a\x75\xb9\x7c\x82\xe9\x85\xb6\xd0\x54\xaa\x83\x9b\xaf\x97\x82\x82\xc8\xbd\x3d\xb8\xbf\x22\xd2\x0d\x64\x01\xcf\xe1\xc4\x50\xa0\x17\x96\xfd\x50\xec\x87\xe0\x70\xf2\xd3\x1a\x40\xe4\x10\xdc\xa8\x41\x30\x87\xa5\x69\x63\x94\x56\x37\x9c\xce\x7e\xf6\x9c\x8f\x9e\x00\x61\x29\x94\xc4\xf7\xe5\xbb\x71\x21\x50\xa1\x15\x15\xfa\xa4\x52\xf4\x1e\x9f\xf3\xcd\x18\x36\x1f\xc8\xbb\x61\x91\xfe\x10\x3f\xb8\x19\xc3\xc3\xb1\x2d\xad\x4f\x75\xf2\x04\xdf\x57\xc9\x99\xeb\xa3\x1f\x3c\xf8\xec\xa9\xf5\xba\x27\xc0\x7b\x33\xb6\x41\xd9\xea\xa7\xc2\x56\x1f\x66\xae\x8f\xde\x78\xe0\xc1\x04\xd2\x8d\x89\x0d\xb1\x3b\x53\x76\x19\x35\xdb\x3b\xe5\x4c\x7d\x16\xc1\xb5\x22\x1c\x81\x26\x2c\x44\x12\x9a\x44\x50\x9d\x50\xd1\xa0\x18\x04\x49\xf2\x6a\xb4\x06\x2b\x85\xfe\xa5\x5b\x0c\x07\xe6\x55\xc0\x88\x44\x1b\xce\xa5\x20\x77\xce\x99\x03\x31\x8b\x8f\x9e\xd8\xdb\xb0\xdc\x98\xd8\x4e\x3d\x85\xcf\xe7\x5c\xce\xe7\x9c\xcf\xe7\xa4\x32\x1f\x3e\x9b\x13\x39\x9b\x13\x9e\x57\x01\xd5\xbc\x02\x2a\x52\x4d\x2e\x01\x9b\x54\x93\xcb\x75\xf8\x07\xc0\x04\xe6\x91\x8b\xfa\x0c\xc6\xd4\x2d\x51\x54\x67\xaa\x35\x2a\xda\xc6\xba\xa3\xa2\xe3\xca\x50\xca\x5e\x32\x4d\xe5\xbd\x3c\xb7\xf5\x11\x7d\x94\x89\x00\xd4\xe7\x91\x8b\xba\x5e\x8f\x8e\xe7\x99\xd5\x2d\xdd\x7f\x42\xa3\x9e\xdc\x23\x61\xc2\xd4\xca\x9d\x47\x9d\x35\x0e\x49\xd2\xd3\xde\x71\x86\x7b\x72\x3f\xe0\xd0\xea\x78\x4b\x68\x6b\x23\xdc\x29\x7e\xda\xd7\x52\x96\x59\x73\x54\x77\x4c\x6a\xba\xff\x4d\xc5\xcb\x59\x6f\x36\x41\xd6\xf6\x94\x88\x48\x73\x4d\x7d\x56\x93\x16\x67\xd9\x97\x76\x5e\xa9\x63\x09\x0e\x55\x84\x87\xe8\x1c\xb7\xdb\x6a\x0d\xea\xed\x3a\xed\x0c\x55\xf0\xba\xd6\x38\xbe\x12\x44\xdb\xe4\xaf\x3a\xcd\xde\xd9\x94\x4f\x95\x2f\x49\xd3\x17\x27\x41\xd6\xd4\x0f\x4f\x0c\x73\xb0\xe1\xd8\x54\xfa\x02\x8b\x20\x94\xeb\x15\xfe\x92\x2d\xa6\x84\x51\xe1\x51\xb7\x55\xa3\x03\xba\x41\x8c\x7d\x3a\x8b\x2e\xbb\xa1\x2a\x27\x1c\xa1\x97\xc6\x95\x56\x3a\xc6\x8b\xc8\x45\xc6\x31\xcd\x08\x5d\x0c\x75\xa0\xc2\xf5\xa6\x41\xc9\x85\xa1\xac\x0d\x27\x51\x77\x80\x8b\xa8\xa5\x8a\x6c\x9e\x2d\x89\x87\x97\xe9\xf0\xa1\x61\xb6\x6c\x7d\x8c\xec\x69\xc5\x80\x38\x76\xd7\x3c\x03\x92\x30\x3f\x4a\x30\x1d\xce\xe2\x2c\x0a\xd7\x86\x4f\x51\xcf\x54\xc3\x47\x3e\x01\x2b\x8e\x92\xd3\xe6\xed\x63\x57\x44\x39\xbd\x8a\x71\x3a\xc7\x98\x99\x10\xff\x05\x41\x96\x36\xcd\x5a\xf8\x97\x41\x98\x8c\xa6\x84\xb0\x94\x51\x7f\xc9\x7f\x04\x64\x71\xaf\x48\xb8\x77\x7f\x74\x7f\xf4\xf0\x5e\x90\xa6\x65\x1a\x67\x39\x46\x81\x88\x24\xd9\xbf\x7d\xd4\x8f\x03\x3c\x63\xfc\xe7\x34\x2a\x5e\x60\x08\x63\x64\x61\xe5\x70\x55\x24\xbd\x8d\x4e\xe6\x9c\x78\x1e\x17\x29\xc7\x64\x69\xe5\x70\x11\xf5\xfb\xcc\x18\x18\x56\x8f\x06\x7d\x8a\x01\x92\xd1\xb7\x96\x64\x49\xce\x31\x1d\xcc\xfc\x50\x3e\x80\xdf\x59\xf9\xa8\xab\x6a\x46\x89\xa5\x8c\xad\xd6\x2a\xce\xc8\x52\x94\x57\xb7\xff\xe3\xc8\x5e\xb3\x22\x15\x20\xa9\x54\xbd\x5a\xbb\xea\x54\x02\xb8\x52\x77\xba\x76\xdd\x98\x2f\x57\xa5\xe6\x49\xbd\x66\x79\xca\x98\x9e\x8f\x83\x8a\x5c\x14\xc3\xea\xce\xc2\x28\x5d\xc6\x4a\x73\x41\x06\x0c\x6e\x1f\x69\x06\x15\x91\xd6\x59\x60\xdc\xc1\x3e\x35\x12\x99\x2e\x1a\xaf\x6a\x56\x0e\x4a\x19\xe9\x20\x69\xbe\xce\x32\xed\xb2\x64\x69\xea\x55\x21\xd6\x50\x86\x0c\x5d\x79\x8c\x11\xa1\xf5\xd8\xde\xe3\xce\x79\x94\xa3\xf5\xa9\x95\xee\x35\x90\x91\xc6\x56\xf6\x4b\x56\x1f\x6e\x82\xa6\x45\xe8\x59\x97\x06\xb3\x72\x84\x76\x66\x6f\x31\x87\xe6\x36\x9c\x75\xea\x3a\xb3\xad\x03\x44\xa5\xc2\x6c\x8f\x63\xa7\xee\x42\x4d\x05\x30\xd4\x7c\x28\xc7\x23\x6f\xec\x08\x37\x24\x5d\x7e\xa1\x0c\xc8\xa7\xdf\xb9\xd5\xea\xea\xac\xaa\xe0\xb9\x26\x2c\x6d\xa7\x29\x99\xea\x01\x8a\x10\x2b\x04\xa1\x49\x4d\x41\x98\x31\x74\xdc\x35\x21\xc3\x98\x94\xce\x71\xe9\xdd\xbf\x6d\x76\xb2\x75\xe6\x18\x4d\x42\xb6\xce\x9c\x03\x64\x68\x52\x19\x6a\x48\xa5\x41\x31\xb4\x3e\xb5\xf4\xaa\xce\x57\xe5\x79\x9d\x41\x84\xf6\x05\x3c\xa5\x02\xea\xa9\x49\x20\xd6\xd8\x20\x39\x1c\x75\x9e\xe5\xd7\x41\x4c\x52\x7c\xa8\xc2\xb5\xf1\xb6\x19\xd0\x51\x35\xd1\x86\xe2\x04\xdc\x89\xfd\x34\x75\xa4\xa5\x76\x99\xa0\xe2\xe6\x88\xca\x9e\x0c\x3b\xa3\x62\x0b\xda\x32\x90\x4e\x35\x43\x05\x5d\x14\xc1\xcd\x6b\x19\x32\xc9\xee\xd4\x2c\xf8\xb6\xc3\x65\x41\x42\x3f\x1e\x4e\xfd\xe0\x34\xa4\x64\x39\x50\x27\xc6\xa9\x7c\x9a\x5d\xb5\xf1\x6a\xf4\x29\xb7\xe1\xb2\x43\xf8\x68\xa4\x03\xb2\xe7\x22\x8a\x7b\x3f\x11\x68\x29\x2a\xda\x39\x3c\xbe\x7d\x6f\x2a\xc0\xf6\xed\xfb\xda\xee\xe8\x6b\xdf\xcc\xc3\x92\x14\x9b\x18\x9a\x65\x60\x12\x64\x18\x2e\x29\x06\xf6\xd7\xce\xe1\x65\xd4\xf5\x92\xa5\x0e\xc0\x33\xed\x1b\x47\xd0\xba\xf3\xa8\x8b\x04\x4b\x60\xe8\x90\xfa\x2b\xc0\xe1\xa3\x8b\x08\xce\x23\xd8\x8e\x3a\x78\xd2\x1d\x9e\xdb\xc1\x68\xbe\x35\x8a\xf7\xa3\x8a\x7c\x5f\x0c\xb1\x71\x92\x51\x37\x42\x4f\xcc\x2f\x71\xf5\x9d\x95\x57\x0c\x10\x5a\x0f\xae\x5b\x95\xd1\x38\x2d\x20\x50\xd3\x59\xc6\xcf\xb1\x95\x87\xd8\xfa\xfb\xea\xfb\xb9\x35\x05\x49\x23\xff\x72\x3b\x9e\x85\x6e\x29\xae\xc5\xb1\x12\x92\x60\x03\xf3\xf2\x8d\xbc\x8b\x44\xa6\x30\xf2\x63\x72\xb2\xc6\x5d\xb8\xa7\x8d\x6e\x8e\xa0\x85\x1f\xfd\x6f\xec\xf5\x0e\xce\xa3\x66\x7b\x95\xa7\x17\xa3\x6e\x70\x84\x5e\x46\x80\x6b\x44\x1e\x70\x41\xb2\xdb\xef\x01\x6a\x87\x3c\xe6\x95\x24\xfd\xee\x2c\x73\xc9\xcb\x28\x52\x6e\xe0\x55\x51\x9b\x85\x5c\x47\x54\x71\x64\x94\x90\xda\x39\xec\xad\xb8\x94\xd4\x4f\x37\xd6\x3a\xc9\xf4\xd1\x55\xc4\x51\x54\x07\x53\xbf\x63\xbf\x28\x7d\x8b\x4f\xf0\xa5\xc3\x40\x44\xb4\xa2\x4a\x39\x5d\xfa\xf5\x3b\xec\x3e\x6a\x99\xc3\x20\xed\xb5\xc9\x0a\xcb\x12\x9d\xda\xe3\x47\x59\x10\x88\xf8\xc2\xda\x7d\xc6\x8e\x89\x78\xab\xc2\x4f\xfc\x28\xce\x28\xd6\x85\xe1\xac\xb8\xd5\x1d\x10\x3f\xe4\xc8\x95\xc3\x93\x22\x6d\x3f\x89\x58\xe4\xc7\x56\x0e\x07\x51\x8f\x3d\xa6\xea\x41\x58\xad\x8a\x20\x08\xa9\xc3\x20\xf6\xa7\x38\xe6\x20\x4d\xa3\x18\x27\x01\xde\x0f\x1d\x2c\xc2\x66\xcd\xa3\xa9\xd4\xee\x07\x61\x05\x97\x6e\x33\x87\xc0\x09\x4e\xb0\x30\x83\x7b\x47\x63\x27\x80\x28\x94\xe1\x29\xf7\xbb\x8e\x80\x6b\x19\x3b\x0c\xa8\x00\xbc\x00\xd0\xab\x6e\x40\x47\x93\x5f\x13\x87\xc1\x8c\xd0\x85\xcf\xda\xe0\xd4\xda\x56\xb5\x68\x3c\x7e\x69\xd6\x3e\x51\x01\x80\xf1\xb4\x48\xda\x54\xe1\x77\x7c\x5a\x24\xdd\x97\x49\xdb\xcb\x32\xe9\x81\x2e\x55\x46\xe8\xf9\xf9\x91\x0a\xf6\x53\x36\xff\x50\x27\x95\x46\xf0\xbf\xa8\xb6\xb2\x93\x22\xe9\x57\x15\xd7\x18\x97\x41\x82\x7e\x53\x26\xf4\x41\x19\xe4\x67\x32\x56\x11\x83\xc8\x79\x99\x36\x69\xaa\x85\x4d\x36\x39\x08\x9e\x77\xbf\x85\xd7\xb4\x91\xa1\x34\x24\x6e\x68\x33\xc3\x58\x7b\xef\x68\x28\x40\xc3\xd8\xce\xe1\x75\x7b\xf1\x4c\xe1\x9c\xab\x90\xbe\x6f\x00\xf5\x73\xbe\xd9\xb7\x36\x7f\x73\x36\x7f\x35\x00\x7d\xd2\x86\xfa\xfd\x71\x1b\xec\xba\x5c\x15\xee\xba\x9c\x00\x7c\x0b\xde\xba\x46\x15\xe0\xba\x46\x15\xe2\xba\x5c\x15\xe2\xf7\xc7\x4d\x88\xdf\x17\x1e\xc7\x76\x8d\x10\xbf\x44\x4f\xb1\xd4\x0e\x78\x67\xcc\xff\x8a\xd1\x91\xcc\x7f\x5f\xcf\x37\xe1\xed\x21\x69\xe1\xed\x71\x86\x9b\x78\xfb\x01\x87\x4d\xbc\x3d\x9e\x67\x4d\xbc\x7d\x42\xa3\x26\xde\x1e\xf9\xac\x82\xb7\x8d\x49\xfe\x92\xe7\xf0\x21\x72\x2f\xd1\xc4\x86\x67\x91\x3b\xc1\xf7\x7f\xfa\x10\xc1\x97\xc8\x7d\x38\xfe\xe9\x59\x04\x5f\xc5\xc7\x97\x08\x9e\x46\xee\xe6\x83\x9f\xbe\x46\xf0\x26\x72\x7f\xf9\xe9\x69\x04\x9f\x0c\x5b\x57\x9e\x59\xcf\x39\x64\x86\xcf\xb1\x70\x78\xed\xbe\x16\xbf\x5e\x8b\x5f\xc4\xdd\x15\xbf\x76\xc5\xaf\xc0\x7d\x27\x7e\xbd\x13\xbf\x32\x17\xed\x46\x22\x33\x42\xd4\x1e\x06\x3f\x7d\x8d\x86\xe4\xa7\x2f\xd1\x30\xf9\xe9\x59\x34\xc4\x3f\x7d\x88\xec\x7b\x4f\xa3\x9b\x31\x78\xd5\x30\x2b\x85\xde\x70\x26\x75\x76\x95\x94\x61\x0f\x65\x3d\xba\x71\x87\x88\xdd\xfb\xe5\x46\xb2\x56\x87\xd5\x6d\xf0\x8b\x5d\x84\x6d\x36\x54\xcb\x78\x25\x5e\xa7\xa8\x91\xc1\x2f\x22\x18\x86\xee\xea\x02\xe3\x53\xc7\x13\x2f\x46\xfe\x15\xff\x50\x8f\xe8\x41\xeb\x79\x25\x69\x3c\xe2\xd4\x8f\xaa\xba\x6b\x89\x77\x11\xbf\x12\x77\x5c\xf5\x37\x68\x6e\x03\xfe\x89\xc2\x6e\x84\x12\xa1\xae\x6d\xc3\x0b\xb3\xb2\x87\x69\x23\x1f\x96\xa3\x28\x70\xe4\x43\xa4\x77\x51\x2d\xf9\x99\x4a\x3e\x14\x53\x29\x92\xbf\xa8\xe4\x67\x24\x2b\xb7\xf3\x57\x95\xb8\x5b\xd9\xce\x4f\x23\x8d\xc7\xf8\xb4\x0c\x70\x16\x15\x08\xd9\x62\x78\x06\x1f\xa2\x9f\x70\xf5\xbd\x74\xe3\x19\x4f\x50\xdf\x5f\x64\x26\x1f\xcb\xc6\x57\xfe\xcd\x21\xbd\xf1\x94\x7f\x85\xfe\xd5\xc6\x1b\xfe\xc1\xd7\x23\xcf\xe1\xb3\x71\x8b\x7e\x8a\xd0\x8b\x48\x85\x87\x8b\x56\x86\x70\x10\x4b\xcb\xc4\xba\x52\xb9\xa8\x58\x2f\x6a\xa2\x17\x95\xd4\x16\xb5\x3f\x8a\xc3\x2e\x8e\x99\x5f\x9e\xff\x3f\x14\xe7\xb7\x02\x6f\x0e\xcc\x2f\x93\xca\x45\xca\x81\xfa\x9d\xfe\xba\x11\x9a\xfc\x7c\xff\x27\x44\x37\x8a\x50\x02\x42\x63\x7a\x78\xdf\xf9\xcd\xb6\x37\x36\xed\x7b\x3f\xdf\x8c\xed\x0d\x3c\x9c\x00\x71\xd9\xb0\x52\xe8\x6f\x93\xad\x89\x23\x1e\x83\x55\x22\x51\xaf\xcf\xc4\x21\xc3\xfb\xbf\xfd\x66\xdf\x7b\x30\x1e\xdf\x8c\x21\x73\xc9\xf0\xc1\x78\xfc\x53\xa0\x97\x68\xf2\xe0\xe1\xf8\xb7\x5f\x7e\x0a\x36\xd0\xfd\x87\x3f\xff\x94\x6d\xa0\xec\xde\x83\x9b\xb1\x3d\x44\xd9\xbd\x09\xaf\x61\x6f\x24\xf6\xf0\x97\xc9\x6f\x0f\x1e\xfe\xca\xf1\xd4\xef\xe1\x48\xa4\x67\x88\x57\x91\xf0\x5f\x52\x79\x04\xff\xdb\x78\x8b\x5f\x78\x67\xae\x8f\xde\xc2\x04\x22\xf4\x3a\x02\x11\x3c\x11\xdb\x10\xbb\x3e\xa2\x3e\xa4\xe0\xc1\xac\xb8\xae\xbd\x88\xd0\xc7\x08\x5d\x57\xd7\x82\x57\x1d\xc3\x6f\xbf\xfd\x06\x59\xa1\xdf\x26\xd3\x7e\xfe\x0d\x82\x42\x2d\xae\x48\x22\x4a\x91\x4e\x26\x6c\xde\x87\x44\x2a\xdd\xc5\x20\xf0\x60\x2c\x2d\xa4\x13\xdf\x84\x57\x21\xc2\x3e\x7c\xe1\x94\x0d\x9e\x89\x7f\x3f\x88\x7f\x05\xad\x03\x41\xff\x40\xd0\x44\x78\xae\x4e\x10\xe2\x1b\xb6\x6b\xe2\x97\x17\x50\xa4\x4f\x9b\x21\xb5\xef\x7d\x89\x6e\xc6\x39\x04\xbe\xdb\xe1\xdd\x7e\x35\xb5\xa0\x9c\x9e\xef\x46\x42\x37\x37\xb7\x21\xf3\x7b\xec\xb4\x3f\x47\xf0\x43\x04\xc4\xe7\x24\x99\xf8\xda\xbf\x33\x7c\x89\x6c\xf0\x7c\xf7\x55\x04\x91\xef\xbe\x8f\xc0\x37\xb4\xa1\x0c\x73\x7c\x79\x0c\x44\x7e\x4b\x61\x2e\x01\xcc\x17\xf7\x97\x8d\x64\x88\x9d\x64\x88\x73\x1b\xbe\x62\x34\xb6\x6d\x48\xfd\x66\xf4\x33\xc6\x8f\xa1\x77\x18\xf9\xbe\xbd\xb1\x2b\xfe\xd4\x4c\x26\xbe\x88\x24\xa9\xc0\xb3\x35\x1e\x22\x36\x9c\x3c\x78\x30\xb6\x9d\xf1\x90\xf1\xfb\xf2\xcc\x77\x89\x0f\xb1\x09\xce\x62\x8a\xcc\x07\xb6\x91\xfa\x3f\x65\x3e\xf0\x66\xb0\x3b\xf3\x51\x2b\x18\x4c\xea\xdb\x5b\x1c\x23\x24\x48\xf0\x30\xf5\x39\x2c\x20\xf4\x5d\xe4\xa3\x55\x8c\xf6\x20\xf6\x91\x40\x8c\x7a\x2e\x87\xa5\xd0\xaf\xf8\x84\x61\x62\x83\x64\x7a\xaf\x43\xff\xea\x68\x4e\x68\x3d\x6e\xe0\x0a\xc6\x41\x7c\xb7\x78\x07\xf1\xdd\x62\x1f\xc4\x77\x8b\x83\x10\xdf\x2d\x26\x42\x7c\xb7\xf8\x08\xf1\xdd\x60\x25\xa4\x3e\x00\x07\xc8\xd5\x4b\xce\xe8\xdf\x72\xf0\xa1\x7f\x65\x1e\x7f\x5a\xe6\x34\xe6\x90\x54\xf3\x1a\x33\xa1\x95\xac\xc6\x74\xca\x8c\xc6\x8c\x32\x2a\xb2\xda\xd3\xe2\xc9\x79\x2e\x15\x27\xd6\x5b\x99\x0a\x83\x2c\xbe\x5b\x2c\xb2\xf8\x6e\xf1\xc6\xe2\xbb\xc5\x1d\x8b\xef\x16\x7f\x2c\xbe\x5b\x1c\xb2\xf8\x6e\x5d\x4e\xc4\x77\xeb\x7e\x22\xbe\x5b\x1c\xb3\xf8\x6e\xf1\xcc\xe2\xbb\xc5\x35\x8b\xef\x26\xc0\x76\x71\x50\x40\x6b\x2d\x4c\x68\x00\x4b\x98\x09\x1b\x01\x46\x2b\x59\x0d\xa8\x05\x73\x33\xdc\xa2\xf8\x36\x90\xc3\x66\xd0\x5d\x99\x61\x97\xa5\xcc\x0c\x3e\x65\x5a\x6b\x04\x22\x29\x73\x1a\x80\x54\x95\xda\xd0\x94\x19\x72\x6b\xbd\x9a\x1d\x72\xb8\x7e\x88\xd8\xfc\x28\x9b\xcd\xa2\x4b\x67\x45\x9c\xd3\xf2\x02\x27\xa1\x3d\x98\xe8\x96\x27\x7a\xf8\x83\xcd\x22\x6d\xb3\x92\x58\xa4\x25\xa1\x4e\x2a\xd3\xca\xc4\xfb\x3a\xed\x3e\x2d\xca\x15\x69\x9b\x65\xe2\xfd\xa2\x93\xfb\xa2\x93\x96\x1b\x38\xfd\xd4\x79\xca\x4f\x0c\x8b\xcd\xad\x2a\x6f\x3d\x60\x5b\x3e\xba\xa2\xf0\xa0\xe2\x9b\x12\xb0\x2d\xf5\x9f\x94\x90\xe0\x5a\x04\x46\xb5\x7e\x1c\x2e\xee\xfd\x38\x0c\xef\xfd\xf8\xc9\x82\x98\x24\x27\xbb\x32\x75\x1b\x06\x3f\x3e\x1e\xfc\x18\xc2\x80\x67\xb0\x68\x21\x8a\x3e\x73\x7e\x3c\x1c\xfc\xb8\x94\x25\x8f\x2b\x89\xce\x8f\x47\x22\x9d\xb7\xa9\xd3\x75\xbb\x83\x1f\x87\xfb\xba\xde\x2c\xa2\x29\xdb\xe5\x0b\xc3\x19\x5b\xe7\x8d\xe0\xe5\x97\x26\xce\xc0\xf4\x42\x75\xef\xe1\xb8\x71\xa7\x60\xf0\x70\x6c\xe7\x39\xcc\xfd\x2e\x49\xba\xe1\x55\x49\x80\x86\x1f\x2d\xa7\x48\x3e\x2a\xc1\xb9\x91\x37\xa9\xda\x9d\x54\xab\x6e\x02\x13\x60\xe7\x1d\x2f\x8c\x35\x5b\xa2\x84\x4d\x1b\xc6\xf6\xd6\x64\xd3\xa9\x27\xe6\x70\xd2\x1e\xb8\x44\xc9\xa5\x8f\xf6\x84\x7f\x57\x19\x06\x45\xc6\xe9\x9a\xb4\x15\xc8\x2b\xe6\x85\x85\x9a\x79\x55\xa7\x1c\x9d\xfb\x95\x00\x53\x9c\x35\xab\x1a\xd4\x35\xb3\x85\x5b\x84\xdc\x86\xa9\x71\x5a\x11\x7a\x02\xc7\x22\xcc\xc3\x95\xdf\x13\x9a\x55\x98\xd8\x0d\x2c\x98\xfa\xe8\x13\x4a\x2a\xb6\x36\xb6\x6d\xeb\x7b\x15\x51\xd4\xec\x53\x71\xb9\xf1\xd1\xdc\x2f\x11\x96\x0f\xe6\x0b\xe6\xeb\x23\x77\x7f\x35\xc8\xf9\x29\x5f\x02\x51\x7c\xb3\x5d\x5c\x95\x5f\x54\xca\xd7\xa7\xe8\xf9\xe8\x59\xb5\xa4\x67\x2e\x3a\x30\x14\x1d\x96\x45\x4f\x51\x33\xf3\x71\x91\xc7\x46\x9c\x33\x19\x15\x24\x5d\x95\x93\xc5\xfe\xb3\x2c\xb7\xa0\xa8\xa3\xa8\x2a\x3b\x35\x36\x29\xce\xd4\x7a\x9b\xd3\xae\x36\xab\x65\x55\xe1\xb0\x13\x32\x1f\x2a\x4d\x0e\xc3\xca\x54\x6b\x19\xff\x51\x6d\x40\xf5\x65\x22\xb5\x70\x67\x52\x6b\x11\x77\x82\xb9\x5a\xea\x3f\xf0\xba\xad\x8f\x6b\xf5\xb6\x9b\xa0\x52\x8c\x15\x7a\x5f\x85\xd3\xb6\x01\x4e\xf5\x82\xaa\xa4\x6f\x68\x4e\xc2\xb2\xd6\x9e\x6f\x6e\xaf\x5a\x52\x15\x7d\xd6\x09\xf5\x77\x55\xe0\x3e\xab\x40\xbd\x9a\x71\xda\x09\xbc\x6a\xa9\xfd\xce\x4e\x16\xbe\x6a\x4e\x77\xb4\x5f\xe9\xa8\x99\x19\x77\x76\xd6\x2c\x59\x0a\x0e\x25\x19\x12\x99\x9c\xb0\xfd\x6d\xbc\x65\x6d\x1f\x5a\x8e\xf5\xfa\x50\x1d\xdf\xaf\xfb\x8a\xfa\x0b\xcb\xb1\x96\x0b\xcd\x7c\x74\x4e\x63\xb7\x32\xd9\xa3\xce\x52\xaf\x2b\xa5\x0e\xea\xf4\xe5\x7e\xb5\xdc\xf3\x4a\xb9\x1f\x8b\x72\x44\x26\x7c\xad\x34\x7f\xe2\x4b\x93\x61\x99\xe3\x34\xb3\x1c\xab\x6d\x98\x6c\x49\xf5\x3a\xdf\x3d\x4c\x90\xf5\x23\xba\xba\xf9\x74\xb3\xb8\xf1\x16\x37\xc3\xc5\xcd\xe3\x9b\xff\x7c\x7c\x33\xbd\xf9\xcf\xe9\x4d\x78\x33\x0c\x6f\x86\xff\x11\xde\xe0\x9b\xff\xc0\x37\xdb\x37\xff\xb9\x7d\xe3\xdf\xfc\xa7\x7f\xf3\xec\x66\xf8\xec\xe6\xf4\x66\xff\x66\xb8\x7f\x13\xdf\x2c\x6f\x5e\xdf\x1c\xde\x1c\xdd\xfc\x78\x73\x70\xf3\xf5\xc6\xf9\x6a\x5b\x36\x5c\xf4\xd1\xdf\x99\x8f\x92\x82\x13\x10\x56\xa9\x4f\x12\x38\xf6\xc1\x47\x57\xf2\x4a\x15\xa1\xc0\x07\x32\xa4\xc2\x71\xa9\x08\xdf\x76\x6a\x12\x93\x14\x2d\x5c\xf0\x6a\x33\x9f\x2f\x98\x0a\xf7\x76\xb4\xba\xfc\x58\x97\xbd\xf4\x5d\x14\xa1\x53\x1f\x42\x1f\xac\x1f\x3f\x0d\x7f\x5c\x0c\x7f\x0c\x8f\x7f\x54\x6c\xc3\xe8\xc7\x83\x1f\x9d\xaf\xc2\x30\xbb\xa7\x88\xd1\x90\x56\xbf\x92\x5b\x96\x08\xca\x68\x1d\xcd\x49\x16\x87\x03\xe5\x59\x54\x78\x15\x15\xce\xdd\x9f\x31\xb8\x42\xd6\x07\x4a\x92\x93\xc1\xfe\xd1\xab\x5f\x1f\x8e\x27\x03\xc9\x04\x89\x6e\xdf\x19\xe3\x70\x1f\xa1\x50\xc9\xbb\x82\x48\xbb\x76\x78\x6c\x3c\x15\xd3\x08\x2d\x23\xf4\x58\x16\x82\x6d\x63\x19\x1f\x1d\xa9\xc9\xa9\x39\x59\xfc\xf6\x2e\x9a\x7f\xb9\xa2\x82\x82\x46\x59\xe1\x6d\xc7\xd9\xac\x4f\xf5\x97\x42\xf2\x50\xb1\x6e\x1b\x58\xb0\xed\xab\xe1\xed\xad\x31\x85\x43\xdf\x5d\xfd\x14\xad\x5d\xf0\xfc\xfc\xf3\xc3\xdf\x36\x1f\xe2\xfb\x6b\xbe\x89\x87\xa2\x9a\x30\x3d\x58\xb3\x86\xf2\x65\xf4\x70\xed\x0a\x52\xf9\xf0\x21\x7e\xb0\x66\xf9\x54\x94\x9f\xd4\xa7\x50\xe8\x1a\xc2\x8e\xef\x56\xfc\xc8\x0a\xef\xeb\x5d\x02\xa3\x9f\x68\x6e\x03\xf1\x20\xf2\x50\xd3\xf2\x58\x8b\x95\x8b\xd5\x2a\x5a\x7c\x95\x49\x63\x3f\xe9\x4f\xd6\x1b\xcb\x15\xb0\x6d\xbb\x74\x85\xdc\xab\x23\x42\xed\xdc\x46\x15\x17\xf4\xb6\x0d\x67\xbe\x6b\xe0\x5d\x6b\x01\x53\xb7\x0e\xd0\x94\xa2\xed\x04\xf9\x06\x2d\xbb\xaa\x9b\x39\x6f\x02\xc4\xa5\x20\xa3\x10\x42\x56\x8d\x12\x65\x00\xa6\x8c\xe3\x79\x2f\xb9\x19\x73\x7e\x37\xa8\x98\x88\x06\x50\xbd\xb3\x88\x22\x55\x24\x15\x3c\xae\x1c\x7f\xe3\xd1\x20\xb1\x2b\x56\x14\xb5\x85\x13\xeb\xf6\x18\x51\x0d\x30\xdb\x39\xcb\xe1\x49\x6d\xb9\xd4\xa7\x2b\xe1\x1c\xa1\x0f\x9d\x6b\x27\x84\x7d\x63\x01\xf5\x8f\x19\x87\xfa\x8e\x6f\xdb\xf0\x26\xb3\xe1\xa0\x63\xbf\x55\xc9\x4a\x98\x51\xf1\x2e\x5c\xa5\x2b\xcf\x33\x78\xe2\x0b\x53\x74\xd8\xf7\xdd\x7d\x5f\x38\xe9\xdf\xf7\x7f\xb7\x6e\x1c\xeb\x4f\x77\x8a\xe2\xa4\x4b\x92\x48\x11\xb3\x73\x7e\xc8\xf2\x85\x78\x65\x12\xc4\x45\x28\xd4\xfe\x3a\xb7\x22\x74\x2c\xdd\x7b\x3a\xac\x7d\x3d\xe0\xa5\xfc\x65\x74\xef\x7c\x62\xd9\x39\x3c\xe7\xc0\x49\x12\x03\x66\x5e\x56\x24\x8e\xca\x29\xa0\x52\xba\x09\x12\x89\x96\x0e\xa9\x79\x1e\xd8\x29\x68\x6d\x88\x03\x12\xe2\x01\xbf\x23\x0e\xac\xc6\xed\xa2\x28\xee\x0c\x2c\xe9\xf2\x40\x50\x98\xe3\xc4\x86\xd7\x7e\xbf\xcb\xf6\xb7\x01\xba\x5e\x60\x36\x27\xa1\xc3\x94\xd6\x42\xea\x50\xc8\x68\x5c\x2a\x2f\x48\xf3\x70\xe7\x71\x80\x88\x2d\x2e\xa9\x24\x63\xce\x19\x5c\x44\x6c\xbe\x43\x71\x88\x13\x16\xf9\x71\xea\xdc\x99\x08\xdd\xa5\xdd\xee\x4b\x22\x7a\xed\x83\xb5\xbb\x77\xb0\x77\xbc\x67\xd5\x43\x51\xc0\xcb\x40\x4a\x71\xdf\xf5\x1c\x79\xb2\xfe\xeb\x57\x47\xc7\xcd\xda\xea\x0c\x7c\xbf\xa2\xeb\xa7\x7b\xad\x9a\xba\xdf\x0f\x46\xf4\x7b\xc5\x50\x84\xbc\x04\x22\x34\x4f\xc0\x92\xd6\xdf\x02\xac\x02\xdf\x9e\x99\x70\xc6\xfc\xa6\x75\x2c\xa1\x56\x4a\x03\xe5\xef\x01\xbe\x0c\x30\x0e\x0b\xd1\xe7\x4b\xcc\x2e\x08\x3d\xdd\x13\x1d\x15\x62\x18\x99\xa8\x8c\xcf\xd5\x35\xc8\x0f\x8f\x98\xcf\xb2\xd4\x32\xbc\x51\xf1\x9b\x61\x95\x0c\xe0\x51\x2a\xca\x8e\x38\x06\x35\xcf\xac\x22\x73\xa1\xd4\x32\x39\x2c\x90\x52\xc8\xb1\x8b\xde\x5e\xfb\x57\x31\xf1\x43\x83\xbf\x18\xeb\x5d\xe9\x3f\x40\x99\xe5\xe0\xc1\x8c\x92\xc5\xc0\x5f\x46\x05\x42\x76\x8b\x56\xac\x43\x3f\xe6\xfb\x19\x87\x03\x8e\x75\xba\x42\x9e\xc3\x17\xdf\x3d\x0c\x4c\xf1\x7f\x1a\x51\x72\xd4\x16\xda\x89\xd0\x33\x5f\x11\x77\xe7\x30\x92\x5f\xb9\x0d\x5f\x3b\x1f\x02\xb4\xc2\x71\xa1\xfb\xd2\x54\x38\xee\x51\x55\x56\xab\x8c\xab\xab\xac\x9b\xd1\x93\x3c\x8c\x10\x93\x8e\x85\xf5\xd5\x41\x29\xc2\xe8\x02\x4f\xd4\xfb\xa3\x56\x9a\xd1\xe9\x67\x51\x13\x5e\x3b\x91\x6c\x48\xe8\x02\x3d\xf5\x5d\xec\x21\xe1\x24\xdf\x86\x37\x46\xcc\x3d\xad\xc5\xfb\xaf\x47\x46\xf1\x44\xb4\x94\x23\xe9\xf8\xe8\x93\xf1\x14\x8b\xd0\x7e\x06\x97\x14\x59\x56\x49\xaa\x0d\x81\x02\x0a\xb2\x5f\x3f\x01\x3a\x36\x61\xdd\xc7\x90\x9c\x48\x67\xac\xca\x32\x8e\xcb\x1f\x96\xdd\x5d\xf8\xce\xd8\x18\xc0\x22\x42\xd8\x83\xd8\x14\x4e\xe6\x4e\x71\xa0\x97\x5e\xed\xeb\x3d\xb5\x15\xc2\xf8\x66\x7f\xc1\x89\xfa\xf7\xc4\xa8\x61\xb2\xf1\xcf\xbe\xc1\xd3\x0a\x35\xea\x83\x07\x6d\x6f\xb1\x96\x1f\x63\xca\x12\x7f\x81\xad\xe6\x30\x9d\x08\x7d\x04\xe3\x52\x76\x72\x36\xda\x49\xdb\xdf\xc6\xfc\x54\x86\x6d\x2a\xc4\x6d\xca\xa5\x35\x58\x80\x15\xa3\xf4\xd1\x88\x62\x6f\x10\xb3\xb7\x0e\x38\x8a\x68\x4b\x92\xb5\xc7\x6a\x0b\x5d\x76\xe9\x5e\x01\x2c\x49\x4d\x7f\x30\x53\xd3\x42\xe2\x2d\x35\xcf\xdb\x9e\xb2\xcf\x1c\x96\x03\x4b\x4d\x58\xbc\x8f\x8c\xda\xee\x6b\xa2\x27\xd4\xce\x77\xd7\xb2\xe1\x28\x10\xa2\x4c\x3b\x07\x9a\x9a\x56\x51\xd8\xd7\x32\x06\x27\x88\xa5\x4d\x8d\x58\x23\x4f\x2c\x55\xda\x24\xb7\x7e\x80\xce\x29\x3a\x15\xae\x75\xee\x4c\x38\x59\x9e\x93\x8b\x23\x55\x40\x9e\xe7\x6b\xaa\xc3\x2a\xc5\xb8\xce\x46\x0b\xd5\xb9\x5b\xb4\x3a\x8b\x62\xa6\xbc\x5c\xfe\xc0\x4f\x07\x86\x2f\xd9\xda\x66\x4e\x38\xc0\xd1\x79\xb5\xb6\x4e\x59\xb7\x05\x69\x78\x28\x0d\x1c\xc4\xb7\xf1\x0e\xd1\x78\xca\xfd\x82\x12\x5b\xba\xa9\x5b\x7f\xc5\x2d\xe1\x41\xe9\x52\x3a\x74\x4f\x6c\xdb\xb1\xac\x1c\x70\xea\x5e\x8b\xe8\x0e\x67\x20\x3a\x77\xce\x40\x4f\xc0\x39\x83\xea\x32\xa9\x9f\xa5\x6e\xe2\x59\x0e\x49\xda\xcb\x80\xc9\x96\x99\x6a\x99\x96\x2d\xe3\x7a\xcb\x49\xa3\x65\xa1\x49\x4a\xd2\x4e\x66\xe9\xfa\x14\x5f\x39\x0c\xc8\xb2\xa6\x46\x0a\x41\x5a\xd8\xe3\xe1\x13\x7c\x79\xe8\xb3\x60\x6e\xe5\x90\x15\xc9\x7b\x67\x56\x0e\x5e\xba\xc6\xd5\xd4\xfd\x2f\xb1\x22\x41\xba\xe6\x22\xde\xf9\xaf\x2a\x19\x78\x49\x58\x75\x04\x6b\xb6\xe1\x8a\x26\xb2\xb5\xbb\x74\x1b\x5d\xf2\xd9\x99\x70\x07\x22\xe3\x7e\x6e\x33\xfa\x78\x74\x8a\xaf\x6a\x82\x7f\xe1\xe7\x2e\x42\xfb\xb0\x9d\xc0\x27\x74\x7b\x1a\x5c\xdc\x2e\x01\x8f\xc8\x12\x1e\x27\x92\x06\x7b\xa9\x2d\x2f\xa7\xba\xa7\x7f\xb7\xfe\xbd\x76\x91\x13\x8b\xca\x53\xe5\x2e\xf6\xfb\x26\x50\x44\x4a\x10\x27\x8a\x65\x39\xd5\x09\xac\xbd\x37\xae\xf5\xde\x00\x71\x01\xf9\x0c\x51\x0a\x98\x0f\xd2\xca\xf9\xad\x27\x4d\x5d\x33\x43\x50\xe7\x0d\x48\x6a\x83\x8f\x8e\x3c\x78\xe3\xf3\xff\x3f\x4f\x6c\xfb\x1b\x6f\xf2\xcf\xca\x9b\xbc\x80\x96\xd9\xbe\xc7\x74\x49\xad\xb7\x76\x2c\x84\x02\x87\xd2\xb5\x28\x7c\x12\x32\x9c\x4a\x4a\xae\xae\xfd\x12\xd4\x30\x4b\xbb\x6f\xbe\xc7\x7c\xc1\x1e\x7b\xf0\xc2\x87\x34\x55\xf7\xda\x38\xed\xbc\x58\x3c\xcf\x60\x96\xca\xc3\x2f\x34\xb5\xba\x6a\xd4\x2f\x7c\x9b\xf7\x23\xfe\xf2\xae\x96\xbd\x5d\x85\xaa\xab\x79\xea\x86\xc8\x4f\xe0\x20\x82\xd6\x2d\x55\x55\x09\x12\x71\x62\xd4\x6e\x4a\xbc\xea\x92\xa7\xf3\x9b\x50\x45\x45\xdb\x82\x45\x82\x8e\x13\x85\xad\x3c\x53\x6a\x6c\x17\xe9\xb2\xd6\x79\x33\x34\x96\x25\xaf\x1d\x06\x47\x43\xc5\xb1\xf8\xf8\xca\x94\x3b\x6e\x71\x13\xb9\xb8\xea\xf2\xee\xc3\xa4\x43\xf2\x70\xa7\x2a\xc6\x39\xfb\x86\x31\x15\xc7\xea\x2d\x07\xa5\x81\xa2\x75\xd4\x2d\x78\xee\xeb\xb4\x52\x59\xfd\xed\x81\x25\xa7\x70\xce\xf1\x80\xe7\x85\x3e\xf3\x2d\x39\xa3\x90\x99\x02\x3a\xf6\x0a\x35\x90\x7c\x38\xb5\xe1\x24\x41\x73\xb1\x37\x16\x69\xa7\x97\xe2\x4b\x29\xe3\xe8\xb6\xe6\x2a\x78\xea\xe2\xca\x26\x38\xbb\xd4\x02\x9a\x22\x6a\x72\xf0\xae\xb7\xed\x17\x1f\x45\xe8\xbd\x0f\x18\xce\x53\x39\x1e\x23\x8a\xea\x62\x55\x9a\x63\xdd\xd3\x47\x61\x6a\x69\x80\x49\xa0\x9c\xf0\xb5\x0b\x8d\x88\x1b\xa1\xfd\x08\x18\xec\x24\x52\x86\x2b\xd1\xd2\xce\x61\x6a\x64\x0f\x85\xb7\x79\x0a\xfb\x26\xf0\x76\xd1\xc5\x2a\x22\x81\x35\xf3\xe3\x14\x5b\x70\x2e\x19\x67\xde\xd3\x15\x5f\xc0\x5d\x0f\x92\x14\x22\x24\x02\x29\x6c\xfd\x5d\xec\xdd\xdb\x7d\xef\x7b\x48\x03\xd9\x86\x67\x1e\xd2\x0c\x98\x2d\x7f\x29\x4f\x0c\xf2\x47\xc1\x5f\xd9\x36\x4c\x53\x54\x72\x95\xea\x77\xc9\x11\x72\x44\x38\x56\x03\x34\xbd\xc4\xa3\x24\x05\x06\x67\xf2\x7f\xe2\x22\x50\x1f\x91\x6a\xb9\x35\x26\x1b\x2e\x78\xab\x45\xdc\x88\x66\xe1\xe7\x9e\x0d\xa7\xbd\x25\xaa\x59\xcf\x3d\x91\x8b\xc3\x88\x89\xb6\x8f\xba\x47\xdc\xa4\x52\x11\x7a\x02\xb1\xa2\x73\xab\x7b\x2b\xe6\x95\xe0\x8b\xd6\x94\x6c\xb8\xec\x40\x9a\xb5\x0f\xcc\x7f\xbb\xa7\xfb\xbc\x97\xe0\x8b\x2d\xd9\xb6\x6b\xf1\x6b\x84\x9f\xae\x3a\xf1\x7c\x44\x52\x21\x09\x81\x4c\xfc\x9d\xf0\x5b\x87\xc4\xe6\xc7\xa9\x2b\x26\x24\x89\x95\x0d\xdb\xa9\x7b\x2d\xdf\xfe\x69\x5a\xdd\x88\x30\xf5\x83\x53\x11\x02\xea\x35\xc5\x69\x8a\x43\xe7\xce\x04\x54\xc1\x63\xce\x76\x72\xee\xf6\x65\x6a\xf2\xe6\xad\x98\xc8\xa2\x55\xd6\x6e\x8b\xd6\x9a\xc2\x15\xf1\xf1\x4b\x42\x96\x56\x6e\xc3\x5b\xd3\x66\x57\x65\xde\x09\x47\x43\x87\x65\x0b\x85\x29\xd1\x5e\x4f\x2d\xd1\x77\x94\x9c\x3c\xd6\x83\x29\x6a\x1d\xb6\xe9\x5b\xad\xe6\x2e\x8e\x31\xc3\x4f\xc4\x12\xa8\x5e\xab\xf6\xd8\xb9\x0d\x3b\x2b\x5a\xd8\x0e\xc3\xbe\xea\x67\xa9\x7b\x1d\x47\x29\x73\x9e\x27\x30\x8b\x70\x1c\x2a\x08\xcb\x1f\xf5\x75\x51\x8a\x1a\xb5\xb4\x19\x09\x32\xb5\x44\x14\xa7\x59\xcc\xd2\x67\xe4\x1c\x53\x99\x62\x5e\xc8\xab\x29\x3e\xc2\xb1\x90\xbc\x89\x31\x09\xc1\x7c\xba\x96\xdb\x25\x31\x52\x56\x19\x28\xd5\xe3\xc4\xc5\xe8\x92\x76\xb7\xa4\x18\x66\xd0\x1c\x65\x66\x1a\x90\x67\xc0\x8a\x83\x95\x58\xf1\x44\x8f\xaa\x58\xdd\xfd\x9e\x3a\x6f\x6b\xe3\x28\xaa\xbc\xea\xa9\xf2\x84\x4f\xa2\x28\xf9\xfc\x9b\x10\xee\x75\x4f\x2d\x09\x84\xa2\xe8\xee\x9a\xb8\x89\xe3\xb0\x81\x54\xef\xd6\xc1\xc9\x76\xb5\xf7\xa9\x7b\x5d\x9c\x9e\xab\x31\xaf\x8a\xad\xa9\x5a\xbf\xb7\xf5\x1b\xee\xdb\xa2\x35\x13\x7e\xe6\xf0\x21\x5d\x69\xad\x50\x0e\x88\x15\xc3\xa0\x95\xce\x71\xbb\xef\xa4\xd1\x37\x69\x76\x1d\x18\xf0\xeb\x59\x71\x79\x7d\x1c\x67\x54\x57\x96\x60\xca\xe1\xcb\xed\x31\xe9\xeb\xfa\x2b\xfd\xb4\x0f\xe9\x04\xf1\x78\x7c\xf5\xb6\x14\x87\xc8\x4a\x6f\xca\xcb\x77\x18\xb1\x62\xb6\x56\x0e\x9f\x56\x6e\x95\x56\x63\x2f\x7a\xe7\xa7\x9a\x7e\x82\x39\xf8\xcb\x19\x7e\x5e\xbd\x7a\x92\x19\x11\x96\x92\xb2\x91\xc7\x3e\x75\xa8\x14\x5b\xf0\x4f\x0c\xf2\x78\xe3\xdf\x09\x30\x7f\xea\x10\xf0\x03\x16\x9d\xe3\xfd\x55\x66\x27\x47\x98\x1d\xfb\xd3\xd2\xee\xe4\x63\x2f\xbc\xd9\xb6\x68\xb5\x18\xfb\x0f\x3d\xa5\x8f\xc9\xc9\x49\x8c\xf7\x2b\x12\x31\x59\x87\xcd\x56\xd5\x39\x2a\x25\x73\xb2\x0a\xed\xa9\x72\x98\x9e\x3c\x21\xf4\xa9\x02\x45\x51\x05\xaf\xac\xf2\x44\x83\xac\xa8\x93\xac\xac\xf3\xb6\x84\x7f\x51\x8b\xcc\x8a\xb0\x97\x7c\x65\xb7\x25\xe3\x98\x43\xd0\xd3\x9a\x2c\xd4\xc4\x84\xac\x68\x49\x4c\x87\xaf\x4b\x0e\x5e\xd9\xbc\x18\xb0\x4c\xf5\x67\xae\xc6\x8a\x27\x51\x0d\x2d\xde\xa7\x25\x5e\x9c\xa5\x15\xc4\xd8\x4e\x05\x66\x78\xb3\x12\x35\xce\x72\x48\x67\x2b\xad\x11\xd5\x9a\xeb\x17\x31\x59\x5b\xab\x3c\xe1\xa4\xfa\x76\x62\x2d\xd5\xef\xa6\xaa\x10\xbe\x5c\x46\x7c\x5b\xe7\x39\xcc\x66\xae\x8f\xf6\x22\xb8\x33\x01\xcb\x02\xcb\xb2\x21\x9e\xb9\x6b\x9c\x9a\x51\xe8\x30\x08\x28\xf6\xc5\x3d\xd0\xa1\xa0\x82\xef\x72\xda\xa5\x6d\x90\x13\xc0\x49\x28\x8d\x91\xa5\x33\xc5\x70\x9b\x39\x01\x14\x9c\x54\x06\x92\x6f\x93\x67\x63\x68\x5c\x21\x5e\x02\x8b\xf5\x58\x16\xa0\xdf\xd3\xc3\x87\xf9\xcc\xe5\x23\xb1\xac\xca\x50\xf8\x0f\x35\x16\x4e\xc4\xf5\x60\xc6\x7a\x30\xe3\xca\x60\xc6\xd0\x64\x16\xb5\x63\xa4\x59\xcb\x83\x80\x1a\xab\x1a\xd1\x72\x96\xe7\x70\x5e\x0c\x49\x43\x3e\x87\x45\x91\xa6\x56\x2a\x87\x93\x99\x7b\xad\xd9\x5f\x8e\x20\x2d\x2c\x58\xcc\x04\x75\xdf\x21\xc9\x2c\xa2\x0b\x21\x4c\xd8\x15\xde\x10\x38\x4e\x4c\x67\x3d\x5c\x69\xd1\x2c\x13\x0d\xf1\x65\xc8\x12\xc5\x82\xf6\x44\x4d\xac\x54\x2b\x07\x43\x45\x13\xb8\x6b\x28\xc9\xad\x28\xd7\xd5\x37\xec\xf8\xe3\xfa\xde\x3d\xd2\xb7\x94\x1c\x2e\x7a\x5a\xd3\xc5\x44\x9d\xa2\xad\xd3\xd9\x2a\x46\x23\x65\x94\x5c\xa9\xca\x0d\xa6\xe1\x68\x45\x65\x05\x9d\xde\x36\x2e\xcb\x45\xe7\x6b\x5e\x92\x87\x0e\xf0\x72\xd6\xe1\xf1\x1a\x4b\xed\x30\xdd\x16\xed\x6a\x0a\xf7\xae\xd4\x5b\x2c\x5e\xaf\x8b\x95\xda\xfe\x0b\x26\xfb\xb2\x67\x7d\xf6\x93\x88\xa9\x5a\xef\x23\x7c\x51\xac\xd0\xdb\x55\x14\x59\x90\xdd\xf4\x35\xc5\xe7\xd5\x6a\x7b\xab\x51\xa1\x49\xc9\x0f\x4d\x55\x06\x3b\x14\x4d\x85\x58\xb3\x47\x95\x4f\x45\xc4\xd9\x99\x75\xfa\x41\x50\x41\x13\xe1\xdc\x8f\xa3\x50\x2c\xc2\x91\xa0\x0f\xfd\x0e\x26\xf6\x13\x51\xbe\x5c\x84\xb3\x02\xf5\xdf\x8b\x8c\x1c\x9e\xcc\xfa\xde\x00\x6b\x0a\x33\x67\x33\x67\x67\xa6\xde\xf8\xe1\xa0\x6b\x39\x4b\x97\xb6\x14\xae\x9b\xc3\x7d\x32\x43\x0c\x51\x15\x47\x52\xc6\x7f\xdc\x9f\xb5\x7d\x56\xbc\x32\x02\xbf\x0b\x06\xfb\x9c\x46\x3e\x5f\x77\x3c\x5d\x4d\xf0\xb1\xbc\xee\x03\x86\x74\x5c\xf1\x8a\x43\x80\x7f\xd9\xea\x91\x47\x24\xa8\xc0\x98\xda\x9d\x08\x1d\xa9\x2f\x7e\x15\xe9\x6b\x73\x10\xa1\x7d\x93\x94\x45\x9c\x95\x0c\xa8\x78\xfb\xd0\xcd\xd7\xbc\xcb\x14\x2a\x2f\x64\x59\x3d\xb6\xf7\xce\x0a\x8d\x86\x03\x11\x1a\x46\xa4\x56\xde\x7d\x2a\xb9\x6d\x15\x91\x33\xe1\xd7\x25\x87\x77\xb3\xfe\xb7\x99\xf7\xac\x3f\xe4\x73\x55\xa2\x49\xa5\x73\xcd\xf7\x0c\xf6\x22\x84\x35\x60\x6c\x38\x9c\x21\x2c\x00\xa9\x81\xb7\x5b\x04\xe4\xd5\xf8\x61\xe7\xf0\x9e\x9f\xbc\x0a\xaa\x77\x26\xa0\x97\x80\x33\x10\x05\xf8\x2d\xcb\xce\xe1\x83\xe1\x88\x56\x05\xf5\x31\xad\x7e\x16\x47\xb5\xfa\xad\xce\x6b\xf5\x4b\x2b\xbc\xe9\xdf\x26\x29\x4f\x0e\xcf\x66\xdd\x3a\x53\x05\xbe\x7d\x98\xc1\x75\xb5\xb3\x3d\x5f\x04\x41\x28\xfb\xe3\x09\x1b\xbf\x6c\xe2\x9f\xed\x7a\xbf\xea\x89\xeb\xcc\x47\x32\xd3\xae\xcf\x89\x55\x46\xf5\x06\xd1\x66\x34\xdf\xf7\x2d\x9e\xc2\x11\x4f\xe4\x66\xe1\x2d\xbc\x9e\xc1\xee\x4c\x0a\x6f\xa9\xdc\x91\x5f\x56\xef\x82\x08\x1d\xcc\xe0\x70\x06\xf5\xad\xa0\x10\xd5\xb8\x0d\xbe\xb6\xf7\x67\xa7\xc7\x3e\xa1\xb3\xc7\x27\x71\xe9\x23\x6a\x8b\xa0\xfe\x8a\x12\xe1\x8a\xd3\xc0\x22\x65\x52\x73\x7b\xae\x1c\xf2\xd5\x5f\xa6\xb5\xc3\xbe\x44\x07\xfa\xda\xf1\x93\x7f\x17\x24\x38\x4a\x06\x6c\x8e\x07\x4b\x3f\x65\x92\x10\x27\xb6\x8e\x2d\xc7\x5b\xca\x6d\x78\x6a\x04\x07\x60\x97\x8e\xf4\xea\x3e\x2a\xb9\x55\x3a\x8a\xc2\xca\x72\x95\x80\x2a\xd2\x4a\x84\xac\x64\xca\x94\x0a\x72\x8a\xbc\x4b\x1f\x70\x81\x30\x22\xe5\xeb\xac\x88\x5a\x0d\x74\x24\x73\x2a\xc8\x23\xca\x1c\xf8\x40\x47\x3a\xa9\x82\x2b\x11\xfa\x0c\x5f\x78\x6f\x3a\xc5\xe6\x57\xe1\xd5\xb3\x83\xc4\xd5\x5d\x75\x4f\x54\x90\x41\xc3\x1c\x65\x7a\x6b\x7a\x1d\xdb\x21\xe9\xdc\x09\xc9\x50\x3c\x7c\xd6\x26\xf3\xba\x39\x99\x4f\x6b\x2f\xd5\xe0\x15\x43\x31\xfa\xc0\xa0\xa6\x29\xd0\xb8\x82\x97\x5b\x79\x3e\x83\x72\xce\x6a\x66\xac\x1c\x0c\xae\x00\xa2\xe6\x1c\x49\x4d\x2e\x10\xfb\xea\xb0\x02\x0a\xbd\x86\x3e\xfa\x00\xef\x66\x9c\xf6\x55\x36\xac\x5d\x9d\x96\xaa\xa6\xdb\xd7\x15\x2f\xfd\x12\x11\x22\xf4\x75\x56\xbc\x4f\xeb\xa5\xaa\x10\xd1\x17\x33\xf7\x7a\x46\xe8\xc2\xf9\x30\xab\xf8\x74\xaa\x72\x8b\x39\x7c\xee\xe3\x09\x45\x65\x56\xa9\x4b\x75\x55\xa9\xe2\xb0\xca\xbf\xd4\x2d\x6f\x71\x05\x06\x54\x2f\x71\xbd\x7e\xbc\x94\x4f\x29\x45\x86\x0a\x02\xd4\xcf\xa1\x2a\x36\x6e\x47\x8c\xab\x22\x0c\x59\x93\xf3\x2b\xe5\x21\xdd\x87\x81\x16\x94\x61\xad\x56\xf2\x84\x92\x85\x92\x66\xa7\xdb\x49\x78\x1c\x2d\xaa\x3c\x2e\x78\x9b\x72\xcc\x2c\xee\x67\x96\xcd\x0d\x36\x0e\x5d\x1a\xf7\x88\xc6\x2a\x37\x9f\x52\x7c\xd2\x53\xa1\x87\x55\x4e\x62\xb7\x94\xdd\xf2\x1c\xdd\x6e\x0e\xa4\xc8\x92\x50\x2e\x73\x82\x9e\xbe\x2a\x32\xe9\x52\x4c\xb2\x02\x22\xb5\xd7\x0d\xb1\xfa\x0d\x68\x78\x3d\x1d\xbe\x97\xec\xa0\xae\xfe\x9e\xa3\x51\xd1\x73\x74\x9b\x9e\x2b\x55\x4b\xe6\x67\xfd\x9e\x5f\xfa\x8b\xb2\xe3\xf4\x36\x1d\x97\x35\x8b\x7e\x67\xb1\xdb\xe8\x65\x47\x6e\x3b\x2b\x87\x78\x25\xf8\x75\x59\x3d\x9a\xb0\xdd\x9a\xde\xd0\x56\x0e\xcb\xd5\xed\x15\xa5\x75\x8b\xf3\x56\x8b\x62\x3b\xe4\x70\xbe\xb2\xb1\x5d\x45\x21\x8a\xb6\x16\x2b\xab\xec\x09\xea\x52\x54\x38\x59\x59\xe1\xa8\xd0\x1f\x50\x55\xa6\x3d\x55\xe4\x83\x42\xed\x9d\x2a\xcf\xe1\xaa\x98\xe1\x76\x18\xea\xcc\x1c\x8e\x63\xa3\x91\x9b\x6e\x90\x5f\x84\x4f\x1c\x06\xd9\x52\x98\xa7\x53\x38\xc7\x34\x8d\x48\xb2\x9f\xcc\x08\x3f\x6a\xe2\x2c\x65\x98\x4a\x65\x74\x29\x2e\xb9\x88\xdd\x15\xc2\xe4\x29\xf5\x93\x60\xee\x30\x98\x66\x51\x1c\x0a\x5b\x78\x2a\xbf\xdf\xa5\x42\xf5\xed\x84\xbc\x97\xbd\x38\x09\xf0\x5d\x2c\x3e\x89\xee\x5a\xca\x93\x4f\xe3\x6e\x42\xa7\x28\xb0\x92\x5e\x51\x58\x62\x71\x30\x0a\x31\x47\x27\x1e\xab\x4a\x7e\x18\x52\x9c\x2a\x6f\x89\x97\xb1\x7b\x2d\x5b\x11\xf3\xe5\x67\xd3\xe3\xb8\x7a\x45\x94\x13\x17\x77\xfc\x1c\xb6\x7b\xd6\x84\x13\x49\xad\x5d\x22\xd7\xe3\xa5\xa9\xb4\xc9\x1c\xde\xa0\xc4\x5a\x24\x25\xed\x24\xd2\x4e\x0a\xda\x49\x59\x3b\xc9\x6b\x27\x45\xed\x24\xbf\x9d\x94\xb6\x93\x66\xed\xa4\xb8\x29\xd5\x39\x90\x8f\x90\x69\x29\x27\x29\xdd\x3c\x3e\xe1\x87\x3c\x96\x07\xbb\x28\x97\x00\x25\xd2\x5d\x99\x14\xde\x39\x81\x5e\xde\x0c\xa6\x7e\x8a\x5f\xfb\x6c\xee\x78\xe0\x2f\xa3\x77\x34\x76\x22\x88\xa3\x29\xff\xf0\xa1\x08\x6b\xb0\x73\x74\xe4\xa4\x30\x23\x09\xdb\xbe\xc0\x29\x59\x60\x9e\x30\x03\x75\xeb\x14\x14\x81\x50\x27\xae\x07\x23\x83\xb7\x3d\x6b\x7a\x84\xd9\x6e\xad\x76\x29\xb0\xe9\x3b\xed\x6a\x23\x38\x20\x7e\x58\x15\xdb\xf4\x54\x7c\x5c\x99\x49\xa3\xda\x4e\x5c\xea\x75\x86\x11\xc5\x01\x2b\x1e\x01\xce\x8a\xac\x97\xfe\x79\x74\xc2\x09\x1b\x51\x98\x98\xc3\x93\x3e\x8c\x2d\x8b\x97\xeb\x55\xf4\x78\x70\x9b\x9a\x7c\x35\x5f\x56\x0e\xe9\xfd\xdb\x56\xde\x0b\xa3\xb2\xeb\x57\xb7\xa9\x5d\x13\xbf\x3d\x37\xc0\xe2\x25\x61\x4f\x48\x26\xdc\x98\xbd\x5e\xab\x61\x05\xd9\xe2\x75\xb7\xa7\x92\x14\xfa\x36\xf6\xfd\xbb\xd5\x15\x0c\xf0\x7e\xbf\x6e\x2d\x0e\xae\xa2\xd6\x87\x75\x6b\xd5\xc0\xf4\x6c\x65\xad\x6d\xbd\x2f\x8b\x3a\x5f\xe2\x4a\x5c\x8f\x03\x7c\x8e\xe3\xb7\x44\x3a\x8d\xfb\x5a\xe4\x48\x40\xe8\xf4\xa7\x7d\x3b\xab\x1c\x95\x2c\x5e\x3c\x96\xae\xae\xc4\x87\x55\xaf\xf4\x69\x75\x25\x85\xa1\xf5\x7a\x2f\xd6\xab\x27\x9e\x6d\x6b\x15\x3f\x97\x78\xa6\xb0\x4b\x4f\xfa\xe3\x2a\xae\x36\xad\xb7\xf4\x83\xf1\x90\x38\xf0\xcc\x3a\x6b\xc4\x28\x58\x61\x23\x6f\x2c\xec\x37\x99\x9d\xdb\x79\xcb\x88\x67\xd7\x83\x37\x31\x1c\xa7\x46\x33\x9a\x5d\x0f\xbe\xc6\xf0\xb8\x33\xf3\x53\x0c\x47\x9d\x99\x4f\x63\xb8\xe8\xcc\x7c\x11\xc3\x69\x67\xe6\xc7\x18\xae\x3a\x33\xbf\xc4\xf0\xce\xeb\x88\x6c\x67\x03\x0b\x8d\x2e\xd5\x5e\x56\xa3\x46\xff\xf1\xc7\x96\x65\x03\x1b\xcd\xfd\x74\x2e\x7c\xab\x95\xa2\x4c\xe9\xd9\xed\x53\xe9\x6b\xad\x19\x15\x84\x43\xd3\xb1\xac\x1c\xd9\x90\xb4\xdc\x7e\xe2\x33\xf4\x05\x51\x1b\x36\xed\x4a\x4b\xac\x1a\xf9\xb8\x15\x63\xa4\x50\xaa\xdc\xb2\x40\x44\x0a\xe1\x8d\xab\xc2\xa2\x17\xe1\xea\xc5\x83\x1f\x62\x28\x24\x00\x0c\xae\x53\xec\xd3\x60\xee\x24\xc0\xe7\xe0\xe0\xbc\xdd\x03\x91\x3d\x10\x3e\xde\xcf\x71\x0e\x34\x34\x9b\xc0\x4f\xe1\x7d\x53\x0f\x76\xce\xd8\xd2\xb9\x77\xcf\xa4\xe9\xaa\x23\x0b\xb5\x15\x5e\x21\x42\x53\x58\xca\xb0\xd0\x80\xc3\x16\x9b\xc5\x9c\x19\xa1\xe8\xd1\xa3\xc2\xf2\xf9\x51\x19\x98\x1c\xd7\x62\x7d\xd3\x47\x85\xf4\xac\x70\xc9\x13\xcd\x10\x0d\x51\xa2\xe0\x1a\xb8\xf4\x51\x33\x06\xbc\x0c\xc8\xae\x6c\x02\x83\x32\x82\x3b\x73\x09\xd0\x86\x41\x83\x10\xad\xb5\x67\xf7\x9a\x55\x8c\x6f\x03\x1d\xf8\x78\x60\x49\x1d\xd7\x60\xe4\x4d\xf2\xfc\x51\x40\x12\x16\x25\x19\x1e\xb0\xfc\x76\x4d\x4b\x6f\x37\xe2\x3e\xb4\x76\x23\x34\xcf\x71\x9c\x62\x31\xe9\xac\x9c\xf4\x1d\xd7\xcd\xe4\xf4\x4c\xb5\x5f\x97\xb5\x1f\x89\xda\x15\xc0\x64\xfd\x80\xa9\x41\x20\x53\x10\xa8\x5b\x8c\x26\xca\x7a\x3c\xe3\xe0\x58\x35\x91\x5a\x7b\xaa\xb6\x9a\x97\xd8\xad\x89\x11\x29\x29\xaf\x85\x43\x38\xa1\x88\xd9\xf5\x18\x65\x39\x10\xd3\x06\x7f\x4b\x51\x5f\x4c\x03\xe6\x44\x68\x8f\xc2\x15\x13\x2f\x46\x22\x86\x81\xfc\x98\xd8\x39\x04\xc6\x31\x74\xc5\x1c\xe2\x44\x7a\x20\xfe\x1d\x5e\xf8\x34\xe1\xfd\xac\x11\x03\x88\x84\xc2\xac\xa0\x1d\x9d\x22\x0b\xdd\x95\xd1\xf9\x1e\x9b\x06\x32\xf3\x07\x33\x7f\x18\x90\x13\xfe\x27\x5d\x46\x09\xff\x7b\xff\x92\xff\x3b\xbb\x7d\x50\xa4\x6a\x60\xb8\x4a\x27\x29\x1d\x92\x24\x5e\x1d\xfc\x23\x22\x48\x1b\xb1\x8e\x46\xa3\xfe\x38\x81\x45\x70\x86\xb0\x5b\xc8\x37\x88\xd0\x81\x61\x3c\x15\x54\xba\x18\x4e\xc6\xe3\x81\x05\xd4\x64\xfe\xf9\x86\x20\x53\xd0\x8d\x59\x50\x8f\xe0\xaa\x15\xf5\xab\xa0\xe9\xd5\x21\x18\x44\xe8\xa2\x7f\x58\x16\x60\xd3\x80\x5e\x34\x82\x11\x96\x91\x4d\x92\x9e\x01\xf5\x22\x40\xad\x53\x03\x6e\xf5\x47\x3a\x5c\x35\x4d\x13\xee\x57\x7a\x0c\x87\xb3\x18\x5f\x0e\xf8\x3f\xc3\x80\xc4\xd9\x22\x19\x34\x67\x6e\x8e\x63\xf1\xa4\x1f\xd3\x4f\x57\xc4\xa1\x6c\x87\x6b\x58\x2f\x24\xe5\xab\xe6\x74\xde\x98\x17\x64\x66\x5c\x90\x5e\x50\xfe\x5f\x07\xcb\xd6\xc6\xfc\x8b\x61\xd9\x25\x3c\x92\x47\x60\x30\x6a\x3c\x97\x6b\x4b\xfc\xac\xfa\xf2\x2c\x15\x0a\x9c\xef\x58\x82\x32\xe2\xe5\x60\xee\xa7\xc3\x54\x9a\xf6\xff\x73\x56\xa6\x1d\xe3\x64\xbd\x95\x69\x5a\x60\xbf\x21\x28\xd0\xcf\x32\x2b\x97\x47\x47\x5c\x09\x8c\x91\xac\x8b\x20\xa0\xfc\xbc\xa7\x24\x1e\x54\x7f\x68\xe8\x18\x02\x46\xae\x5c\x70\xb3\x63\x84\xef\x5c\xb1\xff\x5d\x25\xb9\x30\xdf\xb4\x20\x2d\x4f\x1d\xdf\xbd\x79\x42\x3f\x39\xc1\xf4\x7f\x57\xc5\xb8\x77\x24\x70\x6e\xb5\x52\xfd\x51\xa1\x6a\xad\xcf\x30\x0e\xa7\x7e\x70\xba\x0e\x07\x97\x19\xe3\x54\xb6\xc7\x25\x9d\x90\x44\x61\xb7\xd6\x49\x75\x15\xab\x23\x7b\x38\x08\xa3\xe9\x60\x31\xdd\x1c\x2c\xe8\xe6\x40\x21\x8e\x1f\x47\x27\x89\x08\xe3\x9c\x0e\x03\x9c\xac\x13\xd7\xce\x70\x08\x3d\x25\xc8\x0a\xe6\x38\x38\x9d\x92\x4b\x53\x10\xb9\x1f\xcc\x87\x54\xba\x06\x4b\xb8\x36\xb7\xbc\x8c\x87\x9b\xeb\x00\xba\x7e\x23\x32\xdd\x0b\x8c\x07\xa3\xdf\x0b\x71\x13\x63\x6a\x62\x82\x97\xc6\x19\xdf\x96\xe5\x94\xb7\x8f\xfb\x2d\x06\x7c\x3d\xd6\x33\xed\xb8\x71\x99\x2d\xe2\x4a\x8d\x1b\x5a\x51\xae\x69\xfa\x3c\x6a\xcd\xff\x05\x41\xa6\xbd\xfb\x99\x20\xcb\x9b\xc6\x7e\x62\xd8\x13\x86\xb5\x6a\xc3\xaa\x50\xc9\x89\x88\xd6\x3f\x4c\x42\xa9\xb3\x34\x6b\x4b\x3d\xb4\xac\xa3\x7d\x35\xc5\x5a\x02\x64\xc4\xa5\x29\x4b\x06\x53\x96\x0c\xd3\xc5\x60\x7a\x32\x9c\xf9\x21\x0e\xe5\x6f\x11\x29\xc2\xa7\x57\x83\x05\x1d\x6e\x0e\x16\xd3\x06\xca\xa9\x26\xd6\x0a\x74\x97\xa5\x98\x0e\x53\x6d\xc2\x32\x71\x2c\x86\x2f\x8d\x01\xee\x4d\x95\x87\x0b\xf2\x75\xf8\x7d\x2d\x5c\xe0\xe9\x69\xc4\xd6\x68\x44\x13\x9e\x35\xd6\xcb\x40\xff\x9d\x8e\x80\x93\xdf\x09\x62\xbe\x91\x8c\xd1\x10\x5b\x7b\xc9\xb8\xc0\x7c\x92\xc3\x45\x26\xec\x72\x57\x93\x8c\x75\x8e\xb5\xdc\x86\x38\xec\x79\xcc\x1d\x44\xe8\xca\x34\x92\xc4\x3f\x6f\x47\xd1\x37\x8d\xa3\xb0\x7d\xee\x42\x5a\xde\x52\x1c\x25\xa7\x03\x65\xa1\xd1\x6e\x30\xe1\xab\x61\x22\x55\x45\xdd\x2e\x50\x9b\xe4\x27\xbc\x3d\x13\x18\xc2\xb0\x2b\x14\x89\x8f\xde\xf5\x6b\x8b\x1a\x82\xf5\xe6\x85\x43\xd6\x65\x4f\xbb\x35\xa7\x87\x55\xa8\xfb\xe8\x1c\x03\xe5\x84\xc4\x20\xb3\x3f\xa8\x7a\x5a\xd0\x7b\xb7\x05\x35\x11\x3f\xf7\x36\x3a\xae\xc2\x89\xac\x50\xb7\x4a\x44\x2c\x60\x2c\xc7\x3f\x37\x89\xce\x98\x56\x8c\xdc\xb2\xdc\xff\xb2\x1c\xcb\xb5\x4a\xa2\x7a\x49\x81\x36\x3d\x03\x08\x2d\xcb\xf6\x1a\x9d\x22\xd6\xe6\x97\x8a\x88\x8a\xe7\x1d\x14\x5f\x79\x80\xe2\xa4\x7f\x1e\x4a\xd1\xf1\xa2\x76\xcc\x35\x31\x38\x6c\x68\xfb\x26\x15\xfd\x38\x11\xc2\x95\xd9\x5b\x18\x25\xb6\x93\xe4\xb6\x9c\xfc\x49\xbf\x9c\xa9\x72\xe6\x94\xc9\x0c\x61\x7b\x8b\x3a\x38\x97\x70\x8b\xd0\x33\xd3\xc3\xca\x15\x3a\x90\x74\xff\xcc\xb6\x61\xda\xa6\xfd\x75\x79\x37\x7d\x74\x5d\x4a\x6f\xeb\x02\xef\xb3\x52\xe0\x2d\x24\xdd\x32\xbc\xcb\xc8\x1b\x73\x88\xa8\x32\x9f\x50\x62\x3f\x62\x2e\x03\xea\x26\x82\x16\x5e\x75\x80\xd4\x0b\xc0\x3a\xc5\x57\xd9\x52\xf9\x8f\x60\x90\x04\xc2\x1b\x42\x7f\xf9\x90\x5c\x24\x8d\x1a\x17\xa1\x7b\x5d\xd8\x00\x3b\xbf\x82\x60\xce\x9c\xc9\x7d\xc8\x96\xce\xfd\x5f\x81\xd7\x70\x1e\x8c\x73\x38\xbd\x8d\x00\x35\x20\xf1\x20\x20\xf1\xd0\xcf\x18\xf9\xd6\xc0\xa7\x9c\x4a\xcb\xeb\x85\x99\x42\x9b\x9b\xea\x3d\x04\x48\xc6\xe2\x28\xc1\xc3\x28\x99\x91\x0e\x12\x14\xa1\xc3\x14\xee\x8c\x4d\x0c\x9b\x89\xc9\x4b\x8d\x12\x5f\x13\x33\xb9\xd6\xc0\x0c\xf7\x84\xe6\xd0\x26\x6b\x0e\xcd\xfa\xff\xfe\xdf\x35\x45\xb4\x2d\x71\xf5\x51\x27\xe7\x76\x1a\x8a\x98\x05\x97\x1d\x38\x93\xc3\x63\x23\xf1\x11\xfa\xb0\x5a\xb1\x52\x28\xf7\x56\xdc\x0a\x00\xe9\x8c\xfb\xc0\xe0\x32\x1c\x15\x1d\xd9\x5b\x7b\x29\xba\x33\xb1\x9d\x97\x69\x0e\x81\x7b\x12\x72\x02\x98\xb9\xcb\x54\xdc\xd3\xaa\xcf\x74\xd5\x36\x12\xe1\xd4\xda\xb2\x9c\xe2\xcd\x2c\x53\x2e\x92\x2a\x22\x1f\xcb\xb1\xca\x3b\xac\x78\x90\xab\x3b\xaa\xd3\xdb\x55\x0c\x48\xcc\xb6\xd8\xb2\x9c\xb4\xbf\x4c\x05\xf5\xde\x49\xd1\x9d\xb1\x0d\x99\x6d\x3f\xaa\x55\x28\x67\x50\xb6\x24\x86\xd5\xa3\x91\x4e\x47\x4d\xc3\x7c\xf1\x3a\x65\x0a\x74\x8f\x95\x7e\xfa\x9d\x89\xd2\x57\xaf\xc4\xb7\x2f\x03\xcb\x6b\xc4\x56\xda\xea\x02\x8a\x6a\x0a\x7b\x62\xdc\xfa\x17\x87\x6e\xea\x0a\x7c\x33\xcc\xcc\x86\x99\x2b\x5d\x13\xc3\x59\x3d\x50\x75\x1b\xbb\x29\xb9\x18\x24\x64\x78\x92\x31\x86\x69\x5a\xbb\x03\x0a\x25\x5c\xc3\x76\x2e\x6f\x1f\x47\x62\x79\xd7\xa1\x14\x95\x1b\x0b\xa7\x3b\x16\x78\x26\xe9\xfc\x5a\xcc\xf2\x22\x4a\x86\x17\x51\xc8\xa4\xa7\x6c\x6b\x73\x3c\x5e\x5e\xfe\x75\xe1\xa0\xa3\x64\x99\xb1\xa1\xf2\xeb\x72\xfb\xdb\xef\x33\xa2\x7d\x97\x0c\xa7\x3e\x1d\xaa\x2d\x64\x22\x16\xbd\x22\xa2\x52\xf6\x61\x12\x6f\x1c\x87\xc8\x37\x24\x5f\x85\x46\xa9\xc7\x2c\x40\x6f\x53\xf3\x2b\xfd\xb7\xdd\xae\x2b\x20\x1a\x4e\x59\xf2\xbd\x04\x7f\x49\xa3\x85\x4f\xaf\x4c\xf3\x67\x01\x9a\x99\x64\x05\xab\x5f\x6a\x08\xb2\x36\xd6\x20\xad\xfd\xb4\xb6\x18\xff\x51\xa7\x78\x87\x5f\x1e\x06\xb7\xbb\x41\x58\x3b\x59\xca\xc8\x62\xa0\x70\x03\x06\x78\x74\x32\x32\xcd\x7e\x05\xdc\x04\x7f\xaf\xae\x4d\x72\xdb\x4e\xfd\x14\xf3\x23\xaa\xe3\x6c\x7a\x9b\xa2\x7f\xc7\xc9\xb9\x6b\x2d\x29\x09\x33\x41\x37\xad\x7f\x5f\xeb\x9c\x32\x54\xfb\x86\x53\xcb\x00\x7e\x3b\x87\xed\x8e\x83\xcc\x78\x37\x31\x31\x09\x83\x29\xa1\x21\xa6\xc3\xb1\x69\xda\x2f\x6a\xa4\xa7\xe2\x08\xc8\x28\xee\x31\xad\x96\x50\xc8\x32\x9d\xc0\x2f\xdb\x7c\x66\x61\x32\xaf\x5c\x39\x0b\x6b\xed\x9a\x21\x9e\x32\x1e\x77\x4a\xc9\x85\x65\xe9\x98\x2e\x35\xdb\xfa\xc1\xad\xb8\x91\x5e\x18\x2c\x03\xf4\x2e\x46\x11\x3a\x9a\x09\x8f\x48\xeb\x4d\x5b\x8e\xd4\x30\xf1\xb6\x58\xfa\xbf\x75\x9c\x52\xc5\xda\xb4\x40\xb9\x0d\x6f\x4d\x9c\x4e\x53\xba\xd5\x7d\xeb\x2c\x2e\x58\xea\x42\x95\xe7\xc0\x4a\x13\x1c\x21\x0e\xd3\x0b\x2a\x14\x89\xda\xab\xfe\xd7\x63\xf3\xa5\xd9\xd3\x9b\x01\x32\x6f\xb1\xb4\xad\x31\xad\x61\xaf\xcb\xb9\xca\x36\x31\x28\x1e\xb1\x51\x14\xb6\x53\xa5\x97\x30\x83\xa4\xa8\x47\x2e\xf8\xad\x20\x58\x43\x6a\xca\x11\x58\xb8\x2d\x33\xec\xdb\xbd\xfe\xbb\x77\x90\x3a\x59\x0a\xd8\x7d\x17\xa3\x2b\x61\x6a\x26\xf8\x79\xe9\xc6\x55\x22\x44\xc5\x97\xab\x46\x0c\xdb\xae\x4c\x74\x16\xc2\x01\x1f\xe4\x5c\x09\x23\x0f\xdb\x84\xa2\x28\xbb\x42\x22\xa5\x08\x7b\x8a\xe3\x99\x12\xc9\x8b\x8b\xd6\xed\x64\xdb\xac\xa1\x37\x54\xfe\xda\x16\x01\x58\x2b\xb9\x30\xb0\xe0\x25\x4f\x14\xff\x99\x24\x3a\x3b\x5d\x93\xb9\x0e\x62\x92\xe2\x43\xe9\xbc\xde\x39\xe0\x5b\xf9\x78\x66\xdb\xc0\xd9\x1b\x3f\x4a\x30\xdd\x89\xfd\x34\x75\xce\x54\x70\x03\xe1\x76\x7a\xb9\xe2\x0d\x49\x6d\xaf\x81\x36\x10\x32\x1c\x20\x32\x36\xc2\x01\xe2\xa5\xb7\x29\x1e\x5c\x91\x6c\x90\x66\xea\xe3\xc2\x4f\xd8\x80\x91\x81\x74\x39\x32\x60\xf3\x28\x1d\x28\xd4\xde\xb2\x38\x9b\x4c\x08\x53\x43\xe9\x17\x4c\x1a\x9e\x55\x1b\x44\xeb\xf4\x36\x44\x4b\x79\x35\x30\xcd\x47\xd8\xe3\xf7\x20\x4c\x4b\x70\xb8\x16\xcf\xbc\x24\x69\xa4\x2c\x63\x26\xd2\xbb\x66\x14\xf4\xf3\xcc\x15\x28\xb4\xee\x04\x83\x38\x4a\x35\x03\xc8\x93\x8b\x0d\x3b\x58\x0e\xc7\x83\xc5\x74\xf8\x60\x0d\x89\xbe\x99\xfd\x96\xda\x44\x8b\xe9\xd0\xf8\x2a\xd5\x75\x23\x69\x30\xbc\x06\x7b\xf8\xae\x03\xb9\x75\xe8\x1e\x86\x60\xed\x25\x61\x6a\x95\x86\xb4\x46\xf7\x36\xaa\xa8\x34\x07\xe2\x85\xb5\xc9\xa2\xe1\x80\x14\x6d\xaa\x83\xa2\x6c\x36\xe7\x57\xd8\x16\xc0\xb7\x43\x44\x47\x51\x68\xc8\x79\x1b\x1a\x1f\xce\x22\xf4\x32\x04\x0a\x77\x26\x26\x16\x7f\xfd\xc7\x4a\xe3\x3d\xef\x33\xec\x85\x55\xab\x53\xd3\xa8\x22\xc4\xb6\x84\xf0\x54\x8d\xc2\x76\xce\x8c\x4f\x95\x36\x3c\x09\x1b\x3a\x89\x8b\x59\xbb\xbd\x73\x43\xda\xb2\x65\xbb\x9e\xe7\x70\x60\x92\x4e\xca\x88\x60\x49\x11\x76\xb1\x2f\x28\x84\x81\xeb\x14\x9e\xf4\x83\x10\x59\x2f\x89\xa6\x13\xe9\x60\x26\x8c\x12\x6c\x27\x42\xe7\x81\x01\x70\xe5\x5e\xe8\x00\xe1\x9a\xbc\x86\x3c\x55\x23\x74\x16\x82\x12\xa0\x1e\x20\x9e\x6a\xdb\xc0\x71\x45\x88\x64\x5b\xde\x80\x3b\x1c\x45\xb0\x91\x1e\x7d\xfe\xbd\xbe\xb0\xcd\xcd\x33\x7f\x9a\x4b\xff\xd8\x44\x45\xb9\x51\xbb\xe4\x89\x1f\xc5\x19\x2d\x37\x54\x10\x22\x62\x0a\x3b\x92\x85\x1c\x39\xf7\x7b\x1e\x52\x53\x14\x87\x80\xc1\xa8\x48\xff\x2e\x46\x53\xe5\x9d\xa0\xa5\x31\x5e\x38\xa4\x18\x73\x9e\x6c\xab\x45\x7c\x49\x88\xd2\x99\x08\xea\xd7\x5c\xad\xe6\x46\xe9\x28\xdb\x7f\x39\x9e\xfa\xe1\x09\x1e\x88\x7f\x87\xcb\x28\x8e\xc9\x85\xfa\xa1\x00\xa0\xe8\x99\x38\xe2\x19\x59\x0e\x16\x6b\x3e\x55\x9f\xae\x12\x62\xaa\x7d\x81\x84\x7b\xdf\x57\x5d\xef\x9f\x3d\x91\x56\x22\x34\xed\x78\x0e\x1a\x24\xfe\xf9\x90\xf9\xd3\xb4\x83\xb6\xd7\xd1\xbc\xed\x1a\xc4\x47\xfb\x21\x30\xc0\x23\xe1\x1f\x0a\x30\x47\x1f\x3b\x57\x51\x2d\x9c\xef\xec\x37\x92\x8d\x8f\x39\x7d\x11\x73\x7f\xde\x2d\xde\x64\xfe\x54\x48\x36\xf5\xee\x30\xc9\xc6\x8c\xca\x2e\x46\x92\xd9\x31\xa8\x66\x5d\xa3\x06\x46\xd7\x5b\xe6\xa7\xd5\xf2\xa3\x4e\xae\xe2\x89\xf2\x99\xbb\x96\xa8\xdb\x23\x1d\x1b\xeb\x4a\x6d\xac\xc7\xfc\x20\x2a\xfc\x73\x99\x9c\x4b\xb7\x9b\xf5\xd1\x49\x00\xaf\x42\x41\x8b\x0d\x62\x1b\xb4\x08\xe0\x80\x1f\x28\x66\xd7\x51\xcd\x6a\xc5\xd1\x01\xaf\x3b\x64\x04\xc6\x57\xd4\xc5\x74\x73\x70\x31\xfc\x75\x3c\x8c\x07\x82\x9b\x18\x9a\xde\x53\x57\xba\xb9\x9f\x85\x70\x56\x0d\x3c\xd2\x50\xbf\x77\x2d\xe9\x0b\x98\x43\x8a\x8d\xa4\xa7\x75\xfe\xbd\xdb\x31\xd2\x13\xd3\x48\xf9\xd1\x31\x58\xfa\x63\x39\xce\x8e\x51\xbe\x56\xaf\x71\xef\x8c\x68\x6d\x0c\x72\x55\x9c\x74\x6d\xf5\x8c\x37\x08\x8b\x10\x6a\x9d\xbc\xd7\x1a\x08\x7d\xfe\x7d\x8a\x61\x95\xc3\x35\x1c\x14\xbe\xb5\x6f\x2d\xa9\xb3\x7b\x59\xc8\x7f\xfc\x34\x2a\xc8\x70\x54\x9f\x8d\x33\xb0\xe0\x14\x7d\x11\xe7\xc6\xed\x26\xa6\x5a\xdf\x0d\x4d\x77\xdc\x2e\x0d\xcd\x8a\x08\xa9\x19\xbe\x2a\x0b\xd7\x53\x22\xfc\x56\x63\x0a\x6a\x54\x54\xcb\x73\x78\x6f\x3a\xd8\xd5\xd3\x6a\xb9\xc7\x3c\x02\x41\x0c\xdd\x0f\x13\xdf\xfa\x2a\x19\x90\x78\xf8\xf3\xca\xca\x31\xf2\x42\x38\x20\xd2\xf3\x24\xa4\x31\xe7\xae\x7d\xf1\x6f\xa2\xfc\x17\xad\x43\x47\xff\xb2\x01\x44\xa2\x6b\x4f\x0d\xc0\xfc\x80\x7f\xbb\x11\x7c\x8f\x62\x9f\x8f\xa2\x10\x2c\xe5\x31\x23\xd1\xc2\x11\xc8\x62\x64\xb4\xf3\x60\x5b\x3e\xf2\x43\x28\x2f\xcc\xa5\xe6\x8e\x7a\x60\x06\x6b\xe6\x0f\x19\xf5\xd3\xf9\x90\x58\x30\x15\xed\x38\x91\xf1\xe2\x61\x54\x75\x14\xb1\x01\x43\x77\x4d\x69\x63\xff\x85\x3d\x89\xd7\x3a\x4f\x95\xdf\x92\xc1\x76\x27\x8d\x7a\x66\xa2\xc9\xad\x37\xce\xa6\xa9\xa1\xf2\x24\x61\x69\xf7\x27\x56\x8e\x2a\xd2\x23\xe3\xfc\x38\x97\x38\x58\xe3\xc1\x64\x19\x20\xb2\xd6\xe4\x0c\x6a\x4c\x39\x7c\xe9\xd6\x9a\x5b\x27\xca\x5e\x95\x12\x35\xa9\xd4\x3b\x7e\x79\xed\xbc\x22\xe0\xee\x2b\xc2\xd7\x5e\x5d\xcb\x15\x4f\x8d\x94\x5c\x0c\x2c\xb0\x16\x8c\xef\xc6\xb5\xb7\xa3\xb8\xd3\x5b\xa0\x76\xb1\x31\x2e\x4b\x8c\x4e\x62\x15\x2e\x39\x46\xf3\x98\x5f\xd1\xda\x8b\x51\x34\x58\xfa\x25\x91\xfb\xb2\xab\xcd\xf3\x7a\x9b\x26\xa5\xc9\xa2\xcd\xbd\x24\x5c\x35\xc4\x45\xbd\xb9\xf6\x92\xcb\x6b\xf9\xd3\xdb\x28\x8d\x48\x50\xde\x82\x2c\x1b\xcf\xd6\xef\x54\x2d\xb7\xb4\x6b\xa3\xc1\x9a\xcc\xae\xf1\xa6\xb6\xd6\x5b\x9d\xdc\xfb\x03\x7f\x36\x93\x81\x35\xa7\x57\x35\x29\xe2\xba\x16\x76\x6b\x52\xed\xf5\xce\x3c\xe3\x85\x62\xbd\x23\x47\xb0\x5f\xfe\xc2\x24\x49\x35\x0d\xf2\x3b\x7b\x92\x6e\x8f\xbe\xfb\xa9\xb0\x0b\xab\x84\x0e\xda\xfb\x10\xe9\x30\x73\xcc\x86\x89\xfd\xf7\xb1\xdd\x78\xd9\x2b\x4e\x34\xe3\x01\x25\x0f\xa6\x65\x9c\xa5\x16\xdf\x28\x57\xb1\xe1\xa6\xc3\x69\xe3\x9b\xef\xa1\x43\xfc\xa6\xb8\x3e\x21\xfa\x60\x78\x5f\x79\x16\x1a\x75\xc8\xd7\x39\x2e\x7a\xf5\x95\xd6\x7b\x4b\x79\x8b\x53\x6c\x7a\x4c\x31\x13\x94\x4f\x66\xdd\x57\x25\x9b\x13\xb1\xb5\x67\x84\x2e\x20\x6b\x9a\xfb\x27\xed\x30\x93\x49\x2d\xf8\x66\x4d\xa6\xbd\x17\x46\x6c\x50\x3a\x2b\x9b\x38\x34\x46\x89\x50\x03\x37\x8a\xc0\x5f\xe2\x8b\x5a\xe9\x08\xb1\x18\x30\x50\x25\x87\x15\xf6\xd8\x90\xf2\x3f\x93\xb5\xc5\x02\xb3\x15\x84\xaa\xed\x1c\xc1\x88\x98\x5f\x43\x08\x4a\xbf\x8a\x81\x12\x10\x43\x50\x71\xd7\xd8\xaa\xf5\x34\x44\x41\xc5\x1d\x60\xf7\x41\x51\x78\xc4\x91\xd8\xd7\x71\x56\x2c\xcb\xb3\x22\x8c\x6d\x08\xaa\x4e\x1b\xcd\x6d\xbf\xe2\x6d\x6b\x6f\x60\xbd\x6d\xc7\x65\xdb\x33\xd9\xb6\x76\xfc\xb8\x2e\x5d\x5c\xf3\xd4\xf9\x12\x02\x19\x15\xee\x08\x81\x8c\xe4\x7d\xcc\x08\xf3\x37\x21\x30\x08\xc0\xa0\x18\x63\x92\xa3\x4b\xc4\x7e\xd1\xc5\x1f\x29\x89\xe9\x01\x67\x6a\xb7\xda\xc3\x0f\x29\x59\x86\xe4\x42\xb2\xe0\x9d\x2a\xd9\x86\x97\x97\x5a\xc5\x6f\xb6\x2e\x08\x32\x9a\x12\x19\xf5\xd3\x5a\x92\x48\xf0\xff\xeb\xbc\xfd\x2c\x03\xf4\x34\x45\x74\x44\x85\x6b\x5e\x03\x58\x6a\xfb\x04\x9b\xae\x87\xe6\x7b\x54\x6e\xc3\xe7\x6e\x21\x5d\x33\xfa\x48\x45\x17\x31\x05\xe2\xd2\x51\x11\xaa\x04\x02\x37\x42\x3b\x70\x12\xa2\xc4\x16\xa2\xf0\x08\x4d\x61\x1a\x02\x65\xc2\x65\x28\xb6\x6d\xc8\x44\x89\x4f\x8d\x02\x89\xcc\xf4\x7a\x94\x1a\x2f\xc2\x11\x87\xbc\xbd\xf5\x35\x45\x59\x11\x58\xf7\x22\x1c\x65\x4b\x91\x16\x54\xd3\xa4\xb6\xe1\xd6\xd3\x54\x08\xe8\x49\xb7\x58\x5e\x80\x32\x17\xd1\x1a\x9d\x0f\x69\x05\x80\xbd\xf6\x00\xfa\x12\x35\x58\xd0\xe1\x83\x01\xff\x0a\xc8\x62\x19\x63\x86\x87\x0b\x9c\x64\x83\x74\xde\xe0\x1b\x54\x1b\x61\x80\xbe\x08\xa5\x40\xd3\x1e\x96\x79\x93\x6f\x56\xc3\xab\x3f\x29\x52\x1c\xfb\x2a\xe0\x40\xab\x39\x53\x6d\x75\x51\x93\x95\x13\x92\x60\x83\x99\x89\x69\x23\xae\xa7\x81\xa7\x83\x60\x0c\x05\xaa\x74\x68\xd6\x99\x74\xe5\xfc\x00\x3d\x33\xd1\x8b\x59\x80\x3e\x99\xd2\x8f\xc3\x3a\x8d\xaf\xd2\x2c\xda\x90\x0e\xdf\x06\xb8\x61\x94\x2e\x63\x5f\x46\x38\xb4\xa6\x31\x09\x4e\xd7\x05\x6c\x45\x33\x72\x32\x1e\xff\xb8\x26\x58\xbf\xd9\xc6\xb1\xa0\x50\x02\x11\x6b\xbf\x86\x34\x3a\x99\x9b\xf5\x47\x3f\xc3\x0b\x21\xe2\x4a\x4c\x62\xe5\x1c\x3e\xb6\xad\x3b\x24\x7b\xc0\x77\x17\x15\x2f\x5a\xa6\x67\xb5\xc1\x81\x29\x88\xb9\x54\xda\xc8\x91\x8a\x45\xf7\xd1\x64\x65\xb0\xd6\x53\x18\x85\x8e\xf6\xe5\xa6\x46\xd2\xab\xae\x10\xfa\xdd\x72\x5f\x9b\xd0\xe4\x35\x41\x93\x7f\xa9\xad\xb9\x5a\x34\xb7\x0c\xd0\x1b\xd3\x26\x52\x27\xfc\x64\xf0\x5d\x5b\xe6\xd6\xa7\x5c\xa7\xe6\x68\x85\x71\x2f\x22\x60\x09\xb5\x99\x1d\xb0\xb6\xe3\xb8\x74\xbc\xd3\xdb\x32\x47\x99\x1f\x3a\x15\x39\xe4\x1b\x48\x11\x08\xea\xe6\x86\x1f\xb3\xd5\xa8\x57\x5b\x9f\x43\x44\x6d\x27\x42\x1f\x43\xe1\xf2\xbf\x88\xda\x25\xcc\x88\x96\xff\x60\x9d\xc9\xb6\x4b\x8a\x5b\x39\xc3\x11\xfd\x04\x73\x9f\xb2\x15\xea\x4a\x5d\xc4\x86\x20\xeb\x88\x64\xd4\xa4\xf2\x23\xa2\xbe\x2f\x8d\x2a\x5c\x05\xeb\x67\x0e\x56\xbf\xb5\x26\x80\xd6\x50\x55\xec\x51\x2b\x95\xa1\x90\xbf\x0b\x7c\x53\x1c\xc7\xc3\x34\xf6\xd3\xf9\x77\x80\xaf\x08\x3e\xda\x06\x60\x97\xe5\xdf\x37\xea\x23\x96\xef\x5f\x7f\xd1\xac\x87\xe4\xbb\xe7\x6d\xc6\x1b\x6c\xc4\x1b\x4d\xad\x9f\xc5\x08\x37\x34\xfe\xc4\xb3\x1f\x59\x3a\x59\x5a\x04\x33\xf0\x26\xb9\xb4\xe7\x33\xb6\x25\x38\x58\x6f\x22\x78\xd6\xaa\x51\xf4\x5f\x68\x3d\xb5\xd2\x4a\x59\x2e\x98\x38\x7d\x87\xe3\x2e\xe5\xf4\xdb\x90\xd6\x96\x5d\x70\x54\xc4\x64\x59\xeb\x44\x31\x5b\x28\xdf\xb6\x91\x2e\x23\xe5\x5b\xb6\xa3\xc0\x13\x90\x58\x9f\x16\xff\x16\x04\x06\x65\xb8\x35\xcd\x9c\x4b\x32\x90\x54\x83\xc4\xbb\xf5\x28\xf1\x3a\x3e\xfc\x5a\x52\xb7\x5b\xd9\x48\x17\x2f\x1e\x85\x40\xab\x43\xd0\xb3\x44\x06\x68\x24\xbc\x2c\xce\x4d\x97\x80\x2f\x85\x46\x41\x21\xf4\x14\xdb\xdc\xe4\x20\xe3\x1b\xad\x2f\xf8\x96\x24\xbd\x5b\x32\x42\x87\xfd\x12\x98\xb3\x4e\xfd\xd9\x84\x5c\x50\x7f\x0d\x1b\x9e\xea\x12\x8a\xed\x6e\x39\x06\x11\x9d\x71\xa1\x76\x6e\xf3\xfc\x9c\x86\x32\x5c\xbe\x11\x0a\xc1\xb2\x3b\x4e\x91\x16\x2d\x08\x5d\xb0\x2d\x03\x7a\x2c\x03\xf4\x2c\x46\x1f\x53\x74\x66\x54\x54\x5a\x49\xd9\x3b\x25\x12\xb7\x22\xdf\x8b\x28\xc9\xd2\x6f\xa7\xdb\xfb\x4d\x73\xcf\xf2\xac\xea\x9e\xb0\x86\xca\x37\x4d\xfb\x3b\xe7\xbb\x8c\xff\x11\xd3\xcd\x6d\xc8\xba\x0f\x96\x5a\xec\x95\x28\x2d\x02\x6a\x1a\xe5\xa3\x15\xc2\x2f\xc8\xdc\x00\x15\x01\xc8\x6d\xcb\x2c\x23\x95\x05\xad\x1c\x88\x9b\xf0\xad\x10\xf0\x3f\x15\x71\xa8\xe9\xe8\xa9\x45\xa3\x37\x29\xab\x0f\x2c\x20\xab\xdd\x0d\x55\x1b\xda\xf6\x11\x6e\xa9\xa5\x97\x3f\x5f\x8a\xec\xc0\xac\xa1\x0e\xde\xb2\x53\x2f\x34\x42\x27\x1d\xd6\xfb\xed\xa0\xe1\x11\x0a\xd8\x37\x6b\x4d\x4a\x7d\x8a\x44\x04\x5f\xd8\x4e\xa4\xa2\x64\xed\xea\x59\x30\xed\x77\x7c\x34\x85\xa7\x40\x85\xc9\x6e\x52\x30\x52\x7d\x37\xc8\xff\x55\xf8\x6e\x36\x9d\x2d\x8d\x66\x92\xfa\x5d\x28\x19\xf9\x49\x42\x98\x90\xa4\xa7\x36\x8c\xed\xbf\x8f\xb7\x22\x14\x2c\x05\x6a\xb4\x75\x10\x54\x6d\xb6\x44\xc9\xe8\x04\x27\x98\xfa\x8c\xd0\x77\x34\x36\x94\xa1\x4b\xa3\xdb\x48\x13\x5c\xa5\x27\x01\x38\x40\x89\xa6\xe3\x7b\xc6\xa3\xcb\x9f\xc6\x78\x50\x00\x65\xd2\x21\x3e\x21\x4b\xa8\xcf\xaa\x7b\x1e\x86\x67\xb3\xcf\x90\x2c\x4d\x7b\x52\xd2\x9f\xa8\xe3\x72\xf9\x7f\x9c\x13\x81\xdd\x5b\x38\x11\xe8\xf7\xd1\x78\xbb\x41\xad\x70\x20\xb0\xfb\xcf\x71\x20\xe0\xb7\x59\x0e\xc3\x63\x86\x0e\xf1\xeb\x58\x56\xbf\x8a\x4a\xd5\x0f\x5d\xed\xb9\xa3\xc3\x11\xab\x98\xea\x3b\xb1\x02\xeb\xd9\xb3\x99\x34\x56\x6c\x48\xbb\x0f\x4b\xfd\x64\x90\xb8\x77\xe8\x48\x85\xcb\xbf\x7b\xf7\x4e\x53\xd0\x72\x73\x23\x74\x22\x2d\xcb\xb1\x84\x1c\xbd\xff\xce\x56\x3d\xed\x5a\x72\x78\xab\x21\xd0\x2c\xc5\xf0\xfb\x3d\x62\xf8\xfd\x96\x18\x7e\x6d\x89\x5a\x4b\x02\xdb\x41\x2e\xfc\x25\xe2\xf0\xb8\x9a\xe2\x23\xf5\xb8\x22\x34\x28\x6c\x93\x1f\x40\x3b\x87\x59\x17\x6a\x50\x48\x5c\x6c\x68\x48\xf8\x06\xd7\xf0\x0e\x5c\x5c\x79\xa2\xc9\xfa\xdf\x58\x2a\x8e\x23\x9e\x4b\xc7\x11\x4f\xd2\x1c\x3c\xfd\xae\x43\x9a\xef\x3a\x9c\x6a\x71\x20\xfb\xea\x5d\xa7\x5e\x80\xc8\xcc\xb4\x16\xa7\x52\x7b\x73\xa0\xc5\x9b\x8e\x36\xcb\x7c\x9d\x22\xbf\x74\x03\x41\xd5\xeb\x4e\x25\xd7\x6b\xe4\xd6\xbd\x4a\xb0\x2d\x3e\x86\x27\xd2\xfb\xc2\x3b\xe9\x7d\x21\x11\x0a\xed\x12\xaf\x83\x46\x6d\x93\x8b\x89\xa0\x74\x31\x41\x4c\x2e\x26\x4e\x42\xa4\xa0\x29\x25\xa7\xb8\xe5\x72\xc2\xe4\x6d\x82\xe8\x68\x88\xa5\x0b\xfa\x22\x42\xa2\xf0\x40\x41\x46\xde\x64\x4b\x53\x40\xa2\x3c\x71\x73\xd0\xab\xa9\x3d\xaf\x79\x9b\xe0\x4b\x32\x73\xd9\xd6\x93\xb4\x3a\xb7\xfe\x83\xe1\x2f\xf0\xa3\xa0\x3c\x0c\x5c\x75\xbf\xe2\xac\xe9\x43\x21\x30\xbf\xdc\x98\x64\xd1\x57\x21\xca\xcc\xef\x3f\x07\xc6\x30\x08\x01\x7a\xd5\xb5\xb5\x7d\x99\x67\xdc\xda\xff\x2a\xde\x17\x3a\xfc\x16\xce\xfe\x3a\x19\x80\xf9\x0e\x14\x77\xf0\x20\x4f\x6b\xac\x35\xe3\x6c\xd4\x5f\xeb\x9b\xe1\x80\x33\xe0\x83\x53\x7c\x35\x98\x11\x3a\x10\x50\x8e\x92\x93\x6e\x35\xf5\xbf\xdc\x39\x44\xef\x00\xfe\x79\xbe\x22\x0e\x52\x54\x81\xf4\x7a\xbc\x48\xa5\xfc\x5a\xa2\x9f\xb0\xf3\xec\x16\xf7\x5b\x49\xf5\x5a\x2f\xfe\x77\x22\xb4\x9f\x00\x01\x3a\xe2\x97\x12\xfb\xe6\x86\x63\x05\x81\xc4\x86\xcc\xdd\xa1\x88\x88\xa3\x3c\xd8\xaa\xfa\x0a\x72\x6a\x6e\x84\xfe\x91\x0e\x71\x84\x41\xd2\x92\x0f\x66\x9d\xb3\xbb\xe5\x14\x27\xfb\xef\x77\x8a\x33\x5b\x42\x60\xd6\x3c\x35\x5f\xb2\xd2\xa5\xd1\x6f\x6b\x1b\x03\xec\x1c\x96\xcb\x7e\xa7\x88\x6b\x1b\x61\x89\xec\xb6\x9e\xb5\x0c\x61\x42\x6b\x2a\x63\x6b\x8a\xcd\xab\x9e\x26\x27\xfc\x0a\x72\x7f\x3d\x5d\x4a\xc2\xe4\x1e\x35\xed\xee\x56\x82\xd3\x61\x75\xf4\xed\x8f\x06\xeb\x0e\xb5\x7b\xf6\xff\xfb\x3c\xb0\xf2\x79\xe0\xe7\x69\x30\x0e\x4d\xaf\xe0\xff\x33\x5f\x08\xd6\xb8\xfb\xfe\x4f\x7d\x0c\xa0\x76\x8e\xcc\xb6\xb6\x46\x13\xd1\x52\x2a\xd5\x6f\x20\xea\x2d\x85\x80\xad\x43\xdd\xc4\x86\x79\x8d\x2e\xa9\x48\x07\x3a\xbe\x51\x22\x74\xc8\x96\xa1\x39\x52\xba\x49\xa6\x27\xf8\x14\x26\xe4\xa7\x9a\x75\xcf\xcd\xea\x60\x52\xdc\xa7\x74\x53\x88\x91\xa5\xae\x93\xba\x86\xa9\x7a\x1d\x24\xca\x70\x5d\xb2\x0a\xda\x6c\xbd\x45\x83\x58\x8e\xfa\x02\xbf\xfb\x68\x29\xa0\x05\x42\x02\xfb\x8e\x7f\x65\x52\x7c\x79\x4b\xd9\xa9\xb9\xf0\x9d\x8a\x98\xb4\x1e\xdc\xfa\x09\x45\x99\x74\x3b\x92\xdb\x70\xbe\xec\xd3\xb6\xfe\x3e\xe7\xb9\x5d\x16\xb9\x42\x03\x25\x1e\x4e\x06\x81\xf0\xcf\x55\x38\x89\xd7\x3f\x4d\x3e\xcd\xd7\xbc\xcd\xac\xf2\x89\x2e\x24\x69\xb5\x5e\x87\x82\xcd\x37\x95\xfd\x81\x08\x25\xc3\x3b\x13\x73\xc4\x9d\x34\x30\x29\x29\x3d\x8b\xa5\xdf\xde\x5e\x9d\xba\xdb\xdd\x43\x5a\xe3\x0d\xa3\x40\x28\x1a\xdf\xfa\x39\x64\xad\xf6\x43\x9c\x06\x34\x5a\x0a\x99\xf6\x1a\x27\xf3\x1a\x31\x55\x3a\x74\x76\x16\x5d\xc2\x0f\x26\x84\x1f\xcc\x9f\x0a\x69\x87\x20\x3b\x8f\x7d\xfa\x7d\x26\xe4\x81\x4f\x43\x4e\xbb\x6e\x67\x53\xd3\x68\x60\x28\x3d\xea\xac\xd1\xc4\x6a\x43\xfb\x4a\x7b\x22\x61\x65\xa3\xc2\x4d\x83\x37\x83\xc4\x44\x50\x9e\xc5\xe8\x73\x2a\xa9\x5b\xfb\x50\xb8\x85\xb9\xba\xe8\x24\xfb\x96\x4e\x9e\x9a\x05\x10\x46\x34\x34\x9b\xc4\x3f\x8b\x51\x32\xd3\xda\x83\x3f\x84\x15\x55\x2c\xc0\xc5\x67\xd3\x42\x5e\x8b\x00\xd0\xf9\xb2\x34\x0f\xb6\x94\xe5\xbb\xfe\x0d\xcc\xe4\xdc\x50\xd6\x29\x9e\xf6\x74\xa5\x22\x01\x7e\x30\x3b\x73\x5c\x6f\x8e\xdd\x48\x24\xb5\x4c\x57\x2d\x77\x9b\xe9\x96\xcb\x78\xec\x4f\x2b\xe6\x1a\x3d\xb0\xc4\xa5\x7b\x01\x5c\x75\x2f\xd0\x07\x7f\xaa\xea\x84\x4b\x44\x6c\xbb\xee\x36\x67\x0d\x89\x77\x7b\xe8\xd2\x53\x08\x56\xf6\x01\x8f\x0a\xb7\x7d\x41\xb7\x71\x63\x8a\xe6\x4b\xc0\x23\x29\x0e\xdf\x0f\x81\x02\x91\x51\x22\x1b\x96\xd7\x46\xeb\xc7\xb6\x1d\x76\x10\x22\x51\x3b\x37\xcc\x46\x90\xa1\x93\x36\x19\xfa\x1f\xeb\x5d\xf0\x43\x8c\x22\xb4\xfd\x3f\xdf\xbb\xe0\xed\xc7\xd9\xeb\x5d\x70\xda\xa9\xb4\xd1\x17\x10\x46\xf2\xab\xdf\x69\xe9\xb7\x29\x1e\xdd\x44\x7b\x1d\x7c\x78\xab\xad\xed\x15\xb6\x4a\xdf\x1a\x85\xac\xd3\xfc\x7c\x32\xfe\x0e\xfb\x73\xba\x9e\x9c\xf0\xaa\x6b\x09\x9a\xde\xe8\x3e\xc4\xe8\xf1\x4c\xf9\x53\xfa\x5f\x9f\x74\xdf\xe0\x93\xee\xb8\x97\x23\xff\x4e\x3b\x39\xa3\xd6\x66\x3f\x7b\xb8\x88\xd7\x90\x7b\x74\xba\x4c\x3b\x59\x76\xb8\x4c\x5b\xeb\x24\x89\xd0\x94\x1f\xd1\xbb\x16\x08\x23\x27\xe1\xa3\xab\xa3\x90\xf4\x0f\x37\xf0\x99\x28\xfb\xd6\x47\x15\x47\x71\xdd\xb5\xf6\x92\xb0\x5e\x47\xb9\x8c\xeb\xae\x21\x5d\x0a\x84\xb5\x4a\x32\x46\x71\xd8\x5b\x4f\x7a\x20\x08\x07\xd3\x2b\x35\x99\xd2\xee\xaf\xbb\x8e\xb6\xfa\x93\x15\x94\x31\x5f\x1f\x08\x18\x16\x85\xd3\x59\xc3\x13\x5f\xcf\xc0\xb4\x89\xb7\x05\x46\x05\x06\xe3\xed\x55\xf8\xec\xd1\x5e\x37\xab\x6e\xeb\x3a\x7b\xd9\xd6\x76\xdd\x4a\xc0\x0f\xef\x9a\xe1\x61\x35\x26\x45\x08\x0b\x37\x77\x57\x02\x73\xc6\x1d\x6e\xee\xf2\x8a\xb5\xe0\x45\xf7\xd3\xb4\x92\xe6\x57\x5c\x51\x69\x1e\x24\xe9\xf4\xe3\x23\x55\xb2\x1e\xd5\xec\x07\xda\x3e\x94\xb6\x7c\x74\xbc\x04\x0c\x84\x8f\xd1\x29\x7f\x4c\x9a\x7e\x19\xd6\xf4\x17\x13\x84\xca\xa6\x36\x87\xd3\xe5\xea\x00\xb9\x2b\x37\x7a\x42\x58\x97\x64\xc2\x90\x70\xd4\xf1\x0c\xf4\xb2\x7f\x14\xf1\xaa\x51\xbc\xc7\x34\x8d\x48\x32\xd8\x4f\xf8\x11\xea\x9b\x2f\x95\xeb\x9f\x76\xb7\x3e\xd7\xb7\xbb\xce\xcc\x74\xb1\x9e\x37\x38\xeb\x31\xf5\x93\x60\xee\x7c\xcf\xa8\x55\x7f\x93\x35\x7c\x25\x11\xc4\x46\x53\xd1\xe3\xb7\xb1\xde\xff\x83\xe0\x96\x45\x71\xb8\xeb\x33\xfc\x4f\x05\x9d\xee\xf4\xff\x08\xe8\xbd\x4b\x31\xfd\xa7\x43\x8f\x77\xfa\xaf\x0e\xbd\xa7\x44\xd1\x9d\x7f\x26\xf4\x4e\x74\xa7\xff\xea\xd0\x7b\x8b\xcf\xa3\x7f\x36\xf0\xa8\xea\xf3\x5f\x1d\x76\xff\x0d\x78\x77\xfe\x4d\x58\x57\x61\xa3\xec\x1c\x2e\x3b\x8e\xff\xab\x6f\x90\xb4\x7e\x2b\x9c\xd7\x76\xa9\xe3\xac\xe9\x8c\x88\x03\xc7\xe8\x16\xe1\xfb\x9c\x35\xff\x75\x93\xd9\x0e\x43\x8a\xd3\xf4\x36\xf3\xf1\x65\x95\xb5\xae\x53\x39\x3c\x36\x9b\xfc\x44\x33\xd4\x30\xd8\x34\xc7\x17\xfd\x5e\xe6\x6f\x27\xce\x52\x86\xe9\xe0\x48\x5c\x44\xfe\xc5\xf8\x3e\x81\x69\xff\xb4\x6d\x8c\x57\x3b\x42\xfc\x17\xa0\x7e\x72\xa1\xff\x59\x50\x6b\x8b\x2b\xe8\x3a\x4a\x14\xc2\x49\xb4\x50\x38\xb8\x33\x5e\x57\x55\x41\xf8\x95\xd6\x72\x20\x5e\x47\x85\x2b\x94\x57\x6c\xb0\x28\xf6\xc3\x2b\xcb\xbe\x55\x73\xda\xfb\xa7\xa1\xb9\x14\x33\x16\x0b\xcf\xa0\xeb\x84\x84\x35\x61\x93\x6c\xe9\x76\x82\xc6\x7f\x01\x04\x7b\x8d\x31\x5d\x1b\xbf\x8c\x6f\x70\x7d\xf8\x15\xa1\xcf\x70\xb9\x04\x3c\x5a\xe2\xa6\x0f\xfe\xee\x03\xb4\x8c\x8d\xfc\xdd\xf4\xf2\x10\xa7\xf3\xff\x0e\x62\xf9\xfd\xe4\x4b\x0e\x3d\x21\x6c\x10\x90\x64\x16\x9d\x64\x74\x2d\x35\x2d\xe3\xa1\xb5\xbd\xd2\x2a\xe6\x1b\x4f\x23\x31\xb2\x35\x01\xbb\x30\x81\x64\xf9\x1d\x4e\x33\xa6\x7e\x70\xca\xd7\x24\x51\x36\x82\xff\x36\xfb\x65\xf6\xcb\xec\xb7\xff\x9f\xba\x6b\x71\x8e\x13\x47\xfa\xff\x0a\xe1\xae\x12\x69\xd3\x9e\x78\xf6\x76\xbf\xaf\x0e\x17\x95\xf2\x33\x9b\xc4\x76\xb2\x7e\xe5\xb1\xb5\x35\xc7\x80\x30\x24\x0c\x60\xd0\xf8\x11\x87\xff\xfd\x2b\xbd\x40\x80\x18\x33\xde\xdc\xd5\x77\x55\xbb\xb1\x0d\xa2\xd5\x6a\xb5\x5a\x2d\x75\xeb\xa7\xb1\xc9\x52\x61\x96\xd2\x8d\xd0\x5b\xc4\x89\x84\xaa\x59\x64\x69\xc6\x93\xd3\x47\x61\x86\xf4\xa4\x75\xfb\x63\x63\x14\x75\xe7\x1d\x3f\xae\xf3\x1e\xde\xb6\xfe\x6f\x74\x21\xce\x73\x1a\xff\x27\x9d\x08\x3a\x59\xf2\x1a\x1f\x67\xe5\x77\x72\x44\x27\xbe\x70\xd9\x4e\x7b\xd3\x87\x2c\x74\x9a\x37\x2b\x8e\xd7\x69\x68\x42\x76\xda\xe6\x74\xf8\x60\x33\x2e\x38\x70\x05\x27\x03\xa8\x22\xbc\x56\x46\x76\x35\xd8\xba\xd4\xaa\xe3\x5c\xc0\x62\x3f\x7a\xbf\xb5\x90\xfb\xad\xfb\xb9\x7b\x9f\xc4\xe9\x57\xc7\xb6\x21\xe5\x6e\x9f\x5d\xc1\x51\xfd\xf0\x6f\x2f\x04\x63\xea\xa5\xd4\xc5\x0a\x76\xf5\x22\xf5\x3d\x5e\xb2\x90\xfa\xbb\x82\x2b\xad\x98\xda\xfd\x16\x85\x24\xde\x71\x05\x07\x79\xe7\xc2\x96\xab\xbc\x2f\xd8\x5d\xc3\xb3\xa3\xbc\x2f\x62\x38\xcc\xdd\x81\xb3\xb3\x82\x0f\x2a\xaa\xe7\xd7\x7c\xeb\xfd\x60\x8a\xce\x0b\x16\x4f\xb2\x25\x6d\x42\xda\x57\xb9\x10\xf9\x71\x46\x0f\x98\x45\x6b\xbf\xdd\x97\x6f\xa5\x04\x0e\xb2\x62\xb1\x1f\xc4\x54\x16\xea\xbe\x3a\x26\x37\x86\x37\x87\x71\x69\xfa\xe0\x22\xae\x4b\xcb\xca\x76\x55\x65\xbc\x4f\xda\xef\x8e\xf2\x6e\x9f\xef\xe7\xfc\x2e\x94\xd5\x10\x00\x87\x39\xb3\x7e\x05\x7e\x69\x5b\xcd\x91\xbc\x0a\xc3\xbb\x15\x41\x68\x53\x9e\x9c\x96\x73\x5e\x67\xcc\x41\x8c\x5e\xe7\x03\xa1\xc2\x9e\x01\x5a\xfb\xce\xf8\xb7\x19\x2a\x26\xec\xa5\xe1\xdd\x97\x41\x90\x40\x33\xdc\xfc\xb8\xe5\x08\xbf\x05\x64\xc0\xe4\x7f\x86\x77\x5c\x92\x07\x39\xae\xe0\xfd\x40\xa1\x68\xa0\x8d\x73\xaf\xb0\xc4\x8f\x0d\x9a\x5d\x5e\x26\xc4\x9b\x27\x64\x63\x11\xa8\x87\x49\x7c\x19\xd1\x06\x9f\x63\x31\xdf\xf8\xd5\xca\xe9\xc6\x3f\xac\xbc\x9b\xa5\xbd\xd6\x24\x2d\xb2\x1a\xe6\x19\xa5\xd9\x42\x42\xbb\xe5\xb7\x56\x99\x25\x71\x60\x15\x97\x73\x0f\x6d\x82\x25\xfe\x9b\x4c\x7f\xfe\x15\x3f\x2a\xef\xbf\x34\xdb\x79\x19\x27\x1f\x31\x31\x0d\xe9\x05\x93\xcb\xbc\xf0\x52\x63\x7e\xf9\xdb\x0c\xd9\x7f\x1b\x71\x76\x5c\x21\x31\x2f\xbc\xd4\xeb\x9e\x9d\x5d\xd3\xd5\x96\x2c\xa5\xde\xb5\xa1\x51\x6f\x72\x73\xf8\xaf\x7f\xa5\x58\x3b\x59\x68\x4d\xa3\xd2\xce\xcf\x19\x77\x45\x03\xf7\x14\xe2\x34\x89\x53\x62\xc4\x8d\x5b\xa3\x57\xc6\x66\x8a\xf3\xde\x69\xb0\xad\x52\xd3\x45\xa8\xc6\x4d\x0a\x0d\x6a\x77\xcc\x68\x35\xe5\x40\x19\xcf\x2c\xef\x99\x67\xe8\x82\x49\xd5\x3c\x39\x1b\x0c\xf0\x49\x5e\xa7\x50\xe1\xad\xd5\x76\xfc\x86\x17\x6d\xde\xaa\x5c\x2a\xc3\xec\x13\xa3\x45\x0e\x54\x44\x76\xd9\x3c\x01\x9a\x13\xd0\x9f\x3e\xd4\x31\xcb\xa0\xa1\xcf\xde\xe2\xde\x1c\xd5\xd7\x19\x34\xcb\xe0\x22\x81\x12\x7d\x0a\xe0\x4a\x20\xd6\xd0\x89\x54\x21\x89\xf5\x0b\x35\x51\x46\x02\xf7\xa9\x6a\x4a\x6a\x22\x7b\x28\x2f\xf6\xd0\x9d\x5f\xdb\x36\x53\x3d\xcb\xf2\x43\x72\x4d\x92\x36\xb9\xbe\x63\xf3\x35\xaf\x2a\x38\x1f\x9c\xac\x3c\xe4\x65\x60\xf3\x29\x04\x7a\x4a\x68\x3a\x85\xb8\x97\x21\xbb\xa4\x77\x09\x29\x23\x42\x8c\x89\xd2\x31\x9a\xf9\x60\x27\x99\x17\xd8\xe0\xa7\xa8\x40\x47\x31\x1b\xdc\xe6\x64\x00\x56\x94\x14\x45\x56\xc8\xb2\xbb\xb1\x3e\x53\x1e\x78\x71\x42\x02\x8b\x66\x16\x23\x67\xed\x9e\x9e\x5a\x61\x91\x2d\x1c\x8b\xdf\x22\x6c\x4a\xb0\xe9\x64\x3d\x57\x18\x2e\x1e\xb7\x06\x39\xcf\x41\xcf\xaf\xb7\x93\x78\xfe\x62\x9e\x65\xb4\xa4\x85\x97\x6f\xfc\x32\xd9\x9c\x6c\x6e\x78\x49\x1e\x79\x93\xff\xd9\x08\xe2\x92\xbe\xf0\xcb\xb2\x29\x30\x59\xc4\xe9\xc4\xe7\x59\x42\x47\x26\x00\x0b\x33\x7d\xbe\xac\xf3\x6e\x48\x99\x2d\xc8\xc6\x2f\x93\xff\x9d\x6c\x72\xaa\xfa\x63\x8d\xf0\xbe\xe1\xc2\x09\x5c\xc1\x87\x51\xd9\x71\xe3\x36\xf0\xc7\x41\x9e\x78\x41\xa0\x76\xae\xec\x5f\xba\xe7\xdf\x56\x7c\xa8\x9d\xf5\x29\x48\x30\x66\xe5\x6a\x70\x4d\xc6\xcc\x48\xef\x99\x39\xe1\xc6\x6a\x9d\xa5\x96\x9c\x82\x99\x0f\xf1\xf0\x75\x63\x7b\xf9\xc8\xd4\xf7\x0a\xc3\x6f\x8f\xd1\xc8\x0b\xd6\x86\x24\x9e\x9b\x01\x51\x3a\x39\xb6\x85\xe9\x48\x3b\x9d\xd4\xea\xb9\x7b\x7a\x0a\xfc\x7a\x65\xa6\x5a\xdb\x42\xb3\x76\x4f\x4f\xab\x2d\xea\x04\xd9\x7d\xc1\xfe\x89\x43\x54\x7f\xfd\xa4\x0e\x0c\xcc\x0b\xe2\x7d\xb5\xb4\xdb\xaf\xe4\xf1\xf6\xee\x9a\xac\x79\x3f\x5d\x79\x73\xc9\xea\x36\xff\xff\xe9\xb7\xee\x15\x2a\x42\x0e\x45\x6d\x6c\xa5\x5c\x2a\xe3\x45\x2b\x31\xfa\xc0\xbd\x7c\x79\xdc\xbf\xfe\x88\x89\x58\x95\xe5\xb1\x17\x25\x2c\x45\x5d\x51\xad\x6e\xa2\x38\x21\xe8\xc9\x54\x3b\xa9\xa4\x48\x4e\xf9\xaa\xb5\x5f\x80\xbb\x38\xe6\x24\x67\xf8\xb2\x62\xc9\x23\x92\xd7\x50\x01\xf7\x2a\x8d\xcb\xe9\x5f\x7e\x79\x00\x49\x09\x74\x42\xc9\x2d\x3f\xdb\x52\x61\xf8\x66\x4a\x53\x14\xe0\xc1\x3a\x4d\xf6\x85\x73\x88\xbc\x12\x11\x2d\x4d\xac\xbe\xad\xda\xa0\xb5\xf5\xd7\x44\xe3\xa8\xd7\x59\x27\xb4\x63\xa8\x3e\xfb\xad\x8b\x98\x8b\x12\xa5\x03\x33\x90\x5f\xc0\x1d\x3a\x2e\x31\x5c\xa4\xe6\x2b\x00\x4d\x22\xac\x30\xbc\x5a\x79\x78\x4d\x8d\x10\xbf\xb5\x7a\x0e\x02\x91\xb5\x2f\x93\xec\x44\x82\xd9\xd2\xf5\x35\xb0\x2f\x0f\x7d\xcb\xf9\x01\xdd\xba\xe1\x59\xab\x2b\x5e\xc1\x12\xb2\x46\x76\x2f\x9b\xdf\x9d\xa6\xc1\xcd\xc3\x8e\xba\x2f\xfb\xaa\x2e\x4b\x9e\xb1\x9e\xf1\x27\xb3\xcd\x97\xb6\xed\xd4\xdf\xb3\xa7\x95\x72\x39\x44\x52\xb6\xa1\x05\xb3\xb5\x5a\xf0\x71\xcc\x11\xb5\x19\xd6\x5b\xd9\x67\x32\x2e\xd1\x0c\x0f\xf0\x29\x72\x32\x8f\x9a\x37\x6a\x24\xae\x52\xaf\x86\xc7\xba\x12\xa1\x5a\xfb\xb4\x92\x17\x11\x17\xa4\x2c\xe3\xf4\x72\x47\x01\x81\x8c\x24\xdb\x05\x0e\xe9\xd0\x6e\xfb\x6b\x06\x5a\x99\x2c\xc9\x3a\xeb\xf7\x41\x84\x18\x25\xfd\x2f\xa8\x7b\x38\xb2\x0d\xed\xf8\x44\x06\x97\x66\x9b\xc2\x53\x7e\xfa\x54\x3d\x98\x8a\x9b\x15\xc5\x8d\xb7\x18\x3e\x0d\xe3\xb9\x89\xbb\x44\xf4\xd8\xf0\xe3\x2f\xba\xcd\x58\xc5\x3b\x35\x56\x9b\x47\xc1\x7f\x5e\x40\x8c\xf6\xc0\xdf\x28\x36\xa6\x1c\xd7\xbb\xc2\xf0\xd6\x64\x5f\xa8\x13\x66\x05\xda\xda\x52\x96\xc6\x34\xe9\x31\xe1\x15\xd5\x56\x77\x3e\x13\xf9\x9e\xdf\xbf\xb3\x81\xc1\xff\x94\x13\x99\xfe\x44\x5a\x63\xc9\x34\xd9\xaa\xb3\x41\xa7\x8c\x67\x5f\x7c\x34\xdb\xdc\x6a\x30\x65\x52\x69\x8f\xf1\x3d\x95\x6f\xa7\x50\xb8\x19\x10\x57\x3f\x71\xdc\x1e\x92\x7e\x6f\x48\x6e\xb1\x39\x2c\x4e\x97\xc4\xa2\x15\xa7\x2d\xe0\xd4\x88\x80\x50\x6b\xf8\xa1\x2e\x95\xd4\x09\x57\x8e\xcf\x0f\x81\x59\xda\x36\xfe\xfe\x5d\xe2\xe2\xd8\x36\x07\x6c\xa8\xbb\xe2\x25\x75\xbc\x02\x79\xe8\x6d\x0e\x65\xc1\xe6\xc4\xb2\x60\xce\x95\xee\x4c\xb3\x7e\xf8\x68\xea\x07\x25\x80\x5e\x0d\x8a\xd7\x46\x46\x7c\xb3\x4b\x3e\xad\x2d\x06\x79\x3e\xf9\xf9\xd7\x9f\x4e\xd1\x76\x81\x62\xf4\x59\xed\x88\xfd\x84\xa6\x1b\x84\xa3\x79\xe7\x3d\x58\xfa\x06\xdf\x87\x68\xe4\x84\x16\x6c\x17\x4c\x54\x99\xcb\xe3\x77\x29\x9a\x53\x0c\x31\x0a\x02\x88\x51\x42\x61\x0a\x29\x6f\x1a\x4f\x81\xf6\x59\xd9\x02\xc3\xd2\x45\x31\xda\x06\x1f\x52\xfc\xe2\xe7\xef\x9b\x78\x63\xca\x91\x90\x32\x0a\x31\xfa\x94\x33\x83\x8b\x61\x80\x9a\x2f\x05\x85\x39\x36\xd2\x17\x66\xb7\x4a\xf7\x14\x79\xf8\xc5\x29\x4a\x31\x84\xee\x37\xd4\xbd\xa4\xf7\xa1\xd1\x41\x7f\x2a\x2a\x0c\x93\x5f\xe1\x14\xc5\xe8\xf7\x1c\x32\x2e\x8d\x0a\x66\x18\x43\xe2\x22\x46\x7c\x23\x64\xf4\x3d\x0c\x81\xaa\xab\xc1\x05\xe2\x72\xf1\x60\x13\xbf\xdc\x74\xa6\x2f\xfe\xf1\x13\x0a\x9e\x97\xcf\x13\x8e\x5e\x1e\xad\xa9\x1f\x9b\x9a\x7a\x4c\x1d\x0f\x7d\xe4\x5d\x03\x31\xfa\xbb\xec\xa3\x0a\x43\x11\x19\x9c\xd9\x55\x16\x91\x2a\x43\x5b\x3a\xbb\x05\xa2\x0d\xc6\x48\x7d\xac\x9a\x29\x9b\x13\xa3\xa8\x00\x9b\x2d\xf4\xf4\x12\x54\xa1\x5d\x39\xdc\x54\x4c\x37\xa1\xa0\x28\x46\xef\x81\x46\x2d\x52\x60\x36\x49\x12\xf5\x91\x2a\x8c\x93\x02\x57\x70\x98\x72\xc7\xba\x94\x0b\xca\x3e\xc8\x96\x73\x55\x1b\xeb\x0a\xc8\x0a\x19\x36\x6e\x8e\x20\xef\x7c\xf6\x10\x15\x07\x56\x85\x93\x94\x46\xa3\x9c\x24\xfe\x85\xf3\xd1\x6b\x10\xa8\x56\x39\x48\xe4\x47\xf8\x3f\x07\xd2\xff\xe9\x42\x3f\x0d\xf8\x3e\x59\xf4\x38\xdf\x87\xd1\x74\x6a\x37\x21\x8d\x7a\x6e\x82\x14\x9c\xee\xc9\xc8\xae\xea\x18\x4d\x66\x59\x07\x5c\x99\x96\x7b\x08\xb5\x4e\x68\xce\x4d\xfd\xac\xe7\xda\x70\x06\x4d\x4e\xd9\x2a\x5e\x47\x39\x34\x4b\x5c\xb7\x65\x14\xa3\x4b\x23\x9f\x42\x31\x47\xfb\x33\x3d\x55\x36\xb8\x35\x07\x99\xbf\x2c\x47\x52\x94\x68\x7e\x9c\xcc\xea\x91\x22\x68\x9f\xb4\x10\xff\x46\x56\xd2\x86\x09\xfc\x0f\x7a\x62\x9a\xf3\x78\xa0\x24\x5f\xab\x6b\x11\xa1\x5e\xe7\x6b\x9e\x62\x77\x37\xf9\x01\x3f\xce\x37\x59\x4d\x2b\x46\xbb\x14\xde\x96\x70\x29\x8f\x55\x2f\xd7\x1f\x66\xf5\xcd\x16\x07\x84\xa9\x58\x2d\x73\xfd\xde\x79\x5f\x39\x3b\x26\xf8\xe2\x76\x4f\x48\x62\xbc\x91\xba\xac\x4c\xfb\x39\x59\x4b\x8e\x7c\xab\x53\x7d\x3f\xb2\x7f\x5a\x57\x73\x38\x4f\x36\xb5\x31\x61\xdb\xd0\x58\xfe\xa1\xa3\x87\xba\x85\x90\x8e\x5f\x85\xe1\x5e\x45\x57\x13\x1b\xf8\x95\x31\x3c\xa0\xab\xe6\x8f\x4c\xbb\xe1\x03\x43\xf7\x0e\x2c\xa5\xd1\xd2\x4c\x7e\x90\x66\xb2\x7b\xcf\x11\xfe\xf7\xea\xbb\xd0\x49\xc5\x93\x66\xa0\x36\xb9\x9f\xf2\x23\xc5\x21\xa7\x53\xa3\x72\xd2\x08\x96\x66\x3c\x15\xed\xa6\x9f\x96\x3c\xf1\x98\x85\x7d\x6b\x34\x2d\xeb\x6e\x9e\x75\x84\xb0\x93\x2c\x0b\x25\x82\xd6\x4c\xb2\x9e\x52\x4d\x3b\x64\xd7\xb2\xa8\x3d\xf5\x30\xd9\x53\x71\xb6\xfe\xae\xdd\x5d\x1e\xef\xae\x71\xd2\xe8\x72\x0c\x1d\x0d\x51\x6d\x68\xcd\xf1\x05\x9b\xe3\xf5\xcd\x12\xd5\x0d\x8e\x74\x08\x99\x43\x77\xe5\x1c\x22\x0f\x57\x1c\xec\x65\x3d\x83\x35\x8b\xdc\xb4\x07\x21\xd6\x18\xa3\x02\x96\xae\x0f\x33\xd7\xaf\xf1\x39\x80\xb5\xb8\xc6\x19\x80\x50\x5b\x01\x65\xd0\xa4\x3e\x30\x97\xb6\xde\x4e\x4c\xfa\xa9\x06\xb5\x19\x63\xf5\x04\x6e\x32\x4e\x88\x4b\xb8\x97\x57\xc2\x07\xa0\x18\xea\xe3\x10\xd4\xd7\xd5\x68\xb6\x51\x5e\x15\x5d\x53\x9a\xc1\x3d\xf3\x0d\x9d\xbd\x94\xfb\xf1\xdb\x29\xf0\x75\xc1\x2a\x54\x21\x01\x4f\xc0\x9c\x63\x67\x56\x21\xdc\x55\x0f\xd6\x20\x99\xe9\xc1\x1b\x95\xbb\x31\xfa\x92\x03\x01\x0f\x43\xe4\xc6\x88\x44\x40\x60\x36\x66\xe0\x34\xad\xbc\x8a\xa1\x16\xb5\x93\x37\x4d\x8e\x40\xe1\x26\x28\x43\xd6\x73\x14\xf9\x9c\x63\x86\x7f\xf0\x6b\xf8\x8d\x45\x09\xa9\x19\x4e\x78\xc5\xe7\x0a\xbd\xc3\x8f\x90\x19\x00\x4a\x05\xb2\x2e\x2f\x13\x52\x63\x75\x0c\xab\xe3\xb2\xa7\xf3\x61\x57\xe7\x75\x94\x0f\xe7\x10\x25\x7c\x6f\x54\x68\xbb\x56\x57\x83\xf1\xf1\x97\x2b\xab\x49\x99\x6a\x3b\x25\xf4\xcc\x9b\x8f\x31\x2d\x4b\xb8\xa7\xde\xdc\x49\xfa\xd6\xe4\xa8\xbc\x3c\xc8\x8a\x03\xd5\xb9\x42\x65\xae\xdd\x12\xbd\xca\x21\x04\x02\xec\x13\xa6\x39\xb9\x7b\xcd\x7e\xbb\x64\x3f\xa6\xe3\x74\x47\xd7\x18\x56\xfb\x2c\x54\x73\xdd\x60\x97\x2a\x10\x91\x4b\xdc\x62\xef\x95\xd4\x37\xc1\xdd\xdc\x2d\x51\x16\x35\xdc\xcd\x98\x5e\xcf\x05\x77\xf3\xd1\xdc\x35\x3a\xfc\x20\x57\x85\x99\xab\x93\x06\x23\x46\x30\x76\xe7\x96\x68\xa9\x31\xe6\xb7\x60\x64\xe0\xcc\xbd\x13\x4c\xde\x8d\x66\x52\xfb\xde\x39\x7b\x90\xcf\x54\xe3\xf3\x41\xe3\xdb\x1a\xe5\x6a\x10\xb7\x14\x84\x99\xe5\x38\x72\x4b\x14\xa6\xb0\x1f\x43\x8c\xa2\x14\xec\xb8\x3c\x61\x73\xba\x0d\x77\xfc\xe6\x4d\xf6\x48\x60\xb6\x9e\xd5\x7f\xf3\x0b\x95\xf8\x03\x0c\x5e\xdb\x0f\x55\x39\x16\xd2\x04\x7b\x6d\xec\x12\x3f\x45\x8b\x50\x2e\x44\x72\x92\xb6\x32\xea\xfc\x14\x5d\xab\x77\xa4\x03\x87\xe2\xa7\x28\x0f\x7b\xe9\x16\x59\xaa\x47\x7a\xe5\xa8\x6d\x9d\x52\xb7\x16\xcb\x92\x5a\x73\x62\x65\x29\xb1\xb2\xd0\x7a\x26\xf8\x79\x06\xd6\x33\x59\xfd\x33\x2b\x2b\xac\x67\xb2\xbe\x67\xd6\x7c\x49\xad\x1b\xaf\x7c\x66\xb7\x43\xab\xcf\x26\x36\x1b\x94\x15\x94\xcc\xbe\xbe\xf6\xfe\xb0\xbf\x3b\xf6\x9f\xe0\xa7\x28\x08\x99\x50\xd2\x14\xbc\x48\x0a\xa7\x14\x87\xe6\xcf\xf8\x6a\x39\x6c\x95\xff\xa1\xbf\xfa\x29\x4a\x42\xd5\x23\x71\x20\xbb\x43\xfc\x59\x43\x01\xd4\x4f\x53\x23\x00\x93\x9f\x72\x44\x32\x9b\x07\xc3\x2b\xc8\xd9\x9f\xfc\x7b\x85\x13\xc0\x5b\x81\x9b\x96\x71\xf8\x03\x1b\xde\x78\xf5\x43\x81\x6f\xd0\x7a\x54\xa3\x17\xb4\x9e\x2e\x6a\x58\x80\xcb\x14\xc5\x51\x8b\x2c\x4f\x86\x2c\x23\x8c\x21\x61\x02\xbb\x4e\x3b\x8b\xf5\xba\x4c\x37\x14\xc7\x74\x32\x30\x7f\x12\x78\xd4\xb3\xfb\xd3\x8d\x5d\x5f\x35\xd7\xa3\x26\xc8\xe5\xe3\xc8\x89\xfa\x2f\x53\x14\x32\xb6\xa3\x75\x3e\x0a\x23\x0c\xd7\xc6\xe5\xdb\x47\x32\x22\x5a\x2e\x46\xe3\x6c\xea\xd0\x54\x1d\x48\x1b\x19\x2e\x97\xe3\x56\x7d\xca\xff\x1c\xfb\x6d\x6d\x16\x66\x53\xe7\xef\x04\xd1\x89\x7c\x60\x3c\x51\x52\xc1\xe2\xf1\xed\x8b\x83\x86\xc5\x38\x18\xcb\x9f\xa6\xf2\xea\xe3\x06\x10\x63\x74\x3a\x81\x54\xfb\x9a\x82\x44\xc8\x18\xf9\x7d\x33\x40\x04\x81\x1d\x4f\xe4\x2b\x49\xd0\x90\x91\x54\xd4\x88\xd2\x68\x28\x10\x91\x91\x14\x9a\xa1\xc6\x5c\x10\xc2\xfd\xce\xeb\x08\xa8\x1e\x30\x35\x65\x52\xb3\x8e\xbb\x1c\xde\x61\x4c\x22\xbe\x27\x7e\x5b\x80\xfd\xa2\x9b\xeb\x43\x87\x47\x9a\x61\x10\x16\x93\x38\x30\xa8\xcd\x96\xbe\x8b\x41\xe0\x8b\x87\x62\xb4\xe7\x71\x88\x68\xbe\x53\x3c\xef\x6f\x9d\x8a\xd8\xd5\xb6\x8f\x16\x11\x2a\x30\x86\xf4\x11\x0c\xf6\xed\x4a\xc3\xca\x17\x0f\x79\xe8\xdc\x63\xce\x2b\x04\x11\xe7\xe2\x6e\x58\x42\x3f\x46\x38\x23\x25\x73\xc1\xb8\x8a\x22\x21\x9a\xb3\x1f\xc1\x94\x36\x9b\x36\xa2\x29\x4a\x64\xba\xe6\x63\x98\xa5\x5c\xb2\x74\x13\x0d\xdc\x05\x5c\x18\x21\x53\xb6\x83\xa0\x0e\x09\x77\x37\xc4\x49\x2b\xfc\x5b\xc7\xc1\x86\x62\xd4\x17\xa1\x21\xaf\x58\xdf\x08\x39\x55\x03\x55\xc3\x67\x01\xdf\xbd\xf5\x10\x91\x63\x4d\x1a\x47\x58\xb2\x87\x59\xeb\xc2\x71\x15\x0f\xf5\xd0\xc5\x10\x56\xaa\x45\x37\x8a\x0a\x83\x0f\x4b\x7e\x91\x84\xfd\xee\x6b\xf7\x68\x6c\xea\x5e\x79\xf2\xb4\x81\x5c\x42\xaa\x03\xb4\x12\x88\x8f\xb1\xe4\x90\x49\xb0\x2c\x38\xc8\x89\xe0\x47\x1d\x0d\xeb\x3d\x47\x5a\xf0\x46\x5b\x5f\xc8\x66\x3a\x31\x7a\x13\x42\x06\xa4\x31\x46\xa0\x08\x88\x77\x33\x68\x48\x76\x64\xb5\x2f\xcc\x11\x97\x54\x29\x24\xb5\x14\x92\x52\xc4\x94\xac\xb8\x00\xcb\xff\x52\x59\x89\x6e\x17\xd2\x28\x41\xa9\xc1\x1a\x72\xda\x93\x8f\x85\xa4\xc2\x95\x92\x4a\xdc\x43\x0f\x85\x18\x82\x35\x25\xf5\x9c\x49\x6a\x09\x49\x2d\x08\x5d\x58\x2f\xf7\xa5\x94\x9c\xb6\x12\x8f\x68\x70\x30\xd8\xe0\xd0\xd4\xe0\x0b\x2f\x89\x19\x99\xb3\x78\x41\x8c\x83\x55\x53\xbc\xc3\x10\x6e\xbd\x96\xe6\xd5\x15\x1f\x86\xf0\x2d\x34\x48\xc7\xc8\xcb\x61\x08\x87\xde\xb0\xf4\x77\xeb\xe9\xdf\xc4\x4f\xed\x09\x88\x46\xf1\xae\x21\xba\x7f\xd0\x69\xd8\x78\x6a\x87\x21\x1c\x85\x46\x5a\x92\x2f\xe9\x52\x18\xe9\x88\x77\x6d\x9e\x94\xc7\xd1\xe5\x68\x14\x9d\x9a\x9b\x0e\x15\x11\x9c\x6a\x65\xdc\xe4\x2d\x50\xaa\x07\x2c\x2d\xdf\xdb\xcd\x35\x83\x8b\x79\x7e\x45\xfe\x7c\x0a\x9d\x2c\xac\x7e\xfa\xcc\x31\x73\x57\x9d\xc8\xf5\xd0\x22\x10\xad\x34\x5e\x2b\xd4\xc4\x76\xf9\xee\xb2\x92\xc9\x14\x94\x8b\x8b\x2b\xbd\xae\x95\x8c\x47\x5d\xe9\xfd\x45\x56\x84\x58\xff\x0a\x23\x2d\x89\x5c\x70\x37\x7c\x1d\x3e\xc4\x0d\xc6\xba\x4c\xa4\xef\xfe\x03\x84\xf2\x58\x6e\x94\x75\x59\x93\x05\xb5\x86\x67\x3a\xb8\x46\x9d\x72\xb5\xe1\xa4\xfc\x16\xe7\xb5\xaa\xac\x2a\x0c\x5f\x23\xf7\x98\x4e\xb2\x25\xbd\xcc\xe2\xf4\xf2\x7d\x56\x50\x64\xe7\xa4\x28\xe3\x92\xee\xb5\x12\xf0\x6d\xe3\xc6\x6c\x85\xe1\x34\x32\xde\x80\x21\xfc\x87\x7a\xff\x39\xd3\x3d\x1a\x61\x45\xd4\x71\x0a\x47\xec\x73\x7f\x0a\x51\x31\x09\xb3\x62\x81\x5b\xb0\x19\xbe\x36\xdf\x2d\xc7\xee\xf4\x17\x70\x5f\xaf\x66\x9d\xab\x78\xcd\xfd\xd9\x8b\x04\x7d\xae\xf7\x67\xe7\x11\xa4\xe6\x4b\x4c\xbe\x46\x68\xa9\x99\x37\x93\xd7\x98\x15\x70\x92\xc0\x27\xda\x2a\x68\x4c\x5d\xae\xd6\x6c\xd4\x6e\x8c\xec\xdd\x6c\x99\x04\xfc\x2c\x78\xb9\x9c\x2f\x62\x6a\xd1\x88\x58\x4c\x82\xa0\x8e\xaa\x58\x71\xc9\xdf\xdf\x11\x6a\x5d\x33\xed\x9e\xd8\x18\x58\x09\xe7\x55\x2d\xed\x6e\xd0\x46\x7c\x29\xba\x48\xe5\x20\x66\x4c\x11\xcb\xee\x9c\x4c\xdd\xd9\xf0\x36\x7f\x6b\x83\x97\xc0\xd0\xd5\xf2\x72\x43\x9f\xd5\x8f\xc6\x6c\xcc\xb7\x84\x20\xe3\x58\xa5\x64\xfd\x98\xa8\x1d\xea\x83\x22\x5b\xd4\x68\x8b\xc3\x1b\x81\x85\xd8\x55\xcc\x8a\x01\x2d\xf0\xd0\xdf\x43\x7e\x95\x98\x48\xa5\xe3\x1a\x71\x42\xf0\xca\xea\xb6\xd3\x40\x9f\xfd\x0d\xb5\xde\xf3\x0e\xf0\xd0\x6f\x3a\xed\x6c\x32\xfb\x19\x83\x8c\x39\x1c\xc4\xd0\x34\xf2\x20\xae\xfa\x51\x8e\x7a\xec\xac\x6e\x9b\x87\xee\x98\xfa\x66\x03\x76\xe4\x22\x41\x1f\x85\xa2\xe3\x76\xef\xf3\x3a\x4c\xf1\xed\x6c\x54\x7c\xbb\x00\xd1\xc6\xdf\x43\xa4\x2e\x62\x53\x3b\xb8\x59\x01\x67\x6c\x40\x5c\x24\x28\x4d\xd8\x72\xc8\xb4\x4e\x2f\xba\x29\x09\xd7\x71\x2d\x6b\xe5\x45\x6a\xe6\xa2\xe3\xfb\x86\xa3\x18\xac\xc3\x3b\xab\xf7\x96\x2f\x12\x44\x92\x56\xac\xa6\xb1\xa6\x65\x9d\x74\x7d\x1d\xa0\x90\x35\x54\x9f\xf1\x07\xda\x66\xe0\x81\x8f\x65\x2f\xe5\x23\x35\x88\xcb\x3c\xf1\xee\x2c\x4f\xa1\x78\x6e\xcb\x5b\xb2\x1e\x3f\xa2\x39\x05\x1e\x47\x28\xa5\x28\xc7\xc4\x4d\x1a\xf6\xb2\xf5\x72\x6a\x45\xd7\xc7\xe8\x26\x12\x7a\x27\x99\x7a\x40\xb7\xd9\x5c\x74\x1b\xb9\x86\x64\xbe\x8f\xcd\xe4\x42\xd6\xcb\x7f\x35\x0e\x6b\x71\x4e\x8e\x54\xa6\x2b\x25\xd4\x19\xba\x0a\x89\xd4\xd8\x0a\x76\xa2\xce\x71\xf1\x45\xd8\xb7\xf3\xd7\x86\x67\x79\x6f\xa5\x5d\x55\xb0\x3d\xb4\x4d\x13\xa3\xdb\x88\xdf\xe7\xa2\x2c\x20\xf5\xe6\x4e\xa1\x04\x55\x3a\x04\xfc\x6c\x99\x52\xe7\x0b\x22\x7c\xd6\x3e\x5e\x1d\x32\xa6\xc6\xfc\x15\x75\x50\xbe\x35\xb8\xc7\xd9\x5a\xe6\xf2\x7e\xf3\xcc\xa9\x0b\x9f\x61\x3b\x42\x14\xc3\x4e\x84\x2b\xf0\x9b\xb1\x6e\x34\x58\xa3\xd2\x55\x0a\x3d\x80\x26\x23\xb8\x85\x06\xac\xdf\xc8\xe5\x2a\x06\x33\x66\xac\x8a\xc9\x7a\xe8\x2c\x62\xeb\x7b\xb8\x09\x95\x89\x93\x85\xf7\x48\x49\x8b\xec\xee\x61\x43\xda\x12\x87\xb9\xb2\x43\xc4\x93\x78\xe2\xa0\xdb\x74\x73\x25\x56\x8c\x8e\xe8\x1f\xf6\x13\xfb\x4f\x30\xca\x7a\x75\xab\xda\x7a\xe6\xa1\x4b\xd6\x40\x9e\xb0\x72\x87\xce\x42\x93\xa3\xe2\x4f\x66\xd3\xf6\x7c\x9c\xea\xb3\xb0\xcd\xa7\xdf\xa1\x73\x39\xc6\x28\xe9\x52\x44\x49\x07\x09\x02\x11\x1c\xb5\x7a\x6d\xe6\x2e\xf9\x3c\xc4\x7e\x8c\x09\x02\xb6\xd4\x60\xa6\x99\xe9\xbb\x10\xc2\xb5\xe2\x7c\x85\x88\x01\xfb\xdd\x10\xdf\xc9\xf0\xde\x20\x35\x6e\xc5\xad\x3d\xf7\x12\xe1\xc3\xef\xd7\xda\xf7\x57\x8d\x71\xda\x8f\x63\xff\x1b\x14\xfa\x49\xb7\x0e\xdd\x2f\x20\x81\xcd\xcf\x57\x69\x6e\x41\xda\x1c\x56\x6b\xf6\x0d\xd7\x75\xd5\x9d\xa3\x18\x65\xf5\x3c\xd1\x9a\x98\x4f\x42\x31\xfb\x92\xa1\xd9\x57\x3b\xd0\x82\xa1\x93\xaa\xf0\x44\xa4\x0e\xac\xe7\x62\x73\x41\x37\x73\x56\x47\x1c\xaf\xd3\x98\x6a\x27\xac\xff\xa2\xb0\xa7\xca\x56\x75\x14\x66\x2d\x05\x7f\x80\x78\x6b\xf8\xb7\x5d\x70\x0e\x86\x8d\xf9\x80\xd8\x67\x0b\xcf\x24\x85\xd3\x64\x20\xc0\x2d\x51\x11\x65\xf4\xf4\x48\x86\xc8\xbf\x0e\x15\x57\xd1\xc9\xe6\x09\x07\xfc\xe2\x91\xce\x7d\x1e\xe9\xdc\x8d\xdc\x00\x79\x29\xdc\x28\x12\x02\x93\x59\xff\xa4\x86\x1a\xee\x3d\x3c\x2f\x49\xa1\x3f\xac\x81\x61\xf5\x87\x0a\xf0\xb4\x15\xa7\xd7\x8a\x61\xb8\x8a\xdc\x10\x95\x29\x9c\x29\x1e\x04\xa6\xce\xa7\xed\xa3\x43\xfd\x23\x01\xf9\x63\x20\xf3\x3a\x0d\x33\x1b\x76\xa3\x3a\xc8\xac\x43\xfb\xd8\x90\xa7\xe8\x88\xb7\xf5\x20\x72\x45\x01\x11\xfd\xbc\x8a\x30\x1c\xae\xf0\x08\x46\x07\x4c\xcc\x21\xe0\x4a\xc4\x7c\x2e\x3c\x20\x70\x10\xb5\xa3\x12\x05\x7c\xf1\x50\xca\x83\x11\xaf\x57\xd9\x40\xe9\x59\xb3\x95\x8e\xa8\xa4\xd9\x5a\x7e\x48\x1d\x05\x40\xe1\x7d\x83\x34\x24\x4c\xd7\xca\x34\x57\xb9\x1e\x3b\x64\xc3\xc0\xe0\x6b\xec\x25\x68\x3b\x91\xcb\x95\x0a\xc3\xbb\x21\xd9\xf1\x2b\xbd\xf9\x8d\x56\x73\xaf\x24\xef\x3d\x1a\xf1\x0b\xbc\xbd\x3c\x3e\x2f\x12\x58\x36\xb6\x7d\xa9\xdb\xf6\x63\xef\x3a\xbe\xf4\x28\x39\xcb\xf4\x14\x32\x39\x69\x25\x6e\x88\x66\x11\x64\x21\xa4\x1a\x1e\xc2\x0c\x7c\xc8\x30\x88\xdc\x39\xc8\xd9\x8f\x31\x13\x5b\x2a\xad\x39\xa3\xe1\x04\xc0\x4f\xe1\x3a\x1f\x13\x34\xc3\x32\xd5\x4c\xcd\x76\xb9\x5a\x69\xd6\xac\x69\xb0\x0b\xb6\xdc\x29\xe2\xfc\x5d\xbb\x21\x3a\x8e\xe0\x8c\xf1\xa7\x81\x2f\x00\xf7\x0d\xb0\xc8\x5d\xda\x14\x99\x4c\x23\x39\xd4\xa8\x38\x97\x92\xc7\xdf\x13\x14\xd5\x3c\xea\xc9\x43\xe7\x09\xe4\xb8\xcf\xac\xd0\x99\x11\xf6\x2b\x85\x7b\x51\xc3\xb7\xa4\xbb\x50\xdc\x4b\xd0\x4e\xd2\x24\x7e\xf5\x44\x21\xec\xaf\x48\x8e\xe2\xa2\xb8\x73\x3d\x74\x12\xc1\x71\x88\xe6\xb8\x91\x06\x2b\xc6\x24\xf1\x55\x64\x22\xe5\x63\x33\x91\x6a\xce\x5e\x25\x8c\x9e\x46\xcd\xf9\xaa\x09\xe0\x83\x59\x00\x2d\xd0\x0b\xc1\xe5\x29\xe7\x72\x9d\x9a\x3f\x25\xe8\x54\x5f\x3f\x9b\x57\xa9\x31\xa2\x09\xa4\x3d\xd4\x0c\xb6\x70\xfd\x44\xd1\xe9\xb0\x00\x15\x78\x86\x60\xef\x76\x6d\xf6\xde\x26\xe8\xd6\xb4\xbc\x2f\xd8\x73\x53\xc7\x29\x30\xab\xb5\x14\xe3\x73\xd2\x3b\xff\x10\xc4\x05\xf1\xa9\x1a\xac\x83\xb4\xd2\xde\xf4\xd7\x4a\x92\xc5\x9d\xc3\x09\xfc\x02\x37\x2e\x8a\x1d\xa1\x4f\xdb\x6e\x2a\xbd\x58\x38\x76\xf9\xf2\x72\x5e\xa0\x1d\x5c\x27\xfd\xee\x8c\xd9\xb6\x4a\x95\x2f\xdb\x3c\xda\x96\xfe\xcb\x71\xd5\x5d\x35\x1c\x67\x59\xfe\x50\x83\x3a\x59\x8c\xed\xa1\x66\x79\xe8\x75\x04\x9c\xfb\x14\xfc\x96\x23\xbf\xad\x0c\x8f\x68\xe3\x89\xb0\x6b\xa2\xa8\x66\xd9\xea\x26\x4b\x03\x77\x22\x06\xcd\xc9\x63\x0c\x5c\xdb\x96\x49\x7e\xbb\x76\x6c\x5f\x18\x30\xc9\x88\x6e\xc2\x6a\x56\xa4\x25\xdb\x17\xac\xec\x3f\xce\x92\x0d\x18\xad\x16\x57\x8d\x49\x39\x12\xb6\xa4\xcd\x55\x63\x4a\x8e\x04\x2b\x47\xeb\xb2\xb2\xd2\x7c\xb4\x58\x61\x83\x53\xb0\xb2\xeb\x96\xe8\xb4\xcb\x0a\x7b\x2d\xe4\x72\xe0\xee\x0a\x66\x76\xd7\x65\x86\xd1\x70\x0e\xda\x9d\xb4\xa3\xa1\x59\x1c\x66\x5e\x30\xee\xc0\x45\x0a\xf7\x3a\x0c\x86\xb3\x34\x9d\x88\xd2\x41\x31\xd6\x22\xdd\xc6\xd3\xe8\x10\x1f\xef\x2a\xa7\x70\xdf\xb6\x91\x6d\x4a\xcc\xb1\x78\x13\x99\x20\x99\x02\x44\xb1\x19\x90\x69\x08\x0a\xe9\x20\x41\x7d\xc4\xa4\x3e\x22\xd3\x3b\x53\x31\x33\xa4\xd1\xeb\xa1\xa2\x3d\x4c\xa5\xc3\x56\x49\x13\xba\xd3\xfb\x36\x2d\x03\xaa\xd4\x55\xb2\x0a\x0f\x69\x37\xe9\xa6\x9d\xbe\x49\xaa\x0a\xde\x0f\x7b\xb4\x6f\x28\xd8\x36\xc4\x68\x99\x4a\x47\x39\xe8\x44\x98\x98\x67\x4d\x65\xae\xd2\x1b\x0a\x4f\xa6\x7a\xe1\xbc\xc8\x82\x25\xa7\x2a\x32\x70\x59\xc1\xcc\x7d\xe7\xa1\xf4\x65\x31\xc9\x3d\x1a\x89\xc3\x37\x11\xa5\xb9\xf3\xe2\x45\x92\xf9\x5e\x12\x65\x25\x75\xfe\xb9\xf9\xcf\x7f\xbc\xb0\x31\xf8\x6e\xbb\xe0\x0b\x9b\xb9\x82\xe2\x36\xad\x7e\x64\x63\x69\xbc\x41\xb1\x25\xc7\xd5\x9d\x4f\xd9\x34\xda\x11\x10\x29\x2b\x2d\xe7\x20\x46\xef\x22\x78\x13\x31\x06\x8e\x13\x74\x19\x62\x74\x1b\x62\xf4\x36\xc4\xc8\x0b\x31\x5a\x62\x34\xc3\xe8\x36\xc1\xa8\x61\x1a\xa3\x0c\x23\x1f\xa3\xab\x58\xfc\x4f\xb8\x07\xbf\xc7\x96\x15\xc5\x12\xde\x44\x70\x1f\xa7\x31\x75\xde\x47\x20\x94\xdd\x79\x17\xc1\x35\xb3\x35\xbf\xe5\x50\x2e\xe7\xf5\x6d\xb3\xa5\x73\x87\x0e\x28\xae\x30\x22\x29\x86\xf3\xc8\xbd\xaf\xb6\xe2\x10\x9d\x47\x93\x23\x2f\x4e\x5d\xf9\xf3\xfb\xf7\xfb\x0a\xae\xb3\x38\xb0\x36\x9f\xb8\xee\x5e\xf4\xf4\xe9\x5e\xa4\xca\x80\xcd\xfe\xb5\xe5\x6b\x0c\xb6\x12\xa0\xed\xba\xf4\x2e\x27\x59\x68\x05\x24\x8c\x53\xf2\xf4\xa9\xf8\x39\xf1\x16\x01\x16\xbf\xa2\x3f\xfe\xec\x5f\x74\x6f\x9d\x47\x15\xde\x22\x49\x49\xac\x38\x44\x76\x36\xff\x42\x7c\x6a\x3f\x51\xc4\x16\x59\xb0\x4c\xe4\xc2\xe4\x22\x72\x69\x14\x97\x93\xfd\x64\xc1\xb8\xae\x39\xbc\x88\x70\x98\x15\x88\x15\xf9\x10\x59\x31\x23\xc9\x4f\xb3\x8b\x3f\x2e\x22\x4c\xa3\x22\xbb\xb1\x52\x72\x63\xed\x17\x45\x56\x20\xfb\x2c\x22\x05\xb1\xbc\x82\x58\xf4\x26\xb3\xf6\x93\x85\xac\xa7\xb4\x7c\x2f\x49\x48\x60\xfd\xcb\x7e\xfe\x21\x7a\x6e\xff\xcb\xca\x52\x71\xab\x5d\xee\x5d\x92\x27\xd6\x09\x61\xbd\xa1\x72\xa7\x69\x44\x16\x13\x1b\x6f\x5d\x44\x7f\x7c\x88\xfe\x74\xcf\xf9\x8f\x8a\x37\x45\xf1\xe9\x9e\x47\xe2\x81\xa0\x3f\x21\xb7\x79\x56\xd0\x92\x3d\xc6\x13\x56\x17\x62\x25\xf1\xd6\xff\x05\x00\x00\xff\xff\x74\xa0\x08\xe0\xce\xea\x02\x00") + +func uiAppScriptJsBytes() ([]byte, error) { + return bindataRead( + _uiAppScriptJs, + "ui/app/script.js", + ) +} + +func uiAppScriptJs() (*asset, error) { + bytes, err := uiAppScriptJsBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "ui/app/script.js", size: 191182, mode: os.FileMode(420), modTime: time.Unix(1, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _uiAppIndexHtml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x84\x53\xc1\x6e\xdb\x30\x0c\xbd\xf7\x2b\x58\x5f\xe2\x60\xb6\x8c\xde\x86\xce\x0e\x30\xb4\x3d\xf4\x30\x6c\xc0\x7a\xd9\x91\x91\x68\x5b\xab\x2c\x19\x22\xdd\xa0\x28\xfa\xef\x83\xec\xa1\x89\x33\x04\xd3\x25\xa2\x48\xbe\x3c\xbe\x67\xd6\xd7\xf7\xdf\xef\x9e\x7e\xfd\x78\x80\x5e\x06\xb7\xbb\xaa\xd3\x0f\x38\xf4\x5d\x93\x91\xcf\x76\x57\x00\x00\x75\x4f\x68\x96\xeb\x1c\x0e\x24\x08\xba\xc7\xc8\x24\x4d\x36\x49\x5b\x7e\xce\xce\xd3\x1e\x07\x6a\xb2\x17\x4b\x87\x31\x44\xc9\x40\x07\x2f\xe4\xa5\xc9\x0e\xd6\x48\xdf\x18\x7a\xb1\x9a\xca\x39\x28\xc0\x7a\x2b\x16\x5d\xc9\x1a\x1d\x35\x37\x05\x70\x1f\xad\x7f\x2e\x25\x94\xad\x95\xc6\x87\x53\x78\xb1\xe2\x68\xf7\xd5\x51\x94\x01\x3d\x76\x14\xeb\x6a\x79\x5b\xc8\x56\x47\xb6\xf5\x3e\x98\xd7\x93\x56\xd6\xd1\x8e\x72\x7c\x48\xa7\xaa\xe0\xb1\x05\xe9\x29\x12\x58\x06\x1f\x40\x22\x5a\x67\x7d\x07\xec\x90\x7b\x40\x49\x59\x20\x6f\x20\xcc\x85\x30\xa2\xf4\x60\xfd\x7c\x9f\xa2\x2b\xce\xf1\xd0\x18\x08\x9e\x14\x3c\xf5\x96\x81\x3c\x4f\x91\x18\x90\x99\x84\xc1\xd9\x67\x82\x85\x88\xfa\xcd\x80\x91\xc0\x05\x34\x64\x60\x8c\x61\xa4\xe8\x5e\x57\x70\xb6\x85\xfc\x60\xbd\x09\x07\xe5\x82\x46\xb1\xc1\xab\xf4\xff\x49\x5f\xc5\xd3\x9e\x25\xe6\xe5\xcd\x16\xae\x1b\xd8\x54\x9b\x2d\xbc\xad\xba\xd3\xb9\xd4\x0d\xcd\xe5\xd4\xa7\x04\xf6\xe5\x1f\x28\x1d\x3c\x07\x47\xca\x85\x2e\xdf\xa0\x49\xa4\x67\x8d\x36\xdb\x75\xed\xfb\x51\xf2\xea\x5c\xf3\xbf\x26\x00\x47\xdd\x64\x1f\x3a\x64\xbb\x8b\x95\x6b\xbb\x5e\x30\x02\x8e\x23\x34\xf0\xe0\x06\xf5\x0d\xad\x57\x34\xec\xc9\xe4\x26\xe8\x69\x20\x2f\x2a\x79\x5e\xc0\x5b\x92\xd3\x4c\x3a\xcd\x75\x0b\x12\x27\x2a\xc0\x50\x8b\x93\x93\xbb\x48\x28\x21\xde\x9e\x8e\xef\x7e\x4a\x88\xd8\x91\xea\x48\x1e\x85\x86\x7c\xb3\x2e\xde\x6c\xe1\xfd\x6c\x48\x1c\x47\x95\xbe\x6d\x56\x23\x45\xb6\x2c\xf7\xab\x8e\xd9\x1c\x1d\xed\x9e\xf2\x76\xf2\x33\x8f\x3c\x69\xfb\x1f\x8b\x3e\x88\xf0\x05\x22\xc5\xbc\x5a\xe7\x82\x9f\xc4\x6b\x21\xeb\x6a\xd9\x81\xba\x5a\x16\xfc\x4f\x00\x00\x00\xff\xff\x28\x2e\x82\x1a\xf1\x03\x00\x00") + +func uiAppIndexHtmlBytes() ([]byte, error) { + return bindataRead( + _uiAppIndexHtml, + "ui/app/index.html", + ) +} + +func uiAppIndexHtml() (*asset, error) { + bytes, err := uiAppIndexHtmlBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "ui/app/index.html", size: 1009, mode: os.FileMode(420), modTime: time.Unix(1, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _uiAppFaviconIco = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xcc\x5b\x09\x90\x54\xc5\x19\xee\x75\x51\x52\x49\x2a\x50\xb1\xd4\xc4\x4a\x0a\xa2\x52\xae\x8b\xe2\x62\x84\x12\x63\xc4\x44\x4a\xc5\x83\x63\xb9\x2f\x05\x05\x01\x21\x20\x82\xa0\x08\xb8\x01\xc1\x8b\xa0\xd1\x35\x8a\x28\x02\x1e\x1c\xde\x8b\x88\x68\x8c\x8b\x80\x1a\x4e\x2f\x64\x41\x81\x15\x99\x99\x9d\x6b\x67\x76\x76\xae\x9d\x99\x37\x5f\xea\xef\xe9\x1e\xde\xbc\x9d\xf7\x5e\xcf\xb0\x5a\xf9\xaa\xfe\x7a\xbb\x33\xaf\xbb\xff\xee\xfe\xef\xee\x61\xac\x84\x95\xb2\x8e\x1d\xe9\xd9\x99\x4d\x6a\xc7\x58\x4f\xc6\x58\xe7\xce\x99\xff\xd7\x75\x64\x6c\x65\x3b\xc6\x2a\x2a\xc4\xff\x5d\x18\xbb\xe6\x0c\xc6\xca\x18\x63\x1d\xe9\x3d\x96\xf9\x9c\xa3\x1d\xb3\x04\x80\xf6\x00\xfa\x02\x58\xa7\x69\x38\xee\x0b\x68\x49\x7f\x50\x4b\x6a\x1a\x8e\x01\x78\x09\x40\x1f\x00\xa7\x99\xb4\xfd\x2d\x80\x6a\x00\x81\x58\x4b\x1a\xcf\xbe\xd6\x8c\x01\xd3\x3d\x18\x38\xc3\x83\x55\x6f\x87\xd1\x92\x48\x03\x80\x1f\xc0\x3f\x00\x9c\x91\xa7\x6d\x0d\x04\xea\x8e\x26\x30\x66\xae\x0f\x95\x33\x3c\x9c\xc6\xce\xf7\xe1\xc8\xf1\xa4\xfc\x9a\x3a\xda\x20\xfb\x20\x7e\x00\x3c\x49\x5f\xa4\x34\x60\xe3\xd6\x28\x1e\x7f\x29\x84\x07\x9f\x6f\xca\x21\xfa\x6c\xf3\xf6\x28\xb4\x74\xb6\x8f\x87\x01\xb4\x03\x70\x3d\x80\x46\xfa\x30\x91\x4c\x63\xd1\xb3\x41\x0c\xbe\xcb\x8b\x61\x77\xe7\xd2\xa0\xbb\xbc\x78\xe4\x85\x26\x3e\x86\x80\x1b\xc0\x55\xb4\x56\xf2\x83\xe6\x48\x1a\x6b\x37\x87\xf1\xd4\xba\x10\x9e\xde\xd0\x9c\x43\xf4\xd9\xfa\x2d\x11\x44\xa2\x69\xe8\xb0\x02\xc0\x0f\xf2\x9f\xd5\x35\x61\x5c\x3a\xdc\x85\x8a\x21\x4e\x74\x1d\x98\x4b\x97\x0c\x73\xe1\x8f\xc3\x5d\x78\xe5\xdd\xb0\xbe\xfd\x41\x00\x49\xc9\xfb\xbb\xdb\xa2\x78\xf3\xc3\x08\xfa\x4d\xf3\xa0\x7c\xa0\x13\x17\x56\x66\xa8\x7c\x80\x13\x93\x16\xf9\xf9\xda\xd0\x3b\xc9\x54\xb6\x7d\x48\xb6\x97\xd8\xb5\xbf\x05\x3d\x46\xba\xd0\xb5\x32\xb7\xfd\x8d\x53\x3d\xf0\x34\xa6\x60\x00\xb5\x3f\xa6\xff\x60\xc7\xbe\x38\xba\x0f\x33\xb4\x1f\xe8\x44\x9f\xdb\xdd\x70\xb8\x5b\xb5\xaf\x03\xf0\x8a\xfe\x83\x1f\x1a\x52\xb8\x76\x92\x1b\x17\x0d\xca\xcc\xfb\xb2\xd1\x2e\x74\x1f\xea\xc2\xad\x0b\x7c\x88\xc6\xd2\xc6\xf6\xcb\x01\x5c\x0b\xc0\x27\x3f\xa0\xfd\x99\xfb\x44\x00\xe3\xab\xfc\x7c\xcd\x06\xcf\xf4\x72\xde\xdf\xf8\x30\x62\x6c\xeb\x02\x70\x25\x80\x53\x01\x3c\xa6\xff\x82\xd6\x88\x64\xe5\xea\x09\x6e\x3c\xb4\xb2\x09\x8f\xbd\x18\x82\xc3\x93\xc3\x3b\x31\xb2\x18\x40\xa9\x90\xc1\xb3\x00\xbc\x2e\x3e\x47\x24\x96\x86\xb7\x51\xc3\xcd\xf7\xf9\xb0\x7b\x7f\x0b\xbe\x77\x26\xf5\xbc\x93\x04\xbd\x0c\xe0\x74\x83\x0e\x9c\x09\x60\x99\xd0\x11\xbe\x47\xaf\xff\x3b\x02\x7f\x50\xd3\x8f\xeb\x01\xf0\xa0\xb1\xad\xae\x8f\xd3\x84\x8e\xae\x01\x70\xa4\x25\x91\x8e\xa6\x34\xd0\xc4\xbf\x03\xf0\xbc\x90\xd7\x53\xf5\x6d\xe2\x9d\x18\xab\x6f\xcf\x58\x6d\x29\x63\x55\x25\x19\x32\x83\xfc\x9e\xde\xa5\x36\xd4\xb6\x4c\xd8\x98\xab\xf4\x76\xa6\xa3\xb5\x9d\x31\x83\xd0\xc7\x72\x00\xd3\x00\xbc\x01\xe0\x90\x90\xb1\x94\xa0\x20\x80\x03\x42\xe7\x26\x02\x38\x4f\xee\xc1\xc9\x40\x8c\x7b\x19\x80\x67\x00\xd4\x8b\xb1\x38\xc8\x6e\x35\x36\x69\x08\x84\x34\x24\x93\x39\xf2\x97\x00\xf0\xad\x90\x9d\x0a\x00\xa7\x14\x39\xf6\xef\x84\x4d\xf4\xea\x3b\x8f\xc6\xd3\xa8\xa9\x8d\x62\xca\x12\x7f\xc6\x8e\xde\xe9\xc1\x8c\x47\x1a\xf1\xc1\xa7\x31\x69\x4b\xf5\x70\x00\xa8\x32\xda\x55\x85\xb1\x69\xce\x3b\xa4\xdc\x4a\x90\xfd\x26\xb9\x27\x3b\x54\xd6\x3f\xa3\xff\x44\xf4\x37\xd9\x27\xb2\x67\xc9\x56\xaa\xcc\xe5\xfa\x3d\x00\x17\x2a\x8e\xdd\x47\xac\x5f\x2b\xbc\xff\x49\x0c\xdd\x06\x67\xc6\xbb\xc0\x40\xe7\xf7\x73\xa0\xc7\x08\x17\x76\x7e\xd5\x92\xaf\x29\xe1\x73\x00\x3d\x15\xe6\x9d\x77\x6c\xc2\xab\xef\x47\x70\xcb\x3c\x1f\xb7\x39\xf9\x88\xfc\xd1\x96\x4f\x62\x66\xcd\x09\x7b\x01\x74\xb5\xd8\xef\xed\xc6\x06\xcd\xd1\x34\xdc\xfe\x14\xb7\xb1\x64\x6b\x8e\xb9\xac\xc9\xe9\xc9\xbc\xeb\xf1\xa7\xb8\xbd\xc9\x83\x8d\x00\x7e\x6d\x18\xbb\x14\xc0\xd2\x7c\x2f\x3f\xff\x66\x33\xb7\xbb\xd7\x4f\xf1\xe0\x06\x45\xa2\x77\xfb\x4e\x76\x73\x3b\x95\x07\x24\x0f\x73\x0c\xe3\x5f\x2e\x6c\x58\x2b\x90\x6f\x3d\xf7\x06\x07\xdf\xdf\x42\xa8\xcb\x8d\x0e\xce\xbb\x09\x8e\x92\x3d\xd1\xcd\x7d\xb9\xd9\x8b\x34\x87\xdb\x17\xfa\xb9\x9f\x2c\x84\x26\x2e\xf4\x73\x9d\xb4\xc0\x03\x62\xfc\xae\x82\x9f\xbc\x20\x7d\x27\x1b\x53\x0c\x91\xbe\x5a\xe0\x0b\x21\x73\xd3\x8c\xbe\x5e\xc2\xdf\xa4\x61\x5e\x75\x00\x23\xe6\x78\x31\xea\x9e\xc2\x88\xda\x2c\x5e\x11\x44\x28\xac\x99\x4e\x0d\xc0\x50\x61\xcf\x5b\x41\xd3\xc0\xfd\x2b\xf9\xfa\xac\x9e\x0f\x28\x80\xfa\x67\x62\x8c\xe5\xaf\x35\x23\x6d\xbe\x0c\xd5\x22\x56\x6a\x85\x9d\x5f\xb7\xf0\x18\x83\x64\x89\x78\xa0\x58\x83\x62\x8f\x0b\x2b\xad\xe9\xe2\x21\x4e\x5c\x3c\x38\xc3\x03\xb5\xed\x3d\xae\x01\xfb\x0f\x27\xcc\xc6\xdf\x26\xfc\x58\xee\xdc\xd3\xc0\xd2\x55\x4d\xa8\x9c\xe1\xc5\xbd\xff\x0c\xe0\xc5\x77\xc2\x98\x5f\x1d\xb0\x1d\x9f\xf8\xec\x33\xc1\x8d\x35\x1b\xc3\x78\xe2\x95\x10\xa6\x3e\xd8\x88\x9b\xfe\xe6\xc1\x33\x1b\x4c\xf5\xe0\x88\xd0\xc7\x56\x6b\x4f\xb6\x26\xd8\xac\xf1\xb5\xf3\x06\x34\x1e\xeb\x92\xad\xb7\x9b\x3f\xf1\xf8\xc2\x5b\x99\x58\x34\x99\x4a\xc3\x17\xd4\x78\x5f\x26\x7b\xe0\xd5\xfb\x54\x33\xbc\xb7\x23\xc6\xd7\xd4\x6e\x6c\x22\x5a\xf7\xd1\xf7\xfa\x78\xcc\xad\x00\x1a\xbf\xc9\xee\xa5\xea\xb5\x21\xde\xaf\xca\xf8\xb4\x07\x14\x1f\x92\x2d\x56\xc0\x61\x11\xb7\x58\x62\xd9\x9a\x50\x56\x9e\x55\xc6\xef\x7d\x6b\x83\x3e\x2f\xb2\x42\xad\xc8\x99\x2c\xf1\xf2\xa6\x30\xef\x57\x65\x7c\x92\x91\xeb\x26\xbb\xd1\xe0\x53\x9a\xff\xe3\x00\xee\x30\xb3\x3f\x12\x7b\xbe\x69\x41\xcf\x51\xae\xbc\x3c\x50\x3e\xd1\x6b\xb4\x8b\xc7\xf4\x7c\xff\xfb\x3b\x31\xe1\xef\x7e\xc4\xad\x6d\x1f\x81\x9c\x53\x25\x80\x32\x11\x07\x9b\xa2\x29\xac\x61\xe4\x3d\x5e\x2e\x03\xa4\xdf\xdd\x06\xe7\xe6\x30\x43\x67\x79\xb9\x9e\x4b\xfe\xd6\xd4\x84\x55\xe6\x4e\xb1\xc0\xd9\x14\x1f\xca\x3c\xd5\x0a\xff\x5a\x1f\x42\x59\x7f\x07\xcf\x5b\x28\x07\x96\xba\x48\xcf\x99\x4b\x33\x7a\x4e\x71\x11\xc5\x84\x4e\x8f\xd2\xda\x2f\xd0\xf9\xdf\x1e\x22\xef\x31\xc5\xbe\xba\x16\x1e\x5f\xcd\x5e\x16\xc0\xda\xcd\x11\x5c\xa4\x9b\x3f\xe5\xb0\x94\x57\x11\x2f\x64\x7b\x14\x40\x31\x56\x17\xdd\xf8\xa7\x88\xbc\xc9\x14\xe4\xcf\x28\xd6\x7d\xe1\xed\x30\xaf\x03\x5c\x7e\x73\x66\xbd\x29\xf7\xa5\xdc\x92\x7c\xcd\x5f\xc6\xbb\x79\x4e\x65\x03\x7a\xe1\xce\x3c\xf1\xd7\x6f\x00\x7c\x68\xd6\x88\xec\xc9\x7d\x4f\x06\x70\xf8\x87\x24\x7c\x01\x0d\x37\x4c\xf5\xa0\xac\x9f\x03\x43\x66\x79\xb9\x7c\x6c\xda\x16\xe5\x3e\xdf\xc6\xe7\x12\x5e\x05\xd0\xc1\x24\x06\xec\x0e\xe0\xeb\x7c\x8d\x48\x9e\xeb\x9d\x49\x1e\x90\x87\x22\x1a\x86\xde\xed\xe5\xfe\x85\x6c\x13\x81\xe2\x3d\xf2\x75\x36\x72\xff\x29\xe5\x46\x36\x31\xf0\x15\x66\x3c\x64\x79\x49\xa4\xf9\x7e\x93\x7f\xfc\xfa\xdb\x13\xbe\xcd\xe5\x4d\xe5\xcb\x41\x24\x3e\x03\x70\xb1\xd5\xd8\x3a\x1e\x28\x6f\xfa\x20\x9f\x6f\x92\x20\x9f\x46\x31\x46\x73\xd4\x76\xbd\x93\x22\xc6\xe8\xa2\x32\xb6\x8e\x87\x33\x45\xee\xe4\xc8\xd7\x29\xe9\x58\xf5\xba\x90\x9d\x9f\xa1\xb8\x6e\x26\x80\xa2\x32\x5f\xa1\x17\x15\x22\xff\xa7\x38\x25\x27\xb9\xa1\xf8\x3e\x4f\xbe\x15\x13\xfb\xb7\x58\xd8\x36\x8b\xcc\xbd\x20\x3e\xce\x01\x30\x16\xc0\x4a\x00\xbb\x85\xbd\x08\x09\xff\xe9\x10\xfb\x4b\x79\xf2\x08\x00\xbf\x57\x1d\x17\xc1\x0e\x40\x55\x09\xd2\x8c\xdd\x9f\x62\xac\x77\x9c\xb1\x4e\x41\xc6\x3a\xd4\x33\xd6\xbe\x36\x43\xa5\x55\x8c\x95\x48\xb2\xeb\x4f\xf7\x6e\x69\x6d\x86\xda\x53\x5f\xd4\x27\xf5\x4d\x63\xa4\x69\x4a\x55\x25\xa0\xb1\xcb\x18\x63\x15\x8c\xb1\xb1\xfa\x3a\x85\xa5\x86\x14\x07\x00\xbf\x02\xd0\x0b\xc0\x74\x51\xdb\xda\x43\x62\x24\xe2\x60\x59\xc7\x08\x8b\xba\xdf\x67\x62\x9d\x6f\x17\x36\xe1\xe7\x6d\xcf\x91\x12\xcf\x94\x1b\x5d\x00\x60\x16\x80\xff\xa8\xc6\x6b\x06\xdd\xa3\x39\xbe\x03\x60\x12\x80\xce\x6d\x21\x8f\x0a\x7c\x4b\xbd\x79\x42\xac\xa7\xa9\x92\x92\xbd\x24\xdf\x42\xb1\xae\x85\xed\x82\xb0\x45\x87\x00\x2c\x12\xf5\xa5\x1f\x65\x1e\xa2\xe6\xbd\xd0\xcc\xee\x40\xd4\x00\x3f\xaf\x6b\xc1\xb2\x35\x4d\xb8\xed\xfe\x4c\x3d\x7c\xd0\x5d\x5e\x9e\x77\x3e\xbd\xbe\x19\x07\xeb\x13\xb2\x9e\x9d\x0f\x69\x31\x8f\xe9\xc5\xda\x25\x13\xbe\x4b\x00\xf4\x16\x39\x8d\xa9\xdd\xa6\x75\xa6\x78\xf6\x4f\x37\x37\x64\xf3\x34\x59\x47\x92\x7f\x5f\x3d\xde\xcd\xcf\x06\x62\x71\xcb\xfd\x20\xd9\x7a\x1b\x40\xb7\x36\xe0\xfd\x54\x00\xb7\x59\xad\x39\x44\x2e\x5e\xf5\x74\x30\x1b\x67\x5b\xc5\xc0\x15\x43\x9c\xbc\x1e\x96\x32\x5d\x89\x2c\xea\x00\xdc\x58\xac\x3c\x89\xda\xee\xec\x7c\x79\xa4\x11\xef\x7c\x1c\xe5\x79\xac\x4a\x2c\x4f\xef\x50\x8c\xb5\x7b\xbf\x69\x3d\x4d\x8f\x06\x00\x63\x0a\xad\x75\x8a\x75\x9f\x2d\x62\x71\x4b\x90\xcc\x4f\x7b\xa8\x91\xd7\x75\x28\xce\x55\x21\x7a\xf7\xe1\x95\xb6\xe9\x9d\x84\x0f\xc0\xe8\x42\xf6\x01\xc0\xad\x2a\xeb\x4e\x20\x59\x7e\xec\xc5\x10\xa6\x3f\xdc\xc8\xeb\xb5\x2a\x44\xf3\xa5\x5c\x5a\xb3\x97\x21\x09\xb2\xb5\xd7\x29\xf2\x4e\xba\x7a\x5c\xb9\xe7\x9f\x0e\x5f\x91\xcf\xb1\xe1\x9d\x62\xf5\xad\x56\x9d\x50\xfe\xbb\xba\x26\xcc\xed\xc8\x6a\x49\x35\x45\x92\x68\x4f\x7d\x51\x2e\xec\xf6\xdb\xba\xc0\xb5\x00\x7e\x61\xc2\x7b\x89\x88\x2b\x2d\x8d\xdb\xbb\xdb\xa2\x59\x5b\x42\x39\x56\x9b\xd0\x00\x27\xcf\xe1\xf6\x1e\xb0\xd5\xe9\x38\x80\x71\x26\xfc\x77\x57\x91\x1b\xe2\xbf\x9b\x62\xcd\x46\x95\xc8\x26\xf5\x1c\xe5\xc2\x3e\x7b\xfe\x09\xfb\x28\x0e\x35\xf0\x7e\x8a\xa8\xf9\xd9\x62\xd3\xc7\x51\xbe\x66\xaa\xb6\x46\x8d\x1c\x3c\x5f\x55\x58\x7f\x08\xf9\x98\x65\xe0\xbf\x5c\x7f\x2e\x6c\x85\x2f\x0f\x25\xb0\xe0\xa9\x20\xe6\x57\xb7\x1d\xcd\xab\x0e\xf0\x73\x70\x85\x1c\x5b\x82\x62\xdc\xb3\x74\xfc\xdf\xad\xda\xf0\xff\x04\xb4\x51\x43\x04\xef\x1d\x44\x0c\xac\x84\x63\xae\x24\x6a\x77\xc5\x50\xbb\xbb\x0d\x69\x57\x0c\x5b\xf7\xc4\x55\xec\x8f\x1e\xab\x44\x1c\xdf\xcb\xec\x8c\xc5\x08\xca\xe3\xc7\xce\xf3\xf1\x9a\x2b\xc5\x0b\x6d\x45\x15\x43\x5d\xbc\x7e\x46\x3e\xb0\xb1\x49\xd9\xa9\x1d\x00\xd0\x09\xc0\x9d\x2a\xb9\x47\x3c\x91\x89\xd1\xca\x15\xeb\x95\x05\xdb\x20\xf1\xa4\xd8\x3b\xa5\xb6\x0d\x94\xd3\xdd\x24\xce\xf6\x6d\x41\x31\x1a\xd9\x08\xd5\x7a\x6b\xb1\x76\xb4\xd7\x68\x17\xb6\xef\x8d\xab\xb0\x44\x76\x68\x81\xd0\x65\x4b\xc8\x73\x02\x8a\xeb\xf9\xb9\x8d\xee\x1c\xa6\x58\x5f\x70\xd1\xa0\x4c\x5b\x7d\xae\x20\xcf\x84\x26\x2e\xf2\x23\x6c\x5f\xff\x81\xb8\x17\x60\x59\xdf\x24\x6c\xd8\x12\xc9\x9e\xf5\xfc\x75\xbc\x9b\x9f\xf5\x2e\x5e\x11\xe4\xb5\xa6\x6b\x26\xba\x8b\xda\x93\x4b\x86\xb9\x78\x1f\xd5\xeb\x42\x98\xba\xc4\xcf\xeb\xb4\x97\x8d\xce\x9c\x25\xd1\x38\x1f\xed\xb4\x3c\x23\x94\xf8\x44\xd4\x09\x4c\x41\x31\xe2\xfa\xf7\x22\x3c\xff\x23\x3b\x71\xd4\x91\xcc\x9e\xff\xae\x7c\xb3\x59\xf9\xfc\x24\x5f\x2e\x43\xeb\x1c\x0a\x6b\xfc\x3c\xc7\xd3\xa8\x71\xdf\x42\x72\x4a\x79\x1c\x3d\x15\x70\xd0\x2a\x27\xcc\xce\x21\xcf\x56\x92\x1d\xed\x7b\x87\x5b\xe9\xec\xc9\x8c\x28\x17\xdb\x64\xc2\xa7\x62\x6c\xfd\xbd\x0a\xff\xf9\xb0\x7e\x4b\xe4\xa4\xf5\x95\x64\x7d\xe6\xd2\x46\x55\x7b\x63\xc6\xbf\x6d\x8e\x65\x44\x3a\x0d\x7e\xfe\x58\xa6\x78\xf6\x64\x25\x43\xfd\xa6\x79\xb8\x7d\x28\x12\x75\x76\xb9\x79\x3e\xc4\x5a\xd2\x18\x37\xdf\xa7\x7c\x76\x66\x65\x2f\xaf\x1c\xd7\xc0\x6b\xff\x45\x62\x3b\x80\x9d\x85\x36\x22\xfd\x1d\x33\xd7\xa7\x7c\xf6\x68\xc5\xff\x15\xb7\x34\xf0\xba\x50\x91\x20\xdf\xb5\xba\xd0\x46\x89\x64\x1a\x93\x1f\xf0\xb7\xc9\xfa\x5f\x75\x5b\x03\xb7\x69\x45\x80\xac\xca\x5c\x00\x53\xec\xce\x19\xf3\x61\xc9\x73\x4d\x27\xcd\xff\x49\xca\x7f\x48\xdc\xbd\xbd\x54\xc5\x87\x19\x51\x53\x1b\x45\x37\x85\x7b\x0b\x92\xc8\x37\x55\x0c\x6d\x6d\x7f\xa6\x2c\xf1\xf3\xfd\x2c\x02\x5f\x89\x7b\x26\xbf\x14\xf7\xc0\x0a\x02\xed\xf9\xd5\x13\xd4\x7c\x2f\xbd\x33\x62\x8e\x17\x97\x8f\x69\xc8\x79\x9f\xfe\xa6\xdc\xbd\x48\x3c\x2b\xeb\x5a\xa2\x66\x5a\x10\xc8\x67\x92\xed\x96\x32\x44\x7e\x9f\xe2\x3b\xb3\x39\xcc\x79\x3c\xc0\x63\x0f\xc9\x7f\xb9\xb8\xd3\xf1\x5d\x71\xb6\x87\x82\x8b\xfe\xba\xfc\xab\x8b\xb8\xf3\x51\x10\x36\x6e\x8d\xf2\xf8\x81\x62\xdf\x4b\x87\xbb\x78\x1e\xd8\x63\x64\xeb\x39\xd0\xdc\xaa\xd7\x86\xd0\x7f\x9a\x27\xe7\x7c\xfa\xd1\x55\x4d\x56\x77\x70\xac\xf0\xa9\xfe\x4e\xab\xa8\x9d\x3c\x5a\x68\x27\x0e\x4f\x0a\xd7\xdf\xe1\xe6\x76\x94\xc7\xbd\xfb\xe2\x3c\xb6\x33\xda\x55\x8a\x13\x48\x5f\xc6\xce\xcf\x7c\x47\x6b\xdf\x77\xb2\x5b\xf5\x2e\x85\x11\xe4\xad\xa7\xe4\xa9\x9f\x94\x17\xba\x07\x9a\xb8\xbb\x7c\x7e\x3f\x07\xbf\x8b\xd7\xe0\x4b\xf1\x98\x54\x1f\x13\xc9\x3b\xd1\x9f\xd7\xb5\xf0\x73\x6a\xf2\xd9\xf4\x99\x3c\x1f\x2e\x02\x9f\xe9\x73\x77\xc3\x1c\x66\x17\x78\x0e\xc4\x63\x53\xd2\x01\xf2\x07\x14\xc7\xec\xd8\x17\xcf\xd1\x03\x9a\xcb\x80\xe9\x1e\x9e\x17\xae\x7c\xab\x99\xaf\xff\x9f\xc7\x36\xe0\x1b\xf3\xbb\x53\x56\xa0\x58\x67\xb8\x45\xfd\xf0\xf4\x42\x6d\xd1\xb6\xbd\x71\x1e\xaf\xbf\xbc\x29\x63\x47\xbe\x77\x26\x73\xf4\x94\xe6\xb6\x68\x79\x90\x7f\xf7\xdf\x2f\xe3\x3c\xee\x27\x19\x33\xb9\x83\x69\x87\xe7\x00\xfc\xcc\x8c\x7f\x76\xe2\xce\xc6\x61\xd5\x0e\x3f\xda\x15\xe3\x72\x2d\x6b\x07\xc1\x90\xc6\xcf\x8c\x78\x3e\x55\x99\xb1\x49\x5b\x77\x67\xf2\xc1\x80\xf8\x8e\xe4\xa8\x08\x90\xdc\xfc\xc1\x8a\x77\xdd\x1c\x86\xc8\x7b\xed\x76\x38\x70\x24\xc1\x49\x22\x1a\x4f\x67\x75\x98\x68\xe4\x3d\x5e\x7e\xb6\x24\xb1\xe2\xf5\x66\xee\xbb\x0b\x04\xe9\xe5\x15\x2a\xbc\xb3\x13\xf5\xc4\x49\x2a\x77\xc8\x8c\x20\x5f\x3a\x71\x61\x26\x36\x22\x19\x7a\xee\x8d\xdc\x3b\x7a\x2e\x5f\x8a\xff\xa6\xa3\x00\x9f\x4b\xf1\x71\x3f\x55\xde\x75\x73\x68\x27\xee\xcc\xfb\x0a\x9d\xc3\x82\xa7\x82\xd9\x3b\x8e\x75\x47\x5b\xeb\x29\xc9\x18\xf9\x3f\x05\x1c\xd5\xfb\xa9\x22\xe6\x40\xfb\x30\xc8\xee\x1e\x97\x11\x94\xbb\x92\xee\xf2\xdf\x90\x58\x9f\x35\x5a\x61\x37\x80\x2b\x8b\xe5\xdd\x30\x8f\x4b\xc4\x59\xb9\x92\xc3\x21\x5b\x39\xea\x5e\x1f\x66\x3c\xda\x58\xc8\x19\x91\x44\x54\xd4\x06\xcf\x6d\x0b\xde\x75\x73\xe8\x28\xee\x14\x1f\xb2\x3b\xe3\x80\xb8\xdb\x47\x7a\xaa\x78\x5f\x13\x22\x0f\xdf\x23\xce\xea\x7e\x94\x7b\x11\x22\xce\x38\x4f\x9c\xf5\x1f\xb4\xf3\x75\x64\x77\x14\xf4\x34\x21\x7e\x83\x30\x13\xc0\xd9\x3f\x06\xdf\x26\xf3\xe8\x04\x60\xbc\xb8\x03\x55\x2f\xce\x76\x54\x90\x16\x7e\xf4\x90\xf8\x8d\xdf\x08\xb3\x78\xe0\x27\x9a\x4b\x7b\x71\x17\x65\xa4\xf8\x5d\xcc\x66\x71\xcf\xe9\xb8\xb8\x97\xe2\x15\x67\x23\x5f\x88\x7b\x01\x4b\xc4\xfd\xce\x73\x8c\xbf\x6d\x2a\x6e\xfc\xfa\xf6\x00\x3d\x05\xc5\x19\xeb\x44\xcf\x7a\xc6\x3a\xd0\xb3\x96\xb1\x52\x7a\x56\x31\x56\x42\x4f\xde\x88\xb1\x34\x3d\xef\x67\x2c\x45\xcf\xde\x8c\xc5\xe9\xd9\x89\xb1\x20\x3d\x3b\x30\x56\xaf\x7f\xb6\x67\xac\x56\xff\x2c\x3d\xf1\xac\x62\xfc\x82\x52\xab\x27\xd3\x3f\x4f\x16\x79\xfa\x97\x4f\x23\x3f\x92\x4f\xc9\xb7\x9c\x8f\x7c\xca\x79\xca\x79\xcb\x75\x90\xeb\x92\x5d\x27\xb9\x6e\x41\xb1\x8e\x71\xc6\x7a\xeb\xd7\x59\xac\xfb\xff\x02\x00\x00\xff\xff\xeb\x12\x88\x54\xee\x3a\x00\x00") + +func uiAppFaviconIcoBytes() ([]byte, error) { + return bindataRead( + _uiAppFaviconIco, + "ui/app/favicon.ico", + ) +} + +func uiAppFaviconIco() (*asset, error) { + bytes, err := uiAppFaviconIcoBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "ui/app/favicon.ico", size: 15086, mode: os.FileMode(420), modTime: time.Unix(1, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _uiAppLibBootstrap400Alpha6DistCssBootstrapMinCss = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\xbd\x5b\x93\xe3\x36\x92\x30\xfa\x7e\x7e\x05\xb7\x27\x3a\xda\x6d\x8b\x6c\x8a\xba\x95\xa4\xb0\x63\x76\x26\xf6\x8b\x6f\x22\xec\x79\xd8\xd9\x3d\x2f\xfe\xfa\x81\x22\x21\x89\xd3\xbc\x7d\x24\x55\xc5\xb2\x56\xe7\xb7\x9f\x20\x2e\x24\x2e\x09\x80\xaa\xae\x8b\xda\xe3\xf1\xd8\x45\x01\x89\xcc\x44\x22\x91\x48\x24\xc1\xc4\xa7\xef\xff\xed\xff\x71\xbe\x77\xfe\x52\x14\x4d\xdd\x54\x61\xe9\xdc\xcf\x3d\xdf\xf3\xdd\x30\x2d\x8f\xa1\xb7\x74\xbe\x3b\x36\x4d\x59\x6f\x3e\x7d\x3a\xa0\x66\xc7\x80\xbc\xa8\xc8\x3e\x76\xcd\xfe\x5a\x94\x8f\x55\x72\x38\x36\x4e\xe0\x4f\xa7\x6e\xe0\x4f\x57\xce\x7f\x1d\x11\x87\xee\xdf\x4f\xcd\xb1\xa8\x6a\x2d\xf0\x43\xd2\x34\xa8\x9a\x38\x7f\xcb\x23\xaf\x03\xfa\x39\x89\x50\x5e\xa3\xd8\x39\xe5\x31\xaa\x9c\x5f\xfe\xf6\x5f\x1c\x0b\x49\x73\x3c\xed\x3a\xe2\x9f\x9a\x87\x5d\xfd\xa9\xe7\xe7\xd3\x2e\x2d\x76\x9f\xb2\xb0\x6e\x50\xf5\xe9\xe7\xbf\xfd\xf5\x3f\xfe\xfe\x8f\xff\xe8\xf8\xfb\xf4\xe9\xfb\x7f\x73\xf2\xa2\xca\xc2\x34\xf9\x0d\x79\x51\x5d\x3b\xf7\x8b\xae\x7b\xce\xff\x60\xcc\x94\x98\xf3\x3f\x0e\x87\x3a\x47\x51\x91\x86\xf5\x27\xb1\xdd\xf7\x9f\x8e\x4d\x96\x9e\xf7\x45\xde\xb8\xfb\x30\x4b\xd2\xc7\x4d\x1d\xe6\xb5\x5b\xa3\x2a\xd9\x6f\xd3\x24\x47\xee\x11\x75\x9d\xdb\x4c\xbd\xe9\x62\xeb\x66\xb5\xdb\xa0\xb6\x71\xeb\xe4\x37\xe4\x86\xf1\x3f\x4f\x75\xb3\x99\xfa\xfe\xfb\xad\xfb\x80\x76\x5f\x92\x06\xae\xbd\xec\x8a\xf8\xf1\x9c\x85\xd5\x21\xc9\x37\xfe\x25\xac\x9a\x24\x4a\xd1\x24\xac\x93\x18\x4d\xf6\x45\xd1\x89\xea\x88\xc2\x18\x55\x93\x3c\xbc\x9f\xd4\x28\x6a\x92\x22\x3f\xc7\x49\x5d\xa6\xe1\xe3\x66\x97\x16\xd1\x97\xcb\x71\x4a\xd8\xec\x90\x6f\x02\x94\x6d\x29\x3e\x6f\xb9\x42\x99\xe3\x5f\xf6\xc9\x21\x0a\xcb\xae\xe1\x64\x9f\x1c\x4e\x15\x9a\x64\x61\x22\x23\x21\x35\x8c\x95\x29\xca\x9c\xb9\x5f\xb6\x97\x63\x75\x66\x1d\xd8\x15\x6d\x47\x22\xc9\x0f\x9b\xa8\xc8\x1b\x94\xe3\xa2\xad\xa6\x98\x0a\xc7\xdf\x16\xf7\xa8\xda\xa7\xc5\xc3\xe6\x3e\xa9\x93\x5d\x8a\x2e\x65\x85\x04\xb1\x66\x45\x5e\xd4\x65\x18\xa1\x49\xff\xb4\x1d\xfa\x33\x45\xd9\x25\x3c\xef\xc2\xe8\xcb\xa1\x2a\x4e\x79\xec\x46\x45\x5a\x54\x9b\xa6\x0a\xf3\xba\x0c\x2b\x94\x37\xa2\x84\x63\x14\x15\x55\xd8\x75\xd6\xad\xbf\x24\xe5\xa6\xd8\xfd\x13\x45\x4d\x7d\x09\x37\x61\xd4\x24\xf7\x68\x12\x6e\x8e\x1d\x4b\xe7\xe2\xd4\xe0\x51\x7c\x48\xe2\xe6\xd8\xc9\x7e\xb7\xab\x7e\x6d\x92\x26\x45\x9f\xcf\xbb\xa2\x8a\x51\xe5\xee\x8a\xa6\x29\xb2\x4d\x5e\xe4\x68\x2b\x21\xdf\x60\x75\xed\x10\xe8\x6b\x9c\xb8\x68\x1a\x14\x5f\x76\x93\xba\xa9\x8a\xfc\x40\x7a\xfd\x40\x04\x93\xe4\x47\x54\x25\x0d\x5c\xb9\x2b\xd2\x18\x55\x97\xa8\x88\xd1\xe4\xcb\x2e\x9e\xd4\x61\x56\x5e\x29\xb3\x78\x9f\x53\xad\x68\x1e\x53\xb4\x49\x9a\x30\x4d\xa2\x4b\x16\x56\x5f\x54\x61\xfe\x69\xbf\xf7\xb7\xf4\xd1\xf7\xfd\x4b\x9d\x85\x69\xca\xe9\xd4\x9d\xff\xfe\x52\x9f\x76\x93\xfa\x54\x72\xa5\xab\xc5\x7b\x61\x1e\xf8\xdb\xb2\xa8\x13\x2c\x82\x0a\xa5\x61\x27\xec\xed\x3d\xea\x34\x3a\x4c\xdd\x30\x4d\x0e\xf9\x66\x17\xd6\xa8\x6b\xd2\x61\x3b\x53\xe9\xba\x5e\xb0\x40\xd9\xa5\xc3\xdd\x14\xe5\xc6\xf5\xba\x5f\xe1\x29\x4e\x8a\xc9\x7d\x12\xa3\xa2\xd7\xd3\x24\xc7\xd4\x88\xba\x62\x80\x4d\x5e\x34\xdf\xfd\xda\x69\x5d\x55\xa4\xf5\xe7\x8f\x3d\x28\x1e\x31\xc6\xd6\x25\xc9\x0e\x6c\x44\x89\x30\xba\xea\x4b\x7d\x7f\xc0\xed\x37\x55\x51\x34\x1f\xcf\xbd\x9a\x1e\x93\x38\x46\xf9\x65\x77\x6a\x9a\x22\x9f\x24\x79\x79\x6a\x26\x45\xd9\x74\x02\x2b\x27\x35\x4a\x51\xd4\x4c\xba\x21\x0f\x2b\x14\xea\xcc\x03\x37\x14\x9d\x09\x50\xac\x45\x3f\xe1\x79\x2a\x67\x65\xa6\xd0\x5a\x42\xf4\x8c\xf5\x0c\xeb\xfd\xbe\xa8\x88\x56\x5e\x7e\x6d\x1e\x4b\xf4\x63\x85\x6a\xd4\x7c\x9e\x90\x1f\xf5\x69\x97\x25\xcd\xe7\x09\x6d\xdc\x59\x31\x87\xd4\x90\x92\xcf\xfd\x84\x0e\xcb\x12\x85\x55\x98\x47\x68\x43\xaa\x2e\x02\xdc\x66\xe3\x66\xc5\x6f\xee\xbe\x88\x4e\xb5\x9b\xe4\x39\xaa\x26\x3c\x39\x6d\x35\x65\x00\xa8\x27\x88\xd5\x0a\x75\x74\xb6\x65\x18\xc7\x9d\x49\xf1\x25\x9e\x86\xa6\x55\x92\x1f\x44\x86\xc0\x3a\xc6\x8d\x54\x49\x59\x11\x4b\x99\x4d\xd8\x4c\xcb\x96\x4e\x5e\xe7\x2f\x18\xf0\xbf\x50\xdb\x5c\xf6\x09\x4a\xe3\x1a\x35\x94\x5d\x0c\x55\x17\x69\x12\x3b\x75\x92\xde\xa3\xaa\x1f\x56\x27\x28\xdb\xbe\x07\xde\x6c\x81\x32\xc7\x5b\x06\xf8\xcf\xaa\xd3\xee\x14\x1d\x50\x1e\x43\x86\xb5\x37\x3c\x82\x5d\xe5\x4a\xc9\x2c\xa5\xc6\x63\xcb\xf4\xbd\x09\x77\x29\xda\x66\x61\x4b\xad\x19\xd6\xba\x5e\x84\xdb\x87\x63\xd2\x20\x17\x5b\x89\x0d\x59\xe5\x2e\x65\x55\x1c\x2a\x54\xd7\xe0\xec\xd2\x4e\xdb\x5e\xef\x7b\x55\x0d\x4f\x4d\x41\x87\x28\x3a\xa2\xe8\xcb\xae\x68\x99\x22\x56\x61\x9c\x14\x9f\x9f\xd4\x4b\x79\xf4\xf3\x53\xb6\x43\x55\xa7\x52\x14\x19\x56\x1b\xb7\x2e\x93\xdc\xa5\x7a\xae\x01\x2c\x4e\x8d\x08\x78\xa6\xf3\x90\x63\xbc\x46\x61\x15\x1d\xc1\x79\xd1\x75\x18\x0f\xfb\x96\x2d\x17\xc5\x7e\x5f\xa3\x66\xe3\x06\x65\x2b\x36\x1f\x68\x92\x02\x37\xea\x30\xa4\x22\x7f\x3a\xd8\x61\xf9\x80\xb8\xc0\x53\x7d\x68\xb3\x4f\x52\xe4\x9e\xca\xb4\x08\x63\xd6\x29\xed\x94\xc6\xa6\xa8\x5f\x6c\x62\xd4\x84\x49\x5a\x4f\x32\x94\x9f\xa4\xf5\xbf\x3e\x65\x59\x58\x3d\xf6\xa5\x69\x52\x37\x6e\xd2\xa0\xec\x12\x85\xf9\x7d\x08\x2b\xca\xa5\x41\x59\x99\x86\x0d\x12\x2c\xef\xe5\x57\x62\x43\x3f\x8b\xa5\x7f\xce\x50\x9c\x84\x4e\x59\x25\x79\x73\xfe\x7e\xb2\xd9\x84\xfb\xce\xbd\xd9\x6c\x76\x68\x5f\x54\x68\x82\x31\xfe\xdf\x53\xd1\xa0\xcd\x66\x9f\x54\x75\xe3\xa6\x08\xfb\x8a\x40\x45\x92\xa3\x49\x9c\xdc\x4b\x80\x7c\x49\x07\x91\x26\x12\x00\x57\xd0\xd5\x97\x52\x75\xc9\xd7\x12\x7b\x5b\x1f\xc3\xb8\x78\xc0\x1d\xf8\xb7\x24\x2b\x8b\xaa\x09\x39\x8f\x03\x6b\x2f\x08\xa1\xad\xb9\x84\x93\x10\x1b\xf8\x06\xc5\x67\xad\xeb\xc0\x7b\x23\x54\x50\x67\xea\x5d\x6d\xde\x39\xdf\xbd\x73\xc2\xa6\xa9\xbe\xc3\xf5\x1f\x9d\x77\x1f\xdf\x61\xa7\x8a\x9f\xe6\x65\x85\xdc\x87\x2a\x2c\x39\xc2\x83\x18\x27\x1d\xb4\x62\xc4\xfe\xb4\x5e\xaf\xb7\x65\x78\x40\xee\xae\x42\xe1\x17\x37\xc9\x3b\x2f\x74\x13\xde\x17\x49\x7c\x69\x3a\x2f\xf4\x2c\xd8\x1b\x97\x38\xa6\x2e\x5e\x19\xbb\x45\x76\xd2\x54\x67\x5d\xfb\x63\x30\x39\xce\x26\xe5\xb9\xa8\xca\x63\x98\xd7\x9b\xd9\xf6\x21\x89\x8b\x87\x7a\x33\x23\x55\x7c\x43\xdc\x5d\xda\xce\xcb\xc3\xfb\x5d\x58\x89\x9a\xe4\xed\xc2\xf8\x00\xf5\xa0\x73\x5e\x3c\xcc\x1c\x5b\x52\xa2\x22\x4d\xc3\xb2\x46\x1b\xf6\xc0\x09\x84\x40\x3a\x4d\x3c\x61\x4f\x47\xd0\x37\xda\x2b\x6d\x5c\x82\x1d\xc5\x43\x63\xae\xe8\x08\x70\x16\xc7\x31\x87\xe5\x82\xf7\x16\x4f\xb0\x8c\x17\x75\xde\x40\x68\xd8\xfa\xa0\x16\x5d\xfe\xdc\xed\x54\xee\x13\xf4\xd0\xf1\x72\x26\xcb\x45\x8c\xee\x93\x88\x7a\xc2\x94\xb5\xac\x76\x99\x8d\xa7\xcb\x72\x1d\x55\x45\x9a\xee\xc2\x6a\xf0\xb7\xc3\xd2\x3d\x26\x87\x63\xda\x19\x54\xd5\x2f\x27\x7b\x1b\xde\x43\xea\xcc\x53\x8a\xdc\xfa\xb1\x6e\x50\x36\x21\x7f\xdc\x53\x32\xf9\x4b\x9a\xe4\x5f\x7e\x09\xa3\x7f\xe0\x92\xff\x55\xe4\xcd\xe4\xdd\x3f\xd0\xa1\x40\xce\x7f\xff\xed\xdd\xe4\x3f\x8b\x5d\xd1\x14\x93\x77\xff\x1b\xa5\xf7\xa8\x5b\x96\x9c\xbf\xa3\x13\x7a\x37\xf9\xf7\x2a\x09\xd3\x09\xec\x75\x55\x28\xdb\xf2\x0e\xf5\xdc\xf7\x25\x2f\x6c\xc1\x1c\xde\x60\x1d\xec\x82\x68\x0b\x0e\xfc\xe5\xd7\x26\xdc\x25\x79\x8c\xda\x1f\xdf\xb9\xd3\x77\x9f\x37\xd8\x55\xe8\xdd\x04\x9f\x1b\xd2\xe3\x74\x42\x74\xfc\x38\x9f\x1c\x17\x93\xe3\x92\x6e\xa5\xdc\xce\xa9\xf5\xa9\x6b\xc0\x76\x14\xde\xa2\x42\xd9\xa5\x34\x81\x74\x5d\x20\x56\x20\x0e\x9b\xd0\x2d\xaa\xe4\x90\xe4\x61\xea\x12\x9b\x30\xe1\x77\x2b\xd1\xa9\xaa\x8b\x6a\x73\x44\x69\x79\x09\xe3\x18\x2f\xeb\x2a\xb2\x2d\xb7\x1b\x20\x4e\x80\x20\x91\x7e\x89\x48\x27\x45\x3a\x39\xa5\x56\xde\x8a\xd4\x29\x3a\x58\xe7\xd4\x81\x3b\xb8\x91\x33\xb4\xa3\xa0\xfe\x25\x6e\x84\xad\xcd\xca\xf7\x2f\x71\x7c\x06\xe4\xc1\x88\xa4\x68\xdf\x79\xed\x83\xb9\xea\xf7\xc7\x8e\xef\x10\xb1\x9c\xd9\x66\x25\x58\x2d\xe2\x3b\x65\x07\x86\x8d\x44\x48\x06\xab\xdf\xef\xb1\x26\xd3\x79\x74\x17\xe9\x37\x6d\x97\x90\xec\x2a\x8e\x15\xda\x7f\xfe\x48\x9e\x99\x12\x7c\xfe\x78\x16\xfd\x2f\x0d\x61\x03\x82\x9e\x29\x13\x0c\xcf\xf0\xd7\x92\x1a\x94\x15\xaf\x11\x96\x51\xdd\x8a\x8e\x9d\x18\x14\xe8\xe5\xdf\x6d\xa8\x24\x17\x31\x4b\xe2\x38\x45\x97\x5f\xab\x22\x1d\x36\x1a\x54\x31\xcb\x22\xc9\x1b\x54\x89\x95\x93\x70\xd2\x79\x92\x13\x61\x9f\x95\x86\x3b\x94\xb2\x4d\x16\xf5\x48\x86\xcd\x16\x8e\xb1\x14\xa7\xe8\xe8\x86\x38\x0c\xb2\xc9\xc2\x3c\x29\x4f\x29\x16\xc8\x56\x5b\x73\x31\x2f\x08\xea\xcc\xe7\x6d\x18\x0d\x9c\x9c\xa9\x47\x8a\x05\xe7\xad\xb0\xba\xb2\x22\xa6\xc3\xa4\x94\xaa\xd9\x72\xb6\x8c\x56\x01\x19\x35\x22\xa1\x4e\xad\xb7\x14\x9d\x8b\x57\x46\xd2\xf0\xd2\x1c\xcf\x12\xd8\x05\xcb\x01\x76\xcd\x21\x43\x42\x37\x33\xe2\x78\x0f\x7b\x18\xe6\xbb\x6e\x16\x65\xeb\x74\xe3\xea\xf4\x9e\x24\xde\x83\x75\x5b\x1f\xd2\x75\x71\xd7\x2b\x6f\x76\x21\x73\x81\x21\x25\xff\x7f\x13\x27\x75\x27\xf2\x78\xc2\xd5\x92\xdd\x40\x5f\xc5\x74\x23\x2f\xba\x8e\xa7\xc5\x03\x8a\x79\x5c\x71\xd8\xa0\xcf\x7c\xf3\x26\xc9\xc4\x82\x0e\xa2\x2b\x74\xd3\x22\x0a\x53\xa1\x2a\x2b\xf2\x06\x76\xe7\x3b\xa7\xb6\x5b\x45\xfb\x2e\x55\x08\xaf\x17\x4c\x99\x87\x2d\x5e\x96\xe4\x2c\x32\xc4\x6d\xa4\xd8\x44\xd8\xd2\x05\xde\x67\x5b\x39\xc1\x97\xde\x82\x9b\x30\xc8\xe2\x71\x2b\x16\x29\xb0\x88\xd8\xb0\x53\xc1\xf6\xa0\x38\x35\xe5\xa9\x81\x5d\x75\xd0\x29\xe7\x3d\x9b\xe3\x74\xe2\x1d\x83\x89\x77\x9c\x4d\xbc\xe3\x7c\xe2\x1d\x17\x13\xef\xb8\x9c\x68\x17\x36\xb5\x27\x74\x99\x67\x26\x8b\x37\xfb\x0b\x65\x01\x9e\x8a\x7b\x59\x4c\x5f\x8c\x64\x12\xe5\xee\x78\x3a\x06\x7c\x39\x29\x9d\x75\x5e\x23\x2f\xc0\x15\x05\x9f\x4f\x8e\xf3\xb3\x2c\xd9\x4b\xd7\x9d\xe3\x42\x28\x0f\x68\xc5\xb2\xeb\x94\xe8\x3c\x5c\xbc\xb4\xf3\x77\x15\x68\xa1\x4f\xb3\xce\xdb\xa4\xd2\x74\x79\xce\x97\x00\xa4\xdc\xfb\xa1\x25\xdf\xb7\x85\x07\x51\xd1\xb7\xe5\x25\x30\xbf\xb2\x2d\x2f\xa4\xd9\xb8\xb6\xc7\x8a\x5f\x40\xa6\xdc\xa2\xcd\xaf\x21\x6c\x72\xd0\x07\x02\xdb\xbb\xc2\xd5\x61\x17\x7e\xe7\x4f\xba\x7f\xbc\xe9\xc7\x8b\x87\x83\x8d\x13\x20\xe4\x28\x3b\x70\x17\x2f\x0b\xab\x2f\x13\x1c\xc2\xec\x83\x2b\x41\x47\x4f\x75\xdd\xa2\xfd\x1d\x9a\x5d\x3c\xbc\x89\x3d\xe5\xd8\xe9\x89\x7b\x1b\x4e\x1c\x8c\x2d\xae\xe4\x02\x82\x04\x9a\xcc\x99\x6b\x60\xf1\x2e\x19\x9e\x73\x0a\x18\x89\x38\xa6\x61\xdd\xb8\xd1\x31\x49\xe3\x8f\x4c\x9e\x15\x99\x25\x65\x7b\xf1\x92\x3c\x69\x92\x30\x4d\xea\x8c\x93\xc7\xda\x7f\xbf\x95\x02\x80\xa7\xb2\x44\x55\x14\xd6\xdd\x7e\x68\xf0\x95\x7a\xc9\x74\x03\xea\xe8\x86\x48\x55\x6c\x3a\x56\xb8\xbf\xa4\x88\x6d\x5d\x50\x84\x10\xda\xf3\x44\x5c\xf2\x66\x42\xb2\x7a\xe2\xe0\x09\xeb\x20\xd0\xb8\xdf\xbe\xf4\xdb\xda\xff\x13\xf8\xd3\xb9\xf3\x7f\x7c\xff\xdf\xfd\x77\x42\x83\x0a\xdd\xa3\xaa\x1e\xc6\x84\xc8\x6a\xca\xaf\xc1\x74\x98\xb8\x75\x14\x03\xb1\x5e\x91\x16\x50\xb7\x84\x7e\xfb\x10\x59\x67\x0c\xef\x20\xc3\x60\x4b\x69\x2f\x8f\xbb\xeb\xe0\xae\xbf\xbb\x78\x49\x76\x70\xf7\xe9\x29\xe9\xfc\x63\x21\x96\xc7\x07\xad\x30\x54\x73\x3c\x65\xbb\x3c\x4c\x52\x6e\x2a\x90\x71\x84\xf6\x31\x5b\x70\x43\xda\x4b\x27\x8c\x93\x53\xcd\x10\xf4\xbb\xbb\x4e\xd1\x48\x38\x3f\x4c\x53\xc7\x0b\x6a\x07\x85\x35\x72\x93\xdc\x2d\x4e\xcd\xd6\x2d\x6c\x10\x96\x6a\x53\x0f\xa9\xdf\x09\xcf\x29\x52\xe9\x76\x4e\x28\xb4\x12\x09\x36\xab\x87\x66\x7e\x9c\x38\xa3\x44\x25\xed\x5f\xb7\x94\x15\x52\x5f\xb9\xfc\x82\xf2\xb4\x98\xfc\x52\xe4\x61\x54\x4c\xfe\x5a\xe4\x75\x91\x86\xf5\xe4\xdd\xcf\xc9\x0e\x11\x97\xdc\xf9\xa5\xc8\x8b\x77\x93\x77\x7f\x2d\x4e\x55\x82\x2a\xe7\xef\xe8\xe1\xdd\xf0\x7a\x06\x63\xe7\x06\xab\xd3\x44\x6f\x2e\xce\x45\x8e\xa5\x5d\x3c\x9f\xce\x57\xd0\x68\xae\xf6\xab\xfd\x1a\x1c\xba\x4b\xf8\x93\x40\xc4\x97\xa2\xc5\x0a\x32\xb6\xf4\x7e\xd9\xc5\xe3\x39\xc3\xea\xa4\xb0\xc5\x76\xd1\x12\x5b\x1d\x57\x5f\x76\xb1\xc3\x53\xf0\xe5\xd7\x23\xf2\xf6\xb0\xe4\x86\x5e\x70\x7a\xb5\xbb\x16\x90\x51\xc2\x52\x87\xcd\x91\xc4\x32\x80\x33\xd1\x58\x04\xc5\xbf\x6d\x14\xbb\xe8\x5f\xbc\xb2\x42\x2e\x09\x8e\xe0\x7d\x46\xa7\xd7\x54\xfd\x66\x73\xbf\x6c\xfb\x2d\x95\xfb\x48\x63\x28\x17\xaf\x9b\xfe\x61\x92\xa3\xea\xac\xbe\x32\xe3\x77\xc1\xdd\x6c\xd8\x0a\x2b\x04\x2e\x91\x0c\xe1\x62\x78\xdb\x40\x9a\x75\x25\x2c\xdc\xfa\xdd\xe0\xc9\x2e\x56\xcb\xb2\xfd\x78\xe6\xa9\x8f\x41\x04\x60\x5a\x2d\xef\x9e\x09\xd3\x7a\x1d\x3c\x13\xa6\x69\xe0\xfb\xcf\x84\x4a\x15\x14\x2d\xc7\xe3\x29\x1a\xae\x71\xe2\xa1\xe5\xc1\xb8\xf6\xaa\x50\x68\xf9\x72\x5c\x7b\x40\x14\xb4\x62\x0a\xf6\x60\x80\xa3\xab\xcf\x9b\x6a\x25\xe3\xe1\xb9\x74\xf3\x2b\xf1\x29\x83\xf1\x95\xf8\xd4\xc1\xb9\x0a\xa1\x57\x15\x0f\xbd\x75\xe4\x42\xbf\x5b\xb9\x6c\x9f\x22\xae\x30\xab\x71\x01\x0f\x88\x01\x78\x68\xfc\xc2\x60\xd3\xfd\x67\xcb\xe0\xb9\x22\xe9\xa7\x30\xfe\x2e\xe6\x96\xd7\x11\xd7\x32\xda\x5d\x2f\x46\xa1\x30\x8c\xf0\xd7\xe0\x60\xa3\xfa\x35\x38\xfa\x91\x1c\x8f\xc4\xcb\x0b\xf7\x70\x6a\x1a\x54\xd5\x62\x0b\x5f\x8a\x7e\x72\x80\x3f\x79\x51\x91\x4e\xf8\x82\x5f\xa3\x34\xac\xeb\xef\x7f\x8c\x8a\xd4\xfd\x2c\xe9\x8d\x2f\xf9\xc4\x17\xd2\xba\x03\x9d\xd2\x3f\x3e\xfd\xcb\x7e\x07\xe4\x2f\xfd\x33\x23\x7f\xe6\xe4\xcf\x82\xfc\x59\x92\x3f\x2b\xf2\xe7\x8e\xfc\x59\x93\x3f\xe9\x81\xfd\x65\x14\xba\x27\x7f\x78\xe4\x4a\x83\xfe\x71\x78\x9a\xf5\x4f\xf3\xfe\x69\xd1\x3f\x2d\xfb\xa7\x55\xff\x74\xd7\x3f\x51\x16\xb2\x98\xfd\x65\x2c\x74\x4f\xfe\xf0\xc8\x95\x06\xfd\xe3\xf0\x34\xeb\x9f\xe6\xfd\xd3\xa2\x7f\x5a\xf6\x4f\xab\xfe\xe9\xae\x7f\xa2\x2c\xd4\x19\xfb\xcb\x58\xe8\x9e\xfc\xe1\x91\x2b\x0d\xfa\xc7\xe1\x69\xd6\x3f\xcd\xfb\xa7\x45\xff\xb4\xec\x9f\x56\xfd\xd3\x5d\xff\x44\x59\x68\x53\xf6\x97\xb1\xd0\x0e\xa3\xdd\x0e\x03\xde\x0e\x63\xde\xf6\xc3\xde\xf6\x23\xdf\xf6\x83\xdf\xf6\xe3\xdf\xf6\x2a\xd0\xf6\x5a\xd0\xf6\x8a\xd0\xa6\xee\x1a\x58\x33\x38\xef\xbe\x9b\x34\xcc\x27\xe7\xec\xda\x93\x97\x8a\x3f\x34\xfa\x0f\x8d\x7e\x79\x8d\xfe\x6a\x0f\xe4\x0f\x35\xfd\x43\x4d\x6f\x56\x4d\x07\xc7\xf6\x0f\x35\xfd\x43\x4d\x6f\x56\x4d\xb9\xfd\xd2\x1f\x7a\xfa\x87\x9e\xde\x88\x9e\x76\xf0\x67\x61\xf3\xbc\x0b\xeb\xa4\xde\xf8\xc3\xd6\xb9\xac\xd0\x1e\x55\x15\x8a\x49\xa8\xd1\xdf\x8a\x60\xdc\xa9\xad\xae\x62\x33\x15\xf7\xe2\x87\xaa\x78\xe8\xca\x7a\x6c\xd8\xbd\xbe\x47\x9b\xe9\x96\xaf\x97\x42\x39\xb8\x1b\xe1\xa9\x29\xce\x0a\x7e\x5f\xc0\x8f\x0f\x73\xe0\xb0\x0d\xa3\x30\x94\x88\xbf\x08\x76\x12\x97\xc7\xd3\x6c\x14\xea\x3b\x6f\x86\xff\xf7\x5e\xc4\x3f\x14\x03\x45\x43\x5f\xfa\x32\x42\x32\x18\x45\x72\xba\xf4\x96\xdd\xff\x56\x12\x4d\xae\x1c\x2a\xe3\x24\xd8\x17\x12\xb2\xb3\x51\x64\x83\x85\x44\xaf\x2b\x10\x7e\x0c\x14\x82\x05\x45\x3d\x1f\x85\x7a\x36\x83\xa5\xc8\x95\x43\x65\x03\xbd\xa1\x90\x90\x5d\x8c\x22\x3b\x9f\xc2\x82\xe4\xca\xa1\xb2\x81\xec\x50\x48\xc8\x2e\x47\x91\x5d\xf8\x12\xbd\xae\x40\xf8\x31\x50\x58\x30\x5d\x5f\x8d\x43\xad\x51\xc7\x05\xa0\x8f\x0b\x48\x21\x17\x92\x46\xde\x8d\x22\xbb\xd4\x68\xe4\x12\xd0\xc8\x25\xa4\x91\x4b\x49\x23\xd7\xa3\xc8\xae\x64\x8d\x5c\xf1\x1a\xb9\x12\x34\x72\xc5\x34\x72\xea\x8f\x9b\xd7\x1a\x95\xbc\x03\x54\xf2\x0e\x52\xc9\x3b\x49\x25\xa7\xe3\xec\xc9\x5a\xa3\x93\x6b\x40\x27\xd7\x90\x4e\xae\x25\x9d\x9c\x8e\x34\x2a\xbe\xac\x95\xe4\x95\x95\xf0\x4b\x36\xc2\xe5\x29\x4d\x5d\xff\x5c\x71\x6f\x34\x71\xd1\x94\x16\x71\xca\x84\xcb\x03\x5a\xce\x1b\x20\x5c\x31\xa3\x15\xd8\x6e\xe0\x92\x39\x2d\xe1\x67\x36\xae\x58\xd0\x0a\x7e\xee\xe1\x8a\x25\xad\x58\xf4\x9c\xad\x58\x89\xcc\xc7\x1d\xad\x58\xca\x7c\xac\x69\xc5\xaa\xe7\x63\xca\xba\x77\x27\x33\x32\x65\xbd\x5c\xcb\x9c\x4c\xfb\x7e\x52\x29\xd5\x47\xd7\x3f\xf7\xaf\x14\x68\xc9\x94\x94\x08\xbc\xd5\x47\x37\x20\xc5\xa2\x88\xea\xa3\x3b\x23\xe5\x54\x42\xf5\xd1\x9d\x93\x02\x51\x40\xf5\xd1\x5d\x90\x72\x51\x3e\xf5\xd1\x5d\x92\xf2\x45\xcf\xd2\x8a\x16\xc8\x1c\xdc\x91\xf2\xa5\xcc\xc1\x9a\x94\xaf\x7a\x0e\xa6\xb4\x53\x77\x32\x0b\x53\xda\xb7\xb5\xcc\xc3\x94\xf5\x0e\x0b\x86\x7c\x62\xe2\x4e\xcf\x7c\x48\x98\xe3\x86\xd6\x07\x42\x3d\x2f\x18\x0a\x30\x13\x00\xb0\x84\x68\xcd\x5c\xa8\xe1\x45\x45\x01\x16\x02\x00\x2f\x33\x0a\xb0\x14\x00\x16\x1c\xdb\x2b\xb1\x46\xe5\xfb\x4e\x00\x58\xaa\x7c\xaf\x05\x80\x15\xc7\xf7\xd4\x17\x65\xa2\x32\x3e\x15\xa5\xc6\x49\xda\x18\x4e\x74\xeb\xec\x56\xbd\xb9\x3a\x7b\x61\x87\xae\xf3\xe4\x5f\xdf\xa7\xeb\x36\x0d\x6f\xe3\xd6\x75\x9b\x94\x97\xf3\xec\xba\x8d\xcf\xdb\x38\x77\xdd\x46\xeb\x6d\xfc\xbb\x6e\x63\xf7\x72\x2e\x5e\xb7\x59\x7c\x1b\x2f\xaf\xdb\x9c\xbe\x8d\xa3\xd7\x6d\x86\x5f\xce\xd7\xc3\x3b\xfa\xb7\x71\xf7\x70\x04\xe1\x6d\x3c\x3e\x1c\xb1\x78\x61\xa7\xaf\xce\x20\xbf\x0f\x5b\x58\xd8\xf5\xc3\x66\x50\xe3\xfd\x61\x43\x25\x3b\x80\xd8\xbe\x68\x7c\x40\x6c\x01\x34\x6e\x20\x9e\xa3\xb2\x27\x88\xa7\x96\xc6\x19\xc4\xca\xaf\xf1\x07\xb1\x7a\xca\x2e\x21\xd1\x2a\x8d\x57\x48\xc6\x5d\xe3\x18\x92\x91\x51\x7c\x43\x2c\x4c\xd9\x3d\xc4\xb2\x04\x3d\x44\x2c\x4a\xd8\x49\xc4\x92\x94\xfc\x44\x2c\x48\xd8\x55\xc4\x72\x84\xbd\x45\x2c\x46\xc9\x61\xc4\x52\x84\x7d\x46\x2c\x44\xd8\x6d\xc4\x32\x94\x3c\x47\x22\x42\xd8\x79\x24\x12\x84\xfd\x47\x22\x40\xd5\x85\xc4\x12\x94\x0e\x16\x0c\x55\x36\x07\x13\x0b\xd4\xe2\x63\x62\xc9\xea\xdc\x4c\x2c\x62\x8b\xa7\x89\x65\x6d\x71\x36\xb1\xd0\x75\xfe\x26\x96\xbe\xc5\xe5\xc4\xc3\x60\xf1\x3a\xf1\x78\xe8\x1c\x4f\x32\x30\x16\xdf\x93\x8c\x90\xc6\xfd\x34\xbf\x27\x74\xb3\xf8\x56\xfd\xcf\x2c\x7e\x61\xff\x33\x8b\xdf\xc2\xff\xcc\xe2\xb7\xf2\x3f\xb3\xf8\x25\xfd\xcf\x2c\x7e\x2b\xff\x33\x8b\xdf\xca\xff\xcc\xe2\x97\xf4\x3f\xb3\xf8\xad\xfc\xcf\x2c\x7e\x2b\xff\x33\x8b\x5f\xd2\xff\xc4\x2f\xb5\xde\xc6\xff\xc4\x2f\xd1\xde\xc6\xff\xc4\x2f\xed\x5e\xd8\xff\xcc\x62\xc8\xff\xc4\x16\x16\xf6\x3f\xb1\x19\xd4\xf8\x9f\xd8\x50\xc9\xfe\x27\xb6\x2f\x1a\xff\x13\x5b\x00\x8d\xff\x89\xe7\xa8\xec\x7f\xe2\xa9\xa5\xf1\x3f\xb1\xf2\x6b\xfc\x4f\xac\x9e\xb2\xff\x49\xb4\x4a\xe3\x7f\x92\x71\xd7\xf8\x9f\x64\x64\x14\xff\x13\x0b\x53\xf6\x3f\xb1\x2c\x41\xff\x13\x8b\x12\xf6\x3f\xb1\x24\x25\xff\x13\x0b\x12\xf6\x3f\xb1\x1c\x61\xff\x13\x8b\x51\xf2\x3f\xb1\x14\x61\xff\x13\x0b\x11\xf6\x3f\xb1\x0c\x25\xff\x93\x88\x10\xf6\x3f\x89\x04\x61\xff\x93\x08\x50\xf5\x3f\xb1\x04\x61\xff\x13\xcb\xd1\xec\x7f\x62\x81\x5a\xfc\x4f\x2c\x59\x9d\xff\x89\x45\x6c\xf1\x3f\xb1\xac\x2d\xfe\x27\x16\xba\xce\xff\xc4\xd2\xb7\xf8\x9f\x78\x18\x2c\xfe\x27\x1e\x0f\x9d\xff\x49\x06\xc6\xe2\x7f\x92\x11\x1a\xef\x7f\x72\x07\x80\xdc\xf4\x70\xab\xfe\x67\x7a\x78\x61\xff\x33\x3d\xbc\x85\xff\x99\x1e\xde\xca\xff\x4c\x0f\x2f\xe9\x7f\xa6\x87\xb7\xf2\x3f\xd3\xc3\x5b\xf9\x9f\xe9\xe1\x25\xfd\xcf\xf4\xf0\x56\xfe\x67\x7a\x78\x2b\xff\x33\x3d\xbc\xa4\xff\x89\xcf\x75\xbd\x8d\xff\x89\xcf\x91\xbd\x8d\xff\x89\xcf\xad\xbd\xb0\xff\x99\x1e\x20\xff\x13\x5b\x58\xd8\xff\xc4\x66\x50\xe3\x7f\x62\x43\x25\xfb\x9f\xd8\xbe\x68\xfc\x4f\x6c\x01\x34\xfe\x27\x9e\xa3\xb2\xff\x89\xa7\x96\xc6\xff\xc4\xca\xaf\xf1\x3f\xb1\x7a\xca\xfe\x27\xd1\x2a\x8d\xff\x49\xc6\x5d\xe3\x7f\x92\x91\x51\xfc\x4f\x2c\x4c\xd9\xff\xc4\xb2\x04\xfd\x4f\x2c\x4a\xd8\xff\xc4\x92\x94\xfc\x4f\x2c\x48\xd8\xff\xc4\x72\x84\xfd\x4f\x2c\x46\xc9\xff\xc4\x52\x84\xfd\x4f\x2c\x44\xd8\xff\xc4\x32\x94\xfc\x4f\x22\x42\xd8\xff\x24\x12\x84\xfd\x4f\x22\x40\xd5\xff\xc4\x12\x84\xfd\x4f\x2c\x47\xb3\xff\x89\x05\x6a\xf1\x3f\xb1\x64\x75\xfe\x27\x16\xb1\xc5\xff\xc4\xb2\xb6\xf8\x9f\x58\xe8\x3a\xff\x13\x4b\xdf\xe2\x7f\xe2\x61\xb0\xf8\x9f\x78\x3c\x74\xfe\x27\x19\x18\x8b\xff\x49\x46\x68\xbc\xff\xc9\x9f\xec\x75\xdb\x9b\x3d\x4e\xd9\xbe\xf4\x89\xca\xf6\x4d\x0e\x55\xb6\x6f\x76\xae\xb2\x7d\xd1\xa3\x95\xed\x9b\x9d\xae\x6c\xdf\xec\x80\x65\xfb\xa2\x67\x2c\xdb\x37\x3b\x66\xd9\xbe\xd9\x49\xcb\xf6\x45\x0f\x5b\xb6\x6f\x77\xde\xb2\x7d\xbb\x23\x97\xed\x2b\x9c\xba\x6c\xc1\x83\x97\xad\xfe\xec\x65\x6b\x38\x7e\xd9\x42\x27\x30\x5b\xc3\x21\xcc\xd6\x70\x0e\xb3\x85\x8e\x62\xb6\x86\xd3\x98\xad\xe1\x40\x66\x0b\x9d\xc9\x6c\x4d\xc7\x32\x5b\xd3\xc9\xcc\x16\x3e\x9c\x89\x85\x29\x3b\xa0\x58\x96\xa0\x03\x8a\x45\x09\x3b\xa0\x58\x92\x92\x03\x8a\x05\x09\x3b\xa0\x58\x8e\xb0\x03\x8a\xc5\x28\x39\xa0\x58\x8a\xb0\x03\x8a\x85\x08\x3b\xa0\x58\x86\x92\x03\x4a\x44\x08\x3b\xa0\x44\x82\xb0\x03\x4a\x04\xa8\x3a\xa0\x58\x82\xb0\x03\x8a\xe5\x68\x76\x40\xb1\x40\x2d\x0e\x28\x96\xac\xce\x01\xc5\x22\xb6\x38\xa0\x58\xd6\x16\x07\x14\x0b\x5d\xe7\x80\x62\xe9\x5b\x1c\x50\x3c\x0c\x16\x07\x14\x8f\x87\xce\x01\x25\x03\x63\x71\x40\xc9\x08\xe9\x1c\x50\x9a\x18\x9a\xff\x2a\x5d\x4c\x41\x05\x24\xb9\x85\x52\x44\xf7\x99\x92\x48\xc2\x4f\x29\x11\x6a\x53\x94\x70\xde\xbb\x3e\x8f\x1a\x43\x84\x42\x9c\x2b\x5a\xce\xb5\x8f\xa9\x6f\xc5\x1b\x48\x02\x2d\x96\x5d\x11\x3f\xfe\x80\xff\x7b\xe6\xa8\x6a\xe1\x59\x72\x6c\x30\xd9\x31\x4d\x64\x5d\x67\x5c\x56\xeb\xee\x07\xd7\xe5\xd9\x20\x94\x3e\xe1\x35\x90\xed\x5a\x20\x7a\x7d\xb2\x6c\x5d\x73\x22\x32\x08\x09\x95\xa5\x20\x35\xe6\x18\x96\x6d\xdf\xb3\xa6\x4a\xca\x0e\xbe\x93\x97\xd3\x54\x9b\xbc\x39\xba\xc5\xde\x6d\x1e\x4b\xf4\x5d\x11\xc7\x1f\x55\xc1\xf0\xd9\x0a\xfd\xc5\x47\x86\x09\x67\xe8\x1d\xf0\x90\x84\xbd\xe6\xc6\xab\xa1\x35\xbd\x89\x46\xf8\xf5\xd3\xd0\x2f\x56\x00\x64\x23\xd7\x61\x24\xfc\x08\xed\xaf\x65\x4a\x8b\x82\xe3\xcc\x00\x73\x05\xb3\xf5\x29\x8a\x50\x5d\x4f\xc4\x9f\x1c\x99\xbe\x04\xca\xc7\x1e\xef\xf7\x7e\x7c\x07\x72\x4d\xdb\xe9\x7a\xfe\xa7\xd8\x47\xeb\x68\x69\x6f\xaa\xeb\xb1\x04\x04\x72\x27\x90\x48\xf2\x7d\x31\xe1\x9e\x39\xc4\xe4\x27\x88\x62\x8d\xe2\xfd\x0a\xe4\xb2\x6b\xa4\xed\x5d\x34\x47\xb3\xfd\xcc\xd2\x4e\xd7\x35\x1e\x02\x62\x4a\x44\xfe\x10\x56\x79\x92\x1f\x26\xe2\x4f\x0e\x77\x5f\x02\x66\xd4\xa7\xd9\x39\x01\x36\x68\x3b\x6d\x1f\xf7\xe1\x3e\x88\x22\x7b\x53\x5d\x37\x25\x20\x90\x3b\x81\x44\x1c\xe6\x07\x54\x4d\x84\x5f\x1c\x72\x56\x00\x22\x0a\x62\x14\x23\x90\x57\xd2\x4c\xdb\x4b\xb4\x8b\x22\x4d\x2f\xf9\x96\xba\x4e\x8a\x30\x10\x6b\x3d\x81\xce\x70\xba\x49\x4e\xd2\x55\x36\xc7\xf3\x88\x1c\x7f\xac\x55\x8c\xf6\xe1\x29\x6d\xb8\x56\xf3\xe5\x3c\x9c\x43\x99\xf4\x45\x7b\x4e\xc9\x8d\xa4\xc5\x37\x71\xf8\xe9\xc3\x78\x56\x4b\xc4\xc5\x40\x5d\xe0\x28\xa4\x66\x19\x63\x37\x48\xb8\x15\xaa\xcb\x22\xaf\x93\x7b\x39\x1b\x21\xe7\x32\xf4\xb9\xfd\xda\x4d\x1f\xfa\x91\xee\x4d\xe8\x8a\xba\xba\x63\x82\xbf\x21\xee\xaf\x51\x50\xc9\xe8\x19\xda\x17\x55\xe6\xd2\x7b\xae\xec\xb9\xa6\x49\xea\x57\xea\x9e\x48\x97\x22\x88\x19\x7d\x83\xfe\x16\x04\xed\xd8\x49\xc3\x93\x64\xe1\x81\x5e\xd1\xd4\x6f\xe4\xb8\x36\x69\x52\x6e\x86\xbc\xe8\xed\xd6\x58\x27\xaf\xfb\x42\x66\xe0\xc5\xc7\xd1\xe9\x49\xf9\x81\xe6\x53\x8c\x3a\xde\x74\x51\x4f\xf8\xfd\x26\xb9\x91\x45\x81\xd9\x3e\x2b\x32\x31\x33\xaa\x19\xdf\xb3\x30\xf5\xd2\x48\xc6\xf4\x5a\xd4\xd1\x0d\xd6\x7a\xd4\x96\x61\x1e\x9b\xef\xee\x83\x75\x9c\xa6\xb2\x1f\xa5\x9b\xc2\x2c\x5f\x44\xbb\xd9\x7e\x48\x78\x2f\xa3\xe5\xee\x8f\x2a\x4f\x8d\x5b\xa6\x61\x84\x8e\xf8\xae\xbd\xb3\x98\xb7\xbf\x28\xc3\x28\x69\x1e\x71\x02\x59\xa9\x5f\xc5\x6f\x4f\x68\xd7\x89\xe3\xc9\x34\xaf\x6f\xd2\x27\xe0\x17\x8a\x7f\xad\x50\x18\x17\x79\xfa\xf8\x19\x5a\x12\x48\x3a\x64\x1b\x46\x28\x6f\x3f\xb9\x27\x40\x84\xc7\x77\x51\x74\x66\x87\xdd\x4b\x91\x9d\xd2\x26\x29\x53\xf4\xf9\x23\xbb\x81\x2b\x0a\xd3\xe8\xbb\x80\x26\x65\xfe\xc1\x09\xca\xf6\x23\x88\x0a\xeb\x02\xd1\xa8\xfb\x30\x3d\xa1\x31\x6a\x21\x72\x8f\x6f\xcc\x12\x65\xe1\x56\xdd\x22\x29\xdd\x81\x85\xa3\x54\x18\x8a\x5c\xc0\xc0\x5f\xfa\x80\xb9\x25\x96\xd5\x75\x3a\x9b\xf5\xbd\x13\x7c\x94\xef\x80\x80\x81\xe4\x1b\x51\x24\x32\x6e\x7a\x00\x28\xad\x46\x91\x52\xa0\x80\xfc\xf6\x12\xb5\x3a\x03\xa8\x05\xa3\xa8\x29\x50\x03\x35\xef\x6e\x25\x53\x23\x37\x23\x08\x17\x67\x80\xf7\x66\x2c\xd4\x1c\xe5\xfe\x56\x4e\xc7\x2f\x8c\x5d\xdd\x84\x4d\x12\x3d\x15\xb5\xb2\x04\x52\x1b\x44\x16\x21\x20\xd5\x2f\x5d\x62\xcb\xd6\xf1\x41\x46\xc4\xb2\xf4\x30\xb1\x03\xd5\xd9\xc4\x23\xf6\x00\xdf\x9e\xe5\xa6\x87\x9f\xac\x8d\xc6\xb5\xe0\x61\xc2\x38\x2e\x72\xb5\x19\xff\x7b\xd7\xe4\x30\x9e\x5d\x23\xb5\xac\xb3\x6b\x59\xd4\xb5\xb0\xb0\xd8\x35\x1b\xcb\xa2\x35\xf9\xa5\x51\xea\x32\x83\x66\x3e\xc6\xb2\xca\xb1\xc5\x52\xce\xcb\xb7\x7d\xd0\xd9\x02\xa6\xcb\xb6\x12\xa0\x36\x72\xd7\xe4\x26\x2b\xab\x30\x7a\xa5\x95\xd6\xb5\x57\x24\x62\x44\x02\x10\x75\xeb\x6c\xcc\xea\x30\xf5\xee\xa6\xd4\x80\x29\xd3\xcb\x34\x0f\xcc\xea\x3e\x76\x46\x08\x63\x48\x8c\xec\x54\xbd\xb2\x25\x80\x06\x71\xa6\x0c\x22\x44\xe1\x29\x83\x98\x1e\xbe\x6e\x10\x87\xf6\x5f\x3f\x88\xe9\x61\xcc\x20\xce\xbc\x29\x8e\xbe\x0e\xc3\x88\x69\x02\xb7\x93\xd1\xea\x06\xb5\x8d\x3e\xf7\xbb\x27\x28\xc4\x11\x45\x5f\x80\xac\xa3\x60\x6b\xe1\xba\x24\xae\xbd\xc7\xfc\x1a\x87\x2b\xa4\xab\xbf\xe8\x6a\x01\x7e\x8f\xda\x44\x4c\x14\x45\xf5\x43\x5e\x7f\xa4\x5b\xb1\x78\x2c\xe4\x1e\xe0\xbe\x4f\xe1\xae\x2e\xd2\x53\x83\x54\x19\x48\xb9\x85\x55\xc1\x10\x54\x9b\xce\xdb\x23\x37\x8d\x0c\x58\x89\xf5\x94\x80\xf1\xa5\x27\x9a\xfb\x16\x64\x38\x40\x56\xf0\x6d\x60\x6a\xd3\x1f\x00\xaa\x7c\x57\xd8\x25\x3e\xa2\xf7\x86\x50\xdc\x79\x79\x67\xad\x2a\x50\x40\x16\xac\x11\xcd\x0d\x8b\x36\x0a\xa5\x34\x10\x24\xad\x1f\x81\x7a\x89\x46\x85\x4a\x14\x36\x9b\xbc\xa0\x4f\x7c\x5d\x2f\xd2\x08\x75\x43\xe9\x90\xcb\xee\xbd\xc5\x52\xdc\xaa\x72\x2d\xa8\xe1\x20\x96\xcd\x61\x0f\x5b\x2b\xc4\xc5\x3b\x86\x35\xeb\x8a\x23\xb9\x74\x13\xa9\xf2\x54\x37\x05\x67\x0f\x85\x4a\x79\xe4\xc0\x6a\x49\xee\x26\x18\x61\xaa\x2c\xa2\xdd\xdd\x22\xba\xe8\xc1\xcf\xca\x6e\x4d\x85\x57\x6c\x93\x88\x5d\xdd\xf0\xe1\x42\x75\x3f\x13\xee\x97\x28\x34\xf0\xc2\x4a\xcf\x4a\x74\xe3\x54\xa5\xdf\xbd\x8b\xc3\x26\xdc\xe0\xdf\x9f\xea\xfb\xc3\x0f\x6d\x96\x6e\xa3\x63\x58\xd5\xa8\xf9\xf1\xd4\xec\xef\x26\xef\x67\x7f\xad\xef\x0f\x4e\x9b\xa5\x79\xfd\xe3\x87\x63\xd3\x94\x9b\x4f\x9f\x1e\x1e\x1e\xbc\x87\x99\x57\x54\x87\x4f\x81\xef\xfb\x5d\xcb\x0f\xce\x7d\x82\x1e\xfe\x52\xb4\x3f\x7e\xc0\xef\xe8\x9d\xbb\x0f\xef\x67\xff\xf1\x7e\xf6\xd7\x32\x6c\x8e\xce\x3e\x49\xd3\x1f\x3f\xbc\x0f\x66\xa4\x1f\x1f\x9c\xf8\xc7\x0f\xbf\x04\xde\xcc\x59\x7a\xab\xd9\xcf\xde\xd2\x99\x7b\x8b\x59\xe4\x7a\x73\x77\xea\xf9\x73\x6f\xbe\x74\xa7\xde\xbc\xd3\x0a\xd7\xbb\x4b\xa7\xde\xd4\xe9\x7e\xce\xbc\xb9\x3b\xf3\xee\x22\x6f\xe9\x7a\xcb\x99\x33\xed\xfe\x06\x2b\x67\xea\x05\xde\x2a\x75\xe7\xce\xdc\x5b\x76\x28\x66\xde\xc2\xf5\xee\x30\xaa\xa9\x37\xfd\xed\xc3\x27\xc2\x47\xc7\xe4\xfb\xd9\x7f\xbc\xfb\x48\x64\x45\x27\x06\xac\x63\x43\x25\xa0\x63\x7d\x25\xac\x63\x52\x35\xa8\x63\x30\x8c\xa0\x63\x7b\x3f\x8c\xe7\xe8\xa2\x07\x97\xe3\x7e\x10\xbc\x56\xc7\x08\xf4\x16\x42\xa1\xdb\x68\xea\xf9\x66\x36\xe6\x26\x14\x8c\x74\x82\x28\xd8\xdc\x9b\x3b\x0b\x6f\x16\xcc\x8f\xae\x77\x77\xef\x06\xde\x7c\x79\xf4\xee\x7e\xcb\xfc\x4e\x9d\x82\xae\xf0\xff\x5d\x78\x77\xeb\xae\xec\x97\x99\xb7\x5a\x7a\xcb\xd9\xcf\x9e\x3f\x77\x56\x9e\xbf\x5a\x44\xae\x37\x9d\x2e\xbc\xc0\xf3\xa7\x4b\x6f\x1e\x2c\xbc\xa0\xfb\xb3\x3c\xae\xbc\xd9\x7a\x15\x79\xc1\x3c\x70\x7c\xc7\x9b\xad\x02\xd7\x0b\x82\xa5\x17\x2c\xee\xdc\xae\xfe\xaf\x4b\x6f\x15\x74\xfa\xbc\x0e\x3a\xe2\xf3\x95\x13\x78\xab\xb5\x33\xf7\x82\xc5\xcc\x5b\xce\x30\xd6\x99\xeb\x4d\x57\x73\xd7\x9b\xad\xe9\xc3\x7c\x3d\x77\x7c\x9d\xa6\x12\x6b\x0f\x2b\x6a\x5f\x07\xe8\x29\xab\x83\xd5\x54\xac\x05\xb5\x14\x04\x11\x94\x34\x5e\x2f\x66\xf3\xfd\x45\x0b\x2d\xe9\x28\x04\xae\x55\x51\x02\xbc\x85\x30\x40\x2a\x1a\xef\x57\xfb\x95\x9e\x13\x5a\xf8\xe2\x3a\xda\xeb\x21\xe1\x94\x53\x5a\x37\x70\xdc\xc0\x59\x39\x2b\x5e\x6d\xeb\xa6\x2a\xbe\x20\xa1\x41\xa7\xb8\xbe\xe3\xa7\x33\x67\x96\xf9\xee\xec\x67\xdf\x99\x31\xc5\x88\x92\x2a\x4a\x91\x53\xfd\xf8\xc1\x5b\x48\x65\x51\xfb\xe3\x87\xd9\x07\xb8\xea\x51\x5f\x45\x5a\x41\x10\x9c\x12\x62\x39\x4a\xae\x13\x17\x2a\x7d\x8e\x1b\x39\xf0\x55\xac\x55\xf1\xe0\x88\xb7\x72\x88\xc5\x10\x24\x17\xb1\x25\x2e\x19\x71\x51\xfa\x0a\x5c\x88\xaf\xa4\xab\xfb\x2a\x86\x5d\x68\xa0\x02\x0a\x1d\xe7\xa7\x11\x77\xb4\xc2\x90\x6d\x8b\x6f\x2c\xde\x73\xfa\x7c\xb2\x7b\x89\x6e\x0b\xc8\xcb\x30\xfa\x22\x97\xff\xf3\x54\x37\xc9\xfe\xd1\x65\x77\xbb\xc9\xf8\xf9\x36\x1a\x58\x25\x52\xa8\x4a\x9a\x6c\xa0\x5e\x46\x64\x5f\x75\xaa\xf9\xe6\xf5\x76\x8c\x74\xe5\x77\x6c\xc2\xd5\xbb\xc3\xb9\x6d\xf9\xd0\x8f\xb0\xdf\x81\x10\xb2\x90\xa5\x61\x87\xc5\x9a\x71\x86\xff\xcc\x9f\x14\xd7\xe3\x26\xb3\x48\xde\x66\x8e\x67\x11\xcf\xdd\x3f\x26\x21\x2b\xe6\x86\xd9\x70\xef\x1c\xac\x3e\xba\x58\x80\x01\x5a\xda\xf3\xcb\x37\x6e\x09\xb4\xf9\x7b\x2c\xe5\x0b\x83\x04\xfc\xa2\xdf\xf3\xc7\xe0\xf6\xb0\xc6\x51\x11\xa5\xe6\x26\x79\x9c\x44\x61\x53\x54\x72\xec\x64\x6b\xba\x99\x5b\x18\x23\xf9\x70\x20\x6a\x1b\xaa\x40\x12\xe9\xce\x3f\x63\x5e\xa6\xc6\xf9\x3c\x63\x55\xb8\x5c\x70\x70\x12\xe4\x40\xba\x30\x57\x7d\xd3\xc1\xdd\x8f\xca\x94\xfd\x98\x34\xc8\xc5\x37\x54\x6e\xf2\x02\xdb\x60\xd0\x70\xf4\x63\x70\xaa\x51\xe5\x92\x88\x20\x3d\x06\x90\x15\xbf\x41\xa5\xb5\x5a\xa8\x14\x28\x47\x00\xf8\xb7\x2f\xc0\x4d\xb6\xd2\x61\x86\xb7\xbc\xbf\x14\x0f\x03\xbd\xcd\x1f\x3f\x92\xc3\x3c\xe0\x35\xfd\x5d\xbd\xc7\x81\x4a\x17\xf3\x6f\xd5\xf7\xeb\x78\x59\xf5\x9d\xa0\x6c\xc9\xa9\x88\x60\x32\x9d\xae\x26\xc1\x74\x39\xf1\x02\x7c\x32\x62\x1c\x20\xa1\x3c\xbc\x0d\xee\x88\x1b\xde\xe4\xf6\x6f\x7f\xbd\xe5\x82\x34\x65\x27\x15\xbb\x86\xe4\x59\xdd\x29\xe0\x2e\x86\x22\x25\x76\x8f\xfa\xaf\xac\xe4\xb3\x13\x92\xa0\x3a\x89\x7a\xba\xe8\x1e\xe5\x4d\x3d\x88\xc7\x2d\xab\x24\x0b\xab\x47\xf3\xa9\x20\x3f\x58\x2d\xe2\x3b\x69\xef\x43\x0a\x05\x2c\x74\x30\x2c\xb8\x16\x61\xb8\x90\x71\x4d\x17\xf3\xf5\x4e\xc0\xc5\x0d\x5c\x8f\x9e\x0c\xe0\x55\xc3\x36\x76\xd4\xe8\xa0\xf5\xd4\x85\xc1\xeb\x19\xe8\x07\xf1\xe9\x32\xe2\xc7\xb6\xc7\xcb\xca\xea\x63\xf1\xf0\x93\xc8\x47\x55\x94\x71\xf1\xd0\x2d\x48\x87\x43\x6a\x39\xbd\xc5\x64\x0b\x9e\x1b\xd2\x4b\xbc\x46\x51\x91\xc7\x9c\x16\xb0\x5b\x65\x47\x9c\xfc\xc0\xe7\xd9\x04\x24\xa2\x12\x68\x51\xa1\x65\xf7\x8f\x84\x2d\x8c\xbb\x7f\x24\x84\xbc\x26\x0c\x54\x46\xeb\x82\x3f\x9f\xb0\x7f\x2d\xda\x20\x42\xca\x5c\x88\x1a\x31\x30\x62\xd0\x89\x31\xe2\x12\xf4\x61\xc0\xaa\x6a\x04\xc7\x09\xac\x13\x56\x51\x8f\x50\x0b\x7e\x00\x92\x7c\x5f\x98\xf5\x6d\xb1\x8b\xfc\x58\x46\x41\x0a\x07\x14\x63\x8c\xc2\x6c\xba\xf3\x63\xd9\x28\x04\x61\xb8\x8b\x83\x01\x11\xaf\x07\x18\xf1\x58\x15\x58\x4f\x27\xd3\x75\x30\x09\x82\xc0\xa2\x01\x22\x20\x47\x59\x1c\x7b\x4c\xdc\x30\xec\xa3\xc4\x22\x8c\x3b\xc6\xa8\x0e\x39\xa1\x7d\x8d\x05\x60\x82\x1c\x31\xd4\xbc\x78\x59\x4c\xde\x3c\xda\xfa\x17\x01\x02\x96\x31\x03\x3e\x9f\xaf\xe3\xf9\x5c\xc2\x35\x9f\xae\x97\xf3\xa9\x80\x4b\x98\xfb\x14\xfd\xe8\x61\x0f\x26\xd3\xbb\xf9\x64\x6d\x1d\x75\x1e\x4e\xa4\x2e\xcd\x79\xca\x80\x69\xe8\x47\xca\x48\x9c\xf5\x14\x2f\x30\xe7\x19\x1f\xd7\xe8\x00\x93\xed\x08\x1d\xe0\x25\xce\xc2\xe6\x46\xdc\x86\x40\xbd\x80\x65\x8c\x0e\xa0\x68\xbd\x9a\xca\x06\x12\xed\xd6\xb3\xe9\x52\xc0\xc5\xeb\x00\x43\x3f\xda\xfa\xcf\xfd\xc9\x74\x35\x9b\xac\xee\x6c\xc6\x5f\x00\x14\xe9\x8b\x5a\xc0\x58\x30\xd9\xfd\x91\x52\x12\xb4\x80\xe1\x55\xb5\xa0\xe7\xe3\x1a\x2d\x60\xd2\x1d\xa1\x05\xbc\xcc\x69\x5c\xda\x88\xda\x10\x0a\xe7\x91\x8c\xd1\x81\x68\x3d\xf3\x03\x79\xbe\x44\xd3\x00\x05\x21\x8f\x8a\x57\x01\x8a\x7c\xb4\x06\x4c\x57\x93\xbb\xd9\x64\xb5\xb6\x29\x00\x0f\x27\xd0\x16\x87\x9f\x92\x37\x8c\xfe\x48\xf1\x08\x83\x4f\xb1\xaa\x63\xcf\x78\xb8\x66\xe8\x99\x50\x47\x0c\x3d\x2f\x6a\xba\x31\x92\xb7\x04\xcc\xb1\x85\xb1\x8d\xb8\xb2\x1f\xf0\x85\x25\x52\xe3\xf6\x0d\x16\xff\x5a\xc2\xc9\xab\x8c\x4c\xee\x15\xf6\x11\x32\x37\xa2\x12\xc9\x0c\x0d\x9b\x43\x9d\xcc\x15\xe9\xc2\x64\x78\x9d\x92\x89\xa8\xca\xa5\x30\x79\xdd\x66\x63\xe4\x80\x28\xdb\x8b\x28\xd2\x2a\xe7\x78\x75\xea\x3d\x69\x85\xcc\x28\xbb\x13\x29\x46\x47\x8b\x0f\xd2\xa4\x57\xdf\x87\xa8\x5c\xc1\x1a\x05\xec\x4b\x60\xa9\x5b\x14\x0a\xde\x9f\xa8\x54\xf4\x4a\x65\xdd\xaf\x3c\x79\x64\xf8\x8d\x09\xf3\xb5\xbf\x56\x9d\x78\xf7\x9c\xa7\x33\x46\x99\xac\xfe\x3e\x8f\x10\xd2\xa6\xd7\xdb\xcd\x08\x9c\xc0\x1a\x24\xee\x6e\xb4\x62\xb6\xe8\x8f\xb2\xc5\x11\xd0\xeb\xb5\xe6\xfa\x2d\xcf\x68\xe9\x4b\x9b\x1c\xf5\x08\xd3\x13\x35\x87\xf3\xee\x25\x52\xa3\x94\xc7\xb6\x63\x90\x70\x82\xd6\xe8\xf5\x76\x46\x32\x37\x1a\x2b\x24\xef\x94\x2c\xc7\xc6\xf4\x66\x08\xd8\x2e\xc9\x44\x0c\x26\xe8\x29\xdb\xa7\xd1\x03\x22\x6f\x98\x94\xe3\x4a\x4f\xd3\x27\x7e\x9f\x20\x91\x1a\xa3\x4f\xd6\xbd\x87\x84\x13\xd2\xa7\x57\xdd\x65\xc9\xfc\xc0\x1a\xa5\xec\xba\x2c\x87\xc4\xb4\x1a\x05\x6d\xbd\x64\x22\x7a\x8d\x7a\xd2\x56\x6c\xf4\x90\x88\x9b\x2f\xf5\x70\xd1\xd3\x14\x8a\xdf\x7a\x88\x94\xc6\xe8\x93\x75\x37\x23\xa2\x84\xd4\xe9\xf5\x76\x6c\x12\x2f\xb0\x2a\xc9\x3b\x38\xad\xb8\x2d\x9a\x04\x6c\xe3\x24\x12\x7a\x3d\x7a\xca\xb6\xce\x3a\x12\x69\x92\x7f\x39\xcb\x2f\x23\x41\x6f\x9d\xbe\xba\xf3\x87\x76\x93\xfe\x49\xe8\x50\x57\xb0\x51\x0a\xf4\x9b\x5f\x45\x58\x22\x6e\x15\x15\x51\x0a\xa1\x4f\x20\x0e\xf6\xd1\xbe\x1d\x90\x53\x40\xae\x61\xff\xda\x63\x1e\xdd\x45\x5b\xf9\x75\xe1\x29\x8f\x51\xd5\x0d\xcc\x88\xe1\x17\x25\x40\xf1\x92\xaf\x15\x00\x00\x85\x9d\xbe\xc2\xf2\xe2\x92\xfb\x88\x05\x7f\x13\x86\x11\x1c\xbe\xee\xeb\x98\x01\x6d\x9d\x71\x68\x87\x4f\x13\x9f\xf4\xe1\x54\x87\x02\xbf\x08\xd7\x7e\x22\xcf\xc1\xfc\xc0\x81\xf3\xdf\x15\xe0\xd3\xf6\xf8\x4c\xc6\xaf\xcd\x63\x89\x7e\xdc\x9d\x9a\xa6\xc8\x3f\x0f\xd0\x13\xae\xb2\x42\x35\x6a\x34\x75\xf5\x69\x97\x25\x7c\x25\x7f\x3c\xce\xdb\x87\x31\x3a\xb3\xd7\xad\x3e\xf4\xd2\x9a\x56\xe2\xaf\xab\x9d\x4e\x25\xc2\x4a\x7a\x69\x0d\x41\x98\xab\x09\x5d\x6c\x06\xce\xdc\x97\xbe\x51\x91\xa6\x61\x59\x0f\xa7\x18\xc9\xe0\xb3\x62\x02\x2f\x7e\x2a\xdb\x54\x9a\x6a\x9a\xd4\xa0\x78\xb8\xe0\xec\x38\x36\x28\xa2\x06\x3d\x2d\xfc\x49\x86\x72\x14\x86\x1e\x61\xf0\xfb\x74\x0b\x9b\x63\x12\xc7\x28\x87\xc4\x46\x60\x1d\x6f\xb6\x20\xaf\xeb\x25\x99\x29\xd5\x86\xba\x4b\x6f\x16\x27\xf8\xe9\x54\xaa\xbc\x5d\x64\xd3\xb9\xd9\x84\xfb\x06\x55\xa6\x13\x64\xfe\xd0\x21\xe1\xdb\x97\x99\x7a\x60\x84\x1e\xbe\x60\x87\x58\xde\xbd\xe3\x73\x4b\x75\x0d\xc8\xb9\x89\x7e\x3e\x90\xb3\x27\x7d\x39\xf4\x35\x6b\x4f\x4b\x05\x51\x3b\x23\x9d\x54\xb8\x50\x39\x38\xba\x5e\x73\xdc\xf9\x52\x0e\xab\x81\x24\x47\x26\x43\xf9\x09\xf8\xde\x09\x67\xce\xf2\xfd\xf7\x5b\x72\x4c\x67\xfb\x9b\x9b\xe4\x31\x6a\xbb\x32\x7f\xcb\x2b\xe9\x76\x9f\x16\x61\xb3\xe9\xc0\xb6\x5c\x62\x59\x9f\xfb\x18\x98\x9e\x1f\x61\xb2\xde\xb0\x4f\x6b\x7c\x47\xfe\xca\x78\x2b\xbe\xbf\xe4\x0e\xcb\x60\xfc\x69\x52\x37\x34\xa7\x07\xec\xf9\xe0\xe5\xf2\x4d\xb2\x62\x70\x12\x8d\x93\xfb\x24\x46\x55\xff\x19\x65\xd9\xf6\x1d\xa7\x72\x90\x27\x91\x3e\x5f\x4b\x8f\x34\x69\x50\x66\xcf\x3b\x32\x2b\x5b\xb6\x0e\x44\x29\x0a\xab\xcd\xae\x68\x8e\xca\xa1\x24\xad\x90\x93\xfc\x88\xaa\xa4\x81\x8e\x24\x0d\x2c\x76\xbe\x17\x97\x34\x42\xe0\x90\x2d\x71\x62\xa1\xb0\xec\x4e\xe3\x29\x9a\xee\x95\x65\x57\x37\x9e\xab\xfd\x6a\xbf\x96\xa8\xf4\x6e\x89\x48\x86\x9e\x8e\xe1\x34\x61\x24\x11\x16\xa9\x14\x89\x0c\x1e\xa3\x48\x06\x5e\xef\x81\xaf\x13\x2d\x0e\x04\xf1\x04\xc5\x79\x28\x25\x43\xc0\x20\xa1\x3c\xf9\x7b\x70\x62\x6c\xce\xec\xc3\x6b\x2e\x4d\xa4\x08\xd6\x55\x70\x19\x39\xb7\xec\xe4\x5d\x0f\x75\x44\x61\xcc\x19\x4c\xa2\x5e\xd2\xe1\x2f\x5b\x92\x00\xe6\x17\x88\x52\x51\x35\x89\x23\xdb\xc9\xa7\xfb\x31\x98\x9f\x7d\xd2\xa2\x78\x4b\x6c\x17\xeb\xd6\x90\x35\x40\xb4\x44\xeb\x35\x64\x0c\xb1\x18\x3b\x04\xb8\xa7\xec\xf3\x56\x35\xb7\x60\xff\x55\x5f\xef\x08\x4d\x38\x9f\x88\xad\x01\x86\x8f\x5b\x87\x3c\x26\x64\x75\x01\xce\x73\xd2\x2a\xe5\x58\x27\x57\xce\x37\xe3\xc1\x35\x47\x87\x55\x0e\x39\xdf\x0d\x57\xd0\x0f\xa7\x15\xb6\xed\x87\xcc\xa7\xca\x21\xf3\xa9\x70\xc8\x9c\xfc\xd2\xf2\x40\x66\xb9\xcc\x09\x9d\xfb\x6c\xcc\x02\x6d\x73\x61\xab\x01\xa1\xb7\xd5\x73\xce\xf5\x40\x5e\xc5\xaa\x41\xc6\xe1\x00\x99\x75\xba\xc7\x1f\x24\x59\x0f\x85\x8a\x06\x39\xc3\x23\xd8\x8a\xab\xd2\x6b\x1f\x48\x14\xa8\xb5\x60\x80\xd9\xd0\xc2\x88\x1f\x88\xd3\xcf\x9b\xcb\x96\x08\xa3\x29\x8a\x74\x17\x56\x2f\x74\x9c\x19\x9f\x1e\xae\x9b\xb0\x6a\xb4\x07\x8e\xf1\x29\x63\x0a\x22\x1c\x3a\x26\x65\x7a\x70\x81\x7f\xfd\x19\x7f\x49\x23\xf2\xa2\xf9\x6e\xb3\x4f\xaa\xba\x21\xdf\x70\x93\xef\xec\x37\x69\x28\x16\xc8\xce\xd8\xc7\x33\xb8\xbb\xe6\x55\x6d\xc0\x29\x67\xa7\xd5\x43\x5e\x49\x9c\x26\xe1\xc4\x86\xb4\xe7\x84\x73\x5f\xa5\x1a\x85\xf2\x40\x48\x95\x83\x30\x77\x64\x57\x54\x81\x96\x38\xea\x7a\x0a\x32\x24\x54\xc8\xfc\xd0\xd1\x1a\xfc\x4d\x18\x60\xc4\x98\x11\x23\x69\x19\x22\x8a\xcd\x24\x7e\x59\x4c\xb2\x41\x19\x85\x42\x0e\xfc\x3c\xcf\xe0\x51\xd2\xa6\x21\x54\x15\xf1\x2b\x47\x49\xdd\x93\x28\x76\xd6\x2b\x4a\x94\x2b\x70\xbc\x87\x83\x8d\x9a\x54\xef\xd6\x65\x9a\x34\x52\xa6\x00\x9a\x5d\x4f\xf8\x9c\x80\x25\x2f\xd0\x23\x61\xdb\x24\xdd\x9c\x63\xe1\x10\x4d\x73\x16\x25\x19\xc9\xe2\x0c\xe2\x71\xb6\x92\x3c\x0f\x16\xd9\x31\xd2\x4c\x0f\xe3\x68\xf6\x19\x0d\xa4\x4c\x18\x8a\xbf\x33\x38\x39\xaf\xe3\xd2\xf0\x86\xbe\xa8\x92\xce\x3a\x33\x0e\x84\xba\x38\xa9\x50\x44\xdd\xf5\x2a\xe3\x2a\xb1\x2d\x1f\x6a\xa3\x22\x3d\x65\xf9\xb0\x0a\x28\x35\x1a\x78\xe5\xf3\x19\x71\xc1\xe1\x3f\x8a\x81\x16\x1b\xbe\x8d\x0e\xf6\xc5\x3f\xa2\x81\x86\xd1\x19\xb1\xc0\x9f\xe5\x40\x1c\xe0\x49\x69\x1d\x85\x9f\x46\x38\x1c\x3f\x8d\x70\x38\x64\x18\xd1\xe1\xe8\x7c\x77\x77\xd8\x33\x03\x33\x54\xf4\xfb\xec\xd6\xde\x60\xe8\x65\x1f\xd2\x60\xa8\x47\xd9\x65\xc8\x72\xea\xc9\x99\x8c\xf3\x59\x6b\xe9\xc7\x58\x62\x48\xd6\xcf\xb0\x2e\x82\x68\x9f\xb8\x40\x3e\x01\xd7\x53\x56\xca\xab\x46\xe4\x6b\x16\xcd\x6b\x06\xea\xd7\x38\x6c\x42\xda\x0b\x1a\xde\xae\x3f\x63\xcc\x0e\x17\xbe\xc6\x1f\x27\xee\x8a\xf6\xf3\x64\x1c\x7c\x87\xbe\x30\x01\x73\xee\xc1\xb5\x74\x34\x4d\x09\x49\x20\x7c\x88\x83\x6a\x9d\xe5\xa5\x71\x33\xff\xe3\x16\xfc\xee\x88\x77\xc3\xed\x7b\xed\xa7\xef\x32\x78\xbb\xc7\xd1\x94\xbe\x39\x56\x39\xe8\xf7\x82\xb6\xeb\xad\x36\x53\x65\x03\x3d\x15\x36\xd0\xfd\x2f\xca\x8a\x1c\x90\xf0\x0d\x8c\xf5\x7e\x94\x1e\x82\x6e\x7f\xf5\x00\xe2\x46\x7c\x66\xa0\x36\xb1\xe5\x6b\xe3\xbf\x7e\x7c\xde\x0d\xe0\x8d\xf8\x05\x2f\xb5\x68\xeb\x47\xc7\x6e\x9b\x81\x51\xb9\xba\xd5\x53\xd7\xcb\x11\xfa\x30\xf6\x2b\x56\x00\xd9\x19\xcc\x9a\x6d\x4e\x47\x6a\xff\xd0\x96\x7d\xd6\x40\x52\xd4\xaa\x9f\xdd\x6a\xf3\xef\x3e\x31\xfc\xaf\x74\xcb\x9e\xf8\xf2\x29\xa9\x2d\x55\x32\xcf\x99\xec\x12\x60\x1c\xca\xf6\xf8\x94\x7c\x8e\x16\xc6\xbf\x36\xc3\x23\x46\x09\xaf\x6a\x66\x38\xba\x84\xf1\xdf\xfa\x5b\x27\xea\x98\x69\x79\xdd\x24\x54\xfc\x34\xd9\x89\x1a\x8b\x63\x64\x88\x48\x83\x6e\x24\x55\x19\x8c\xf3\x0e\xc6\xb4\x78\xae\x88\x87\x5d\xf2\x67\xe1\xad\xac\x7d\x60\xc5\x08\xd7\x08\x83\x3b\x76\x58\xae\x53\x81\xf1\x4d\x24\x51\x5e\x35\x5e\xd7\xb1\xaa\x78\xf5\xcf\x15\xe4\xe3\x47\xe1\x87\x31\x32\x3f\xf3\xaf\xd1\x25\x35\x80\x5f\x7e\x0c\xf6\xc4\x07\xdf\x48\xc1\xc9\x67\xed\xef\x50\x00\x17\x90\xbf\x35\x8f\xfe\xe6\x9e\x61\x52\x78\x17\x0c\x04\xdc\x21\x58\xc8\x15\x1c\x2a\x55\x2f\x70\xa8\x33\x39\x80\xcf\x64\x01\xce\x42\x02\x0e\xb0\x13\xcf\x32\x3f\x86\x57\x34\x5b\xab\xd4\xcc\xb6\x56\x23\x4d\x73\x23\x58\xca\xe6\x36\xf4\xed\xd8\x48\x23\x7e\x1d\x5b\xd7\x31\xa4\x2a\x82\x94\xaa\xe6\xad\xde\x79\x66\x49\x3e\x78\x70\x50\x08\x93\xf7\x0b\x69\xb0\x13\xbf\x71\x96\xb2\xf9\x2a\x39\x64\xe0\x8c\xbe\x4c\x00\xee\xb4\x4f\xba\xe1\xc3\x8d\x37\xd8\x97\x40\xf1\xff\xa7\x4f\x4f\x33\xe2\xf3\x28\x0d\x6e\x3c\x76\x06\xcc\xda\x43\xb2\x9d\x83\xda\x11\x9c\x90\x9f\xb3\xee\x67\x7f\xb4\x73\x34\xac\x86\x2b\xa2\x80\x4f\xed\xf0\xdd\x3e\x0a\xf7\x48\x83\x9a\x9d\x9f\x30\x21\x1f\x71\x96\xa2\x3f\x22\x73\x1d\x91\x18\xd5\x51\x95\x94\x9d\x2a\x8c\x48\x2f\x6d\x4f\x47\x24\x1c\x98\xa2\xce\x2a\x3d\xa8\x00\x9e\xd6\xe9\xea\x99\x92\x63\x15\x57\xa3\x22\x2f\x94\xe8\x47\x3d\x44\x1c\xc7\x4f\x4d\xb3\x2c\x67\x8b\x92\x92\x27\x2f\xfc\xf7\xf8\x26\x63\x4d\xf9\x20\x57\xea\xa3\x1b\xf2\x3e\xc1\x9b\x2d\x7b\xfb\x71\xd3\xf6\x36\xf2\xc2\xee\x69\x6e\xcd\xa5\xb7\x58\xce\xbd\xd5\x22\x75\x67\xde\x62\xed\xcc\xbc\xe5\x34\x70\xa7\xde\x62\x76\xd7\xfd\x77\xf1\xb3\xef\xcc\xbd\x60\xe9\x04\xde\x7a\x35\x77\x56\x5e\xb0\x70\xee\x9c\xc0\x9b\xae\x67\x50\x7e\xd6\x71\x22\xea\x4c\x60\x83\xaa\x2c\xc9\xc3\xc6\x34\xdd\xf5\xdf\x7c\xbe\xa6\x04\xe7\xce\x5c\x93\xa2\xb4\x97\xa1\xef\x04\xc7\xb9\x5e\x1c\x78\xb7\x37\x5a\xdd\x78\x5d\xd5\xb5\xbc\x31\x45\x73\xe7\x8e\x3b\xe7\x54\x6d\x48\xcc\x3a\xfb\x20\xaa\x9c\x5e\x65\x08\xf7\xb5\x5b\x37\x61\xd7\xad\xdf\x5d\xac\x4f\xdb\x53\x25\x6b\x9f\x74\x66\x4c\xb2\x3e\x96\xd6\x3f\x68\xb0\xb1\x7d\x0b\xad\x25\x46\x1a\x3e\xad\x2c\x5d\x8f\xab\xbf\xb6\x69\x38\xad\x37\x63\x91\x14\xf2\x97\xfd\xa6\x51\x35\x4b\x98\x0c\x3e\xfb\xcc\x9d\xfd\xec\x16\x7c\xe7\x65\xa7\xf8\x02\x34\x92\xb3\xd9\x8c\xa6\x66\x77\xfc\x9f\xf1\x24\xff\x2d\xf3\x9d\xce\x26\xce\x8e\x73\xd5\xfe\x39\xfd\x32\xc6\xae\x04\x20\x62\xb0\x2c\x5c\x77\x65\xeb\x4c\xfd\xb2\x55\x56\xae\xa1\xe2\x69\x57\xe6\x75\x0b\x77\x58\x96\x28\xac\xc2\x3c\x92\x6e\xef\x93\xca\x25\xc5\x80\x3e\x8b\x01\x2e\x59\x03\xda\x5c\x7d\x61\x97\x88\xe3\x2b\xce\xb9\xca\xbe\x19\xc5\xc8\x5f\x49\xa7\xba\xdc\x04\x48\xbe\x1c\x4b\x3e\x42\xd1\x1f\x65\x97\xef\x56\x24\x37\xfb\x13\x54\xfb\x24\x45\x86\x6d\xcc\x88\x29\x16\xc0\xc7\x5d\x35\x5b\x8d\x8e\x1e\xdd\x67\x70\x47\xe0\xe7\x04\x83\x15\xfd\xc6\xdf\xee\x93\xb4\x41\xd5\x26\x4c\xcb\x63\xf8\x1d\x15\xcd\x8f\xfe\x47\x60\x63\x82\x49\x29\x3b\x35\xc1\x0b\x1d\x8e\xce\x4a\x27\x66\x17\x12\x79\x20\xbd\xa3\x68\x1f\x64\xf3\xf0\x86\xce\xea\x90\x3f\xed\xea\xc8\x3c\x20\xb9\x4d\x1a\xe6\x87\xef\x50\xfe\x91\x1d\x07\xea\x3f\xef\xf8\xeb\xb1\x28\x6a\xd4\xd9\x1d\xe4\x79\xde\x3b\xb8\xf5\x66\x87\xf6\x45\x85\x34\xf2\xc7\xa7\x17\x86\x10\x08\x3b\x84\x8c\x9f\xd9\x50\x2c\xa5\xdd\xc1\x57\x0e\xcc\x73\xbd\xcc\xf0\x1d\xf6\x06\x81\x7e\xa1\x61\x93\x1e\x15\x44\x2f\xbe\xbf\x54\xc5\x43\x8d\xde\x5d\xbc\x3c\xbc\x7f\x46\xbf\x41\xcc\x19\x0b\xdc\x27\x27\x7c\x17\x82\xa9\x93\x4f\x20\x75\x47\xda\x3b\xb1\x76\xba\xc1\x00\x59\x08\xa5\xff\x6d\xfa\x24\x8f\x01\x79\xa3\x4d\x24\x69\xd3\x84\xbb\x5a\x0c\x92\xf2\x57\xae\xc7\x31\x07\xe6\xe0\x27\xfc\xd1\x87\xd8\x59\x12\xe3\x12\xc1\x70\x4f\x8d\x89\x5c\x75\x41\x74\xf1\xed\x8a\x1c\x9c\x65\x13\x48\xa5\xc6\x8b\x4b\xaa\x01\x3e\xce\xa4\xca\xe8\xf4\x7f\x81\xae\x9a\xe4\x39\xfe\x03\x67\xe1\x03\x0b\x55\x96\xf8\x83\x8a\x81\x1e\xc4\xbf\x27\x7e\x45\x72\xc5\xc5\xa7\x71\x4c\x06\xd1\x21\x8b\xe9\x80\x5a\xfc\x36\x41\x3e\xe6\xf4\x94\x73\x3e\x1d\xee\x32\x49\x53\x75\xfc\xa1\xa1\xe3\x20\xb5\x42\x90\xb0\x79\xea\xb7\x34\x54\xa9\xe9\x9d\xd3\x86\x28\x57\x87\xa3\x73\xdb\x38\x15\x7e\xb6\xb3\x13\xca\x6b\x5c\x42\x8e\xbc\x6f\x4f\x3a\x17\xfc\x2a\x9a\x78\x49\x16\x68\xe2\x12\xf1\x17\x40\xb3\x09\x77\xec\xdd\xfe\x4f\xf8\x47\x19\xe6\xf2\xa7\x9b\x02\x0c\x15\xa7\xf4\x79\x4f\x1e\xde\xef\xc2\xea\x45\xcf\xbd\xdc\xc6\x86\x0b\x58\xd0\x58\xef\xdd\x5d\xd5\xb9\x83\xa0\x6b\x26\xf8\x81\x01\xe8\x06\x06\x9a\x98\xb0\xfa\x06\x99\x5f\x40\xf5\xdf\xb9\x89\x6c\x71\x66\x6e\x28\xb3\xac\x0c\x1d\xe0\xf3\x2e\x7e\xb7\x35\x86\xd7\xac\xc1\x54\x16\x9c\x95\xb2\x5d\x16\x4a\x1b\x09\x97\x10\xea\x75\x62\x0e\x2b\xc5\x7c\x30\x7e\x18\x19\x7e\x35\x3a\x44\xd2\xc9\xa9\xdd\x1a\xa5\x7b\xf0\x80\x6f\x67\x3d\x80\x53\xbe\x32\xbc\x7c\xe4\x42\xb9\xeb\x1d\xd0\xbb\xa9\xe6\x33\x4a\xe3\xa2\xad\x5a\x74\xae\x53\x92\x86\xb2\xd2\x11\x3a\x4a\x41\xdd\x24\x2a\x34\xb9\xec\xe9\xb6\xa5\x73\x96\xb6\x83\xe7\x39\xea\x0b\xe9\xa1\x97\xc3\x3e\x7c\x5c\xe8\xb8\x33\xb9\xc4\xee\x6a\x6b\x94\x2e\xe0\xef\x1b\x55\x5f\x9c\xbc\x35\x02\x84\x46\xbf\x9b\x54\x5b\x0c\x06\x64\xb8\x3d\xa7\xdf\xbf\x2d\x56\x0b\x7c\x7b\x8e\x80\xab\x73\x57\x1c\x41\xd5\x35\x1f\x56\xd3\x6b\x0b\xc8\xc7\x2b\xc0\x40\x74\x88\x7e\xf2\x3a\x19\x86\x49\x8e\x2a\xdb\x44\x31\xdc\xee\xa3\xa0\x3d\x03\x06\xe4\x58\x54\xc9\x6f\x1d\xb1\xa7\x99\x90\xaa\x78\x80\xec\x47\x57\x0c\x41\xf2\x48\x3a\x2b\xcb\x4e\x88\xf5\x28\xf8\x42\x15\xea\x45\x6f\x52\x32\x0e\xe7\x5b\x8b\xce\xc2\x9e\xd6\xb0\x02\xaf\x4f\x3d\xc0\x7c\xc8\x4a\xf7\x42\x57\x68\x7d\x3b\x43\xae\xa4\xe1\xe0\x18\xf9\xb7\x24\x2b\x8b\xaa\x09\xf3\x06\x94\x09\x54\x3d\x48\x07\xa8\x95\x1a\xf1\x27\x94\xf5\x0c\xb2\xb5\x4c\xf0\x35\x01\x63\xb5\x5a\xae\x60\x63\xe0\xd6\xd9\xb3\xd9\x2b\x7c\x42\xf1\x6b\x4c\xd6\x6a\x79\xa7\xe5\xf2\xad\xa7\xde\x37\xa6\xc2\xd2\xb8\xbe\xb5\xf4\xec\x1c\x3e\x87\xed\x92\x14\xf0\x5f\xd5\x7c\xf1\x92\xbd\x55\x0b\xc6\xf3\x38\xd6\x88\xad\xd7\x53\x8d\x79\xc8\xe2\xe7\x33\x62\x59\xfc\x75\x46\x6c\xbd\x0e\xb4\x5c\xbe\xf5\x34\xfc\xd6\x14\x59\x1c\xd7\xb7\x96\x9e\x9d\xc3\x67\x31\x62\xa2\x02\xfe\xcb\x1a\x31\x4e\xb2\x37\x6b\xc4\x38\x1e\xc7\x1a\xb1\xe9\x74\xbd\xd6\xd8\x87\xf4\xf0\x7c\x56\x2c\x3d\x7c\x9d\x15\x9b\x06\xbe\xaf\x65\xf3\xad\x27\xe2\xb7\xa6\xca\xe2\xc0\xbe\xb5\xf4\xec\x1c\x3e\x8b\x19\x13\x35\xf0\x5f\xd6\x8c\x71\x92\xbd\x59\x33\xc6\xf1\x08\x9b\x31\xa0\x4d\x9b\xbe\xb5\x1e\x7f\x6b\x9a\xd0\xa6\xcf\x67\xde\xdb\xf4\x0a\xf3\x6e\xe5\xe5\xad\x47\x72\x8c\xb4\x9e\xc1\x22\x89\x42\xfb\x97\xb5\x48\x9c\x64\x6f\xd6\x22\x71\x3c\x82\x16\x89\x55\xa6\xe4\x30\x1f\xff\x42\x6e\x02\xd7\x31\x34\xe4\xed\x34\x7f\xec\x65\xfd\xd1\x84\x4e\x7a\xa3\x02\x41\xd0\x6f\x79\x4c\x64\x8d\x58\xc4\xb7\x34\x57\x30\x28\x4e\x0c\xb5\xe1\x62\x54\x43\x23\x6f\x22\xa4\x8e\xc3\xd5\x28\x42\xf2\x79\x0e\x1e\xc3\xcc\x88\x81\xbc\x2f\xff\x49\x3c\xa4\x60\xa3\xc6\x3e\x9a\x1a\x01\x5a\x94\x28\x37\x01\x76\xf5\x3f\x99\x24\xad\x1d\x22\xa6\x76\xc2\xd9\x10\xe1\xd0\x95\xa5\x25\x79\x21\xf7\x55\xe7\xc5\x85\x03\xb5\xb3\xc0\x99\x05\x1f\x46\x9c\xc3\x05\x0e\xd6\x53\xbe\x1d\xfa\x7f\x6f\xf1\xf1\x03\xad\x23\xbb\x86\x1f\x3f\x04\x7d\x41\x9a\xe4\x28\x0a\xcb\x1f\x3f\x60\xae\xfb\xe2\x2c\x69\x50\x95\x26\x59\xd2\xfc\xf8\x61\xea\x93\x23\xbc\x73\xe7\xee\x18\xcc\x7f\x99\x3b\xd3\x25\xf9\x1b\xcc\x8f\x01\x74\x68\x1f\x96\x13\x6a\x1b\xb3\xee\x27\xf9\x3d\xaa\x6a\xa4\x31\x13\x72\xad\x68\x28\xfa\xc3\x3b\x5a\x44\xd2\xf4\x81\x61\x44\x13\xa1\x21\x69\xc1\x04\x99\x09\x23\x7b\x5a\xf3\x10\x2c\x16\x13\xf6\xaf\x49\x50\x26\x33\x61\x86\x55\x0c\x85\x40\x72\x35\x96\x26\x68\x31\x04\x54\x81\x0d\x95\xd6\x74\x98\x09\x4b\xc6\xc3\x0c\x2c\x98\x0f\x10\x14\x34\x20\xc6\xc1\xd3\x1b\x0e\xa1\xff\x53\x7d\xf7\x6f\xd5\x80\x74\x7c\x3b\xc3\x7f\xde\xcc\x8c\x28\xf2\x92\x0c\x89\x32\x4b\xa2\xb0\x8a\xff\x15\x4e\x67\x3d\xe5\xb4\x75\xa0\x3f\x6e\x1d\x56\x31\xbd\x6e\xe1\xd9\xce\xfd\xb1\xc3\x36\x53\x81\x48\x93\x34\x29\x92\xbf\xd1\x59\x71\x00\xf5\x69\x27\xc0\xe0\x43\x97\xec\xd3\x01\x25\xfd\x12\xc1\x89\xda\x86\xfb\xba\xfd\x0c\x43\x59\x8f\x08\xf7\x50\x3f\x0c\x8f\xc2\xf7\x3f\x42\x4f\x7e\xf2\xf0\xe9\x29\x25\x07\x9a\xc3\x95\xd3\xfc\xea\x23\x12\x8f\x8d\x3b\xd4\xab\xd0\x1d\x3a\xad\x92\xe5\x04\x62\x48\xd6\x21\x12\x06\xd2\x40\x08\xa3\x47\x93\x8e\x2b\x19\x60\x02\xf0\xcb\x0b\x5d\x6a\xf8\xad\xee\x3c\xb5\xac\xad\x02\x55\x48\x8e\x94\x47\xfc\x71\x15\x3d\xd4\xe5\x3a\xd3\xb2\xfd\xe8\x00\x45\xbe\xc3\x54\x61\x5f\x14\x8d\xbe\x1b\x36\xb6\xf1\x35\x0b\x36\x9e\x09\x09\x60\x10\xfa\x53\xfb\x3e\xc4\xa3\x5a\x24\xc8\x80\x1c\x47\x17\x33\x36\x78\x4b\x48\xfa\xae\x98\x92\x89\xe4\x5a\x60\xa0\xa2\xfc\x7d\x91\x04\x3e\x56\x6c\xa6\x21\x60\xa3\xad\xd9\xb5\xb3\x57\xde\x34\xca\xb7\x75\x78\xd1\x4d\xa0\x2a\xaa\x7f\xe6\x24\xfd\xd4\x8c\x90\xdb\x02\xaf\xbc\x20\x8e\x6f\x0b\xb1\x23\x56\x8d\x67\x07\xdf\x79\x79\xe5\xe5\x87\x7d\x43\x88\x11\xae\x7c\x3c\x17\xec\xca\xbb\x2b\xef\x38\xe3\xdb\x42\xbc\x88\x55\xe3\xd9\xa1\xf7\xa5\x5d\x79\x55\x16\xd7\x14\x62\x46\xa8\x19\xcf\x8b\x7c\x7b\xf2\x13\x6e\x46\x16\xf0\x0c\xb7\xe6\x5e\x7b\x29\xae\x80\x06\xd6\x1b\xfb\x3d\xa8\x22\x2f\xba\xb9\x60\xbf\x15\x53\xc0\xa3\x55\x1f\xfb\x6d\x88\x02\x1e\xdd\xb8\xdb\xef\xc0\xa3\xaa\x8f\x7d\x42\xad\x1b\xb8\xec\x8d\x70\xef\x3d\x42\xf3\x87\xaf\x1a\xa1\x27\x5b\x8b\x93\x1f\xc0\x44\xb1\x53\xf5\x7f\x4f\x45\x83\x40\xc2\x56\x9e\xc0\x2a\xe2\x20\x09\x9f\x81\x9a\x28\x3b\xde\xf0\x6c\xa2\x48\xb6\x5e\x40\x05\xf3\xc9\x60\x66\x4c\x2e\xb9\x6e\x2c\xf8\xcd\xaa\xae\x5a\xdd\x43\x4b\xfd\xea\x17\x70\xf5\x64\xbb\x94\x6e\x8a\x90\xc8\x0e\x56\xbf\x61\x00\x75\x3b\xea\x69\xf8\x68\xfd\x60\x53\xbe\xeb\x04\xf6\x7b\x3b\x8c\x4d\x51\x6a\x1d\x40\x95\x15\x9d\x33\x68\x64\x9a\x30\x63\x72\xf8\xf4\x84\x00\xe7\x0f\xa0\xa5\x3f\xc4\x4c\xcc\x2f\xe2\x2e\x92\x7b\xe6\xb0\x3d\xbe\x7e\xa9\x2a\x1e\x1c\x31\x70\x2f\x16\xab\x45\x97\x81\x33\xa2\x5e\x2f\xf4\x9d\x07\xbc\x5b\xf2\xa5\xf4\x62\x3e\x97\x5e\x8c\xd4\xdd\xc4\x86\x52\x11\x12\x90\xc3\x4d\xd8\x0b\x2d\xca\x56\xd3\x86\xcf\xe5\x27\x7e\xe5\xd3\xb5\xb1\x29\x10\x49\x16\x76\x93\x1a\x44\x53\x10\x62\x15\xfa\xfa\x81\x57\x91\x92\x7d\xa7\x98\x72\x02\xb4\x64\x5c\x1b\xc3\x5d\x10\xe3\x93\x32\x9a\x90\x3a\xe3\xec\xd7\x78\x2c\x76\x13\x05\xe1\xd2\xee\x66\xc7\xa6\x2c\x34\x60\xd4\x77\xf1\x49\x38\xc0\x0e\xda\x30\x3d\x25\xc5\xef\x13\x90\x28\x6c\x4e\xbe\x12\x0b\x27\xb0\x9e\x31\xdb\x14\x27\x16\x67\xb8\x4b\x98\xfc\x76\xa3\xe2\x94\x37\x9b\x19\x49\x42\x20\x95\xc9\x20\x62\xcb\x43\x58\xf6\xdf\x6e\xf1\xad\xf9\x72\xb5\xe8\x22\x70\x23\x2d\x0d\xd0\x57\x55\xc0\x8d\x64\x24\x72\x75\xf1\x76\x15\x0a\xe3\xa8\x3a\x65\x3b\x25\xaa\xa0\xee\xcd\x69\x72\x00\xdb\xbd\x88\x42\x3a\x00\x39\x1c\x33\x10\x94\xaf\xce\x24\x2c\x73\x5f\x76\x0d\xb7\x0a\xf2\xcd\xc8\x17\xb7\xc2\xc5\x3c\x62\xdd\x0f\x72\x41\x9f\x39\xc0\xf8\x91\x9f\xf9\x95\xbf\x74\xd5\x5c\xcf\xe5\xa7\x77\x23\xe8\x63\x87\xb0\xe7\x42\x7b\x09\xf0\x57\x63\xa2\x97\xf8\x8a\x6d\xa4\xcf\xab\xd9\x8d\xc1\x65\x78\x48\x72\xdc\xec\xe5\x52\x27\x28\xaa\x02\x6a\x44\x19\x1e\x90\x12\x70\x74\x48\xb1\x12\xca\x34\xdd\xb5\x30\x2e\x16\x39\x90\xe3\x8d\xe0\x40\x6d\x74\xcc\x51\x13\x0b\xe5\x28\x50\xd1\xf3\xd8\x87\x64\xa2\x23\xb2\x38\x6a\xf6\xeb\x03\x7e\xf6\x06\x8b\xa7\x20\x2a\x2a\x94\x45\x65\x54\x56\x1d\x30\xe7\xc0\x85\xa3\xa3\x7f\x57\x01\x5d\xe9\x08\x45\xf5\xa6\x65\xab\xcd\x11\xa5\x66\x7c\x33\xbd\x2d\x90\x78\x63\x1b\xb4\xa1\x60\xcc\x65\xdc\xa3\xac\x99\x24\x0b\x3a\x85\xf0\x21\x37\x4e\x34\xe3\x12\x8d\xc3\x18\x4c\x33\xc1\xa0\xfb\x33\x93\xea\xcf\xcc\xd4\xae\x9f\x08\x32\x35\xb5\x56\x20\x57\x67\xa0\x78\x8c\x09\xe4\x61\x04\x4f\x94\x4e\x60\x34\x0c\x66\x6a\x4f\x30\x13\x66\x2b\x41\xd6\xc1\x30\x3e\x98\x57\xa4\x4e\x3e\x9d\x78\xe6\x72\xea\x29\xe1\x3e\x82\x95\x7c\x1f\xc1\x56\xbe\x93\x56\x38\xc5\x65\xbf\x3a\x61\x17\xd6\x88\x5c\x49\x0f\xaf\xdf\x1d\xdf\x1b\x94\x95\xcd\xa3\x74\x6a\x6a\xd7\xe4\x0e\xed\x96\x6a\x1b\x58\x0a\x92\x4b\x48\x31\x90\x29\xca\x7e\xc9\x21\x13\x78\x72\xca\x19\xb1\x70\x5b\x1c\xf7\x97\x0f\xee\x2d\x95\x45\x7c\xa9\x24\xf6\xc7\xd7\x46\x33\x24\x34\xd5\x08\x10\xd3\xed\xaf\xd8\xe7\xe1\x7e\x3d\x56\x68\xff\xb9\xbf\x07\x14\xa8\xa2\xa9\x69\x14\x74\xf3\xdd\x22\x58\xac\x7a\xde\x2d\x2f\x1f\x24\x38\x88\xac\x58\xa5\x23\xeb\x07\x8b\x30\x5c\x30\x74\xb6\x97\x0c\x12\x1c\x44\x56\xac\xd2\xf6\x76\xbe\x8e\xe7\x73\x86\xce\xf8\x32\x81\x07\x82\x08\x72\xe5\x3a\x6a\xb3\xe9\xce\x8f\xfb\x4e\xda\x5e\x1a\x48\x70\x10\x4d\xb1\x4a\x47\x16\x45\xeb\xd5\x74\xdf\x6b\x88\xf9\xe5\x80\x08\x06\xea\x11\x5f\xa3\xa3\x19\xad\x67\x7e\x10\x5d\xbc\x7f\x9e\xb2\x5d\xd1\x54\xdc\xc5\x26\x81\xc6\x79\x0f\xe0\x57\x84\xb0\xb3\x3e\x13\xd2\x12\x28\xbb\x21\x95\xea\xbc\xa3\x1a\x90\x3d\x45\x5f\xeb\x1e\xf9\x2b\xe2\x7b\x39\xf8\x31\xd6\xec\x01\x6c\x9f\x9e\x92\xd8\x72\xd0\x58\x4e\x1e\x76\xf1\xc2\x14\x55\xcd\xb8\x57\xba\xd3\xc1\x20\x5f\x95\xff\x02\x93\xc0\x01\xed\x4e\x91\x08\xff\x34\x9f\x0b\xab\xc4\x8b\x81\x64\x90\x59\x5d\x9c\xd4\x59\x52\xd7\x09\xfe\xa8\x3a\x4a\x8b\x5a\x6b\x19\xa9\x7b\xc4\x12\xb9\x89\x09\x68\xe4\xbe\x81\x7c\xe8\xa7\x74\xbc\xdf\xfb\x8a\x2f\x19\xfb\x68\x1d\x2d\xd9\x5a\x31\x8b\x56\xcb\x59\x2c\xa1\x72\xc0\xd1\x8b\xa6\x28\xd8\xcd\x64\x50\x5e\x18\xec\xc6\xf7\xdd\x62\xde\x69\x28\xa9\xd1\x4c\xfd\x78\x8d\xe2\xfd\x4a\xe2\x6d\x17\xc5\xfb\x7d\xbf\x8e\xcd\xa6\x2b\xff\x6e\xcf\xe3\x81\x19\x0b\x97\xf1\x02\x09\xf4\x40\xae\xe6\x8b\x60\xb9\x66\x50\x06\x13\x11\xed\xef\xd0\x4c\x7e\x29\x14\xee\x83\x28\x62\x8c\xdd\x85\xcb\x78\xb6\x93\x50\xc1\xbc\xed\x57\x28\xda\x2d\x64\x50\x80\xbd\xe5\x72\x31\x1d\x84\xa6\x35\x25\xfb\x20\x46\xca\xeb\x57\xb4\x8b\xa2\x81\xbb\x70\x3d\x9f\xcf\x03\x11\x13\xcc\x1c\x9a\xef\xd6\xbb\xb5\x04\x09\xf0\x76\x37\x9f\x2d\x66\xf3\xcb\x9f\xd9\x96\xf0\x0b\x7a\xdc\x57\x61\x86\x6a\xa7\xac\x8a\x43\x85\xea\xda\xdd\x85\x95\x5b\x37\x55\x52\xa2\xfa\xbc\xaf\x8a\xec\x0c\xa5\xf5\x9e\x92\x64\x7f\x4d\x01\xd6\xfa\x8e\x7f\xb9\xfc\xd9\x2d\x5e\x14\xfd\x0b\xe2\xf6\x18\xc6\x67\xdc\x56\x77\x6b\x00\x8e\xeb\x1e\x93\x38\x46\x39\xef\x2b\x03\x99\x76\xbb\x82\xab\xaf\xa0\x52\xf6\xb0\x9c\x5c\xce\x3c\xe6\x11\xdb\x56\xb1\x35\x95\x6a\xac\x9e\x12\x64\x42\xe8\xb8\x0f\x2b\xf7\xd0\xb1\x80\xf2\xe6\xbb\xf9\x22\x46\x87\x09\x70\x1c\x71\xf1\xd1\x09\x16\xef\x27\x9c\xdd\x56\x7e\x2f\xfc\xf7\x9a\x96\xfa\x9a\x95\x84\x43\xfa\xfd\x51\xcd\x3b\xee\x16\xdf\x20\xd3\x37\xcf\xb1\x36\x4d\x53\xef\xd1\x68\x6b\x24\x95\x0b\xf3\x24\x0b\x1b\x34\xbc\xed\x20\x05\xdd\x24\x85\x26\xbc\x33\xad\x1d\x22\x1d\x27\xc9\xf7\x49\x9e\x34\x68\xeb\x16\x4f\x68\x74\x75\x8b\x8b\x87\x7d\xac\x17\x7a\xb1\xf7\x32\x57\x0e\x53\x9e\xdd\x5d\x11\x3f\x8e\x3a\x75\x69\xbb\xa6\x68\x38\x00\xf8\xaf\x96\xc8\xee\x22\x1f\x7e\x74\x43\xdc\x9a\xbb\x3a\x59\x7f\xb7\x60\xef\x00\xc2\x38\x94\x83\x95\x92\x1f\xfb\xa7\x60\x1d\xec\x3a\x5f\x03\x6e\xce\xf6\x24\x9a\x5a\x61\xc3\xce\xf3\x66\x0f\xa8\x91\x43\x89\x5a\xba\x62\xb8\x9a\x30\x69\xc8\xfa\x2d\x61\x79\x95\x23\xd4\x5f\xf3\x4a\xf6\x45\xbf\xc8\xd3\xed\x18\xd4\xb4\xbe\x4f\x3d\x87\xad\x08\xfc\x19\x4f\x09\x1b\x0e\x02\x6b\x8e\xc9\x7c\xd5\xc1\x60\xa5\x23\xa0\xc2\x1b\x4f\x5e\x4b\xb0\x7d\x3c\x5e\xc5\xf2\x35\x09\xee\xf1\x11\x22\x1d\x29\xed\x34\xd7\xf3\x60\xb3\x0c\x3a\xc3\x62\xa0\xd9\x89\xe7\x1a\x82\xdc\xd9\xab\x3e\xc0\x26\x53\xa3\x86\xe0\x39\xde\x98\xc0\xa8\xc7\x8b\xce\xd6\xe0\x27\xaf\xce\xc2\x34\xbd\xbe\x1d\x6e\x66\x13\xbb\x0e\x09\x2f\xc4\x38\x44\x48\x52\x93\x7d\x7a\xaa\x8f\x4a\x2b\xe9\x96\x4a\xf1\x98\x86\x1a\x64\x91\xf1\x3d\xe5\x8b\x01\x10\xcf\x53\xbe\x00\x80\x16\x4c\x16\xf7\x10\x22\x19\xd0\x05\x54\x38\x0a\x72\x09\x75\x08\x26\xe4\x0a\xf2\x71\xf8\xf5\x68\xf4\x3a\x65\xc6\x3f\x76\x4e\x6a\x09\xf7\x01\x75\x5d\x3d\xf9\x4a\xd0\xcc\x05\x45\x62\x01\x12\xd6\x7e\xbd\xc0\x71\x84\x49\xcf\x30\xfb\x0a\xce\x4c\x0c\x48\x0e\x0e\xc4\x7d\x29\x0f\xc2\xdc\x67\x31\x2d\x19\x31\x8e\x44\x09\xb1\x25\x88\x79\x1c\x97\x02\x98\xef\x5a\xeb\x58\x56\x31\x6b\x10\x5c\xad\x24\xc6\x46\x56\x0d\xe9\x5a\x6b\xd5\x03\x57\x1a\x75\x83\x6b\x6e\x82\x10\xb5\x42\x27\xd8\x68\x8e\x66\xfb\x99\x86\x49\x8b\x4a\x70\x20\x16\x7d\xa0\xd4\x45\x7d\xa0\x71\x44\x19\x2b\x8b\x01\x0a\x51\x3d\x68\x15\xc6\x11\x41\x80\x73\x8a\x40\xc7\x35\x88\x5f\x8f\xe6\x6a\xdd\xb0\xb5\xb3\xaa\x07\x45\xa0\xd5\x10\x56\x6f\x54\x12\x11\x89\x05\x48\x50\x15\xbd\xc0\x71\xb4\x55\xcf\xb0\x45\x5b\x44\x28\xcb\x1d\x92\x94\x07\x41\x61\x58\x7c\x57\x46\x4c\xa3\xb2\x42\x9c\x15\x62\x1f\xc7\x68\x01\xf6\x49\x7b\x1d\xdb\x10\x76\x2d\x92\xab\x95\xc5\xd2\xcc\xaa\x2b\xa4\xbd\x56\x55\x68\xb5\x51\x53\x04\x14\x66\x18\x41\x4f\xb4\x82\x26\x71\x6f\x2d\xb3\x16\x35\x11\x80\xcc\x5a\xc2\x38\x10\xb4\x84\xc5\xd9\x51\xb6\x43\xb1\x5b\xa1\xba\x2c\xf2\xba\x43\x65\x3b\x1f\xc3\x6d\xf1\x87\xcf\x01\xa4\x48\xaf\x8a\x56\x39\xcb\x26\x9f\x9a\x53\x9b\x38\x4a\x09\xee\xf9\x44\x05\xc4\x05\x40\x79\x82\x83\xe5\x40\x45\xb1\xfb\x27\x8a\x1a\xa0\xe2\x3e\x89\x51\xa1\xfd\x02\x41\xfe\xf2\x40\xbd\xb3\x8a\x24\x65\x27\x9b\x51\x5f\xed\x92\x1b\x4c\x77\x8f\xeb\xe1\x6a\x24\x2e\x4f\xff\x3c\xf0\xee\x16\xab\xe9\x7c\xf6\x1e\x68\x36\x5d\xea\x9a\x2d\x96\x5e\xb0\x80\x9a\xcc\x77\x8f\x33\xb0\xc5\x0a\x04\x9f\xee\x1e\xa7\x20\x38\x49\x46\x43\x5e\x02\x92\xc3\x8b\xd8\x03\x17\x4e\x05\x0d\x07\x61\x6c\x87\x3b\x7c\xdf\x27\xe1\x96\xfe\xe6\xdd\x6e\xcb\xee\xe3\xeb\x60\xfa\x8b\xbc\xbc\x05\x25\xd8\x7f\xb0\x82\x7f\x88\x67\xa1\x18\x22\xf3\x59\x8b\x01\xe7\x6a\x71\xa1\x33\x89\xbe\xd0\xec\x75\x57\x6a\x01\xdf\x3e\xe0\xeb\x6f\xa2\xcb\x8a\x38\x4c\xdd\xa2\x44\xf9\x59\x99\x06\xb8\x6e\xd0\xa7\x7d\xd2\xa2\xd8\xf2\x39\x0b\xdb\x37\x4e\xfd\xc5\x70\x3d\x2e\xee\x9a\xfc\x3a\x85\xbb\xd9\x0e\xd3\xf1\xf6\x61\x8c\x1c\xca\x4f\x9c\x84\x69\x31\x24\x25\xc4\x01\x6b\xc2\x84\x50\xb4\x2f\xaa\xcc\xf1\x66\xb5\x83\xc2\x1a\xb9\xc5\xa9\xd9\x8e\x87\x74\x0b\x01\x6d\x31\x02\xe3\x53\x21\x26\x66\x56\x26\x7a\xe2\x4a\x43\x42\x21\x0d\x1b\xf4\x9d\x3f\x71\x83\xc5\xfb\x8f\x5b\xbe\x35\x50\x6d\xa8\x63\x92\x27\xd7\x05\xe9\x25\xaf\xb4\xf6\x0d\x54\x7d\x1d\x49\xff\x23\xaf\x6d\x94\x5e\xaf\x74\x6e\xdb\x2b\x06\x2b\x79\xdc\x84\xa7\xa6\xb8\x88\x8c\xa9\x06\x9e\xd8\x31\x9c\x44\x80\xde\xb6\x37\xf5\xcb\x96\x35\xa3\x36\xfa\x5f\x37\xc9\x03\xf0\x7e\x27\x4a\x93\x72\x33\x5c\xa9\x22\x86\x25\x95\x3a\x53\x70\x32\x50\x52\x44\xe0\x33\x8a\xf2\xdc\xc6\xc4\xe3\xaa\x28\x9f\x6a\x4c\xe6\x50\x7a\x00\xdf\x57\xf0\x63\x23\xc2\xdf\x3c\x29\x55\x77\x9a\x7e\xe6\x2d\x35\xa9\xa7\x1f\x74\xbe\xe4\xfb\xa0\x67\x0c\x37\xf3\xc8\xcb\x30\xfa\xb2\x21\x97\x63\x3d\xf6\x15\xf4\x37\xd3\xfd\x0d\x3e\x78\xe8\xee\x50\xf3\x80\x10\xa7\x56\x42\x5b\x73\x9b\xfe\x2b\xc5\xc5\x70\x9f\x99\x7a\xbf\x1d\x7b\x3b\x40\x84\x0a\xe5\xee\xf0\xe5\x5b\x0e\xfb\x11\x2a\xe2\x47\x60\x8e\x3e\x7f\x7a\x91\xc5\x60\x1a\x68\x5e\x87\x6f\x75\xd4\x51\x1e\x6b\x47\x1c\x63\xc4\x00\xc2\x60\x77\x25\x5a\x50\x68\x8c\xc5\xe4\x15\xd2\x00\x13\xf9\xfd\x64\xf9\xf4\x8f\x05\xfe\x81\x36\xda\x4f\xff\xc4\x36\x75\x54\x15\x69\xba\x0b\x2b\x37\x43\x61\x7d\xd2\xdf\xca\xb9\x5e\xaf\xd7\x65\x4b\x17\x84\x85\x5f\xb6\xcc\xb1\xc5\xcf\xbd\x03\x42\xf0\x19\x0e\xda\x09\x0b\x0e\x77\x3d\x90\xdf\xa1\xa1\x6b\xcc\xcc\x2f\x5b\x87\x5f\x9f\xea\x8c\x03\x9d\x75\xa0\xa6\x54\xf2\xa4\x4d\xca\xa3\xbf\x23\x6d\xbc\xa6\x28\xd2\x26\x29\x81\x4e\x0e\xf6\x70\xe5\x4b\xfb\x1a\xec\xbf\xee\xc3\x2c\x49\x1f\x37\x9d\x93\x97\x22\xb7\x7e\xac\xbb\x0d\x07\xf9\xe3\x9e\x92\xc9\x5f\xd2\x24\xff\xf2\x4b\x18\xfd\x03\x97\xfc\xaf\x22\x6f\x26\xef\xfe\x81\x0e\x05\x72\xfe\xfb\x6f\xef\x26\xff\x59\xec\x8a\xa6\x98\xbc\xfb\xdf\x28\xbd\x47\xdd\xda\xe5\xfc\x1d\x9d\xd0\xbb\xc9\xbf\x57\x49\x98\x4e\xea\x30\xaf\xdd\x1a\x55\xc9\x9e\xfa\xce\xf4\xfb\x12\xbc\x8c\xf1\xce\xf3\xbc\x73\x9e\x51\xd3\xa0\x0a\x9f\x77\xee\x14\x8a\x42\x91\xb3\xd6\x15\x0a\xbf\x90\xc5\x5a\xbe\xef\x94\x7b\xc9\xda\x29\x0e\xff\x9b\xbc\x18\x07\x3d\x66\xde\x1f\x1f\x0a\x06\x0f\x04\x97\x89\xe7\xaf\x31\x37\x0f\x45\x15\x53\x6e\xf8\x12\x89\x67\xe5\x7c\x3c\x81\xc2\xb9\x3e\x71\x63\xb7\xfb\xcd\x5f\xe2\x4b\x47\x4f\x5a\x69\xd6\x43\xc5\xae\x76\x1b\xd4\x1c\x51\xe5\xa2\x14\x65\x28\x6f\xdc\xb0\x69\xc2\xe8\x88\xe2\xfe\x1b\x3b\x06\x4a\xff\xe2\xaf\xe6\xd8\xec\x5c\x74\x3b\x8e\x2d\x9f\xed\x68\xd6\x59\xb4\xd1\xd8\x9d\x1e\x6b\x92\xe7\xc3\x57\x4d\x20\x51\x0d\xec\x59\x5c\xa7\x17\xc3\x77\x6e\xe4\x0b\x93\xce\x7e\xf0\x57\x85\x11\x53\x42\xe7\x50\xd9\x3a\xa4\x0b\xea\x91\x38\xbc\x9e\x8f\xe8\x48\x47\x45\xe5\x97\xde\xf8\xc5\x36\x46\x1d\x15\x81\xad\xb1\x62\xea\x80\x47\x0b\x89\xde\x3c\x0e\x8b\x09\xef\x70\xfd\xf7\x5b\xf1\x14\x02\x1e\xb3\x31\x22\x12\xc4\x44\x5e\xb6\x5e\x29\xa8\xa6\x28\x55\x96\xe9\xf7\xa6\x5a\x7d\x1a\x2b\x27\xbd\x7e\xe8\x68\x9a\xe4\xf4\x14\x5d\xf2\x99\x98\xa4\xd7\xce\x57\x4a\x09\x8b\x56\xe5\x99\x5c\x39\xa7\x55\xa7\xd1\xd3\xce\xa4\x22\x30\x55\x9b\x3e\x31\x77\xf9\x1a\x85\x52\x64\x85\xdf\xcd\x03\x92\x22\x34\xb9\x65\x09\xdf\x1a\xd0\x3b\x07\xb3\xb2\x75\xee\x30\x2d\xc3\xe7\x2e\xa0\xab\xae\x39\xf2\x08\x77\x55\x5d\xfb\xe8\x90\xb3\x15\xdd\xd7\xde\x0a\xcc\x2a\xc8\x0a\x85\x1d\x97\x8b\x57\x16\x25\x8e\xbf\xe8\x62\x63\xca\x86\x63\x29\x2f\xb0\x9c\x40\x3a\x2f\x61\xf0\x96\xca\xf6\x8f\xc5\xf7\x4d\x17\xdf\x9b\xd9\xf6\xf6\x6a\x36\x66\x8d\x67\xa0\xf4\x2f\x5e\xe3\x85\x8b\xa3\x71\x0c\x63\x34\x42\xfa\x59\xf7\xe4\x9a\x16\xcc\x06\x01\xac\x28\xe8\x84\x3a\x3a\x49\x7b\x8b\x2d\x9a\x5f\x3a\x53\xaf\x62\xde\xc8\x8a\xe8\x75\xb8\xd3\xa9\x6c\x8a\xa7\xd2\x2d\xdb\x5c\x7a\x21\x36\x60\x8b\x8f\x5f\x23\x4c\x55\x32\x03\x37\xbe\xc2\x8d\x0f\x71\x43\xce\x13\x8d\x60\x81\x78\x37\x32\x65\xe2\xdd\x08\x29\x55\xc6\x2a\x08\x86\xbe\x42\x3d\x08\xbc\x6e\x44\xc8\xe2\xa3\x13\x10\xad\x95\x16\x2c\x7e\xc9\xb9\x46\x3b\x46\x71\xc2\x2b\xa3\xa0\x1b\x64\x1a\x71\xaa\xc1\xfb\x50\x4f\x51\x0e\x50\x90\x90\x5c\xce\x9c\x22\xc8\x73\x1a\x74\xe8\xc6\xea\x06\x76\xe8\x64\xca\xd4\xa1\xe3\x08\x8d\x56\x0d\x68\xa6\xdb\xc0\x75\xc3\x61\x99\x3a\xe2\x4c\x57\x6c\x47\x37\x51\xae\x51\x8d\x51\xac\x70\x6a\x68\xb1\x1a\x82\xe7\xf8\x14\xdd\x30\xd9\x4c\x41\x32\xe7\x41\x13\xb4\x56\x43\xf4\x63\xf1\xc9\xdd\xd5\x58\x2e\x9c\xc1\x58\x25\x4d\x8a\x6c\x42\xd2\x80\x9b\x1d\xa5\x6e\xdc\xa0\xd7\xaa\x01\xdc\x2b\xd5\x2f\x55\x43\x87\x57\x74\x92\xfa\xeb\x72\x7f\xb0\xbf\xae\x10\x1f\x8f\xf1\x9a\x89\x20\x98\x1e\x98\x15\xad\x36\xf0\x46\x4d\xb6\x90\xc4\x28\x5c\x33\x0f\x46\x71\x42\x89\xb1\xef\x1c\x4d\x36\x92\xdb\x16\x3c\x65\x1a\x98\x57\x07\x4e\x2e\x3d\x33\x26\x1b\xc9\xef\x51\x78\x13\x49\x43\xcb\xcc\x05\xbf\x2b\x5b\x67\x3a\x1f\xf0\xf4\xe1\x09\xee\x2d\xaf\x21\x53\xef\xca\x10\xd0\xde\x75\xff\x68\x93\x0a\x90\x7c\x77\xb3\xb1\x49\xf8\x66\x7c\x0e\x3e\x71\xda\x41\x5f\xf6\x33\x88\xfe\x0d\x16\xed\xee\x9a\x76\xb7\x87\x90\xe5\x6d\x98\xc4\xd0\xac\xfd\xca\x3d\x55\x4f\x4d\xb7\xfd\xec\xd4\x4b\xe6\x55\x0f\xec\xd3\x44\x71\xc5\xa9\x46\xa9\xfa\x46\x60\xa8\xa3\x1b\x55\xdd\xfb\x40\x7c\x96\x41\x79\xa3\x3d\x34\x36\x7f\xb5\x40\x36\x2e\xc3\x7d\x36\x2c\x90\xab\xbc\x16\x75\x67\x31\xc9\x53\xc5\xa1\x1d\xf7\xd6\x7a\x49\x5f\xf3\x26\xf9\x88\x17\xd7\x12\xb0\xe9\xdd\xb5\x1e\xef\xd7\x01\x41\x2f\xb1\x65\x08\x13\x23\xfc\x86\x6c\x1f\x46\xc8\xbd\x4f\xea\x64\x97\xa4\x49\xf3\xc8\xde\xfc\x1a\xaa\x58\xeb\x12\x55\x75\x89\xf0\xb1\xa1\x6e\x64\x70\x68\x42\x29\xba\x5c\xfe\x5c\x9f\xca\xb2\xa8\x9a\xda\xf9\x4e\x1d\xb3\xe1\xad\xf4\x2c\x26\x06\xee\xe3\x47\xa7\xa8\x9c\xef\x8c\x10\x7f\x0c\xf3\xed\x0d\xb3\x38\x22\x6e\x8e\xbf\x87\x10\xcb\xca\x0a\xdd\x4b\x65\xec\xd8\xd9\xb3\xbd\xf8\x1b\xcb\x87\xce\xab\xba\xca\xbc\x60\xec\x52\x11\xd9\x33\xaa\x04\xa5\x22\xb2\x89\x1c\x33\x1f\xa0\x23\x1c\x7d\xe5\x85\x0a\x10\xc2\x2e\x73\xd1\x31\x6b\xa1\xd8\x19\x58\x13\xd1\xbe\x5e\x43\x57\xd7\x79\x0b\x59\xd7\x46\x77\x00\x78\x15\x7b\xf2\xc7\xb8\xbe\xc1\xb8\x0e\xe8\x3b\x87\xa4\x2a\x52\x79\xee\xb2\x62\xd3\xf4\x1d\xce\xad\x7c\xab\x47\x09\xa4\x72\xf9\x88\x80\x8c\x9f\x6f\xa3\x81\xa5\xbe\xd3\xe2\xbd\xf9\x4d\x81\x70\x68\x12\x1a\x0a\x2e\xeb\x37\x50\x49\xef\xe0\x02\x47\x4b\xdb\x12\x57\x8e\x4b\x7d\xd5\x9f\x63\xda\xf2\x6f\x72\x61\xe5\xe0\x52\xee\xaa\x9c\xd2\xed\x8e\xae\x1a\x5f\xe8\xa4\x61\x95\x5c\xf6\x64\x48\x34\x1a\x70\x07\x1d\xf0\x33\x77\x06\x94\xff\xf2\x3f\x2f\xdc\x0a\x95\x28\x6c\x1c\x22\x7c\x47\xd6\x06\xf9\x33\x7f\xdf\x7f\xef\x90\x23\xc1\xba\x1a\x8d\x2c\x9e\xe1\x7e\x2a\xfb\x5d\x54\xce\x3e\x49\xd3\x1f\x3f\xbc\x0f\x66\xfb\xfd\xfe\x83\x78\xa1\xd5\x9d\x73\xc7\xdf\x55\x45\xae\x92\xf2\x53\x77\xee\x90\x7f\xa6\xde\xc2\xed\xfe\x0d\xc8\xbf\x0e\xfd\xeb\xd2\xf2\xdf\x80\x1b\xa6\xf4\xe3\x76\x63\x1d\x9d\x7a\x8b\xae\xab\xdd\x9f\x29\xe9\x9a\xc3\x75\xd3\x61\xe5\x73\x17\xff\x63\xec\x6a\x92\xc7\x49\x14\x36\x45\x55\x03\xa6\x4f\x3a\xb4\x87\xf7\xed\xf2\x6b\xb4\xc5\x0b\x59\xc4\x17\x32\x5a\x70\xda\x00\x96\x8d\x5c\x7c\x33\xdd\xfd\x96\x32\xad\x82\x92\x73\xd2\xe4\x49\xe7\xda\x7c\xe5\x5c\x9b\x2f\x9c\x6b\xa3\xbf\xf8\x23\x47\x83\x19\x98\x0d\xc1\x90\x4a\x2e\x60\x87\x21\x88\xc5\xeb\x06\x2a\x6f\xf0\xd1\xa9\xb2\xd5\x1f\x26\xd7\xde\x63\xb1\x80\xf5\xc5\x49\x13\x4b\x28\xd1\xe5\x15\xc6\x96\x46\xb9\xff\x3e\x41\x88\x26\xea\x29\x93\x18\x83\x4a\x58\x78\x69\xf3\x02\xb4\xd9\xce\x42\xf3\x35\xf9\x60\x43\xc2\x12\x27\x9c\xd0\xcd\xaa\x4e\xb9\x58\x02\xb9\x9e\xd5\xae\x70\x78\x41\xbd\xe5\x3f\x73\x08\xb8\x57\xf4\x2e\xdf\xd0\xb4\xf8\x5e\x3c\xe2\x1a\xb0\xd4\x93\x67\x4d\x4a\xca\xe1\x86\x5f\xd6\xa2\x29\x4a\x19\xb8\x29\x4a\x15\x2e\x4b\xe2\x38\x55\xf0\x92\x52\x15\x9a\xbe\xc7\x90\xb9\xc0\xa5\x00\x0f\x5d\x77\xe0\x26\x5c\x95\xa6\x1d\xd4\x01\x5a\xce\xb7\xd8\x1d\xdc\x7d\x18\x8b\x49\x94\xa4\xa0\xfc\xee\x60\xcd\x26\xc9\x61\x0c\x39\xf8\x21\x17\xe7\x50\x64\xce\x23\x29\xb1\x66\x4b\x27\x29\xd3\x95\x3f\x59\xe6\x8a\xcc\x89\x24\x25\xba\xc6\x7c\x92\x32\x51\xe1\x2b\x58\xf6\xdb\x9c\x49\x52\x22\x67\x4b\x28\x29\x53\x94\x3f\xac\xe4\x8a\xcc\xa9\x24\x25\xba\x96\x8c\x92\x32\x59\xe9\x1b\xbd\xa1\xc4\x9c\x4b\x52\x91\x2d\xb9\xac\x48\x05\x27\x29\x59\x54\xf1\x62\x78\x51\xc2\xa4\x48\x47\x77\xea\x4f\xa7\xd3\x40\xa0\x4b\x02\xb0\xfe\x99\x7d\x2d\x04\x54\x36\x45\xd9\x03\x90\xec\x02\x00\x10\x09\x8e\xfb\x52\xb2\x03\x00\x90\xbe\xe0\xf2\xe5\x44\x03\x00\x28\x0e\xa3\xf7\x80\xc4\x66\xf3\x60\xb8\x6f\x48\xbe\x2f\x8f\x9d\x2e\xa2\xb5\xc6\xbb\x28\xc6\xa5\x49\x61\x98\xc8\x5e\xfb\xeb\xd3\x95\x33\x7c\xf6\xfb\x2d\x46\xa7\x56\x61\x28\xf1\x9b\xb0\xaf\x4d\xd8\xce\x90\x45\x49\x15\xa5\x48\x12\xef\xa2\x73\xfd\x19\x84\x0f\x5c\x35\x91\xa2\xb0\xda\x27\xed\x55\x97\x0d\xc4\x6e\xe7\x44\x09\x2f\x41\xf8\x81\x8e\x5d\xb2\x42\x4b\x5b\x21\x08\x84\xde\x4d\x0a\xad\xec\x22\xb8\x08\x07\x00\x34\xe1\x2e\x1d\x28\xe2\x5f\x00\x80\x1b\xa1\x34\x15\xa1\x70\x91\x08\xda\x39\x6e\xaf\x7f\x2b\x3f\x27\x15\x90\x01\x26\x1c\x23\x1f\x1c\x02\x0d\x3b\x1c\x04\x8c\x0a\x44\x61\x38\x83\x1f\xbb\x75\x66\x53\x88\x3a\x1b\xa3\x13\x3d\xd4\x68\xb5\xa8\x33\xbb\x66\xd4\x99\x5d\x39\x18\xcc\x38\xfd\xa8\xb3\x37\x54\x91\x41\x48\x37\xa8\x25\x80\x9a\xac\x96\x77\x54\x4d\x32\xab\xdd\xc8\x46\x99\x8e\xec\x6a\xeb\x91\x8d\x30\x20\xd9\x08\x1b\x92\x5d\x65\x46\xb2\xb7\xb4\x24\xd9\x2d\x1b\x13\xc3\xe7\x36\xb1\x9b\x1e\x6c\x6a\x92\x1e\xc6\xa8\x49\x0f\x35\x5a\x4d\xd2\x83\x5d\x4d\xd2\x83\x5d\x4d\x18\xcc\x38\x35\x49\x0f\x6f\xa8\x26\x83\x90\xbe\x0d\x35\x99\xe2\x43\xee\x58\x4f\xda\xd4\xa6\x27\x6d\x3a\x46\x4f\x7a\xa8\xd1\x7a\xd2\xa6\x76\x3d\x69\x53\xbb\x9e\x30\x98\x71\x7a\xd2\xa6\x6f\xa8\x27\x83\x90\x6e\x51\x4f\x3c\x92\x47\x32\xa9\xea\xe6\x2c\x7e\xe2\x1d\x27\x79\x98\xd2\x4b\xd5\x87\xdc\x0a\x64\xf7\xe4\x4e\x87\x98\x63\x5f\xc2\x1e\x28\xce\x34\x34\xa2\x0c\x24\x94\x0a\x46\x86\x90\xe1\x3b\xe5\xf8\x37\x8a\x0d\x48\xa7\x12\x52\x5f\x46\xea\x6f\xfb\xcc\x1f\xb8\xb4\x2a\x1e\xce\xc0\x97\xed\xc7\xa2\x4a\x7e\x2b\xf2\x26\xe4\x14\xc9\xf8\x95\x3b\x00\x26\x7d\xbf\x5e\x15\x0f\x3c\x90\xfa\xd9\xbb\x08\x60\xaa\xa4\xbc\x93\x2f\xe2\x21\xf6\x59\xd8\xe7\xd9\x98\x27\xa4\xcc\xfc\x2b\x30\x96\xfa\x61\x04\xdc\x0a\x91\x88\xc0\xd7\x8d\x04\xc5\x32\x6a\x28\x5c\x00\x18\x1c\x12\x00\x70\x0c\x90\x30\x44\xa6\xfe\x8d\x1e\xaa\xd1\xbd\x13\x69\x8e\x19\x33\x7b\x1f\x75\x70\xb4\x9b\x0f\x55\x58\x9e\x05\x76\xf0\xf7\x2b\xdd\x7f\x20\xfa\x50\xa5\xae\x82\x52\x20\x17\x0a\x01\x34\x48\x85\x96\x8a\x52\xad\xaf\xe2\xfa\xa2\x0c\x98\xc8\x9d\x49\xb6\x26\x20\x1b\xc0\xc5\x93\xde\xd9\x90\xac\xd8\x67\xe5\xad\x10\x2e\x06\x34\x01\xfc\xec\x5d\x01\x16\x5e\x16\xc9\xb5\x63\x50\xa8\x7c\xa2\x3c\x56\xb9\x44\x79\x3c\x96\x47\x09\x54\xfe\x9e\xdf\xc6\x9f\x00\xa2\x72\x47\x5e\x05\xa8\x0c\x92\xf2\x11\x3c\xaa\x80\xc0\x0b\x37\x03\x93\x32\x80\xca\x22\xcd\x41\xa1\xf2\x48\x01\x47\x30\x29\x24\xb3\xd0\xf2\xaa\xe2\x1b\x89\x47\xe5\x39\xc4\xc1\xb1\xb3\x99\x1f\x02\xa4\x65\x27\x4e\xea\xa6\x4a\x76\xa7\x06\x59\x39\x92\x31\xb1\x97\x1d\xf8\xd4\x07\x30\x53\xb8\x0f\xfb\x00\xe9\xc1\x09\xe8\x21\x3e\x61\x3c\xb6\xf6\x22\x77\xf2\xfc\x20\x38\xe1\x09\xa2\x60\xd6\x4c\x0e\x08\x87\xb9\xad\xc8\x13\x30\x2b\xf8\x37\x67\x16\xce\xf4\x53\x42\x83\xc4\xd4\x58\x64\xac\x7f\x57\xa7\xb2\xa6\xbe\xae\x03\x99\x83\xc0\x44\xf6\x00\x08\x33\x02\x59\xdb\x2a\xd4\x44\x47\x50\xdf\x70\x8d\x85\x41\x00\x4a\x56\x37\x19\xc0\xd8\x9c\x71\x07\xaf\x1b\x42\x9d\x45\xdb\xf1\x26\x01\x5c\x19\xec\x58\x64\x2e\x78\xad\x07\x5a\x6b\xf4\x7a\xe0\x00\xd2\x6d\x93\xdd\x17\xa9\x4b\xfa\x2d\x36\xd7\xab\xef\x40\x5e\xa3\xc2\x7a\xa3\x2e\xd2\x97\x4d\xba\xd8\xda\x6a\xad\x07\x3e\x54\x93\x3d\x0a\x95\xcc\x8f\x64\xae\x21\x1c\x7a\x63\x3d\x70\x03\x5a\xec\x31\xc8\x54\x1d\x15\xe7\x90\x84\x43\x3f\x43\x78\x15\x85\x67\x89\x16\x09\xe3\xa1\x46\xe9\xde\x0d\x4f\x4d\x21\x51\xef\xca\xf1\xb7\xe3\x10\x5d\x72\x95\x04\x9e\x9e\x00\xc8\xa1\x4a\x62\xbc\x99\x01\x21\xb4\xe8\x05\x8e\xa0\x69\x8b\xdb\x98\xe7\x2c\xc7\x18\x3c\x69\xb5\x38\x04\xea\xea\x74\x1d\xda\x69\xe6\x2a\x47\x19\x9a\xac\x9a\xf6\x02\x55\x70\x9a\xe2\x86\xfa\x39\xca\x91\x05\x81\xa4\xb1\xd0\x4c\x64\x90\x88\xc0\x9b\xb2\x12\x71\x0d\x4d\x6b\x0c\xc7\x9f\x76\xa1\xd1\x20\x91\xf4\x01\x9a\x22\xb8\xa5\x61\x7e\x08\xea\x00\x41\x49\xe2\xd1\xcd\x22\x98\x8e\xe1\x75\x16\xd1\xb0\xec\x45\xa2\x49\x75\xf6\xec\x01\xa5\x3a\x7b\x99\x98\x52\x9d\x7d\xd3\x61\xa5\x3a\xfb\x9d\x44\x96\xc8\x38\xfc\x7e\x83\x4b\xfd\x40\xfd\xee\xe3\x4b\x75\xf6\x0a\x21\x26\xfc\x2a\xfe\xb5\xa2\x4c\xb4\x47\xb7\x13\x68\xca\xbe\x99\x58\x53\x9d\xdd\x78\xb8\xa9\x9b\x97\xb7\x1f\x71\xaa\xb3\x6f\x32\xe8\x54\x67\x37\x16\x77\x82\x26\xce\x2d\x85\x9e\x80\xe9\x72\x0b\xd1\x27\x78\x92\xdc\x46\x00\xaa\x9b\x1a\xdf\x40\x0c\x2a\xbb\xfd\x30\x94\x3c\x39\xde\x2a\x12\x25\x4d\x82\xd7\x0f\x46\xa9\xea\xfe\xea\xf1\x28\xc0\xe0\xbf\x75\x48\x4a\x35\xe6\x6f\x1f\x95\x52\x67\xd5\xab\x07\xa6\x3a\xb1\xdc\x5e\x6c\x0a\x9e\xcb\xaf\x17\x9e\x02\xe7\xf0\x6b\x44\xa8\x74\x73\xf7\x46\x82\x54\xd0\x6a\xf5\xda\x71\x2a\xdd\xa4\x79\xe3\x50\x95\xe1\x4c\x2d\x26\x9f\xc5\x2f\x12\xab\xca\xe2\x67\x8f\x55\x65\xf1\xcb\xc4\xaa\xb2\xf8\x9b\x8e\x55\x65\xf1\xef\x24\x56\x45\xc6\xe1\xf7\x1b\xab\xea\x07\xea\x77\x1f\xab\xca\xe2\x57\x88\x55\xe1\xef\x01\x5e\x2b\x56\x45\x7b\x74\x33\xb1\xaa\x2c\xfe\x66\x62\x55\x59\x7c\xe3\xb1\xaa\x6e\x5e\xde\x7e\xac\x2a\x8b\xbf\xc9\x58\x55\x16\xdf\x56\xac\x0a\x9c\x38\xb7\x14\xab\x02\xa6\xcb\x2d\xc4\xaa\xe0\x49\x72\x1b\xb1\xaa\x6e\x6a\xdc\x7e\xac\x0a\x6b\xde\x6d\xc7\xaa\x94\xc9\xf1\x56\xb1\x2a\x69\x12\xbc\x7e\xac\x4a\x55\xf7\x57\x8f\x55\x01\x06\xff\xad\x63\x55\xaa\x31\x7f\xf3\x58\x15\x30\xab\x5e\x3d\x56\xd5\x89\xe5\xe6\x62\x55\x9a\xb9\xfc\x7a\xb1\x2a\x70\x0e\xbf\x46\xac\x4a\x37\x77\x6f\x24\x56\x05\xad\x56\xaf\x1c\xab\xd2\x4e\x9a\xdb\x8b\x55\xb1\x0f\x7b\xc9\x84\x3d\xbc\xcc\x57\x7a\x87\x67\x8f\x55\xa5\x87\x97\x89\x55\xa5\x87\x6f\x3a\x56\x95\x1e\x7e\x27\xb1\x2a\x32\x0e\xbf\xdf\x58\x55\x3f\x50\xbf\xfb\x58\x55\x7a\x78\x85\x58\x15\x4e\x4a\xf0\x5a\xb1\x2a\xda\xa3\x9b\x89\x55\xa5\x87\x6f\x26\x56\x95\x1e\x6e\x3c\x56\xd5\xcd\xcb\xdb\x8f\x55\xa5\x87\x6f\x32\x56\x95\x1e\x6e\x2b\x56\x05\x4e\x9c\x5b\x8a\x55\x01\xd3\xe5\x16\x62\x55\xf0\x24\xb9\x8d\x58\x55\x37\x35\x6e\x3f\x56\x85\x35\xef\xb6\x63\x55\xca\xe4\x78\xab\x58\x95\x34\x09\x5e\x3f\x56\xa5\xaa\xfb\xab\xc7\xaa\x00\x83\xff\xd6\xb1\x2a\xd5\x98\xbf\x79\xac\x0a\x98\x55\xaf\x1e\xab\xea\xc4\x72\x73\xb1\x2a\xcd\x5c\x7e\xbd\x58\x15\x38\x87\x5f\x23\x56\xa5\x9b\xbb\x37\x12\xab\x82\x56\xab\x57\x8e\x55\x69\x27\xcd\xed\xc5\xaa\xfa\xec\x62\x98\x7e\x9b\xbe\x48\xb0\xaa\x4d\x9f\x3d\x58\xd5\xa6\x2f\x13\xac\x6a\xd3\x6f\x3a\x58\xd5\xa6\xbf\x93\x60\x15\x19\x87\xdf\x6f\xb0\xaa\x1f\xa8\xdf\x7d\xb0\xaa\x4d\x5f\x21\x58\x85\x33\x23\xbe\x56\xb0\x8a\xf6\xe8\x66\x82\x55\x6d\xfa\xcd\x04\xab\xda\xf4\xc6\x83\x55\xdd\xbc\xbc\xfd\x60\x55\x9b\x7e\x93\xc1\xaa\x36\xbd\xad\x60\x15\x38\x71\x6e\x29\x58\x05\x4c\x97\x5b\x08\x56\xc1\x93\xe4\x36\x82\x55\xdd\xd4\xb8\xfd\x60\x15\xd6\xbc\xdb\x0e\x56\x29\x93\xe3\xad\x82\x55\xd2\x24\x78\xfd\x60\x95\xaa\xee\xaf\x1e\xac\x02\x0c\xfe\x5b\x07\xab\x54\x63\xfe\xe6\xc1\x2a\x60\x56\xbd\x7a\xb0\xaa\x13\xcb\xcd\x05\xab\x34\x73\xf9\xf5\x82\x55\xe0\x1c\x7e\x8d\x60\x95\x6e\xee\xde\x48\xb0\x0a\x5a\xad\x5e\x39\x58\xa5\x9d\x34\x6f\x1d\xac\xf2\xf6\x69\x11\x36\xe4\xc6\x20\xfc\xb8\xe9\x1e\xc5\xdd\x58\x07\x40\x6e\x3d\x22\x10\xf8\x59\x05\xc1\x59\xf3\x09\x84\x94\x33\xdf\x94\x15\xab\x6b\x59\x67\x76\x06\xea\x6c\x0c\x0f\xec\xca\x18\x90\x0d\xe3\x17\x8f\x5d\xeb\x2c\xb6\xf3\x91\xc5\x63\xf8\x60\x77\x92\x8c\xe5\x63\x38\xcd\x86\x47\xe3\x60\xe7\x23\x3d\x8c\xe1\x83\x5d\x7a\x31\x96\x0f\x2e\x52\xd9\x35\x6f\x53\x3b\x23\x6d\x3a\x86\x11\x76\xab\x02\xcc\x88\xb7\x4f\x5a\x7a\x49\x57\x7f\x23\x22\x2e\xa2\xf7\x2b\xb3\xab\x46\xe5\xeb\x45\xfd\x99\xcf\xda\xd2\x6b\xb4\xa4\xe6\xd2\x1d\xa5\x1a\x0c\x75\x93\x44\x5f\x1e\x45\xf2\x6c\x9a\x92\xba\x6d\x5f\x4e\x7f\x13\xbe\x24\x34\x95\x5b\xe4\xe9\x23\x70\xa9\x23\x15\xee\x70\x3f\xe7\x74\xb8\xae\xb1\xbf\x67\x74\xe3\x76\xa5\xc5\x3d\xaa\xf6\x69\xf1\xc0\x2e\xc4\x8f\xd2\xa4\xdc\x54\x28\x6a\xc8\x1d\xdd\x13\xff\xe3\x76\xd7\x47\x53\x29\x45\x17\xdf\xfe\x16\xee\x52\xb4\x21\xf7\x4f\x4e\x80\x1a\xfc\x74\xe6\xfa\x11\x36\x49\x44\x39\xc3\x37\x89\x52\xd6\xe8\xad\xa2\x98\x23\x7f\x60\x07\x5f\xd5\x9f\x22\xc2\x4f\x07\x73\xf1\x1e\xdc\x60\x71\xa6\x57\x10\x2f\xde\xf3\x63\xfe\xe0\x2e\x7c\x5a\xb3\xf0\xa5\x9a\x15\x6b\xb3\x92\xdb\x4c\x7d\xd6\x68\xea\x8b\xad\x8e\x1d\x25\x76\xc3\xf1\x42\xaa\x5a\xf8\xac\x6a\x21\xb7\x5a\xf5\xad\x56\x72\xab\x8e\x58\x7f\xb3\xa7\xd8\x2e\x23\xac\x0c\x37\xab\x2a\x00\xc7\x1e\x40\x87\xc2\xed\xaa\x89\x0c\x1d\xe1\xba\xba\xac\xe9\xab\xd4\x6b\xf4\xb2\x6a\xa8\x04\x2e\xcf\xcb\x76\x43\x35\x74\x63\x5e\x96\x0e\xf5\xea\x45\x79\x59\x6b\x40\xbe\xd5\x37\x7b\xd4\x32\xbc\x35\xf1\xe2\x4e\x99\x04\xc8\x8d\x72\x0e\xf9\x23\xc9\x62\xca\xa3\x06\x20\xaa\x01\x82\xf0\x0c\xc0\xec\x06\x18\xca\x09\x00\x94\x0e\x40\xb8\x8f\x00\x48\x6b\xa3\xb5\xb5\x20\x78\x34\x77\x67\x6b\x65\xd2\x0d\x7a\x99\x11\x91\x01\x12\x0b\x04\x12\x80\xc0\x02\xa9\x13\x80\xbc\x02\x59\x5e\x80\xb8\x02\x51\x5c\x80\xb4\xcc\x84\xb6\xe6\xe6\x8f\xc6\x8e\xc8\xa2\x52\x25\x35\x63\x92\x9a\x76\x82\x9a\xaa\x72\x9a\xf1\xe8\x95\xfa\x6a\xa8\xa7\x37\xee\xaa\x52\x9a\x49\x52\x52\x40\xd2\x01\x84\x5c\xd0\xab\xca\xc8\x48\x65\x6b\x6c\xfc\x68\xea\xc2\xd6\xc2\x9a\x3b\xef\xe5\x43\x54\x69\x0a\xe9\xd2\x5c\x20\x00\x29\xd3\x5c\xe2\x1f\xd2\xa6\xb9\x2c\x27\x48\x9d\xe6\xa2\xa4\x20\x7d\xb2\xd0\xda\x5a\x10\x3c\x9a\xbb\x23\x4b\x0c\xd0\xa9\x05\x93\xd9\xac\x93\xd8\x4c\x95\xd7\x82\x27\xa0\xd4\x57\x43\x3d\xbd\x74\x5b\x95\xd5\x42\x92\x95\x02\x92\x0e\x20\xe4\xa2\x6e\x55\x4e\x46\x2a\x5b\x63\xe3\x47\x53\x17\xb6\x66\xd6\x4a\xd7\x3f\xf7\x3e\x8b\xb8\xa8\x95\xcd\x50\xa7\xae\x6a\x65\xc5\xd5\x02\xcb\x5a\xb9\xe3\xea\xa1\xb5\xa4\x4c\x39\x00\x75\x85\x2a\x5b\x13\xfe\xad\xa1\xe1\xa3\x9e\x6d\xf9\x36\x6d\xb1\xa1\x3b\xed\x45\xa1\x5d\xdd\xca\x66\x80\xd2\x2c\x6f\x65\xc5\x81\xe8\xd6\xb7\x72\xc7\x01\x69\xd7\x8e\x32\xe5\xa0\x34\x0b\x54\xd9\x5a\xc9\x6d\x6d\x28\x1e\x2d\x9d\x92\xe5\x06\xa0\x70\x83\x41\x78\xf0\x32\x57\x36\x03\x0c\xbc\xce\x95\x15\x07\xa1\x59\xe8\xca\x1d\x07\xa3\x5b\x49\xca\x94\x03\x82\xd7\xaa\xb2\xb5\xd1\xda\x5a\x10\x3c\x9a\xbb\xa3\xc8\x4c\x15\xd9\xac\x17\x19\xb8\xde\x95\xcd\x00\x01\x2e\x78\x65\xc5\x01\xc0\x2b\x5e\xb9\xe3\x40\x34\xeb\x4a\x99\x72\x30\xe0\xb2\x55\xb6\x16\x42\x5b\x73\xf3\x47\x63\x47\x64\x49\x29\xcd\xdd\xf9\x20\x28\xdd\xc2\x57\x36\x03\x94\x66\xe5\x2b\x2b\x0e\x44\xb7\xf4\x95\x3b\x0e\x48\xbb\xac\x94\x29\x07\xa5\x59\xbb\xca\xd6\x4a\x6e\x6b\x43\xf1\x68\xe9\x94\x22\x3a\x40\xcb\x16\xbd\xf0\xc0\x15\xb0\x6c\x06\x08\x70\x09\x2c\x2b\x0e\x00\x5e\x03\xcb\x1d\x07\xa2\x5b\x69\x52\x0e\x06\x5c\xc8\xca\xd6\x42\x68\x6b\x6e\xfe\x68\xec\x88\x2c\x2a\x65\x19\x25\xd1\x67\xea\x2c\xc8\x21\xe1\xac\xe1\xab\x31\x7a\x05\xa4\x12\x40\xaa\x7e\xe3\x2d\x79\x0b\x3c\x10\xe5\x45\x81\x4a\x05\x28\xdc\x5d\x05\xa6\xb5\x92\xdb\x1a\xdb\x3f\x5a\x7a\xb4\x35\xf2\xa8\x0f\xff\x65\x6e\x6d\xdc\x29\x73\xb5\xe0\x66\x99\xaf\x87\xf7\xcb\x3c\x84\x66\xcb\xcc\x83\x80\xbb\x66\x23\x15\xe3\xc6\xd9\xc0\xbf\x79\xef\x5c\x8f\xdc\x3e\x73\x70\xfa\x1d\x34\x0f\x64\xd8\x44\xf3\x60\xa6\x7d\x34\x0f\xa7\xdf\x4a\xdb\x89\xda\x77\xd3\xb6\xde\x8d\xd8\x50\xd7\xa3\xf6\xd4\x1c\x94\x76\x5b\xcd\xc3\xe8\x77\xd6\x3c\x94\x61\x73\xcd\x83\x69\xf7\xd7\x56\x8a\xd6\x2d\xb6\xa5\x5f\xf6\x5d\x76\x3d\x62\xa3\xcd\xc1\xe8\xf6\xda\x3c\x88\x76\xbb\xcd\x03\xe9\x77\xdc\x3c\x94\x6e\xd3\x6d\x23\x67\xdb\x77\x9b\x7b\x64\xdd\x7a\xd7\x23\x77\xdf\x1c\x9c\x7e\x03\xce\x03\x19\xf6\xe0\x3c\x98\x69\x1b\xce\xc3\xe9\x77\xe2\x76\xa2\xf6\xcd\xb8\xad\x77\x23\xf6\xe3\xf5\x88\x2d\x39\x07\xa3\xdb\x95\xf3\x20\xda\x8d\x39\x0f\xa4\xdf\x9b\xf3\x50\xba\xed\xb9\x8d\x9c\x6d\x87\x6e\xee\x91\x75\x93\x8e\xd7\x1c\xfd\x3e\x9d\xaf\x06\xb7\xea\x02\x00\xbc\x5b\x17\x40\x34\x1b\x76\x01\x06\xdc\xb3\x9b\x09\x99\xb7\xed\xa6\x5e\x58\x76\xee\x78\x51\x19\xb3\x79\xe7\x01\xf5\xfb\x77\x01\xca\xb0\x85\x17\xe0\x4c\xbb\x78\x01\x50\xbf\x91\x1f\x41\x77\xc4\x5e\xde\xda\xc7\x31\xdb\x79\xbc\xca\xd8\x77\xf4\x3c\x98\x76\x53\x2f\x00\xe9\xf7\xf5\x02\x98\x61\x6b\x2f\xc0\x69\x77\xf7\x76\xa2\xf6\x0d\xbe\xad\x77\x23\xf6\xf8\x78\xd9\xb1\x6d\xf3\x79\x20\xdd\x4e\x5f\x80\xd1\x6e\xf6\x05\x28\xfd\x7e\x5f\x00\xd3\x6d\xf9\xad\x14\xad\xbb\x7e\x4b\xbf\xec\x1b\x7f\xbc\xde\x8c\xd9\xfb\xf3\x80\xfa\xed\xbf\x00\x65\x88\x00\x08\x70\xa6\x20\x80\x00\xa8\x8f\x03\x8c\xa0\x3b\x22\x14\x60\xed\xe3\x98\x68\x00\x5e\x88\x6c\x01\x01\x1e\x48\x17\x13\x10\x60\xb4\x61\x01\x01\x4a\x1f\x19\x10\xc0\x74\xc1\x01\x2b\x45\x6b\x7c\xc0\xd2\x2f\x7b\x88\xa0\xb6\x46\x09\x44\x08\x5d\xa0\x40\x82\xd2\xc6\x0a\x24\x38\x7d\xb8\x40\x02\xd4\x45\x0c\x46\xd0\xb5\x05\x0d\xac\x1d\x34\xc7\x0d\x0c\xe7\x75\x32\x37\x8b\x4d\x81\x03\xae\x16\x0c\x1c\xf0\xf5\x70\xe0\x80\x87\xd0\x04\x0e\x78\x10\x30\x70\x60\xa4\x62\x0c\x1c\x18\xf8\x37\x07\x0e\xb2\x78\x5c\xe0\x80\x83\xd3\x07\x0e\x78\x20\x43\xe0\x80\x07\x33\x05\x0e\x78\x38\x7d\xe0\xc0\x4e\xd4\x1e\x38\xb0\xf5\x6e\x44\xe0\x20\x8b\xc7\x04\x0e\x38\x28\x6d\xe0\x80\x87\xd1\x07\x0e\x78\x28\x43\xe0\x80\x07\xd3\x06\x0e\xac\x14\xad\x81\x03\x4b\xbf\xec\x81\x83\x2c\xb6\x07\x0e\x38\x18\x5d\xe0\x80\x07\xd1\x06\x0e\x78\x20\x7d\xe0\x80\x87\xd2\x05\x0e\x6c\xe4\x6c\x81\x03\x73\x8f\xac\x81\x83\x2c\x1e\x17\x38\xe0\xe0\xf4\x81\x03\x1e\xc8\x10\x38\xe0\xc1\x4c\x81\x03\x1e\x4e\x1f\x38\xb0\x13\xb5\x07\x0e\x6c\xbd\x1b\x11\x38\xc8\x62\x7b\xe0\x80\x83\xd1\x05\x0e\x78\x10\x6d\xe0\x80\x07\xd2\x07\x0e\x78\x28\x5d\xe0\xc0\x46\xce\x16\x38\x30\xf7\xc8\x1a\x38\xc0\x6b\x8e\x3e\x70\xc0\x57\x83\x81\x03\x01\x00\x0e\x1c\x08\x20\x9a\xc0\x81\x00\x03\x06\x0e\xcc\x84\xcc\x81\x03\x53\x2f\x2c\x81\x03\xbc\xa8\x8c\x09\x1c\xf0\x80\xfa\xc0\x81\x00\x65\x08\x1c\x08\x70\xa6\xc0\x81\x00\xa8\x0f\x1c\x8c\xa0\x3b\x22\x70\x60\xed\xe3\x98\xc0\x01\x5e\x65\xec\x81\x03\x1e\x4c\x1b\x38\x10\x80\xf4\x81\x03\x01\xcc\x10\x38\x10\xe0\xb4\x81\x03\x3b\x51\x7b\xe0\xc0\xd6\xbb\x11\x81\x03\xbc\xec\xd8\x02\x07\x3c\x90\x2e\x70\x20\xc0\x68\x03\x07\x02\x94\x3e\x70\x20\x80\xe9\x02\x07\x56\x8a\xd6\xc0\x81\xa5\x5f\xf6\xc0\x01\x5e\x6f\xc6\x04\x0e\x78\x40\x7d\xe0\x40\x80\x32\x04\x0e\x04\x38\x53\xe0\x40\x00\xd4\x07\x0e\x46\xd0\x1d\x11\x38\xb0\xf6\x71\x4c\xe0\x00\x2f\x44\xb6\xc0\x01\x0f\xa4\x0b\x1c\x08\x30\xda\xc0\x81\x00\xa5\x0f\x1c\x08\x60\xba\xc0\x81\x95\xa2\x35\x70\x60\xe9\x97\x3d\x70\xc0\xb2\x86\xeb\x03\x07\x22\x84\x2e\x70\x20\x41\x69\x03\x07\x12\x9c\x3e\x70\x20\x01\xea\x02\x07\x23\xe8\xda\x02\x07\xd6\x0e\x5e\x1d\x38\x60\x1f\xd8\x64\x6e\x7a\x30\x05\x0e\xb8\x5a\x30\x70\xc0\xd7\xc3\x81\x03\x1e\x42\x13\x38\xe0\x41\xc0\xc0\x81\x91\x8a\x31\x70\x60\xe0\xdf\x1c\x38\x48\x0f\xe3\x02\x07\x1c\x9c\x3e\x70\xc0\x03\x19\x02\x07\x3c\x98\x29\x70\xc0\xc3\xe9\x03\x07\x76\xa2\xf6\xc0\x81\xad\x77\x23\x02\x07\xe9\x61\x4c\xe0\x80\x83\xd2\x06\x0e\x78\x18\x7d\xe0\x80\x87\x32\x04\x0e\x78\x30\x6d\xe0\xc0\x4a\xd1\x1a\x38\xb0\xf4\xcb\x1e\x38\x48\x0f\xf6\xc0\x01\x07\xa3\x0b\x1c\xf0\x20\xda\xc0\x01\x0f\xa4\x0f\x1c\xf0\x50\xba\xc0\x81\x8d\x9c\x2d\x70\x60\xee\x91\x35\x70\x90\x1e\xc6\x05\x0e\x38\x38\x7d\xe0\x80\x07\x32\x04\x0e\x78\x30\x53\xe0\x80\x87\xd3\x07\x0e\xec\x44\xed\x81\x03\x5b\xef\x46\x04\x0e\xd2\x83\x3d\x70\xc0\xc1\xe8\x02\x07\x3c\x88\x36\x70\xc0\x03\xe9\x03\x07\x3c\x94\x2e\x70\x60\x23\x67\x0b\x1c\x98\x7b\x64\x0d\x1c\xe0\x35\x47\x1f\x38\xe0\xab\xc1\xc0\x81\x00\x00\x07\x0e\x04\x10\x4d\xe0\x40\x80\x01\x03\x07\x66\x42\xe6\xc0\x81\xa9\x17\x96\xc0\x01\x5e\x54\xc6\x04\x0e\x78\x40\x7d\xe0\x40\x80\x32\x04\x0e\x04\x38\x53\xe0\x40\x00\xd4\x07\x0e\x46\xd0\x1d\x11\x38\xb0\xf6\x71\x4c\xe0\x00\xaf\x32\xf6\xc0\x01\x0f\xa6\x0d\x1c\x08\x40\xfa\xc0\x81\x00\x66\x08\x1c\x08\x70\xda\xc0\x81\x9d\xa8\x3d\x70\x60\xeb\xdd\x88\xc0\x01\x5e\x76\x6c\x81\x03\x1e\x48\x17\x38\x10\x60\xb4\x81\x03\x01\x4a\x1f\x38\x10\xc0\x74\x81\x03\x2b\x45\x6b\xe0\xc0\xd2\x2f\x7b\xe0\x00\xaf\x37\x63\x02\x07\x3c\xa0\x3e\x70\x20\x40\x19\x02\x07\x02\x9c\x29\x70\x20\x00\xea\x03\x07\x23\xe8\x8e\x08\x1c\x58\xfb\x38\x26\x70\x80\x17\x22\x5b\xe0\x80\x07\xd2\x05\x0e\x04\x18\x6d\xe0\x40\x80\xd2\x07\x0e\x04\x30\x5d\xe0\xc0\x4a\xd1\x1a\x38\xb0\xf4\xcb\x1e\x38\x60\x29\x9c\xf5\x81\x03\x11\x42\x17\x38\x90\xa0\xb4\x81\x03\x09\x4e\x1f\x38\x90\x00\x75\x81\x83\x11\x74\x6d\x81\x03\x6b\x07\xaf\x0e\x1c\xf4\x19\x31\x32\xb7\x4d\x4d\x91\x03\xae\x16\x8c\x1c\xf0\xf5\x70\xe4\x80\x87\xd0\x44\x0e\x5a\xdb\x17\xfe\x46\x2a\xc6\xc8\x81\x81\x7f\x73\xe4\xa0\x4d\xc7\x45\x0e\x38\x38\x7d\xe4\x80\x07\x32\x44\x0e\x78\x30\x53\xe4\xa0\x1d\xf5\xd9\xbf\x9d\xa8\x3d\x72\x60\xeb\xdd\x88\xc8\x41\x9b\x8e\x89\x1c\x70\x50\xda\xc8\x01\x0f\xa3\x8f\x1c\xf0\x50\x86\xc8\x41\x3b\x26\x17\x80\x95\xa2\x35\x72\x60\xe9\x97\x3d\x72\xd0\xa6\xf6\xc8\x01\x07\xa3\x8b\x1c\xf0\x20\xda\xc8\x01\x0f\xa4\x8f\x1c\xb4\x23\x12\x04\xd8\xc8\xd9\x22\x07\xe6\x1e\x59\x23\x07\x6d\x3a\x2e\x72\xc0\xc1\xe9\x23\x07\x3c\x90\x21\x72\xc0\x83\x99\x22\x07\xed\xa8\xac\x01\x76\xa2\xf6\xc8\x81\xad\x77\x23\x22\x07\x6d\x6a\x8f\x1c\x70\x30\xba\xc8\x01\x0f\xa2\x8d\x1c\xf0\x40\xfa\xc8\x41\x3b\x22\x95\x80\x8d\x9c\x2d\x72\x60\xee\x91\x35\x72\xd0\xa6\xc6\xc8\x01\x5f\x0d\x46\x0e\x04\x00\x38\x72\x20\x80\x68\x22\x07\xad\x35\xbf\x80\x99\x90\x39\x72\x60\xea\x85\x25\x72\xd0\xa6\x23\x23\x07\x3c\xa0\x3e\x72\x20\x40\x19\x22\x07\x02\x9c\x29\x72\xd0\x8e\x4b\x3a\x30\x82\xee\x88\xc8\x81\xb5\x8f\x63\x22\x07\x6d\x3a\x2a\x72\xc0\x83\x69\x23\x07\x02\x90\x3e\x72\x20\x80\x19\x22\x07\xed\xa8\x4c\x04\x76\xa2\xf6\xc8\x81\xad\x77\x23\x22\x07\x6d\x3a\x22\x72\xc0\x03\xe9\x22\x07\x02\x8c\x36\x72\x20\x40\xe9\x23\x07\xed\x98\xf4\x04\x56\x8a\xd6\xc8\x81\xa5\x5f\xf6\xc8\x41\x9b\x8e\x8c\x1c\xf0\x80\xfa\xc8\x81\x00\x65\x88\x1c\x08\x70\xa6\xc8\x41\x3b\x2e\x67\xc1\x08\xba\x23\x22\x07\xd6\x3e\x8e\x89\x1c\xb4\xe9\x88\xc8\x01\x0f\xa4\x8b\x1c\x08\x30\xda\xc8\x81\x00\xa5\x8f\x1c\xb4\x63\x12\x19\x58\x29\x5a\x23\x07\x96\x7e\xd9\x23\x07\x6d\x6a\x8b\x1c\x88\x10\xba\xc8\x81\x04\xa5\x8d\x1c\x48\x70\xfa\xc8\x41\x3b\x2e\xbb\xc1\x08\xba\xb6\xc8\x81\xb5\x83\x96\xc8\x81\xd7\xa0\xb6\x4f\xb5\x7f\xc6\x3f\x48\x46\x56\x25\x13\x34\x05\xa5\x57\x69\x3c\x1c\x93\x06\xb9\x38\xf5\x32\x70\x15\x06\x86\x6c\xaa\x53\x1e\x85\x0d\x3a\xcb\xb9\x21\x71\x6d\x5f\x88\xd2\x34\x29\xeb\xa4\xde\xaa\x28\x29\xa2\xae\xef\x3c\x6b\xa9\x94\xd0\x13\x57\x61\xe1\xf1\x50\xb8\x40\x01\xa3\x09\x7f\x39\x38\x25\x07\xaf\x3e\xef\x03\x6e\xc5\xb2\xbe\xda\x18\xea\x33\xbf\x5a\x79\xaa\xb3\x31\x6c\x19\x3e\x2b\xc1\xcd\x58\x16\x58\x1b\x5f\x7d\x26\x58\x2b\x5f\xc3\xc5\xf3\x57\xf2\xc5\x4e\xad\x90\xd1\x3b\x8c\xe3\xab\xcf\x0c\x6b\xe5\x6b\xb8\x64\xec\x4a\xbe\xfa\xa0\x18\x6e\xc7\xb2\xc4\xda\x18\xeb\x33\xc5\x5a\x19\x1b\x12\x4a\x1b\x19\xa3\xbd\x28\x1e\x50\x15\x85\x35\x3a\xd3\xd9\x12\xe6\xf5\xbe\xa8\xb2\x4d\x5f\xa1\xe0\x3f\x95\x25\xdc\xa4\xaf\x50\xf5\x3d\x2c\x93\x26\x4c\x93\xdf\x94\x36\x43\x0d\xdf\x68\x5f\xe4\x8d\xfb\x80\xb3\x83\xba\xe4\xaa\xa7\x33\x57\xb4\x99\xfb\xbe\x08\xb3\x2b\xd2\x58\x80\x58\xf5\x10\x18\x7b\x44\x2a\xeb\xe6\x31\x45\x1b\x52\x42\x39\xc3\xd3\xfd\x1c\x15\x69\x51\x6d\xfe\xb4\xdf\xef\x55\xf5\x3b\x35\x28\x66\x00\xcb\xd9\x32\x5a\x05\x1c\x4c\xc8\x01\x91\x24\xb1\x13\xa1\xe8\xd8\x19\x18\xd6\x7a\xbe\x5b\x04\x8b\x95\x42\xa1\xac\x92\x2c\xac\x1e\x19\x94\x1f\xac\x16\xf1\x9d\x4a\x83\x82\x89\x54\x58\xa1\x40\xc7\x0f\x16\x61\xb8\x50\x27\xf8\x29\x8a\x50\x5d\x33\xa8\x45\xb4\xbb\x5b\x44\x2a\x1d\x0a\x26\xd2\x61\x85\x62\x7f\xe6\xeb\x78\x3e\x57\xe8\x24\xf9\xbe\xe8\x89\xec\x22\x3f\x46\x2a\x91\x0e\x46\xa4\x80\x4b\x04\xf4\xb3\xe9\xce\x8f\xd5\x6e\x3c\x84\x55\x9e\xe4\x87\x7e\xcc\xfc\x30\x9e\x03\x14\x28\x98\x48\x84\x15\x0a\x74\x50\xb4\x5e\x4d\xd5\x81\x8f\xc3\xfc\x30\x00\xc5\xeb\xc5\x6c\xbe\x57\xc9\x10\x28\x91\x0a\x2d\x13\x88\x44\xeb\x99\x1f\x44\x0a\x91\x43\x15\x3e\xba\x71\x58\x7d\x61\x70\xc1\x3a\xd8\x05\xc0\xa8\xf4\x80\x22\xa9\xa1\x58\xa0\x36\xf5\xa7\xd3\x69\xa0\x50\x3b\x26\x31\xc2\x33\x61\xe3\x7f\xf2\x9d\x70\x4b\xa0\xf1\x64\x2c\xc3\x0a\xe5\x0d\x59\x14\xeb\x63\x18\x17\x0f\x38\xcf\xf4\x76\x17\x46\x5f\x0e\xf8\x52\x03\x57\x85\x1e\x72\x29\x27\x39\x4d\x71\x7c\xc6\x7f\x93\x34\x69\x1e\xe9\x42\xcb\x73\x41\x4a\xdc\xb6\x76\x4f\xe5\x39\x4e\xea\x32\x0d\x1f\xb5\xf9\xce\xfb\x0c\xc2\x8b\xd5\x02\xdb\xcb\xa1\x75\x5c\x3c\xe4\xba\xf6\x86\x95\x93\x22\xa8\x33\x03\x79\x80\xfe\x6a\xb9\x92\x9a\x5f\x49\x9f\xad\x90\x14\x41\x16\x5f\x47\x7f\xbd\x9e\x4a\xcd\xaf\xa4\xcf\x56\x42\x8a\x20\x3d\x5c\x47\x7f\x3a\x5d\xaf\xa5\xf6\x57\x32\xd0\x2f\x79\x6c\x08\x53\x13\x07\x1c\x94\x89\x8e\x47\x55\xae\x33\x82\x79\xe3\xee\xd2\x22\xfa\x62\x51\x2a\x0c\x79\x36\x36\xc4\xbf\x04\x6e\x44\xe8\x24\xc7\x57\x21\x3c\x81\x8e\xd4\x92\xfc\xb4\x52\x7a\x7a\xbf\xc0\xf6\x7c\x21\x30\x66\x14\x11\x1d\x00\xf2\x4b\x37\x4c\x9f\xbe\xff\x93\x53\x17\xa7\x2a\x42\xbf\x84\x65\x99\xe4\x87\xff\xfe\xcf\x9f\x7f\xdc\x15\x45\x53\x37\x55\x58\x7a\x59\x92\x7b\x51\x5d\x7b\x59\x58\x3a\xdf\x7f\xfa\xff\x03\x00\x00\xff\xff\xae\xba\xa2\x3e\xd4\x4d\x02\x00") + +func uiAppLibBootstrap400Alpha6DistCssBootstrapMinCssBytes() ([]byte, error) { + return bindataRead( + _uiAppLibBootstrap400Alpha6DistCssBootstrapMinCss, + "ui/app/lib/bootstrap-4.0.0-alpha.6-dist/css/bootstrap.min.css", + ) +} + +func uiAppLibBootstrap400Alpha6DistCssBootstrapMinCss() (*asset, error) { + bytes, err := uiAppLibBootstrap400Alpha6DistCssBootstrapMinCssBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "ui/app/lib/bootstrap-4.0.0-alpha.6-dist/css/bootstrap.min.css", size: 150996, mode: os.FileMode(420), modTime: time.Unix(1, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _uiAppLibBootstrap400Alpha6DistCssBootstrapMinCssMap = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x7d\x6b\x57\xdb\x3a\xd3\xe8\x7f\xe9\x57\xbc\x37\xe1\x5a\xfa\x9c\x4f\x92\x2c\x1b\xdb\x38\xc1\x75\xd3\xec\xf4\xac\x77\x75\xb9\xc1\x75\x4c\x6e\x24\x21\x84\x70\xd6\xf9\xef\xef\xd2\x5d\x96\xe5\x10\x28\xdd\xed\xde\x4f\xf8\x10\x6c\x69\x74\x1b\x8d\x66\x46\xd2\xcc\xf8\xff\xbd\x7b\xc8\x17\xcb\x72\x36\x7d\xf7\x9f\x13\xe7\xdd\x72\xb6\x5a\x0c\xf2\xe5\xbb\xff\xfc\xdf\x77\x7f\xfe\x79\xf8\xe7\x9f\x87\xcb\xc1\x72\x79\xf8\x75\x3a\x5b\x4c\xb2\x71\xf9\x94\xff\x49\xde\xdf\x39\xef\xbe\xcd\x66\xf7\xcb\xfb\x45\x76\xf7\x27\x7b\xd7\x81\xef\x16\xe5\xf4\x5e\x00\xea\x19\x8b\x9c\x14\xb3\xe5\x3c\x64\x8b\x32\xfb\x36\xce\x97\x96\xcc\x49\xf9\x58\x4e\x97\x87\x5f\x87\xb3\x87\x7c\x61\x2b\x7c\xbf\xb9\xcb\xb7\x94\x1b\x97\xcb\x7b\x5b\xbd\x5f\xcb\x49\x56\x6c\x6d\x91\x02\x6c\xc9\xff\x36\x5b\xdc\xe4\x8b\x3f\x16\xd9\x4d\xb9\xb2\xb6\xc0\x00\x6d\x39\x83\xd9\x8d\xad\xe6\xaf\xc5\xa2\xbc\xd9\xd2\xe2\x33\xd9\xdf\x16\x79\x36\xba\x9b\x95\x53\xeb\x80\xf5\x4a\xfe\xf8\xbe\xc8\x26\xf9\x7a\xb6\x18\x59\x31\xfa\xdc\x5c\x50\x80\x3f\x16\xb3\xb5\xad\xf4\xf7\xd9\x62\xb2\xad\x70\x53\xfe\xd7\x6f\xab\xfb\xfb\x99\x15\x5f\x72\x80\x8d\x10\x5f\xef\x17\xd9\x74\x59\xde\x97\x0d\xd9\x37\x8b\xd9\xdd\xcd\x6c\x3d\xdd\x52\xf9\x34\x7b\xf8\xe3\xa6\x7c\x28\x6f\xec\x64\xc6\xda\xfe\xa3\x58\xcc\x56\x77\x56\x72\x9a\xde\xad\xee\x9b\xb3\x07\xab\xe5\xfd\x6c\xf2\x47\xe3\xe0\xa7\xd9\x43\x43\xf2\xb7\xcc\xda\x9f\x41\xb6\xd8\x46\x0b\x24\xdb\x8e\xe5\x45\x9e\xdd\x0c\x16\xab\xc9\xb7\x6d\xa5\xc7\x79\xb6\xf8\x5e\x3e\xda\x2a\xb8\xcb\x8a\x72\x9a\x11\x4c\x6f\xa9\x60\x2b\xd0\xd7\x6f\xd9\xcd\xf6\x95\xd5\x90\xff\xf5\x76\x35\xf9\x36\xbb\x5f\xd8\x6b\xcd\xc6\xf9\xc2\xc6\x5e\x44\xad\x4d\xf9\x5f\xef\x16\xb3\x62\x91\x2f\xb7\x2f\x9a\xec\xa6\xcc\xed\x0b\xeb\xeb\x24\xbf\x29\x33\x5b\x06\xe1\x3d\x8d\x24\xa1\x33\xa8\x66\xba\x59\xe4\xcb\xbb\xd9\x74\x59\x3e\xe4\x7f\xe4\x93\x6f\xb9\x6d\xca\xbf\x0e\xc6\xb3\xa5\x15\x5d\x93\xd9\x4d\x36\xb6\xae\x96\xd9\x6c\x7c\x5f\x6e\xeb\xd5\x22\x5f\xe6\xf7\x7f\xdc\xe7\x8f\x76\x8c\xcd\xee\x9a\xd8\xf1\x20\x5b\xcc\x56\xcb\xdc\xd6\xac\x64\x1f\x64\xad\x36\xad\x84\xd5\x7d\x39\x2e\xef\xcb\x9c\x4e\x58\x59\xd8\x66\x5a\x03\xf9\x96\x0d\x46\x04\x77\xd3\xad\x7c\x51\x02\xfd\x41\x25\x8d\x55\x3c\xe9\x95\x52\xc6\xfe\x4c\xe7\x6e\xca\xe5\xdd\x38\xdb\x6c\x07\xfa\x3e\xce\x6d\x6b\xa8\x02\x31\xcb\xb6\x11\x6d\x53\xbe\x56\xc5\xdd\x8c\x31\xbe\xed\x50\xcb\xc1\x22\xcf\xa7\x64\xf1\xdb\x87\x26\x1a\x64\x70\x7f\x30\xc0\x67\xaa\x2c\x9f\xca\x69\xf1\x0c\xcc\x5d\x36\x78\x16\xa8\x81\xcc\x24\xbd\xe4\x8f\xf7\x7f\xdc\x2f\x56\xd3\x41\x76\xbf\x8d\x6d\x50\xb8\x7c\x72\x37\xcc\x96\xe5\x56\xf1\x45\xe0\x86\xa5\x55\x04\x6b\xbd\x7a\x28\x97\xe5\x37\xf2\x66\x9b\x64\x51\x97\x09\xf4\x3f\xce\xbb\x69\x36\xa1\x2a\xd4\xff\x38\xef\x26\xd9\xdd\x5d\x39\x2d\x96\xef\xfe\xf3\xee\xff\x90\xbf\x53\x0c\xfa\xc0\x89\x00\xc2\x4e\x1f\x00\xe0\xf4\x00\x02\xec\x29\x22\x4f\x73\x28\x1f\x37\xfc\xb1\xeb\x31\xf0\x0e\x79\xc5\xa0\xe3\x39\x09\x79\x8a\xc9\x4f\x47\xfe\x04\xe4\x27\x01\x31\x16\xb9\x89\xe7\xf8\xa4\x58\x97\xe5\x22\x0e\x17\xb3\x5a\x7a\x9e\xd3\x93\x65\x23\xe0\xcb\x62\x1d\xcf\xe9\xc8\xd6\x02\x96\x2b\xaa\x9a\xd0\x1e\xf1\x6e\xd3\x27\x51\x2b\x26\x4f\x29\xeb\x42\xe2\x91\xe6\xf8\xf0\xba\xec\x07\x01\xd1\x8f\x9e\x47\x80\xb1\x53\x42\x59\xc3\x39\x94\x05\x79\x15\x18\x3b\x03\x56\x6d\xe2\x11\x18\xfe\x4a\xd1\x52\x40\x59\xa5\x78\xa4\xe3\xe8\x90\x8a\xe9\x13\xe6\x6d\x27\x96\xb4\x0e\xa9\x31\xd2\xc6\xe6\x37\x75\xb4\xc3\x87\xd1\x93\xd5\x47\xaa\xdf\xb4\x27\x31\x7b\xea\x78\x4e\xac\x21\x9a\x0e\x9f\x3e\x61\x1d\xf9\xfd\x2a\x9a\x52\xf2\x94\xb3\x27\x9f\xb7\xc4\x27\x53\xbc\x06\x6c\x42\xba\x1e\x6b\x28\x26\xf5\xd1\x49\xca\x48\x93\x4b\x48\x60\x12\xd9\x19\x45\x1d\xb4\x70\x26\xfb\x96\x93\xd7\x94\x55\xdd\xf3\x34\x22\x48\xe5\xfc\xa7\x20\xd2\xa9\xb1\x2b\x2b\xed\x9b\xd5\x27\xb2\x02\x8c\xb5\xf9\xee\x48\x24\xe7\xac\x44\xea\xb1\x1e\x0c\x64\x1b\x13\x08\x02\x41\x41\x14\x9b\x05\x22\x8f\x07\x34\x81\x3d\x6f\x28\x48\x26\xdb\x4c\xe4\x90\x18\x85\x9c\xd2\x5f\xf6\xbc\xa4\xb0\x89\x9c\xc8\x0e\xeb\x7d\x87\x90\x50\x85\x7a\xf9\x32\x51\x43\x10\x13\x62\x2c\x22\x8a\xe8\x8e\xa2\xf2\x9e\xf6\x23\xe6\x3a\xd1\xca\x55\xf0\x94\xc8\xc9\x55\x44\x96\xca\xf9\xc9\xb4\xb9\x16\x1d\xa4\xb8\x8b\xd0\x61\xe8\x71\x2a\xce\xdc\x4d\xd4\xd0\x36\xab\x1d\xdd\x45\x9e\xb3\x61\x88\x42\xee\x79\xc4\x07\x19\xa1\xc7\xc8\x73\x06\x6e\x79\x25\x4a\x77\x65\x73\x11\x7a\x1f\x79\xce\xa9\x28\xb3\x94\x20\x74\x49\x9f\x43\x35\x5a\x8a\xa0\x88\x8d\xb1\xe7\x09\xb2\xc2\x3a\x57\x48\xe4\x78\xba\x12\x55\x8a\x1c\xd5\x68\x23\xf4\x3e\xf6\x9c\xd4\x5d\xb7\x45\x02\x1e\x0e\x28\x12\x30\xc3\x7e\x22\x89\x8f\x71\xb8\x15\xfd\x1d\x31\x42\xa0\xbf\x6c\x8d\xe5\x2a\x61\x00\x06\x9c\x40\x73\x80\x01\xef\x73\x2e\xb1\x94\x93\x35\x83\x59\xd7\x30\x96\x6c\x21\xf1\x08\x24\xeb\xd7\x39\x24\xc3\x7b\x0f\x49\x2d\xe7\xd0\x09\xc0\xe0\x10\x6a\x6c\x6a\x02\x01\xe6\x1c\x91\xae\x5b\x83\x7e\xe8\x24\xb3\x1e\x52\xc6\x1a\xcb\xd1\x4e\x20\x5b\xaf\x00\x38\x3e\x29\x28\x80\x7c\xc2\x32\x69\x22\xa5\x0c\xc1\x5f\xb1\x46\x88\x0a\x04\x0b\xb6\x12\x83\x58\x47\x74\x44\x3a\xd5\xb1\xd0\x73\x44\x0a\xd3\x0c\x36\xd6\x09\x04\xae\x27\x58\x58\x14\x48\x04\xfa\x21\xc7\x15\xe9\x66\x60\xd6\x52\x40\x74\xe2\x7d\x64\x6c\xad\x4e\x78\x02\xa5\x7c\xba\x7c\x01\x93\x48\x98\x04\xcc\x20\x5d\xe2\x05\x64\x15\x66\x20\x19\x13\x3c\xf7\x15\x29\xfa\x62\xd9\xf6\x49\x85\x4a\xec\x0d\x80\xe0\xb9\x5a\xcb\x1d\x74\x1c\x9d\x5e\x3a\x25\x74\x4f\xa2\xb3\x4b\x56\xa7\x8d\x23\x05\xda\x13\x96\x6b\x13\x0b\xc2\x89\xbc\x49\x42\x18\x24\x3e\xba\xe6\x88\xec\x83\x3e\x45\x76\xd0\xf0\x83\xc6\x90\xf5\x80\xce\xcf\x40\xd2\x3c\x96\x02\x40\x65\x44\x20\xf0\x9c\x96\x18\x13\x96\x12\x94\x4f\x9c\x12\x54\x3d\xb9\xb0\xb8\x34\xaa\xd0\x84\x4f\xca\xd6\xaa\xf6\x25\xb3\x57\x3f\x81\x14\x86\x3e\x97\xc3\x7c\xe8\xe2\x75\x20\x39\x52\x5f\xc2\xf5\x34\x8d\x41\xfc\xd0\x55\x4f\x87\xa4\xb8\x19\xa3\x9f\x08\x0f\x43\x8e\xaa\xc4\x9b\x84\xa0\x06\xd0\x05\xdd\xd0\xb9\x80\x0d\x65\x23\xec\xcc\x28\x93\x99\x21\x6f\x12\xd5\x4b\x47\xa0\x1d\x12\x88\x6e\x20\x56\x41\x1a\xb2\x75\xc6\x11\x80\x25\x02\x30\x67\x0d\x11\x13\x2b\xbe\x7d\x10\x01\xc9\xa0\xeb\xbf\xe3\x5d\xc4\x9e\x33\xc0\xb7\x31\x87\x4c\xc0\xc0\x13\xf8\x02\x9c\xa7\x75\xaa\x28\xed\x68\x64\x9d\x8a\xa5\x97\x69\x3f\x74\x85\x4b\x46\x92\x2a\xca\xea\xcb\x69\xee\xcb\xc9\xcd\xe5\x93\x1a\x76\x4f\x12\x41\x06\x84\x4c\xf7\xe5\x78\x23\xd9\x80\x12\x0f\x8a\xe6\x32\xb9\xfc\x03\x59\xb3\x7a\xa5\xe3\xd9\x40\xb6\xfe\x2b\x03\x4a\x89\xee\xa7\x28\xed\x82\x76\xf8\x18\x82\x98\xaf\xfb\x3e\x88\x42\x3e\x8c\x52\xe4\x31\xbe\x9b\xaa\xa5\xed\x13\x4e\x2e\xf8\x5f\xca\x5e\x63\xae\xc6\xd0\x69\xaa\x71\xb1\x0a\x3f\xeb\x68\x22\x03\xe9\xbc\x33\x31\x17\x17\x92\x7a\x5b\x65\x7d\x4c\x20\x88\x94\x90\x0a\x2a\x62\xc6\xbb\x08\x3c\x27\xc5\xf7\x42\xee\xe7\xfe\xe1\x5f\x94\xf5\x46\x4d\x3f\x4f\x70\xdb\xa2\xc7\x63\x68\x2e\x9d\xc4\xca\x62\xd4\xd4\xfa\x54\x2b\x0b\x49\x0d\x5d\xd9\xff\xb6\x99\x16\x59\xd2\x12\x4b\x9a\xad\xac\x0d\x2e\x02\xf8\xb3\xa6\x62\xea\x9d\x0c\xf8\x4a\xdf\xc6\x20\x75\x90\xce\x4f\x04\x11\xbb\x04\x45\xfc\x8a\x17\x2a\x62\xe9\x81\x8a\x0c\xca\xab\x2a\x65\xd7\xac\x54\x30\x44\xa5\x8c\xd0\xfa\x4a\xb5\x65\xc8\xd1\x7b\xcc\xb5\x46\xd5\x40\xe4\x96\x9e\xe7\x64\x68\xec\x59\xb2\x66\x9e\x47\xc8\x5e\xe9\x2f\xae\xe7\x4c\x10\x08\x02\x06\x1a\x10\x5e\xd7\xaf\x6e\x9d\x72\xc6\x04\x03\xbe\x1b\x51\xba\xa3\x31\x4e\x63\x82\xd4\x12\x15\xd4\x8d\xb0\xa9\x40\xea\xf4\x75\xe9\xf1\x15\x9b\x00\xb0\x24\xd4\x19\x1d\x41\x67\x06\xab\x72\xc5\x18\x4f\xac\xb1\x19\xa0\x33\x21\x25\x0c\x0e\x10\xc0\xb4\xce\x9e\xe3\x03\xef\xbb\x73\x81\x88\x92\xc0\xdb\xc0\x8b\xe0\x08\x3a\x3d\x14\x48\x2a\xf2\xc5\xb6\xd0\x75\xf9\xf6\x21\x91\xb3\xae\x6d\x7f\x4c\x9d\x04\x7f\xe1\xbd\xec\xa0\x9e\x58\xc3\x81\xfc\x51\x52\xdf\x48\xeb\x19\x69\x5e\x18\xd6\x3b\x92\x7b\x6c\x57\xc8\x27\xcc\xd7\x77\x85\x86\xe4\x2b\x60\x75\xea\x18\x42\x82\x47\xa4\xef\xfb\x38\x2f\x0d\x38\xc7\xd4\xb9\x28\xe5\x89\x1f\x27\xd7\xc7\x9e\x33\x48\xa6\xd7\x27\x1e\x9b\xf7\xa8\x3a\xef\xf6\xf9\x53\x94\xe9\x7d\x12\xc8\xc0\x99\xce\xc5\xb0\x15\x9a\xb0\xe6\xe0\xf9\x06\x74\xd2\xf7\x9e\xa0\x18\x3f\x9e\xc3\xd0\x49\x40\x1a\x68\x4d\xd4\x18\x42\x5c\x6d\x41\x50\x0f\xb6\xd0\xaf\x3e\xa2\x2b\x22\x01\xea\x35\x27\xb6\x61\xf4\x65\x5d\x98\x0c\x88\x4d\x44\xaf\xda\x5e\x07\x3d\xb9\xc0\xe9\x21\xa0\xef\x83\xfb\x55\xda\x8e\x08\x75\x1a\xf4\x1e\xa1\x63\xe4\x39\x1b\xe8\x4d\x5d\xcf\xe9\xa1\x4e\x0d\x20\x7e\x23\x80\xd6\xce\x35\x8c\x60\x60\x4e\x55\x8c\x8a\x37\x82\x68\xd5\x20\x3a\x0a\xc2\xbd\x26\x92\x1c\x7d\x79\x2d\x0e\x1f\x90\x47\xca\x5f\x35\x8f\xf0\x87\x21\x5a\xdb\x20\xdc\x41\xe8\x44\x28\x03\x42\x39\x17\xea\x58\x26\x9f\x54\x9a\xb6\xf5\x8a\x24\x0b\x89\x00\x90\x24\x1e\x71\xb6\xad\xd8\x40\x8c\x52\xda\xc5\xf7\xd0\x73\x22\x34\x81\x35\x80\xce\xdb\x00\xb4\xb6\x01\xb8\x37\x5c\x88\x28\x76\xcd\x79\x94\xe7\xf1\xf5\xd2\xa2\xac\x7e\x20\xf3\x19\xa4\x7f\x8b\x42\x4d\x6d\x4d\xaa\x3f\x9d\x1d\x7f\x12\x89\xa1\x5e\xf5\xa7\xbb\xe3\xcf\x3f\xbd\x02\x71\xc6\x92\x56\xb9\x27\x93\x36\xde\x0a\xd6\x24\x6a\x84\x96\x90\x4c\x3a\xba\x75\xbd\x3d\xfe\x7f\xb4\x02\xaf\x05\x2d\x9c\x61\x8f\xe1\x3d\x86\xff\x39\x15\x34\x63\xb8\xb5\xc7\xf0\xcf\xc3\x30\x0e\x81\x7e\x26\x49\x8f\x71\xd6\xea\x51\xa9\xad\xa5\x4a\x1c\x59\x1f\xbb\xc0\x50\x87\xb1\xc7\x24\x83\x56\x32\x03\xc6\xf1\x92\xd0\x4c\x8d\xb4\xc8\x4c\x53\x62\x25\x00\x4e\xc7\x3b\x87\xed\x2d\xd5\x76\x2d\xd5\x76\x2d\xd5\x76\x41\x24\x70\x83\xc7\x28\x7e\xb6\xde\x9e\xa5\xde\x9e\xa5\xde\x9e\xac\xb7\xb7\x53\xbd\x81\xa5\xde\xc0\x52\x6f\x20\xeb\x0d\x7e\x69\x7f\xf7\x78\xf8\x3d\xf1\x90\xfc\xa4\xfe\xfe\xaa\x7a\x77\x67\x0f\xa2\xde\x08\x9f\xc0\xc4\x49\xbc\x15\xfa\x28\xce\x49\x1e\x50\x25\xa1\x6b\x26\xf4\xcc\x84\xe0\x59\x88\xb7\x2b\x92\x9a\x10\xdb\x12\xc4\x58\x26\xe8\x23\x47\x03\x9e\x56\x13\xba\x66\x42\xcf\x4c\x08\x9e\x85\x78\xbb\x22\xa9\x09\xb1\x2d\x21\xc2\x47\x30\x71\xba\xde\x12\x7e\xe4\x26\x02\xf8\xbe\x9a\xd0\x33\x13\x82\x67\x21\xde\xae\x48\xcf\x84\xd0\x13\xd0\x03\xc4\x44\x0f\x3c\x82\x98\xdd\x57\xfc\x14\x59\x9a\xfd\x14\x59\xda\xfd\x49\xb2\xf4\xb9\x7a\x5f\xcb\x33\x9e\xab\xf7\xb5\xbc\xf3\x57\xf5\x77\x8f\x87\xdf\x13\x0f\xbd\x9f\xd4\xdf\x5f\x55\xef\x6b\x65\x69\xcf\x94\x3f\x3d\x53\x96\xf6\x4c\x91\xd5\x33\xa5\xdc\x36\x88\xb7\x2b\xd2\x37\x21\xb6\x25\x88\xb1\x18\xb2\xb4\x67\xca\xd2\x9e\x29\xb2\x7a\xa6\x94\xdb\x06\xf1\x76\x45\xfa\x26\xc4\xb6\x04\x26\x4b\x33\x25\xa1\x30\x15\x59\x99\x29\x5c\x33\x53\xa8\x65\xa6\xd8\xdb\x06\xf1\x76\x45\x06\x26\x84\x96\xd0\xdf\x0b\xd7\xbd\x70\xfd\xb7\x08\x95\x3d\x1e\xf6\xc2\x75\x2f\x5c\xf7\xc2\x75\x2f\x5c\xf7\xc2\x75\x2f\x54\xf6\x78\xd8\x0b\xd7\xbd\x70\xdd\x0b\xd7\x7f\xb5\x70\x6d\xed\x85\xeb\x5e\xb8\xfe\xf3\x85\xca\x1e\x0f\x7b\xe1\xba\x17\xae\x7b\xe1\xfa\xdb\x08\x57\xff\x44\x78\x6b\x2a\x73\xd3\xae\x7c\xe2\x56\x4e\x97\xd2\x4d\xb3\x13\x68\x6e\x15\x39\x10\x76\xf7\x3d\x50\xf1\xaa\x48\xc0\x27\x6a\x49\x9f\x05\x9a\xa3\xd9\xc0\x84\xb9\xa1\x7e\x9e\x23\x18\xd4\x8b\x8f\x61\xe8\x0c\xc0\x12\x06\xd2\x75\x23\x0d\x85\x9f\x9b\x1f\x08\x77\x80\x54\x98\xeb\x77\xcc\xf2\xae\xa7\x5c\x48\xa3\x9a\x0b\x69\x02\xae\x42\xee\xc6\xbb\x81\xa0\x17\x3b\x33\xee\xf6\xd1\x6d\x3b\x1b\xea\x75\xc2\x5a\x2d\x20\x69\xe2\x14\x02\x3f\x96\x3e\x68\xe8\x3d\x0e\xd9\x50\xa4\x57\x5a\x10\xa8\xe7\x38\x74\x4a\x04\x22\x05\x0f\xae\xda\xd2\xcd\x10\xa4\x89\x4a\x9f\xc2\x8f\x0c\x39\x23\xe1\xd1\x26\xeb\x49\x48\x35\x23\xad\x9a\x84\xd4\x32\xa7\xb5\xcc\xb5\x5a\x12\x5a\x09\xf7\x30\xa6\x3f\xd5\x2a\x0e\xa0\x51\xc5\x88\x56\x31\xaa\x55\xf1\x26\xfd\x68\x40\x4a\x62\xe2\x24\xb1\xa3\x24\x71\x4b\xef\x33\x69\x1e\x07\x75\xbf\x11\x10\x84\x7a\x56\x62\x64\xe5\x55\xfa\x15\x39\xcc\x63\x4a\x0e\x6d\x0d\x09\xf9\x72\x47\x83\x6b\xea\x19\xda\x0b\x84\x93\x57\x3f\xd4\xbd\xab\x62\x8b\xfd\x35\x7d\x9a\x08\xaa\x09\x3d\x32\xa8\x44\x94\xc7\xc3\x90\x90\x85\xad\xbc\x5f\xf5\xda\x6f\x08\x55\x60\x8e\x2b\xd2\x3c\x83\x49\xea\x9a\x3b\xab\x48\xef\xf2\xbe\xc5\x9b\xa9\xa0\x8e\x88\xcc\x83\xe7\xe3\x27\xa1\x28\x67\xb2\x64\x04\xa4\xeb\xb2\x7a\xef\xed\x00\x33\xb0\xc0\xf4\x9e\xaf\xe6\xe5\x20\x7a\xc3\xc9\xa7\xb6\xd3\x82\xe0\x5c\x72\x01\x2d\x72\x07\x4a\x3d\xee\x62\x56\x47\x1c\x92\x3e\x19\xd2\x87\xd3\x3d\x41\x21\x59\xda\x4b\x14\x68\x8e\xd7\xdc\x3d\xe8\x11\x85\x4e\xb1\x25\x6f\xb6\x25\xef\x18\x36\xe7\xad\x20\x00\x6b\x48\x66\x6e\xe4\xde\x41\x49\x95\x0a\xe8\xce\xa5\x40\x6b\x57\x3a\xbb\x06\xa1\x53\xb8\xd2\xe9\x7d\x06\xc1\x65\x48\x56\x5a\xbf\x4e\xf7\x11\x88\x84\x9b\xfc\x0c\x6a\x0e\xac\x5d\xe1\x4b\x46\x71\xb8\x84\x92\x4f\xb3\x47\xe5\x93\x3d\x51\x50\x2b\x05\xc5\x1e\xb9\x8d\xec\x6e\x50\x5d\xea\x19\x82\xa4\x53\x9a\x00\x8a\xb5\xf6\x14\xd1\xa7\x9e\x33\xdf\x01\xda\x88\xe1\x11\xcb\xe9\xcf\x24\xc5\x63\xd0\x3e\x77\x29\x37\x3a\x64\xff\xe6\xbe\x33\x72\x01\x58\xf8\xce\xca\x25\x00\x2d\x17\x80\x25\xa2\x69\xf7\x48\xa5\x75\xeb\xde\x2b\x20\x63\x4e\xc6\x23\x48\x3d\x90\xc7\xd0\x99\x50\xfe\xb4\x44\x9a\x1f\x61\xc5\xdf\x29\xf9\x74\x16\x0a\x4f\xb6\xb4\x88\x42\x67\x8d\x01\x98\xb9\x4e\x81\x01\xb8\x73\x9d\x39\x55\xf6\x26\x2e\xe1\x58\xb4\x64\x97\x4c\xed\x2e\x4d\x74\xb4\x26\x1e\x23\xd9\xc4\xe9\xf3\x4d\xf4\xa5\x07\xa8\x72\xcb\xef\x59\x9c\xe7\x3a\x32\x3c\x8d\x72\x35\x49\xaa\x53\x10\x13\x89\xbf\x42\xa0\x13\x6b\x74\x27\xfc\xb1\xdb\x9c\x51\xaa\x35\xa6\xd0\xd9\x91\x84\xc3\x60\x54\x0b\x3d\x50\x71\xc1\x4d\x49\x0b\xe7\xd4\x95\x88\x47\x74\x61\xe4\x5c\x71\x6f\x9d\x53\xf7\x56\xae\x41\x84\x21\xc1\x55\x12\x08\x1f\xd5\x94\xae\x1d\x15\xea\xc6\xf7\x78\x18\xa2\xa5\xf8\xf5\x39\x26\x12\xe5\x8c\x45\xa3\x8c\x30\x69\xaf\x87\x94\x91\xfc\x35\x95\x3f\x85\xf6\x8e\xce\xae\x45\x04\x17\xf6\xcb\xe2\xbf\x30\x19\x46\x44\x9b\xe4\x42\x01\x75\x85\x55\xc8\x49\x68\xc4\x98\x0a\x97\xca\x8c\x85\x9c\xb8\xc7\x9d\x90\x7b\xf2\xb2\x94\xf5\x35\xba\x4b\xbc\x9f\xd6\x60\xe4\x4e\xae\xab\x0d\x96\x5d\x74\x96\x78\x3c\xe4\x05\xfb\x65\x8e\xf8\x8c\x44\x0b\xa3\xc1\x96\xd1\xe0\x01\x7c\x76\x84\xd7\x54\x05\x90\x0d\x8e\x52\x30\x08\xb5\x98\x01\x3b\x3b\xd3\xa9\xad\xe5\xa0\xfa\xda\xd5\x5e\x25\xb4\x60\xa2\xe2\x31\x97\x4f\x9c\x86\x2e\x3d\x22\xca\x53\xa1\x70\x84\x47\xd7\x44\xb6\x07\xe5\x35\x65\x7c\x79\xf0\xc2\xde\x3d\xdb\x9e\x44\x09\x4d\x5c\xab\x47\x15\x71\xa8\x80\xa0\xa2\x30\x63\xaa\x0b\x6f\x20\x58\xc1\xdd\xbb\xf3\x46\xc7\x58\x3f\x05\xe7\x6a\x60\x27\x90\xca\xcf\x02\x05\x5a\x48\x09\xa5\x74\xf1\x92\x63\x44\x75\xd0\x95\x82\x7a\x40\x21\xa1\xc1\x63\x24\x15\x45\x22\xdd\x4b\x04\x0e\x90\xce\xda\x79\xf9\xa1\x4b\xd1\xb7\x74\x7f\xf1\x6c\x1a\xda\x24\xd6\x11\xe1\x52\x5d\xfd\xc2\x0d\xc4\x74\x7d\x60\x29\x25\x0e\x4c\x16\xaa\xa4\x56\x47\xf3\xce\xbc\xc3\x21\xe1\x14\x1b\xfc\x8b\x07\xc9\xbb\x7f\x86\x43\x22\x3e\x0e\xb0\xe4\xee\x08\x68\x73\xac\xba\x9f\xb3\x96\xc6\x5e\x48\xc4\xf4\xca\x0b\x78\x50\x22\x7c\xf4\x57\x5b\x73\x5e\xcf\x40\x3d\x74\x83\x2d\x5a\x8d\x11\xda\x64\x06\x25\xad\x96\xea\xb1\x50\x8f\x86\x96\xa1\x14\xe9\x3e\x9a\x61\x60\x06\x4c\x60\x1a\xcc\x97\x43\xfc\x26\x11\x03\xda\x11\x0f\xdd\xd4\x23\x1d\x92\xbd\xba\x49\x48\xea\x17\xa7\x47\x37\xc6\xca\x81\x5d\x3b\xf3\x36\x4e\xda\xd8\x28\x7b\x5b\xb2\xa7\x74\x37\x0d\x72\x67\x00\x36\xf0\x2f\x31\xbd\x2a\x42\xcb\x11\x4c\x49\x1f\xbf\x39\x7d\xba\x18\x05\xae\xe2\x90\xe1\x72\x03\xb5\x18\x69\x89\xe7\x64\xe8\xbd\x75\xbb\x25\x59\xff\x2d\x74\x09\x62\x4a\x18\x5b\x42\x00\x68\x12\x02\x6b\xbb\xf4\x38\xd8\x32\xc4\xc9\xf6\x21\x92\x4d\x7e\xa8\xe4\xbe\x0c\x4c\xa5\xb7\xe5\x7b\x1c\x51\x33\x21\xd9\xfc\x86\x31\xd4\xb6\x11\xee\x20\x74\x72\x34\x74\xb7\xed\x35\x22\x3a\xe6\xb9\x36\xe6\xa4\x71\xcc\x4c\x4d\x99\x3f\x33\xe6\xf9\xf6\x31\xcf\xe9\x98\xd7\x62\x63\x8b\x71\xbd\x4b\x64\xcc\x4b\x4d\x25\x9a\xab\x31\x9b\x9d\xab\x8f\xb9\x84\xa1\xd3\x45\x53\xf7\xf9\x89\x2e\x76\x9a\xe8\x42\x9c\xa8\x6c\x1d\xf4\xf3\xb4\x1c\x69\xc1\xc1\x9a\x26\x5a\x1e\x42\x30\xe5\x65\xf7\x89\x9e\xc1\xd0\xc9\xd0\xfd\x0e\x83\xfe\x17\x51\xf7\x8a\x0e\xfa\xe9\x6f\x1e\xf4\x4e\x33\xfd\xf3\x06\xdd\x82\xa1\xd3\x47\x67\x3b\x0c\x7a\xb4\xd3\xa0\xe5\x39\xd3\x8f\xcf\xb4\x64\x0f\x4d\x83\x96\x08\x66\x67\x79\xbb\x0f\xfa\x00\x92\xda\xd1\x13\x6c\xe0\x64\xda\x29\x8b\x40\xc0\x11\xc2\xce\x31\x2c\xe1\xb9\x2d\x9a\x4b\xb5\x5b\x2c\x32\xd7\x31\xed\xf7\x8f\xa0\x40\x86\x01\xbb\xa0\x55\x99\x3d\xa5\xd1\xcc\xf4\xad\xca\x71\x33\x0a\xf8\xb8\xe9\x59\x0c\x3a\x83\x75\x28\xeb\xb0\x23\x36\xec\xf3\x86\x61\x1b\x1c\x56\x6e\xd3\xb6\x0e\xfb\x79\x6e\xee\x8b\xe0\xa2\x05\x92\xc3\x8e\x8c\x61\x5f\x68\x7b\xb3\x73\xeb\xb0\xb5\xce\xb9\xf4\xcc\x14\x1d\xbe\x70\xb6\xd7\xbb\xcd\xb6\x2e\x79\x7e\x64\x95\x1b\x84\x63\x9d\x6d\x79\x54\x4f\x5a\x7c\x76\xb6\x3b\x94\xc8\xc7\x4d\x47\x83\xff\x56\x22\xef\xd2\x61\x2f\x7e\xe5\xb0\x77\x9a\xed\x37\x1e\x76\x16\x3a\x33\x88\x1e\x5f\x38\xec\xd6\x6e\xc3\x66\x01\x33\x5b\x6f\x31\xdb\x3a\x9b\xb0\x0e\x5b\xa2\x98\xb4\xf8\xec\xb0\x89\xd0\xee\x6a\x51\x35\x2b\x37\x08\x7c\x5b\xc9\x6e\xed\xce\xd9\xc9\xf3\x98\xfd\x9b\x21\xd2\x9f\xf4\x04\xc9\xa6\x3f\xd1\xc0\x65\xa7\x2c\xfb\x16\x12\x15\x2d\xbf\xe6\xa7\xf4\x43\xf8\xe8\x13\xa5\xad\x80\xc7\x3e\x90\x69\xb7\x3e\x90\xea\x5c\x01\x67\xbe\x2d\xf0\xa6\x36\xb6\x07\x48\x55\xb6\x96\x08\x09\x95\x0c\xe1\x93\x0f\xe4\xa2\x2e\xe0\xa9\x8f\xe5\xf6\xa7\xeb\x53\x74\x7e\x72\x12\xf4\xe8\x36\x9c\x8b\xaa\x1d\x58\xdc\x6b\x05\x91\x2c\x70\xe6\x36\x9c\xd5\xea\x05\x66\x61\x68\x9e\x8a\x0a\x6b\x1d\x11\x9e\xba\xc7\x72\x82\x5a\x04\xe7\x20\x90\xb7\xdb\x51\xa8\x85\xd3\xc5\x5f\x06\x81\x1e\x67\x36\x02\x95\x4d\xb2\x91\xd6\x33\xd2\xfa\xdf\xdb\x4e\x8f\x87\xb6\x23\xd3\x16\xf0\x99\xe5\x20\x34\x9a\x9d\xba\xf3\x64\xc7\xc8\x62\x9f\x4f\x8f\x95\x67\xea\xbd\x80\x24\xc1\x38\xdc\x55\x61\x0c\xd9\x66\xfc\xcb\x10\x06\x32\x82\x72\xe5\xfc\x67\x60\x49\xeb\x19\x69\xd9\x4d\x5b\x9c\xfc\x63\xd9\x0a\x13\x08\x7e\xed\x20\xc7\x88\xb9\xa9\xf6\xdb\x6a\x93\xce\x03\xfc\xa1\xbf\x34\x3b\x8c\x58\x13\xb1\x95\xd3\xff\xbe\x99\xf6\x17\x3d\x05\x2e\xa0\x8e\x3d\xa2\xf2\xc7\xe6\x29\x0b\x2f\x14\xb7\xb5\xd0\xe2\x14\x3b\xea\x00\x2b\x92\x25\xd4\x29\x89\x7a\x32\xce\x01\x62\x50\x89\xc6\xad\x9f\x7e\x2b\x16\x50\xb9\xeb\x53\x8b\x44\x5d\x27\xf6\x80\x45\x7c\xef\x78\xd5\x77\x43\x76\xa4\x6c\xc6\x06\x4b\x97\xca\xfa\x85\x2b\xef\xc2\x8d\xc8\xf9\x72\xf2\x35\x76\xe2\x6e\x2a\x91\x12\x6d\xc1\x4f\x55\x30\x57\x95\x61\xe3\x38\x3d\xf9\xa4\xce\x61\x7a\xd5\x8e\xe0\x29\x7c\xa0\x5b\x64\x40\xf5\x9d\x09\x6c\xb9\xb6\x98\xbb\x1a\xb7\xfb\xce\x36\x00\x2b\x48\xfe\xcd\xe0\x14\x6a\x9d\xb0\x80\xdf\x43\xb6\x1f\xde\xd0\x2b\xb7\x63\xb8\x80\xf5\xcb\x0b\x8d\x2d\xa5\x54\xd3\x56\x0b\xeb\x32\x74\x12\x90\x48\x3a\x4a\x42\x7e\x4f\xa5\x10\xc8\xd7\x84\x5f\xb9\x79\xd4\x29\x27\x10\x37\x61\x89\x85\x42\xf4\x93\xcf\x86\x80\x84\x1c\x77\x81\xb8\x76\x4b\x65\x35\x81\x2c\x67\x5b\x56\x06\xe1\xd2\xaf\x00\xac\xe8\xd8\x14\x71\x77\xe4\x13\xe3\x49\xf8\x84\x32\x42\x79\x7d\x68\xdc\x05\x69\xdc\x6c\xa6\x1e\xb5\xd4\xbe\xb6\x8a\x43\xa1\xa2\x15\xf4\x86\x5d\x55\xf5\x16\xe7\xd0\x1f\x43\x7e\xfb\xb1\x84\x20\x8b\xc5\xf4\x7c\x6b\x2b\x6d\x99\xdf\x8f\x4c\x5c\x7a\xe3\x7a\x04\xe9\xbf\x27\x4a\x35\x23\x28\x4b\x8c\x61\x9b\x13\x9f\x2e\x69\x4b\x5a\x9c\xe9\x24\xd2\x26\x81\x49\xe0\x63\x18\x08\x7e\x13\xbd\xf0\xb2\x82\x8d\x9b\x4e\xd5\x5a\x29\x07\x03\x6d\xf1\xb2\x44\x8f\xaa\x18\x91\x3c\xc7\x0e\x42\x67\x83\xe5\x0d\x1e\x25\xa8\x53\x75\x59\x8a\xa9\x59\x0b\x1e\xc2\x21\x0a\x78\xf7\xb1\xe2\x17\xb8\x80\x2b\x14\x92\x6d\x01\x19\x10\x1a\xc2\x23\x18\x70\x05\x86\x42\xad\x04\x14\xd9\x05\x2e\x75\x02\xc6\x9e\x73\xe1\x6a\xad\x92\x3d\x3c\x45\xfe\x0c\x0f\xe1\x9d\x6b\x6f\x6b\xe3\x86\x34\xff\x0c\xd9\x5b\x29\xdc\x90\x5f\x1f\x95\x48\x5e\x4f\x63\x50\x40\x31\xa4\x01\xa8\x1c\x1a\x77\x08\x32\x26\x34\xc4\x2b\x1f\x6c\x70\x01\xc9\x34\x80\x31\xe2\x37\x4c\xea\x32\x4f\x68\x68\x05\xb2\x40\xa4\x12\x22\x05\x33\x28\x16\xeb\x0b\xa8\x9a\xbd\xa7\x40\x1e\x9c\xd1\xb5\xb3\x52\x8f\x9a\xec\x54\x72\x6c\xa4\xe6\x5c\xd3\x83\x73\xa0\x64\x15\x4d\x7b\xc1\x79\xba\x5c\x56\x07\x90\x30\xa6\x58\xae\x07\x2b\xb9\xe6\x81\x26\x4d\x04\x0a\x43\xe7\x94\x5e\x10\xf3\x99\xf5\x42\x67\xe9\x0e\xe1\x38\xa8\xcc\x69\x4b\xcc\x59\x19\xb0\xfc\x61\x18\x48\xc3\x6a\x7d\x4e\x5b\x61\xe8\xac\x70\x95\x52\x4e\x29\xa5\x9c\x63\x56\xca\x56\xeb\x3c\x0c\x69\xfe\x5d\x64\xab\xf5\x53\xab\xf0\xa9\xd1\x03\xdb\xd2\x92\x85\x49\x9f\xd7\xee\x06\xde\x1e\x79\xb1\xc6\x4d\xb8\x8a\xa2\xbe\x13\x31\x8e\xdb\x6c\x5d\x1a\xcc\x6b\x87\x15\xca\x91\xc9\x42\x17\x27\x81\x59\x83\x69\x46\xfe\x6a\xee\x25\x94\x63\x5f\xe3\xfe\x37\x17\x90\x5a\x62\x8d\x11\x65\x3f\x73\x4c\xfe\x8d\xe0\xa1\x2b\xda\x8e\xda\x1c\x91\x8c\xd0\x4a\xf5\xd5\x90\x1d\x46\xf6\x3a\xea\xdd\x95\x26\xdb\x94\x57\x90\xba\xe9\xef\xcc\xbd\x85\x0f\x22\x1a\x1a\x2e\xe1\x0c\x85\xaa\xd3\xd8\x12\x70\x7e\x03\x8d\x80\xd2\x0d\x92\xd1\x16\x15\xdc\xa6\x45\x75\x8c\xed\x51\x4d\x4b\xba\x85\x4f\xf2\xbe\xa6\x84\x05\x16\x5c\x89\xfd\xae\x5d\x30\x08\xec\x9b\x86\x5b\x78\x28\x02\xfc\xc7\xd6\x82\x13\x18\xd8\xf7\x27\xb7\xf0\xce\xab\x96\x5c\x0b\x93\xb9\x53\x61\xec\x88\x41\x37\xe4\xdf\x38\xe1\xeb\x98\x12\xcc\x01\xfd\x5d\x31\x33\x3d\x8a\xe1\x89\x7b\x0b\x9f\x3c\x1b\x0f\x2e\x61\xe9\x53\xe3\x24\x15\xae\x15\x7b\x7c\x0d\x31\x1b\x3d\xd6\xec\x84\xcf\x94\x6a\x65\x43\x66\xcd\xb3\xf1\xed\x12\x1e\x78\x21\x29\xa1\x64\x4e\x47\x28\x35\x42\xd5\xd7\xdd\x27\xf8\xfc\x5e\xd1\xad\x53\x57\x2e\x23\xbc\x6d\xf1\xf8\x96\xc5\xe3\x5b\x16\x8f\x0f\xbe\xd0\xfb\xe1\x3c\x16\xd3\xff\x7d\x03\xe9\x96\xec\x10\xd2\x3d\xd9\x81\x4b\xfe\xcd\xe0\x93\x5c\x38\x77\xb0\xcd\x91\x77\x4e\x70\x1d\x8b\x3d\xc4\x19\x6c\x73\x64\x5c\x20\x30\x42\xb1\xb6\xc8\x79\xd5\x53\xd4\x76\xe6\x3a\xa2\x5c\x00\x4a\xd7\x39\x40\x00\xdc\xba\xa4\x14\x98\xf8\xe4\xdf\x12\x9d\xf0\x0f\xcd\x60\x34\x8e\x3e\x72\x5b\xab\x57\x29\x4f\x8a\x7e\xb3\xea\x53\x04\x2a\x96\x34\x4b\x5b\x13\xbe\xc6\xaa\x2e\x3d\x42\x8e\xb1\xcd\x6c\xf2\x9a\x30\x74\x90\x6d\x3b\x93\x8e\x9a\x32\x68\xed\x8d\xa7\x1a\x5b\x8a\x7d\x0b\x9d\x95\x0b\x4a\x68\xeb\x10\x35\x66\x70\xc1\x1a\xc6\x35\x95\x3c\x01\x4f\xb0\x4d\xb8\xff\x39\xb4\x98\x1d\xa5\x6d\x6e\x77\x62\xec\xdc\x3a\x16\x05\xd8\xd8\xc9\x28\xd5\x37\x97\x4f\x2f\xb8\x1a\xd6\x76\x66\x76\x23\xa2\x8e\x5a\x94\xea\x7e\xb7\xd0\xdf\x13\xcf\x39\x46\x63\x78\x22\x24\x71\x67\x04\x8f\x31\xd5\xf5\x62\x71\xdd\xba\x89\x41\x3b\x24\xeb\xbf\x1b\xd4\x0f\xf1\x97\x21\xd9\xae\xac\x91\x14\xe5\x01\x15\xe5\x5a\xf1\x49\x48\x18\xca\x06\xbe\x44\x4b\x7d\x85\xa4\xf0\xe8\xc7\x9c\x44\x90\xee\x0e\xb5\xa3\x76\x41\x12\x0b\x66\xd1\x6f\x6b\x1b\xca\x4c\xe3\xe6\x58\x99\x1a\x88\x59\xaa\x45\x1f\x6d\xe0\xf3\x4a\x48\xa9\x03\x82\x99\x32\x40\x89\x1b\xe7\x21\x32\xe6\xc1\x76\xd1\x5f\xc0\x31\xfc\x20\xbe\x55\xd3\x19\xc1\x52\x7e\xda\x4a\x43\x51\x04\xbe\xd3\x5b\xdb\x91\x88\x98\xad\x59\x96\xd2\xcb\xf5\x82\x71\x9b\xfa\x09\xe4\x7b\xc2\x78\x20\x18\xa1\x60\xcb\x5e\x34\x01\x77\xcc\x92\x74\x83\xf4\x63\x8c\x91\xd2\xfc\x15\x1e\x12\xa0\xe2\xdd\x67\x9e\x55\xfb\xc9\xaa\x42\x54\xa1\xc6\x66\xa6\x37\x51\xdf\x1d\x88\x9b\xca\x75\xaa\xe5\x4a\x08\x2a\x9f\x39\x9b\xdb\x96\xa5\xb1\x57\x35\x16\x28\xae\x36\x60\xd8\x59\xd8\x0e\x18\x7e\x74\xe5\x5a\xa6\x7d\xda\x51\xd3\xbe\x6c\x53\x3b\xdb\x09\xd9\x2e\x3e\xc2\x8b\x74\x04\x9d\x12\xae\xe1\x6d\xf7\x91\x4a\x9c\x35\x0c\xac\x27\x46\x36\x1e\x93\x58\x78\xd1\x8b\x86\xba\x4d\x9b\x19\xc3\xa7\x6b\xa0\x7d\x28\x48\x05\xe5\xc5\x6c\x10\x4b\x04\x36\x88\x0e\xe2\xf8\x63\xd7\x49\x37\xf0\x69\x08\x87\x50\x33\xa5\xd9\x81\x2f\x64\xa0\x72\x72\xa6\x7d\x84\x84\x50\x4c\xd7\x72\xc0\xc1\x3c\x69\x1e\x61\x8c\xe5\xc1\xf0\x1a\x5e\xaa\x59\xb9\xa2\x5a\x61\xd7\xb2\x08\x52\x7e\xd8\x69\x38\x87\xd0\x63\xcf\x19\x3d\x71\xe5\xa7\x77\x21\x3d\xe7\x4c\x6a\xbe\x1c\xfd\x29\xfc\x00\x95\xd2\x2a\x55\x99\xce\x04\xce\x21\xb5\x13\x03\xc7\x90\xfc\xeb\x2f\xa0\x36\x64\xde\xed\x2f\x6d\x32\xbd\x85\x65\xed\xaa\x2b\x83\x3e\x3d\x3a\x60\x6a\xdf\x31\xa3\x85\x2d\x76\x20\xda\xcf\x11\x33\xdc\x3b\x10\x3a\x5f\x34\x85\x0b\x17\x58\xf6\x40\x13\x78\xe0\x86\xce\x1c\x4e\xe1\xbd\x94\x10\x13\xb8\xc4\x21\xd7\x0d\x4f\xe9\xb1\x8a\x41\x6c\x15\x5a\x49\xc5\x29\xf0\x1b\x59\xfe\x71\xdd\x24\xa0\x03\x78\xf3\x6a\x99\xe9\xae\x38\xb3\x8e\x88\x2c\x9b\x43\x79\x02\x1e\xa3\xa9\x1f\x32\x47\xdf\x97\xef\xeb\x5e\xb7\xfb\xd1\x57\x65\xe2\x69\x7e\x1c\x19\x68\x30\x2d\x53\x8a\x9a\x3a\xc8\xeb\x57\x9f\x3a\x4f\x70\x08\xb1\x34\x51\xd8\xc0\x09\x54\x2b\x22\x0d\xb5\x6f\xf2\xfc\xb4\x71\x6d\x59\xc9\x4c\x65\x4f\x2c\xb6\xf0\xa9\x7e\xd8\x95\x55\x07\xc6\x65\x90\x74\x32\xd0\xae\xbe\x66\xea\xfc\x83\x99\xb5\x49\xc4\x9a\xfb\x23\x50\xf9\xb0\xa8\x71\x4c\xac\xad\xec\x3b\x78\xeb\x09\x16\x7d\x55\x40\x65\xd9\xbd\x81\x73\xac\x50\x19\x8b\x93\x5a\xe3\xee\x41\x71\xde\x18\x6c\xbb\x71\xe8\x02\x8b\x02\xa1\x48\xb8\xd0\xdf\xa3\xba\xb8\xe3\x39\xb8\xae\xa8\x33\x82\xfa\x7e\x86\xb0\xb3\x81\x79\xe9\x7a\x64\x03\x91\x76\xb5\x83\x78\x4e\x72\x9f\x3f\x3b\x17\x10\xe4\x89\x39\x17\xfe\xf7\x0f\xb8\x4d\xca\x5e\x30\x7f\xb6\x39\x8c\x75\x8c\xd7\x08\x41\xbb\x8d\x0c\x24\x21\x04\xa0\x6a\xec\xa9\xf6\xf4\x5d\x50\x3d\xbb\x7a\xd6\x16\xf4\x01\xb6\x9d\x03\x08\x5a\x30\x79\x4d\x37\x8e\xe0\x47\xa2\x3c\x9e\xc3\xae\xf6\x05\xa4\x8c\x3d\x7d\x80\x14\x05\x33\x94\xbc\xc6\x7e\xf5\x07\x86\x74\x8f\x3e\x12\x26\x7b\x2c\x1a\x5e\xaa\x4d\xda\x4a\x3d\x6a\xa9\xb9\x36\x6f\x67\xe8\x23\x91\x0b\xa5\xcb\x0b\xc7\xdf\xc7\x3e\x9d\xaf\xa5\x0b\x9c\xd2\x05\x41\x52\x9f\xeb\xab\x8f\x4e\x89\x40\x37\x6e\x9c\xeb\x09\xa6\xed\x15\xf2\x8e\xee\xd7\xcc\x35\xd9\xa8\x8d\xd0\x6b\x49\x6e\x01\xdb\xce\x29\x02\x6b\x98\xd4\xe7\xfa\x09\x52\x14\x1c\x88\xa3\xf9\xbf\x6d\xae\x6f\x11\x3d\x1d\x58\x8a\xfd\xff\x8b\xe6\xfa\x01\xb5\x89\x72\x75\x2a\x0a\xef\xe7\xfa\xbf\x6d\xae\x5b\x3f\x30\xd7\xad\xfd\x5c\xff\x53\xe6\x1a\x9c\x91\x94\xdf\x63\xa2\x5e\x48\x6b\x18\xfc\xd5\xde\x4f\xee\x96\xc9\x8d\x40\xf6\x59\x39\xb8\xf9\x7c\x4f\x95\x83\x4b\xba\x26\xc0\x04\xd1\x7f\x53\xa4\xee\xd6\xe2\x58\xc0\xb4\xa9\xd3\x7a\x5f\xbe\x7f\x69\xd3\xbb\xc7\x63\x7a\x05\x99\x4f\x91\x48\xff\xfe\xd1\x39\x47\x60\x02\x13\x91\x30\x85\x1f\xf9\x49\xff\x31\xff\xa6\x39\x10\x17\xcc\xb2\xb2\x13\xd8\x26\x3d\x2a\x10\x3f\x60\xca\xc1\x10\xd1\x0b\x87\x99\xf4\xc7\x98\x5d\x8b\x63\xa2\x35\x92\x1d\x8f\xc4\x65\x60\x81\xe4\x70\x22\x32\x1c\x32\x80\x39\x1b\xc7\x02\x11\x1c\x30\x57\x53\x31\x9c\x88\x0c\x67\xa9\x86\x33\x87\x64\x3c\xa4\x97\xe7\x88\xfc\xcb\x17\x7c\x3c\x4b\x48\x06\x74\xa0\x0d\x68\xc9\x42\x17\x5c\x88\x63\x76\x39\xae\x53\x6d\x44\x11\x1d\x51\x81\xd4\x88\xe6\x90\x0e\x69\xae\x0f\xa9\xc5\x86\x74\xae\x0d\x69\x0e\xd1\x22\xe1\xb6\x55\x7f\xd7\xee\xaf\xf9\x98\xa8\x84\x0b\x78\x25\xb6\x20\x73\x48\x37\x6d\xfe\x9b\x45\x89\xe2\x07\x11\x95\xcf\x82\x52\x3f\xd6\x5c\x5a\xa1\xa5\xa0\xe2\xb3\xbd\x54\xb7\xdc\xf8\x08\xde\x41\xd2\x95\x16\xdc\x68\xfb\x4a\x8f\xde\xed\xc7\x81\xc0\x4c\x10\x3a\xc7\xee\x02\xde\xa2\xc0\x72\x44\x32\x87\x05\x0a\x9d\x8d\xbb\x80\x53\x28\x6e\x98\x68\x7e\x4b\xe4\xcf\x91\xbe\x19\x54\xe7\x0e\x8a\xf1\x68\xa7\x55\x03\x13\x79\xec\x06\x7b\x01\x8f\x5c\xbe\xcd\xd4\x2d\xd7\x19\x32\xe6\x70\x8e\xed\x4d\x68\x15\xf7\x6a\x15\x5f\x7a\xce\x1a\x2e\xe0\x42\x5d\x6d\x8b\x1f\xd1\xc4\x1c\xce\xbc\x50\xf7\x54\x56\xa8\x54\x1b\x50\x03\xbd\x13\x03\x9a\xc3\x24\x9e\x33\x40\xf7\xbe\xcd\x1a\x1f\x83\x8a\x69\x2c\x3f\x3a\x72\x67\x7e\xe8\x0c\xd0\xd3\x4b\x8a\xac\xfc\xd0\xe9\xa1\xb3\xa6\x22\x75\x47\x9f\xbe\xdb\xa2\xad\x1c\xbe\xa4\x95\x73\x3f\x74\x32\x34\xbe\x6c\x28\xa2\xdb\xbb\x8a\x22\xa3\x4b\x42\x52\xe8\xbd\x6c\x46\x33\xa6\x75\x0f\xa8\xe1\x1f\x1a\x5e\xd6\x33\x23\x77\x74\x49\x50\x8a\xa6\x96\xcc\xc4\x9d\x5f\x12\x72\x46\xf7\xd6\xcc\x35\xcb\x7c\xb2\x66\x1e\x5f\x92\x4d\x38\x3a\xb3\x66\x4e\x02\x32\x59\x27\x97\x58\x32\x2b\x3b\x26\x64\x91\x39\x24\x5b\xf7\x03\x01\xa1\x4c\x70\xe9\xa5\xbb\xb2\x90\x61\xb7\xb1\xcc\x1e\x83\x99\x85\x6e\x14\xc4\x52\xab\xe4\x40\x8b\x60\xe2\x5e\xf8\x6d\xdd\x24\xcc\x38\x8a\x11\x56\x1a\x9e\xd3\x5d\xc0\xb3\x50\x2e\x92\x39\x2c\xa2\xb0\xe6\x41\xff\x22\x1b\xb0\x04\xc4\x9e\x33\x58\xc0\x7b\x69\x74\x31\x81\x6a\xe5\x93\x26\xd6\xf4\xc3\xea\x0b\x78\x22\xcd\x36\x18\x44\x8b\x3f\x47\x07\x90\x99\xe7\x4e\x02\x3d\x8e\xc0\xdb\xba\x6a\xb3\xaf\x8a\x46\x6f\xe1\xd9\xbc\xfb\xb5\xf2\xeb\x04\x05\xf3\x99\xef\xb7\xa0\xb8\x60\xf8\x72\x44\xcd\x38\xb2\x0d\x3f\x57\x8e\x87\x70\x18\x3e\x40\x8a\xb3\xe3\xd0\x7b\xd9\xf9\xde\xcb\x70\x36\xa2\x38\x7b\x0b\x5c\x5c\x51\x9b\x49\x75\x81\xa7\xa8\xf2\x13\xd1\x48\x16\x70\x1c\x63\x8b\xed\xc1\x1c\x96\xb1\x47\x24\xfe\x08\x76\xe5\x81\xf6\x18\x7e\x26\x9a\xc2\x1c\x76\x65\x89\x05\xfc\xec\x9c\xc3\x05\xbc\xbb\xc2\x16\x6b\x83\x39\x9c\x5c\x79\x44\x7b\x38\x85\x5d\x91\x06\xce\xe0\x67\xa2\x5c\x1c\xc0\xae\x2c\x71\x08\x3f\x3b\x73\x97\x9e\x0e\xf1\xc5\x73\x87\x3e\x3a\x4b\xc6\xef\x31\x58\x23\x7e\xa2\xe4\x0f\xe1\x34\xfe\x48\x27\xa0\x6c\xf3\x63\xdc\xb9\x42\xd2\xa8\x86\x2f\x54\xb9\x95\x2f\xd4\x23\xb7\x67\xf5\xe8\x25\x44\x64\xf7\x4f\xe7\x76\x94\xc3\x8f\x6d\x6d\xaa\x0d\x33\x4b\xab\x91\x6f\xf2\x00\x81\x10\xf7\x6b\x78\x59\xff\xc2\xba\x3a\xa0\xe4\x6c\x84\x2e\x55\xcd\x62\xcf\xf5\x88\xfe\x58\xe9\x57\x4d\x63\xaf\xdc\x29\x25\x00\x94\xc8\x09\xc0\xa7\x05\x72\x0a\x66\xba\x22\x2c\xf5\xe9\xfd\xa5\x4b\x63\x6d\x09\x25\x82\x5b\xd2\x2a\x8b\x7d\x3c\x45\x2f\x39\xaf\xc6\x3a\x82\xd9\xe8\x9f\xd4\x90\x37\x30\xa0\xea\xb6\x2f\x88\xee\x09\xce\xa0\xf0\xb5\xd0\xd5\x93\x0d\x7c\x24\x7b\x20\xf4\x04\xd3\x8a\x76\xb2\x16\xd9\x9f\xa9\xee\x38\xd0\xdd\xa4\xb7\x39\x74\xdc\x42\x6a\x4a\x3a\xaf\x5c\xe0\xa8\x8b\x45\xf3\x5a\x56\xbf\xd4\x09\xb8\xd3\x80\x2d\x62\x8a\xba\x3c\x30\xae\xb0\xb7\x05\x77\xb2\x7c\x89\xfe\x03\x7c\x82\x58\xfa\xae\x5e\xc0\x53\xf8\x8c\x7d\xb4\xfa\x06\xf0\xd0\x15\x51\x39\xec\x07\xee\x11\x76\x4a\xf7\x08\xce\x25\x9a\x63\x85\xe6\xb8\x05\x6f\x21\x76\x0a\xf7\x08\x62\xe1\x85\x12\x2b\x34\xc7\x2d\xf8\xbd\x5e\x79\xfc\x46\x95\x1f\xc3\x6f\xa1\xf6\x9d\xf9\x0c\xd4\xaf\x48\x39\xeb\xab\x9b\x83\x19\xf3\xdd\x18\x0a\x20\x3d\x81\x9f\x05\xed\x1d\x43\xaa\xd0\x0e\xe4\xd5\x53\x54\xf3\x96\x60\x5c\x76\x88\xda\xbc\xcc\xa0\x40\x19\xb0\x5b\x9e\x73\x65\x35\xad\x86\xdd\x91\xd3\x72\x42\x5d\x8d\x06\x7c\xa0\x23\x37\x74\x72\xea\x50\xcd\xe7\xef\x16\x95\x10\x4b\x9d\xa3\x44\xdf\x64\x8e\x3b\x71\xdb\x4e\x8e\x1e\x76\x82\x5d\x51\xd8\x93\x9d\x60\x8f\xdd\xb6\xd3\x47\x87\x26\xac\x50\x2e\x2b\xb0\x07\xb4\xde\x29\xde\xa9\xbf\xb8\xed\x0c\xd0\x83\x09\x2b\xd4\x49\x1d\x16\x5d\xb7\x35\x6d\x22\xb2\xb0\x4b\x0e\xf8\x1e\x4a\xe4\x45\x33\x97\xa8\x22\x6b\xf8\xe8\x12\x55\xa4\xa3\x17\xa6\x1e\x31\x03\x15\xbb\x57\x38\x80\x2b\x23\x55\x79\x3a\xf2\x1e\x7e\x13\x89\x17\x10\xe8\x74\x67\x6c\x6c\x6c\xcb\xb3\xff\x01\x5e\x0a\x2a\xba\x80\x49\xe8\xe4\x9a\x27\x57\xc0\xa5\x3d\xa7\xd0\x84\xae\x04\xbf\x66\x33\xa0\xcc\xfd\x15\x0b\xe9\x54\x33\x28\x35\xe5\xd4\x9f\xad\xce\xc0\x14\x10\x06\x5c\x3d\x14\x40\x58\xc4\x01\x8a\xf9\x8c\x10\x86\x8d\x4e\x9e\xaf\x26\x37\x6a\x59\xeb\xb5\x2c\x11\xe9\xcc\x87\x1f\xed\xcc\x06\x91\x8d\xca\xad\xfb\x6c\x35\xa5\x59\x4d\x4b\xab\x06\x7d\xa6\x26\x50\x08\x93\x89\xef\xe8\x76\x20\x18\xa0\x6b\xa2\xdf\x44\x3c\x91\xeb\x36\xde\x35\xd1\xd8\x5e\x04\x5f\xbc\x04\x3e\xb8\xd6\x8c\x21\x76\xd0\xf1\xd2\x2a\x5b\x36\xa4\x45\xcd\x9c\x75\x88\x3e\x09\x82\x2b\x50\x9f\x13\xb9\xd2\x2f\xea\x92\x8e\x3a\xb0\xa1\xbe\x40\xe0\x46\xb3\x91\x99\x69\xcf\x65\xe4\x7e\x7e\xe6\x9a\x33\xf0\x78\x6c\x2d\xa6\x32\x31\x1d\xca\x97\xe4\x9a\xca\x61\x5a\x73\xba\xd6\x1c\xfc\x01\x7a\xda\x92\xdb\x59\x27\x7e\xd6\xa2\x5e\x9c\x9f\xbc\x81\x3a\x8c\xbc\x17\xaa\xed\xaf\xd8\x47\xf8\x96\x6b\xf9\xb4\xb2\xee\x6c\x76\xce\x09\xb8\xf4\x9c\x52\x59\x79\x26\x8f\xe8\x0a\x48\x5f\xda\x35\xea\x3e\xa3\x2b\x7c\x63\xf1\x84\x2c\xb6\x2b\x94\xe3\x94\x36\x1b\xd3\x5f\x15\x95\xcb\x60\x8d\xb8\x2e\x1c\xec\x67\x75\xe0\x93\xe7\x9c\xc3\x29\xba\xb3\x1e\x76\x4d\x10\xe1\x89\xa7\xec\x60\x9f\xe1\x7d\x8a\xee\x11\xb0\x9c\x7b\x5d\x5d\x89\x52\x2b\xb8\x46\x07\x1a\x46\x17\x15\x93\xa2\x16\x7c\xd8\xe6\x63\x16\x81\x33\x48\x8d\xa9\xc1\xcc\x25\xff\x0a\xf4\x01\x09\xf0\x21\x6a\x53\xa7\x87\xd2\xa5\xfa\x38\x3a\x91\x39\x53\x44\x4d\x06\x35\x5b\xc0\x67\xd4\xda\x33\x44\x2f\x0a\x98\x51\x3a\xe9\xb3\x0b\x46\xae\x34\x68\x1a\xbb\x6d\x6a\xb7\xac\x52\x7a\xd4\x98\x09\x07\x1a\x19\xf6\x4d\x82\x0c\x43\xe7\xd8\x05\xa9\xf4\xa2\xfc\xd4\x76\x36\x2e\xc8\xc5\x8d\x03\x3a\xb9\x14\xc6\xa6\x75\x72\x92\x7e\xd3\x95\xb8\x70\xae\xc7\x0d\xd1\xd7\xae\xf4\xa3\x4d\x9e\x50\xe2\x55\xfc\xb8\x44\x6c\xd9\x0d\x0a\x6d\x55\x7f\x0a\xb9\xc3\xd6\x12\x81\xcc\x66\x5e\xac\xb0\x72\x57\xf5\x72\x32\x7b\xc8\xa6\xf7\xd4\xe8\x21\x73\x43\x99\x9b\x3d\xd4\x23\xf1\x89\x10\xba\xcd\x3d\x94\xa1\xf3\x76\xe8\xe1\xef\x8f\xc3\x75\x73\x0f\x37\x9c\xfb\x54\x7b\x38\x12\x44\x58\xed\xa1\x3c\x1c\xd3\x3c\x97\x9a\x7b\x28\x47\xb2\xbd\x87\x68\x01\xdb\xb5\x73\x32\xb5\x33\x53\x25\xd5\x4a\xe2\x42\xf8\x8a\x22\x38\x09\xea\xbb\xee\x4f\xdf\xf9\x0d\x0d\x63\x21\x95\xd8\x13\x8c\x83\xda\x8e\xe4\x6c\x07\x71\x36\xeb\x50\x0e\xc7\xbc\x94\x71\x20\x64\x58\xf5\x9d\x1a\xde\xb1\x73\x44\xae\x51\x56\xdf\x23\x74\xeb\x86\x5a\xd0\xee\xd8\xa2\x53\x34\xee\x93\x78\x9a\x8a\xa2\x5a\xc1\x91\x7f\x82\x32\x7e\x04\x9e\x1d\xa3\xcf\xdb\x37\x3e\xca\xe1\xb4\xab\x9f\xe1\xe3\x2a\x88\xe9\x07\xac\xe4\x66\x84\x16\x50\x0f\x45\x4a\x5d\x5f\x3b\x3f\xe0\xf9\x6a\xb8\x6c\xf3\x4a\x7d\x39\xff\x7f\x91\x59\xbf\x47\xbe\xb8\x1e\xd5\xc4\x57\x0a\x84\x82\x61\x26\xaa\xd8\xc7\x06\x60\xf7\xf9\x34\xb3\x2e\xad\x9a\x25\x2a\x60\x35\x3e\x75\xa6\x1e\xbb\xfc\x71\xca\xe4\xcd\x1c\x6e\x20\xcf\xc9\x25\x64\x2e\x01\x73\x80\x9f\x20\x3f\x45\x52\x6a\x24\x3f\x76\x0a\xf8\x41\x98\x69\x97\xa6\xd1\x65\xe0\x99\x4e\xf1\x7f\xdb\x85\xdb\x4e\xbe\xee\xf9\x03\x1a\x0b\x5f\xf7\x78\x85\x96\xae\x70\xc1\x21\x3d\x2f\x7e\xc4\x55\xba\xa2\x53\x5c\x53\xe3\xbe\x6e\x4f\x54\xfe\xf9\x2f\xf2\xde\xe3\xef\x3e\x88\xfe\xd2\x2c\x43\x7f\x42\x84\x45\x5a\x92\x21\x64\x00\x2a\xc1\x23\x0a\x9e\x58\xe9\x76\x2d\x9e\x7e\xc0\xfd\x01\x8c\x0b\x86\x00\x44\xd5\x78\xbf\xfe\xdb\xb8\x36\xaa\xce\x04\xde\xcf\x45\x4c\xa0\x10\xa3\x56\xa4\xe6\x65\x93\x56\x11\x53\xfb\x9a\xc0\x15\x8b\xd5\xbe\x81\xa2\xe6\x8f\x4f\x90\xf0\xdb\x74\x0d\x85\xef\x55\xf0\x08\xb9\x30\x6e\xdc\xb3\x1b\x9c\x9c\x31\x97\x31\xba\xc5\xd8\xd9\xc0\x11\x5a\x61\x8e\x05\xe5\x4c\xd1\xd1\x90\xd7\xa1\xc1\x58\xfa\x9c\x4d\x8f\xd1\xd0\xfb\x4c\x8b\xcd\xbc\x4a\x06\x3a\x09\x6e\x48\xeb\xb5\xc5\xa8\xf0\x1d\xa3\x4b\xa0\x85\x99\xec\x82\x6a\x08\x9a\xce\x21\x9a\x5f\x9f\x5e\x3a\x25\x3c\x40\x8b\xeb\xb3\x4b\x61\x92\x8b\x6b\x47\x64\x94\x27\xd7\xbc\x6b\x2a\xb9\x46\xa4\x8a\xd8\x90\x03\x46\x3c\x0f\x95\xd6\x01\x16\x07\x37\xf7\x5a\x9e\x19\x62\xf1\x71\x15\x4d\x38\x7f\x26\xf8\xeb\xcb\xd5\xf6\xa5\x47\xed\x0a\xee\x21\x59\x84\x32\xc0\x87\x5a\xdd\xbc\x6b\xb7\x70\x83\x9c\x11\x06\xe0\x3d\x35\x5c\x98\x09\xc7\x32\xb5\xda\x0d\x07\x52\x75\xb8\xae\x98\xb1\xaa\x55\xf0\x82\x27\x38\x82\x54\x0f\x78\xa4\xe1\x04\x2e\x54\x80\x11\xe3\x34\xf2\x10\x1e\x23\x1a\x92\xfb\x10\x09\xe7\xc2\x40\xc2\x44\x66\x6f\xb7\xb5\xaf\x3a\x21\xbc\x8e\x1e\xd0\x04\x52\xbf\xc5\x27\x1a\xd2\xe2\x14\xd9\x91\x10\x80\xf7\xe8\x14\x39\x07\x2e\x00\x43\xea\xb2\x58\xb8\xb1\x06\xb3\x03\x12\xb0\xd6\x09\xcd\xc5\x66\xe1\x96\xcc\x05\xff\x81\x06\x53\x68\xb9\x76\x24\x44\xe0\xc4\x6d\x21\xa7\xc4\x00\x7c\x40\xce\x39\x02\x17\xae\x8e\x84\x78\x47\x24\x18\x9d\x18\xf1\x4e\x88\x88\x2d\x46\xd4\x15\xa3\x7e\xeb\x11\x4a\xf4\x88\x4e\xa4\xf3\xef\x1a\x2d\x31\xf5\x3b\x48\x03\x53\x16\x1a\x32\x82\x7b\x7d\xc8\xab\x14\xfc\xe0\x85\xe6\x9a\x34\xd0\x6b\x53\x41\x94\x56\xa6\xf5\xda\x6d\xff\x33\xd7\x2e\x0a\xed\x6b\xf7\xc5\xa2\xfc\x08\x7d\x11\x92\xbc\x85\xc2\x11\xd4\x16\xf9\x46\x38\xca\xc4\xe0\x09\x1e\xb3\x60\xfe\x77\x74\xe7\x0c\xde\x33\x8f\xdf\x0f\xd4\x1b\xeb\x1c\xc6\x1a\x51\x8b\x23\xb9\x0f\x70\x0d\x29\x2c\x03\x22\x0b\x51\x5d\x55\xf4\xe5\x13\xeb\x70\x01\xc1\x1d\x5a\x41\xda\x04\xab\x7b\xbd\x15\x3e\x02\x47\xa8\xc2\x10\x0a\x57\x06\x07\x19\xba\xe7\x3e\xdd\x39\x8e\x5d\xba\x0f\x3f\x64\x11\xfe\x87\x34\x28\xc5\xac\xb2\x14\xc4\x0d\xe4\xc2\x6d\x41\x0a\xcb\x80\x36\x6e\xac\xc5\x3d\x52\xb3\x35\x11\x7d\x3d\x71\x37\x90\x36\xc1\xea\x3e\xd8\x0a\x1f\x81\x5b\x5c\xe1\x1b\x2b\x2c\x43\x43\x3c\xe0\x0b\x5f\x38\x35\x17\xb2\x7d\x70\x8b\x88\x38\x3c\xc6\x3a\x5e\x85\x8a\x70\x86\x8f\x59\xdb\x0c\xa8\xf0\x62\x31\x9d\x15\x3c\xcd\x44\x5f\xc7\x5e\x0b\xd2\x26\x58\xdd\xcb\xad\xf0\x09\x78\xf4\x5a\x3a\xeb\x3a\xaf\x44\x7c\xb0\x31\x31\xdb\xf6\xae\x0f\xea\x57\xa7\x35\xf5\xe8\xce\xaf\x72\x33\x3f\x10\xe5\x8e\xfc\x53\x9f\x4e\xc7\xd4\xa5\x14\xf1\x41\xba\x99\x5f\x40\x70\xe1\xeb\x33\x28\x6c\x97\x0e\xfd\x0d\xa3\x1e\x06\x34\xb9\x8c\xb5\xad\x98\x9a\x91\x91\xc0\xca\xe2\x72\xcd\x66\x9c\xd5\xbd\xd9\x0a\x1f\x81\x8e\xee\x47\xab\x0e\xd0\x6c\x41\x12\x9a\x0d\xb0\x92\x23\xf4\xfe\x52\xdc\xee\x8c\x34\xf3\x8f\x11\x6c\xa1\xd5\x25\x75\x9b\xe9\xca\x9b\xb0\x20\xd4\x2d\x55\x78\x9b\x89\xf0\x86\x2d\x6d\x41\x82\xe2\x5d\x39\xa8\xba\x93\x31\x18\x7f\xc4\x43\x03\x5b\x72\xd0\x63\xc4\x9d\x0d\x55\x8c\x31\xd3\xdb\x5e\x51\x80\xd8\xea\xd9\x77\x32\xda\x81\x39\xfa\x02\x9c\x0b\xe8\xa6\x94\x15\x05\x41\x7d\x23\xd8\x07\x96\x8d\xa0\x62\xd9\x99\x05\xb0\xfb\x7c\x9a\x59\x97\x56\x4d\x0b\xc9\xa0\x87\x15\x95\xb8\xea\x64\xce\x54\x68\xf4\x79\x85\x9c\xb9\xe7\xe2\x27\xf4\x8f\xec\x3f\x0f\x57\x27\xa1\xd8\x57\x3a\x76\xda\x37\xe8\xd1\x7e\x71\x5d\x14\xa3\x0f\x90\x4e\xec\x04\x89\xf8\x19\x6b\x1a\x77\x88\x75\x7c\xa2\x76\xd5\x2c\x1c\xe3\xa9\x56\xd5\x48\x74\x45\x80\x2c\xb5\xb0\xa4\x3a\xc8\x4a\x81\xac\x21\x7a\x44\x6c\x2e\x4e\xe1\x13\xfa\x7b\x9a\xe4\x8e\x93\x2c\xd9\x82\x03\x6d\x11\xe2\x97\x9e\xe1\xef\xbe\x1b\xeb\x80\x5d\xbf\x76\xd0\xa8\x9e\x31\x15\x7f\xe8\x92\x5d\xbd\x7e\xb8\x2a\x7e\x0b\x77\xed\x36\x1c\x3d\xa9\x13\x26\xbe\x4f\xf0\xc5\x77\x60\xb8\x22\x86\xc5\xdd\x15\x67\x4c\x81\x16\x51\x14\xd7\x9c\x04\x8d\x4d\x9d\xfa\x1a\xd5\x4b\xbc\x02\xb1\x88\x69\xc5\x10\x74\x7a\x65\xa6\x5c\x5c\xa9\xef\x1e\x35\xea\x9e\x91\x45\x9b\x54\x61\x3e\x76\xb6\x8d\xdb\x69\x7a\x32\x49\x25\x19\xa8\x9b\x57\x70\x65\xe1\x0b\xbd\x95\xca\xdf\x3a\xa0\x5b\x3d\xca\x40\x00\x90\xbd\x23\x8a\xf4\x4c\xbb\xe0\x39\xa4\x71\x45\x0b\x66\x73\x6e\x2c\x84\xd8\x82\xc9\xc6\x29\xe7\x72\xe7\x16\xdd\x42\xaa\xb0\xa1\xd8\x0c\x9d\xf9\x9a\xea\x8e\x48\x75\xe7\x90\x7e\x92\x44\xa8\x90\x69\xdd\xa6\x53\x2d\x13\x83\x04\x82\x2a\x09\xd8\x94\x75\x73\x61\xe1\xe1\x15\x93\xd6\x73\xc8\xa0\x26\x10\xa0\x05\x24\xb9\x22\x65\x40\x13\x06\x2a\xa1\x84\x0d\x29\x13\xad\x9e\x25\x4b\xaa\x56\x8d\xdc\x05\x64\xe2\x59\x18\x76\x78\x40\xbf\x87\x1d\xc1\x3b\xb7\x80\xca\x1e\x7b\xe6\x7e\x51\x59\xe0\x2a\x7c\x11\x6c\x5a\x87\x15\x71\x06\x7e\xa8\xde\x5e\x1d\x56\x1c\xc8\xbe\xba\x5e\x14\xd2\xf8\xa8\x13\x28\xef\x03\xa7\x14\xc1\x13\x28\xb8\x0b\x49\x20\xdd\x9f\x40\xa9\x28\x4d\x59\xf8\xdd\x09\x64\xcb\x95\xa5\xe4\x34\xa1\xcf\x12\xe2\x29\x74\xd2\xa1\xfb\x59\xc4\x07\x28\xdc\x2c\x74\xb2\xa1\x7b\x6d\xbb\xeb\x2c\xdc\x34\x74\xf2\xa1\x7b\x69\xb3\x9b\x2b\xdc\x28\x74\x0a\x38\x74\x91\xcd\xe6\xbf\x70\x51\xe8\x0c\x86\x6e\x14\x58\x2c\xf2\x0a\xd7\x13\x9f\xdc\xe4\xba\xa6\xf8\xc6\x18\xd3\x4c\x1f\xe1\x18\x01\xc7\x12\x03\xb3\x62\xce\xb8\x81\x01\x4d\xe4\x30\x39\x40\xf4\x08\x8c\xbf\x92\xd2\x8c\x8e\x79\xc2\x8a\x26\xa4\xf2\xbd\xb0\xbe\x0f\xe4\xfb\x9c\xbe\xab\xfa\x77\xf1\x18\x22\x6a\xa3\x80\x3f\x57\x39\x17\xea\xf1\x5c\x2f\x7a\x86\x36\xc8\x73\x36\xf0\x14\x0d\x5d\xba\xfc\xf4\xa1\x64\xc6\x50\x26\xe6\x50\xfa\x46\xd7\xcd\xf7\x12\x1a\x63\xe9\xbd\x70\x2c\x23\xb8\xfb\x60\x56\xfb\xc1\xfc\xe6\x83\x69\xfd\x3b\x06\x83\xae\x79\x17\x5a\x4a\x87\x60\x56\xdb\x40\xa8\x9b\x3e\x10\x5b\x57\x5f\xf6\xc7\x84\xc6\x12\x1a\x03\x2d\xbc\xb1\xe0\x18\xbb\x81\x63\xce\x70\x26\x42\x97\x90\xa3\x2b\x35\xad\x5b\x73\x59\x1a\xc8\x6a\x06\x12\xf7\xba\x33\x53\xbd\x70\xa9\xe5\xb2\xe7\x5c\xcd\x15\xc3\x5c\xbd\x75\x5d\xe7\x5f\xd6\xaa\x97\xc2\x98\x7d\x42\xc8\xd6\x03\xbd\x82\x8d\x96\xbb\x51\x15\x6c\xa8\xaf\x0a\xc5\xad\x76\xa3\xa8\x06\xd8\xad\x52\xd8\x48\x1b\xc1\x40\x3d\x76\x4d\xc2\x1b\x99\x88\xd3\x76\x2e\x2b\xc8\xb5\x72\x80\xd5\xf9\x9b\xd4\x52\xe7\xaa\x4c\xa1\x65\xce\xb5\x81\x6a\xcd\xaf\xa1\x31\x2b\x5a\xc1\x09\x2d\xb2\xd6\x8a\x94\x5a\x3b\xb5\x31\xc8\x93\x0d\xc4\x6c\x19\x34\x79\x0f\x34\x8f\x2b\x51\x68\x54\xed\xb9\x6c\x69\x6d\x8e\x7c\xae\x01\xb2\xa1\xeb\x28\x62\xe9\x33\x6d\xe8\x39\xd0\x8e\x4c\xe5\xc8\x4b\xad\xcc\x40\x15\x99\x18\x73\xd6\x57\x03\x9f\x41\x73\xc2\x66\x16\xf2\x13\x65\xd8\xb8\x97\x5a\x99\x09\xb4\x36\xa3\x7d\x92\x77\xa2\xcd\x89\x7e\x73\x3d\xd3\x9e\xb5\x6f\x49\x8b\x93\x03\x2c\xca\x2c\xb5\x51\x4f\x34\x6c\x0c\xd4\xb0\x27\x1a\xe0\xc4\x3a\xd7\x13\xad\xe3\xcb\x86\xb5\x36\x50\x23\x5c\x69\x80\x3a\xf1\x8c\x2a\x34\x65\xd4\xb8\xd2\x00\xe7\x15\x9a\x36\x6a\x1c\xd9\x6b\x64\x83\x2e\xb5\x55\x9a\x2b\x3c\xe5\x06\x82\x7b\xa0\xca\x51\xf5\x66\x67\x1a\x96\x7a\x0a\x4b\x45\x6d\xfd\xcf\x54\xe3\x3d\x85\xa5\x89\x06\x57\x27\x09\x3d\xbd\xa7\x30\x56\x67\x2e\x3a\x4d\xf4\x4c\x82\x9b\x34\x10\x82\x9e\xce\xcf\xa3\xde\xa3\x1e\x59\x6a\xe7\x54\x9e\xe5\x2f\x12\x06\x83\x17\x09\x83\xc9\xcb\x84\x41\xf6\x23\xc2\xa0\x3e\x17\x2f\x94\x06\xf3\x1f\x95\x06\xeb\x1f\x95\x06\x83\x1d\xa4\x41\x51\xe3\x2e\x76\x71\xb0\xdc\x51\x1c\xb4\x5e\x23\x0e\xd6\x2f\x17\x07\xc7\xaf\x11\x07\xa7\xaf\x11\x07\xc7\xbb\x8a\x83\xe5\x2b\xc4\xc1\xec\xc5\xe2\x60\xf5\x0a\x71\xb0\x79\x85\x38\x58\xbf\x42\x1c\xac\x77\x15\x07\xcb\x1d\xc5\xc1\x66\x57\x71\xd0\xda\x55\x1c\x6c\x76\x15\x07\xad\x5d\xc5\xc1\xec\xa5\xe2\xa0\xce\x18\x1a\xc4\xc1\x64\x47\x71\xb0\x7c\x8d\x38\xa8\x73\x97\x06\x71\xb0\x7a\x99\x38\x98\xec\xc5\x41\x7d\x39\xee\xc5\xc1\x5e\x1c\xec\xc5\xc1\x5e\x1c\xa8\xc7\xbd\x38\xd8\x8b\x83\xbd\x38\xd8\x8b\x83\xbd\x38\xd8\x8b\x83\xff\x3e\x71\xd0\xda\x8b\x83\xbd\x38\xd8\x8b\x83\xbd\x38\xd8\x8b\x03\x13\xab\xff\x65\xe2\x00\x3d\x21\xcf\xe9\xa3\x4b\x8f\x3b\x12\xb8\x01\x76\x32\xe4\xf2\xd7\x02\xba\x18\x3b\x7d\x84\x44\xf6\x21\x2a\x5d\xec\x6c\xe0\x05\xba\x23\xe2\xa3\x5a\xae\x80\x46\xc1\x5c\x16\x2c\xe0\xaf\x2b\xd9\x7a\x45\x49\x74\xe5\x69\xa1\xa9\x1a\x3d\x20\x6b\x5e\x2a\xbe\xee\x16\xda\x68\xc8\x6d\x2b\xa6\x5c\x09\x59\x78\x25\x20\x8c\x84\x02\x03\x18\xdd\x42\xcf\x49\xd1\x36\x83\xb7\x00\xd4\x3f\x09\x64\xc4\x4a\x51\x5f\x7d\xe4\xdd\xea\x0a\x5b\xa5\x8d\x32\x82\xed\x34\x99\xe3\xa9\xa1\x50\xb8\x44\xd6\x18\xa1\x27\x16\x5f\x8b\x1b\x8a\x0e\x00\xf0\x9e\x79\xed\xc8\xd7\x5c\xe6\x76\xaa\xc0\x8d\xaf\x1d\xf9\x9a\x83\xa0\x4d\x86\xdc\x95\xe2\xf2\x33\x7b\x65\x4b\x19\x61\x8f\x74\x10\x8b\x9e\x33\x6b\x30\x5e\x5f\xaf\xfa\x9a\x55\x5f\x07\xd5\xd7\xbe\xf6\x8a\xb0\x66\x93\xcf\x33\x30\xcf\xe8\xc9\x0c\x5e\xc1\x5f\x7a\x0f\x3a\x6a\x6d\xab\x2e\x68\xef\x99\xf1\x3e\x30\xde\xfb\xfa\x3b\xd2\xe0\x95\x28\xa9\x74\x84\x65\x89\x5a\x2a\x5d\xe1\x14\x5f\xed\x4a\x61\x74\xa5\x30\xba\x52\x18\x5d\x29\x8c\xae\x14\xaa\x2b\x85\xd1\x95\x42\x75\xa5\x30\xba\x12\x49\xb6\xab\x7a\x92\x57\x3b\x92\x57\xfb\x91\x57\xbb\x91\x57\x7b\x91\xcb\x4e\xe4\xd5\x3e\xe4\xb2\x0b\xf9\x6f\x3b\x2f\xbf\x14\x19\x89\x65\x99\xf4\xb7\xae\x8b\xbc\x79\x11\x21\x05\x2c\x9d\x58\x44\x0f\xfa\x32\x23\xaf\x2e\x93\xc4\x36\x1d\xfd\x67\xd0\x9f\x6f\x9b\x2e\xa4\xc1\x03\x99\x55\xe9\x08\xcb\xca\x8d\xe9\x48\x6c\xcb\xa4\xff\xcc\xb2\xc8\xb7\x2d\x23\xa4\xc1\x03\x99\x55\xe9\x4a\xa1\xba\x52\x18\x5d\x89\x9a\x27\xbb\x4e\x0a\x79\x33\xdd\x20\x05\x2c\x83\x1f\x54\xfa\x90\xcb\x2e\xe4\xbf\xed\xbc\xfc\x12\x64\xc4\x6d\x66\x09\xdb\x91\x15\xa4\xd5\x35\x9a\x56\xab\x4f\xab\x7d\x49\xab\x3d\x4d\x9b\xd6\x68\x6a\x5b\xa3\x77\x6e\x09\x89\x6a\x3c\x73\xdf\x33\xcf\xe5\x9a\x50\x4b\xab\x42\x2d\xad\xae\xc7\xb4\xba\x78\xd3\xea\xd2\x4e\x9b\x84\x5a\xda\x24\xd4\x12\x1b\xf3\x4c\x0d\xe6\x99\x1a\xb3\x9e\x1a\x54\x92\x1a\x54\x94\x36\x33\xcf\xb4\x99\x79\x26\x36\xa1\x96\x1a\x42\x2d\x35\x56\x63\x6a\xac\xde\xd4\x58\xdd\x69\xb3\x50\x4b\x9b\x85\x5a\x62\xe1\xe3\x7f\x1f\x8d\xfc\xb6\xf3\xf2\x4b\x91\x91\x58\x96\x49\x7f\xeb\xba\xc8\x9b\x17\x51\x83\x50\x4b\x9b\x84\x5a\x62\x63\x9e\x75\xf4\x5a\xd0\x9f\x6f\x9b\xae\x46\xe6\x99\x36\x33\xcf\xc4\x26\xd4\xea\x64\x6f\x59\x16\xf9\xb6\x65\xd4\x28\xd4\xd2\x66\xa1\x96\x58\xf8\x78\x6d\xb2\xeb\xa4\x90\x37\xd3\x4d\x03\x1f\x4f\x9b\x84\xda\x6f\x39\x2f\xbf\x04\x19\x71\x9b\xd9\x2f\x2b\xa1\xd6\xaf\xae\xd1\x7e\xb5\xfa\x7e\xb5\x2f\xfd\x6a\x4f\xfb\x4d\x6b\xb4\x6f\x59\xa3\x05\xdc\x4b\xb5\xbd\x54\xdb\x4b\xb5\xbd\x54\xdb\x4b\xb5\xbd\x54\xdb\x4b\xb5\xbd\x54\xdb\x4b\xb5\x5f\x3e\x2f\x7b\xa9\xf6\x5b\x71\xcf\xbd\x54\xfb\x3d\xe7\xe5\xbf\x55\xaa\xb5\xf6\x52\x6d\x2f\xd5\xf6\x52\x6d\x2f\xd5\xf6\x52\x6d\x2f\xd5\xfe\x05\x52\x0d\xdd\xa2\x36\x79\x2e\xa1\x8c\xf3\x87\x6e\x69\x2c\xa1\x12\x2a\x74\xdd\x42\x27\x47\xa1\x6e\x1f\x43\x8b\xab\x0f\xdb\x76\xdc\x2e\x66\xa3\xe8\x59\x46\xc1\x28\x35\xd3\x78\xe0\xc2\x5d\x52\x4b\xb7\xb9\xfb\xc8\x2a\xd3\x0b\xe6\x46\x41\x66\x00\xca\xbb\xf7\xeb\x4a\xb6\x5e\x51\x92\x4c\x2e\x0f\xcf\x24\x0c\xef\xb4\x88\x4d\x7a\x52\xa9\x25\xcd\x21\x08\xa6\x90\x1a\xb1\x2d\xf9\x2c\x04\x00\xdd\xb3\xb0\xfd\xd5\x94\x8c\x26\xf0\x68\x78\xc1\x3d\x64\xd3\xcc\x0c\x8b\xf0\x98\x4e\x8f\x78\x1f\xc1\x5b\xac\x47\x9a\x2a\xf1\x17\x99\x03\xae\xf8\x37\xa1\x2a\x90\x73\x6e\x00\xf8\x7a\xc8\x5e\x0d\x52\x98\x6b\xbe\xbe\xce\xac\x06\x29\x62\x39\x9a\x90\x05\xac\x81\x8a\x90\x87\x3a\xa8\x37\x72\xdb\x4e\xcf\x7f\x74\xb1\x19\x60\x4e\x19\xbe\x29\xad\x4c\x0b\x8f\xa7\x82\x12\x63\xe4\x79\x4e\x0f\xb9\x92\xc0\xdd\x84\x10\x0a\xe6\x11\x51\xf3\x27\x77\xed\x12\xda\xdb\xb8\x0b\x97\x92\x88\xc8\x29\xe0\x13\x27\xcb\x8d\xfb\x9e\x5a\x9b\xeb\x39\x7f\x6f\xa1\x56\x73\xa1\x96\xa5\x10\xf0\x43\x1d\x34\x07\xdd\x36\x0f\x4b\xc8\xdf\x69\x44\xc0\x4b\x46\xce\x2a\xbc\x90\x2f\xbe\xa5\x63\x40\x2d\x15\xd4\x88\x42\x9d\xda\xa0\x4e\x15\xd4\x1a\x82\x88\x70\x15\x97\x62\x9a\x25\xbe\xfb\xff\xff\x1b\x00\x00\xff\xff\xb4\x36\xa3\x31\xcc\x09\x01\x00") + +func uiAppLibBootstrap400Alpha6DistCssBootstrapMinCssMapBytes() ([]byte, error) { + return bindataRead( + _uiAppLibBootstrap400Alpha6DistCssBootstrapMinCssMap, + "ui/app/lib/bootstrap-4.0.0-alpha.6-dist/css/bootstrap.min.css.map", + ) +} + +func uiAppLibBootstrap400Alpha6DistCssBootstrapMinCssMap() (*asset, error) { + bytes, err := uiAppLibBootstrap400Alpha6DistCssBootstrapMinCssMapBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "ui/app/lib/bootstrap-4.0.0-alpha.6-dist/css/bootstrap.min.css.map", size: 68044, mode: os.FileMode(420), modTime: time.Unix(1, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _uiAppLibFontAwesome470CssFontAwesomeCss = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xd4\x7d\x51\x8f\xeb\xb8\xb1\xe6\xfb\xf9\x15\xda\x19\x64\xe7\xcc\xa0\xd5\xa7\x25\xbb\x6d\x77\x5f\xdc\xbd\x99\xdd\x20\xd8\x00\xc9\x26\x40\x26\xc0\x3e\xec\x0b\x45\x95\x2c\x1e\x53\xa2\x86\xa4\xdc\xed\xb3\x98\xff\xbe\x90\x64\x5b\x9f\x64\xb3\xd4\x0b\xcc\xcb\x6d\x04\x39\x63\xe9\x63\x89\x14\x8b\xc5\xaa\xe2\x47\xea\xcb\x4f\xff\xe5\x53\xf4\x53\x14\xfd\xd9\xd4\x3e\xfa\xf9\x8d\x9c\xa9\x28\x5a\x3f\x6e\x1f\x9f\xa2\xec\x14\xfd\x31\x17\x47\xda\x8b\x3a\x3f\x45\x71\x54\x7a\xdf\xbc\x7e\xf9\x52\x98\xda\x8b\x01\xf8\xa8\x4c\x14\x47\x7f\x84\x2b\xbd\xac\xbf\x2a\x49\xb5\xa3\x50\x91\x2f\xfa\x7c\xff\x73\xf7\xd0\xd7\xe8\x9f\x7f\xf9\x6b\xf4\xf7\x3f\xff\x35\x4a\x1e\x93\x87\xe8\x7f\xfc\xf3\x9f\xaf\xd1\xdf\xfe\xf2\xcb\x45\xc8\x8f\x9f\xa2\x9f\xbe\x7c\xfa\xf2\x53\xf4\xe7\xbf\xff\xaf\x5f\xa2\x7f\xfc\xfc\xcb\xff\xec\x1e\x11\x07\xff\x3a\x74\x5f\xa1\xb8\x10\x92\xa2\xff\xfb\x29\x8a\xce\xbf\x2a\xa5\x4f\xaf\xd1\x0f\xdd\x33\xcf\xed\xfc\xe1\xdf\x3e\x45\x91\xb3\xf2\x35\x6a\xad\xfe\xfc\xc3\xe3\x63\x5f\x51\x87\xd5\x8d\xdf\x28\xeb\x7e\x3e\x92\xf1\xff\x71\xfc\xf7\xfe\xc5\xfc\xf0\xe3\xff\x67\xb9\xef\x15\x15\xea\xfd\xbf\x5e\x8b\x47\x85\xb1\x95\xf0\x9f\x7f\xa0\x2a\xa3\x3c\xa7\x3c\x36\x0d\xd5\xfe\xd4\xd0\x0f\x3f\x3e\x7c\x40\xe6\x9b\x29\x8a\xf4\x3f\x6e\xc5\xf5\xd7\x3f\x2e\x22\x20\xe1\x63\x02\xbc\xbf\x57\xde\xdb\x96\x3e\xde\x0e\x77\xdc\x5f\x64\x7c\x0f\xf7\x2d\xed\x5b\x2d\x2c\x88\x75\xc7\xfd\xf0\xd2\xfb\xae\x7c\x23\xb5\x2f\xfd\x6b\x54\x77\x77\xf5\xf5\xb2\xf3\x27\x4d\xe3\xd5\xdf\x3e\x3d\x16\xa2\xef\xff\x5c\xb9\x46\x8b\xd3\x6b\xa4\x6a\xad\x6a\x8a\x33\x6d\xe4\xe1\x52\xec\x52\x60\xf6\x4f\xb2\x6e\xde\xbf\x24\x11\x28\xcb\xf8\x1c\xf5\x8d\x3a\x59\x25\x59\xe5\xbb\xab\x9e\xde\x7d\x6c\xa9\xce\xc9\xaa\x7a\xff\x1a\x89\xd6\x9b\xee\x7a\xd7\xce\x83\xf2\xf1\x50\xaa\x32\xc6\x97\xc3\xfd\xda\x2b\xa1\x95\x70\x94\xf7\xb0\xca\x7c\x8b\x8d\x7b\xbf\xc1\xed\xad\x38\x39\x29\x34\x75\x8d\xf9\xf2\x53\x54\x89\x03\xb9\xc8\x97\xd4\xd7\x23\x5a\xad\xfe\x10\x69\x61\xf7\x64\x23\x4b\x5a\x78\x75\xa4\xc8\x9b\xfe\xbe\x92\xa6\x8e\x64\xf7\x46\x55\x4d\xb6\x1b\x12\x8f\x85\x88\xf5\x7e\x1c\x0e\x43\x23\x92\xc7\xd5\xf9\x8f\xaa\xae\x2a\xfd\xeb\x29\xcf\xaf\xf7\xe9\x71\xfb\x3c\x5c\x3e\x92\xf5\x4a\x0a\x1d\x0b\xad\xf6\xf5\x6b\x14\x27\xcf\x7f\x38\xbf\xe0\x38\x7d\x9f\x0b\x4d\xbb\x42\xc3\xcd\xd5\xcd\xcd\xd5\x78\x73\x7d\x73\x73\x3d\xde\x7c\xbe\xb9\xf9\x3c\xde\x2c\xde\xfa\x9b\x6f\x2a\xf7\x65\xd7\x88\x74\xf7\xbc\x4d\xd6\xe9\xcb\x50\xdb\xbe\x3b\xce\x35\x95\x54\x7b\xb2\x97\x72\xad\xee\xcb\x35\x22\xcf\x55\xbd\x8f\x35\x15\x5d\x33\xbb\x32\x95\xb0\x7b\x55\x9f\xaf\xa4\x8f\xc9\x7a\x10\x79\x79\x2b\xee\xac\x5d\x71\xa7\xdb\x9d\xc6\xd4\x04\x32\xff\x5b\xa4\xd5\x20\xd8\x38\xe5\x95\xa9\x5f\xaf\x1d\x72\x41\xdd\x00\x44\xe6\x8c\x6e\x7d\xaf\x55\xc3\x53\xe3\xf9\x63\xcf\xcd\x9b\x5f\xf6\xa6\xe9\xfa\x66\x76\x31\xd8\x66\xad\xa0\xeb\xcf\x4f\x4a\x1e\x87\x17\xb6\xdb\x8c\xef\x34\x33\x36\x27\x8b\xef\xe7\x35\x7a\x4c\xa9\x8a\x1e\xd3\xe7\xee\xff\x93\xb3\x2e\x0c\xb8\xd7\xc8\x19\xad\xf2\xe8\xe9\xf1\x69\x47\x55\xf4\x3d\xf5\x7f\xe3\xfd\xd8\x8a\x5c\xb5\xee\x35\x7a\x4c\xc6\x47\x34\xad\xd6\xfd\x2b\x1e\xba\x56\x1b\xe1\x5f\xfb\x2a\x4d\x00\xb6\xd3\x3e\x44\xf4\x17\xce\x90\x5b\x31\xe7\x9e\xb3\x83\xce\x3e\x8e\xfa\x75\x47\xe0\xa4\x97\x2f\xd0\x2f\x3f\x45\x7f\xa2\xc6\x92\x14\x9e\xf2\x48\xb8\xc8\x14\xd1\xfa\x71\xfd\xf8\xd4\x0f\x9b\xa5\x2a\x2d\xb5\xe9\xf1\xa3\xb5\xfd\x48\x55\xbb\x26\xb9\x46\xd5\x3d\xe2\x62\x5d\x44\xad\x2a\x31\x28\xd5\xe5\x76\xea\x22\x55\x17\xaa\x56\x9e\xfa\x21\x2d\x6c\xd7\x33\x1f\x04\x5e\xbb\xc2\xd1\xd2\x73\x12\x28\xee\x3c\x35\xee\xf3\xee\xc7\xc0\x93\xee\x43\x7f\xfb\xf4\xc7\x8b\xf8\x03\x9d\x0a\x2b\x2a\x72\x11\x36\xf2\xe9\x0f\xfd\x3f\x63\x2d\xbc\x15\xb5\xeb\xa6\x85\xd7\xc8\x1a\x2f\x3c\x7d\x7e\xca\x69\xdf\x3f\x35\x8a\x98\x9b\xbf\x7d\x8a\xa2\xe4\xe9\x03\xe2\x56\xcf\x2f\x9c\x40\xb8\xfd\x5b\x57\xfd\xff\x9c\xd5\xee\x7a\x78\xb8\x13\xbf\x3c\x0d\xbd\x5c\xb9\xb8\x50\xda\x77\x43\xfb\xbb\xc6\x9a\xbd\xca\x5f\xff\xf4\xbf\xff\x52\x89\x3d\xfd\x72\x91\xf6\xf8\x37\x25\xad\x71\xa6\xf0\x8f\xff\x5d\x38\x25\xfb\xbb\x9f\x7b\x39\xca\xd4\xff\x9e\xfc\xf8\x1d\xce\x7a\xb7\x95\x78\xb9\x36\xab\x7b\x1a\x77\x3f\x7c\x6f\x52\xf7\x64\xf7\xbb\x55\x3e\x5d\xaa\x7c\xb2\x5b\xa8\x3d\x00\x98\x9b\x93\xfa\xa7\xdb\xdf\xad\xfe\xab\xa5\xfa\xa7\xdb\x85\xfa\x03\x80\xb9\x79\x9e\x80\xb5\x6a\xe2\xd2\x58\xf5\xad\xf3\x31\xf4\xef\xd5\x88\xa7\x87\xa8\x52\xd6\x1a\xcb\xe8\x52\xef\x10\x7d\x8e\x93\x87\x28\xb9\xd7\x98\xf9\xed\xe0\x2d\x68\xc8\xc5\xbd\xf9\xdd\x74\xe9\xc3\xcd\x48\x1e\xa2\x98\x69\xc6\x78\x3b\x78\xeb\xb7\x4f\xaf\xd6\x18\x1f\x4d\x46\xf4\xc3\xed\xc5\x64\x77\xef\x6a\xba\x9d\x5c\x9d\x75\xeb\xcd\xad\xc9\x8b\xba\xbc\x24\x74\x86\x9c\x17\xf2\x10\x74\x85\x18\x4f\xfc\xe2\xeb\x0c\x3e\xc6\xc5\x03\x4d\xef\x78\xa5\xe9\x7d\x97\xb4\x52\x79\xae\xa7\xf5\x88\x93\xf7\x07\xf8\x75\x76\x54\x39\x17\xec\x09\xaa\xd2\x59\x5d\xde\xb3\xba\x3c\x64\xf0\xac\xb0\x8e\xd7\xd8\xe0\xb7\xdb\xe7\xdf\x77\x94\x55\x7d\x24\x7b\x9e\x70\xa5\xd1\xc6\xbe\x46\xdf\x17\xfd\xdf\xd9\x45\x99\x84\xe7\xad\x3b\xc7\x01\xff\xaa\x95\x34\x39\x45\xff\xb0\xea\x28\x3c\x45\xff\x72\x14\xfd\x6c\x49\x44\x9f\xff\xf1\xaf\x9f\x7f\xec\xa2\x01\xaa\x5d\x6b\x29\x72\xd2\x12\xd5\xdd\xe4\x60\x49\xe4\x64\x5d\x94\x9b\xa8\x36\xbe\xff\x19\x99\xa2\x88\xac\xa8\x73\x53\x45\xb2\x14\x56\x48\xdf\x21\x7c\x29\xba\xfb\x8d\x25\x47\xb5\xef\x63\x0a\x77\x09\x25\xf6\x5a\x38\xf7\x9a\x51\x61\xec\xa5\xd2\xb5\xa7\x2e\x9a\xfa\xee\xff\x14\x4f\x4f\x4f\xdf\x5d\x1a\x56\xb5\x4e\xc9\x30\x30\xb9\x02\x1d\x09\x2b\xcb\x30\x32\xbd\x22\xa9\x3e\x92\x36\x0d\xc5\x26\x8c\x5e\x5d\xd1\x25\x09\xeb\xc3\xc0\xf5\x77\xd0\x4b\x36\x8c\x7b\x9e\xe0\xb8\x47\x6f\xae\xc8\xd6\x11\x23\x71\x7b\xc5\x15\x4a\x57\x61\xdc\xee\x8a\xf3\x65\xdc\xc7\x7b\x61\xec\x0b\x60\xc3\x28\x31\x91\xa8\x1c\xf3\x7a\xb2\x2b\x54\x96\x24\x0f\x61\xa0\xbc\x02\x2d\x55\xe6\x78\xa9\xe3\x30\x00\xa5\x36\x6e\x7a\xc5\xab\x8a\x18\xfd\xc9\x67\x6a\x11\x37\xba\x65\xe0\x34\x87\x57\xaa\x66\xf0\xc9\xa8\x9e\x8d\x79\x23\x1b\x9b\xa2\x08\x83\x41\x45\xd5\xbe\x16\x3a\x8c\x1c\x55\x74\x4f\x57\x5d\x3a\xbf\x01\xb3\x0f\x97\x1b\x95\xd5\x5b\xe1\x4a\x46\xb9\x92\x51\x5d\x4b\x53\x85\x15\x21\x79\x46\xe5\xe2\x46\x4a\x32\xaa\xab\xec\x8c\x31\x07\x1d\x35\xd6\x1a\x91\x87\x71\xa3\xc6\xe6\xe6\xad\xd6\x2c\x76\xd4\x58\x61\xad\x79\x8b\xa5\xb2\xb2\xab\x70\x5f\x34\x5c\x4c\x84\x8a\xb5\x4d\xb8\xd0\xa8\xcc\xaa\xce\xcc\x7b\x18\x38\x2a\x73\x37\x5b\x5d\x85\x87\x0b\xe4\xdf\xcd\x3c\xbb\x21\xc0\x43\x0d\xb0\xd4\x90\x08\x8f\xb4\x84\x60\x00\x15\x96\x5c\x78\xfc\xa6\xa3\x46\xf6\x99\x09\xa1\xc3\x62\xd3\x51\x27\xbb\xde\x0d\xe3\x46\x1d\x2c\xb4\x08\xeb\x6a\xba\x46\xc3\x9a\x37\xa5\xa9\x99\x71\x9c\x8e\x6a\x78\x34\xba\xad\x88\x1d\x69\xe9\x66\x8e\x66\x75\x20\xdd\xce\xe1\x4c\xdf\xa7\xa3\x4e\xfe\x6a\xbb\x29\x33\x8c\x1c\x35\x32\x13\x0b\x50\x30\xa4\xdc\x3b\xcb\x10\xc6\xbc\xad\x51\xed\x32\x63\x98\xbe\xca\x27\xb8\x4a\x58\x06\x3b\xaa\x55\x63\x55\xcd\x28\x4a\x31\xda\x01\x51\x91\x15\x41\xe4\x6a\xb4\x9e\x7d\xfe\x34\x88\x4b\xa0\x9a\x3a\x6c\x02\x56\xa3\x8a\x2a\x2f\x34\xe3\x2d\xac\xc0\x50\x76\x5e\xd9\xd9\xdd\x0a\xc2\xd7\x53\xf8\xe0\xd8\x05\xd1\xa3\xae\xf6\xde\xde\x90\x7a\x09\xa2\x37\x33\xf4\xe0\x1a\x86\xf1\xdb\x19\xde\xf2\x55\xdf\xcd\xe0\x5f\x5b\xe7\x55\x71\x0a\x17\x78\x99\xd8\x84\x30\x6e\x54\xd9\x9c\x72\xaa\xa7\x36\xca\xb4\x1e\xae\xdd\x29\x8d\x16\x94\x47\x8e\xba\x7c\x54\x39\x99\x45\xa5\x1a\x75\xba\x29\x8d\x37\x93\x6a\xa9\x2e\xbc\x9a\x5c\x69\x94\xf4\xad\xe5\x4c\xf2\x0a\x14\x9f\x6a\xa9\xc2\xd3\xf6\x1a\x9c\x55\xd1\xc4\xdd\x70\x62\x3a\x72\x3d\x6a\xb5\xc8\xbb\x5e\x09\x23\x47\xbd\xf6\xdc\xc8\x5b\x8f\x5a\x4d\xb9\x9a\x76\xc8\x50\xf5\xd8\xfd\xda\x0a\xb6\xb5\x6b\x70\x63\xcb\x0e\xba\x5c\xe2\x79\xea\xd9\x7d\xa0\xc4\x66\x3a\xe7\x86\x0d\xd9\x7a\x0b\xce\x32\x35\x71\x26\xe4\xe1\x4d\xd8\xb0\x09\x58\x8f\xea\x5e\x08\xe7\x3f\x50\x00\x8d\xf4\x12\x56\x4c\x66\xf3\x30\x6e\x54\xee\x46\xb4\x2e\x6c\xf6\xd7\x12\x9a\x67\xc2\x73\xce\x3a\x07\x43\x69\xf9\x3a\xd2\xf4\x05\x2c\xe1\x9f\x9f\xa6\x6f\x78\x11\x3f\x6a\x2d\x7d\x25\x19\x56\xc6\xe7\x14\xd5\xe2\x68\xcd\x82\x1d\x7c\x5e\xdd\xe0\x79\xcb\xf6\xbc\x86\xde\x68\xdd\xd9\xb7\x0a\xc3\x47\x35\xed\x7d\xfa\x45\xfc\x06\x06\x5d\x45\xcb\xf8\xed\x6c\x18\x2c\xe1\xc1\x8f\x68\xc9\x79\x65\xea\xc5\x22\x2f\x60\x34\x0b\xb3\x08\x1f\xd5\x55\x5a\xe3\x5c\x29\x94\x0d\x0f\xb5\xe7\xec\x6e\x7b\x99\x61\xfc\x2c\xef\xb6\x98\x2b\x01\xfe\x86\x08\xfb\x63\xcf\x34\xf3\xc9\x59\xc5\xd9\x3c\xcd\xd0\xbc\xda\x6c\x92\x19\x9c\xf1\xf5\x36\xe9\x0c\xcb\xba\x91\x9b\x15\x98\x7f\xa5\x67\x43\xe9\x61\xb4\xa9\x61\x09\xa3\x4a\xd3\x7b\x23\xea\xf0\x30\xdc\x80\xd1\x35\x55\x63\x89\xc9\xa1\x6c\x36\x93\x81\x12\xc6\x6d\xa7\x23\x24\x0c\x04\x9f\xc2\x79\xb2\xca\x85\xdd\xc6\xcd\x0b\x34\x49\x6a\x31\xac\xe6\x2c\xa9\xee\x66\x54\xdd\xbd\xe2\xfa\x7e\x54\x5a\x4d\x22\x1c\x10\x6c\x24\x44\xb1\x5c\x07\x8c\x0a\x4a\x27\x06\x46\x08\x8b\x9d\x16\x4c\x90\xb5\x1d\xf5\xf3\x4d\xd8\x5a\xd5\xfb\x89\x46\xe0\x5b\xf1\x56\x89\x7a\xcf\xbc\x97\x6d\x82\x33\x50\xcd\x00\xc1\xfa\x0a\x4d\x75\xce\x64\xa4\xb6\xa3\xde\x0e\xa9\xbb\x30\x72\x8d\x5a\x57\x71\x6e\xdb\x16\xcc\xad\xd8\xd7\xc4\x20\x37\x37\x86\x9f\x19\x92\xdb\xed\x0d\x9a\x1d\x94\xdb\x1d\x44\xc3\xfe\x8d\xb8\x8a\xbc\x80\xeb\x63\x9a\x46\xd5\xfb\x58\x72\x29\xbf\xad\x80\x69\x59\xe7\x8c\xaf\xb7\xcd\x66\xc8\x9e\xa6\x13\x86\xcb\x99\x83\x14\x1f\xc3\xd8\x7c\x8e\x65\x54\x91\x30\x22\x8d\x65\x29\xac\x8f\xa7\x1e\xf2\xf5\x7a\x50\xc8\x6e\xd4\x67\xff\xa6\xbc\x27\x7b\xf6\xf8\xc2\x25\x12\xf0\x49\x24\x75\xa1\xe6\x62\x91\x74\x16\x44\x76\xbd\x67\xc3\x33\xcb\x6e\xd4\xe1\x03\x85\x3d\xb3\xdd\x7a\x92\x58\x73\xf3\xcc\x5a\xd8\xe6\xed\x9e\xe7\xaa\xcf\x60\xc1\x75\x28\xdb\x2a\x73\x7c\x36\x69\xb7\xbd\x85\xb3\x3a\xbd\xdb\x4d\x53\xc8\xa5\xd0\x61\xd3\xb7\x7b\x99\x26\xb0\x99\xe9\x79\x27\x26\x09\xca\x2e\x88\x0b\x63\xc1\xf2\xaa\xfa\x40\xb9\xaa\x17\xfb\x54\x4e\xdb\x19\x7b\xc1\xe4\x91\x76\x60\x8a\xdf\x3d\xd9\x5a\xe8\xfe\x49\xe1\x02\x34\xad\xbd\x0a\xbf\xc0\x17\x50\x61\x6b\x9a\x32\xac\x30\x2f\x09\x4c\x44\xbe\x6c\xb3\xa5\x46\xbe\x8c\x8a\xdb\x36\x6c\xc2\xf2\x65\x05\x73\x57\x65\x6a\xa6\x63\x5e\xd6\x18\xd3\x32\x66\xff\x05\x16\x17\x96\xa2\xb0\x97\xcd\x4d\xf2\x87\x43\x6f\xa7\x55\x58\x7c\x0f\xbb\xb9\x95\x08\x43\x5f\x6e\xcd\x43\x31\x19\x99\x97\xcb\x61\x11\x62\xd6\x4d\x61\xe4\xa8\xb7\x6d\xcd\x26\x32\x5f\xc0\xbd\xb5\x5d\x3c\xdd\x4d\x06\x4c\x77\x42\x8c\x46\x34\xf5\xfa\x2c\xe3\x9d\xbd\x8c\x6a\x5b\xe6\x39\xd3\x03\x62\x54\xda\xac\xd5\xba\x34\x36\xac\xe0\x02\x32\x66\xa4\xc3\x19\x8b\x02\x82\x2e\xb2\x5e\x15\x4a\x0a\x1f\xee\x54\x01\x8b\x61\xa2\xce\x63\xb3\xe0\x6b\x8b\xf5\x1c\xcf\x7a\xf2\xe2\x79\x0e\x67\xac\xa6\xd8\xcc\xc1\xac\xcd\x14\xdb\x99\x2b\x7f\x0e\x56\xf8\x0a\xed\xee\x17\x5a\x68\x75\x60\x25\x82\x6b\x4c\x60\x15\x82\x6f\xd2\xa8\xca\x7b\x6d\x32\xa6\xdb\x46\x4d\x7e\xb3\x54\x33\x6b\xa3\x22\x87\x04\xb3\x3b\x84\xb5\x56\x40\x9a\x61\x58\xbd\x0f\x21\x33\x50\x5b\xab\xa8\x90\x82\x49\x88\x64\xc9\xdc\x99\xe1\x96\x24\x32\x58\x26\xb3\xe6\xfa\x7a\x87\x31\xd7\x3a\x62\xa2\x5d\xf9\x04\x6e\xa4\xb8\x4e\x15\x0f\xd7\x09\x2d\x5c\x72\xac\xa2\xd4\xa6\x0d\x1b\x04\x39\xd6\xae\xd0\x82\x09\x91\x24\x0c\xc2\x76\x9a\xb5\x73\x52\x39\x67\xb8\x76\xa0\x47\xde\x9c\xa6\x56\x53\x69\x72\x8c\x41\x91\xcf\x90\xa6\x6a\xc8\x4a\xad\xc2\x1a\x2a\xc7\xe1\xe6\xc4\x6c\x51\xb6\xd0\xa6\x69\x4e\xdc\x93\xb6\xb3\x69\x29\x8c\x1c\x47\x5c\x2d\x8e\x4a\x9a\x69\xcf\x58\x1a\x38\xa3\x33\x8f\x95\x79\x3f\xd3\x6c\x76\xdc\x86\x6d\xa1\x14\x53\xa8\x61\xa0\x19\x38\x60\x56\x1d\xc8\x97\xd6\xb4\xfb\xf0\xb8\x92\x12\x66\x9d\x9c\xac\x56\xcc\x24\x2e\x71\x10\x66\x4c\x34\x28\x09\x63\x2c\x66\xb9\x23\x47\x7f\xa7\x65\xe6\xbc\x1c\xe2\x4b\x55\x7b\xb2\xc4\xa4\xa5\xf3\xf4\x16\xbc\xd4\xbf\xf9\xa8\xeb\x7b\x63\xf6\x9a\x86\xdc\xdd\x52\xa9\xf5\xbd\x52\x61\x38\xc4\x9e\xa6\x66\xc2\x81\x1c\x42\x4f\x61\xc9\xf3\xf6\x36\xdf\xce\xd0\x8c\x41\xcf\x77\x33\x2c\x3b\xcf\xe4\x2f\x33\x34\x3f\xc1\xe4\x90\xd8\x33\xba\xad\x6a\xe6\x55\xa0\xbb\xe3\x8c\xf5\x33\xcf\xa4\xbb\x14\x2e\x0c\xe9\x69\x63\x27\x6f\xe7\x01\xae\x92\x63\x34\x2f\x9f\x8a\x98\x19\xe9\xfe\x9a\xe0\xca\x43\xa6\xe5\x4c\xd6\x09\x62\xe9\xe9\x26\x24\x09\x63\x47\x45\x3f\xaf\xb3\x43\x07\x3d\x5c\x06\x6a\xd8\xa2\x11\xac\x86\xd3\xfe\x4a\xe5\x18\x4a\xee\xc5\x91\xc2\xc6\x83\xc6\x21\x90\x0b\x57\x66\x66\x9e\x23\xf4\x42\x96\xa6\x22\x6e\x52\xa5\x9b\x44\x0c\x63\x7d\xe9\x36\x74\xe5\xd0\x9b\xc9\xb4\x55\x4e\x6d\xad\x61\xa6\x63\x02\x2b\xaf\x3c\x55\x22\x3c\x3c\x68\x1c\x1e\x6d\x95\x59\xd2\x3a\xbc\xa0\x47\x2f\x30\x4d\x39\x3f\xe7\x03\xa9\x06\xdf\xe0\x9d\xe2\x68\xd6\xf7\xa5\xcf\x5a\x9d\x71\xcd\xcf\x30\x5f\x59\x8a\x9a\x21\x49\x91\x9c\xba\x02\xcb\x24\x15\xca\x67\x25\x16\x62\x44\x1a\xd5\xbf\xf3\x67\xe2\x2a\x0c\x2d\x26\x0b\x39\xbe\x34\x4e\x72\x83\xa5\x00\x32\x52\xab\x3c\xeb\x95\x15\xe9\x24\x9a\xe0\x62\x14\x48\xdb\x98\xa2\x20\x46\xe6\x1a\x9d\x1e\x4d\x36\x6c\xa5\x8b\x19\x05\xa9\x5f\x82\x0f\xd7\xa1\x80\xb8\xb6\x55\xba\xdf\x9f\xc3\xa0\x47\xa5\x2d\x8d\x6b\x94\x17\x5c\xfb\x0a\x08\x08\xaa\xac\xd5\xa2\x96\x4c\x13\x47\xc5\xad\x28\x3f\xa8\xf0\xc8\x29\x20\x91\xd8\xe9\x28\xd9\xf8\x2b\x93\xa8\x2c\x32\xe8\x0f\xc6\x4a\x14\xa3\x7e\x96\x4b\x53\x6c\x01\xcb\xe6\x1f\x98\x91\x0b\x58\xa2\xa9\xf7\x7d\xa4\xd2\x66\x0b\xe1\x54\x02\x64\xce\x49\x21\x76\xb6\x4b\x80\xd9\x39\x29\x15\x9e\x7d\x13\xa0\x78\x4e\x8a\x70\xd3\x7b\x02\x4c\xcf\xa1\x10\xdf\x96\xf5\x0c\xbd\xd0\x88\xe7\x19\x9c\xab\xfd\xe6\xa6\xf6\x5c\xb5\x47\x05\xce\xc9\x1d\x98\x65\xe4\x04\x08\xa0\x5a\x34\x2c\xf2\x65\xea\x82\x32\x0d\x13\xe0\x6b\x65\xdd\xf0\xc4\x0c\xd5\x03\xdc\x08\x8b\x00\x6a\xe8\xc2\x0a\x62\x02\xec\xd0\x5f\x5b\xe3\x97\x3a\x29\x9f\xa1\x17\x3a\x09\x32\x88\x8d\xaa\xeb\xf0\xd0\x4a\x80\xf8\xc9\x2f\x65\x25\xc0\xfa\xec\x57\x05\x2d\x35\xfa\x34\x0b\x6a\xc6\x2b\x77\xca\xa7\xf3\x0c\x24\x13\x12\x27\xc0\x00\xbd\x2c\x34\x84\xb1\xeb\x1b\x6c\x43\x4c\x1a\x32\x01\x2e\xa8\xab\x58\x32\x68\x02\xcc\xcd\xc2\x9a\x37\x56\x2a\x9a\x49\x86\xb2\x9a\x00\x55\x73\x2f\x2a\x6a\xc2\xf3\x66\x02\x04\xcd\x03\x9d\x7a\x07\x81\x13\x2c\xd1\xe5\x61\x66\x8b\x04\xe8\x99\x3d\xb2\x5f\xf7\x26\x4b\x4c\x4d\x46\x9d\xf2\x64\x2b\xc5\xd0\x7e\x93\x14\x94\x8a\x61\x0b\x26\xe9\x3d\x95\x8a\x85\xd6\xb7\x6a\x05\x57\xef\xc8\x49\xc1\x65\x38\xaf\x23\xc4\x54\x35\x7e\xaa\x9f\xe3\xbd\xa2\x9d\x3d\x63\xbc\x15\x7e\x67\x40\x08\xd5\x46\x0e\x0b\x9d\x7d\x72\x27\x5c\x02\x7c\x03\xcb\x58\xa9\xf4\x79\xf2\xbe\xe2\xc2\x84\xf9\x8b\x09\x70\x42\xdb\x1a\x32\x3c\x0f\x63\x12\x28\xce\xac\x39\x84\x97\xe5\x12\xe0\x89\x5e\x28\x1b\x61\xec\x38\x00\x54\x5d\x30\x6f\xe7\xee\xfa\x78\x18\x0e\x4b\x34\x6d\x43\xd6\x49\xab\x9a\xb0\x39\x00\xc2\xa8\x6b\xb3\x25\xf0\x38\x0c\xc8\x0a\x66\xc7\x41\x02\xbc\xd1\xa6\xfd\xf6\xad\x33\xfa\x8a\xc2\x9e\x50\x02\xdc\xd1\x4a\x75\x5d\xca\x2d\x62\x24\x40\x0b\x1d\xd1\xfc\x22\x7b\x02\x14\x51\x57\x2a\x0a\x93\x44\x93\xd5\xed\xca\x38\xa3\xbc\x40\x14\x2d\x94\xa5\x98\xde\xbd\xaa\xf7\xad\x72\x25\xf3\x7a\x80\x2e\x6a\x8d\x3c\x30\xb3\xe7\x0a\x57\xc9\xdf\x65\x1e\xee\xf8\xd5\xed\x2a\xf9\x07\x32\xd8\xc9\xea\x76\xb9\xfc\x23\x39\xec\x04\x68\xa3\xb3\x72\x8c\xe3\x02\xd4\xd1\x59\x21\xd6\x83\x01\x26\x69\xe9\x2b\xfd\x1c\x06\x82\xa3\xe0\xdc\x2a\x8c\x83\xe5\xf3\x5a\x96\x86\xe9\xa9\x1c\x8d\x82\x91\x07\x76\x72\x05\x26\x68\xd6\x6a\xed\x18\x8a\x48\x02\x5c\x50\xd2\x5a\x35\x4e\x31\x0b\xf3\x09\x70\x41\xaf\xe8\xe0\x92\x7f\x02\x7c\x50\xeb\x96\x5c\xf5\x04\x58\xa1\xb0\x07\x21\x0c\x07\xae\xb3\x62\x95\x77\x3d\x67\xd4\x2d\x55\x64\x73\x17\xcf\x8c\x3e\xa0\x7f\x6a\x3a\x92\xe6\x94\x0f\x98\x9f\x03\x96\xd5\xb9\xf5\x44\x55\xe5\x12\x1f\x21\x41\xea\x27\x32\x69\xc3\x05\x30\x8f\x00\xcb\xd7\x8b\xe5\x20\xe7\x06\xfc\xdb\x30\x3e\xc7\xe4\x4e\xc3\xec\xa5\x4b\x80\x1a\xea\xcd\x7e\x16\x58\x3c\x40\xf6\xf1\xd2\x2f\xfc\x2b\x04\xe6\xe8\x59\xdc\x2c\xb9\x37\x13\xc6\xf4\x1d\x90\x4a\xcf\xa2\x6e\x77\xbd\xcc\xa4\xf1\xe6\x0b\xc8\xa7\xd4\xda\x29\xc3\x85\xda\xb0\x3d\x00\x12\xea\x3e\x63\xea\x3b\x8e\x91\xdc\x68\x3d\xdb\xa1\xd5\xba\xf0\xec\x03\x2c\x54\xdb\x36\x34\x8d\x93\x54\xcd\xd4\x0c\xec\x7f\x3d\x8b\x1f\xaa\x6c\xf2\xfb\x44\xd3\x4e\xfd\xda\x84\xa3\x0b\x60\xad\xda\x76\x5c\x6b\x38\x0b\x36\xb7\x97\xc2\x4b\xeb\x09\x30\x5a\xdf\x66\xeb\x36\x07\x1b\xf6\xf6\x80\xd5\x9a\x29\x2f\xcd\x6c\x31\x2e\xf3\xc1\xec\x70\xf2\x2c\x26\x99\xa1\x30\x2e\xbb\xcd\x20\x85\xc1\xb3\xac\xb7\xd0\x4d\x29\xb8\x24\x75\xf2\x9c\xdf\x2b\xc1\xe5\xc5\x13\xa0\xb8\x0e\x45\x2a\xd3\xd6\x6c\x2a\x3c\x01\x9e\x2b\x16\x61\x1f\x03\x64\xd7\xbe\x4c\xdd\x56\x64\x95\xe4\x9f\x93\xde\x2f\xc3\x3f\x08\x36\xd4\x0c\x1c\x26\x66\xb8\x03\xcd\xf5\x0c\x66\x0d\x0d\x70\x5d\x4f\xa6\xf5\x6d\xb6\x68\x14\x81\xf1\x7a\x2e\x11\x86\x8e\x03\xe0\x7d\xa4\x66\xde\xc1\xed\x26\xb8\xc5\x1a\xbc\xdc\xd4\x99\xdb\x32\x90\x00\xe1\x35\xb7\xa6\x61\xf6\x14\x26\x1b\x5c\x7c\x14\xf2\x10\x9b\x23\xd9\x42\x33\xf1\x14\xb0\x5f\x55\xed\xbc\xd8\x5b\x11\xe4\x78\x26\x1b\x0c\x71\x95\x3c\x84\x4d\x12\xb0\x60\x05\xe3\xb9\x02\xff\x35\x53\x3e\x6b\x59\x9f\x02\x08\xae\x57\xf0\xd2\xbb\x06\xae\xab\x6f\xab\x4c\x87\x6b\x0c\x4c\xd7\x01\xb9\x28\x7a\x0d\xb1\x6b\xbd\xff\x00\x0b\x3c\x01\xe2\x2b\x14\x61\x46\x03\xf0\x5f\xa1\x00\xeb\xd5\x03\x09\x16\x8a\xf0\x53\x22\x10\x61\x45\xd3\x30\xc6\x12\x68\xb0\x6f\xaa\xce\x99\xed\x39\x09\x10\x60\x45\x9d\x5b\xa3\xc2\x13\xdf\x76\xc2\x17\x6c\xc3\xea\x0d\xdc\xd7\xdc\xaa\x2c\x63\x16\xc0\x13\xe0\xbe\xba\xc3\x29\xbc\xda\x91\x00\xf1\xb5\x30\xad\x5d\xe8\x75\x64\xb8\x5a\xd2\x3a\xec\xa0\x22\xb3\x95\x2a\xc1\x54\x15\x08\xad\x3c\x6e\x85\xe9\x3e\xaf\xa6\x2e\xd5\xde\x0a\xaf\x1a\xc6\x8e\x00\xc1\xd5\xb5\x5c\xd6\x6d\x87\x6b\xe4\x1c\xf9\x30\xd9\xe1\x6e\x2d\x59\xaa\x23\x53\xf9\x2d\x04\x48\x61\x5b\x0a\xfc\xd5\x63\x38\x61\x03\xc4\xd5\x37\x52\x19\x53\xc1\x51\x0b\x2d\xd5\x96\x49\xe0\xec\x70\x63\xd6\x9e\xb4\x62\xb6\x1c\x27\x3b\x39\xb3\xb3\x4b\xeb\x81\xc9\x6e\x46\xc5\x1e\xf7\x92\xf3\x43\x73\x37\xdf\xef\x72\x2d\xc7\x5a\x81\x97\x1b\x07\xfc\x66\x0d\x7b\xe6\x34\xf3\xe2\x12\x70\x6a\xfd\x72\x2a\x1e\x98\xae\x6f\x25\x91\x96\xa5\x50\x61\xd3\x0b\x6c\xd7\xa3\xaa\xc8\x2c\x59\x5e\xa0\xbc\xfa\xd6\x1e\x94\x2b\x63\xad\xae\xdb\x3e\xcf\x0b\xe5\xe1\x45\xc3\x04\x98\xb0\xb0\x9e\xc5\x35\x07\x08\x4e\x8d\x90\x14\xbb\xb2\xf5\x9e\x19\xa9\xc0\x88\x75\x9a\x61\x32\x27\x40\x85\xbd\x1e\x38\xb2\xd4\x7a\xd0\x7d\x63\x73\x76\x7f\x4f\x02\xe4\x57\xd3\x50\xcd\x18\xe1\x97\x6c\xe2\x08\x28\xdf\x42\xb2\xf1\xc2\xa6\x9a\x65\x46\xdb\x5a\x1d\xc9\x3a\xe5\x99\x77\x2d\xc1\x96\x58\x2f\x6c\x7c\x4b\x6a\xd8\x5b\x91\xb7\xe7\xbd\x3f\x61\x62\x40\x02\x2c\xda\x93\x28\x0d\xd3\x5d\xe3\x98\x19\x28\x41\x41\x24\xf0\x66\x2d\xe5\x79\x78\x19\x36\x01\xd6\xec\x80\x5c\xea\x26\x81\x09\xf4\xce\xa1\xa0\xb6\x59\xdc\xdc\x94\x00\x8b\x16\x4a\x85\xe1\x10\x6c\x92\x56\x52\x99\x30\xf5\x29\x01\x0a\x6d\xae\xf6\x61\x13\x0c\xec\xd9\x46\x51\x1e\x37\xaa\x21\x1b\x37\xe1\x8e\x01\xfe\x2c\x14\xe0\xb2\x65\x40\x9e\xcd\x6d\xdb\x30\xeb\x1e\x40\x98\xfd\x6a\x4c\x15\xe6\x82\x24\xc0\x93\xd5\xa2\xde\xb7\x82\xb1\xc6\x40\x8f\x2d\x44\xd8\xdf\x00\x72\xec\x85\x2e\x10\xc6\x42\xb2\xa5\x54\x4c\x92\x19\xe8\xb1\x8d\x08\x3b\xe6\xc0\x8d\x75\x8d\x61\x74\x00\x78\xb1\x92\x8b\x66\x80\x11\xdb\xe1\xc2\x7a\x92\x8d\x3a\x98\x51\xc9\xd1\x18\x92\x6c\x3d\x87\x2e\x0d\x8b\x0c\x8f\x38\x22\x26\xd6\xc8\x36\x53\xe0\xa2\x60\xc8\x56\x90\x3c\x71\x83\x2c\x03\x77\xb7\xf5\x66\xb2\x04\x7d\x9d\x1b\xc3\xa5\x91\x90\x37\xcd\xae\x78\xf1\xae\xc2\xe5\x04\x7a\x8e\x4c\xed\x32\xec\x78\xee\x3c\x86\x24\x03\x7f\x98\x8e\x4a\xd4\x9e\xd9\x9c\x95\x64\x98\x8a\x68\xeb\x9c\xa5\x28\x27\xd9\xa8\xa6\xb9\xf0\x22\x63\x48\x40\x09\x30\xa6\xfb\x1c\x4a\x93\x73\x8b\x7e\xc0\x92\xee\xd1\xdd\x2c\xc6\xc1\xd3\x29\x9c\xde\x25\x31\x3c\x9c\x44\xae\x66\x95\x31\x6f\x64\x1b\xa3\x38\x1e\x5c\x02\x5c\xe9\xe2\x4c\x54\xf0\x66\xb6\xfd\x6d\xb8\x31\x3b\x13\x02\x6e\xf5\x07\x48\x70\xcf\x98\x71\x95\xbe\xa9\xe6\x9e\x98\xb3\x23\xcd\x09\xda\x4c\x05\xf5\xbd\x79\x57\x54\x9b\x2b\xc3\x09\xda\x4e\x05\x55\xe6\xa8\xee\x36\x6d\x38\x5d\x83\x11\xb4\x9b\x0a\xea\x97\x5c\x19\xf8\x0b\x38\x7c\xcc\x6a\x9f\x44\x32\x6b\x4e\xcc\xb6\xc8\x04\x68\xd7\x5f\x5d\xd1\x1f\xd3\x17\xc6\x4a\x88\x37\x0b\x8a\x33\xd3\x4e\xb3\xa6\xc3\xd5\xd6\xdc\xb9\xea\xc4\x71\xc6\x31\x77\x6d\xd3\x8c\x4c\x59\x80\x5a\x6e\xba\x00\x22\xf7\xd5\xa3\xaf\x8d\x0f\xef\xbf\x48\x80\xd1\x3d\xf3\x75\x2d\x39\xe5\x3c\x18\xea\xcb\xe5\x2c\x4c\x35\x4d\x80\xf7\x3d\x3b\xf6\x84\xaa\x86\xd9\x07\x9d\xe4\x93\x6d\x6f\x4b\x66\x39\x9f\x50\x54\xc2\xb0\x71\xd0\x9e\x62\x69\xaa\x4c\xd5\xc2\x9b\x59\x0e\xe6\x9c\xc2\x96\xf7\xae\x96\x42\x1e\xc8\xc6\x35\x31\x29\x89\x1c\x8f\xea\xa9\x25\x0d\x87\xbc\x33\xd1\x23\x90\xc5\x7f\xfd\x35\x8c\xda\x40\x30\x2a\x4b\x31\x55\x85\x37\x52\xef\x61\xb2\x71\x02\xc4\x71\x47\xf5\xd4\x2f\xee\x77\x5e\xf0\x9b\xb9\x13\x20\x93\x77\xe5\x67\x83\x17\x24\x30\xc3\x11\x28\xe6\xa5\x72\xde\x30\xa1\x13\xd2\xcb\x07\xb5\xf5\x25\xd7\xba\x71\x54\x96\xfd\x89\x90\x61\x24\x9c\x86\x26\xac\xd8\x5b\xd1\x84\x87\x02\x32\xc7\xb5\xca\x99\xcd\x3c\x09\x90\xc4\x87\x35\x33\xce\x2d\x05\x96\xf8\x15\xbc\xa4\xe0\x84\x07\x50\x55\xe1\x15\x10\xc2\xd4\xb9\x94\x64\xe3\x4c\x00\x5f\xf6\x6c\x6c\x5b\x9f\x19\x6e\x72\x03\x82\xb8\x67\xa2\x2e\xe0\x80\x67\xaa\x36\xb2\xd5\xcc\x46\x98\x84\x26\xf1\x70\xd8\x66\x01\xfd\xbb\x7f\xed\xec\x81\x15\x09\x50\xbe\xfd\x9b\xe2\x2c\x1b\x30\xbe\x4f\xa4\xc3\x71\x06\xb0\xbd\xbb\x71\x3e\x28\x37\xf3\xae\x04\x24\x2b\x8b\xb0\x63\x06\xb4\x6e\x29\x74\xf7\xae\x3c\x43\x0b\x20\x54\xd4\x13\x17\xba\x00\xa1\xfb\xbc\x33\xe5\x4d\x68\x8e\x2f\x09\x8c\x6e\x29\xe3\xa3\x72\xe1\x60\x07\x18\xdd\x52\xc6\x55\x7f\xd4\x06\xb7\x05\x35\x01\x4e\xb7\x94\x71\xae\x9c\x34\x47\x66\x38\x02\xad\x5b\xca\x58\x54\x14\x0e\x92\x70\x9f\xa8\x5c\x7a\x27\x48\xed\x96\xfd\x06\x29\x26\x33\x0b\xe4\xee\x9e\x5b\xce\xd3\x7c\x90\xdb\x7d\x45\x33\xea\x01\xec\xee\xfe\x40\xcc\x30\x10\xf8\x2e\xa6\x39\xf1\xf9\x3a\x20\x76\x87\xcf\x61\x4c\x80\xd4\x4d\x27\xca\xad\x69\x1a\xae\x33\x30\x35\xd9\xf9\xb1\x99\x6d\xb9\xfa\x42\xd4\xaa\xac\x2f\x73\x71\x8a\xa5\x38\x30\xef\x19\x73\x93\x24\xf8\x33\x1e\x12\xa0\x77\x37\x8a\x78\x70\xfa\x34\xd9\x77\xb3\x88\x86\x33\x27\x85\xf3\x45\x30\x3a\x4c\x81\xc5\x3d\x20\x17\xcc\x74\x0a\x0c\xee\x73\x42\x94\x39\x24\x32\x05\x06\xf7\x05\x1d\x9c\xe4\x52\xe0\x6f\x67\x8a\x8d\x3c\xd3\x27\xdc\x7f\x10\x34\xc8\x29\xf0\xb6\x95\x79\x2f\x4d\x78\xa3\x5d\x0a\xbc\x6d\x51\xef\x49\x73\xe7\xf2\xa5\x40\xdd\x96\xc1\xf5\xda\x14\x68\xdb\xae\xa4\x03\xcd\x68\x9d\x25\xfd\x3a\xbb\xa4\x34\xd3\x94\x51\x77\x2b\x12\x75\x23\xc2\x87\x23\xa6\x4f\x98\x6e\x39\x39\xd2\x5a\xe4\x8c\x64\x64\xb7\xd4\x35\x49\x9f\x53\x9f\x41\x0d\x97\xc0\x90\xd6\x95\x5c\xb6\x24\x4d\xf0\xfc\x49\xdb\x56\x59\x38\x62\x4f\x81\xc6\xad\xbb\x36\x86\x79\x10\x29\x30\xb6\xbb\xf6\xb9\xe0\x14\x9e\x02\x5b\xdb\x95\xca\x7a\xa7\xea\xac\xd5\xc1\x4c\x72\x0a\x8c\x6d\xa7\xaa\x46\x9f\xb2\x56\x85\x5d\x9d\x14\xf9\xda\x87\x93\xf0\x5a\x84\xdf\x74\x32\xd9\x0a\xe9\xd9\x0d\x96\x69\xb2\x9d\x82\x97\x97\x45\x53\x3c\xca\x57\x89\xca\x84\xcf\xb6\x4a\x13\x3c\x87\x27\xbc\x25\x39\x05\x3e\x78\xbf\x39\xca\x91\xb4\xe1\x99\x37\x05\x4e\x78\x65\xbc\xb1\xfc\x28\x4e\x70\xf5\xc7\x12\xf9\xf8\xa8\x28\x98\xc9\x4b\x81\x18\xde\x9f\xb2\x92\x31\x27\xf4\xa6\xc0\x09\x3f\x12\x73\xd0\x56\x3a\x21\x7a\x87\x9d\xbb\x14\x88\xdc\x15\x59\xd9\x86\x9d\xfb\x14\xd8\xd8\xfd\x9e\x5d\x77\x9d\xf5\x2f\x6b\x2a\xa2\x76\xfb\xfe\x0b\x54\x61\x19\x6b\x9c\x55\x2f\x70\xce\xeb\x4e\xf1\xfc\xde\xae\xc9\xe7\x1d\x39\x61\xfc\x66\xd2\xf2\x45\xf8\x76\x26\x9e\x7f\x5d\xbb\xa9\x70\xe7\xad\x09\x4f\x9d\x29\x50\xb4\x01\x1e\xe6\x67\xa6\x40\xd2\xc6\x02\x61\xa3\x08\x34\xed\x9a\x5a\x66\xe3\x67\x0a\x1c\xed\xe1\xad\x6b\x66\x65\x28\x05\x9e\xf6\xf5\x64\x15\x53\x14\x4a\xaa\xb0\xfb\x96\x02\xfd\x7a\xdc\xd6\x1d\x1e\x85\xc0\xbc\x7e\x2b\x85\x77\x22\xbc\x88\x90\xae\xd0\x32\x5a\xc6\x37\x4d\x81\x77\xdd\x8f\x6d\xd6\x1c\x01\xdf\xba\x07\xb3\x47\xc2\xa7\xc0\xb9\x2e\x8d\x9f\x4d\x73\x59\x78\x2b\x47\x0a\x14\xec\xa3\x12\x40\x54\xbb\x03\x9d\xf8\x9d\x1c\x10\x42\xfb\x36\x7b\x0b\xaf\xec\xa7\xab\xc9\x6e\x42\xd5\x86\xfd\x26\xe0\x53\x9f\xe4\x34\xad\x02\x69\x97\x70\xf1\x51\x19\x4d\xe3\x55\x1d\x57\xa6\x76\x9c\x4e\x02\xdd\xda\x34\x54\x73\x47\xa6\xa5\x2b\x3c\xd5\xa9\xa1\x5c\x79\xca\x9d\x63\x94\x11\x4f\x2c\xf3\x9e\xec\x29\x5e\x4f\x3b\x6c\xb8\x7a\xef\x1a\x6e\x57\xb9\x95\x0c\x04\xed\x0b\x7e\x75\x57\x8a\x2f\x2d\x51\xdc\x79\x9e\x9e\x49\x42\xa4\x40\xe1\xbe\x94\x4c\xef\xca\xe3\x4e\xeb\x4a\x81\xda\x7d\xc1\x27\x77\xa5\x9c\xeb\x13\x16\xb4\xba\x11\xf4\x74\x57\x10\xee\xf7\xb9\x23\x66\x0d\x93\x66\xeb\x28\xee\x93\xec\xdc\x73\xc7\xd1\xa5\x62\xd9\x5a\xc7\x68\x1a\x10\xc2\x4d\xf6\x95\xa4\x9f\x1c\xe3\x72\x07\xbf\x9d\xe3\xdb\x7a\xa1\x04\x9e\x94\xa6\xe4\xe1\x14\xd7\x26\x7c\xbe\x51\x0a\xac\x70\x80\x87\xe3\xcb\x14\x68\xe1\x52\xc6\x5f\x65\xd8\x29\x04\x3e\x78\x1f\x9b\xd7\x64\x5d\x2c\x35\xe3\x46\xae\x27\xbb\xcb\xc3\xe9\xc1\x74\x8d\xa7\xaa\xea\x61\x81\x4e\x32\x1c\xa3\x14\x88\xe0\xa5\x69\x6d\xff\x05\x16\xa6\x91\x40\xf4\x1e\xe1\x53\xad\x1c\xaf\x3b\x6e\x79\x2a\x05\xa2\xf7\x58\x24\x0d\x88\x62\x07\x0a\x30\xbc\xc7\x12\xab\x80\x24\x62\xbc\x4d\xa0\x7c\x5f\x0b\x84\xc1\xb3\x03\xad\xf6\x56\x64\xb3\xf4\x5e\x7f\xdd\xb2\xdf\xbf\x48\x9f\x67\x07\x5d\x39\x6f\xe6\xcb\x44\xfd\xf5\x85\xec\x57\xfa\x3c\x3b\x03\xeb\x72\x5c\x10\x57\x64\x3b\x2d\xa2\xd5\x37\x76\x73\x64\x0a\xac\xee\xe1\x19\xcd\x42\xdb\x5e\xa6\xf8\xb3\xc1\xe0\x4a\x88\x59\x09\x12\x92\x1b\x74\x78\x52\xb1\x15\x39\x71\x9f\x2d\x48\x9f\xf1\x73\x32\x7b\xd5\x4d\x64\xcc\x14\x0f\x4c\x6e\x69\xa9\xff\xd8\x54\x7f\x66\x86\x09\x1f\xb1\x92\x02\x95\x3b\x4c\xb8\x48\x81\xbd\xbd\xdf\x2f\x30\x44\x52\xa0\x6d\x7b\xab\x1a\x91\x1f\x15\x67\x47\x81\xb1\x6d\xf2\xda\x1c\x3a\x15\xae\xd5\x21\x98\x0d\x4d\x81\xad\x3d\x29\xb0\x94\x60\xd9\xe0\xf1\x99\x3e\x6e\xd8\xcd\x6d\x29\xf0\xb6\xdf\xd4\x41\x75\xb3\xbd\x88\xc3\x21\xd4\x06\x4f\x98\x2a\x84\x65\xaa\x8f\x9b\xda\x2c\xf3\xf5\x9a\x74\x83\x6b\x96\x96\x8a\x30\xad\x3a\x05\xc6\xb6\x69\x98\x0f\x0c\xa4\x40\xd5\xee\x35\xbb\x26\xdf\xf9\x32\xda\x58\x66\x5a\x04\xd2\xb6\x3f\x4e\x03\x2e\xd2\x74\x54\x8e\xd9\xf4\x99\x02\x7f\xbb\xbb\x2e\xc2\x43\x03\xc8\xdb\xcf\x4f\x4f\x0d\xd3\x5a\xa0\x1c\x56\xe2\x1b\xf3\x70\xa0\x6f\x5f\xf7\x4b\xf6\x8c\xba\x70\x2d\x80\xc4\x7d\x2d\x32\xec\xf8\x62\xca\xdc\xd9\x96\x39\x9c\x43\xce\x94\x59\xdd\x96\x19\x76\x73\x31\x65\xd6\xd0\x7b\x79\xeb\x18\x0e\x61\x3a\x39\xc3\xb8\xe9\xa2\xa1\x30\x74\x33\x81\x3a\xb5\x67\x2c\x06\xd0\xb7\x3b\x30\x53\x59\x0c\x54\xc3\x5e\x0e\x30\xb6\xcf\x07\xfc\x30\xab\xd2\xe9\x56\xdc\x41\x73\x95\xc8\x70\x82\xfc\xf6\x2d\x0c\xc4\x2f\x75\x54\xc4\x48\x04\x87\x45\x0b\x79\x88\xbd\x0a\x0f\xe1\x09\x75\xbb\xf6\xfd\xb7\xe3\x82\xe0\xdd\x9c\xeb\x17\x0b\xad\xc2\x8c\x82\x14\xf8\xdb\x94\x87\xb9\x64\x29\x1e\x47\x3c\x9e\x05\xca\x66\x3c\x80\xc8\x2d\x4d\xae\xa8\x61\xda\xb8\x43\x2f\x3b\x0f\x8f\x5a\x20\x6d\x17\xfd\x16\xa0\xe1\x2b\x7e\x61\x3c\x7e\x41\x2e\xec\x69\x02\x6d\xbb\xb1\x26\x6f\xa5\x8f\xcb\x36\x7c\xb6\x77\x0a\xfc\xed\x4a\xbd\xb3\x14\xa3\x14\x58\xdc\x4e\x5a\x95\x31\x48\xd8\x62\x29\xba\x50\x63\x61\x92\xdc\x65\x77\xf1\x8c\x26\xef\xa6\x9f\xdb\x58\x7c\x40\x7e\x0f\xce\xc9\xc7\x75\xe8\xf3\x01\xe2\x59\xf8\x73\x4e\xe9\xcb\xd3\x3d\xbc\xe3\xe6\x54\x20\x69\x97\xc2\x95\xcc\xc7\xa2\x52\xe0\x67\x67\xba\x25\x6f\x0c\x93\x96\x07\x7a\xf6\x15\x1c\x87\x35\x06\x0f\x24\x26\x2b\x89\x51\x16\x20\x62\xef\x95\xd7\x82\x11\x0a\x1c\x8b\x26\xa3\x3d\x7b\x02\x4b\x0a\xf4\xeb\xb7\xa6\x30\xb6\x0a\x5b\x85\x29\x01\x5b\x31\x73\x3b\xf0\xae\xcf\xbc\x67\xa1\x63\x21\x25\x97\x64\x03\xfa\xf5\xc8\x83\x67\x4d\x03\xd0\xb0\x67\x9f\xfe\x60\x94\x0b\x48\xd6\x99\x56\x4c\x40\x03\x14\xea\x81\x1b\x96\xd3\x70\xf0\x03\xe7\x62\x00\x9d\xfa\xfc\x09\xb4\xee\xb6\x35\x9a\x3f\x70\x3a\xc5\x43\x89\xad\x50\x9a\x19\x4e\xc0\xae\x16\xce\x29\xd7\x3b\xd7\xba\xf3\xc8\xeb\x7e\x43\xdd\xc9\x79\x62\x3a\x11\xb8\xd6\xc2\xe9\xc1\xf5\x6a\x2c\xf9\xf9\xf7\x14\x44\xbf\x5b\x51\xd4\xc3\x21\xe0\x17\x96\xf0\x3d\xfc\x9d\x67\xc0\xd1\x7c\x24\x8a\x7a\xec\xf6\x4b\x50\xd6\x85\x4a\x45\x9f\xe2\x9f\x3f\x37\x67\xbe\x3f\x91\x02\x87\x7b\xaf\x55\xf8\x68\x97\x14\xf8\xdb\x3d\x30\x66\x2a\x0b\xfe\xb2\xda\xdf\x7c\x57\x62\xd2\xfc\xb0\x10\xdc\x49\xf6\x16\x2f\x38\xa2\x40\xe9\x3e\x2a\x91\x33\x53\xbc\x78\x99\x21\x97\x42\x0b\x60\x76\xbb\x5a\x34\x40\xb1\xba\x83\xcd\x6e\xb0\xf1\x9e\x5d\x41\x05\x92\xf7\xb5\xc4\x52\x85\xe0\x8c\x93\x2b\xe1\x3d\x8c\xc6\xf3\x90\xad\xf3\x31\x9e\x53\x7b\x0b\x07\xe2\xf7\xc9\x08\xa6\xe2\x40\xfc\xf6\x25\x55\xa4\x1c\x33\xc2\xf0\x3c\x64\x38\x5c\x75\x32\xcd\x3d\xdc\xdc\x5e\x5c\x10\x00\xae\x78\x31\x25\x25\xf6\x5f\x20\x5e\x72\x42\xb2\x69\xce\xc4\x95\xe2\xc0\xd9\x39\x20\x8f\x8f\x9f\xe7\x65\x58\xa1\x29\x90\xc8\x27\x05\xb8\x67\x80\xd6\xab\x9a\x39\x6a\x29\x45\x1a\x79\x9e\x5b\x72\x8e\xfd\xa2\x62\x0a\xc4\x71\xc4\x73\x75\x19\x15\xff\x28\xe7\xbb\x66\x2e\x32\x38\xda\x4f\x0a\x64\xf2\x5e\xc2\x2c\x93\x84\x32\xb8\x7a\xc8\xe9\x22\xca\x82\x73\x04\x44\x73\x80\x73\xf2\x67\x47\x59\x86\x91\xc0\x34\x57\x79\x9c\x09\xce\x31\x07\x9e\x79\x6e\xfb\x09\x3b\xd6\x4a\x52\x3d\xfb\x48\xb0\xca\xf9\x57\x08\xfc\xf3\x99\x98\xd9\xcb\x3c\x0b\xe2\x6a\xbf\x82\xc9\xdd\x30\xbe\x06\xd2\xd1\x2d\x9d\xf9\xd4\x52\x54\xe1\x38\x0f\xc8\xe5\x9e\x34\x71\xdb\xb8\x53\x89\xdf\x20\x21\x5b\x0d\x07\xca\xce\x16\x4f\xe0\x4e\xe8\x3a\xbf\x88\x22\xb7\x77\x9f\xb2\x0a\x4a\xfb\xe0\x62\x8a\xdc\xdd\x95\x9b\x06\xe5\xb2\xb9\x62\xf9\x72\x57\x5a\x12\x94\xb6\xb4\xb8\x22\xc5\x5d\x81\x4f\x41\x81\xfc\x22\x0b\x1e\x27\x5e\x9a\x37\xee\xc1\xe0\x04\x0a\x5f\xfa\x76\xba\x37\xc5\x25\xcf\x93\xdf\x19\xc7\xc4\x01\x76\x7a\x63\x72\xc9\xcd\x42\x40\x4b\x1f\xb6\x84\xc7\x95\x78\x57\x95\xfa\x16\x1e\x98\x40\x3d\xbf\x14\x51\xf5\x42\x91\x64\x5e\xc4\x92\xf3\x86\x99\xa3\x73\xfc\x30\x66\x45\x2e\xb6\x24\x3d\x7e\x41\xeb\x01\xa5\xe1\xb7\xc3\xef\xc8\x5a\x85\x64\xcd\x4c\x00\x4a\x63\xec\x00\x10\xd1\x33\x51\xe7\xec\xc0\x06\x0e\xfa\xde\x8a\x30\xb1\x00\x58\xe8\xe4\x19\x5e\x11\x10\xce\x55\x95\x87\x23\x2e\x20\x96\x5b\x71\x24\xcd\xe4\xc2\x80\x3f\x4e\x64\x59\x6d\x01\xfe\x78\x7f\x7e\x9b\xe4\x48\x3c\x39\xfa\x72\xe6\xad\xd0\xbc\x77\x80\x47\x92\xb7\x0d\xd9\x7e\xe3\x4f\xd8\x8e\x00\x89\xfc\xad\x59\x4c\xd2\x02\x8f\xbc\x22\xf2\xcc\xba\xe2\x85\x44\xee\x6c\x6c\x6a\x7d\xea\x01\x8d\x71\xaa\x8f\xb1\x22\x91\x39\xa3\x5b\x4f\xff\xf6\x29\x8a\x86\x4f\x05\x47\x49\xf3\xde\xfd\x3a\x7f\x67\xf8\xf2\xb3\x11\x79\xbf\xdf\x30\x7a\xea\x7e\x55\xc2\xee\x55\xfd\x1a\xc5\xe7\xbb\xd7\x73\x3d\xa2\x52\xe5\x39\xd5\xdd\xb5\xfe\x1b\x0d\x51\xa7\x9a\x9f\x9f\x1e\xa2\xf3\xff\x7e\xec\xee\x64\x83\xc7\xd9\x89\x1a\x2b\x16\x17\x46\xb6\xae\xff\x88\x80\x90\x5d\xc0\xf5\x70\xef\x56\xff\x5f\xb3\x36\x38\x2f\xbc\x92\xd0\x02\xd1\x7a\x83\x4d\xb8\xfc\xbe\xd4\xfa\x69\x5a\xe5\x2e\x92\xc8\x34\x8d\x75\x1e\xf0\xbf\x7d\xfa\x7f\x01\x00\x00\xff\xff\xa2\x10\xca\xbc\x26\x92\x00\x00") + +func uiAppLibFontAwesome470CssFontAwesomeCssBytes() ([]byte, error) { + return bindataRead( + _uiAppLibFontAwesome470CssFontAwesomeCss, + "ui/app/lib/font-awesome-4.7.0/css/font-awesome.css", + ) +} + +func uiAppLibFontAwesome470CssFontAwesomeCss() (*asset, error) { + bytes, err := uiAppLibFontAwesome470CssFontAwesomeCssBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "ui/app/lib/font-awesome-4.7.0/css/font-awesome.css", size: 37414, mode: os.FileMode(420), modTime: time.Unix(1, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _uiAppLibFontAwesome470CssFontAwesomeMinCss = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xcc\x7d\x4d\x8f\xe4\xb8\xd1\xe6\xdd\xbf\x22\x77\x06\xde\xe9\x36\x4a\x35\x45\xe5\x77\x15\xbc\x9e\xfd\x80\x01\x03\x36\xf6\x60\x1f\xf6\xb0\x17\x8a\x0a\xa5\xd8\x49\x89\x1a\x92\xca\xac\xec\x46\xff\xf7\x17\x92\x18\x4c\x2a\x2b\x28\xcf\x0b\xcc\xe1\x35\x0c\xbb\x8b\x7c\x48\xf1\x23\x18\x11\x0c\x3e\x64\xfe\xfc\xa7\xff\xf6\x87\xd5\x9f\x56\xab\xbf\xea\xd6\xad\xfe\xe7\x15\xac\x6e\x60\xb5\x79\xde\x3f\xbf\xac\x8a\xdb\xea\x97\x92\x5f\xe0\xc4\xdb\xf2\xb6\xca\x56\xb5\x73\xdd\xeb\xcf\x3f\x57\xba\x75\x7c\x02\x3e\x4b\xbd\xca\x56\xbf\x44\x29\x63\x5d\x7f\x97\x02\x5a\x0b\xa9\x22\x3f\x2b\x9f\xff\x69\xf8\xe8\xeb\xea\x9f\x7f\xfb\xfb\xea\xff\xfe\xf5\xef\x2b\xf6\xcc\x9e\x56\xff\xfb\x9f\xff\x7c\x5d\xfd\xe3\x6f\xff\xc2\x4a\x3e\xff\x61\xf5\xa7\x9f\xc7\x2f\x64\x15\x17\xf0\xcd\xff\xab\x91\xea\xf6\xfa\xd3\x50\xde\xb7\xf9\xa7\x37\x6b\xc4\x6b\x6f\xd4\xa7\x9f\x9e\x9f\xc7\x0f\xda\xf8\xb3\xd9\x15\x8a\xe1\xcf\x67\xd0\xee\x2f\x97\x3f\x8f\x1d\xfc\xe9\xf3\x7f\xa2\xcc\x8f\x12\x2a\xf9\xfe\xdf\x43\xd1\x55\xa5\x4d\xc3\xdd\xa7\x9f\xa0\x29\xa0\x2c\xa1\xcc\x74\x07\xad\xbb\x75\xf0\xd3\xe7\xa7\x7f\x5f\xe5\x55\x57\x55\xfe\x97\x8f\xb5\x8d\xe9\xbf\xb9\x86\x44\x05\xbf\xa9\xbc\x73\x54\x71\x67\x7a\xf8\xcd\x9d\xb0\x97\x13\x56\xf1\x63\x94\x6f\xe0\xd4\x2b\x6e\xa2\x5a\xed\xe5\xf4\xd3\xe7\xb7\x71\xea\xae\x20\x4f\xb5\x7b\x6d\x87\x1c\x35\x25\x59\x77\x53\xe0\x53\xbe\x3f\x57\xfc\x5b\x29\x6d\xa7\xf8\xed\x55\xb6\x4a\xb6\x90\x15\x4a\x8b\xf3\x08\xf5\xa0\xd5\xfc\xff\xd8\xa6\x7b\xff\x99\xad\x22\x61\xf0\xf5\xca\xaf\xf0\x2a\xdb\x1a\x8c\x74\x6f\x0e\xde\x5d\x66\xa0\x2d\xc1\xc8\xf6\xf4\xca\x7b\xa7\xdf\x86\x8e\x9c\xa5\xcb\x26\x74\xa3\xb5\xab\xc7\xbc\xd6\x49\xae\x24\xb7\x50\xbe\x65\x8d\xfe\x9a\x69\xfb\xfe\x88\x39\x19\x7e\xb3\x82\x2b\x18\x1a\x9c\xa9\xd3\xb7\xfb\x17\xd9\xf3\xda\xff\x07\x9a\xb7\xb1\x03\xf5\xd4\xe7\xe7\xfd\x16\x9a\xb7\x0b\x18\x27\x05\x57\x19\x57\xf2\xd4\xbe\x66\x6c\xfb\xc7\xb1\x8e\xfc\x3d\xaa\x23\x87\x66\x4c\x5c\xc7\x89\x6b\x9f\xb8\x89\x13\x37\x3e\x71\x1b\x27\x6e\x7d\x62\x75\xfd\x76\x95\xa5\xab\x5f\xd9\x73\x7e\xd8\xee\xd9\x26\x3f\x42\x33\x0d\xc5\xf4\x75\x01\xad\x03\x33\x62\x7b\xf5\xad\xe3\x65\x29\xdb\x53\xa6\xa0\x72\xaf\x2f\x6f\x0d\x37\x27\xd9\x4e\x7f\xe5\xcf\x6c\x33\x55\x31\x76\xca\xfa\x59\xcb\x06\x59\x79\x6d\x75\x0b\xbe\x8e\xff\xa1\xe4\xb7\x4e\x5b\xe9\xa4\x6e\x5f\x0d\x28\xee\xe4\xc5\x8f\x51\x94\xc1\x0b\xab\x55\xef\xe0\x6d\xac\x3b\x9b\x55\x3e\x35\x78\x96\xe4\x74\xf7\x3a\xfb\x9b\xec\x80\x92\x7e\x2a\xa6\x4a\xd9\xf3\xd4\xe3\xc3\xce\x0f\x46\xa1\x4d\x09\x06\x3b\xf9\xfa\x9c\x43\xb3\x7a\xce\xb7\xc3\xff\xb2\x61\x62\xa6\xfc\x57\xab\x95\x2c\x57\xcf\x2f\x07\x68\x56\x3f\x02\x80\x4f\xcf\x0c\x2f\x65\x6f\x5f\x9f\x99\xaf\xae\xeb\x95\x1a\xc7\xe6\x5b\xa5\x34\x77\xaf\xc3\x3f\xef\x19\x66\x98\x71\x9f\x33\xfe\x7b\xc8\x9a\x17\xf3\xc3\x6b\x26\xd9\xf0\x93\xfb\x50\x41\x3c\x05\x13\x24\x55\x7b\xaa\x39\xcf\xff\xee\x83\x8b\x5f\xab\x78\x66\x3b\xd9\x7e\xc3\x95\xc2\x5b\xd9\xf0\x71\x0a\x7d\xce\x2a\xb7\x2b\xd9\x56\xb2\x95\x0e\x56\x83\xb0\x73\xf3\xf6\x5b\x40\x38\x52\x16\x16\xea\x66\x51\x31\xeb\xa0\xb3\x9f\x0e\x9f\x89\xda\x29\xd8\xf7\x5f\xb0\xda\x33\xdc\x2a\xc3\x1b\xb0\x2b\xec\xcc\xcb\x1f\xc3\x37\x9d\xe1\xad\x1d\xb4\xd4\xab\xd1\x8e\x3b\xf8\xf4\x52\xc2\xe9\xf3\x1b\x9d\xfc\x9d\xbd\x2c\x15\x5d\x6f\x8f\x74\x61\x9f\xf1\xfd\xfb\x2f\xff\x85\xda\x32\x8c\xff\x94\x96\x1d\x5f\xbe\x65\x8d\xcd\x2a\xa9\x1c\x98\xd7\x1f\x3a\xa3\x4f\xb2\x7c\xfd\x3f\xff\xef\x6f\x0d\x3f\xc1\xbf\xb0\x86\xe7\x7f\x48\x61\xb4\xd5\x95\x7b\xfe\x5f\xdc\x4a\x31\xe6\x7e\x1a\xab\x90\xba\xfd\x33\xfb\xfc\xc3\x5b\xb2\x39\xc7\xa9\x2b\xc3\x57\x52\x79\x89\xf4\xb8\x9d\xec\xf0\x7b\x34\x34\x5f\x6a\x28\x3b\x2c\xb4\x14\x33\x53\x19\x71\x5b\xf3\xfd\xef\xd1\xd6\xf5\x52\x5b\xf3\xfd\x42\x5b\x31\x33\x95\x31\x99\x07\x25\xbb\xac\xd6\x46\x7e\x1d\x8c\xb7\xfa\x1d\x1a\xfc\xf2\xb4\x6a\xa4\x31\xda\x24\xe4\x61\x34\x99\x9f\x32\xf6\xb4\x62\x8f\x0d\x9f\x65\xd1\xc9\xf7\x46\xa3\x11\xfd\x3d\xe4\xe1\x37\x35\x99\x3d\xad\xb2\x44\x93\x7d\x16\x9d\xfc\xfd\xd5\x68\xed\x56\xb3\xd5\xf6\xf4\x21\x8d\x1d\x88\xc4\x7c\x1f\x27\x3e\xcc\xd5\x63\x4e\x18\x10\x3f\x18\xc1\x24\x5b\xc7\xc5\xf9\xa3\x49\x7e\x23\x7d\x2c\x6f\x7b\xa1\x79\xf3\x2e\x4b\xfe\xe0\xc2\xe4\x1f\x1d\x98\x46\x96\xa5\x8a\xbe\x95\xb1\xf7\xa7\xfb\x1f\xf9\x7b\xca\xea\xbf\xf8\xaf\x0d\x8a\x2c\x61\xd1\xb1\xbe\x6f\x71\x13\xbc\x43\xf7\x7d\xf6\x8d\x8f\x9e\x93\x6c\x2f\x60\x2c\x7c\x13\x5a\x69\xf3\xfa\x63\x55\x55\x63\xf2\x49\x71\x6b\x5f\x0b\xa8\xb4\x19\xf2\x5a\x07\xad\x7b\xfd\xe1\xff\x57\x2f\x2f\x2f\x3f\x8c\x80\xa6\xb7\x52\x90\x00\x36\x01\x2c\x70\x23\x6a\x12\x91\x4f\x08\x68\x2f\xa0\x74\x07\x99\x26\x51\xeb\x09\x55\x03\x37\x8e\x04\x6c\x7e\xc0\xce\x19\x32\x7f\x7b\xcf\x4f\x7c\x62\x37\x21\x7a\x0b\x74\x0d\xfb\x29\xbf\x92\xaa\x21\xf3\x0f\x53\xbe\xab\x33\xc5\xcd\x09\x48\xcc\x11\x31\x64\x2e\xbf\xd7\x20\x2d\xdd\xcd\x62\x82\x88\x1a\xc4\x99\x04\x88\x09\x60\xa0\xd1\x17\x6c\xc3\x28\x5a\x42\x69\x3b\x4b\x70\xb2\x01\x7a\x56\xcb\x78\xd2\xb2\x4e\xf5\x34\x0c\x66\xb0\x46\xb6\x34\x8e\x79\x21\xe9\xf4\x15\x4c\xa6\xab\x8a\x04\xa1\xa0\xc8\x53\xcb\x15\x89\xf0\x82\x72\x82\x30\xc3\x53\xbf\xf4\x89\x84\x7b\x89\x71\x86\xdb\x9a\x9e\x71\xe6\x65\xa6\xd6\x0d\x39\x5b\x6c\x1b\x66\x3c\x21\x96\xcc\xcb\x8c\x18\x14\x41\x02\xe2\xc5\xc6\x68\x5e\x92\xf9\x5e\x6c\x4a\x7d\x6d\x55\x0a\xe3\xc5\x86\x1b\xa3\xaf\x99\x90\x46\x0c\x0d\x1a\x8b\x90\x70\x4e\xc2\xfb\x8e\x04\x7b\x89\x92\x6d\xa1\xdf\x49\x80\x97\xa8\x41\xf1\x85\xca\x48\x60\xf9\x43\x6c\xcc\x27\x8f\x39\x9a\x28\x03\x1d\x70\x52\xaa\x19\xa0\xd0\x56\x06\x2c\xb9\x36\x72\x2f\x1f\xe3\x2e\x8a\x2b\xb2\x9a\xdc\x4b\xc8\x30\x19\x64\xbe\x17\x89\x4a\x71\x52\x64\xf2\x4d\x50\x32\x65\x57\xeb\x96\x5e\x1d\xb9\x97\x8a\x8b\x56\x7d\x03\x29\x79\xce\x77\x33\x54\x6a\xaa\xf2\xfd\x0c\x46\x4f\x51\xee\x45\xe4\x57\x23\x74\x49\x4a\x6a\xee\x05\xa4\xe0\x69\x08\x2a\x97\x44\xdf\x8b\x90\x4d\xf7\xda\x4b\x41\xa1\x35\x3d\xb6\xe5\x3d\xbf\xe1\x86\xc6\xf8\x69\xee\x8c\x6c\xe9\x09\xac\xfc\x72\xe2\x0d\x18\x4e\x21\xd6\x5e\x97\x8c\x71\x0d\x2a\x9f\x61\x33\x14\xb9\x92\xd6\x5e\x44\xa4\xe3\x8a\xb6\x58\x6b\xd4\x1b\x83\x71\xf5\xd6\x93\x82\x6d\x22\xd8\x64\x93\x29\x94\x97\x95\xd1\x48\x4f\x5b\x44\x0a\xb5\x8b\x51\x93\x29\x27\x71\xfb\x18\x67\x92\x4d\x3b\xc4\xb0\x2f\xbd\x75\xb2\xba\x91\xc0\xe3\x7d\x4d\x91\xf9\x5e\x64\x4a\x28\xa1\x9d\x2d\x65\xdd\xbb\x28\x69\x5e\x28\xe8\x93\x24\xc2\x8b\xd2\x45\x96\xa0\x97\xe6\xda\x8b\x54\x57\x6b\xa7\xe3\xaf\xcb\xc1\x17\x8d\x13\x3a\x29\x5c\x6f\x12\x6a\x69\x8d\x52\x07\xad\x90\xa4\x65\xd9\xa0\x17\xc3\xbb\x6c\x90\x5d\x7a\xf4\x37\x5e\xb4\x78\x39\x0c\x29\x89\xf0\xc2\xe5\x12\xe2\xbd\xf1\xa2\x05\xa5\x9c\x8d\xe6\xd4\xb2\xcc\xfe\xda\xf3\x54\x27\x36\xe8\xde\xd4\x03\x64\x11\xb9\x8d\x3c\x84\x65\xe4\x2e\x32\x13\xe4\xa2\xdf\xec\xd1\x69\x82\x2e\x2b\xb8\x38\x5f\xb9\x21\x97\xd5\xc6\x8b\x5c\xc5\xad\x5b\x06\x06\x45\xb5\x80\xe1\x77\x83\x43\xe6\x7b\x09\xeb\x78\x6f\x49\x55\xb7\x11\xd8\x6c\x4d\xea\xd3\x4d\x89\x4a\xc4\x24\xdb\x00\x51\x87\x16\x70\xdb\x97\x68\x84\x96\x70\x5e\x78\xe0\x0b\x08\x52\x36\xb6\x79\x98\xb6\x8b\xd1\x69\x5d\xb1\x5d\xcf\x71\x49\x2d\xb0\xdd\xe0\x28\xf6\xd6\x9b\x6d\x12\xe6\xc5\x65\xf4\xde\x96\x70\x3b\x94\xed\x06\x16\x71\xfb\x58\xfc\x16\x70\x68\xd3\x7a\xb0\xc3\x3e\x67\x09\x7a\x44\x8d\x52\xe9\x25\x98\x17\x9b\x61\xdb\x6a\x6b\x2e\x0d\x29\xd2\xdb\xe2\x63\x3f\xe8\xe5\xb1\x15\x1f\x7b\x92\x40\xa2\xed\xe3\xa4\x8d\xdf\x42\xec\x8e\xa5\x26\x76\xf7\x12\xa3\x92\xd3\xba\x63\x31\x8c\xf6\x17\x76\x79\x8c\x49\xb9\x1e\xbb\x35\x6a\x3d\xa9\x1e\x44\xf7\x29\xa8\x1a\xb2\xa0\x97\x2c\x78\xef\x78\x4b\x4a\xfb\x0e\x75\x90\x6e\x3a\x03\xf4\xd6\x71\xb7\xbb\xcb\x27\x99\xbf\x8f\x04\x93\x04\xa0\x99\xb3\x0e\x8c\xb4\xa4\xc7\xb1\x3b\x62\x53\x85\xe2\x53\x00\x74\x41\x82\x76\x5e\x82\x4e\x32\x31\x45\x5e\x76\x14\x70\xd2\xe7\xdb\x09\xdc\x2f\x24\x06\xce\xcb\x09\xdc\xe8\x6c\x08\xd9\x99\x55\x9c\xf6\x83\xf7\x5e\x4c\xae\xdc\xb4\xb2\x3d\xc5\x13\x16\x77\xd2\x19\xc9\xdb\x13\xdd\xcd\x3d\x0b\xfa\xb5\xa5\x01\xa8\x8b\xb8\x82\xb6\xa4\xf7\xd3\x7b\x2f\x3d\x86\xb7\xa5\x26\xf7\xc3\xfb\x4d\x10\x82\x26\xe1\x09\xec\x51\xf9\xf0\x53\x0b\x34\x62\x37\x57\x77\xb4\xc0\xef\xf7\x73\x54\x4a\xe4\xf7\x07\xdc\x67\xb8\x2b\x24\x3e\x78\x44\x43\xab\xbb\x4e\xb6\xa7\x4c\x24\x02\x0e\x7b\x8e\x46\x44\x95\xb4\xc3\xb0\x2f\x62\xc4\x78\xd2\x49\xc2\x44\x6c\x86\xb3\x0b\x89\x29\x67\x18\x5a\x32\x20\xec\x01\x32\x51\x73\xe3\xb2\x99\xd3\x14\x92\xa9\xb2\x07\x2f\x55\xee\x2a\x9d\x03\xe3\xdd\x06\x12\xc9\xd0\x30\x0a\x18\x7c\xfd\x25\x68\x1e\x7b\xf3\xc3\xa0\x1b\x52\x7d\x1e\xbc\x28\x9d\x81\x34\xf7\x87\xcd\x7d\xdf\x6f\x1f\x36\xfe\xa4\x62\x38\x6c\x67\x82\x47\x63\xd0\x9c\xd5\x7d\x53\xd8\xe4\xe6\xf8\xb0\x7f\x80\xa5\x24\xeb\x70\x88\xc2\x4b\x35\x57\xa4\x7e\x38\x1c\xa3\x20\x16\x6d\x4a\x0e\xfc\x1e\x06\x19\xbc\x6c\x12\x83\x6a\x48\xb6\x67\x28\x65\xbb\x34\x05\x22\x6a\x7f\xe6\x38\xbd\x2f\x3e\xa0\x5e\x7a\x77\x60\x5a\xae\xc6\x9a\x49\x20\x44\xad\x93\xe4\x40\x1c\x51\x92\x8c\xee\x6a\x72\x3e\x8f\x0c\xb5\xac\xab\xfb\x62\xa1\xf1\x47\x2f\x3f\x7d\x97\x8a\x8b\x1c\xd7\xa8\x90\x1b\xdd\xd2\x03\x7a\xdc\x84\x4d\x04\xad\xec\x8e\x18\x18\x5c\xf0\x94\x8f\xbb\xf9\xe6\x36\x81\xda\x47\x9f\x5a\xea\xd7\x61\xb6\xd8\x48\xc8\xf1\x61\x95\x55\xb1\xe0\x63\x2a\x59\x92\xc7\xa3\x4b\x22\xbc\xf8\xf4\x6d\x2a\x4e\x72\x44\xcf\xc7\x0c\x3b\x95\x41\x03\xd2\xa3\x8f\x6e\x34\xc0\xcc\x71\x30\xb4\xc1\x3f\x7a\xe1\xa9\xcb\x92\x1e\x3f\xee\x45\xa7\xe8\x95\xaa\xb5\x21\xc5\x8b\xe3\xfe\x1e\x14\xb9\x95\xab\xd0\x3d\x06\xe3\x64\x25\x05\x77\xe4\x14\x70\x0c\x27\xf3\xb6\xcc\x74\xda\xdb\xe2\x9b\x19\x2e\xe5\xbb\xf1\xed\x0c\x46\xeb\x12\xbe\x9b\x81\x52\x9a\x84\xef\x63\xe7\xcd\xbb\x9d\xc9\x0f\x1f\x08\x70\xba\x37\x54\x18\x31\xd1\x58\x2a\x84\x98\x6c\xb2\x97\xa8\x93\xd2\x05\x3d\xdc\x5e\xa0\xae\x06\x5a\xfa\x14\x80\x97\x18\x7e\xb2\x67\x52\x7a\x38\x6e\xc8\xa6\x93\x1a\x02\x51\xa0\xf8\x18\x09\x95\xe0\xf4\xd6\xb0\x60\x33\x43\x9a\x08\x24\x16\x18\x6a\x36\x3a\x0c\xcf\x28\xda\xbd\x05\x7a\x5b\x21\x5e\xd0\x03\xe1\x41\x2f\x3e\xa1\x92\x26\x0b\xf8\x86\x08\xa5\x7b\x72\x75\x09\xdf\x86\x4a\x71\xda\xb7\x15\x28\xea\xfd\x2c\x98\x60\x85\xb4\x56\x27\x5a\x19\x5c\xb2\xee\x36\x53\x28\x52\x81\xa5\x17\xa5\xd8\xe2\x66\xbb\x03\x23\x94\x24\xa5\x45\x78\xd1\xb6\x7c\x7e\xe4\x50\x29\xdd\x75\xb7\x44\xc5\xfb\x58\xef\x92\x08\x2f\xdc\x2d\xbf\x48\xa1\x67\xa3\x6a\x60\xa2\x9d\xcc\xfd\x1b\xba\xcf\x51\x90\x2b\xeb\x49\xa5\x21\x78\x04\xd1\x34\xa4\x40\xfb\x6e\xe4\x19\x5c\x6d\x74\x7f\x22\x05\x59\x08\xd4\xae\x25\x18\x25\x69\x9b\x23\x82\xb4\x17\xb4\x8b\x2e\x20\x38\xc6\x74\x94\xb2\x0c\x66\xb6\xa7\x75\x78\x89\x4e\xbe\x6c\x1d\x18\xa0\x03\x56\x65\xfe\x00\x5a\x98\x8d\xd2\x8b\xdb\x49\xeb\x93\x82\x29\xac\xb0\x80\xde\x7c\x40\x93\x30\xdc\x00\xe8\x96\x76\xfe\x4a\xf4\xff\xb9\x01\x97\x54\x40\xe5\x3e\x46\xd1\x1a\xad\x3c\xc4\x98\x94\x42\x2d\x8f\x31\x2a\xa9\x49\x4b\x8c\x35\x68\xd5\x37\x2d\xdd\xb5\x60\x66\xad\x36\x6e\x6e\x21\x87\x14\xb2\x0c\x06\xae\xb4\x99\x75\xf6\xe9\x9e\x08\x96\x96\x87\x32\x2a\x39\xd7\x59\x63\x12\x4f\x14\xc3\x2d\xa7\x3f\x7c\xa5\x30\xf0\x32\x77\x37\x49\x8c\x97\x36\x7f\xf4\x13\x8d\xee\x93\x5f\x0c\xa4\x0e\x00\x3c\xb0\x81\x53\x38\xf3\x1b\x0b\x9c\xf8\x05\xc8\x75\x08\x5e\x0a\x4b\x6e\xeb\x42\x3f\x44\x2c\x1c\x17\xb5\x6e\x20\x61\x1f\x60\xbe\x1f\xa5\xb5\x12\x3c\xec\x1d\x12\xa8\xdd\x5d\x37\xd7\x33\x25\xa4\x69\x83\x02\xa8\xec\xa4\x83\x86\x93\xf2\x09\x5e\x3e\xfb\xa6\x30\xa0\x14\x19\x11\x87\x23\x2a\x63\xeb\x1e\xce\x76\x65\x17\x0f\xc7\xbc\x54\x50\x6f\xa7\xda\x15\xbd\x2a\x12\x9d\x2a\x42\xac\xa4\xe6\x2d\x7d\x7e\x0d\x22\xb2\x5a\x8b\x47\x96\x50\xc6\xc8\xb4\x0b\x0f\x5e\x02\x07\xcb\x9a\x35\x24\xa4\xba\xc7\x58\x5d\xad\xad\x48\xc8\x69\x85\x27\xc8\xbd\x74\x29\xf3\x5f\xe5\x77\xf7\x31\xe1\x84\xe2\xa6\x55\x57\x15\xd0\x75\x6c\x82\xdd\x55\x60\x48\xad\x55\xc5\x07\xc7\xe3\x09\x11\xf9\xad\x0a\xb7\x15\xbd\x54\x23\x85\x94\x46\x79\xd9\xa9\xb5\xed\xa4\xe3\x89\x76\x57\xe8\x09\x36\x45\xaf\x78\x2b\xe8\xa6\x7b\xf9\x69\xa0\x3c\x4b\x52\x50\x2b\x8c\x6a\x0c\xb2\x02\x26\xfb\x42\x47\x49\xaa\x02\xc7\x91\x5e\x6b\x95\x97\x93\x7a\xc1\x44\x54\x78\xbc\xb3\x6c\x49\x2a\x8c\x9e\xb6\xa7\xd1\x05\xed\x8b\xb4\x3f\xcc\x90\x8f\x32\x03\xa7\xb4\x38\x43\x72\xca\x0c\x4d\x5a\x0f\x86\x2c\x95\x19\x34\x61\x8e\x18\x92\x55\x26\x70\xb2\xad\x9b\x18\x95\x6e\xe4\x36\x86\x25\x5a\xb7\x9b\xb7\x2e\xd1\x2c\x2f\x48\x25\xd8\x33\x7d\x32\xc2\x90\xc3\xa2\x78\x97\x42\x1c\x23\xd7\x85\x6e\x30\x47\x9b\x5e\x0c\xe2\x1f\x6f\xbc\x9f\xee\xe9\x64\x49\x24\xb7\xa4\x63\xed\x0c\xf9\x2d\xbf\xf6\xda\x2d\x8c\x6d\x19\xa3\xd2\x63\x8b\xf1\x8c\x4e\xb6\x2d\x29\xc9\x0c\xc9\x2b\xc9\xa8\x31\x43\xe6\xca\x18\x47\x37\xd0\xa9\xdb\xdc\x53\xbd\x27\xcc\x8b\xe5\xb3\x30\x08\xbd\x13\x61\xc8\x62\xc1\x18\x22\x89\xd9\xcc\x31\x1d\xd0\xb1\x10\x86\x7c\x16\xdb\xa4\x08\x2d\x0c\xd9\x28\x95\xd1\xd7\x54\x2d\x41\x89\xd0\xb4\x1a\x86\xf4\x93\x13\x6f\xa0\x23\xb5\x3e\x43\xd2\xc9\x19\x6e\xa3\xd9\x4a\x54\x24\x82\x99\xa5\x75\x23\x43\xca\xc9\x88\x18\x0f\x6a\xc0\x00\xfd\x45\x3f\xd5\x0e\x4c\x23\x69\x86\x11\xcb\x71\xae\x69\x0a\x05\xcb\x3f\xcc\x74\xc6\x95\xfa\x30\xdb\x51\xe2\xbc\x78\x8e\x76\xcc\xc7\x08\x33\x68\x3a\x37\x93\x96\x7b\x56\xd5\xcf\x6b\xbe\xe7\x90\x03\x81\xd4\x16\xa5\xc5\x74\x00\x30\x6e\x70\x49\x24\x9a\x2f\x43\x2f\xf0\x7c\x7b\x1f\x84\xac\xd2\x24\x93\x83\x21\xbb\xa5\x6f\xa3\xfd\xed\x53\xd8\x00\x67\x85\xd1\x67\x32\xda\xcd\x90\xf0\x82\xe7\x7e\x24\xc6\x0b\xa1\x6c\x2b\xba\xb3\x1f\x4f\x75\x48\x18\xc6\x52\xfb\x0e\x8c\x15\x46\x76\xe4\x12\x43\xe6\x8b\xed\x8b\x05\x90\x17\x45\x30\x9c\xa6\x07\x32\x24\xc0\x74\xfd\xd7\xaf\x83\xda\x93\x40\xda\x60\x86\x24\x98\x46\x0e\x33\x90\x88\x4a\x32\xe4\xb9\xdc\x51\xc9\x23\x21\x86\x9c\x17\x5b\x4b\x20\x59\x2f\x6c\xfd\x70\xa0\x43\xcb\x10\x32\x5f\x2a\x69\x20\x83\x77\x27\xdb\x53\x2f\x6d\x4d\x77\x17\xf9\x2f\x46\x8b\x33\x6d\x07\xd6\xe1\x70\xe7\x5d\x94\xe4\x04\xad\x1f\x0e\x77\x96\x83\x5d\x6c\xbd\x27\xe1\x49\xed\x8e\x3c\x98\x07\x3c\x6d\x42\x91\x0b\xf3\x00\x4e\xd9\x52\xa4\xc6\xd4\xae\x51\x5b\x12\x80\xb6\xcc\xda\x35\x99\x8f\xa7\x3e\xad\xa8\x35\x3d\xc2\x65\x58\x63\x5a\x9c\x53\x06\x02\xd9\x2d\x45\xaf\x94\xa5\x0f\x16\x19\xf2\x5b\x40\x29\xd9\x59\x49\x9f\x1f\x31\xe4\xb7\x04\x14\x75\x12\xc5\x90\xe3\x62\xec\x82\xd3\xc6\x90\xe9\x12\x71\x06\x49\x18\x92\xa8\x64\x4a\x88\x36\x33\x7a\xc2\xc2\x07\x77\x1f\x71\xb4\x94\x23\xa7\x45\xc1\x05\x54\x42\x18\x90\xce\x32\x61\x52\x32\xb0\xb9\x8b\x8c\x58\x38\x07\x63\x81\xcf\x12\xd3\x7c\x48\x60\xd8\x81\x45\xe7\x30\x4b\x78\x0c\x17\x44\xa4\x20\x12\x57\x86\x4d\x6d\x47\x13\xb9\x19\xf2\x5d\x9c\x3e\x3d\xb8\x90\x4f\xf7\x70\x08\x0e\x6b\x72\x44\x90\x0d\xe3\x6b\x99\xc7\x21\x1e\xea\xa0\x47\x1e\x79\x32\xbe\x86\x0f\x1c\xd2\x87\x4a\x92\x6b\x1f\xe9\x34\xd0\x9b\xd9\x29\x28\xf4\xe4\x5a\x43\x56\xcd\xa9\xa0\x5b\xe5\xe5\xb4\xd4\x4a\xcd\xc9\xc7\xbd\x25\x15\x2e\xb2\x6a\x4c\xdf\xc1\xcc\xf9\x95\x2d\xfd\x7d\xd4\x84\xed\xdc\x79\x6c\x8a\xf8\xcf\x1b\xcc\x26\xe5\x4b\x47\x3a\x96\xc8\xc0\x31\xfd\x3d\xb8\x38\xd5\xa6\x3f\xa4\x90\x27\x44\x0c\xb9\x39\xd7\x79\xd0\xf5\x6c\x48\x87\x02\xe9\x39\x85\x74\x42\xcf\x83\xdf\x85\xa3\xa2\x4e\x6c\xcb\xef\xdb\x63\x32\xbf\x78\xd8\x3e\x93\xa0\x38\x56\xc6\x55\x57\xf3\x44\x90\x8b\x6d\xcb\x0f\xc8\x44\x18\x8d\x21\x55\x67\x82\x36\xba\x6f\x53\xa1\x33\x86\x7c\x9d\x18\x9a\xaa\x16\x49\x3b\x23\xb6\xed\x1b\x30\x52\x24\xeb\xcd\x09\x6c\xb2\x62\x24\xab\x4e\xe7\xd3\xf4\x9a\x42\xbe\x8e\x07\xa5\x16\x2f\x92\x76\x6e\xba\x77\x7d\xb1\xa4\x4f\x90\xba\xe3\x91\x24\xc4\x0b\xe1\xfb\x9d\xa3\x32\xcf\x3f\xdc\xf3\x97\xbe\x74\x9c\xb7\x29\x41\x09\x64\xc8\xdc\x29\x8d\xee\x68\x1a\x3b\xdb\x85\x08\x3e\x17\xe7\x4c\x5f\xc0\x54\x8a\xf6\x90\x91\xc6\x23\x5b\xeb\xf8\xc9\x70\x8a\xdd\xc2\x76\x61\xe7\x21\xc5\x99\x5c\xd3\x48\xe7\xe1\xb4\xf3\x83\x44\x9e\x42\xba\xa2\x4f\x99\x3f\xa4\xea\x04\xd0\xc2\x58\x21\x6b\xc7\xf5\x4d\xa1\xc8\x16\x21\x67\x67\x42\x2c\x55\xb5\xc1\xdd\x44\x7b\x5a\x66\x91\x31\xa4\xf0\x44\x50\x5a\x0a\x91\xc9\x13\x01\x53\x8e\x1e\xd2\x79\x22\x68\x52\xd1\x23\xa5\x87\x77\x1d\xad\x4c\x90\xd0\x73\x95\x6d\x49\xd3\x5c\x19\x52\x79\x78\x5b\x1a\x2d\x49\x85\xbe\xbf\x73\x2e\x7a\x52\xbc\x90\xc5\x53\x1a\x59\x14\xf4\xa9\x0e\x43\x16\x8f\x3d\xdf\xc8\x10\x26\x43\x0a\x4f\xa5\x7b\x93\x9e\x9d\x40\xd6\x31\xa0\x14\xe9\xe3\x04\x92\x0e\x34\x9c\x6e\x0a\x72\x73\x92\xf9\xeb\x10\x9d\x70\x72\x66\xc6\x4f\x86\x3b\xd9\xd1\xcb\x10\xa9\x3a\xb6\x4f\xc4\x0e\x0e\xe1\xbc\x27\xc1\xd7\x60\x87\x40\x4a\x16\xb5\xbc\xd0\x6d\xdb\xa3\xcb\x4b\xaa\x16\xa4\xe2\x5c\xc8\x9d\x2b\x72\x70\xae\x20\x0b\xba\x01\x5e\x18\x0c\xb4\x86\xde\xc2\x1e\x02\xff\xf8\x04\x4a\xd2\xb7\x44\xd8\x41\xc4\xea\x66\x21\xa6\xce\x0e\x31\xb7\xeb\x7e\x5b\x27\x29\xf1\x07\x20\xf1\xa9\xc5\x74\x9c\xfb\x64\x8f\x47\x33\x0f\x0e\x55\xb2\x16\x86\x1e\x90\x5b\x0c\xcf\x21\x67\xe7\x5a\x03\x28\x51\x73\x49\x2a\x22\xe4\xed\x5c\x64\x03\x7a\x41\x0f\x21\x79\xc7\xf5\xe6\x2c\x6d\x9d\x29\x19\x6e\x0a\x4c\x07\x3e\x64\xf8\x9d\x21\xa5\x27\x8a\x2c\x27\x5a\x8b\xe7\xd6\x1d\x17\x90\xd9\xba\x77\x8e\x5e\x0e\x48\xed\xb1\x8a\xa6\x50\x31\xe4\xf4\x84\x5b\x8c\x0b\x9d\x42\x09\xd4\xa6\x4c\xb1\x63\x19\xd2\x78\x74\x07\x2d\xad\x91\x8e\xc5\xdd\x4a\x49\xd7\x47\x41\x10\x7f\x1c\x3e\x8f\xcb\xf4\xad\xbc\x80\xb1\xd2\xd1\x23\x26\x70\x5d\x1a\xc7\x4d\xf6\xe1\x64\xed\x64\x78\xd9\x7b\xfa\x2c\x79\x7c\xc5\x90\x0c\x74\xe3\xb5\xa6\xc7\xda\x8b\xed\x74\x22\x4c\x21\x90\xff\x63\xa0\x2c\xc9\xd3\x09\x86\xec\x9f\x09\xb1\x30\xc6\x3c\x84\xda\x06\x53\x07\x7d\xb7\xc4\xfb\x65\xc8\x06\x8a\xd0\x24\x0c\x77\x01\xa0\xa4\x90\x9a\x3c\xd1\x66\x48\x05\x2a\xe5\x89\xd4\x4e\xc8\x02\xea\x24\x94\x59\x27\x3b\x30\x59\x47\x0e\x28\xf2\x80\x22\x60\x22\x04\x80\x24\xa0\xd2\xf4\x1d\x1d\xd8\x44\xe2\xcf\x17\xad\x1b\xf2\x64\x91\x21\xdf\x47\xf1\xf6\xd4\x73\x5a\x51\x21\xcd\xa7\xe2\xa4\x05\x44\x92\x0f\x9e\x66\x91\x18\xdc\x89\xd6\x92\x8e\x54\x21\xcd\xa7\xe3\xa4\x6b\x86\x1c\x1f\xdb\x69\x7a\x8e\x90\xdf\x23\x12\x7e\x29\x32\x7b\x86\x7c\x72\xfe\x0a\x2f\x0b\x05\xd4\x89\x53\x34\x56\x6c\x66\x90\x05\x31\x2c\xc2\xa5\x63\xa0\xbd\xc8\x62\x17\x01\x96\x2a\xc2\x3d\x1d\x88\x5b\x42\x88\x0b\x74\x84\x7a\xa7\x67\x47\x2c\xa8\xe6\xc9\x42\x81\xee\x30\xdb\x68\x3a\xfe\x2e\x49\x38\x0f\x9e\x07\xdd\x86\x22\x4c\x4f\xe2\xce\x19\x2b\xd0\x4f\x82\x8b\xe4\xad\xa3\xf9\xc8\xac\x08\x5b\xb6\xbe\x2d\x53\x14\x29\x56\x78\x61\x29\xb9\xe3\x05\x7d\xe2\xcb\x90\x98\x35\xee\x25\xbb\x32\x11\x3e\x47\x36\xd6\x88\x1a\x14\x73\x02\x96\x47\x30\x78\x17\x40\x1f\xc6\x32\xb1\x8e\x3f\xaa\xaf\x60\x3a\x2d\x13\x94\x03\x86\xa4\xac\xca\x9f\x96\x39\x3d\x27\x6e\x4f\xe9\x0f\x37\xdc\xee\x39\xe3\x65\xb8\x44\xcd\xf1\x31\xf4\x57\xd9\x11\xa5\xbd\x9b\x95\x28\xbf\x8b\xca\x8f\x53\x41\xd5\xd0\x97\x52\x27\xca\xef\xa3\xf2\x8d\xbe\x48\xaa\xfd\xd3\x2d\x40\xba\xfc\x21\x2a\x3f\x9e\x47\xd0\xb0\x23\x7a\x13\x74\x2c\x5d\x04\xb2\x4e\x09\x34\x07\x9f\x21\xbd\xeb\x8b\xad\xc6\x87\x19\x48\x8c\xc0\x2d\x40\x05\x59\xa1\xfb\x59\xa4\x66\x4a\xec\xf5\xc7\x44\xcb\x2f\x73\xa2\x9a\xed\xbb\xee\xce\xff\xb9\x03\x4d\x42\x67\x22\x59\x2c\x78\x7a\xad\x76\x24\x89\x92\x21\x6b\x6c\xee\x24\x19\xb0\xd2\xba\x48\x99\xf9\xd4\x82\x64\xd8\x30\x64\x96\xcd\x6f\x58\x42\xd3\xd1\x97\x5a\x58\x79\xa7\x73\x2f\x28\xb0\xf2\x7e\xda\x49\x66\xfb\x05\x73\xcb\x84\x6e\x0a\xd9\x72\xa7\x1f\xf6\xa7\x53\x00\x4c\x10\x89\x35\x17\x67\x30\x59\x0b\xf4\xe6\xae\x0c\x17\x75\x5b\x01\xd3\x53\x6a\xb4\xe3\x8f\x5c\xb4\x5f\x7f\x25\x73\x77\xb8\x6f\x10\x35\x9f\x4d\xde\x15\xe4\x3b\xc9\x8a\x62\x48\x4b\xb3\xd0\xce\xbc\xa9\x91\x4b\x99\xbc\x7e\xc3\x90\xa9\x36\x14\x9b\x2f\x98\xa8\x20\xbd\x14\x90\xbe\x56\x4b\xeb\x34\xed\x1c\x07\xea\xda\x24\x4e\xae\x4e\xb4\xdd\xaf\x88\x1a\x38\x7d\xbd\x85\x21\x59\xad\xe3\x86\x9f\x0c\xef\x48\x91\x0c\xbc\x34\x25\x4b\x9a\x3a\xcb\x90\x83\x36\x45\xb1\x13\x3e\x0e\x92\xd0\x02\x68\x41\xd6\x20\xdc\x01\x6f\xc8\xf0\x26\x84\x08\x9b\x10\x60\xb2\x82\x47\x5c\xa0\x49\x2f\xf5\xae\xd0\x09\xd5\x8e\x04\x34\x47\x3b\xd2\x48\x32\x2b\x64\xab\x45\xaf\x68\x4e\x2a\x83\xfb\x06\x85\x5c\xf2\xc8\x2f\x1b\x47\x2d\x75\x0f\x8f\x21\xa9\xcc\x5d\x65\x42\x21\x20\xa7\xec\x06\x8a\xf4\x31\x91\x4f\x36\xac\x9d\x49\xb6\xe8\x3e\x73\x0c\xa1\x54\xa4\x5b\x80\xcc\x31\xc1\xd5\xd0\x67\x47\x9f\x67\x41\x90\x97\x5b\xc2\x4d\x45\xce\x98\x27\x8d\x5e\xb9\x4a\x50\x4c\x90\x34\x26\x44\x76\x91\x96\x74\x68\x91\x34\x26\x44\xd6\x8c\x37\x04\x13\xb7\x18\x18\xd2\xc6\x84\xc8\x4a\x69\x85\xbe\xd0\xd2\x8e\xcc\x31\x21\x32\xde\x00\xe9\x00\x87\xbb\x07\x62\xa1\x8f\x81\x3d\x26\x46\x2e\x31\x1d\x07\x42\xfe\xd8\x48\x53\x4b\x9e\xfb\x06\xfa\x58\x40\xd1\xd3\x87\x04\xb2\xf1\x25\x14\x12\x80\x07\xa5\xba\xbb\x25\xc3\x0e\xc8\x1d\x23\x5f\xf0\x60\xc8\x1b\x83\x1b\x94\x46\x77\x5d\x62\x10\x43\xe4\x64\xf0\x86\x0a\xd3\x27\xda\x83\x3b\x09\x69\x5c\x5d\xf2\x5b\x26\xf8\x99\x1e\xa7\x10\x3a\x01\x9e\xbc\xdc\xc6\x90\x41\xd6\x49\x48\x82\xf2\x97\x3b\xcb\x75\x09\x85\xaf\x90\x70\xeb\x2a\xca\xa3\xcf\x91\x28\x36\x21\xd2\x5a\x2a\x47\x92\x98\x8f\xcb\xd0\xcf\x88\xe4\x48\x12\x43\x14\xa5\xab\x73\xa4\x88\x15\x32\xb5\x3b\xc8\x5f\x02\xd5\x90\x52\x48\x39\x52\xc3\xa4\x7e\xaf\x35\xc9\x15\xcf\x91\x1a\xc6\xdb\x13\xa8\xc4\x8b\x11\x39\xb2\xc3\x04\x75\x5a\x91\x23\x33\xcc\xd6\x70\x86\x39\xbb\xa5\x86\x5f\xe7\x29\x52\xd1\x0d\xf5\x12\xd4\x00\x6f\x3b\x4e\x3e\xba\x91\xbf\x84\x8d\xe8\xcd\x82\x52\xbc\xa4\x6b\x0a\x87\xa2\x6d\x0b\xc2\x95\x30\x06\x6e\x48\x64\xd8\x66\xd8\x3a\xb1\xaf\xcc\x59\x78\x97\xc4\xf4\x4d\x41\xee\x8e\x72\x24\x8a\xa9\xa1\xed\xe4\xc9\x5b\x8e\xa4\xb0\xa1\xdd\x96\x32\x30\x39\x12\xc2\x6c\x2d\x8d\xb3\xb2\x2d\x7a\x45\x05\xa4\x72\x24\x85\x59\xd9\x74\xea\x36\xec\xc9\xc9\x09\x0b\x94\xb0\xf3\x8d\x3b\xc5\xc9\x91\x62\x77\x0e\xbe\x4b\x31\xf9\x73\xb6\x8f\x40\x8b\x47\x06\x79\x78\xf1\x48\xf2\x46\x93\x17\xc8\x73\x16\x6e\xe1\x92\x17\x4e\x72\xa4\x98\x8d\xac\x61\x0b\xc2\x90\x76\x22\x47\x9a\x59\xa3\x9d\x36\xc9\xb5\xc1\x42\xa8\xd6\x00\xb8\xec\x22\x81\x8a\x3d\xe4\xc8\x35\x1b\x6f\x6f\x16\xf4\x4b\x46\x39\xd2\xcc\x2e\x40\xdf\x5a\xcf\xef\x1c\x32\xd2\x35\xc8\x91\x24\xd6\x80\x11\x3d\xe9\xc1\xe5\xc8\xf5\x1a\x2f\x6d\xd8\x60\x8b\x7c\x44\x94\xb7\xf6\x34\x3e\xd8\x4b\x16\xdd\x04\x53\x80\xb0\x84\xc7\x95\x87\x67\x8e\x86\x9e\x78\xc6\x2b\x89\xdb\xdd\x3b\xb4\x04\xdb\xc7\xd5\x25\x7b\x7f\x88\x2a\xb3\xce\x68\x52\xef\xe7\x48\x00\x8b\x60\x24\x5b\x25\x47\x0a\x58\x0c\x24\x75\x06\x92\xc0\x5a\xe8\xe9\xeb\x03\x39\x32\xc0\xa6\x51\x53\x74\xdc\x36\x47\x16\x58\xb8\xb8\xa9\xab\x4a\x0a\x49\xfa\x02\x39\x92\xbc\xee\xd7\x6f\x48\x61\x47\x7e\xd7\xb5\xe6\xce\x72\x32\x5a\x98\xaf\x83\xe2\x30\xb4\x03\x93\x23\xbb\x6b\x5c\x32\xa9\x55\x8c\xac\xae\x11\x94\x7a\x1f\x2e\x47\x66\x57\xad\xdd\x5c\x69\x17\x24\xf7\x32\x47\x9e\xd7\x45\xf2\x88\x21\x30\x87\xdc\x7d\x94\x04\x00\x37\x45\x7d\x71\x25\x0f\x9f\xf2\xf5\x9d\xdc\x2e\x7b\xd2\x36\x23\x69\xeb\x26\x66\x9b\xca\x68\xcf\x49\x96\xf2\xa2\xa1\x3b\x27\xdb\xac\xd1\xad\x4d\x48\x08\x52\xba\x74\x07\x6d\xe2\xd5\x80\x7c\x1d\xae\x5a\x77\x50\x4a\x07\xa5\xb5\xb4\x68\x84\xcb\xfc\xce\x81\xb9\x65\x9b\xd9\x30\x4f\x89\x44\x52\x4c\x1b\x9d\xd5\x87\x14\x30\xc4\xad\xa9\xc2\xae\x36\x00\xd9\xe0\xb1\x38\x7a\xaf\x96\x23\x47\x0c\x4b\xe4\x54\x35\x89\xeb\xef\x39\x52\xc7\x10\xc7\xa8\xc2\xfe\xeb\x64\xf9\xf5\xbc\xfc\x0b\x55\x3e\xa6\xd4\xce\x4b\x6f\xd0\x16\xf4\x16\xb2\x31\x1e\x97\xf8\x8c\x97\x6e\x99\x89\xde\x58\x5a\x26\x90\x6e\xa6\x8b\x2f\x20\xdc\xec\x9e\xe8\x1c\xb7\x9f\xe1\xfa\x36\x8d\x0c\x0f\x08\x48\x71\xbe\x65\xad\x26\x2f\x2e\xe7\xc8\x39\x8b\x60\xa4\xd3\x9f\x23\xe9\x4c\x88\xec\x8b\x20\x7d\x0d\x64\x9b\x8d\x1b\x9f\x16\x8c\xcd\x84\xa2\xbd\x92\xcd\xfd\xd6\x0f\x19\xb1\xc8\x37\xe1\x01\x1c\x35\x45\xc4\x05\x7d\xac\x9c\x23\xcd\xac\xd6\xbd\x19\x1f\x15\xa5\x1b\x8f\x3c\xb2\x3b\x6c\x26\x2b\xf7\x64\x9b\x08\x20\xe7\xc8\x23\xbb\x43\x73\xba\x86\x94\xb0\x22\x81\xec\x8e\x5c\xd3\x15\x00\xed\xc1\x20\xa3\x2c\x00\x49\x50\x7c\xbd\xfc\x64\x78\x31\x8f\x43\x8c\xc9\x26\xf5\xb2\x64\xbe\x8d\x6f\x9d\x5b\xa7\x3b\xa2\x74\x7a\x57\x9f\x6f\xe3\xfb\xe8\x78\x6b\x38\x01\xdd\x47\x50\x25\xbf\xa6\x18\xfb\x39\x32\xc7\xa6\x3a\xbb\x74\xd3\x8f\x11\xce\xaf\xc5\x04\x92\xc7\x48\xe0\x22\x21\xef\xe1\x5d\x27\xc3\x4b\x48\x3c\x40\x98\x6f\xc3\xe3\xa8\x27\x39\x68\x71\xda\x5c\x21\x5f\x4c\x18\x18\x5f\xfd\x1d\x2f\x03\x6a\xf2\x96\x67\x8e\x84\x31\xf2\xb0\x2f\x47\x8e\xd8\xe9\x94\x3e\x7d\xcc\x91\x1c\xe6\x8c\xec\x78\x79\x91\x09\x95\x83\xbc\x30\x5d\xb6\xfa\x3c\x08\x54\x2b\xcf\x54\x34\x26\x47\x4e\xd8\x0c\xb8\xb0\x11\xdd\x85\xf7\x55\x5c\xd6\xa5\xd8\xdc\x39\xb2\xc3\xae\xf2\x2c\x07\xd3\xc5\x33\xd2\x49\xde\x85\x9b\xe0\x15\x37\x74\xf3\x02\x8b\xdb\xd0\xcf\xae\xe6\xbb\x10\xf6\x37\x50\x91\x64\xae\x1c\x79\x61\xba\xa3\xdf\x0e\xcc\x91\x10\x36\x4a\x56\x0b\x6e\x30\xb8\x4a\x1b\x5a\xe3\x23\x35\xcc\x5d\x66\xae\x34\x28\xb8\x48\x4b\x5f\x2e\xc8\x91\x24\x36\xa4\x71\x52\x22\x91\x21\xb6\x7d\x79\xe9\xe8\x4e\x20\x91\xa3\xe1\x5f\xe9\x8f\x20\x47\x2c\xf0\xf6\x47\x46\x03\xf9\x35\x64\x8a\x05\xe8\xc4\x84\xa6\xb1\x8f\xd7\x01\xa6\xc7\xd0\x68\xec\xfa\x01\x3b\xb1\x9d\x69\xec\x06\x07\xbd\xec\x2d\xcd\xcd\xc8\xef\x4f\x3e\x75\x83\xdf\x4b\x42\x76\x77\x88\x95\x27\x7a\xe1\x21\x47\x6c\x00\xd1\x8d\x09\x5b\x09\xd2\xde\x22\x2d\xcc\x5f\xf4\xa5\xcf\x5e\xf2\x3d\x7f\x44\x25\x3e\x56\x04\x6d\xff\xf5\x2b\x09\x08\x6f\x5e\x36\x40\xd7\x80\x26\x54\x71\x71\xce\x9c\x24\x57\xc6\x9d\x1f\xd6\x3a\x29\x12\x2a\xe9\x30\xa3\x51\x64\x5c\x49\xf2\xcc\x2b\x47\x92\x18\x94\xe4\x71\x7f\x1e\x9e\x6f\xba\xbf\x02\x93\xda\x2b\x22\x5b\x4c\xe8\x52\x42\x47\xb7\xfd\x10\xfc\xaf\x92\x5c\x0d\x48\x0d\xab\x46\x3e\xed\xf4\x8b\x34\x24\x2e\x3c\xd3\x4d\xfa\x2a\x48\x0e\xeb\x8c\x2e\x7b\xe1\xb2\xba\x27\x9f\x1e\xcb\x91\x25\xd6\xc8\xf7\xd4\xf9\x72\x8e\x5c\x31\x2b\x8c\x2c\x68\x04\x52\xfb\xf9\xe0\x54\xa6\x75\xfc\xa1\xf8\x88\xa3\x25\xe9\x10\xbd\x5d\xb9\x54\x61\xf9\x01\x96\xa8\x2f\x9c\xae\xf8\xf7\xcc\x0a\xf2\xfd\xdf\xfc\xf8\xf2\x01\x67\x13\xa6\x00\xb9\x60\x35\xb7\x35\xfd\x9a\x70\x8e\x34\xb0\x42\xf5\xe0\xb4\xa6\xe3\x74\xc8\x02\x0b\xa0\x8c\x9c\xd1\xf0\x82\x13\x18\x01\xf4\x64\x22\xe1\xeb\x24\x9d\xe2\x74\x25\x78\x7c\xd7\x15\x70\x4a\x5d\xf6\xcc\x91\xe6\x75\xed\x2a\x6d\x1a\x72\x75\x45\x44\x2f\x49\x9b\x1e\xe4\x77\x79\xc6\x15\x57\x19\x17\x22\x11\x2e\x40\x9a\xd7\x9d\x2e\x97\x5a\x62\x48\xf7\x7a\x78\x2f\x93\x9e\x74\xa4\x73\x15\x4a\xd2\xde\x29\xb2\xb5\xa6\xc3\xfb\x12\xa6\x8b\x6f\x09\x53\x87\xcc\x2d\xff\x46\xf5\x90\x65\xb4\x4a\xbe\xa8\x95\x87\x77\x9c\x0c\x97\x8a\x16\x5f\x24\x72\x71\x6b\xa5\x1d\x7d\x2c\x35\x38\x64\xed\xc8\x06\xbf\x59\x07\xf4\xe0\x23\xad\x8b\x5b\x35\x59\xf6\xce\x80\x7b\x78\x05\x91\x8f\x8c\x79\xde\x4e\x8f\x94\x21\x9f\x89\x82\xcf\xab\xc6\x87\x25\x80\x57\xed\x7d\xb6\xbc\x27\x3d\xf8\xbb\xd5\x18\xf9\x7b\xf8\x5a\x49\x3f\x05\x99\x23\x57\xec\xa4\x24\x79\x97\x34\x47\x9e\xd8\x08\xc8\xe8\x26\xa1\x2f\x25\x4f\x8f\x4f\x3d\xce\xfa\x46\x96\x0d\x14\xea\x6b\x96\x76\x62\x90\x39\x76\x91\xbc\xa4\xcd\x12\x3f\xc6\x88\x05\x2f\x12\x09\x64\xb6\xe5\x5d\x74\x42\x3e\xc7\x14\x73\x4c\x76\x4a\x1d\x36\x20\x97\x2c\x20\x17\x3e\x8c\xf7\x2e\x03\x4f\x8e\x44\x85\xe7\xa3\x8c\x75\x59\xfc\x78\xd0\x0c\x86\xfc\xb2\x9b\xe6\x74\xc3\x90\x5f\xe6\x6a\x68\x40\x5a\x5a\xba\xc3\xf3\x51\xd1\x53\x39\x33\x55\xfe\xf4\x98\xbb\x14\x25\x44\x46\x5a\x35\x63\x75\x8c\xbf\xdd\xb1\x60\x26\x8b\x68\x6b\x69\x6b\x7e\x4e\x68\x0a\x64\xa8\xdd\x7f\x7d\x83\x66\xc8\xe4\xc8\x54\x9b\x01\x13\x75\xa2\xec\xc9\x96\xbe\x48\x9d\x07\xae\x5a\x59\x1a\xb0\x36\xf5\xa8\x7c\x8e\xf4\xb4\x18\x97\xf8\xa6\x17\xbf\x8b\x78\x60\xae\x62\xd1\xc4\xf1\x6f\x8e\x94\xb5\xb1\xe0\x7c\x03\x1d\x17\x4d\x7c\x55\x44\xe1\xd2\xb4\xb1\x46\x36\x5b\x04\x4b\xd4\x17\x3f\x86\x42\x22\x90\xce\x26\xcb\xac\xe0\x09\xc7\x0d\xc9\x6c\xa5\x19\x0d\x50\xe6\x7f\x38\x32\xee\x9a\x2c\x93\x03\x82\x1c\xb7\x87\xd2\xf3\xa1\xf1\xe5\x13\x6d\x5c\xa3\xa9\xd2\xb4\x85\x0c\x8c\x37\x03\x9e\xd7\x25\x78\x43\x7a\xe9\xc8\x60\x1b\xf6\x62\x89\x9b\x38\xb9\x08\x4f\x79\x82\x69\xa6\xe7\x7f\xe6\xe1\xd2\x28\x23\x91\x9c\x0c\x9b\x8a\xfd\xc7\xba\xd7\xa9\x4a\xfe\x7d\xf8\x54\x1c\x3e\x56\x97\xa7\xaa\x4b\x45\xa6\xc4\xf1\x63\x25\x2c\x55\xc9\x42\x38\x55\xf0\x8f\xf5\xbc\xa4\xea\x49\x86\x55\xc3\xc3\x68\xb5\xbe\x26\xbe\x83\xce\x08\x77\xb5\xeb\x67\x3c\x53\xcb\xb6\xf1\x9f\x45\xe2\x40\x17\x19\x70\x9d\x2e\x45\x42\x2f\x23\xf5\x6d\xba\xe5\x93\x35\xfc\x5d\x36\xf2\x2b\xb9\x3c\x90\xe0\x86\x50\xd9\xa6\xa1\x6c\x06\x35\x60\x9d\xa6\xad\x50\x19\x9e\xfe\x1f\x76\xd2\x06\x84\x8b\x9f\x5f\x7e\x8a\x2a\x89\x7f\x86\x67\x5e\xc5\x9a\xac\x62\xbe\xf0\xe2\x4a\xe8\xd5\x87\x7c\xb7\x82\xb7\x65\x6a\x59\x21\xd5\xed\x64\x38\x79\x6c\x86\x64\x37\x70\xf4\x21\x34\x12\xdb\x64\x53\x92\xde\x36\x32\xd8\x0c\xbf\x80\xa2\xe3\x00\xc8\x54\x03\x30\xa9\x39\x45\xa6\xda\xf8\x06\x82\x48\x9c\x04\x97\xc1\xa7\xd0\xd7\x4a\x25\xed\x5c\x78\x59\xad\xef\xc0\x8c\x8c\x5c\x72\x81\x22\x5d\xed\xda\x2d\xc5\x8b\x90\xb1\xd6\x00\x38\x3a\x9a\x3f\xd2\xd5\xac\xc9\x74\xab\x6e\xc4\x4f\x79\xf9\xdf\xf0\xea\xde\xf1\x17\xc3\x86\x7f\xe2\x4f\x6c\xe2\x4f\x88\xbe\x66\x43\x6a\xb8\xa8\x58\xcb\xb2\x84\xf6\x6d\x7c\x82\x71\x10\x8e\x4f\x2f\x4f\x2b\xff\xdf\xcf\xf8\x2b\x9c\x2f\xe1\xa3\x59\xa5\x45\x6f\xc7\xe7\x05\xb9\x18\x1c\xec\x27\x22\x67\xfc\xd7\xbd\x79\xd6\x71\x27\x85\x6f\xdc\xf8\x53\xaf\xbe\x75\xe3\xbf\x7d\xa3\x5e\xee\x2d\x1a\xfc\xca\x42\xc1\xd4\xa4\x01\xf3\xfd\x0f\xff\x11\x00\x00\xff\xff\xdc\x38\xf5\x02\x18\x79\x00\x00") + +func uiAppLibFontAwesome470CssFontAwesomeMinCssBytes() ([]byte, error) { + return bindataRead( + _uiAppLibFontAwesome470CssFontAwesomeMinCss, + "ui/app/lib/font-awesome-4.7.0/css/font-awesome.min.css", + ) +} + +func uiAppLibFontAwesome470CssFontAwesomeMinCss() (*asset, error) { + bytes, err := uiAppLibFontAwesome470CssFontAwesomeMinCssBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "ui/app/lib/font-awesome-4.7.0/css/font-awesome.min.css", size: 31000, mode: os.FileMode(420), modTime: time.Unix(1, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _uiAppLibFontAwesome470FontsFontawesomeOtf = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x9c\xfa\x79\x7c\x93\xc5\xfa\x07\x0c\xcf\x34\xc9\x9d\x74\x26\x4b\x97\xa4\xd2\x26\x77\x02\xc8\xa2\xb2\xb5\xd9\xda\x0a\x28\x50\x16\x05\x41\xc4\x88\x2c\xc2\x4d\xda\xa6\x4d\x68\x9a\x84\x24\x5d\xa1\x74\x87\x42\xa0\xd0\x36\xa5\x94\x52\x5a\xa0\x2a\x9b\x2c\x82\xe0\x7a\xac\xc7\xa3\x22\xb8\x13\x3d\x8a\xfb\xf6\x73\x45\x3d\x1e\x74\xd2\x4c\x8a\xef\xe7\x4e\xc0\xa3\xef\xf3\xc7\xfb\x7e\x1e\x42\x73\x5d\x33\x99\xb9\xbe\x33\xd7\x5c\xdb\xe4\xce\xbd\x16\xcb\xbd\x00\x81\x3a\x20\x00\x23\xf3\xe6\xce\x1d\x99\xeb\xfb\x2a\x1b\x00\x70\x0c\xc0\xc8\x73\x73\x16\xcf\x5c\x02\x58\x70\x0b\x80\xd4\x09\x00\xc8\xbc\xf7\xfe\x29\xfa\x16\x7d\xf5\x6a\x00\xe9\x5e\x00\xc0\x9a\x82\x52\xab\x07\xbe\x72\xc0\x02\x20\x8d\x02\x20\xd0\xd8\x6d\xd6\x42\xf1\x9e\x9f\x8f\x01\xf8\xc7\x08\x00\x80\xd9\x6e\xb7\x59\x15\x02\x74\x06\xc0\x3f\x16\x03\x00\xc6\xd8\x4b\xfd\x95\xf3\x27\xdc\x74\x1e\xc0\x3f\xfc\x00\xa0\xef\x4b\xad\x95\x9e\x84\x17\x16\x03\x90\x80\xd6\x00\x00\x18\x97\xb5\xd4\x76\x47\xd2\x98\x9b\x41\x02\xb2\x03\x20\x94\x79\xdc\x3e\x3f\x10\x00\x00\x12\xe4\x95\x00\x80\x91\x10\x08\x05\x00\x42\x28\x9d\xeb\x76\xf9\x67\x56\xd8\x7c\xee\x52\x1b\xdf\xce\x0b\x27\x81\xc8\x9b\x30\xf2\x56\x42\xe4\x2d\x41\x38\x5d\x18\x90\x0a\x02\x52\xe1\x56\xda\xa9\x49\x84\x1a\x06\x8a\xb4\xfd\xe0\x81\x3a\xf3\x1f\x81\xc0\x9f\x8c\x54\xac\xd1\x9f\x53\x68\xf4\x9f\x26\x1f\x67\x01\xfc\x4c\x96\x92\x70\x36\x01\x40\xc0\x00\x0c\x92\x41\x3a\xd0\x82\xd1\x60\x22\xc8\x04\x46\x30\x0d\xdc\x01\xe6\x80\x79\x60\x21\xb0\x80\x87\x00\x07\x6c\xc0\x0e\x4a\xc1\x3a\x50\x05\x6a\x40\x3d\xd8\x0e\x3a\x41\x0f\xe8\x07\x47\xc1\x29\xf0\x24\x18\x04\xff\x02\xe7\xc1\x3b\xe0\x23\xf0\x0d\xf8\x05\xfc\x0e\x86\x21\x80\x42\x28\x81\x49\x50\x05\xd5\x50\x07\x6f\x86\xb7\x42\x23\xbc\x03\xde\x05\x2d\x90\x83\x4e\xe8\x81\xeb\xe1\x66\xd8\x09\xf7\xc2\x03\xf0\x18\x7c\x1c\x9e\x85\x4f\xc3\xe7\xe1\xbf\xe0\x79\xf8\x2e\xfc\x02\x7e\x0f\x7f\x82\xff\x85\x04\x5e\x4b\x40\x09\x69\x09\xea\x84\xf1\x09\xc6\x84\xe9\x09\xf3\x12\x96\x24\x2c\x4f\x28\x4a\x70\x27\x54\x25\x6c\x4a\xd8\x91\xd0\x9d\x70\x30\xe1\x78\xc2\xd9\x84\xc1\x84\x57\x13\x42\x09\x9f\x25\xfc\x92\x70\x35\x21\x9c\x10\x15\x08\x05\x32\x41\xba\x40\x2b\x18\x27\x98\x28\x30\x08\x72\x05\x79\x82\x7b\x05\x4b\x05\x05\x02\xb7\xa0\x5a\xb0\x45\xb0\x47\x70\x50\x70\x42\xf0\xac\xe0\xbc\xe0\xa2\xe0\x4d\xc1\xbf\x05\x5f\x09\xfe\x2b\x88\x0a\xc5\x42\xb9\x50\x2d\x1c\x2d\x9c\x22\x34\x09\xa7\x0a\xe7\x0a\x17\x0b\x1f\x10\xae\x10\xda\x84\x3e\x61\x8d\xb0\x49\xb8\x4d\xd8\x2e\xdc\x2d\x3c\x28\x7c\x44\x78\x58\x78\x4a\xf8\x84\x70\x50\x78\x41\x78\x49\x78\x59\xf8\xa5\xf0\xaa\x88\x11\xa9\x44\xe3\x44\x13\x44\x59\x22\xb3\x68\x9a\x68\x8e\xe8\x5e\xd1\x83\x22\x4e\x64\x17\x95\x8a\xd6\x89\xca\x45\x1b\x44\xb5\xa2\x46\xd1\x76\x51\x9b\xa8\x47\x74\x40\x34\x20\x7a\x44\x74\x5a\xf4\xac\xe8\x05\xd1\xcb\xa2\x8b\xa2\x90\xe8\x0b\xd1\xaf\xa2\x61\x26\x81\x91\x32\x4a\x46\xcb\xdc\xca\x64\x32\x46\x66\x3a\x33\x9b\x59\xcc\x2c\x63\x1e\x62\xac\xcc\x5a\xa6\x8c\xa9\x67\x9a\x99\x6d\x4c\x90\xe9\x66\x0e\x32\x47\x99\xa7\x98\x97\x98\xd7\x98\x7f\x33\x9f\x32\xdf\x30\x57\x98\xff\x30\xd7\xc4\x8c\x58\x2e\xbe\x49\xcc\x8a\x6f\x11\x4f\x14\xeb\xc5\x66\xf1\x3c\xf1\x72\xb1\x5d\x5c\x25\x6e\x14\xb7\x8a\x77\x89\xfb\xc5\x8f\x8a\x1f\x13\x9f\x16\x3f\x2f\xbe\x28\x7e\x57\xfc\x99\xf8\x1b\xf1\x15\xf1\xaf\xe2\xa8\x44\x2a\x51\x4b\xc6\x4a\xb2\x24\x66\xc9\x54\xc9\x1d\x92\x39\x92\x85\x92\x07\x24\x05\x92\x12\x89\x5b\x52\x29\xd9\x2c\xe9\x94\x74\x4b\x0e\x48\x0e\x49\x8e\x49\xce\x49\xfe\x29\xb9\x28\x79\x53\xf2\xa1\xe4\x6b\xc9\x7f\x25\x43\x89\xe2\xc4\x11\x89\xda\xc4\x31\x89\xa6\xc4\x79\x89\x4b\x13\x8b\x13\x9d\x89\x9e\xc4\xf2\xc4\xba\xc4\x96\xc4\x9e\xc4\x63\x89\x27\x13\x9f\x4a\x7c\x3e\xf1\xf5\xc4\xf7\x13\x3f\x4b\xfc\x3e\xf1\x6a\xe2\x30\x82\x08\xa3\x14\x94\x81\xc6\xa1\xdb\xd0\x24\x94\x89\x0c\xc8\x8c\x72\xd1\x34\x74\x27\x9a\x85\xe6\xa2\x7b\x11\x87\x0a\x50\x19\x0a\xa0\xdd\xe8\x30\x7a\x0c\x9d\x42\xcf\xa1\x7f\xa1\xf3\xe8\x6d\xf4\x31\xfa\x0a\xfd\x07\x45\x30\xc0\x02\x2c\xc6\x2a\xac\xc6\xe3\xb0\x09\xcf\xc2\xf7\x61\x2b\x2e\xc2\xa5\xd8\x8f\xab\x70\x1d\x6e\xc6\x3b\x70\x27\xee\xc1\x7d\xf8\x61\x7c\x08\x1f\xc3\xa7\xf1\x59\xfc\x24\x7e\x0e\xbf\x88\x5f\xc1\xef\xe2\x0f\xf0\x4f\xf8\x57\x29\x90\x0a\xa5\x49\x52\xa5\x74\x94\x74\xac\xf4\x56\xe9\x24\x69\x96\xd4\x24\xcd\x95\x4e\x97\xce\x94\xde\x25\xbd\x47\xba\x58\x6a\x91\x2e\x93\x3e\x24\x5d\x23\x2d\x94\xda\xa5\x4e\xa9\x47\xea\x97\x56\x4a\x37\x48\xeb\xa4\x9b\xa5\x01\xe9\x0e\x69\x87\xb4\x4b\xda\x23\xed\x93\x1e\x94\x3e\x2a\x3d\x2a\x3d\x21\x3d\x2d\x3d\x27\x7d\x46\xfa\xbc\xf4\x65\xe9\xeb\xd2\xb7\xa5\xef\x4a\x3f\x90\x7e\x2c\xfd\x5c\xfa\xb5\xf4\x3b\xe9\x15\xe9\x7f\xa4\xbf\x49\x87\xa4\xc3\x32\x28\x93\xc8\x14\xb2\x34\x59\x86\x4c\x2b\x1b\x2b\x9b\x28\x33\xc8\xb2\x65\x53\x65\x77\xca\xf2\x64\xf3\x64\x0b\x64\xf7\xca\x96\xca\x56\xc8\x56\xcb\xf2\x65\x45\xb2\xb5\x32\x97\xcc\x2b\x2b\x97\x55\xcb\x36\xca\x1a\x64\x9b\x64\x5b\x65\xad\xb2\x4e\x59\xb7\xac\x57\xb6\x5f\xf6\xb0\xec\xb0\xec\x31\xd9\x29\xd9\x13\xb2\xa7\x64\xcf\xc9\x5e\x90\xbd\x24\x7b\x55\xf6\xba\xec\x6d\xd9\xbb\xb2\x0f\x64\x1f\xcb\x3e\x97\x7d\x2d\xfb\x4e\x76\x45\xf6\x1f\xd9\x6f\xb2\x21\xd9\xb0\x1c\xca\x45\xf2\x44\xb9\x4c\x9e\x2c\x57\xc9\xd3\xe5\xac\x7c\x94\x7c\xac\xfc\x56\xf9\x24\x79\x96\xdc\x24\xcf\x95\x4f\x97\xcf\x94\xcf\x91\xcf\x97\x2f\x92\x2f\x91\x2f\x95\xaf\x90\xaf\x96\xe7\xcb\x8b\xe4\x6b\xe5\x2e\xb9\x57\x5e\x2e\xaf\x96\x6f\x94\x37\xc8\x37\xc9\xb7\xca\x5b\xe5\xed\xf2\x5d\xf2\x3d\xf2\x7d\xf2\x03\xf2\x47\xe4\x47\xe4\xc7\xe5\x8f\xcb\xcf\xca\x9f\x96\xff\x43\xfe\x4f\xf9\xcb\xf2\x0b\xf2\x37\xe4\xef\xc8\xdf\x93\x5f\x96\x7f\x22\xff\x42\xfe\x7f\xf2\xef\xe5\x3f\xc9\x7f\x95\xff\x2e\x8f\xc8\xaf\x29\x12\x14\x8c\x02\x29\xe4\x8a\x14\x45\x9a\x22\x43\xa1\x55\x8c\x56\x8c\x53\xdc\xa6\x98\xac\xd0\x2b\xcc\x8a\xdb\x15\x77\x28\x66\x29\xe6\x2a\xe6\x2b\x16\x29\x96\x28\x96\x2a\x56\x28\x56\x2b\xf2\x15\x45\x8a\xb5\x0a\x97\xc2\xab\x28\x57\x54\x2b\x36\x2a\x1a\x14\x9b\x14\x5b\x15\xad\x8a\x76\xc5\x2e\xc5\x1e\xc5\x3e\xc5\x01\xc5\x23\x8a\x23\x8a\xe3\x8a\x27\x14\xcf\x2a\x06\x15\xff\x52\x9c\x57\xbc\xa9\x78\x4f\x71\x59\xf1\x89\xe2\x0b\xc5\xff\x29\xbe\x57\xfc\xa4\xf8\x55\xf1\xbb\x22\xa2\xb8\x96\x94\x90\xc4\x24\xa1\x24\x79\x52\x4a\x52\x5a\x52\x46\x92\x36\x69\x74\xd2\xb8\xa4\xdb\x92\x26\x27\xe9\x93\x72\x93\x66\x24\xcd\x4b\x5a\x94\xf4\x40\xd2\x43\x49\x05\x49\x6b\x93\xd6\x25\x55\x26\xd5\x26\x6d\x4a\xda\x9e\x14\x4c\xea\x49\x3a\x90\x74\x38\xe9\x64\xd2\xb9\xa4\x7f\x24\xbd\x94\xf4\x5a\xd2\xa5\xa4\xcb\x49\x9f\x27\x7d\x9b\xf4\x73\xd2\xef\x49\xc3\xc9\xc2\x64\x9c\x9c\x92\x9c\x9e\x3c\x32\x79\x7c\xf2\xe4\x64\x53\xf2\xb4\xe4\xbc\xe4\xf9\xc9\xf7\x25\x2f\x4b\xe6\x92\x8b\x92\x4b\x93\xfd\xc9\xeb\x93\x1b\x92\xb7\x24\xef\x4c\xee\x4a\xde\x97\xfc\x70\xf2\xb1\xe4\xd3\xc9\x4f\x27\xbf\x90\x7c\x3e\xf9\xcd\xe4\xf7\x92\x3f\x4e\xfe\x2a\xf9\x87\xe4\x5f\x93\x87\x52\x40\x8a\x38\x45\x9e\x92\x92\x92\x9e\x32\x32\x65\x7c\xca\xe4\x14\x53\xca\xb4\x94\x92\x94\xf2\x62\xa7\xd5\xe7\x2b\x2d\xf3\x39\x0a\x7c\x36\xab\xb7\xc0\x6e\x73\x95\xdb\x9c\x6e\x8f\xcd\x6e\xb3\x7a\xfd\x3e\xbf\xd5\xcb\xff\x71\xb6\x52\x8f\xbf\xaa\xcc\x67\xf3\x16\x39\x9c\xa5\x7e\x3b\xe7\xb4\x7a\x8b\x6d\x7e\x3b\xcf\x39\x7c\x7e\x77\x89\xd7\x56\xea\x2e\xb7\x55\xbb\xdd\xa5\x9c\xc3\x15\x23\xee\x32\xbf\xbb\xa8\xc8\xe7\x28\x76\x59\x9d\x05\xee\x62\xbf\xd7\xea\xb3\xdb\xdd\xa5\xb6\x22\x87\xd3\xc6\x59\x9d\x7e\xbf\xa3\xd4\xe6\x75\x5b\x0b\x0b\xdd\x15\x2e\xa7\xdb\x5a\xc8\xf7\xdd\xe0\xcb\x3c\xfc\xbb\xc3\x95\xef\xae\xf4\x38\xad\x55\x5c\x81\xc3\x5b\xe0\xb4\x79\x6d\x1e\x9b\xd5\xef\xb5\x15\x79\x6d\x3e\x3b\x0f\xcb\x4f\x71\xba\x0b\x4a\x8a\x9c\xd6\x62\x3e\xe5\x79\xec\x6e\x97\xcd\x57\xee\x76\x96\x95\xda\x38\x77\x51\xd1\x75\x8e\x97\x7a\x9d\x2d\xf3\xac\xf3\x16\xb8\x0b\x6d\xf9\xd6\x18\xf1\x5b\x8b\xfd\xd6\x62\x5f\xbe\xdb\x5d\xc2\xff\x95\x5a\xbd\x25\x1e\xaf\xc3\xe5\x2f\xb0\x96\xda\xbc\xd6\x22\xb7\xcb\x9f\xef\x76\x16\x3a\xfc\x56\xa7\xa3\xc0\x6f\xab\xf4\x73\x76\x9b\xa3\xd8\xee\x8f\xb1\x15\x8e\x42\xbf\xdd\xea\x74\x14\xbb\x38\xa7\xad\xc8\x1f\xe7\x0a\x6c\x2e\xbf\xcd\x1b\xe7\xbd\xfc\xd0\x38\xbb\xb6\xcc\xe7\x77\x14\x55\xf1\x6b\x76\xb8\x0a\x6d\x2e\x7f\x6c\xca\x75\x36\x36\xae\xc8\x5a\x60\xe3\x35\xc2\x95\x3b\x0a\x6d\x6e\x8f\xa3\xc0\x5f\xc6\x6f\xd7\x55\xe0\x70\x96\x5a\x3d\x1c\xbf\x32\x9b\xd7\x5a\xc8\x0b\xf2\x3b\x5c\x7e\x5b\xa1\xc3\xef\xb3\x5b\xbd\xb6\x02\xbb\xad\xa0\x84\x57\xbd\xcf\x6f\xf3\x70\xf9\xd6\x82\x92\x0a\xab\xb7\xb0\xc8\xea\xf3\xff\xd9\xb8\x41\x79\x4d\x7a\xac\x65\x3e\x9b\xcf\xef\xf6\x14\xb9\xbd\x7f\x0e\xbc\xce\xc7\x24\x5c\xe7\x6d\x6b\x6d\x05\xfe\x02\xbb\xad\xdc\xeb\x8e\x6f\xef\x06\x1f\x5b\xac\xc7\x59\xe6\xe3\xf8\x93\x2d\x75\xb8\xae\x73\xf1\xf3\x8f\xb1\xee\x92\x18\x59\x57\x66\xf3\xf9\x1d\x6e\x57\xac\xe1\x70\x15\xb9\x63\x8c\xaf\xc0\x6b\xb3\xb9\x7c\x76\xb7\xff\xfa\x8c\xf8\xd1\xba\x4b\xae\x33\xf9\x56\xd7\x75\xce\xea\xf5\xba\x2b\xe2\xaa\x8d\x71\x71\x75\xc6\xd8\x32\x4f\x9c\xf2\x07\x1b\xd3\x02\x6f\x08\x5e\x9b\xcf\x51\x6d\xe3\x8a\xca\x9c\xce\xeb\xac\xaf\xd4\xea\x74\xda\x2a\x0b\x9c\xd6\x52\xeb\x9f\x2b\x29\x76\x14\xf9\x9d\x36\x6b\x51\x91\xc3\x6b\xb3\x55\xd9\x38\xb7\xc7\xe6\xe2\x69\x81\xd3\xed\xb3\x55\x58\xbd\x2e\x87\xab\x38\x36\xd0\xe3\xb4\xba\x6c\x05\x56\xa7\xcd\x55\x68\xf5\x7a\xad\xae\x42\x77\x69\x81\xbb\xb4\xd4\xe6\xf2\x97\x5a\x8b\x5d\xb6\x3f\x35\x52\xe6\xb9\xc1\xf1\xcb\xf1\xda\xfc\x15\x36\x9b\xdf\x67\x77\x7b\x3c\xbc\xa4\x02\xab\xd7\x5f\xe4\x76\x16\xda\xbc\x71\x84\xeb\x3c\x8f\x7a\x7d\x95\xe5\x36\xaf\xdf\x51\x60\xbd\xb1\x68\xbb\xdb\xeb\xa8\x76\xbb\xfc\x56\x67\xbe\xd5\xcb\x15\xd8\xad\x5e\xbf\xbf\xc2\xe1\xf7\xdb\xbc\xb1\x55\xf1\x76\xc2\x9b\x6a\xac\x11\x37\x53\xce\x6b\xf3\x7b\xdd\x25\xb6\xaa\x02\x77\xb1\xef\xfa\x12\x7d\x7e\x7b\x59\x69\xbe\x8f\x2b\xf3\xc4\x5c\x2d\xde\xe0\xd7\xc7\x37\x63\x0e\x6d\xb7\x3a\x8b\x62\x2e\x1e\x77\xed\xd8\xc1\x95\xf9\x9d\x0e\x57\x89\xad\xd0\x11\x57\x95\xa7\xcc\x67\xf7\x38\x5c\xb6\x4a\xbf\xcd\xeb\xb2\x3a\x39\xfe\xc3\xf8\x61\xfa\xbd\x6e\x8f\xbd\xaa\xd8\xe1\xb7\x97\xe5\xc7\x86\xc6\x1d\x36\xe6\x8f\xb6\x52\xb7\x2b\xe6\x88\x31\xd3\x8c\x4b\xbf\xe1\x5c\xf1\x56\xec\xd3\xd8\xb4\xeb\x3b\xbb\xb1\xa9\xb8\xc0\x32\x17\xef\xd3\x05\x5e\xde\xc6\x79\xfd\x15\x7a\x7d\x3e\x7b\x61\x61\x7e\x99\xd3\x69\x77\x7b\x5d\xf9\x36\xa7\xb3\x80\xd7\x59\x91\xa3\xc0\xea\xb7\xd9\xad\xae\xc2\xb8\x6d\xc4\x38\xde\x5e\x62\x4c\x99\x27\x46\xf8\x3d\xc7\xed\x89\xfb\x9f\x41\xfd\xad\x23\x36\xf7\x6f\x3d\x65\x9e\xbf\x35\x79\x11\xc5\x4e\x77\xbe\xad\xc2\x6b\x73\x15\xd8\xfd\x56\x5f\x89\xaf\xc8\xe1\xf4\xdb\xbc\xf9\x5e\x87\xad\xa8\xc0\xea\xb3\xf1\x46\x17\xb7\x6c\x97\xdb\x6f\x5b\x57\x66\x75\x3a\x5c\x45\x0e\x97\xc3\x5f\xe5\xb4\xf9\x7c\xb1\x8e\x62\xaf\xbb\xcc\xc3\x6b\xb0\xc0\xe9\x2e\x2b\xcc\xb7\x59\x4b\x6c\xde\x82\x32\x7f\x81\xdb\x53\xe5\xb1\x7a\x62\xe6\xe1\xf0\xf8\xac\xe5\x36\x5e\x2f\x5c\xbe\xd3\xea\x2a\xf1\xda\xdc\xde\x42\x9b\xb7\xcc\xe9\x76\xfa\xfc\x5e\x47\x89\xcd\x6f\xf7\xba\xcb\x8a\xed\x65\xae\x42\x9b\xd7\xe9\x70\xd9\xfc\xd6\x7c\xa7\xad\xd4\x5a\xec\x28\xf0\x7b\xcb\x0a\x4a\x3c\x7c\x60\xf0\xda\x7c\xfe\x3f\x99\xb8\xc5\xbb\xdd\xc5\x4e\x1b\xf7\xa7\xd3\xfe\xa5\x5d\xea\x76\xd9\xaa\x0a\xac\x5e\x9b\x3f\xae\xa8\x18\x57\xe6\x89\xd3\x98\xa6\x62\x5c\x5c\x45\x7c\x04\x75\xf9\x7c\x6e\xaf\x9f\xff\x8b\x3b\x1f\xcf\x94\x79\x6e\xa4\x8c\xd8\xf9\x5f\xb7\xa0\x32\x57\xa1\xdb\x69\x2b\xb6\x3a\x0b\xad\x3e\x7b\xbe\xdb\xea\x2d\xbc\x6e\x9a\xfc\xa0\x1b\x56\xca\xf3\xf9\x6e\xa7\xdf\xe7\xf0\xdb\x4a\xad\x9e\xb2\xd2\x7c\xaf\xcd\xe9\xb4\x7a\xac\x3e\xbf\xcd\xc9\x83\x72\xf9\x65\xce\x7c\x5b\x65\x81\xdd\xea\x2a\xb6\xc5\x34\xc7\xdd\xc8\x11\xf1\x56\xdc\xf0\xf8\xc4\xc4\x95\xf2\x11\xcc\x6f\x77\xfb\x0a\xdc\x1e\x9b\xaf\xcc\xe1\xe7\x4f\x86\xb7\x96\x38\x62\x51\x91\xcd\x56\xe4\x76\x17\xc6\xf2\x4f\x2c\x82\xf3\xe0\x65\x0e\x67\xa1\xc3\x55\x6c\x77\xfb\x3c\x7c\x98\xb7\x96\xe6\x97\x39\xad\xae\x02\x5b\xa9\xad\xb0\xc4\xe1\x2f\xe2\xd7\x60\xf3\x72\x6b\x6d\xfe\x7c\x9b\xcd\x6b\x8f\xbb\x60\x66\x91\xad\xd0\x5d\x96\xcf\x1b\x88\x8b\xd7\x24\xaf\xa8\xbf\x75\xc4\xf4\xf5\xb7\x9e\x32\xcf\xdf\x9a\xfc\x1e\xfe\x37\xf7\x2f\x93\x6e\x8c\xfe\xdf\xb0\x42\x9b\xaf\xc4\xef\xf6\x38\xad\x1e\xbf\xdb\x13\x3b\x70\x7f\xa9\x3b\x9f\xdf\x43\xdc\xc9\xe2\x96\x1a\xb3\x97\x75\x65\x6e\x7f\x5c\x62\x9c\x8b\x49\xf4\x79\x1c\x2e\x97\xcd\xfb\x67\x06\x75\xde\x70\x5b\xab\xf3\x6f\x81\xe9\x2f\x6d\x3e\x38\xf1\x4d\x5b\xa5\x87\x77\xa1\x98\xf6\xf8\x53\x89\x0f\xf2\x95\x3a\x9c\xb6\x22\xaf\xbb\xc2\x55\x6a\xb3\x17\x5b\x4b\x6d\x1e\x6b\x61\x89\xad\x2a\x76\xc4\x7c\x22\x8e\x09\xe2\x69\xcc\xff\x6d\x5e\x5b\xa1\xdf\xe6\x2d\x75\xc4\xaa\x80\xc2\xf8\x0a\x38\xab\xd3\xf9\x67\x10\x8a\xc7\x04\xa7\xbb\x20\x1e\xa3\x63\x3e\x57\xe0\x75\x7b\xf8\xd1\x7c\x3a\x2a\x29\x73\xf1\x36\xc5\xe9\xb3\x73\xff\x12\xcb\x7d\x65\x1e\x9b\xd7\x57\xe0\x75\x78\xfc\xbe\xb2\xfc\x38\xc3\xe9\x73\x0c\x9e\xb2\xea\x6a\x5e\x37\x0e\x5b\x81\xad\xd4\xc1\xcb\xe1\xb5\xf4\x3f\x8e\x2f\x0b\x7c\x76\x87\xcd\x59\x78\x23\xb4\xc7\xf1\xf9\x74\xc0\xd9\x2a\xfd\x0e\x57\x71\x99\xc3\x67\xb7\x79\xbd\xee\x82\x12\x9b\xbf\xd4\x5a\x59\x50\xe8\xba\x11\xe0\x7d\x37\x92\xfd\xdf\x3a\xe2\xde\xf1\xd7\x9e\xff\xa5\x84\x58\x93\x3f\x46\xbb\xbf\xd4\x69\x2a\xf0\xf9\x0c\x56\x57\x81\xdd\xed\x8d\xc7\xb8\xb8\x05\x3a\x9d\x3e\x5b\x95\xcd\xe6\xe4\xfd\xdf\xe1\xfb\x4b\x02\xf8\xb3\xeb\x46\x8a\xe0\x0c\x99\x86\x58\x3d\x14\x8b\x9d\x8e\xd8\x02\xff\xcc\xc0\xb1\x73\x8a\x85\xdc\x58\x9f\xd3\x56\x6e\x73\xf2\xee\x11\xa3\x31\xef\x8e\x7d\xc8\x0f\x8d\x45\xd6\xd8\x1c\x43\x96\x3e\x9e\x40\x63\xe9\xc4\x5d\xea\xb1\xfa\x7c\x37\x0e\xfb\xcf\x43\xf7\xbb\x3d\x9c\x21\x2b\xdb\x56\xe6\x2d\xce\xf7\x94\xf9\x0a\x1d\x2e\xef\x5a\x4f\x95\xb7\x2c\xbf\xc4\x5b\x91\xef\x2f\xe0\x1d\xea\x4f\xa7\x8a\x45\x84\x7c\xfe\x84\x3d\x76\x6b\xbe\xcd\xcf\x19\xf4\xb9\x7f\xf6\xf9\xfd\x5e\x47\x7e\x99\xdf\xe6\xfb\x7f\xf6\xc4\x2c\xeb\x7a\x6f\x2c\xea\xfd\xad\xc1\x7f\xca\x19\x0c\x46\xce\x60\x30\x55\xb9\xcb\xfc\x65\xf9\xf1\x15\x5f\xe7\x2b\x1d\xae\xe2\xca\x1b\x79\xfb\xc6\xe7\xbc\xa2\x0a\xbd\x6e\x4f\xbe\xbb\xd2\xe7\xb7\x16\x94\xdc\x88\x22\x0e\x97\xcf\x6f\x2d\xf6\x5a\x4b\x8b\x9c\x8e\x82\x12\xaf\xb5\xd0\x55\x94\x95\x9d\x95\xef\xf0\xe7\x97\xf1\x0a\x8d\xeb\xb6\xac\x34\xdf\xe9\x8d\xbf\xc7\x3a\x9c\x6e\x57\xf1\x5f\xd2\xc1\x5f\x9a\x7c\x00\xfa\xb3\xc1\xdb\xc6\x5f\x9a\x71\x97\xf6\x78\x9c\xb6\x0a\x87\xab\xd0\x5d\xe1\xb3\xba\x0a\xbd\x6e\x47\xa1\xd3\xe1\x2a\xab\x2c\xf4\x3a\xf2\xf3\x9d\x36\x5f\x49\x95\xc7\x56\xe4\x2e\xf3\xfa\xd6\x95\xf1\xc1\x96\x0f\x80\xee\x22\x5b\xa9\xd5\x19\xfb\x2b\x76\xf8\xfd\x0e\x8f\xaf\xcc\xc5\x19\xcc\x66\xbe\x3c\x77\x94\xdb\xf2\xcb\x8a\xcb\x4b\x2a\x6c\x8e\x7c\xb7\x97\xaf\x22\x5c\x9c\x21\x5b\x1f\xdb\x22\x77\x63\x8f\x9c\x21\xdb\x18\x5f\xc2\x8d\x4c\xe6\x8c\xc7\x73\xce\x90\x6d\x2e\x74\xfb\xff\xda\x6d\xc8\xce\x29\x77\x94\xda\xdc\x5c\x7c\x01\x9c\x21\x27\x33\x9e\x2a\xe2\x4d\x37\x67\xc8\xd1\x73\x86\x1c\x03\x67\xc8\x31\x72\x86\x1c\x13\x67\xc8\x31\x73\x86\x9c\x6c\xce\x90\x93\xc3\x19\x72\x72\xcb\x5c\x8e\xb9\x59\x33\x33\x8b\xb2\xac\x59\x9c\x21\x57\xcf\x19\x72\x0d\x45\x59\x56\x23\x67\xc8\x35\x71\x86\x5c\x33\x67\xc8\xcd\xe6\x0c\xb9\x39\x9c\x21\x37\x97\x33\x66\xf2\xe3\xf2\x39\x63\xa6\x9e\x33\x66\x1a\x38\x63\xa6\x31\x36\x7d\x56\x16\x67\xcc\x34\x73\xc6\xcc\x6c\xce\x98\x99\xc3\x19\x33\x73\x39\x63\x56\x26\x67\xcc\xca\xe2\x8c\x59\x7a\xce\x98\x65\xe0\x8c\x59\x46\xce\x98\x65\xe2\x8c\x59\x66\xce\x98\x95\xcd\x19\xb3\x72\x38\x63\x56\x1c\x3d\x2f\x33\x4e\xb2\x38\xa3\x5e\xcf\x19\xf5\x06\xce\xa8\x37\x72\x46\xbd\x89\x33\xea\xcd\x9c\x51\x9f\xcd\x19\xf5\x39\x9c\x51\x9f\xcb\x19\x0d\x99\x9c\xd1\x90\xc5\x19\x0d\x7a\xce\x68\x30\x70\x46\x43\x7c\x01\xb3\xe3\x12\x66\x67\xc5\x09\xff\x61\x0e\x67\x34\xc4\xc5\xcf\x36\xc5\x89\x39\x4e\xb2\x39\xa3\xd1\xc0\x19\x8d\x46\xce\x68\x34\x71\x46\xa3\x99\x33\x1a\xf9\xbe\x1c\xce\x68\x8c\x4f\x98\x93\xc9\x19\x4d\x59\x9c\xd1\xa4\xe7\x8c\x26\x03\x67\x34\x19\x39\xa3\xc9\xc4\x19\x4d\x66\xce\x68\xca\xe6\x8c\xa6\x1c\xce\x68\xca\xe5\x8c\xe6\x4c\xce\x68\xce\xe2\x8c\x66\x3d\x67\x34\x1b\x38\xa3\x39\xbe\x98\xb9\x7c\xb7\x99\x33\x9a\xb3\x8b\xb2\x8a\xf8\xee\x5c\xce\x98\x9d\xc9\x19\xb3\xb3\x38\x63\xb6\x9e\x33\x66\x1b\x38\x63\xb6\x91\x33\x66\x9b\x38\x63\xb6\xb9\x28\xab\xa8\x80\x33\x66\xe7\x70\xc6\xec\x5c\xce\x98\x93\xc9\x19\x73\xb2\x38\x63\x8e\x9e\x33\xe6\x18\x38\x63\x8e\x91\x33\xe6\x98\x38\x63\x8e\x99\x33\xe6\x64\x73\xc6\x9c\x1c\xce\x98\x93\xcb\x19\x73\x33\x39\x63\x6e\x16\x67\xcc\xd5\x73\xc6\x5c\x03\x67\xcc\x35\x16\xe9\x79\x8d\xe7\x9a\x8b\xf4\xbc\xc6\x73\x73\x38\x63\x6e\x2e\x67\xca\xcc\xe4\x4c\x99\x59\x9c\x29\x53\xcf\x99\x32\x0d\x9c\x29\xd3\xc8\x99\x32\x4d\x9c\x29\xd3\xcc\x99\x32\xb3\x39\x53\x66\x0e\x67\xca\xcc\x2d\xb7\xf1\x51\xc8\x94\x95\xc5\x99\xb2\xf4\x9c\x29\xcb\xc0\x99\xb2\x8c\x9c\x29\xcb\xc4\x99\xb2\xcc\x9c\x29\x2b\x9b\x33\x65\xe5\x70\xa6\xac\x5c\xce\xa4\xcf\xe4\x4c\xfa\x2c\xce\xa4\xd7\x73\x26\xbd\x81\x33\xe9\x8d\x9c\x49\x6f\xe2\x4c\x7a\x33\x67\xd2\x67\x73\x26\x7d\x0e\x67\xd2\xe7\x72\x26\x43\x26\x67\x32\x64\x71\x26\x83\x9e\x33\x19\x0c\x9c\xc9\x60\xe4\x4c\x06\x13\x67\x32\x98\x39\x93\x21\x9b\x33\x19\x72\x38\x93\x21\x97\x33\x19\x33\x39\x93\x31\x8b\x33\x19\xf5\x9c\xc9\x68\xe0\x4c\x46\x23\x67\x32\x9a\x38\x93\xd1\xcc\x99\x8c\xd9\x9c\xc9\x98\xc3\x99\x8c\xb9\x9c\xc9\x94\xc9\x99\x4c\x59\x9c\xc9\xa4\xe7\x4c\x26\x03\x67\x32\x19\x39\x93\xc9\xc4\x99\x4c\x66\xce\x64\xca\xe6\x4c\xa6\x1c\xce\x64\xca\xe5\x4c\xe6\x4c\xce\x64\xce\xe2\x4c\x66\x3d\x67\x32\x1b\x38\x93\xd9\xc8\x99\xcc\x26\xce\x64\x36\x73\x26\x73\x36\x67\x32\xe7\x70\x26\x73\x6e\x91\xde\x9c\x59\xa4\xe7\xc7\x65\xeb\x8b\xf4\xfc\xb8\x6c\x23\x67\xca\x36\x71\xa6\x6c\x33\x67\xca\xce\xe6\x4c\xd9\x39\x9c\x29\x3b\x97\x33\xe5\x64\x72\xa6\x9c\x2c\xce\x94\xa3\xe7\x4c\x39\x06\xce\x94\x63\xe4\x4c\x39\x26\xce\x94\x63\xe6\x4c\x39\xd9\x9c\x29\x27\x87\x33\xe5\xe4\x72\xa6\xdc\x4c\xce\x94\x9b\xc5\x99\x72\xf5\x9c\x29\xd7\xc0\x99\x72\x8d\x9c\x29\xd7\xc4\x99\x72\xcd\x9c\x29\x37\x9b\x33\xe5\xe6\x14\xe9\xb3\x6d\xbc\x7d\xe8\x73\x32\xe3\x24\x8b\x33\x67\xea\x39\x73\xa6\x81\x33\xc7\xfd\x48\x9f\x63\x8a\x13\x33\x67\xce\xcc\xe6\xcc\x99\x39\x9c\x39\x33\x97\x33\x67\x65\x72\xe6\xac\x2c\xce\x9c\xa5\xe7\xcc\x59\x06\xce\x9c\x65\xe4\xcc\x59\x26\xce\x9c\x65\xe6\xcc\x59\xd9\x9c\x39\x2b\x87\x33\x67\xe5\x72\x66\x7d\x26\x67\xd6\x67\x71\x66\xbd\x9e\x33\xeb\x0d\x9c\x59\x6f\xe4\xcc\x7a\x13\x67\xd6\x9b\x39\xb3\x3e\x9b\x33\xeb\x73\x38\xb3\x3e\x66\xe2\xfa\x99\xf1\x35\xcc\xcc\x8a\x13\x7d\x9c\x18\xe2\x24\xbe\x98\x99\xf1\xc5\xcc\x34\xc7\x49\x76\x9c\xe4\xc4\xc9\x75\x29\x33\xe3\x64\x56\x9c\xe4\xc5\xc9\xec\x38\x99\x13\x23\xb3\xe2\x40\xb3\xe2\x40\xb3\xe2\x40\xb3\xe2\x40\xb3\xe2\x40\xb3\xe2\x40\xb3\xe2\x40\xb3\xe2\x40\xb3\xe2\x40\xb3\xe2\x40\xb3\xe2\x40\xb3\xe2\x40\xb3\xe2\x40\xb3\xe2\x40\xb3\xe2\x40\xf1\x20\xa2\xcf\x8b\x03\xe5\xc5\x81\xf2\xe2\x40\x79\x71\xa0\xbc\x38\x50\x5e\x1c\x28\x2f\x0e\x94\x17\x07\xca\x8b\x03\xe5\xc5\x81\xf2\xe2\x40\x79\x71\xa0\xbc\x38\x50\x5e\x1c\x28\x1e\x6b\xf4\xf1\x58\xa3\x9f\x1d\x07\x9a\x1d\x07\x9a\x1d\x07\x8a\x47\x1c\x7d\x3c\xe2\xe8\x67\xc7\x81\x66\xc7\x81\x66\xc7\x81\x66\xc7\x81\x66\xc7\x81\x66\xc7\x81\x66\xc7\x81\x66\xc7\x81\xe6\xc4\x81\xe6\xc4\x81\xe6\xc4\x81\xe6\xc4\x81\xe6\xc4\x81\xe6\xc4\x81\xe6\xc4\x81\xe6\x64\x73\xe6\xdc\x38\xca\x9c\x38\xca\x9c\x38\xca\x9c\x38\xca\x9c\x38\xca\x9c\x38\xca\x9c\x39\x79\x6e\x4f\x55\x2c\xc7\x8d\x9c\x6d\x2d\xb7\x8d\x9c\x67\x75\x15\x56\x8d\xd4\x67\x66\x99\x27\x8f\x9c\xe9\x74\x8e\x8c\xd7\x9f\x23\xbd\x36\x9f\xcd\x5b\x6e\x2b\x9c\xfc\x97\x87\x05\xf0\x4a\x02\x80\x40\x0a\x56\x02\x0e\xb4\x82\x76\xd0\x05\x0e\x80\x47\xc0\x49\xf0\x31\x1c\x0d\x27\xc0\x29\xd0\x00\xb3\xe1\x54\x68\x81\xcb\x20\x07\x0b\xa1\x1d\xba\xe0\x76\xd8\x06\x3b\xe1\x29\x78\x0e\xbe\x0c\x5f\x87\x6f\xc3\x77\xe1\x47\xf0\x73\xf8\x0d\xfc\x0f\xfc\x0d\x46\x12\xb4\x09\x37\x27\x8c\x4f\x58\x9c\xe0\x4d\xa8\x4e\xa8\x4f\x38\x98\x70\x38\xe1\x6c\xc2\xab\x09\x6f\x26\x7c\x96\xf0\x55\xc2\xb7\x09\xbf\x24\x0c\x0b\x12\x04\x49\x82\xc9\x02\xbd\xc0\x2c\xb8\x5d\x30\x43\x30\x5b\x70\x97\x60\xa1\xa0\x5f\x70\x52\xf0\xac\xe0\x9f\x42\x2c\x4c\x17\x6a\x85\x63\x85\xb7\x09\x27\x0b\x8d\xc2\x1c\xe1\x0c\xe1\x1c\xe1\xa2\xd8\x77\xee\xab\x85\x35\xc2\xcd\xc2\x80\x70\xa7\xf0\x15\xe1\x4f\x42\x2a\x02\x22\xa1\x48\x22\x1a\x21\xd2\x88\xa6\x88\x0c\xa2\x9d\xa2\x2e\xd1\x7e\xd1\x71\xd1\x13\xa2\x67\x44\x83\xa2\x57\x44\xaf\x8b\xde\x16\xfd\x20\x22\x22\xca\x2c\x66\x1e\x64\x56\x33\x05\x4c\x31\xe3\x64\x6a\x99\x66\x66\x0b\x73\x9c\x39\xc7\x3c\xcb\x5c\x11\xe7\x88\xa7\x89\xe7\x8a\xe7\x8b\xbb\xc4\x7b\xc5\x07\xc5\x47\xc4\x8f\x8b\x9f\x14\x3f\x27\x7e\x41\xfc\x8a\xf8\x2d\xf1\xd7\xe2\x9f\xc5\x61\x89\x46\x92\x27\x79\x40\x62\x95\xac\x95\xb8\x25\xe5\x92\xf5\x92\x5a\x49\xb7\x64\x40\x72\x4c\x72\x46\xf2\xbc\xe4\x35\xc9\xa5\xc4\xc4\xc4\x19\x89\xf3\x13\x57\x24\x6e\x4d\xdc\x91\xd8\x97\x78\x38\xf1\x85\xc4\x97\x12\xdf\x4b\xfc\x2e\xf1\xbf\x89\x43\x89\x7f\x20\x09\x92\xc5\xbe\xdf\x9e\x8c\x6e\x47\x33\x91\x05\x95\x22\x2f\xaa\x41\x0d\xa8\x19\xed\x45\xc7\xd0\x13\xe8\x19\xf4\x25\xfa\x16\xfd\x88\xc5\x38\x15\x4f\xc5\xb3\xf0\x5c\x7c\x0f\xb6\xe0\x65\x98\xc3\x05\xd8\x81\x5d\xd8\x87\xab\x71\x3f\x7e\x18\x1f\xc3\x8f\xe3\xa7\xf0\x20\x7e\x1b\x5f\xc6\x5f\xe3\x2b\xb1\x6f\xad\x47\x4a\x27\x4b\x0d\xd2\x1c\xe9\x0c\xe9\x5c\xe9\x02\xe9\x62\xa9\x47\xba\x41\xda\x22\xdd\x2e\xed\x92\xee\x95\x3e\x22\x3d\x29\x7d\x4e\x7a\x51\xfa\x96\xf4\x43\xe9\xe7\xd2\xef\xa4\x3f\xc9\xc4\xb2\x71\xb2\x39\xb2\x42\x59\xa9\xac\x5a\xb6\x59\x16\x90\xb5\xcb\x1e\x96\x9d\x93\xbd\x28\x7b\x43\xf6\x6f\xd9\x47\xb2\xcf\x65\xff\x27\xfb\x49\xf6\x1f\xb9\x4c\xce\xca\xc7\xca\xb3\xe4\xd3\xe5\xb3\xe4\xf3\xe4\x8b\xe4\x0f\xc8\x57\xca\x6d\xf2\x5a\x79\xb7\xfc\xb4\xfc\x69\xf9\x0b\xf2\x97\xe4\xaf\xc9\xdf\x91\xbf\x2f\xff\x8f\x02\x29\x6e\x56\xdc\xaa\x98\xa4\xc8\x56\x4c\x57\xe4\x29\xe6\x2b\xee\x55\xac\x52\x94\x28\xbc\x8a\x3a\xc5\x66\x45\x87\x62\xaf\xe2\x61\xc5\x71\xc5\x69\xc5\x53\x8a\x7f\x28\x5e\x51\xbc\xa9\xf8\xb7\xe2\x43\xc5\xaf\x8a\xb0\x62\x38\x29\x35\xe9\xd6\xa4\xdb\x93\x16\x27\x3d\x90\x94\x9f\xe4\x4c\x5a\x97\x54\x9e\xb4\x21\xa9\x31\x69\x6b\xd2\xce\xa4\xce\xa4\xde\xa4\xc7\x93\xce\x26\x5d\x4c\xfa\x2c\xe9\xb7\x64\x90\x2c\x4f\x1e\x9d\x3c\x31\xd9\x94\x7c\x7b\xf2\xac\xe4\xf9\xc9\xf7\x26\x5b\x92\x8b\x93\xab\x93\xb7\x27\xf7\x24\xf7\x27\x3f\x92\xfc\x58\xf2\x13\xc9\xcf\x26\xbf\x90\x7c\x21\xf9\x8d\xe4\x4b\xc9\x97\x93\x3f\x49\xfe\x32\xf9\xb7\x14\x71\x4a\x7a\xca\x98\x14\x73\xca\x5d\x29\x2b\x52\x56\xa5\xd8\x53\x7c\x29\xeb\x53\xea\x53\x9a\x53\xb6\xa6\xf4\xa4\xf4\xa7\x9c\x4a\xf9\x67\xca\xa5\x94\x0f\x53\x7e\x4c\xf9\x4f\xca\x6f\x29\x91\x54\x94\x3a\x22\x75\x64\xea\xb8\xd4\x89\xa9\xe6\xd4\x19\xa9\xf3\x53\x2d\xa9\xcb\x52\xd7\xa4\xda\x53\x5d\xa9\xfe\xd4\x0d\xa9\x8d\xa9\x5b\x52\x5b\x53\x3b\x53\x7b\x52\xfb\x52\x1f\x4e\x3d\x92\x7a\x32\xf5\x4c\xea\x53\xa9\xff\x48\x7d\x3d\xf5\x83\xd4\x6f\x53\x49\xea\x35\xa5\x4c\xa9\x51\xde\xaa\xcc\x51\xce\x50\xde\xab\xbc\x5f\xb9\x4c\xf9\x90\x32\x5f\x69\x57\x7a\x94\x1b\x95\xcd\xca\x0e\x65\xaf\x72\x40\xf9\x98\xf2\x71\xe5\x33\xca\x17\x94\xaf\x28\x5f\x53\xbe\xad\x7c\x5f\xf9\x89\xf2\x4b\xe5\x77\xca\x9f\x94\x57\x55\x50\x25\x57\xa9\x55\xa3\x55\x53\x54\x46\xd5\x54\xd5\x9d\xaa\xb9\xaa\x7b\x54\xf7\xab\x1e\x54\x3d\xa4\xb2\xab\x4a\x55\x7e\x55\x9d\x6a\x9b\x6a\xb7\x6a\x40\x75\x5c\xf5\xa4\xea\x9f\xaa\x57\x54\x6f\xaa\xfe\xad\xfa\x54\xf5\x8d\xea\x27\xd5\x55\x55\x58\x75\x2d\x4d\x90\x26\x49\x93\xa5\xa5\xa4\xdd\x94\xa6\x49\x1b\x9f\x36\x31\x4d\x9f\x36\x3d\xed\xae\xb4\xfb\xd3\x56\xa7\xd9\xd2\x9c\x69\x15\x69\xb5\x69\x4d\x69\x5b\xd2\x5a\xd3\x3a\xd2\x76\xab\x6e\x43\x64\x26\x8a\x58\xc6\xb1\x72\x8d\xe8\x59\x8d\xb0\x49\x45\x5f\x23\xaf\x89\x4e\x16\xcd\x3c\xb2\x54\x7d\x4d\x79\x11\x69\x86\x06\x2d\x2c\x79\x9a\x1d\x74\xbe\x5b\x74\x52\x1b\x5d\x4c\x5a\x54\x7b\x9b\xf7\x36\xb4\x37\x91\xd7\xe9\xeb\x23\xda\x9b\x82\xd5\x6d\xd5\x92\xa8\x94\x09\x2b\xc9\x27\x48\x43\xc1\x62\x34\x14\x8c\x1a\x3f\x66\xb1\x6a\x14\xc2\xaa\x48\xd0\xcf\x5e\x0b\x8a\xaf\x05\x35\xc2\x41\xd5\x76\x34\x14\x4c\xdb\x8e\xc2\xca\x8b\x5f\xb3\x54\xf9\x03\xb3\x0e\x45\x95\x3f\x88\xd7\x21\xaa\x14\xe7\xb3\x7e\xf6\x3d\x56\x3c\x0e\xe1\xaa\x9a\x9a\x2a\xcc\x10\x03\x51\x11\x15\x31\xe8\xf0\x58\x56\x87\xa9\x81\xaa\xa8\x8a\x1a\x74\xf8\x4b\xa4\x11\xad\xa9\x66\x35\x91\x7e\x6a\x11\x6f\xac\x6d\xac\xdd\xa4\xdb\x54\xdb\xba\x31\x58\x4f\x42\x34\x34\x82\x30\x6c\x47\x47\x6b\x5b\xbb\x8e\x5c\x22\x97\x44\x58\x45\x8c\x44\xc7\x6a\xc2\x83\xab\xd0\x35\x4b\x31\xab\x11\xcf\x58\x81\x88\x51\x9c\x1a\x21\x12\xa4\x0b\x2b\xc5\xe4\x1c\x4a\x8d\x46\x83\xc2\xd4\xcb\x54\xc9\xa4\x46\xc9\x12\xa4\x09\x0f\x4e\x64\x23\x96\x95\xfc\x58\x52\x8f\x88\x52\x2c\x0f\x4f\xa3\x3f\x92\x1f\xa3\xd3\x30\x63\x44\x78\x22\xd2\xe2\xd5\xec\x71\x2c\xd6\x23\x1c\x6d\x8c\x8e\x8d\x8e\x8d\x36\x46\x1b\xc3\x63\xa3\x63\xc3\x8d\xe1\xc6\xf0\xd8\xf0\xd8\x70\x23\x36\xb0\x5a\x7c\x11\x51\xcb\x34\x84\x8f\xbb\x0e\xd9\xf1\x0c\x56\x87\xa7\xb2\xd4\x22\xc6\x8b\x78\xdd\x58\xee\x66\xc3\x41\x6a\x59\x84\x48\xf0\xa2\x2a\x0f\x2d\x60\xe6\xb2\xba\x05\x25\xec\x45\x06\x33\x66\x84\x99\x3b\x59\xac\x22\xf5\x2c\x1d\xa4\x2d\xb4\x85\x0e\xce\x47\xba\xa1\x60\xf4\xcc\x25\x36\x40\xb6\x22\x22\x63\x6f\x47\x0b\x26\xb2\xf8\x76\x44\x43\x4c\x55\x4d\x77\xaf\x8e\x58\xd6\x22\x6c\x42\x54\x39\x85\xc5\x0f\x22\x2d\x5e\x30\x86\xc5\xe3\x59\x6a\x19\xc3\xe2\xe3\x87\x0e\x1d\xc7\x4b\xd1\x3d\x48\x87\xcb\x11\x79\x1a\x11\x09\xd2\x62\xbe\x65\x46\x45\x08\xab\x78\x45\x6b\xa9\xf2\xba\x18\xa5\xb8\xb7\xbb\xbb\x57\x4b\x94\x4c\x6f\x77\x4d\x95\x8e\x28\x85\x4e\x16\x57\x6f\xd8\x50\x8d\x55\x63\x11\x1e\xae\x25\x59\x68\x48\x79\x02\x05\x88\xf2\xc6\x2b\x40\x94\x0b\x88\x25\x75\xf8\xad\x21\x25\xb1\xa8\x3e\x5c\x1e\x9a\xfe\xa8\x16\xab\xf6\x6e\xd8\x53\xad\x5d\xc0\xf0\x33\x75\x0b\xc4\xd5\x7b\x36\xec\xd5\x5e\x64\xf6\xee\xd9\xb3\x57\x47\x83\x24\xb4\x08\xe1\x23\x68\xd4\xe7\xa6\x5e\x84\xc9\x28\x22\xde\x87\xf0\xbf\x51\xb4\x28\x5a\x44\x6e\x41\x61\x96\x7f\x45\x59\x51\x73\x5b\x70\x73\x87\x3a\xd8\x41\xe6\xa1\xe7\x9e\xeb\x44\xf8\x3e\x64\x60\x75\x78\x03\x4b\x2c\xc2\xeb\x6f\xb8\x87\xbd\x66\xa9\x43\x11\x4b\x08\x45\x2c\xcc\xde\x3d\x1b\xaa\x7d\x6c\x33\x5a\xf2\xaf\x77\x70\x27\x4b\xce\xb1\x44\x45\x55\xc4\xa0\x1d\x0a\x8d\x63\xb1\x6a\x3c\xc2\xe2\xf1\x08\x4f\x43\x1a\xd1\x8c\x99\x08\x5f\x97\xde\x11\x24\xf3\x10\x0e\x2b\x89\x12\x8b\xda\x9a\x1b\x76\x34\xaa\x1b\x1b\x36\x37\x37\xeb\xf0\x6a\x44\x46\x30\x21\x96\x68\x56\x92\xe4\xe9\x57\xb4\xa4\x9d\x74\x88\x48\x32\x8a\x5a\x34\x74\xe4\x14\xa4\x32\x20\x5c\xc0\x06\xb0\x78\x12\x8b\x07\xd7\x9c\x5d\xaa\xc5\xdd\x35\xbd\xd8\x7e\xc8\x85\x47\xb3\x34\x88\x87\x43\xaa\x59\x6c\x44\x99\x56\x8e\xb4\xa9\x8f\x90\xdf\xd9\x48\xa8\x18\x69\xe8\xbd\xcc\x33\xf5\x5b\x3f\x9c\xa7\xa6\x41\xa6\x1e\x91\x35\x0c\x99\x33\x7c\x51\x54\xe3\x7a\xe8\x0e\x27\x29\x46\x91\x20\xf3\x25\x7b\x6d\x22\xd3\xd9\xd7\xdd\x7f\x20\xe3\x40\xc3\xc0\xe6\xfd\xda\xc8\x21\x22\x17\x1d\xdb\x71\xf0\xd1\xa3\x19\x72\x62\x27\x3f\xb2\x27\x59\x6a\x27\x33\xe8\x0c\x62\xc7\x8f\xb0\x1a\x0a\xc4\x73\x5e\xba\xef\x6d\x2d\xa6\xca\xc5\x08\x5e\xd7\xb8\x66\x68\x46\x5c\xe7\xd4\x12\x57\xba\x86\x19\x8c\xab\x3d\x1c\x12\xc6\x46\x5c\x0b\xfd\x7d\x40\x24\xf4\x26\x1b\x16\xb2\xd9\x88\x1f\x39\x17\xe9\xe4\xaa\x03\x2c\x49\x65\x49\x25\x4b\x54\x48\x8b\x07\xcf\x9e\x1d\xc4\x62\xc3\xa5\xbc\x2f\xb5\x78\xf6\x92\x25\xb3\x31\x33\x9b\xc5\xe4\x23\xb6\x8c\xc5\x55\x48\x8b\xa7\x22\xa2\x14\x4e\x45\x98\xf2\x2a\x54\xfd\x66\xfa\x7c\xd4\x7c\x56\x8b\xf3\x59\x8d\x04\xbc\xc7\x5e\x66\xbf\x46\x58\x6c\x47\x78\x28\xa8\x11\xf6\xab\xbe\x45\xf4\x73\xfa\xb9\x88\xee\x31\xa1\xa8\x72\x0a\x4b\xf6\x30\xe4\x73\xfa\xf9\xab\x08\xeb\xae\x59\xc4\x24\x18\xb1\x8c\x64\x35\xa2\x3a\x3c\x01\x4d\x62\xb1\xbf\xba\xac\xb2\x41\x47\xcb\xa2\x2b\xa3\x5b\x67\x89\xbc\x9b\x9d\xb5\xa5\x19\x55\xbb\xab\xbb\x36\x6a\xc3\x80\xfe\x6e\x8a\xb6\x88\xb6\x36\x6d\x6d\x6e\xca\x58\xb7\xdb\x77\xa8\x7b\xf7\xce\xf6\xdd\xda\xf0\x03\xa4\x0e\xab\xec\x2e\x97\x9d\x37\x66\xbb\xeb\xd0\x71\xde\x98\x79\xdb\xe7\x8d\xf9\xf8\x21\x97\x5d\x47\x95\xe2\xb0\x52\x78\x34\xb6\x5a\x7f\x24\x44\xfc\x30\x40\xfc\x98\x19\x60\x75\x58\x6c\x41\x58\x23\x06\xb1\xa8\xa3\x5d\x10\xf7\x85\x8b\x77\x22\xac\x5a\xcb\x62\x43\x5e\x1e\x79\x12\x91\x7e\xa4\x1b\x0a\x89\xbf\xbc\x74\xe9\x4b\x2d\x56\x99\x58\x4c\xa6\xd2\x04\x72\x0b\x9d\xfe\xad\x76\xcf\x8a\x8e\x65\x0f\x66\xd0\x79\x53\x68\x2e\x9d\x4a\xe5\x5a\x2a\xa4\x53\x28\xb7\x90\x96\xa8\x5d\xa5\xdb\xb7\xbb\x74\xb9\x24\x99\xdc\xbe\x9c\xdc\xad\x3e\xff\x72\x5b\xe7\x8b\xba\x4f\x16\x7f\xb7\xe6\x97\x75\x8f\x34\x1d\xda\x74\x78\x73\xcf\x96\x3d\xbb\x77\xf4\x4a\x88\x84\xdd\xb1\x6f\x63\x57\xdd\xee\xc2\x73\xdc\xe3\x8e\x4f\x24\xd8\x3b\x50\x10\xf0\x7a\xb1\x3a\xea\x08\x44\x1d\x51\x47\x06\x26\x97\x59\x18\x20\xc1\x48\x90\x04\x05\x98\x54\xb1\xa4\x05\xe1\x19\x2c\xb9\x8b\xc5\xbf\x7d\xfe\xf9\x6f\x78\x12\x4b\x94\x4b\x10\x86\x64\x3c\x12\x60\x8d\x08\xe0\xf0\xe1\x00\x79\x02\xf1\x96\x4d\x2c\x64\x24\xab\x11\xd7\xc5\x3c\x35\x75\x0f\xce\x62\x35\x91\xba\x69\xac\x9f\xcd\x44\xb8\xbb\x57\x87\x55\xce\x6b\xae\x80\x53\xbd\x61\x43\x4b\x73\x8d\x8e\xab\x76\xe7\xaf\xce\xd0\x44\x88\x78\xf5\xa3\xf9\xe7\xaa\xb5\xcd\xdd\x7b\x5a\xf6\xa8\x8f\x1c\xea\xea\x3f\xa0\x0b\x2f\x0c\x4f\x0b\x2f\x8c\x4e\x13\x95\x1f\x38\x54\x77\x44\xbd\x67\xcf\xf6\xb6\x6e\xdd\xb9\xbd\x8f\x9e\x79\x32\x43\x23\x4a\x14\x3f\xe9\x3e\xc3\xed\xd5\xb6\xd5\x6c\x68\xdd\xa0\x96\x7b\x51\x38\xf4\x2e\xc2\x53\x58\xa2\xcc\x44\x98\x04\xc8\x2a\x1c\xa8\x41\x98\x06\xe8\x2a\x7c\x19\x45\x83\xbf\xa0\xa8\x32\x6e\xbe\xe1\x60\x15\x8b\xbb\x51\xf9\xab\x2c\x66\x6e\x61\xb1\xea\x63\x44\x19\xc2\x3c\xc8\xd2\xcf\xe8\x67\xe4\x29\x74\x9e\x8d\x5a\xa6\xb0\x61\x0b\xf9\x89\x25\x4f\x21\xf2\x19\xf9\xac\x13\xe1\xf0\xda\x40\xd8\x11\xb6\x67\x60\x1a\x5c\xcf\x62\xe2\x17\x0c\x05\xc9\x6d\x28\x3a\x8d\xfe\x48\x7f\x8c\x4e\x8b\x4e\x23\x3f\xd2\x1f\xc9\xe3\x88\xfc\x18\x9e\x36\x81\xd5\x69\x22\x9f\x09\xc9\xac\x3f\x23\xa9\x0e\x47\x42\xa4\x0f\x0d\x2b\x99\x76\x36\x9c\xc0\xea\xae\x29\xc5\x74\x26\xb9\x9f\x8e\x24\x4d\xcd\x5a\xea\xa0\xab\x45\x15\xe5\xdd\xf6\x43\xea\xc8\x19\xe6\x50\xf7\xf1\xbe\x72\x1d\x75\x90\xd5\x22\xd2\xd4\x46\xee\x27\x23\xc9\xcc\x8c\x88\x52\x4c\xe6\xd0\x55\xe4\x66\x1a\xd0\x62\x55\x2f\x8b\xc7\xa3\x05\xb7\xa0\x68\x68\x36\xc2\x73\x59\x2d\x56\x91\x52\xaa\x24\x69\xd4\x40\xc7\x8f\xa2\x22\xaa\xa5\x69\xdf\x53\x86\x8c\x7d\xf9\xe5\xfe\xc3\x8f\x6a\xb7\x33\x37\x57\x2e\x1c\x4f\xa5\x6a\xd7\xba\xb6\xf6\x0a\x5d\x5d\x6b\xdd\x8e\x86\x1d\x85\x54\x34\xa2\x6b\x53\xf7\xa6\x9e\x4d\x92\x86\x87\x4f\x36\x3d\xa9\x26\x0d\x24\x81\xb8\xc9\x6a\x1d\xa6\xab\x68\x00\xab\x7e\x45\x69\x7e\x84\x2b\x11\xc9\x62\x75\x7c\xbc\x7c\x86\xa5\xa3\x70\xb0\xbd\x3d\xa8\xc3\x6f\xbf\xf4\xd2\xdb\x58\x74\x8a\xc5\x73\xee\xbb\x6f\x8e\x0e\x9b\xd8\x70\x30\xaa\xac\x65\x71\x47\x0b\x71\xb0\x94\xcf\x7e\x6d\x4d\x8d\x3b\x1a\xd4\x7c\x2a\xc0\x55\xdd\x35\x24\x8d\xe5\xcf\x9c\x28\x61\x2c\x82\x63\x72\x0a\x51\x3f\xb3\x74\xcd\xd9\x41\xdd\x51\xf2\x2b\x22\x2f\xa2\x05\x0c\x39\x82\x86\x2d\xe4\x49\x56\x1b\x56\x32\xe4\x1a\xe2\xc7\x44\x95\xcc\x11\xa4\x8b\x2a\xf9\x5e\xe2\x27\xdf\xa0\x12\x71\x3e\xd2\x2e\x98\xc6\x5e\x64\xc8\x71\x52\x1d\x16\x22\x1d\x56\x2d\x43\x9a\xc8\x0c\xc6\x90\x97\x67\xd0\x69\xe8\x0c\xd2\xc6\x92\x9b\xd9\xc5\x28\x1a\x52\x91\x14\x16\xab\xf8\x14\x78\x1f\xd2\x62\x6a\x6f\x62\x71\x6d\x57\x4f\xd3\x5e\x35\xef\x87\x41\xac\x61\xea\x30\x99\xc2\x0e\xdd\x2e\xe6\x87\x68\xa9\xf2\x73\x44\x76\xa1\x43\xc7\x75\x43\xb7\xbf\x84\xb0\x8a\x06\x5b\x11\x09\x92\xa9\x2c\xae\x64\x79\x9f\x15\x60\x1a\x20\xcf\xb2\x24\x80\xcb\x58\xe2\x64\x89\x65\xc1\x33\x88\xb7\xe9\xa1\xba\x56\xa4\x61\xea\x32\x11\xfe\xe4\x93\x4f\x72\x9e\x63\xb1\x23\x87\x2b\x2c\xe4\xea\x36\x6e\xac\xdd\x51\xc9\x3b\x58\x75\x6b\x77\xed\x9e\x6d\xdb\x02\xdb\xd4\x87\x77\x1c\xda\xf9\x48\xfb\x2f\x0f\x7f\x77\xf6\x93\x97\x25\xf5\x2f\xbe\xdc\x7c\x5e\x1d\x4e\x27\x6f\x92\x2a\x72\x02\x87\x47\x93\x5c\x32\x82\xdc\x0b\x03\x24\x97\x8c\x25\x8d\x61\x21\x49\x26\x1f\x93\x5c\x41\xe4\xd6\x21\xac\xa2\x6e\x3a\x9e\x66\xd2\x75\xd4\x41\xef\x24\x33\x88\x9d\xd8\x09\x4f\x1d\x78\xc0\x7b\x3a\x30\x30\x90\xfe\x16\x8b\xf3\xd0\x35\xcb\xf5\x54\x1e\xb1\x78\x11\x5e\x8c\x86\x94\xaa\xf0\x54\x7a\x85\x5c\x89\x4e\xa5\xcb\xe9\xfd\xd3\x68\x3a\x1d\xa5\xa5\x69\x44\x55\xb5\xcf\xbd\xd3\x5f\x9f\xee\xab\x5f\xef\x5f\x97\x11\x37\x73\x06\x67\x9c\xe3\x8d\x88\x8a\x8b\x89\x98\x21\x4a\x96\x98\xc8\x07\x2c\x5e\xd9\xc3\x04\x10\x99\x8b\x98\x58\xa0\x45\x30\x40\x7c\x48\x23\x1a\xe4\x8d\xde\x98\x85\x48\x37\x83\x5f\x67\xb5\x78\x2f\x79\x8a\xd5\x92\x10\x09\x89\xda\xda\x5a\x83\x1d\x19\x58\xdc\xd2\xbe\xb9\xad\xb9\x6d\x78\xc5\xd0\x8a\x11\xde\x81\x8a\x06\x7b\x06\x56\x91\x5b\x59\xd2\xc5\xde\x8f\xf0\x63\x68\x12\x5f\x11\x04\xca\x1b\x58\x4c\x8f\xd3\x6a\x5a\x4d\x8f\x63\x12\xd8\xc9\x62\xd5\xed\x88\xfa\xa9\x9f\x21\x6f\xb3\xc4\x4f\xfd\x62\xf2\x26\x4b\xfc\xc4\xcf\x60\xd5\xdb\x08\x67\xa1\x1f\x70\x2b\x7b\x2d\xc4\x64\xa3\x48\xa8\x95\x8d\x69\xfb\x43\x84\xc3\xc1\x34\x22\x67\xb5\x01\xf1\x7c\x56\x17\x0d\x86\x83\x2e\x16\xd3\x77\xe8\x2e\xba\x8b\xbe\x43\xdf\x21\xbb\xe8\x2e\xf2\x0e\x79\x87\xec\x22\xbb\xc8\x3b\x58\x35\x81\xd5\x62\x72\xe6\x28\xf1\x93\x16\xf2\x6c\x06\x2e\x65\x89\x12\x57\xb1\xf2\xdf\xa6\x12\xb4\x52\x4b\x73\xa8\xf2\x28\x4d\xca\x20\x4f\xa3\x77\xfe\xf5\xc2\x6f\x5a\x4c\x82\x24\x18\x37\xd8\xef\x11\x51\x0a\x30\x51\xf2\x6d\xa2\xc4\x76\x17\xb9\x83\xc5\xaa\xae\xdd\x81\xbe\xda\xdd\x1b\xbb\x2a\x02\x1b\x6b\x69\x90\x06\x47\xd4\x6e\x0c\x54\x74\x6d\x94\xfc\xaf\x0a\x0c\x92\xa0\x08\x2f\x60\x3f\x40\x98\x99\xce\x62\xed\x04\xe2\x67\x96\x21\x0d\x9d\xb1\x8a\xb7\xd8\x62\x56\x23\x1c\x5c\x81\x88\xff\x07\x31\x16\x2f\x5d\xb3\x66\xa9\x2e\x1a\x22\x53\x11\x8e\xa8\xc8\x54\x15\x85\x0c\x5d\x43\x9e\x25\xf7\x90\x3e\x11\x49\x26\xd3\x68\x27\x43\x47\xd2\x4a\xaf\x75\x53\xd3\xe6\xa6\x2d\x4d\xe9\x2d\x0c\xfe\x18\x2d\x7f\xee\x41\x16\xab\x7e\xe2\x03\x32\x5f\xa2\x10\xc5\xb8\x5f\xa8\x42\x8b\x55\x97\x11\xde\xb8\x31\x50\xb1\x7b\x23\x9e\xc1\x97\x82\x2a\xf2\x11\x8b\xc5\x44\xc0\xe2\x0f\xf8\x0d\x93\x5d\xec\xe7\xa6\x51\x58\xd5\x7f\x51\xd4\xdb\xb6\xaf\x7b\xaf\x3a\x7c\x95\xe9\xed\xac\xa9\x6a\xd6\x95\x2f\x10\x55\x35\x57\xd6\x54\xab\xa3\x57\x99\xaa\xfa\xee\xde\x36\x1d\x76\x21\x7e\x86\x32\x40\xb6\xb1\x98\x58\xd8\x6c\x16\x7b\xbd\x81\x82\x01\x2f\xde\xbd\x3b\xd0\xb7\x71\x37\x2e\x46\x9a\x48\x1d\xc3\x67\x3f\x9d\x26\x52\x47\x76\x22\xbe\x8a\x59\xbe\x7c\x1e\xc2\x64\x27\xdd\xb9\x18\xd1\x9d\x64\x27\xde\xbd\xb1\x2f\xb0\x7b\x77\x3a\x56\x85\x6f\x23\x9f\xd0\x4f\xa2\xb7\x45\x6f\xa3\x7f\x52\xf2\x49\xf8\x36\xbe\x9f\xa7\x3a\xac\x9a\x8e\x30\x31\x92\x6f\xd8\x68\xe8\x22\xa2\x46\x2c\xaa\xed\x6a\xee\xd9\x9b\xb1\xb7\xad\xa7\xab\x4b\x8b\xc9\xad\x48\x8b\x27\xb3\x33\x58\x4c\x5a\xc8\x20\xb9\x85\xc5\xcd\xed\xe4\x55\x16\x93\x95\x48\x87\x89\x1d\x69\xb1\xa8\xa5\xa3\x63\x4b\x87\x7a\xd7\xae\xd6\x9d\x41\xdd\xde\xce\xae\x9e\xd6\x7d\x24\xb8\x18\x8d\xd8\x31\x50\x7f\xb0\x7c\x8f\x04\x13\x0b\xd9\xc8\x56\xb3\xd1\xd0\x18\x16\x93\xb5\x6c\x00\x4d\x60\x62\x93\x05\x24\x89\xc5\xe1\x69\xe4\x47\x3e\x76\xeb\xe4\x7c\x41\x81\xef\x46\x61\x25\x35\x92\x66\x16\x6b\x84\x9f\x91\xd8\x3d\x05\xe7\xa1\x1b\x35\x8b\x97\x6f\x68\x22\x83\x4c\x36\x5f\xda\x79\x11\xce\x47\x74\x14\x26\xe6\x13\xd7\x7d\x08\x93\xf7\x79\x6d\xf7\x6a\x89\x85\xe9\xed\xc6\xc7\xc8\x1c\x16\x8f\x24\x14\x0d\x85\x2e\x06\x88\x32\x25\x70\x9a\xaf\xa4\x48\x30\x0c\xd9\x54\x3b\x26\x86\x8f\xa6\x6c\x6e\xd5\x05\xeb\xb6\xad\x6f\xac\x5d\x3a\x7d\xc4\xa6\xc6\x86\x4d\xf5\x5b\xeb\xb7\x36\xec\x68\x6a\x97\x04\xb0\x2a\x44\x5c\xed\x7d\xdb\xf6\xb4\x76\xa5\xb7\xf6\x89\x76\x30\xcd\xdb\x9a\xb7\x35\x6a\xbb\x1e\xba\x44\x5d\xa2\x61\x29\xce\x20\x57\x56\xa9\x68\x02\x4d\x20\xb1\xbf\xf8\x8b\x26\x10\x48\x13\xc4\x24\x17\xbf\x14\x73\xd9\x72\x56\xfe\xf0\x81\x9e\x83\x9d\xba\xce\x03\x9b\x1e\xad\xec\xc5\xb5\xb5\xeb\x9b\xab\xd5\xd5\xeb\xdb\xba\x6a\x75\x58\xbc\x0c\x61\x7e\x51\x44\x89\x0f\x93\xbc\x15\x24\xfb\x56\xa2\xe0\x6b\xcf\x11\x34\x63\x36\xc2\xd4\x12\x0e\xa9\x7a\x6b\xba\xab\xb4\xd4\x92\xc3\x12\x0b\x83\xf3\x10\xb5\x30\xd9\x88\xf0\x81\x86\x04\xe8\x2a\xb2\x8a\x06\x56\xf2\xe1\x90\x34\xf2\xb7\x29\xfc\x33\x0a\x2b\x31\xd9\xc2\x1e\xc2\x64\x90\xb4\x60\xd2\x8f\xf8\xfa\x05\x67\xb3\xf2\x14\xde\x29\xc2\x37\x91\xd3\xf4\x01\x22\x25\xbb\xc9\x19\x5a\x44\x64\xa9\xc3\x33\x34\xc2\x47\x71\x7f\x29\x1b\x20\x6d\xb1\x1a\x3f\x48\x46\xb2\xf8\x22\xaf\xdf\x69\x08\x0f\xad\x18\x5a\xd1\xd6\xb6\xa3\xad\xb5\x3d\x1d\x0f\xaf\x18\x5e\xd1\xdc\xbc\xb9\xb9\xa5\x29\x1d\xb7\xb0\xeb\x59\x4c\x95\xb3\x10\x1e\x18\x08\x9c\xf6\x0e\x60\xef\x40\xe0\xf4\xc0\x00\xae\x6e\x5f\xdf\x55\x8b\xc9\x5b\x68\x02\xd2\x11\x0b\xc2\xaa\x69\x1f\xad\x20\x09\x44\x9e\x41\xe4\xcf\x92\x84\xcb\x1f\x69\x2f\xdf\xfe\x2c\x4d\xa0\xf2\x0c\x7c\x68\x5f\xc7\xe9\x8a\xc3\x74\x16\xd9\x3d\x62\xcf\xa9\xd3\xc1\xb3\x6a\x32\x9b\x8c\xa1\x63\xe8\x6c\x9c\x16\xd8\x4c\x36\xd1\x5b\xc8\x74\xed\x1a\x86\x68\xa8\x7d\x0b\x5d\x11\xc8\x08\xb4\xd0\x9d\xf8\x7b\x36\x16\x04\x3e\x66\x23\x96\x99\x08\x33\xef\xf3\xd5\x46\x38\x98\x89\xf0\xde\x9e\xf6\xae\x2e\x1c\xab\x03\x71\xb4\x21\x3a\x2e\x3a\x2e\xda\x10\x6d\x08\x8f\x8b\x8e\x0b\x37\x84\x1b\xc2\xe3\xc2\xe3\xc2\x0d\x58\xd7\x59\x5b\xd7\xbe\x5e\x4d\x9f\x5a\x4a\x7f\xa6\xe5\x34\xfb\xf7\x09\xc4\xa8\x1b\xba\xc6\x60\xbd\xb8\xaf\xaa\x6b\x9d\x27\x83\x8f\x04\x7c\x5e\x7c\xa4\xeb\xe1\xbe\x5e\xed\x57\x62\x3c\x1f\x91\x7a\x16\x93\xe5\x48\x2e\x5e\xf8\xdc\xf2\x57\xc9\x7e\xa4\xc5\x35\x61\x01\xea\xe6\x03\xd2\x1d\x08\xc7\x2e\x20\x3a\xcc\x57\x9a\x58\x54\x55\x55\xef\xf5\x66\x78\x3b\xbd\xbd\x55\x5a\xac\xf2\xf8\xfd\x1e\xed\x38\xc6\xe3\x3f\xf0\x88\x0e\x67\xb1\x34\x68\x42\xd8\xdf\x55\xde\x57\xab\xdd\xd4\xb9\xab\x65\x97\x7a\x17\x66\x62\x45\x04\x0e\xa7\xb0\x6d\xe4\x07\xd4\x5c\xdb\xa5\x8b\x87\xbd\x20\x09\xe2\xf0\x54\x72\x85\x5c\x09\x4f\xc5\x0c\x51\xfc\xf2\x0b\x51\xe8\x70\x38\x58\x8c\x70\x3b\x4b\xba\x10\x1e\xc3\x12\x23\x26\xbf\x91\xd3\xf4\x34\xfd\x0d\x8b\xaa\x7a\x07\xea\x07\xd4\x18\x06\x22\x41\x41\x24\x88\xc5\x1b\x59\x4c\x16\x12\x15\x11\x90\xfb\xb6\xe8\x1e\x7f\xae\xff\xe2\xc5\x8c\xee\xad\x7b\xb6\x74\x6b\x71\xff\x65\x35\xf1\xb1\xe4\x34\xf9\x0d\xdf\xf7\xd6\x6c\x97\xbf\xb9\xae\x4a\x4b\x0f\x8b\xeb\x7b\x0f\x6c\x3a\xa4\x7e\xe7\xa5\xb7\x70\x7b\x47\x47\xb0\x2d\x98\x1e\x16\x85\x1f\x11\x7d\x15\xbd\x48\xab\x88\x94\x88\xb1\x8a\xf8\x49\x33\x7f\xeb\x9c\xcb\xea\xa8\x3f\xaa\xc4\x21\x1b\xc1\x59\x59\x36\x8a\x67\xcd\x3a\x45\xf1\xd7\x5f\x9f\x22\x38\xa4\xc5\xd7\x2c\x9d\x6c\x2c\x5e\xc5\x62\x75\x20\x16\xbc\x62\x25\x87\x1e\x61\x22\xe4\xc3\x7f\x03\xab\xe5\x9d\x72\x1f\xc2\x6d\xed\x3b\x3a\x82\x19\x78\x60\xe0\x74\x60\xc0\x8b\x61\x6c\xcf\xc1\xe6\x36\x2d\x26\x77\xf3\x39\x4f\xcc\xef\xaa\xfe\xe0\xc3\x19\x03\x9d\x07\x7b\x7b\xb5\x64\x3c\x19\x27\xda\xdb\x8b\x17\xfc\x17\x61\xaa\x6e\xaf\xd8\xc3\xf5\x70\x07\x0a\x0e\xb4\x1e\x68\xdf\xdf\x21\x69\x3b\xbe\x95\x0f\x5b\x21\x62\x0c\x2b\x49\x10\x06\x88\x51\xc3\x0c\x12\xa3\x00\xf7\xf4\xb4\x75\x75\xe9\x86\x04\xe1\x1f\x45\xc1\x20\xf1\x90\x55\xa4\x29\x03\x2f\x61\xe9\x19\x12\x42\xe4\xaa\x18\x93\x79\x2c\x7f\x09\x51\x46\x2c\xaa\x65\x08\x6f\x69\x6f\x69\x6f\x6e\x6f\xda\xdd\xb4\xa7\xa1\x9b\xea\x48\xe5\x08\x7a\x28\x56\xc3\xd2\x55\xe4\x0a\x92\x8f\xcc\xd1\x30\x06\xf2\x35\xc2\x81\xb0\x84\xc5\xe2\xe3\x15\x41\xaf\x57\x8b\xc5\xf6\xbe\x86\x81\x01\x2d\x26\x62\x2a\xc6\xd4\x4e\x67\xe0\x17\xa9\x98\x6a\xce\xd3\xa9\x6a\x5a\x44\xcb\x69\xb2\x6d\x81\x0e\x3f\x54\x59\xe0\x28\xd1\x76\x95\xb7\xf9\x7c\x19\xab\xfc\x4b\xac\x7e\x2d\xce\x88\xdb\x9e\x76\xe8\x1a\x43\x8c\xbf\xff\x40\xb2\x75\x98\xa1\x8a\x71\xe3\xa8\x42\x37\x1c\x22\x1f\x22\x9c\xcd\x86\x43\x98\xc8\xd9\x23\x7c\x68\x58\xca\xc2\x00\x26\xb7\xb0\x7c\x21\x8b\x27\x21\xfe\x9a\x83\xdf\x8d\x65\x93\xd9\x64\x0c\x19\x43\x66\x63\x55\x00\xe1\x1f\xc4\x13\x11\x7e\xac\xe6\x98\xff\xa0\x16\x07\x16\xf3\xf3\xc4\xc7\xf1\x9a\xe9\xf4\x3f\xd1\x6b\x85\x19\x01\x31\xcd\x27\xa7\x72\x49\x36\x26\xb3\xe8\x6e\x51\x65\x57\x5f\x7d\xbf\xba\x6b\x77\x6b\xc7\x2e\x5d\xfc\xc4\xfe\xfa\x1f\x93\xc7\x59\x3f\x3b\x74\x86\x18\x10\x26\x5a\x52\x47\xb4\xe1\x20\xd1\xde\x49\xee\x21\x4a\xa2\xc5\xe7\x8a\x4f\x70\x5c\x71\x31\xc7\x9d\x28\x3e\x77\xee\xc4\x89\x73\x5a\x9c\x41\x84\x01\x22\xdc\x42\x84\xda\x86\xfa\x6d\x0d\x6a\xeb\x56\xfc\x02\x92\xef\xec\x6a\xdd\xdd\x9d\xc1\x5f\x94\x71\x2c\x73\xc7\xfe\x78\xaf\xe9\x64\xb7\xf0\x56\xc2\x27\xf5\x4d\xec\x6f\xf8\xcb\x4b\x79\x06\x1c\x4b\xde\xb5\xe9\x4f\xad\xea\xaa\xed\x0b\xec\xee\x4a\xc7\x44\x59\x83\x70\x34\x9d\xbe\x49\xab\xe8\x09\x6a\xfe\x2f\x1d\x4b\xcc\x93\x30\x79\x87\xee\x22\xb1\xe2\x22\x5e\x64\xe0\x77\x48\x22\xe1\xde\x23\x63\xd4\x44\xf1\x61\xc1\xb2\x5f\x74\x98\x6c\x44\x43\x96\x25\x2c\x26\x4b\x89\x9e\xe8\xc9\x52\x9e\x52\x3d\x5d\x8a\x35\xa2\x41\x06\x9f\x66\x19\x4c\x82\x34\x88\x17\xcf\x78\x41\xd7\x55\x1d\xac\xda\x55\x2d\xa9\x6b\xef\x68\xc6\xd5\x61\x80\xb4\x34\x44\x43\xa2\xe6\xe6\x16\xac\x11\xf9\x54\x64\x0a\x8b\x67\xb2\xf4\x8c\x18\xf7\xf7\x97\xb7\xb0\x78\x4b\xfd\xf6\xfa\xb6\xc6\xf4\xa6\x36\xdc\xc4\x07\xee\x76\x3e\x70\xef\xae\xed\x0b\x74\x75\xa5\x3f\xf5\x14\xbe\xfe\x95\x08\x09\xe2\x7c\x3e\x19\x9e\x21\x67\xf8\x99\xf0\xfd\x48\xb5\x20\xf2\x0a\xa6\x21\xf1\x24\x84\x55\x44\x8c\xb4\xbc\x47\xc4\x22\x98\xf0\x24\x11\x17\x31\x18\x06\xfc\xac\x00\x87\x01\xab\xc5\x54\xa5\x61\x12\x20\xa6\xca\xd3\x2c\xc4\xcc\x38\x84\x87\x43\x62\x6a\xc0\xe2\x70\x02\xc2\x1d\xc1\xd6\xb6\x36\xbc\x09\x89\x31\x15\x13\x31\xe6\x8d\x92\x2f\x17\xe7\xcc\xa3\x4c\xe5\x8a\x4e\xd7\x66\x6d\x15\xf6\xb3\x42\x4d\x04\x2c\x46\x8b\x91\x18\x77\xf5\x74\xee\xed\xd8\x27\xe9\xdb\x4e\x54\xdd\x7b\x32\x30\x61\xc9\x84\x0c\x32\x61\x31\x61\x27\xfe\xaa\x3d\x81\xa9\x52\x4c\x7e\x67\x71\x46\x77\x47\x67\x77\xab\xf6\x9b\xbe\x37\x2e\x3c\xfe\xa9\x04\x37\x36\x77\x74\x6c\xd3\xbd\x16\x9e\x28\xda\xb5\xad\xb3\x83\xdf\xd1\x66\x14\x73\xde\xcd\x08\x73\xf6\x33\xba\xd2\xc7\x0e\x54\xfe\x43\xfd\x8f\xfd\xfb\x0e\x63\x46\x8f\x48\x1a\xd2\xe1\x8e\xb6\x5d\xed\xba\x5d\x7b\x83\xbd\x5d\x7b\x25\xef\xbd\x80\x37\x21\x15\xee\x68\xe9\x50\xe3\x2d\xac\x0a\x5f\x0c\x90\x9f\x10\x3e\x80\xce\xf1\x7b\x2e\x64\xc3\x46\xf1\x71\xdc\xbd\x37\x83\x28\xc5\xc1\x1d\x1d\x6d\x6d\xda\x36\x6c\x44\xc4\xb2\x92\xc5\x74\xcd\xb5\x85\x22\xf2\x05\x43\xd6\x44\x16\x8a\xe2\x57\x71\x6a\x99\xc8\xc6\xcc\x9e\x04\x71\x74\x2a\xb9\x42\xf9\x38\x18\xe6\xef\x94\xe1\x86\xe8\xb8\xf0\xb8\x68\x03\x5f\x4a\x34\x23\x4c\x43\x31\x13\x8d\xa2\x00\x3e\x41\xc2\x2c\x7e\x9c\xe5\xaf\xca\x98\xfa\xc5\xe3\x59\x3c\x19\x8d\xe5\xa5\x5c\x24\x4a\xac\x89\xcc\x10\x63\x0f\x22\xb7\xb2\x78\x9d\x7f\xbd\xbf\x5e\x57\xef\xdb\xe9\xde\x57\x85\x75\xcd\xcd\x9b\x1b\x1b\x32\x7c\x64\x2c\x1d\x83\xff\xf7\xe5\x56\xcc\x4e\x53\xc8\x11\x16\x1b\x0c\x9b\x0d\xea\x72\xba\x60\x7b\x6b\x13\xef\x27\x27\xf9\xfa\x88\x0f\x30\x98\x79\x88\xc5\x1b\x6b\x03\xe5\xbb\x6b\x71\x3f\xf9\x18\x41\x5c\xb3\xd6\x91\xe1\xe8\xc6\xe2\x3c\x16\xd3\x19\x64\x06\xa6\x2c\xd5\xd6\xd5\x6d\xad\xec\xdc\x98\x8e\x19\x92\x87\xf8\xbb\xfc\x82\x8a\x14\x6c\x1a\x39\xca\xf8\xf9\xef\xbf\x7d\xf1\xc5\x6f\xbf\xe3\x8a\x12\x1d\xad\x16\x6f\x68\x6a\xda\xa0\xc5\xda\x89\x63\x16\x53\x96\x4e\xc8\xa0\x13\xb0\x8a\xca\x28\xa6\xdb\x98\xda\x86\x00\xd6\xb6\x36\x36\x6c\x6f\x50\x4f\x42\x37\xd6\xc7\x87\xd8\xf8\xd7\x79\x44\x89\x55\xe4\x2c\x7f\x5b\x62\x8a\x09\xc3\x60\x91\xef\xc0\xb1\x9a\xc7\xd4\x98\xd9\xdb\x53\x53\xb5\x4d\x87\x45\xbd\xdb\x7a\xba\x63\x17\xae\xb0\x88\x37\x7c\x65\x38\xa4\xc2\x03\xac\x16\x17\x51\xf1\x49\x06\x8b\xc9\xd3\x08\x0f\xf1\x9b\xa5\x37\xd3\x39\xbc\x93\x5a\xb0\x66\x68\x06\x83\xa3\xca\xb0\x12\xdf\xfa\xe0\xb9\xe3\xf9\xba\xc3\x0e\xff\x3e\x4c\x8e\x22\x7e\x36\xb9\x1f\x61\x2a\xb9\x42\x6f\x22\xc6\x65\xe4\x1f\xb8\xa2\xb4\x52\x77\xb8\x6a\x6d\x9f\x5d\x8d\xd5\x74\x04\x05\x14\xd0\x11\x3a\xac\x7a\xdc\x7d\xa0\x68\x85\xad\x70\x45\x21\x16\x3f\x88\x8a\x58\x2d\xd6\x6a\x84\x7c\xb9\xe6\xad\xf7\x55\x55\x69\xe9\x78\x3a\x0e\x93\x91\x2c\x1f\x0d\x30\xe5\xcf\x4a\xd4\xd5\xd5\x83\xa9\x92\x2a\x31\xb1\x93\x19\xb8\xbf\x1c\x06\x30\x04\x10\x00\x0c\xc1\x48\x00\x6a\x00\x68\x04\x60\x2b\x00\xdb\x01\xe8\x06\xe0\x61\x08\x8e\x00\xb8\xf9\x8f\x84\xcd\x7f\x08\x36\x9f\x4e\x78\x41\x00\xf8\xa1\x26\x00\x72\x01\x78\x11\x80\xdf\x00\xec\x00\xb0\x13\xc0\x2e\x00\xbb\x01\xec\x01\xb0\x17\xc0\x3e\x00\x4f\x03\xf8\x04\x80\x11\x90\xa0\x07\x09\x77\x83\x84\x2f\x80\x40\x02\x04\x39\x40\xd0\x0a\x04\x17\x80\x30\x1d\x08\x73\x80\xb0\x01\x08\xdf\x04\xa2\x51\x40\xd4\x03\x44\x5f\x03\x26\x19\x30\x3b\x01\xf3\x06\x90\x30\x40\xb2\x11\x24\x4a\x40\x62\x06\x48\xbc\x1b\x24\x5e\x05\x68\x21\x40\x3b\x01\xfa\x18\xe0\x3b\x01\xae\x02\xf8\x13\x20\xdd\x0d\xa4\xdf\x01\xd9\x6d\x40\xf6\x18\x90\xcf\x02\xf2\xc5\x40\xde\x0e\x14\x1b\x40\x52\x0e\x48\xce\x01\xc9\x53\x41\x72\x23\x48\x71\x82\x94\x5a\x90\xf2\x0b\x48\x5d\x05\x94\x26\xa0\xd2\x02\xd5\x71\x90\xd6\x0a\x6e\x2a\x05\x37\x75\x83\x9b\x9e\x05\x37\x7d\x0b\x6e\x8a\x80\x11\x13\xc0\x88\x87\xc0\x88\x9d\x60\xc4\x07\x20\x7d\x1a\x48\x7f\x1e\xa4\x53\x90\xa1\x00\x19\x9d\x40\x9d\x0f\x34\x93\x80\xe6\x7b\xc0\xce\x03\x2c\x07\xd8\x2a\xc0\x3e\x0c\xd8\x10\x60\x7f\x07\xec\x1f\x40\x3b\x1e\x68\xef\x00\xda\x07\x80\x76\x13\xd0\x9e\x07\x3a\x08\x74\x77\x00\x5d\x01\xd0\x45\xc0\xc8\x25\x60\xe4\x47\x60\x54\x26\x18\xf5\x2e\x18\x3d\x11\x8c\x5e\x0d\x46\x9f\x07\x37\x67\x82\x9b\xfb\xc1\x18\x29\x18\xb3\x0e\x8c\xf9\x08\x8c\xf9\x01\x8c\x15\x80\xb1\x1b\xc1\x38\x13\x18\xf7\x25\x18\x3f\x13\x8c\xff\x11\xdc\xca\x80\x5b\xdb\xc1\x6d\xf3\xc1\x84\x9b\xc0\x84\x41\x30\x51\x0b\x26\x96\x82\x89\x87\xc1\xc4\xcf\xc1\xa4\x76\x30\x39\x05\x4c\xce\x02\x93\xbb\xc0\xe4\x8f\xc0\xe4\x6b\x60\xca\x62\x30\xe5\x0a\xc8\x14\x83\xcc\x56\x90\x95\x0b\xf4\x97\x80\x9e\x02\xa3\x1a\x98\xd6\x01\xd3\x56\x60\xfa\x1d\x98\xa7\x01\xf3\x20\xc8\xce\x02\xd9\x95\x20\xfb\x19\x90\x63\x07\xb9\x11\x70\xfb\xfd\x60\x6a\x25\x98\xc6\x82\x69\x16\x30\xad\x1e\x4c\x67\xc0\xf4\x13\x60\xfa\x10\xb8\xb3\x19\xdc\xf9\x14\x98\x31\x0a\xcc\x78\x0f\xcc\x5c\x0b\x66\xfe\x04\x66\xed\x06\x79\x3d\x60\x76\x2b\x98\xf3\x28\x98\x3b\x08\xe6\x5d\x01\x77\xcd\x07\x77\x9d\x06\x77\x8b\xc0\xdd\x16\xb0\x48\x0d\x16\x75\x82\x45\x9f\x81\x7b\x47\x83\x7b\x2b\xc1\xe2\x54\xb0\x58\x05\x16\xdf\x04\x16\xa7\x83\xc5\xef\x82\x25\x93\xc0\x92\x72\xb0\xe4\x0d\x60\x79\x18\x3c\x30\x0f\x2c\xd5\x80\xa5\x8f\x82\xa5\x27\xc0\xd2\x57\xc1\x83\x2c\x58\x96\x05\x96\x2f\x03\x2b\x5e\x02\x2b\x27\x80\x95\x2f\x80\x87\xf2\xc0\xaa\x24\xb0\x6a\x10\xac\x8a\x82\xd5\x41\xc0\x4d\x00\x5c\x2e\xe0\xe6\x01\xce\x0d\xb8\x0e\xc0\xbd\x03\xb8\xaf\x00\xf7\x1f\xc0\xfd\x01\xd6\xb4\x01\xeb\x08\x60\x9d\x07\xf2\xcd\x20\xff\x79\x90\xff\x15\x28\x58\x0c\x0a\x5e\x01\x85\xe3\x41\xe1\x65\x60\x5b\x04\x8a\xe6\x81\xa2\xbd\xa0\xe8\x0a\x28\xbe\x03\x14\x7f\x08\xec\x2d\xc0\xfe\x26\x70\x4c\x02\x8e\x3a\xe0\xf8\x0a\xac\x1d\x09\xd6\x5e\x06\x25\x15\xc0\x39\x16\x38\xbb\x41\x69\x36\x28\xed\x03\xa5\x2f\x83\xd2\x9f\x81\x6b\x0c\x70\x4d\x05\xae\x7b\x81\xab\x00\xb8\x9a\x80\xeb\x39\xe0\x7a\x0d\xb8\x3e\x04\xee\xd1\xc0\xdd\x0e\xdc\xff\x02\x1e\x16\x78\xc6\x01\xcf\x1d\xc0\xb3\x0c\xac\x83\x60\x1d\x02\xeb\x6a\x80\xf7\x6e\xe0\x6d\x07\xbe\x1c\xe0\xbb\x1d\xf8\xa6\x01\xdf\x76\xe0\xfb\x04\xf8\x22\xc0\xbf\x15\x94\x6d\x05\xe5\xd3\x40\xc5\xdd\xa0\xc2\x0e\x2a\x42\xa0\x72\x1e\xa8\x7c\x03\x54\x8d\x04\x55\x8d\xa0\x7a\x1c\x58\x6f\x06\xeb\xcb\xc0\xfa\x27\xc1\x06\x1d\xd8\xd0\x00\x36\xbc\x07\x6a\xfe\x01\x36\x8a\xc0\xc6\x3d\x60\xe3\x2f\x60\x63\x14\xd4\x3e\x01\xea\xf2\x40\xdd\x5e\x50\xf7\x3e\xa8\x4f\x06\xf5\x0b\x41\x7d\x33\xa8\xff\x0e\x34\xe4\x82\xc6\x24\xd0\x98\x07\x1a\x37\x80\xc6\x1e\xd0\x78\x16\x34\xe9\x41\x53\x2b\x68\xce\x01\xcd\x4b\x41\xf3\x0e\xd0\xfc\x33\xd8\xb4\x18\x6c\x6a\x01\x9b\x13\xc1\xe6\x02\xb0\xf9\x33\xd0\xa2\x04\x2d\xf7\x83\x96\x76\xd0\xf2\x05\xd8\xf2\x02\xd8\x7a\x2f\x08\xa4\x82\xc0\x49\xb0\xed\x6e\xb0\xed\x75\xb0\xfd\x3b\xd0\xfa\x25\xd8\x71\x33\xd8\xb1\x01\xec\xb8\x00\x76\xde\x04\x76\xde\x03\x76\xb6\x81\x9d\xe7\xc0\xce\x4f\x40\x5b\x2f\x68\x5f\x03\x82\x4f\x80\xae\x74\xd0\xf5\x02\xd8\x5d\x0a\xba\x11\xe8\xee\x00\x7b\x20\xe8\x59\x0c\x7a\xdc\xa0\xa7\x1f\xec\x1d\x04\xbd\xff\x06\xfb\xb2\xc0\xbe\xad\x60\xdf\x65\xd0\x77\x1b\xe8\xab\x04\x7d\x2f\x83\xfe\x9d\xa0\xff\x0d\xb0\xff\x35\xf0\x88\x11\x3c\x5a\x04\x0e\x4d\x06\x87\x05\xe0\xf0\x5d\xe0\xf0\x7b\xe0\x88\x1a\x1c\x79\x00\x1c\x7d\x08\x1c\xfd\x05\x1c\xcb\x02\xc7\xbe\x07\x8f\x7d\x03\x4e\xec\x00\x27\x93\xc1\xc9\x0b\xe0\xd4\x78\x70\x2a\x0f\x9c\xaa\x00\xa7\x8e\x80\x53\x4f\x82\xc7\x57\x82\xc7\x87\xc0\xe9\x07\xc1\xe9\x7e\x70\xe6\x11\xf0\x44\x0b\x38\x2b\x01\xe7\x6e\x01\xe7\xf6\x80\x27\x59\xf0\xe4\x15\xf0\x54\x3e\x78\xea\x4d\xf0\xf4\xeb\xe0\x99\x13\xe0\xd9\xa9\xe0\xd9\x8f\xc0\x73\x4a\xf0\xdc\x31\xf0\x8f\xf9\x60\x70\x3d\x78\xe1\x29\xf0\xe2\x64\xf0\x52\x12\x78\xa9\x17\xbc\x7c\x1f\x78\xf9\x31\xf0\x4a\x11\x78\xe5\x38\x38\x7f\x1b\x38\xff\x3e\x78\xf5\x3c\xb8\xd0\x03\x2e\x76\x81\xd7\xb6\x80\xd7\xb7\x81\xd7\x2f\x80\x37\xd2\xc1\x1b\x1b\xc0\x9b\x6b\xc0\x9b\x47\xc1\x3b\x2b\xc0\x3b\xbd\x20\x74\x0b\x08\xfd\x13\xbc\x3b\x1f\xbc\xfb\x3c\x78\x0f\x82\xf7\x7e\x02\xff\x7e\x06\xbc\xaf\x05\xef\xbf\x0f\x3e\xf0\x80\xcb\xb9\xe0\xc3\x11\xe0\xc3\xcf\xc1\x47\xb3\xc1\xc7\x0a\xf0\x69\x2e\xf8\x6c\x2b\xf8\x3c\x0c\x3e\x1f\x06\x5f\xbc\x06\xbe\x7c\x0e\x7c\x35\x00\xbe\xfa\x03\x7c\x5d\x0c\xbe\x7e\x02\x7c\xfd\x6f\xf0\x7f\x7f\x80\x6f\xfc\xe0\x9b\x8f\xc0\xb7\xc5\xe0\xdb\x30\xf8\x7e\x22\xf8\xfe\x23\xf0\xc3\x31\xf0\xe3\x08\xf0\xe3\x66\x70\x65\x1d\xb8\xf2\x05\xf8\xf9\x4e\xf0\xf3\x55\xf0\xcb\xa7\xe0\x3f\x6e\xf0\xeb\x2a\xf0\x5f\x2d\xb8\x9a\x05\x86\xac\x80\xce\x87\x20\x0f\xc2\x73\x50\xd0\x0f\x85\x42\x28\x3c\x0a\x45\x99\x50\xf4\x36\x64\x3e\x81\xe2\x62\x28\xfe\x12\x4a\xb6\x40\xc9\x00\x94\x7c\x0a\x13\xc7\x40\x84\x21\xfa\x02\xe2\x45\x10\xef\x82\xd2\xdd\x50\x36\x17\xca\x27\xc3\xa4\x74\x98\xcc\xc0\xe4\x2a\x98\xb2\x0e\xa6\xbc\x0b\x55\x1f\xc0\x34\x23\x4c\xfb\x0a\xde\x14\x81\x23\xce\xc1\x8c\x5d\x50\x3d\x01\x6a\xb4\x50\xb3\x10\x6a\xf6\x40\x76\x1a\xd4\x36\x43\xdd\x0e\x38\xf2\x2c\x1c\x75\x07\x1c\xf5\x39\x1c\x3d\x15\x8e\xb6\xc3\xd1\x9f\xc0\x9b\x53\xe1\xcd\xdb\xe0\x98\x7c\x38\xb6\x18\x8e\x9b\x0d\xc7\xb5\xc1\xf1\x0c\x1c\xbf\x1d\x8e\x3f\x0d\xc7\x7f\x08\xc7\x7f\x0c\xc7\x7f\x0a\x6f\xd1\xc0\x5b\x9e\x83\xb7\x3e\x07\x6f\x1b\x0d\x6f\x3b\x08\x27\x74\xc2\x09\x9f\xc0\x89\x77\xc2\x89\x1e\x38\xf1\x2c\x9c\x34\x17\x4e\x7a\x00\x1a\xef\x80\xc6\x43\xd0\xb4\x11\x9a\x7e\x81\x66\x31\x34\xb3\xd0\x6c\x80\xe6\x3b\xa0\x79\x27\xcc\x4e\x84\x39\xa3\x61\xee\x6e\x98\xfb\x3a\xbc\x7d\x12\x9c\x3a\x17\x4e\xfd\x16\x4e\xcb\x85\xd3\x28\x9c\x3e\x1e\x4e\x7f\x08\x4e\xef\x86\xd3\x9f\x87\x77\xa4\xc1\x3b\x97\xc3\x19\x4b\xe0\xcc\xb7\xe0\xac\x67\xe0\x6c\x25\x9c\x33\x13\xce\x3d\x0f\xe7\x6d\x85\x77\xdd\x02\xef\x3a\x00\xef\x16\xc1\xbb\x4b\xe1\x82\x79\xf0\x1e\x0d\xbc\xe7\x7d\xb8\x70\x35\x5c\xb4\x02\xde\xfb\x1c\x5c\x5c\x09\xef\x9b\x01\x97\xc8\xe1\xfd\x63\xe1\xfd\x4e\x78\xff\x1f\x70\xe9\x51\xf8\xe0\x69\xb8\xec\x76\xb8\x6c\x09\x5c\xf6\x30\x5c\xf6\x15\x5c\x2e\x81\xcb\x57\xc1\xe5\xef\xc0\x15\x75\x70\xc5\x0b\x70\xe5\x04\xb8\xd2\x05\x57\x9e\x87\x0f\x15\xc2\x87\xda\xe0\xaa\x62\xb8\x7a\x39\x5c\xfd\x0d\xe4\xf4\x90\xfb\x12\xae\x31\xc1\x35\x17\xa1\x75\x3f\xb4\xfe\x04\x0b\x66\xc1\x42\x01\x2c\x9c\x0a\x0b\x1f\x84\x85\xe5\xb0\xb0\x07\xda\x46\xc1\xa2\x11\xb0\xe8\x1b\x58\xec\x86\xc5\xaf\x43\xfb\x22\x68\xff\x27\x74\x94\xc0\xb5\x33\xe0\xda\x0f\x60\xc9\x25\xe8\xfc\x18\x96\x36\x40\x57\x1f\x74\xf7\x43\x4f\x14\xae\xb3\x43\xef\x4e\xe8\x7f\x0a\x96\x95\xc0\xf2\xe5\xb0\xa2\x08\x56\xfe\x08\xab\x97\xc2\xf5\x5e\xb8\xa1\x01\xd6\x4c\x81\x1b\x19\xb8\xf1\x49\x58\xdb\x08\xeb\xa2\xb0\xfe\x24\x6c\x7a\x00\x36\x6d\x87\x4d\xd7\xe0\xa6\x32\xb8\x59\x07\x5b\x94\x70\xcb\xab\x70\xeb\x4a\xb8\x95\xc0\xc0\x05\xb8\xad\x1b\x6e\x97\xc1\xed\x7e\xd8\x9a\x06\x5b\xf7\xc1\x1d\xf3\xe1\x8e\x1f\xe0\xce\x93\xb0\x7d\x23\x6c\x7f\x1b\xb6\x7f\x08\xdb\xbf\x86\xed\x3f\xc3\xf6\x21\xd8\x71\x14\x06\x77\xc2\xce\xf3\xb0\xeb\x26\xd8\x65\x80\x5d\xf3\x61\xd7\x21\xb8\xfb\x66\xb8\xbb\x0d\xee\x3e\x0e\xf7\xbc\x08\x7b\x76\xc0\xbd\x05\xb0\xf7\x0f\xb8\xef\x1b\xd8\xf7\x06\xdc\x3f\x06\xee\x3f\x0c\x0f\x4c\x85\x03\x17\xe0\xc0\x6b\x70\xe0\x0d\x38\xf0\x16\x1c\x78\x07\x0e\x84\xe0\xc0\x7b\x70\xe0\x7d\x38\x70\x19\x0e\x7c\x04\x07\x3e\x81\x03\x9f\xc1\x81\x2f\xe0\xc0\x57\x70\xe0\xff\x86\xff\x08\x10\xa1\x46\xa4\x23\x42\x48\x84\x44\x18\xb6\x10\xa1\x80\xf8\x89\x50\xa5\x11\x8d\x0c\x5b\x34\x91\xcf\xa2\x16\x31\x15\x52\xa1\x6a\xc8\xb8\x18\x0d\x1b\x35\x11\xc0\xc8\x35\x91\x77\xe5\x23\x0b\x58\x82\x34\xa2\xa0\x40\x23\xba\x10\xae\x56\xd1\x7d\x64\x32\xd9\x47\x26\x9f\x3f\xde\x7f\xd9\x7e\x3e\x7d\x01\x49\xb0\x9f\x9f\xd6\xbf\xc8\x9e\x4e\xf7\xd1\x49\x22\xf2\x8a\xf8\x32\xa2\xca\x5f\x10\x7d\x45\x4c\xf7\x91\x49\x8b\x8e\x4f\x2b\xb7\x2f\x4a\x5f\x40\x13\xec\x8b\xfa\xa7\x9d\xb7\xa7\x93\x7d\x74\x32\xdd\x47\x27\x2f\xb2\x97\x4f\x3b\xbe\x28\xfd\x22\x4d\x38\xbe\xe8\x72\xf9\xf9\xe3\xe9\x64\x1f\x99\x24\xa2\xaf\x90\x41\x44\x5e\x11\x93\x7d\x74\xd2\x79\xfb\xe5\xfe\xe3\xe7\xd3\x2f\x92\x84\xe3\xe7\xcb\x2f\x2f\x3a\x9e\x2e\xa7\x7f\xf4\x97\x93\xed\x6c\xd4\x18\x36\x92\x6f\x58\x6a\xb9\x88\xa2\xc6\xa8\x31\xfe\xcd\x26\xb5\x4c\x43\x61\x63\xd4\xf8\x31\x4b\x2c\x33\x51\xd8\x18\x36\x8a\x17\x22\xf9\x70\x6d\x80\x84\x86\x32\xc9\x93\x30\xac\x24\x21\xc1\x90\x85\x1c\x53\xed\xaf\xea\x2d\xd3\xd2\x26\xa6\xac\xaa\xaa\x4c\x47\x9b\xc4\x65\xbd\x55\xfb\xb5\xa4\x89\xd9\xdf\xdb\xbb\x5f\x47\xde\x1a\xfa\x48\x45\xaa\x68\x13\xb9\x93\xae\xa5\x6b\xe8\x44\x23\x9d\x47\x81\xb6\xae\x6a\x47\xd9\xde\x8d\x24\x87\x26\x8f\xd8\xd4\xd1\xd1\x12\x54\xef\xea\x6a\xeb\xec\xd0\xbd\xfc\xee\xc1\x83\x07\xf7\x4a\xf6\xec\x3f\xd3\xfd\xa4\xfa\xa3\xd0\xf2\xfb\x17\x94\xac\xbd\xc3\xae\x33\x14\x50\xe9\xcd\x54\x96\xb1\x5a\x5c\xd6\xed\x88\xc9\x3e\xb0\xf7\xe1\xfd\xba\x80\xf8\xd0\xc9\xb7\x5e\x7e\x4c\xfb\xfd\x20\x51\x85\xc8\x92\x0c\x79\xff\x5f\x5e\xf4\x8f\x70\x30\xac\x24\xdb\x59\x0d\x9d\xa1\x67\x35\xc2\xc1\x99\x48\xde\x2f\x27\x46\x04\x87\x82\x24\x28\xd0\x30\x07\x35\xa2\xb9\xaa\x67\x17\x06\x8b\xb4\x9a\x48\x1d\x53\xb4\xb0\x61\x85\xeb\x80\xab\xaf\x42\x37\x24\x1d\x96\x8a\x86\x83\x34\x24\xae\x47\x11\x25\xf3\x25\x4b\x43\x43\x41\x66\x48\x3a\x24\x15\xf5\xf5\x1d\x38\x74\x28\x43\xde\x5f\x0e\xc9\x33\x88\x54\x22\xc1\x62\xa4\x11\x8d\x54\xf1\xd7\xd5\xfa\x86\xad\x2d\x0d\xda\xe1\x10\x0d\x8a\x0a\x36\xba\x8b\xac\x19\xd7\x56\x92\x51\x68\x68\xb9\x78\x28\x48\xea\x45\xd1\xc7\xc8\x28\x24\x1f\x19\x20\xc1\x88\xf2\x14\x8a\x28\x49\x50\xb0\x09\x0d\x59\x66\xa0\x01\x56\x27\xef\xa7\xca\xf8\x4d\x77\x28\x48\xf2\xd9\xd3\xec\xd1\x1e\x56\x13\x99\x51\x87\x86\x82\xe2\x7e\xdf\x81\xb2\x81\x0a\x72\x33\x4d\x20\x63\xa8\x90\xe8\xa8\x44\x72\xcf\x7b\xdf\xde\xf1\x5f\xf5\x36\x66\x1b\xf3\xdf\x6f\xdf\xbf\xf0\x9e\x8e\xe8\x88\x84\x8c\x21\x42\x72\x33\x49\x18\xe8\x3b\xb0\xbf\xff\xa0\x64\x38\x28\x8e\x9c\x10\x9a\x73\xa9\x60\xfe\x32\x2d\xcd\x18\x4d\x33\x46\xd1\xf4\x51\x92\x35\x4b\x27\x4c\x99\xa3\xde\xca\x6c\x65\xe6\x4c\xf8\xe6\xec\x52\x1d\x4d\xff\x8d\x66\xfc\x46\x33\xae\x4a\xb2\xde\x59\xf2\x13\x61\x32\xe6\x22\x2d\xe9\x63\x4f\x35\x73\x5e\x1d\x51\x9e\xfc\x1d\xf5\xaf\x60\x35\x62\x20\x88\x28\xa9\x52\x45\xdc\xec\x71\x44\x9b\x88\x87\xae\xea\x68\xd2\x0d\x09\xa3\x3f\x89\x6a\xbb\x7a\x9a\x7b\xd4\x72\xe2\x67\x4f\xb3\x11\x99\xea\x70\x49\x97\x6f\x87\x36\xba\x35\x44\xcb\xc2\x2b\x45\xfb\x1a\xaa\xf7\xfb\xd5\xe5\x6c\xf8\x01\x5a\x27\x6a\xea\xea\xde\xd4\xad\x3e\xd4\x75\xf0\x61\xb2\x02\x11\x3f\xab\x11\xae\x0b\x1f\x52\x5d\x8a\xe6\x46\x65\x64\x65\x54\x4e\x57\x86\xc2\xb9\xf4\x65\xf2\x5c\xf8\xf6\x57\xc9\x7d\xe1\x14\x72\x5f\x34\x25\x7c\xfb\x42\x11\x59\xf7\xca\xff\x3f\x52\x0f\x3c\x42\x56\xa0\x68\xed\x0a\x76\x0b\x2b\xd8\xc2\x12\x56\x45\x7a\xe6\x93\x7f\xd1\x3d\x5a\xd2\x83\xe8\x9e\xf9\xf4\x5f\xb4\x87\x8e\xfb\x81\x62\x92\xa8\x1b\xfa\x9e\x21\x89\x3f\x10\x4c\xc6\xe9\x68\x30\x82\x55\x56\x76\x3f\xd2\xca\xc9\xad\x34\x48\x36\xc4\xef\xad\x41\xe2\x43\x61\xe5\x82\x0a\x36\x12\x1c\x0e\x12\x80\xae\x05\x35\xc2\x3a\x02\x58\x3f\xab\xa1\x3c\x8d\xf2\xa7\x04\x50\x58\x19\x55\x56\xb0\x44\x49\x8c\xaa\x65\x48\x33\x34\xb8\x0a\x69\x22\x83\xc5\xac\x86\x99\x71\x01\x8d\xec\x2f\x27\x5f\xa3\xa1\x60\x38\xa8\xea\x60\x37\x21\x61\x07\x1b\x51\x46\x95\x37\x78\x39\x79\x84\x0d\x07\xc9\x99\xe5\xec\x90\x45\x68\x40\x43\x4a\x1a\x5a\xce\x0e\x2b\x35\xc2\xc1\x98\x1d\x69\x69\x88\xb9\xee\x7f\xe2\xa5\x67\xd7\x0c\x6a\x49\x88\x19\x3c\x7b\x76\x50\xc7\x0f\x3c\x8d\x62\x03\x4f\xa3\xd8\xd4\xff\x2f\x49\x5b\x58\xf2\x6f\xf6\x9a\xe5\xc6\x6c\x32\x15\x69\x28\xd0\x08\x07\x97\xb3\xff\xcf\x4f\x86\x2c\xc2\x87\xfe\xde\x23\xef\xef\xd6\x08\x07\x20\x91\x69\x18\xb9\x40\xc3\x6c\x8e\xac\x56\x0d\xd4\x0f\x54\xf5\x6a\xa9\x86\x68\x48\x02\x1a\x1e\x33\x3c\x96\x3e\x4d\x9e\x21\x09\x88\x6a\xa8\x86\xdc\xcd\x92\x6b\xf4\x1a\xe1\xd9\xa5\xec\xc0\x40\x67\x6f\xaf\x8e\x68\x88\x66\xc8\x3e\x64\x17\xf5\xf6\x76\x0e\x0c\x64\xc8\xe9\x1f\xad\xe5\x90\x24\x68\x84\x03\x02\x8d\x28\x85\xac\xbd\x21\xf0\x69\x12\x7b\x5d\x1f\xf6\x37\x14\xfa\x34\xff\x22\x4f\xff\x05\xe5\xe9\xeb\x7d\x77\xb3\x7f\x07\x8b\xc9\xa0\x4f\xff\x0d\xfd\x06\x32\xef\x68\x4b\xd9\xb0\xf2\x14\xe2\xdf\x49\x50\x19\x8d\x04\xc9\x25\x44\xfd\xc4\xcf\x5c\xff\xf9\x0c\xf5\x53\xbf\x38\xfe\xec\x8d\xf8\xa9\x9f\x79\x1c\x69\x2f\x7a\x11\xf1\x13\xbf\xf8\x0e\x44\x94\x47\x67\xf0\x97\x65\xdd\x5f\x24\xf1\x4e\xab\xfc\x2c\x26\x27\x1a\xba\xfe\xd4\x2e\x1c\xf2\xfe\x65\x2c\x8d\x7f\x8f\xc8\x47\x9d\x6f\x91\xd2\x13\x7b\x9a\x47\x36\x53\x21\xf1\xd3\x07\xc9\x38\xed\xfd\x67\x6f\xaf\xb3\x2e\x59\x73\x7f\xd7\xed\x2f\x5a\x25\x24\xed\xd6\xf7\xe8\xad\xd4\x9c\x71\x81\xa5\xc7\x69\x75\x58\x88\x88\xf9\x3d\x72\x2b\x49\xbb\xa2\x7d\xf1\x89\xae\x8f\xd6\xbc\x68\xfd\xd7\xd4\x5d\x4b\xd6\x48\xe8\x83\x74\x1c\x15\x52\x3f\xdd\x9c\x41\x2e\xb1\x64\x31\xab\x1d\x56\x0e\x05\x55\x6f\xdf\xf7\xd2\x9c\x39\xf7\xdd\x37\x47\x3b\x1c\x7f\x34\x4e\xae\xb1\xb1\x30\x12\xc3\x27\xdd\xac\x80\x04\x7f\x58\x8e\xf8\x10\x4d\x72\x10\x0d\x91\x71\x6c\x98\xe7\xa2\x3c\x17\xb1\x90\x1c\x74\xcd\x42\xc6\xb1\x1a\xd1\x20\xc9\x41\x9a\xc8\x8c\x9f\x91\xdc\x86\x22\xc1\x21\xe5\x7a\x14\x0e\x12\xa8\xda\x5b\xdb\x53\xdd\xaa\xa5\x0b\x1e\xad\x3f\x56\x73\xac\xfa\x68\xfa\x63\x4f\x9f\x3c\xf7\xd8\x53\x92\x9d\xed\xad\xed\xc1\x8c\x8e\x2d\x1d\x9b\xda\xb4\xd6\x97\xe7\xbc\xba\xf4\x59\x49\x5b\x53\xc3\x8e\x06\x75\x43\x43\x4b\x73\xb3\x8e\x8e\x1e\xe9\xda\x53\xda\xe5\xec\x4c\x77\x93\x7b\x44\x7b\xb7\xac\xdf\x5d\xa5\xa6\x5e\xa6\xaa\xa6\x76\xfd\x66\xdd\xfa\x7b\x9b\xe7\x37\x2d\x72\xd6\x3b\x37\xba\x36\x50\xed\xef\x23\xda\x1a\xf9\x89\x0e\xaa\xa6\xe3\xd6\xfa\x74\x9b\x9a\x36\x37\x35\x64\x34\xec\x68\x6c\x6b\xd2\x9e\x5c\x7d\x62\xf5\x63\x2b\xd7\x97\x6e\x2c\xad\x2f\xa1\x8b\xdc\x23\x36\xb4\xd4\x56\x6d\xc8\xa0\x5e\x71\x75\xd7\xfa\xbd\x2d\x5a\xb2\xc0\xd3\xe9\xe8\x5e\xbb\xb7\x24\xdd\xf1\x50\x11\xe7\x58\x25\xd9\xd4\xd4\xd2\xd4\x90\xd1\xb8\xbd\x71\x67\x93\xf6\x89\xfb\xde\x5e\x38\xb8\x52\xd2\xd4\x1e\xdc\x1c\x54\x07\x83\xb1\x27\x7a\xa3\x7e\x3f\xb4\xe1\x70\xed\x91\xfa\xf4\x47\xe9\x3d\xa2\xea\xed\x3d\x1b\x7b\xd5\xc4\xcb\xf4\x76\x77\xf5\xec\xd0\xf5\xbc\xd2\xf6\x5a\xfb\xf9\x23\x9d\x47\x76\x1f\xda\x43\xb4\x14\x8c\xd8\xd4\xc1\xcf\x7c\x8c\xa8\xc9\xf8\xa3\x07\x75\x6d\xb1\x0d\x07\x37\x07\x9b\xdb\xb5\x45\x4f\x16\x9f\x73\x3c\xdb\x73\xa8\xeb\xf0\xae\xa3\x64\xe1\xa3\x23\x7a\x5a\xbb\x7a\xf7\xf0\x46\x5e\xca\x46\x62\xcf\x18\xc9\x49\xf6\xfa\x97\x2d\xbf\xb1\xe1\xe0\xd0\x19\xd5\x5e\x96\x04\xc3\xa1\xbf\x10\x25\xbd\x45\xb5\xd2\xe3\xde\xa4\x1d\x0e\x31\x9b\x3c\x8f\x3e\xa3\x8b\xdc\x15\x51\x5e\xbb\x4b\x3c\x6c\x8c\x9c\xff\x14\x3d\x5b\x71\xef\xe9\xa5\x6a\xde\xfd\xef\x2d\x58\x51\xa1\x9b\x43\xa7\x8a\xe8\xab\x6f\xb0\xd7\xee\x61\x68\xc2\xa5\xac\x2f\xb5\x43\x21\xe6\xcb\x4b\xdf\x91\x04\x5d\xe4\x2e\x52\xc6\x07\x19\xb8\x09\x91\xa0\xc0\xcf\x86\xcf\xa8\xb6\x07\xb6\x6f\xdd\xae\x8d\x5e\x0a\xbb\xa2\x97\xa2\x2e\xd1\x96\xad\x5b\xb6\x64\x44\xfd\x53\x58\x72\x1e\x91\x60\x54\x49\x42\x2c\xf1\x85\x9f\x52\xed\xda\xbd\xa5\x7f\xe3\x2e\xea\x26\xf3\x47\x84\x27\x56\xb3\xf4\x41\x31\x6d\x21\x6b\xac\xc7\xe7\x05\xac\xf6\xf4\xe1\x82\xe8\x0f\x1b\xeb\xb6\x94\xef\xda\x98\xfe\xea\xcc\x9d\xcd\x1d\x9b\x3b\xb6\xa6\x07\xb7\x76\xb4\xb6\xef\x1c\xba\x2b\xfc\xee\x88\xa1\xbb\xa2\xef\x8a\x36\xb5\xb5\x6f\xe9\x88\x3d\x18\xef\xd8\xd6\xb1\x63\x67\xdb\xab\xef\x8e\x90\xb7\xa0\x48\x90\xa4\xa2\xa1\x20\xa9\x40\xa3\xd8\xb0\x91\xe1\x1d\xc1\x1f\x36\x12\x65\xf8\x4c\xfc\x77\x33\xe1\x33\x44\x19\x36\x12\xbf\x20\xa2\x8c\xf8\xc9\x6b\x88\x5e\xa5\x7e\x37\x22\x16\x14\x36\xfe\xa0\xba\x19\x91\x5b\xfb\xcb\x49\x88\x58\x96\xb2\xf0\x39\x8d\x58\x23\x88\xfc\x10\x3e\xa9\x5a\xbf\x6d\x43\xed\x06\x35\x6d\x61\x36\x6c\xe8\xea\xd9\xa6\xdb\x21\x3e\x48\x42\x84\xb2\x64\x11\x89\xb0\x07\x69\x48\xb4\x59\x3c\x14\x88\x16\xab\x4e\xd7\x9d\xde\x70\x42\x1b\x35\x45\x0e\x89\x06\xea\x3d\xfb\x3d\x6a\xfa\x0d\x89\xb0\x7b\xa8\x45\x54\xb5\x6d\x63\x4d\x95\x9a\xde\xce\x54\x6d\xec\xee\xdd\xa6\xdb\x43\x2c\x84\xb2\xf4\x1b\xc6\xe3\x29\xf3\xd6\xeb\xa2\xa6\x6b\x87\x44\x1b\x8a\xeb\x0a\x0a\x32\x5c\x1d\xdc\x29\xed\x90\x85\xa9\xae\xe1\xc7\xf5\x91\x20\x0f\x33\x40\x22\x6c\x1f\x0d\x8a\xaa\xb6\xd5\xd4\x54\xab\x87\x2c\xcc\xa9\x8e\x73\x87\x62\xe1\x20\xc2\x07\xda\x20\x4b\x2c\xff\x42\xd1\x42\x86\x8f\x52\xa2\xe2\xa2\x95\x15\xcb\xd4\xcb\x56\xf6\x9d\x28\xd2\x51\x35\xd1\x88\xa2\x36\x62\x46\x11\x99\xea\x40\xbd\xbf\x67\x9d\x9a\x06\xc3\x16\x86\x2c\x60\xa3\x16\x1a\x14\x93\xcf\xd8\xb0\x25\x6a\x19\x41\xb4\x28\x6c\x09\x5b\xf6\xf5\xee\x7c\xb4\xfe\x60\xba\xbc\x92\x0d\x1b\x49\x90\x57\x92\x32\x27\x72\x35\x7c\xf5\x4b\x44\xae\x56\xb3\xf4\xea\xff\xef\x9f\x2c\x92\x22\x96\x5e\x0d\x87\x72\xd9\xbf\x89\xf8\x75\xe8\x16\xd5\xce\xae\x96\xdd\x0d\x9d\x34\x44\x42\x23\xda\x9a\x1a\x5b\x1b\xd5\x8d\x8d\x2d\xcd\x4d\x3a\x7a\x89\x5e\x12\x35\x37\x6d\x6e\x6c\xc8\x18\x87\x02\xc4\x42\xaf\xfe\x8c\xc8\x55\x62\x11\xef\xee\xea\xe8\xda\xa9\xa3\xbf\x86\xfb\x73\xd9\xfe\xf2\x48\x88\x58\xbe\x42\x91\x8e\x70\x48\x35\x91\x5a\x44\x34\xc4\x4c\x24\x16\x11\x7d\x8b\xd9\xbe\x73\x5b\xdb\xf6\x9d\xc4\x1e\x6e\x1a\x31\xb4\x8c\x21\xf6\x68\xd3\xf6\x4d\xdb\x9a\xb7\x6f\x4a\x27\xcb\x4b\x55\x27\xea\x06\x6b\x1e\xd3\xd2\x86\xf0\xb3\xa2\x63\x35\x05\x0f\xdb\xd5\xc3\x21\xc6\x5e\xb0\x6e\x6d\x8d\x8e\x36\x44\x9f\x15\xd5\x38\xea\x96\x16\x67\x44\xcb\xc9\x4e\x74\x96\xd5\x08\xfb\x87\x94\xaa\x03\xb5\xfd\x15\xbb\xb4\xd1\x33\x24\x54\xd9\xe5\x0d\x54\xd4\xa5\x57\xd4\xd6\x96\xfb\x33\x86\x95\x62\x72\x0f\xbb\xab\xb5\xad\x53\x17\x3e\x43\x42\xa2\xbe\x5d\x5d\xfd\x07\x32\x88\x32\xed\x66\x44\x7e\x66\x03\x24\x98\x7a\x72\x31\x22\x17\x58\xc2\x22\x9a\x46\x55\x23\x48\x3a\x1d\x45\xef\xbf\x4c\x97\xab\xc9\x1e\x44\xaa\x88\xf3\x17\x32\x9b\x8c\xd3\x75\xee\x0e\xec\xab\xdd\x45\x59\xa2\x1d\xd1\xd6\xd4\xd0\xda\xa0\x6e\xd8\xda\xb0\x79\x53\x93\x84\xa6\xde\x4a\xc7\xe7\x51\x83\x9a\x8c\x41\xe4\x26\x92\xb4\xdc\xf8\x9d\x2e\xf5\x2d\xaa\xa5\x5a\xb2\x00\x85\x2d\x0e\x1e\x84\xb4\xb0\xa9\x27\x35\xa2\x6f\xc2\x7e\xd5\xde\x9a\x3d\x55\x5a\x6a\x61\x36\xd4\x37\xd4\x6c\xd2\x55\x17\xd4\xda\x7c\x85\x12\x3a\x71\x32\xcd\x9d\x42\xe7\xaa\xa9\x8a\x26\x3f\xf7\xe5\x24\x1d\x61\x09\xfb\x06\xca\x62\xa3\x16\x13\x8a\x5a\xc4\xa9\x6f\x5d\x42\x44\x45\x54\x22\xaa\x26\xa3\xc9\x7d\x77\x90\x07\xd5\x61\x11\x79\x92\x04\xc8\xef\x9f\xe9\xb6\x6d\x0f\xb4\x6e\xcf\x18\x18\x3a\xa3\xfa\x36\xb6\x01\x11\xc9\xa0\xa3\xe9\xfd\x1f\xd0\x65\xea\xa8\x88\x3e\x43\xb7\x52\x62\xd2\x6d\x09\xb4\x6c\xc9\xa8\xee\xde\xd0\xab\x25\x2b\x99\x3d\x9d\xc1\xee\x9d\xba\xbd\xa7\xbb\x4e\x1d\x7c\x5c\x42\x26\x7e\x4b\x72\xbf\x21\x73\xd5\x44\x45\x92\x57\x18\xbe\xd7\xf1\x4b\x0f\xc6\x56\xde\xff\xbf\x1f\x5c\xe6\xf2\xb6\xaa\x14\x84\x95\xe4\xea\x68\x96\x84\x84\xa3\x50\xec\x6d\x13\x8a\x5a\x54\xff\xe0\x3b\x6e\xbc\x29\x87\x95\x37\x8a\xce\x50\x28\xf6\xec\x79\x1e\x3b\x1c\x12\x13\x65\x24\xf4\x3b\x8a\xfe\xd1\x5f\xae\x11\x0e\x12\x0b\x24\x0e\x3e\x3f\x58\x04\x24\x34\x14\x54\x11\x8b\x98\xa4\x20\x6a\x11\x93\xd0\x04\x62\x40\x25\xc4\xc2\x90\xad\x74\x35\x59\x4d\xb7\xd2\xad\x74\x35\x5d\x4d\xb7\x6a\xa9\xa5\xe4\x53\x56\xde\x5f\xc0\x92\x4e\x96\x84\xc8\x05\xb6\x1c\xad\x1a\xc8\x7f\xdc\xaf\xd5\x50\x79\x09\x7b\xd1\x8b\x34\xc2\x5f\xc5\x8f\x1f\x18\x38\xf3\x54\x86\x46\x34\xb8\xa0\x18\x71\x74\x3a\xd5\xd0\x2c\xb5\xd3\xb5\xb3\xdb\xad\x7b\x8d\xea\xa8\xe2\x79\x9a\xa5\xa6\xa3\xe9\xa4\xfb\x17\xd0\x14\xdd\xba\x8d\xae\x1a\xdf\x7a\x49\x65\x4d\x6d\xb5\x2f\x63\xb8\x5a\x3c\x99\xed\xea\x6c\x6d\xdb\xa5\x7d\x97\x68\xc9\xd4\x4b\xc4\x40\x5c\x5f\xd2\x91\xe4\x1e\x35\xb9\x89\x24\xff\xf3\x3c\x11\xe9\x0e\xed\x39\xd0\x7d\x32\x43\x3e\xf2\xc6\x16\x02\xc4\x42\x42\xb1\xa7\x04\x21\x62\x11\x9c\x66\x87\xb4\xaa\xf0\x94\x68\x32\xf9\x39\xfa\x60\xf4\xc1\x68\x32\xfd\x39\x3a\x85\xc2\xbe\x51\xa7\x6f\xd1\xf6\xad\x20\x0b\xd7\x8a\x28\x3c\xf4\xd3\xed\x04\xab\x4b\x66\xa3\x70\x88\xdc\x83\x4a\xc4\x13\x72\x96\x4e\xe7\x74\xf3\xba\x44\x95\xaf\xd6\x5f\x7c\x23\x83\xfc\x93\x3c\x4f\xf6\x92\xef\xc8\x77\xe4\x79\xba\x97\xfe\xf3\xae\xfa\x05\x95\x0b\xb5\xf3\x6a\x45\x1f\x70\x39\x83\x13\xd4\x47\xc5\x7b\xd9\xa3\x62\x82\x7f\xfa\x88\xc0\x43\x3a\xb2\xf0\x58\xdf\xb3\xa2\xd3\x3f\xf5\xfd\x46\x60\x86\xfc\x5a\xed\x51\x8d\x70\x10\x06\x86\x82\x02\x2f\x2b\x8f\xfe\x11\x6b\xf1\xc9\x44\xe0\x65\xc3\xca\xf0\x19\xd5\xcf\x8b\xae\x4c\x3a\xa9\xdd\xd1\xd8\xb0\xad\x51\x6d\x77\xb9\x8b\x75\x77\x12\x49\x3f\x95\x51\x19\x95\xf4\xdf\x99\x51\x7c\xc8\x7d\xbc\x23\xb8\x6d\x47\x87\xf6\xbb\x53\xe7\x7f\xfc\x39\x43\x3e\x52\x23\x9a\x57\xc1\x0b\xe0\xd0\xff\x2b\x01\x24\x98\x46\x38\x2a\x27\xf7\xd1\xc5\x97\xc9\x55\xd6\xdd\x53\x79\xa0\x56\xf7\x48\xcd\x40\xed\xc1\x2a\xc9\x4f\x79\x2f\x51\x31\x95\x67\x50\xf9\x7d\x54\x7c\x4b\x9e\xd6\x57\xe5\xad\xf5\xd4\x48\xfc\xb5\xeb\x2b\xdd\x19\xab\xd9\x13\x1d\xc1\xed\xad\x1d\x5a\xb2\xf8\x32\x91\x93\xfb\x08\x17\x93\xf5\x0a\x5d\x40\x8e\xd0\xe3\x44\x46\xae\xb2\xae\x3d\xeb\x0f\xd6\xe8\xba\x1b\x7b\x36\xed\x69\x7c\x74\xc3\xa3\xd5\x0f\x57\x4a\x48\x0e\x95\xfd\x48\xef\xa7\x6b\x32\xe8\x9a\xdb\xe8\xfd\x34\x87\xca\xb4\xeb\x2a\xdd\xd5\xee\x0d\x1b\x1a\xd7\x6f\xaa\x69\x94\xf8\x6a\x36\xac\x77\x65\x4c\x66\x83\x71\xd9\xbc\xa0\x05\xe4\x08\x79\x85\xcf\xba\x01\xa2\x22\xa9\x44\xc9\xd7\x3c\x81\x13\xe8\x2f\x4f\x61\xfe\x7c\xa5\x7e\x1a\x26\xe7\x91\x8a\x7c\x87\x98\x88\x52\xc8\x13\x52\x19\x6f\x5e\x0b\x5e\x4b\x55\x85\x53\xc3\xca\x68\xaa\x38\xaa\x1c\xea\x50\x91\xf3\x28\xaa\x14\x87\x95\x69\x71\x66\x58\x49\x83\xaa\x61\xe5\xb0\x72\x48\xc9\x90\x67\xe2\x73\xf8\xfb\x99\x2a\x9c\xca\x32\xa9\x23\x47\x10\x25\x33\xa4\x14\xc6\x1a\x3b\x33\x4b\xd9\xa8\x72\x58\xc9\xa4\x8e\xcc\x21\xca\xb0\x92\x49\xfd\x34\x1c\x86\x28\xac\x64\x86\x83\xe4\x3c\x7b\x5d\xc8\x50\x70\x48\x79\x43\xa0\xbc\xbf\xbf\x7c\x7f\x79\x4a\xe0\xc2\x91\xa3\x17\x8e\x90\x94\x23\xdf\xbf\xfa\xfd\x91\xa3\x47\x8e\x1e\xf9\xee\xc2\x77\x17\xf8\x7f\x47\x2e\x7c\xff\xdd\x91\xa3\x47\x2e\xa4\xd6\xfe\x31\x78\x21\x2d\x5c\x12\xff\xf9\x62\x79\x79\xa0\x3c\xf6\x0b\xcf\xb5\x51\x47\x46\x7f\x5f\x60\xbf\xfa\xc2\x36\x55\x17\x5b\x57\x1f\xa8\x6b\x60\xbb\x82\x81\x5d\xea\xef\x3a\xd0\xae\xce\x40\xa7\x9a\x64\x75\xa0\xae\x20\xf9\x27\xaa\x78\x95\xdd\xdf\x17\xe8\x53\x93\x94\xeb\x9f\x5c\xf8\x1f\x4d\xed\x07\xe0\xfa\xe8\x20\x9b\xba\x7c\xb0\xee\xc0\xbe\x40\x7f\xac\x71\x20\x3e\x25\xc8\xcf\xed\xff\x1f\xf3\x5d\x90\x8d\x0f\xb9\xaf\x1b\x95\x38\x03\xce\x06\x36\xb5\x0e\x0c\x1e\x3d\x12\x38\xa2\xbe\xd0\x8d\xe2\xcb\x48\x9d\x7b\x27\x88\x2f\x65\xab\x2a\xfc\xff\xe1\xeb\x4d\xe0\x9b\xa8\xb6\xc7\x71\x6a\x3b\xc9\x38\x3e\xab\x92\x19\x6c\x67\x32\x33\x55\x10\x54\x10\x41\x22\xfa\x50\x04\x51\x41\x65\x97\x80\xec\x94\x7d\x29\x94\xd2\x86\xee\x6d\x9a\x34\xfb\x9e\x74\xda\x74\xdf\xa1\x40\xcb\x56\xaa\xec\x5a\x04\x14\xa9\x0a\xfa\xaa\x3e\xb7\xf7\xf0\xa9\xa8\x0f\x77\xd1\x33\xc9\x49\xf0\xff\x49\x0a\xbe\xef\xf6\xff\x25\x9f\xcf\x2c\xf7\x9e\x7b\xee\xb9\x67\xe6\xde\x39\xe7\xde\x73\xce\xdd\xe8\x94\x37\xc9\x1b\xff\x43\xf7\xc6\xc8\x26\x36\x8e\x3b\xb9\x90\x4a\x86\xfb\x0a\xa9\x18\xb7\xad\x7c\x74\x45\x68\x39\xf1\xca\xc2\xfb\x0f\x3d\xcd\xa1\x4e\xf1\xde\x77\xab\x17\xbe\x22\x86\x56\x44\x97\x13\xad\x39\x35\x9b\x36\xb2\x1b\x4b\x36\xe9\x74\x42\x64\x53\x64\x13\xb1\x61\xef\x8e\x9c\x57\xb9\xbd\x5d\x35\xad\x6d\xa2\xac\x97\xcb\xe0\x45\x2a\x39\x6d\x0b\x1f\xa6\x21\x4c\xc5\xe7\x61\x4e\xfc\x33\x51\xad\x58\x1f\x7e\x99\x29\x6e\xca\xad\xd1\x49\xae\x02\x67\x9e\x39\x1f\x7b\xaf\x6d\x4d\x59\x5f\x96\x9e\xbb\x8e\xbb\xf6\xa0\x42\x3b\x35\x78\x36\x4f\x2c\x6f\x71\x49\x15\x41\x32\x28\xd5\x79\xaa\xb9\x50\x48\x01\xaa\x1d\x7b\x61\xf4\x31\x11\x76\x86\x85\x9a\x63\xe6\x63\xdb\xf6\xa7\xee\xcb\x5e\xd9\xbc\x94\x8b\xba\x15\x85\x85\x16\x6b\xa1\xe8\xf2\xa0\x6a\x7f\x39\xf2\x2b\x67\xa6\x16\xe9\x72\xf2\xac\xf9\xb6\x82\xca\x42\x7b\xa1\x79\xc1\xea\x51\x39\x9b\x8a\xf3\xb6\x1b\x4c\x3a\x73\x51\xa5\xce\x9e\x6b\x59\xba\xe1\xa1\xac\x65\x86\x82\xfc\x12\x4b\x3e\x69\x29\xac\xdc\x6e\xc9\x2f\x7b\x71\xe3\x84\x2d\x8b\x8a\xb2\x72\x0b\xad\x39\x76\xbd\x54\xea\x28\x72\xe4\x58\xf3\xec\x79\x25\x6b\x9d\x2b\xea\x96\x93\x43\x0f\x40\xc2\x84\x9f\xb9\xf0\x83\x8a\xcf\xbf\x78\xfb\x52\xbb\x08\x1d\x61\xa1\xe6\xa8\xe9\x58\xf6\xfe\xd4\x6b\x27\xec\xdf\xf1\x8f\xa2\xf4\x1d\x9f\x1c\xd1\xdf\xad\x26\xbe\x4d\x70\xda\xf9\x44\x75\x92\x4b\x4d\x94\xb9\xf9\x34\xa4\x81\x0e\xd1\x70\x99\x4a\x88\xaf\x92\x5b\x29\xa8\xe4\x63\x4c\x95\xc2\x34\x4a\xca\x6b\x74\x88\x66\x42\x74\x88\x46\xcd\xe3\x14\x68\x22\xb4\x02\xa4\xe9\xdf\xf3\x43\xae\x6a\xfe\x75\xb7\x30\x1d\x24\x45\xef\x96\xfe\xb5\x07\x05\x1c\x05\xa3\x88\x83\x6b\xa7\xec\x5e\xc0\x45\x35\x7d\x54\xa4\x67\xba\xf2\x6e\x8d\xe6\x6e\x31\xa2\x89\xeb\x45\x1a\x98\xc0\x83\x26\xae\x13\x25\xc3\x7d\xdd\x7c\x82\x53\xad\x2c\x4b\x0c\x6b\x43\x57\x99\x1b\x0e\x16\x38\x6e\xc0\x78\xfe\x86\xfb\x05\x8c\x43\x06\x18\x1c\x27\x86\xb4\xb2\x86\x41\x9d\x62\x21\xa8\x89\xb7\xb3\x27\x9e\x7a\x86\x8b\x48\x8a\x67\x26\xce\x7f\x2e\x5b\x5c\x88\x6a\x02\x75\x0a\xe8\xe4\xaf\xd1\x4a\x13\x25\xe8\x78\xc5\x74\x5e\x0c\xd3\x32\x45\x45\xb5\x6a\x2c\x7b\x90\x4a\x43\xfa\xbb\x51\x97\xe4\xb9\x70\xcb\x60\xe7\x21\x5e\x75\x20\xb4\x31\xbc\x96\x51\x65\xbd\x87\xf7\x9c\xc3\x07\x5f\xc5\x51\xa4\x23\x3f\xdf\x91\xcf\xdd\x7b\xaf\xc7\x75\xaf\x18\x79\x35\x3a\x94\x39\xff\xa6\xa7\xea\xbc\xe8\xae\x69\xf2\xd7\x00\x09\x37\xe7\x01\xc9\xb9\x24\x97\x24\xb1\x4d\xce\x46\x47\xa3\xf0\x42\x05\x8e\xf0\xfc\x9d\x3d\xf8\x13\xd4\xee\x38\x2b\xc8\x0b\xec\x44\xdd\x2a\x60\xf0\xe4\x7a\x76\xdd\x02\x53\x96\x59\xc0\x3b\xb7\x12\xb6\x6d\x8e\x6d\xdb\x58\x2f\xdc\x09\x77\x56\xc1\x9d\xa0\x02\x55\x11\xa8\x38\xc9\x55\x21\xb1\x8d\xb6\x46\x5b\xa3\xb0\xb4\xe1\x41\xff\xa6\x1d\x25\x55\x25\xbb\x4d\x75\x8b\x7e\xde\xf0\xfb\xf2\x5f\x49\xd5\x81\x49\xf0\xf4\x54\x98\x36\x19\x9e\xc1\x95\xb2\x2e\xc5\x16\xb0\x06\xac\x01\x72\x81\x62\xb2\x02\xbb\xa2\x1b\xd0\x10\x89\xac\xc4\x41\xf7\x34\x3d\x90\x99\x6a\x7f\x9c\x48\xc6\x3f\x30\xf1\xdb\xd0\xc3\xdf\xcb\xc7\x7f\x19\x0c\x39\xf0\xae\xbc\x1a\x3e\xc4\x0a\xf8\x4a\x25\xcb\xaf\xd6\x32\x39\x67\x25\x98\x7d\xf1\xaa\xeb\xb7\xdf\xd8\xca\x8e\x97\x9d\xbb\x39\x78\x18\xd8\x72\xbc\xff\x1b\xb1\x6b\x41\xc5\xf3\x33\x59\xb4\xe1\xbd\x63\x30\x7f\xc9\x92\xea\xc6\x15\x42\x49\xa8\x94\x51\x5d\x75\xb4\x3a\x63\xff\x5e\x57\x6f\xef\x5f\xee\x51\xc9\x3f\x95\xff\xf4\x13\x1b\x78\xf9\x65\xff\x61\x0e\x1e\x83\x27\x9f\xc5\x17\xb1\x08\x47\xcc\xc5\x55\xeb\xd7\xb9\xfc\xeb\xc5\xc8\xc1\x6b\xb7\x32\x01\x98\x0a\xcf\xd5\xc1\xb4\x2f\xbe\x30\x7f\xc1\xc1\x51\x78\x1b\x14\xf0\x1d\xac\xc3\x89\xc0\xe0\x0b\x2f\x8b\x70\x57\x1f\xa8\xdf\x81\x69\x2c\x54\xa3\x1b\x06\x61\xae\xa0\xba\xba\x7c\x99\x6b\x39\x87\x06\x34\x16\x5a\xd1\x28\x7a\x1f\x25\x54\x72\x97\x15\x46\x98\x6a\x33\xc9\xb6\xa5\xf6\x6b\x73\xb6\xb3\xcf\xfa\x86\x6e\x98\x23\xcc\xdc\xf6\xbc\x63\x7a\x91\xfd\x81\x94\xe4\xa8\xfe\xae\x7f\xd6\xe7\x0e\x76\x86\x25\x55\x3a\x0e\x4e\xf2\x7d\xf1\xaf\xda\x2f\x39\x55\xf3\x85\x8b\x0e\xc7\x45\xd1\x71\xe6\xf5\xfc\x33\x2d\xcd\x9e\x16\xae\xa2\xcb\xdf\xe5\xee\x9a\x59\x39\x33\x30\xab\xc6\xd1\x90\x62\x7d\xe9\x04\x2c\xa9\x3c\xde\x0b\x95\x7d\x10\x3c\x0e\xc1\xca\x33\xbe\xd7\x5b\x4e\x5d\xd8\xd9\x5f\x75\xb1\xad\x62\x57\x60\xb7\x77\x37\x69\xbe\xeb\x2e\xc3\x5d\x1c\x0e\xc1\x3b\x2b\xfd\xc8\x88\xf9\xc3\xde\x30\xbc\x53\xf1\xda\x96\x54\x55\x7a\xb6\xd2\xf3\x18\x66\x5e\xdb\x58\x3a\xcd\xb4\xa1\x6c\x9d\x2e\x73\xf6\xe6\xa9\xe5\xd3\xf3\x48\x55\x73\xe1\x78\x22\xb9\x19\x6f\x03\x6f\x58\x02\x2f\x3e\x00\x34\xde\x0e\x77\x0c\x76\xc2\x2d\x72\x0a\x54\x85\x82\x40\xab\xf6\xa9\x15\x17\x81\x66\x1e\x0b\x4b\x9f\x28\x0e\xd7\x74\xec\xcb\x12\x55\xef\xe0\x60\x18\x9f\xb5\x6f\x85\x33\x6b\x43\x2a\x0e\xc6\xf1\xc4\x86\xac\x9a\xad\x87\xb9\x4f\xae\x49\x8f\x29\x56\x94\x6c\xdd\xb0\x53\x84\xc1\x38\x7e\xe7\x86\xc3\xce\x9d\xfb\x52\x61\x30\x8c\x27\x54\xfb\xf6\xed\x2c\xe9\x58\xc1\xa9\x43\x06\x75\xd2\x1f\xf0\x0e\x45\xaa\x1a\xdf\xf0\x3a\x61\xe9\xf1\x2e\xb2\x79\xd7\xef\xf5\x07\xb8\x7a\xb8\xd3\x53\x5c\x23\x06\x4b\xac\x4f\x15\xb0\x78\xb3\x12\x97\xfb\x63\x82\x12\x3b\xc3\x83\x6d\xdb\x17\x1f\xa1\x60\xaf\x0d\xf6\x3a\x60\xaf\xa0\xda\xe7\x38\xe2\x3d\xe6\x3b\x4c\x56\x7d\xf5\x6f\xeb\x65\x6e\x4f\xab\x6f\x5b\xb3\xe8\xb6\xb7\xc1\x16\xbe\x7b\x1f\xf8\x78\x62\x6d\x96\x4e\x5a\xcd\xe1\x51\xc5\x53\x4f\xbb\x9e\x82\x2f\xf9\xe4\x2d\xbc\x3a\xe9\x5f\xc0\x24\xc4\x5a\xd5\x00\xfe\xc4\x4f\xd5\x84\x1e\xde\xa1\xde\xf0\xb9\x60\xd9\xb1\x3d\x64\x5d\x1b\xe8\x5b\x5e\xba\x41\x40\x6d\xa1\x09\xf5\xab\x8a\x7d\xc5\x25\xec\xb8\x40\x64\x4b\xf6\xbc\x23\x14\x8c\xb7\xc3\x78\x07\x3c\x22\xbc\xa8\x74\xc0\xa8\x81\xda\x53\x6b\xe0\x56\xb8\xdb\x04\xb7\x71\x95\xc7\x5d\xb6\x0a\xb1\x2a\xa6\x08\x1b\x5d\xf6\x76\xd8\xc2\x1f\xdc\x0f\x3e\xbe\xb4\x20\xb7\x64\xbb\x2b\x55\xc2\x06\x6c\x36\x63\x03\x7c\xc9\xab\x93\x82\x6a\x4c\x65\x96\xd5\xa5\x15\x88\xd7\x24\x45\x43\xdd\xef\xcb\x36\x60\x2a\xde\x92\x9b\x25\x14\xeb\xcb\x0a\xf3\xd8\xbc\xaa\xc2\x5a\xbd\x90\xbb\x13\x52\xf1\x96\x7d\xdc\xd1\xa2\xdf\x1b\xc4\xb0\xa4\x28\x28\x4a\x3b\xba\x0f\x52\xe1\x96\xe6\x9d\x42\x6d\xb0\xaa\xbe\x89\x6d\x2a\xab\x2f\x0e\x0a\xcd\x59\x98\x0a\xb7\x6c\xe0\x92\xb7\x50\x11\x1a\x5e\xe0\xd5\x38\xe8\x71\xde\xce\x8f\xa1\x40\x8a\xdd\x85\x07\x3d\xce\xcf\xa1\xc6\xdc\xc8\x2b\x7b\x9c\xb7\x50\x1b\xa9\xeb\xb0\xd7\xe8\xc7\xf9\x30\x1d\x03\x95\x25\xc6\xc9\xc7\xd3\xa2\xf4\xe3\x7c\x88\x8e\x81\xc8\x52\xd2\xd8\xff\xa0\x1b\xb8\xbb\x81\xee\x7a\xde\x9f\xe8\x64\x29\xe9\xd9\xff\x72\x48\x6e\xf6\xc7\x1d\x2c\x12\x41\x02\x1d\x03\x43\x79\xb9\x3f\x69\xe0\xb8\x2f\x86\x43\x4d\x4c\x66\xf6\xc5\xd3\x06\x5f\x3f\x26\xe7\x51\x32\x1d\xd6\x31\x4b\xa9\xb8\xc1\x50\x0f\xf6\x10\x66\xb3\xcd\x58\xce\x96\x7b\x8c\x7e\xb3\x00\xf1\x04\xbf\x64\xab\xe0\x9e\xa0\x74\x3c\x6a\xd7\xf0\x79\x14\x5c\x0d\x69\x99\x01\xd3\xfc\x1e\xe8\x21\xfc\x66\xa3\xa7\x9c\x9b\xca\x8b\x91\xfe\x02\x2a\x6e\xbb\x1d\x4f\x8d\xdb\x6e\xab\x89\xe6\x88\x6e\x0d\xdf\xdc\x9c\x0b\x63\x62\x4a\x15\xb3\xa3\xa8\x55\x57\x19\x37\x01\x29\xe7\x0a\x8b\xcc\xa5\x7a\x31\x32\x22\x32\x9c\x80\xbf\x2a\xef\xa7\xa2\xda\x4a\x3e\xaa\x55\xde\x18\xb5\x85\x90\x76\x38\x0f\x13\x94\xf2\x88\xc8\x08\xa2\x34\x58\x67\x7e\x3b\x36\xd0\xbf\xcf\x83\x36\xac\x1d\x30\xc3\x3b\x14\xd3\x20\x42\x74\x58\x9b\xc9\x87\xa5\x08\xcd\x44\x34\xb2\x26\x22\x45\x24\xd4\x80\x26\x6e\xfb\x84\x5a\x1d\xaf\xbc\x02\xe7\xf8\xb8\x51\xa3\x1a\x27\x2b\x1b\x78\xd8\x4d\xa9\x93\x7a\x65\x25\x0f\x9a\x0c\x66\x21\xe5\x54\x87\x7a\x95\xf3\x28\x35\x4e\xbe\x3e\x45\xba\x25\xc6\x40\x3a\x11\xfe\x18\x92\x26\x27\x50\xbf\x2b\x2e\x5f\x06\x3d\xea\x09\xf9\xe9\xd0\x47\x8c\xd9\x6e\xb6\x58\x84\x48\x77\xa4\x9b\xb0\x58\xcc\x76\x33\x57\x6a\x94\xaa\xfd\x6e\xbf\xcf\x27\xca\xdd\x72\x37\xe1\xf3\xf9\xdd\x7e\xae\x5a\x32\x96\x8a\xf3\x41\xcb\x44\xfb\xa3\xfd\x44\x8c\x28\x65\xa8\x3f\xd4\x4f\x40\x13\xf4\x33\x60\xe5\x51\x0f\xa5\x44\x5b\xce\xa6\x9a\x8d\xdc\xc6\x4d\x25\x39\x3a\x11\x27\xe0\x5f\x65\x4d\x44\x03\x13\x60\x42\x4c\x76\x88\xea\x2d\xd4\x41\x0a\x3e\xa3\x12\x43\x52\x98\x2e\xa2\x62\x02\xab\x89\x02\x82\x9a\x15\x98\xb1\x43\x2b\xc8\x09\xd1\x5a\x62\x45\xd3\xd1\xac\xe3\xdc\xf1\xa3\x3b\x0f\x37\x8b\xf2\xa0\x50\x2d\xb1\xe3\xb5\xc0\xf9\x73\x6c\x72\x3e\x9f\x18\x92\xae\x30\xcf\x53\xe2\xb5\x7e\x65\x48\x92\x7b\x98\x34\x2a\xaa\x77\x82\x84\xfa\xdc\xc1\x4e\x68\xe1\xc3\x92\x6a\x8e\xca\x27\x4b\x32\xcd\xcc\xe1\x05\x55\x73\x7b\x45\x5b\xb0\x49\xa8\x6e\xea\xbd\xd0\xfc\x0e\x59\xe5\xa9\xf4\x55\x70\x15\x95\x96\x32\x8f\xd8\xfc\x6c\xef\xb4\xea\x3c\x32\x98\x57\x91\x93\xcd\xaa\xe6\xc4\xa4\xcd\x9f\xb6\x7c\xbb\xf0\x13\x61\xe1\x27\xb8\x09\xda\x26\x40\x2b\xf9\xb2\x7e\x55\x73\x06\x97\xb1\x3a\x37\xbd\x54\x9c\x80\xad\xb8\x09\xdb\x16\x3e\x46\xaa\xd2\x17\x3d\xb6\xf9\x81\xe1\xac\x6a\x0e\xee\x87\x02\x2c\x80\xfd\x30\x97\x12\x92\x07\x94\xbf\x2b\x61\xcd\xc0\xc3\x93\xa5\x2b\x72\x0f\xd0\x89\xe1\xbf\xc0\x55\x66\xde\x95\x91\xa7\x15\x40\x02\x09\xa3\x70\x14\x01\x7f\x97\x7f\x62\x24\xa3\xa3\xd8\x68\xc4\x5f\xf0\x97\x14\xa3\xb1\xd8\x61\x94\x8c\x92\xab\x56\x92\xe0\x17\xf8\x25\x45\x92\x6a\x5d\x92\x91\xfc\x24\x72\x99\xa9\x2e\xaf\xd2\xfb\x04\xbd\xaf\xd4\x6e\x30\x4c\x9f\x9e\x62\x36\xdb\xca\xcb\x59\x1c\x0c\x0b\xf9\x50\xbf\xa2\xb6\xd6\x6e\xad\x15\xab\xac\x41\x8f\x24\x9d\x38\x91\x52\x51\xe1\xa9\xb4\x57\xd9\x2b\x4d\x92\xd1\x4b\xd6\xaf\x5b\x5d\xb1\x9a\x8b\xf6\xcf\xe5\x47\x86\x35\x4c\x54\x13\xd5\x10\xb1\xd7\x59\x19\xd2\x84\x34\x04\x8c\x81\x31\xcc\x81\x03\xce\x37\xd7\x1d\x88\x89\x21\x29\xeb\x0e\xcc\x74\xae\x5b\xf7\xe0\x83\x29\xb1\x0e\xf1\xf5\xd7\x44\x72\x9a\x13\x68\x0b\xb5\x87\x87\xf5\xa1\x53\x40\x27\xea\x78\xf9\x30\x53\x6d\x1c\x20\xa5\xc4\x6a\x34\x16\x15\x17\x94\xe6\x19\xc9\x32\xb3\xa9\x4c\xcf\xe2\x26\x58\xc8\x43\x92\xc2\xef\x73\xbb\x7d\xe2\xc1\xd6\x23\x4d\x27\xeb\xc9\x5a\x4f\x55\x75\x1d\xdb\x50\x5c\x53\x28\x38\x9d\x4e\xd8\x40\xfd\xe5\x6e\xac\x98\xcb\x83\x21\x64\x65\xe0\x21\x5e\x26\xf8\x94\xa0\xbe\x28\x50\xc8\x95\x1b\xed\xb6\x72\x51\x17\x77\xaf\x40\x2d\x6a\x94\xd1\xb4\x47\xf0\x1c\x36\xe3\x52\x18\x87\xdb\x03\x06\xb1\xdc\x5f\x69\xa9\xe4\xbc\x5e\x97\xcb\x2b\x56\xfb\xa5\x1a\x7b\xcd\x66\x28\x6c\x83\xfb\x3f\xfd\x86\xfc\xf2\x23\x48\x7b\x09\xb2\x38\xd0\xa0\x56\xb1\xad\x4e\xd7\x6a\x10\x6c\x15\x92\xbd\x82\xab\xaf\xf3\x57\x07\x45\x38\x47\xdd\x68\x0a\xd0\xcf\xe7\x0d\xbe\x7e\xa5\xfa\xbb\xea\x88\x8e\x97\x7f\xb9\xce\x5c\xb7\xd5\xea\xb2\x72\xe5\xe5\x36\x93\x49\x9c\x3e\x9d\xb8\xce\xe2\x80\x72\xc0\xa3\x4c\xf5\xf7\xff\xea\x53\xf6\x27\xd3\x1d\x1e\x8f\xc3\x33\xe0\x99\x78\xe2\xc4\x00\xe3\x53\xff\x17\xe7\xa1\x28\x74\x9c\xe9\xec\x74\x9e\xcc\xe8\xc4\x9b\xe0\xa6\x94\x8c\xce\x45\xce\x8c\x8c\x28\x17\xe5\x52\xb0\x0e\xea\x06\x6e\x53\xf1\x26\xbc\x29\x23\xc3\xb9\xa8\x33\x23\x55\x9e\x12\x99\xd2\x99\x71\xd2\xd9\xd9\x99\x1a\x7a\x2d\xf4\x1a\x91\x0c\xdf\xf2\x21\x09\x24\xb8\x8d\x8a\xd0\x32\x0d\xb4\x12\x9e\xa2\xe4\x3b\xf8\xbd\x14\xdc\x49\x89\x28\xa1\x24\x51\x40\x47\xe8\x08\x0d\xb4\xe2\x62\x7c\x69\x04\x69\xe5\x03\x14\x68\x78\x11\x5a\xf8\x1d\x3c\x4c\xe4\xe3\x8e\x15\xef\x50\x63\x79\xa4\xe1\x1c\x85\xb4\xe2\x6f\xd4\x40\x4a\x72\x54\x0f\x3d\x7c\x6c\x34\x0d\xaf\x57\x13\x39\x4c\x0f\x7f\xdd\xf2\xbd\xf9\x7a\xb2\x5a\xf1\x37\x68\xe7\x43\x8b\x21\x97\xef\x89\x9d\xd4\x7c\x1a\xf4\xf0\x90\xac\x56\x28\x12\xd5\x8a\x79\x37\xf2\xa2\x8b\xa3\x8b\x7f\xe2\x53\x43\x8b\xa3\x8b\x89\xf6\xec\x26\x69\x1f\x1b\x87\xc5\x3f\x50\xad\x56\xdc\x9e\xe0\x54\x13\xfa\x44\x35\xb1\x41\xfe\x8d\xd9\x53\xef\xec\xd8\x5c\xaf\x0e\x5f\x0c\xe5\xa6\x6c\xae\xcf\x2e\xde\xc0\xc2\x3f\xf8\x0d\xed\xc5\x7b\xea\x85\xe4\xb5\xd4\x1c\x4a\x4d\x4c\x5e\x4f\x45\xa4\xcf\x29\x59\x52\x4c\xe6\xc5\x6b\xb4\x9a\x28\xbb\x91\xb0\x91\xba\x0e\xf1\x4b\x9c\x0a\xa7\x5a\xa1\x80\x1a\x2a\xba\x18\xf2\xf8\xd0\xe2\xd0\x62\x78\x88\x4f\x8d\x2e\x0e\x2d\x26\x06\x3c\x68\xa2\x8b\x41\x4d\xc5\xda\x31\x27\xd6\xd8\xeb\x70\x3d\x54\x3c\x39\xde\xec\xf8\x4a\xe4\x11\x54\x32\x3d\x94\x3a\x3c\x19\xf2\xf8\x64\x2c\x91\x19\x5e\xad\xb8\x29\xb1\x46\x3e\xc5\x64\x67\x4b\x79\xfb\x38\x68\xe2\xf7\x49\x4d\xed\xd9\x62\x0c\xb3\x81\x4f\x0d\x19\xd4\x78\x2b\xf3\x77\x4a\x1d\x2e\xf3\x50\xc9\x11\xfd\x3d\x6a\xc5\x8c\x04\x18\x1d\x6e\x4e\x54\x27\x55\xa8\x93\xfe\x16\x7b\xb1\x71\x02\x4c\x48\x31\xf0\xd1\xc2\x68\x61\xca\x4f\x7c\x28\x76\x1a\x70\x3b\x8a\x8d\x7e\x29\xf0\x10\x1f\xe9\x90\x3b\x52\xe4\x0e\xb9\x83\xb8\x81\xe1\xab\x70\x73\x62\xf8\xeb\xd0\x88\x58\xf1\x68\x61\xa8\x30\xc5\xc0\xe3\x04\x9c\x90\xf2\x13\x2f\x77\x44\x3a\x52\x22\x1d\x91\x8e\x9f\xf8\x54\x98\x80\x13\x76\x50\xa1\xc2\x50\x21\x91\x8c\x34\xf4\x87\x69\xe8\x4f\x70\x0e\x9c\x13\xd5\x49\xbd\x50\x46\xc5\x5e\x08\x45\x16\x0f\x2d\xbc\x12\xde\xe2\x63\x4f\x59\xb1\x21\xf6\xba\x28\xe1\x59\x5e\x44\x5a\x09\xfd\x7d\x4c\x1a\xb5\x98\xff\x6f\x85\xa2\xd2\x0d\x3f\x4c\x38\x45\xfd\x09\xb4\x96\x52\x27\x95\xc8\x0f\x31\x85\xa6\x42\xbd\x5e\x18\x3b\x96\xd0\xeb\x0b\x61\x17\x8f\xcf\xc1\x73\xf8\x1c\x3e\x47\xe8\xf5\x45\xa6\x42\xae\xb0\x30\x10\xd4\x8b\x63\xbf\x22\xf4\x41\x53\x7d\x3d\x5b\x1f\xa8\x0b\x06\x05\x88\xc3\xc0\x73\xb1\xc4\xba\x58\x62\x7d\x30\x28\x7c\xf5\x15\x11\x0c\xd6\x07\xe0\x0a\x65\xd2\x07\xc5\x01\x00\x78\x4e\x1e\xcc\x07\xea\xb9\xfa\xfa\x58\xda\x57\x63\x89\xa0\x3e\x50\x58\xc8\x16\x9a\x8a\xf4\x7a\x01\x9f\x1b\xa8\x2b\x96\x58\x54\xc8\xca\x77\x42\x2e\x93\x46\x21\x3d\x87\x1a\xec\xbc\xca\xab\x9a\xd5\x44\x52\xe8\x65\x00\x3e\x72\x28\x72\x28\x46\x9c\xa9\x90\x2b\x8a\x53\x83\xd7\xe0\xda\x9f\x8e\x30\xb1\xaa\x2f\x7f\x05\x33\x29\xc8\xc5\x5c\x79\x94\x3c\x12\x66\x52\x97\x63\x15\xf9\x0b\x0b\x59\xf0\xe1\xf8\x33\xbc\xea\x22\xdc\xca\x77\xf3\x20\xf5\x85\xb4\x20\x7d\x49\x85\x69\xd0\x5c\x77\xb7\xd6\xde\xf0\xda\x86\x57\xe3\xb3\x6d\x52\x48\xc3\xe0\xa8\xa1\x73\x27\xa5\x0b\x4b\xb3\x32\x17\xeb\x58\xa7\x12\xde\xe5\xf7\x2b\xbf\xfb\xee\x1f\xef\x75\x0a\xe7\x3a\x76\xee\x78\x95\x3d\x3c\xa7\x67\xfa\xfa\x4d\x7a\x7d\xa1\x90\x5f\x92\x57\xb0\x74\x36\x59\x6e\x36\x58\x8d\x9c\xc9\xe4\xf6\x5a\x44\x4c\xf9\xb1\xb4\xd2\xda\x20\xd5\xa4\xc2\xd0\xcf\x21\xf9\x5d\x78\x84\x83\xc9\xa0\x45\x1e\xa7\x8b\x32\x8d\x5a\x26\x8d\xea\xe6\x41\x07\xfd\xa0\x03\x1a\x74\xa0\xf9\x92\x0a\x4b\xa0\x61\x26\x50\x11\x2d\xbc\x4e\x5d\x81\xfe\x91\xd7\x49\xd2\x6c\xa2\x22\xd2\x15\xb8\xc2\xa3\x46\x89\x74\x98\xfe\x1f\x14\x6b\x62\x14\x6b\x94\x21\x3a\xa2\x61\xd2\x62\x9f\xda\x04\x39\x21\xa6\xc0\xee\x95\x25\x26\x1d\x87\xa1\x02\x15\x38\x2c\x9d\x84\x84\x16\x1e\x13\x94\x38\xec\x65\x54\x80\x22\x1d\x86\x91\x90\x00\xa7\x29\x4c\x50\xbc\x0c\xc3\x40\x01\x0a\x18\xf6\x32\x89\x09\x5e\x1e\x12\x94\x30\x2c\x1d\x14\xa8\x78\x19\x87\x91\x98\xf0\x38\x0f\x09\x0a\xf8\x1a\xb4\xeb\x29\x1c\xaa\x58\x0c\x19\x38\x11\x26\x62\xc6\x09\x12\x86\xb6\xf0\x38\x54\x89\x19\x8b\x71\x22\x4e\x5c\x8c\x19\x24\x0e\x7d\x9c\x87\xa1\x8a\x13\x98\x01\x13\x71\x22\x64\x2c\x26\x71\xa8\x97\x87\xa1\x4a\xc8\x38\x01\x13\x61\xe2\x09\xc8\x20\x61\xe8\x46\xea\x65\x3e\xfc\x99\xbc\x8c\xf9\x99\x47\x1e\xf8\x14\xe0\x81\xff\x99\x4f\xc5\xe1\x30\x1c\x14\x54\x2a\xf2\x18\x4f\x8f\x5f\x0f\xc7\xe1\x97\xf9\x54\xe0\x07\x12\x63\x97\xc3\x71\xf8\x6f\xb1\x5c\x3e\x96\xf8\x1b\x0f\xc3\x61\x38\x01\x19\x30\x9d\x19\x1a\x9f\xec\xae\x08\xad\x8f\xf5\xad\x7b\x7e\x8e\xf5\xac\x0e\xec\x48\xc1\x11\x30\xc2\xc0\xa7\xde\x73\x4f\xac\x5f\x1d\xc3\x63\x3b\x28\x79\x82\x3c\x81\x80\xbb\x1e\x65\x86\x52\x71\xbf\xe3\x8f\xe4\x64\x2a\x51\x4d\xa4\x85\xee\x64\xf0\x35\xb4\xa1\x1d\x7b\x31\xe1\x9e\xae\xd3\x0f\x0b\x21\x4b\xc8\x4c\xbc\x36\xbe\x73\x38\x26\xb0\xd7\x8a\xf0\x55\x66\xde\xe7\x9b\x7e\x86\x44\x16\x4e\x81\x0d\xec\xd0\x0b\x89\xbf\x6c\x9a\xfb\xb9\x20\x6f\x88\x2c\x61\xe4\x89\xf8\x1d\x7c\x1f\x79\x3c\xee\xf4\xfa\x7d\x64\x62\xe4\x09\xf8\x0e\xbf\x87\x6e\x0a\xbe\x97\x9f\x10\x92\xd5\xc4\xf4\xbc\x84\x3e\x35\xd1\x9b\x18\x5f\xb1\xbc\xb0\xfc\x8d\xa7\x84\xa8\x56\x01\x47\xe1\x28\xd1\xd6\x56\xd3\xb5\x97\xdd\x5b\xd2\x95\xd3\x26\x4c\x7e\x9f\x68\xcb\xc9\xb8\x2e\x4f\xe5\x88\x51\x31\x2a\x10\x3a\xc8\xa5\x36\xb5\xea\x84\x90\x18\x4d\x83\xb7\xa9\x0f\x3e\x24\xda\x5a\x6f\x94\x68\x15\xf0\x28\x1c\x23\x42\x5a\xc5\xdf\x8e\xbc\x71\x41\x1c\xa8\xc7\x19\xab\x47\x4d\xf4\xca\xfd\xcc\xde\xd2\x18\x4c\x54\x0c\x89\x37\xe4\xb4\x8c\x18\xde\xc9\x93\x89\x1c\x1d\xfc\x9b\xdf\xd4\xa6\x13\xe0\x28\x1e\x23\xa2\x5a\xc5\x53\xcb\x67\x4f\x8b\x0d\x1d\xd3\x8e\xcc\xfe\x9b\x10\xd2\x2a\xf0\x28\x1e\x25\x72\x62\x75\xb7\xe5\x08\x1f\x4c\x26\x74\x6d\x9d\xf0\x0c\xdf\xda\x26\x86\xe2\xd8\xda\xaa\xbb\xf6\xc6\x67\x43\x27\xe7\x25\xf4\xaa\x15\x43\x12\xd5\x8a\xe9\xf2\x9b\x31\xa9\xf0\x46\x6d\xd5\xb1\x56\x94\xe6\xe8\x62\xad\x10\xe3\x98\x32\x06\x30\xe5\xb4\xc2\x9d\x7c\x5b\xab\x08\xc7\xe0\x28\x11\xd5\x2a\x9f\x7a\x63\xf9\x05\x01\x68\xc5\x85\x37\x8e\xfc\x4d\x0c\x69\x95\x70\x2c\x56\x73\x1c\xa8\x4d\xfc\xe0\x03\xa2\xb5\xad\xa6\x33\x56\xd7\x64\x35\xd1\xf7\x67\x5d\x21\x6d\xac\xae\xc9\x1f\x10\xad\x37\xe4\x4f\x9d\x4e\xc4\x63\x18\x63\xc6\x75\x6b\x9e\x98\x08\x7e\x0c\x8e\x11\xad\xba\x1b\x10\x39\xe2\x93\x93\xaf\xb7\x69\x80\x9f\x84\x2e\x56\xcd\x40\xa3\xd2\x62\x12\x6b\x33\xd2\x6a\xc5\xe4\x04\x27\x6c\x4a\x2c\xe2\xc3\x34\xec\xe7\x23\x92\x2c\x9d\xe3\x51\x42\x9d\x12\x3f\x8d\x8c\x9a\x8b\xdf\xa3\x28\xae\xbc\xab\x0c\x95\x98\xc4\x62\xda\xbb\x38\xfd\x0c\xd2\x42\x95\xae\x2a\xa3\x36\x97\x34\x04\x02\xa6\x1a\xae\x29\x58\xd7\x58\x67\x6d\x70\xd4\x89\xb6\x1e\x7b\x4f\x0f\x2b\x6f\x83\xfd\xff\x90\x9f\x12\x40\x87\x92\xe2\x6f\x94\x2c\xc9\xb1\x8f\xf2\x5a\x2a\x64\x95\x75\x55\x7c\xa8\x25\x74\xb5\x8e\x4a\x46\xa5\x9a\xb8\x9c\x50\xad\x26\x2e\x27\x86\x24\xb9\xbf\x8e\x0a\x59\xc3\x57\xab\xf8\xe4\xd8\x80\x75\x25\xa4\x89\x0d\x58\xff\x4f\xb7\x6a\xa0\xd5\x78\x17\x53\x50\x52\x5c\x08\x7f\x50\xc5\xb5\x0d\x22\xbc\xa0\x6c\xa8\xad\x8d\x3b\xda\xd5\xd7\x14\x17\x88\x76\x18\xcd\x94\x38\x8a\xcb\x0a\x38\x9c\xa9\xc8\x2f\xae\xaa\x11\x0b\x43\x09\x44\xc0\x13\x08\x78\x05\x9f\x5f\xf2\x48\x1c\x64\x29\x24\xc9\x66\xf1\x8b\x01\xab\xc7\x64\x62\x93\x9d\x71\x73\x99\x97\xa8\x04\x70\x01\x7d\x05\xd4\xd0\x0f\xea\x2b\x31\x49\x57\x03\xcf\x32\x1b\x32\x0b\x37\xc4\x86\xa1\x0d\x99\xf5\xfb\xc4\xd3\x4a\x79\x83\x12\xb4\xd0\x8f\x5a\x65\x64\x83\x72\x9e\x32\xb2\x34\x74\x89\x59\x90\xfe\x72\xef\x3a\x7e\x6f\x5b\x41\x69\x55\x4c\x91\x7f\x98\x90\x0d\x57\x98\x05\xe9\xe9\x0b\x04\x5c\xa0\x80\x3b\xe0\x61\xa2\xba\xaa\xad\x61\x2f\xd7\xfb\x72\xfa\x02\x51\xfe\x0b\x4a\x2f\xf0\x91\x19\x0a\xb8\xfd\xc7\x1f\xe1\x76\xb8\x7d\xc4\x8f\x78\xfb\xb3\x33\xb7\x2e\x5e\x23\x22\x8d\x7f\x45\x1a\xfe\x4a\x9c\x58\x33\xb3\xe3\x59\x0e\x6f\x1f\x31\x02\x6f\x87\xb5\x94\x18\x99\x71\x2f\x85\xfd\xc3\xf8\x2b\x11\xcd\x67\x7c\xb8\xff\x49\x4a\xd6\xc0\x76\xaa\xb9\x39\x37\x4c\xc3\x3f\x6d\xbc\x9d\x07\x99\x42\x07\x3e\xf8\x3c\x3e\x82\xcf\x09\x4b\x96\xaf\x58\xb2\x78\x05\xa9\x2f\x2d\x31\x15\x70\xb1\x2f\x61\x43\xa0\x26\x58\x2d\x42\x05\x14\x41\x3e\xdc\x0b\xbf\x73\xb1\xaf\xa7\x2c\xc1\x62\xe6\xd2\x3a\x38\x8a\xc4\x23\x59\x4b\x17\x6a\x05\x14\x31\x25\xf2\xec\xc7\xb8\x72\x1a\x89\x07\x1e\x40\x3f\xe6\xe1\x7b\xec\x06\xcf\x06\xff\x46\xc1\x9b\xb7\x63\x81\x71\x2e\x2e\x9e\x30\x94\xcd\x0d\x98\xa5\x42\x61\xd9\xce\xc6\xcd\xe7\xff\xf5\x06\xa4\x9f\xe4\x0e\x5d\x99\x51\x74\x5c\xdc\x7c\xf9\x87\xa2\x2b\x1c\x8c\x82\x91\x87\x2e\x00\x27\xc2\x1e\x10\x60\x29\x2c\xef\x83\x3e\xb2\xba\x2f\xf0\x56\x1f\x9b\x8c\x7f\xc0\x58\x2a\xee\xd6\x83\x1a\x66\xc0\x75\x72\xc0\xf0\x21\xee\x3e\x89\x52\xf8\x2a\x03\x97\xb1\x0c\x9e\xc2\x5d\xa0\x12\x5c\x0e\x9b\x8b\xd8\x33\x6b\xdf\xe8\x67\xb0\x22\xa2\xdd\x18\x51\xb1\x78\x19\xca\xf0\x29\xd8\x85\x2a\xc1\xe1\xf2\x3a\x88\x8c\x73\x1b\xbe\x79\x17\x2a\x64\xed\x5e\x59\xc5\xc6\x75\x95\x70\x12\x0c\x4b\x90\xb5\x30\x2c\xf1\x10\x2f\xf7\x33\x58\x8f\x93\x70\x17\xce\xc0\xf7\x39\x7c\x1f\x77\xc1\x0c\xa8\xc7\x49\xe2\xbf\x61\x04\x0c\x81\xc1\x30\xe6\x13\x72\xf5\xb4\xdc\x89\x8f\xb3\x87\x79\xd8\x49\xe5\x7e\xb4\xfa\x82\x00\x63\x1e\x83\x21\x38\xf8\xdf\x38\x82\x8c\xae\x91\x69\x66\xdb\xf6\xed\xdb\x50\xf1\xc0\x03\xa8\x80\x65\x54\xe8\xcb\x08\xcd\xb4\x97\xb7\xea\x9b\x05\x78\x0d\x67\xe0\x57\xb0\x12\x81\x43\xc0\xaf\x70\x25\xbe\x86\x33\x44\x7d\x6e\xb9\x2e\x9b\xcd\xae\xd0\x05\x73\x05\x7c\x0d\x66\xc0\x57\xb8\x12\x80\x03\x80\xaf\x20\x1d\x4e\xc3\x0c\x31\xd8\x5c\xd1\xda\xce\x26\xc7\x1e\x9b\xe9\x06\xa5\xf2\xab\xb0\x8c\xc1\xa7\x3f\xc6\x11\xc0\x0d\x85\x87\xff\x17\x75\x38\xf4\x22\x72\x40\x3e\x22\x40\x9f\x7c\xed\x06\x45\xa3\x51\x09\xcb\x28\xf8\x03\xe6\x31\x55\xe6\x4a\x83\x5f\x08\xe6\x3e\x70\xb6\x80\xd3\x1b\xcc\x06\xb3\x38\xff\x7e\xa2\x6a\xce\x2c\xff\x6c\x2e\x42\xe0\x9b\xb8\x02\xcf\xe0\x62\xb1\x34\xcf\x94\x9d\xc3\x66\x07\x72\xaa\xf3\x04\x50\xe2\xb3\xf0\x08\xde\x0f\x0b\xc6\x91\x86\xc2\x8d\xf3\x8b\x58\xbd\xdf\x50\x69\x16\xf4\xcd\xff\x9e\xdb\xc0\x55\x55\xf9\x2b\xfd\xe2\x89\x2f\x61\xbd\x7c\x2b\xac\x95\x6f\x8b\x9d\x53\x5d\x6e\xa7\xcf\xcd\x1e\x88\xcc\x63\x3a\x6c\x1d\x96\x0e\x01\xbb\x22\x0e\x02\x9e\x7c\x1b\x94\x30\x01\x66\xb1\xb2\x16\x69\x66\x87\xa9\xb9\xb4\x45\x98\x08\x0c\xde\x01\x77\xe0\xed\xff\x98\x81\x49\x29\x40\x4c\xfc\xf7\xf0\xf7\x51\x89\x63\xd0\x82\x4e\x7c\x06\x0f\x67\x3f\x89\x29\x29\x70\x0a\x5a\x81\x87\xed\xb0\x50\xec\x3e\xd2\x7d\x62\xcf\x2b\x64\x75\x4b\xa0\x79\x07\x9b\xdc\xdc\x1d\x77\xcb\xb0\xf1\x61\x09\x1e\x8e\x75\xf1\x02\xf8\x83\x2a\xb9\xde\xc5\x6b\x6a\x61\x08\x5f\x5c\x20\xe2\x0b\x4a\xbb\x4c\x31\xa5\x8e\x62\xc3\xf5\x1e\x5e\x59\x2d\x16\xca\xcb\x08\xbf\xa7\x32\xe0\x8b\xf5\x70\xff\xf5\x1e\x6e\x8e\xf5\x70\x8b\xa7\xdc\xcc\x66\xc8\x5b\x99\x9e\xed\xe9\x3b\x96\x72\x4b\xd3\xb7\xad\xda\x2e\x46\x25\x75\xb8\x6c\xfb\x1a\xd7\x92\xd6\x35\xa9\x6b\x5a\x5f\xca\x39\xc2\xcd\xa1\x14\x47\x5e\x6a\xeb\x6e\x15\x5b\xbb\x5d\xc7\xb7\x77\x93\xc9\xf8\x47\x4c\x78\x26\x0a\x13\xd5\x44\xba\x9a\x48\x67\xa6\xf7\xa1\x66\xfa\xc8\x91\xa8\x41\x4d\x4a\xf4\x01\x18\x67\xf0\xe8\xad\xe5\xa6\x54\x59\xc5\x9b\x4c\xb6\x32\x97\x31\xd5\x6d\xf0\x1b\x25\x8b\xec\xc3\xce\x14\x0c\x62\x10\x17\xf4\x12\x2e\xbb\xcd\x69\xe3\xe4\x41\x94\x38\xf2\x7e\xb3\xc9\x6a\x74\x19\x53\x5d\x46\xaf\xb1\xc2\x02\x3e\x9c\x9b\x02\x73\xd1\xe7\x2f\xaf\xb0\x56\x3a\x52\x5d\x4e\xa7\x8b\x83\xa3\xbc\x78\xe5\x4a\x85\xe4\xa9\xb2\x55\xa5\x2e\x80\x05\x10\x84\x20\x74\x46\x7c\xb1\x02\x92\x3d\xd5\xe1\x71\x3b\xdd\x5c\x20\xe0\xf6\xfa\x44\xa0\xaf\x54\x56\xf8\xaa\x6d\xc1\x54\xd4\x84\x66\xc0\xc3\xf0\xf0\x95\x2b\x7d\xa0\x99\xde\x97\x9a\x9c\x66\xa3\xa0\xa7\x0f\xfa\xfb\xa0\x07\x34\x70\xf5\x55\xaa\xb3\xaf\x13\x68\xd0\xf4\x81\x06\xe8\x81\xeb\x4a\x5e\x4e\xa0\x18\xe8\xe2\xfb\x86\xc0\x01\x2a\xaa\x81\xab\x0c\xf4\x43\x0f\xf6\x2b\xfb\x86\x40\x3f\xf4\x63\xbf\x32\xaa\x91\xe9\x18\x84\xac\x8d\xea\x98\x18\x90\x36\x14\x3f\x0f\xdc\x77\xf1\x37\x0a\x0d\xc0\x86\xae\xd6\xf1\xd3\xcb\x28\xe8\xe9\xa7\xfa\x60\x1a\x8f\x3d\xca\x90\x2e\xfa\x27\xd2\x01\x5c\x07\xa8\xbe\x21\xd0\xc5\xa3\x24\xeb\xfe\x27\xf0\xff\x7f\x40\xa6\x66\xa0\xe3\x2e\xd2\x36\x3e\x34\x3a\x7c\x88\x81\xbb\x87\xe3\x9d\xff\xc0\xa9\x1c\xea\x1e\xe5\x41\xa7\x80\x91\x7d\x78\x2b\xde\x7a\x56\x3c\xf4\x6d\xcf\x37\xa7\x3f\x27\xc3\xe1\xe8\x21\x66\x17\x8f\x92\x12\x47\x4e\x87\x5b\xe1\xd6\xb9\xe2\xea\x07\x56\x8d\xd6\x3e\x4c\x62\x35\xcc\x84\xe9\xfb\xe0\x24\x37\x10\x7f\xe6\x2c\x1f\xa6\x93\x06\x20\x3f\xc2\x21\xd8\x8c\x55\x98\x28\xe6\xbc\x90\x3d\x37\x73\x1e\x89\x83\xe6\xcd\x18\x83\xa9\x7f\x56\xf2\x11\x0c\x81\x66\xa8\x82\x44\xb1\xed\x4c\xfb\xd9\x5d\xa7\x49\x18\x74\xfa\xfc\x65\x48\xe5\x40\x8a\x49\xa7\xb5\x25\x67\xf9\xe4\x81\xf9\xb2\x10\xcd\xc0\xef\x91\x7b\xa0\x3b\x52\x1e\x29\x8f\xdc\x83\x87\xf0\x37\x5c\x01\x29\xf8\x1c\xac\xc2\x9b\x85\xa5\xf8\xd8\x53\xb3\x67\x3c\x5d\x5c\x50\x58\xec\xcb\x26\x9d\x4e\xa7\x83\xf5\xe5\x34\x17\xb5\xb8\xbb\x7d\xdd\x81\xfd\x95\xf0\xe4\x61\x18\xf3\x19\xdc\x09\x24\x69\x39\x76\xc2\x76\x82\x93\xcb\xe5\x7b\xa0\x1b\x7e\x17\xe3\x9a\x64\x4c\x0e\xb8\x87\xc7\xe9\xb8\xd1\x98\x9e\x8e\x1b\x25\x98\x2e\xc4\x94\xe7\x7b\xf8\xc8\x28\xf8\x10\x4f\xc8\x73\xe5\xb9\xf0\x21\x9c\x90\x47\x09\xd7\xa4\x90\xb4\x9e\x82\xf2\x81\x68\x37\xfd\x7c\x58\x92\xe9\xff\x7a\x9f\xdc\xdc\x0c\x57\x29\x58\xc9\xb4\xb7\x3b\x7b\xb2\xdb\xa3\x85\xa1\x82\x01\xf5\xae\x20\x25\x3b\xdb\xb9\xaa\x3d\x1b\x26\xe0\x5f\xaf\xab\x78\xf2\x80\x6a\x17\xe9\xd8\x41\xc1\x04\xf8\x2b\x91\xdc\x9c\x01\x57\xa9\xd0\xe6\xeb\x65\x71\x02\xfc\x35\xc5\xc0\x47\x06\x94\x3a\xb9\xc3\xc0\xa7\xe2\x04\xfc\xeb\x00\x9a\xd4\x50\x61\xb4\x20\xae\xdf\x15\x10\xc9\x70\x1f\x7c\x39\x60\xab\x6a\xe7\x3b\x99\x80\xad\xc2\xea\x17\x50\x03\x5a\x22\x60\x36\x78\x8d\x5c\xa4\x5f\xa6\x41\xab\x98\xcc\xd7\x5a\x6a\x0d\x55\x22\xf6\xcb\x34\x51\xa3\x2f\xa8\xc8\xe7\xf2\x0b\xca\x4b\xf4\x22\xf6\x47\x68\xc2\x50\x66\x29\x2e\x86\xf5\x14\x68\x23\x1a\x05\x6a\x94\xd9\x96\x35\x07\x84\xb0\x36\x9b\x0a\xd1\xb2\x66\x3d\x85\x5a\x59\xa3\x00\x8d\xb2\xdd\xd7\xbd\x4e\x88\x07\xc3\x30\x79\xca\xbd\x16\x11\x34\xa8\x25\xca\xfd\x95\x56\x89\x93\xfb\x23\x34\x6a\xa7\x50\xc5\xbe\xe2\xca\x32\x11\x62\x48\x4b\x82\x0d\xc6\x46\xae\xb1\x41\xaa\x09\x8a\x10\xab\xb6\xb2\xca\x57\x5b\xcb\x26\xa7\x01\x52\x60\xa5\xfe\x74\xd4\x57\x65\x85\xe8\x21\x37\x4c\xe5\xae\x9b\xc9\x85\xff\x7b\x8a\xa0\xda\xd5\x1e\x93\x4f\xfe\x13\x77\xc9\xfe\xc9\xb3\xff\x3d\xee\x52\xd1\xe6\xe5\x93\xff\x77\xdc\xa5\xb6\xf2\x56\x4b\xeb\x40\xdc\x25\xd5\x86\x4e\x6f\x7b\x47\x67\xdc\xc8\x00\xbe\xa2\x0e\xf1\x61\x0d\xe8\xa9\xa8\xe6\x25\x0a\x6f\xfb\x69\x38\xdc\x26\xc4\x54\xdc\xb9\x7c\x32\xdc\x17\x1b\x9e\x94\x2f\x26\xaa\x95\x2f\xca\x9f\x32\x47\x16\x56\xad\x17\xae\xf5\x2b\xc6\x21\x35\x7f\xda\x5c\x11\xbf\x8c\xa4\x11\x45\x05\xc5\x39\x39\xec\xf2\x57\xca\xf6\x0b\xe1\x7e\xc5\x17\x40\x9d\xba\x70\x56\x84\x2f\xe5\x34\xa2\xae\xa1\xb6\xad\x8d\xc5\x2b\xf0\x1d\xe8\xa9\x48\xcf\x4b\x54\xb9\xcb\x58\xce\xfa\xfc\xf0\x95\x9c\x46\x5c\xf9\x14\x1e\x7c\x0f\xee\xe0\x42\xfd\x8a\xe4\x6b\x7a\x10\xe3\x73\x2b\x89\x21\x6d\xac\xe2\xfd\xfc\xff\x9a\xaa\xb9\x26\xc1\x58\xfe\xff\x67\x76\x26\x2c\x01\xbd\x91\x6a\x96\x25\x90\x12\x9c\x6a\xe5\x20\xb8\x8d\xba\x26\x01\xad\xbc\x48\x85\x25\xa4\x95\x7f\x4e\xdb\xc0\xee\x81\x39\x5c\x90\x4a\xa8\xc4\x10\x1d\xa2\x19\x94\x22\x31\x5d\x5f\xa6\xc3\x12\x83\xd2\xb5\xd8\x75\xac\x08\xa3\x96\xcb\x74\x3c\xd2\xea\xf0\x20\x35\x39\x48\x11\x1d\xc8\x8e\x0e\x80\x42\x4c\x7a\x55\x63\x19\x48\x71\xab\xb1\xfe\x04\x27\xf4\x24\xda\xf9\xf0\x43\xcc\xd6\xf4\xf5\xeb\x56\x65\x92\x2e\xa3\xd3\x68\x64\x71\x0f\x6e\xc0\xfe\xc8\x10\xbc\x05\x6f\xda\xf7\xfa\x68\xc1\x5e\x57\xef\xa8\xe7\x7e\xf8\x6a\xef\xe9\xbf\x89\x0f\xba\x9f\x38\x97\xf5\x0f\xd2\x5e\x5d\x6d\xaf\xe6\x1a\x6b\x3c\xbe\x06\x71\x64\xe3\x13\x97\x7e\x66\x5d\x4e\x97\x53\xe8\x2c\xee\x32\xec\x73\x90\x2f\x1c\xdc\xd8\xd7\xcf\x1e\xac\x3a\xd0\xb0\x47\xf8\x15\x69\x78\xf0\x51\x78\xca\x48\x5a\x6b\x1d\xf5\x75\x2c\x90\xdf\x7e\x0b\xe4\x1b\xaf\x65\xaf\x3a\x28\x1c\x97\x8e\x34\xf4\xb4\x15\x2d\xde\xb4\x72\xc5\xb6\x97\xfd\x87\xaa\x0e\xd6\x93\x20\xc1\x82\x34\x3e\x34\x1b\xaa\x61\x0b\x14\x27\xa8\x89\x3b\xa0\x1c\xfe\xc2\xcb\xbb\x4e\x53\x30\x07\x9e\xe2\x9b\xdf\xe7\xdf\x94\x5f\xfe\x16\xe8\xb7\xe1\x33\xbe\xef\xfa\xa4\x6b\x58\x13\x17\x45\x43\x5a\xe6\x1e\x3e\x26\x54\xc2\xa7\xf1\x68\x0a\x33\xa8\x98\x9c\x3d\x64\x2d\x7f\x4d\x8a\xbc\xc7\x00\x3d\x27\x36\x6c\x46\x68\xf9\x3d\x46\x4f\x5d\x93\x42\x43\x18\xa0\x65\x3a\x96\x24\xa1\x96\x01\x3a\x94\xa2\xec\x03\x9a\x08\x5d\x44\x41\x81\x94\x32\xc6\x6c\x06\x0e\x53\xea\xf0\x20\xc5\x06\x5e\x8c\xbd\xe2\x87\xf8\x39\x94\x22\x6e\x7c\xda\x1c\xeb\x8c\x21\x7a\xc0\xc2\x25\x76\x4e\x0c\xf5\x87\x25\x66\x0f\x95\xb9\x35\x10\xdc\x26\x04\xb7\x05\xb6\x66\xb2\xf0\x77\xea\xb7\xcf\x3f\xff\x6d\x57\x87\x49\xbf\x43\xd0\xef\x30\x75\xec\x62\xaf\xf0\x42\xe8\xeb\xa8\x96\xd9\x85\x9d\x50\xb7\xee\x80\x30\x10\xda\x4c\xf7\xe0\x83\xba\x6d\xdf\x4e\x68\xce\x15\x47\x8e\x44\x00\x20\x3e\xba\xda\x0b\x34\xa4\xb0\x90\x89\x23\xe1\x7e\xdc\x82\x9f\x5e\xff\x6f\x81\xfb\x71\x24\x64\x42\x0a\xd0\xbd\x1f\x5d\x15\x42\xe3\xa2\xe3\x60\x01\x7f\xba\xaf\xef\x74\xdc\xb0\x57\xc4\x2c\xc8\xba\x72\x85\xc8\x6d\xfe\xf4\x81\x1d\x5c\xeb\xd7\x5f\xb7\x8a\xc9\x70\xdf\x16\xde\x9a\x7b\x34\x17\x24\xb8\x1c\x7b\x9d\xe8\xc1\x16\x0a\x24\xd5\x13\x61\x3a\x44\x17\x51\x21\x29\x22\x31\xcf\xbc\x30\xf7\xe9\x67\xe6\x9e\x79\x0f\x56\x53\x61\x29\xe9\xcf\xbb\x6b\xbc\x2a\xf0\xee\xd9\xb9\xcf\x88\x11\x3a\xf2\x57\xa6\xc6\x50\x5d\xe2\x11\x70\x54\xab\xb1\x43\xbf\xb3\x74\x67\x6a\x47\xf7\xee\xfd\xbb\xba\x49\xaf\xdf\xe3\x0f\xb0\x1d\x48\xc1\xa0\x6d\x6d\x82\xcf\x6c\xf2\x94\x73\x26\x93\xdd\x62\x16\x91\x7a\x28\x27\x98\x5d\xb5\xad\x22\x55\x07\x0f\x10\x35\xf6\x92\xaa\x12\x0e\x67\x29\x4a\xf4\x86\x12\xab\x58\xba\xd8\xa2\xb5\x2c\xca\x32\x66\x1b\xb2\x4b\x51\xf9\x55\x8a\x37\x5e\x30\x13\x93\xf0\xd6\xac\x3c\xd1\x62\xb6\x9b\x4c\xac\xc9\x63\xf2\x9a\x85\xce\xb5\xbb\xd7\x75\xac\x2e\xcd\x2e\xcb\x2e\xdf\x86\x0f\xe6\xa4\x94\xda\x0d\xc5\xa5\x2c\xce\x54\x96\x54\x96\xd6\xd8\x05\x18\x95\x23\x6d\x0d\x66\xd5\x64\xa5\x66\xae\xd9\xb2\x2e\x73\x2d\x69\x35\xdb\xcc\x26\x36\x13\xa8\xb4\x1d\x39\x82\xc5\x1f\xb0\x55\x70\x81\x0a\xb7\xcf\x27\x02\xf5\x65\x9b\xbe\xbd\x6c\x47\x79\x6a\x2b\x3e\x40\x94\xb8\x6b\xca\x6a\x38\x98\xa5\xa8\x09\x56\xd6\x78\xc5\xea\x13\xbe\xd7\x7c\xaf\xec\xac\x68\xaf\x6c\xaf\x06\xe5\xd8\x14\x6b\xbc\xe0\x2e\x48\x82\xe4\x9d\x4d\xa2\xcf\xe7\x0e\x04\xd8\x0a\x9b\xdf\xea\x17\x32\x0e\x6e\x39\xb0\xf5\x50\x75\x7b\x55\x7b\xc5\x0e\x78\xb0\x2d\xa5\xda\x5d\x59\x5b\xcd\x86\x68\xfc\x89\x81\x93\x54\x3a\x05\x5f\x50\xaa\x27\x1a\x56\xfe\x68\x6c\x12\xe0\x55\x5e\x9d\xe4\x4a\x82\x93\x94\x6a\x4a\x3a\xa5\x32\xc2\x17\xd4\x40\x86\x6a\x16\xbc\x1a\x37\x4d\xd7\xf1\x21\x89\x81\xfd\x78\x01\x0a\x22\xa9\x50\xcb\x0b\xc7\x79\x51\xa6\x51\x62\xca\x78\x18\xff\xed\xaf\x30\x0c\x1e\x61\x93\xb7\xf0\x4e\x98\xca\x3b\xbf\x1d\xb0\xbb\x79\x03\xee\x80\x35\x40\xc3\x73\x40\x8f\x06\x7a\x1c\xd0\xaa\x17\x7d\xaa\x17\x9b\xe5\x44\x9e\x79\x80\x12\x54\xc1\xde\x98\x3e\x63\xe6\x45\x0b\x25\xf7\x33\xeb\xb6\x8e\x5d\xea\x10\x9a\x73\x6a\x96\x66\xb0\xaa\xad\x3e\x28\xe2\x3d\x05\xee\xfc\x7c\x16\x93\x1f\x5f\x8e\x84\x80\xb7\x2a\x90\x42\xc5\xbe\x83\x78\x93\xd8\x38\xff\xc1\xfd\xf3\xb8\x8c\x10\xdd\xa9\x50\xbd\xe8\xfb\x18\x6e\x81\x49\x67\x8f\x88\xed\x7b\xda\xf6\x74\xec\xfa\xee\xe7\x4d\xf0\x40\xdf\x5b\x24\xf0\xad\x93\xf1\x66\x11\xa9\x91\xe3\xf1\x66\x16\xae\x2a\xde\x39\x37\x7b\x9a\x08\xb4\x8b\x89\x21\x17\x90\x82\x9b\x51\x10\xf0\x69\xc5\xee\x37\x1b\xde\x78\x97\x7d\xc7\x7a\x76\xf3\x39\xe1\xbb\xc5\x23\x0e\x0c\xe5\x36\x66\xc4\x94\xee\x11\xf7\x75\xe2\x43\xb3\xa7\xaf\x5d\xb5\x21\x7d\xe3\x0a\x52\x15\xec\xdd\xb2\x66\xda\xd8\x35\xdb\x48\xdc\x19\xeb\x63\x51\x1a\x0e\xf1\xd0\xa3\x50\xbd\xd8\xdc\xf1\xe9\x16\xc3\x2e\x71\x19\xa4\x40\xca\x4a\xb8\x9b\x53\xbd\xe8\xfb\x46\xb1\x5f\x01\x8b\xf8\xf6\xc3\xd5\x27\x4f\xb2\xad\xb6\x36\x73\x8b\xd0\x79\xbc\xfe\xcc\x59\x36\xd9\x46\x2d\x18\xe0\x10\xa4\x0d\xd8\x04\xbf\x0e\x77\xc0\x5a\xa0\xe1\x56\xa0\xa7\xfd\xc9\xa5\xd9\xbd\xaa\x0f\x6d\x20\x85\xfb\xe3\x6c\x7a\xe4\x3f\x6c\x8a\xf4\x33\xd3\x66\xcd\x7e\x56\xc0\xab\x0a\xbc\xf9\xca\x78\xa4\x58\xbc\x59\x37\x19\x79\x61\xfa\x5b\x5d\xf0\xc0\xfd\x3f\x6f\xdd\x95\xb3\x27\x7b\x0f\x79\x76\x39\xde\x02\x93\x1e\xe7\x32\x14\xaa\xd9\xbd\x21\xba\x53\x79\xfa\xeb\xfd\x8d\xa7\xc4\x83\x70\x13\x28\xf6\x01\xc5\x01\xad\x50\xcd\x6e\x86\xc4\xf7\x17\xe1\xcd\xa2\x6a\xb6\x2f\xdf\x9e\x6f\x2b\x10\x5e\xd2\xb5\xbe\xb0\x8c\x55\x7d\x68\xcb\x31\xe7\xe8\x73\x85\xbd\x19\x8d\xab\x97\xb2\x19\x25\x4b\x73\x73\x04\xd5\x6c\xdf\x31\x47\xc7\xd8\x75\x2c\xd0\x0e\x46\x35\xbb\xf9\x6c\xe1\x99\x8c\xe3\x82\xbf\xc5\xd3\xd6\xca\xaa\x66\xf7\x9e\x2c\x3d\x99\x7d\x58\x70\xd7\xb8\x6a\x6b\xd8\xbe\xdc\xbe\x35\x27\x05\x9f\x52\x75\xb8\x17\x66\xbb\xf0\x4e\x18\x84\xcf\x73\x98\xa4\xc0\xd1\x78\xc7\xda\x45\x38\x4c\x34\x64\x4e\xd8\xb2\x95\xc3\x9e\x18\x6d\x7f\x32\x72\xa7\xa2\x7b\xdb\x85\xb1\xbb\xd7\xec\x5d\xb1\x2f\xfd\xe0\xea\xd7\x9f\xdf\x8c\x0f\xfd\x78\x1f\xa9\x6b\xeb\x2c\xd9\xcb\xfd\xfa\xe3\x81\xef\x4e\x88\x7b\xde\xf0\xbe\xf1\x36\xfb\x6e\xc1\x1b\x5b\xde\x14\xe0\x69\x45\x8c\x41\x02\x50\x70\x33\x08\x62\x72\xf4\x8f\x47\xd5\x8a\x71\x09\xce\x50\x7f\x62\xa8\x5f\x4d\x5c\x62\x9c\xca\x5c\x9e\x70\x2a\x93\x9b\xd5\xc4\xa0\xb8\xe7\x4c\x78\x32\x83\xd3\x71\x26\x3e\x61\xb3\x09\x91\xbf\x47\x4e\x47\x3e\x92\xcf\x10\x76\x37\xce\x84\x27\x60\x3a\x0b\x7b\xe1\x85\xd7\x41\x03\xf7\xc1\xe3\xf8\xf0\xcc\x57\x85\xb6\xcc\x93\xce\xb6\x5d\xe4\x9b\xaf\xc2\xe3\xf0\x30\xdc\xc7\x81\x06\x5e\x98\x83\x7b\x45\xa0\x87\xfc\xdf\xae\x2e\xb0\x95\x4f\x4e\x83\xed\x7c\x62\x88\xbe\xc2\x1c\x58\x63\xc9\x16\xb0\x47\x11\x5f\x98\xd1\x0e\x2c\xcc\x40\xbf\xe2\x48\xe9\x85\x8e\xa5\x94\x88\xfd\xff\x7d\x99\xf5\x7a\x8e\x18\xd6\xc8\x3d\x5d\x54\xec\x5b\xe7\x09\x3d\xff\x2d\x98\xa0\x2a\xc1\x09\x06\x28\x02\x15\x14\x81\x05\x8a\xc0\x90\x08\x06\x48\x66\x42\xcf\x43\x51\xf4\x79\x65\x6d\x38\x8d\x79\x6e\xd1\xfc\x09\x82\xd3\xa1\x9c\xb8\xe8\xd4\xdb\x17\x5e\x7d\xf5\xe3\x8f\x4f\xbc\x38\xcd\x25\xca\x9f\x5d\x4b\x63\x64\xa5\xf2\xdb\x4d\xe7\x1f\x9d\xbe\x36\x7d\x55\xa1\x60\x2e\x76\xe4\xe6\xb1\x91\x14\x2c\x72\x2a\x3d\xa1\x9b\x6d\x6f\x39\x59\x28\x1a\x6e\x57\x1c\xdf\xfd\xda\x45\xb8\x3d\xa6\xe7\x2b\xee\xc5\x8d\x62\xe4\x6e\x25\x18\xc2\x85\x69\x7c\xe4\x8f\xd8\xb0\x9b\x00\x12\x68\x12\x65\x5d\x48\xc3\xc0\xa7\x94\x20\x6b\x95\xa3\xa8\x19\x94\x10\xd1\x2a\x43\x1a\xbc\xca\xc0\xa3\x78\x3b\x8c\xc1\x14\x41\x96\x94\xed\x7c\x4c\x72\x12\xa3\xb4\xe2\x86\xf4\x24\x46\x24\x25\xa6\xe0\xed\x38\x06\x1f\x1d\xcd\x8b\xf2\xbd\x8a\x0f\x23\x05\x44\x91\xa7\xba\xac\x8e\x73\xba\x9c\xce\xba\xea\xea\x3a\xb7\xf0\x8a\x9c\x47\xc8\x4f\x0e\x18\xa6\x5a\x28\xf8\x9c\xd2\xf1\xf2\x55\x78\x8b\xc2\x7e\x58\xc8\x87\xb4\x1b\xf9\xa8\x76\x2e\x2f\xd3\xea\xa4\xe6\xf5\x54\x44\x9a\x32\xb0\x6e\xf4\x34\x3e\x1d\x4d\x8b\xa6\x4d\xa3\x40\x81\x8a\xf9\x7c\x28\x2d\x94\x16\x4b\x83\x37\x28\x27\xc4\x85\x94\x04\x1d\x0f\x74\x62\xdc\x86\xb8\x8b\x82\xab\x70\x95\xb9\x9f\xc2\x7e\xc5\xf2\xea\x69\x5b\xd7\x75\xfb\xda\x45\xe8\x51\x40\x90\x17\xa3\x5a\x65\x16\x25\x5c\xcf\xe8\xa6\x44\xe8\x1f\xce\x27\xa7\x75\xf3\xd7\xe3\x54\xc8\xfd\x20\xc9\xfd\x40\xd3\x8f\xca\xcb\x43\x77\x31\xb8\xa8\x07\x53\x41\xfd\x3d\x7b\x05\x24\x25\x8e\xed\xc4\xe4\x97\x1e\x14\xc2\xe7\xa1\x83\xb9\x0f\x53\x51\x8d\x8b\x56\x09\x2f\x7d\xdd\x09\xc9\x30\x96\x05\x69\xa4\x22\xde\xb7\xc7\x51\xd8\x73\x45\xb1\x90\x8a\xf4\x2f\xa3\x46\x62\xcf\x75\xef\x39\x5a\x89\x2f\x40\x21\xae\x83\xb7\x8a\x85\x43\x0b\x0f\x6c\x69\x28\x21\x7b\x97\xd4\x2c\x9a\xce\x4e\xcf\x98\x3e\x72\xe4\xc8\xe9\x23\x85\x27\xf8\x50\xff\x23\x7c\x9f\xf2\xca\xc8\xbe\x91\x23\x33\xfa\xfa\xfa\x6a\x4e\xf6\x1e\x17\x1a\x6a\x0e\xec\x3e\xf4\x0a\x09\x6f\xd5\x42\x21\xac\x83\x17\xd8\x64\x68\x39\xff\x4d\x5d\x68\xc9\x41\x0a\x1e\xdc\x01\xe9\x50\x21\xc7\x24\x72\xb9\x0e\xbe\x64\x6c\x36\xb3\xcb\xe2\xb5\x7a\x1d\x7e\xb7\xc7\xe3\xf1\x3b\x7c\x56\xaf\xd5\x65\xb6\xdb\x48\xa7\x72\x6b\x0f\xe3\xb1\x38\xcd\x36\x3b\xe9\x54\xda\xec\x16\xb7\xd5\x67\xf3\x3a\xfd\x1e\xb7\xd7\xed\xb3\x7b\xac\xe4\xaa\x43\x8c\xc3\x66\x75\x5a\x5d\x56\xb7\xdd\xe3\xf6\xb8\x3c\x5e\xa7\xc7\xe1\xb5\xbb\xad\x8e\x58\x81\x66\x1d\x63\xb3\x59\xdc\x36\x8f\xcd\xeb\xf0\x7a\x3c\x6e\xb7\xcf\xe1\xb1\x7a\x6d\x4e\x8b\x3d\x96\xfb\xf9\x64\xc6\x6e\xb5\xd8\xcd\x6e\xb3\xdb\xea\x73\x79\xdd\x5e\x9f\xdb\x6f\xf7\xdb\xbd\x16\x87\x95\x74\x2a\x5f\xb2\x31\x56\x8b\xd5\x6c\xb6\x78\x63\x3f\x7f\xc0\x67\xb5\x0a\x4e\x65\x77\x80\xb1\x5a\x2d\x66\x87\x60\x76\x58\x3c\x0e\xaf\x23\x96\xe5\xf2\xbb\xfc\x76\x57\xac\x4c\x68\x08\xbc\xcb\x60\x2e\x8e\x40\x2d\xae\x98\x26\x6c\xb3\x18\xeb\x6a\xea\x5d\xaf\x5d\x60\x8f\x17\xee\x29\xa8\x13\x40\x51\x0d\x7f\x79\x19\x16\xb1\xa7\xf3\x8e\x6c\xda\x2f\xf8\xaa\x1b\x5e\xdd\xfa\x1e\x99\x5e\x7d\xdf\x73\x4e\x36\xb8\x2a\xdd\xb7\x82\x5b\x91\x6e\xd1\xaf\x12\x9d\xf7\xbd\x9d\x5e\x2a\x6c\x7d\xba\xe1\x45\x5f\x29\xb9\x69\x7d\xde\xf2\x79\x2c\x2e\x84\xbf\xac\x00\x45\xa9\x50\x5c\x5a\xaa\xb3\x6c\xca\x2c\x9d\xac\x5b\xfe\x31\xb9\xf5\xc4\x22\xaf\x93\x5d\x74\x34\xc3\x29\xee\x2d\x6e\x9d\xe3\x64\x77\x3f\x08\x77\xef\x71\xb2\xae\x74\xe7\x6a\x3d\x5b\x62\x2c\xda\xe6\x13\x70\xc5\x05\x1c\x01\x5a\xc8\x65\x61\x2e\x05\xf1\x25\x76\xdc\x2f\x80\x24\xeb\xd2\xe2\xa6\x77\xd7\xdd\x00\xfa\xce\x50\x91\x49\x8a\x27\xb3\x9e\x9e\xff\x68\x4c\x6b\x78\xf4\xe9\x53\xef\x67\x89\x91\x49\x30\x9e\x0a\x2f\x65\x06\xc2\x76\x45\xb4\xb2\x36\xa5\x5a\x5f\xe8\x2f\xe2\x8a\x0a\xe3\xc6\x18\xda\x88\x16\xa6\x53\x20\x45\xb4\xf0\x3a\x2f\x6b\x41\x52\x0e\x84\xf9\x8a\x0d\x0b\xb1\xe1\x42\xc0\x04\xb8\x53\x9d\x74\x40\x4e\xa0\x40\x18\x0b\x69\x3c\xde\x01\xf4\x5d\x40\xab\x93\x8e\x02\xfd\x28\xd0\xaa\x40\x9a\xea\xa1\x34\x35\xa1\x0f\x2d\x66\x70\x17\x2e\xc6\x33\x58\x37\x5a\xc8\x7c\x14\x93\x4c\x0f\xa1\x02\x13\xf7\xa0\x62\xd1\xd2\xed\x8b\x39\xd5\xdc\xb4\x2d\x45\xad\x1d\xe2\xe1\x96\x97\x8e\xb2\x2a\x5f\xf3\xa7\xd9\x1f\x7f\xca\x82\xf9\x5d\xe8\x82\xe5\xf0\x80\xf0\xfa\xe1\x0f\x3a\x2f\xec\x24\xf7\x7e\xfe\xd5\xbe\x6f\x38\x95\x25\x0d\x6e\x01\x62\x09\xdc\xd2\xdd\x2d\x75\x73\x5e\x9f\xd3\xe1\x15\x55\x81\xc9\x52\x91\x2b\x2f\x7f\xb9\x61\xf9\x32\x76\x7e\x55\x56\xe3\x12\xa1\x6e\xb5\x84\xb7\x2d\x65\x81\x76\x33\x7d\x65\x90\xaa\x3b\x2b\xa8\x02\x69\xfa\x4e\x63\xcd\xfe\x23\x95\x47\x8f\xb0\xbf\xae\xfa\x14\x15\xc2\x9a\xb5\x86\xb5\x78\x33\x12\xc7\xf1\x16\x4e\xe5\x98\x8c\x89\xc3\xd6\xad\xba\x47\x54\x05\xd2\x1e\xdf\x3c\x7e\xdd\xb4\x17\x49\x2c\xc3\x69\x1a\x7c\x07\x0f\xb0\x2a\x4b\xda\x5f\xdb\x1f\x9f\xb0\x6c\xfb\xca\xa5\xac\x6a\x6e\xda\xa8\x0f\x1e\xfa\x41\x38\x79\x7c\xd7\x71\x20\x20\x29\x13\x14\xdc\xaf\x70\x9b\xb4\xef\x07\x11\x2e\x42\x12\x14\xc1\xaf\xf0\x39\x9b\x2c\xdf\x46\xe9\x78\x38\xc1\x04\x9c\x01\x5b\x40\x30\x35\x2f\x6e\xc9\xab\x7c\xa1\x73\xee\x9e\x79\x5d\x64\xdd\xb6\x8c\xdd\x9b\x67\x3d\x84\xcf\xcd\xe7\xb2\x36\xb4\xd7\xe4\x88\xf8\xfc\x4f\x38\x18\x06\x0f\x87\xe7\xc9\x92\xb6\xec\x7d\x3b\x4f\xc1\x73\x5f\x9e\x63\xf7\x6c\xe9\x2c\xda\x21\x6c\x3a\xbd\xf9\x6c\xc6\x19\x43\xd3\xf6\x13\xb9\x01\xd2\x63\x32\x39\x4d\xdc\xfa\x67\x8a\x8a\x37\x89\x8b\x73\x33\xe6\x65\x2f\x27\x33\xe6\xe4\xcf\x7e\x96\x1d\x7d\xf0\x91\x3d\xe3\x85\x96\x59\x3b\xe7\xec\xd5\x5e\xc5\x27\x60\x25\xae\x84\x27\xee\x7e\x6d\xe3\xeb\x59\xe7\xb6\x93\x9b\x2f\xfd\x73\xed\x37\xdc\x3b\x6f\x34\x76\xbe\x2e\x1e\x69\x3f\xdd\xd9\x7c\x82\xac\xed\xaa\x7b\x77\xff\x80\x81\xf2\xc0\x60\x17\xbe\x0a\xe7\xf9\xf8\x48\xd4\x3f\x60\x2f\x01\x3d\xa8\x61\xee\xa7\x9c\xd1\x7e\xe5\xbd\xff\x23\xf6\x70\x72\x44\x0f\x7b\xa9\x81\xf1\x2d\xd1\x42\xc1\x79\x5e\x8d\xc3\x95\x91\xc7\xe4\xfb\x1f\xba\xf4\xd0\xf8\xc8\x63\x91\xfb\x09\x75\xd2\xc7\x61\x49\x19\x04\xda\xcd\x97\xf3\x76\x1e\xae\x30\xdb\xf4\x0b\x0d\x39\xc2\x73\x5b\x70\xf0\x92\xa9\xdc\xb3\xb3\x76\xb6\xce\x14\x71\xeb\x27\x68\x04\xe3\x63\xb0\x95\xd4\xbd\x99\x75\xee\x1d\xf6\xe2\x71\x18\xfc\xf6\x6e\xa1\xb2\xed\x95\xe0\x0e\xce\xe7\x77\xda\x7d\x62\x83\xf9\x7d\x1c\x5e\xb7\x95\xac\xca\x6f\xd1\xe9\x56\xe0\x9d\xcf\xaf\x61\xf3\x1a\xb2\x2b\x0b\x84\xf7\x31\xe5\xf2\x18\x48\x79\x92\x34\x34\xb4\x17\x34\x75\xbf\x05\x77\x1e\xe6\x5a\x5b\xb7\x97\x35\x8a\x1d\x45\x30\xfc\x49\x7f\x01\xe9\xb6\x38\xcd\x16\x16\xa4\x50\x43\x1a\x9f\xd6\x9c\x9b\x70\x58\xad\xb8\x37\x51\xad\xd0\x86\x23\xcc\xdc\xec\x19\x05\xcf\x9b\xde\x39\xf4\xca\xf9\xb6\x0f\x66\xae\x7b\x26\x6b\x4a\x09\x79\x7e\xce\x23\xdd\xa3\x39\x9c\x86\xc3\xf0\x1e\x9c\x9a\xed\xc9\xf6\xe5\x88\xd8\x5c\x83\xe5\x40\xe3\x38\x58\x48\x6e\x5d\x52\xa4\x9d\xcd\x62\xd2\x99\x7b\xff\x35\x57\x58\xe0\x5e\x54\x9b\xde\x46\x3a\x9c\x76\x07\x8b\x63\x21\x11\x87\xc0\xbd\x5b\x04\x53\x56\xa6\x35\x93\xcb\xcd\x73\x7b\xf2\xc4\x1e\xa4\xe1\x96\xd1\x70\xb7\x8d\xd4\x60\x22\x8a\x0b\x71\x24\x97\x95\xed\xf2\x6c\x13\x1f\x84\xa1\xf0\xc4\x02\x98\xce\xc9\x97\xe1\x23\xb9\x4c\x9e\x54\xe3\xac\x71\xd4\x88\xe7\x8f\xbe\x76\xe6\x70\x1f\x99\x1c\xd5\x87\x6e\x81\x13\xf0\x39\xec\x4a\x80\x5f\xe0\xf5\xc4\xf0\x3c\x35\x71\x95\xf1\x66\x8d\xae\xc0\x41\x1c\xe6\xe2\x83\x28\xa0\x5f\xc4\x4c\xac\xc0\x13\x50\x11\x75\xc2\xeb\x21\x27\x04\x94\xdd\x70\x82\xc0\xa3\x30\x57\x71\xa9\xf5\x75\xb8\x4d\x80\xb1\x8a\xe4\xb1\x6a\xe2\x63\x75\x78\x04\x3c\x39\xd8\x09\x7b\xa0\xac\x2f\xf4\x38\xec\x51\x1d\xf9\x6f\x0b\x20\xa2\x2a\x1f\xbf\x86\x2c\xec\x81\xb3\xf7\x08\xdd\xa6\x9a\xb6\xa6\x46\xc7\x1b\x7d\xac\x13\x37\x2d\x5b\x0e\xbc\xe0\xdc\xf0\xe5\xa2\x56\xc1\xf9\xcc\xf1\x0f\x1c\x82\xf3\x43\xf3\x4b\x53\x84\x77\x90\x82\xa4\xbd\x87\x9b\x02\x27\x9a\xf6\xb6\x34\x91\x38\xa9\x11\xa7\xbd\x0d\xc7\xd8\x7f\xee\xbe\x70\xe2\x94\x50\xde\xb4\xed\xa3\x97\x7e\x23\xfb\x9a\x60\xc4\xbd\x4e\xb6\xfe\xdc\xdb\xd2\x5b\xdc\x5b\x6f\x1b\x0b\xcf\x89\x4e\x18\xf1\x43\x5f\x9e\xf0\xd2\x5d\xdb\x26\x96\xe7\x91\x27\xe6\xef\x9e\xf6\x08\x8b\xc7\xf1\xd9\xe7\x71\x52\xbe\xd0\x91\xd3\xb6\xec\xa9\x61\x8e\x47\xb3\xd9\xbc\x9a\x9c\xee\x80\x00\x67\x7f\x86\x2c\xe8\x81\xaf\x59\xd5\x91\x91\xbc\x10\xd9\x76\xed\x0b\xc6\x6e\x8d\x0d\xc9\x66\x8f\xcd\xe7\xf6\xba\x3d\x3e\x97\xdf\xee\xb7\x79\x2c\x76\x2b\xb9\x67\x23\x63\xb5\x9a\xdc\x16\x9f\xc5\xef\x08\x78\x3d\x5e\x6f\xc0\xee\xb3\xf8\xcc\x2e\x93\xd5\x46\xee\x5e\xce\x58\x6d\xe5\x1e\x4b\xc0\x12\x70\x56\xf8\x3c\x3e\x6f\x85\xcd\x6b\xf2\x99\x9c\xe5\x16\x2b\xf9\xd2\x4a\xc6\x6a\x31\xba\x4c\x01\x93\xdf\x2e\xf9\xbc\x5e\x9f\xe4\x08\x98\xfc\x66\xb7\xd1\x6a\x25\xcf\x64\x33\x76\xb3\xd1\x56\xee\x31\xba\xcd\x01\xb7\xdf\xed\x97\x3c\x15\x76\xc9\xe6\x37\xd9\xcd\xe4\x79\x0b\x63\x36\x59\x8c\x82\xc1\x61\xf2\x05\x58\x7f\xc0\x27\x09\x92\xab\xc2\x62\x62\xcf\x56\x32\x2e\xb3\xd9\x6c\xb4\x1b\xed\xe5\x5e\x87\xdf\x11\xf0\xfb\x25\xb7\xe4\xaa\xb0\xba\xcc\xe4\x7f\xfc\x3a\x42\x12\x68\xe3\xbe\x29\x87\xf8\xb0\x96\x81\x61\xbc\x80\xda\xa8\xe6\x9f\xbc\xdc\xaf\x5c\xca\x8f\x04\xad\x02\x06\x53\x28\x3d\xc8\xf7\x6d\xa4\xe0\xbe\xb8\xc3\x35\x2d\x93\x31\xe1\x5c\x8a\xbb\xc8\xa8\x15\x97\xe0\x7e\x4a\x1d\xea\xdd\x4c\xa9\x15\x93\x17\x53\x31\xa4\x22\xaf\x0e\xf5\x22\xcd\xa8\x15\x93\x61\x1a\x8f\x3a\x75\xa8\x0c\x74\xd0\x49\xa9\x71\x10\x03\xbb\x29\xf9\xea\x21\x3e\x72\x55\xd9\xc0\xab\xc3\x69\x40\x33\x31\x45\x16\x25\x45\x4c\x7f\x67\x16\xf0\x11\x5a\x11\x1b\xa8\x62\x4a\x79\x26\x2f\x4b\x78\x1b\x53\x08\x1b\x47\xc3\x32\x1c\x05\x23\x71\x24\x8c\xc2\x65\xdf\xe0\xc6\x7a\xd2\xee\x70\xda\xb9\xa2\x22\x73\x59\x99\x58\xa2\x37\x15\x16\xb0\xc8\x29\x37\xb5\x67\x75\xd9\x04\x38\x9b\x09\x16\xb4\xec\xc2\xb3\xe4\x26\xcf\xce\xec\x2e\x0e\x38\x45\x43\x7d\xa0\x26\x28\x06\xab\xfd\xf5\x8e\x06\x52\x96\xec\x4c\x01\xfc\x82\x23\xe0\x33\x74\x83\x0b\x5d\xe0\xc6\xcf\x60\x04\xfe\xd2\x40\x3a\x1c\x4e\x47\x0c\xab\x5e\x2f\x96\xea\x4d\x45\x05\x2c\x0e\x55\x6e\xda\xb1\x75\xaf\x5d\x90\x3f\xda\x28\xaf\x8e\xac\xee\x8a\x7c\x44\x6e\x74\x77\x6c\xdb\xcb\xc1\x50\x45\x43\x5d\xa0\x3a\x28\x56\xc7\xb0\xd6\x93\xc9\x4e\xa0\x21\x09\x34\x90\x04\x97\xe3\x02\x52\xc8\x04\x9a\x2b\xf1\x7b\x3a\x31\xdc\x0e\xfd\x0c\x78\x79\x90\x86\xc4\x8e\x49\xa8\xa9\xe3\xd5\x38\xb9\x8c\x82\xfe\xfe\x38\xc7\xa6\xf1\xd8\xaf\x54\xe3\x43\xb2\x8e\x81\xb1\x72\x2e\x51\xef\x6b\xac\x6e\xe0\x42\xad\x8a\x86\xc6\xd2\x42\x9f\x08\x63\x23\xb9\x04\x4c\x45\x0d\xb3\xb3\xbc\xb5\xbc\x5d\xc0\x45\xf2\x2f\xc4\xbb\xba\x67\x4f\x3c\xc9\x45\x5b\x15\x4f\x3e\xbb\xf8\x19\x9d\x88\x8b\x22\xbf\x10\xe5\xd9\xe5\xba\x2c\x16\xfb\xe3\xf1\x56\xcf\x53\xcd\x61\x0e\x6e\x4d\x80\x87\xa8\x43\x7c\x98\x66\x64\x5a\xf9\x31\x85\x1a\xd4\x62\x3f\xea\x22\x34\x17\xd1\x2d\xa3\x50\xbb\x9e\x87\x64\xc5\x33\xb8\xfd\x73\x9c\x7a\x16\xa7\x7e\x3d\x1e\xaa\xdc\x6f\x42\xf2\x5d\xff\x18\xfb\xe9\xbb\xa0\x9c\xf8\x49\x0f\x88\x70\xcb\x21\xf8\x31\x13\x0e\xe1\x0a\x98\x8a\xf7\x92\xed\x7c\x3c\x9e\x3f\x49\xbd\xf7\xc2\x99\xa7\x45\xa4\x23\x3f\x31\x58\x03\x4b\xd1\x0f\x04\x06\x3a\x48\x68\x55\x42\xa0\x03\xfc\xa0\x84\x1a\x58\x4a\x26\x37\xa3\xf4\x09\x3c\x0d\x34\x26\x41\x52\x4c\x6e\x1e\xbc\x80\x07\xfa\x93\x4f\x40\x0b\x3d\x40\xab\xde\x0e\x0f\x43\x0d\x03\x4b\xa8\xef\x29\x21\x3a\x1a\x7a\x18\x98\x06\xcb\xff\x05\x3b\x41\x66\x81\x81\x64\x98\x07\xb5\x50\x0b\xc9\x38\x0f\x19\x94\xff\x85\x3b\x61\x1a\x2e\x17\xe0\xf9\x21\x78\x2f\xdc\x81\x93\x41\x27\xe7\xb1\xa0\xc5\x71\xb0\x0e\x1b\xba\x05\x08\xf0\x82\x6a\x6f\x4c\x8c\x2c\xf1\x94\xfa\xf4\x22\x36\xac\xc1\x71\xb8\x0e\xb5\xac\xea\xed\x48\x1e\x4e\x46\x1d\xde\x8b\x77\x08\x03\x21\xb1\xb5\x0a\xd5\x3f\xf1\x2e\x50\xa2\x12\x98\x98\xf8\xfe\x01\xbf\x96\x52\x13\xe9\x21\x9a\x01\x01\xb8\xc6\x86\xc0\x4e\x73\x7b\xaa\xa9\x3d\xaf\x29\xdb\x8f\x73\x8e\xa7\xf4\xc2\xac\x40\xbb\x69\x67\x7e\x43\x6a\x41\x63\x56\x20\xdb\x84\xb3\x16\xa4\x2c\x81\x39\xe6\x38\x40\xea\xb6\xc0\x36\x53\x41\x3e\x72\x28\xa6\x20\x07\xe2\x00\x48\x6a\xb6\x39\x2f\xcf\x9c\xbd\x04\xe7\xa4\xe0\xac\xde\xec\x40\x96\xa9\x20\x3f\x35\xbf\xc0\x94\x15\xc8\xee\xc5\x59\x29\x38\x67\x49\x0c\xc0\x94\x9d\x6a\xce\x0e\x64\x35\x16\x80\x80\x5c\x0a\x0a\xc8\xc5\x40\xfc\xd9\xa9\x81\xec\xa6\xbc\x76\x33\xcc\x59\x92\xb2\x00\x67\x99\xe2\x20\xa9\x0d\xf9\x3b\x4d\xed\x01\x98\xd5\x9b\x72\x1c\xe7\xf8\xb3\x1b\xf3\x76\x98\x52\xdb\xcd\x3b\x03\x0d\x8d\xc0\x81\x90\x02\x1c\x0a\x44\x49\x75\x63\x79\x23\xe7\x0f\xb8\x5c\x7e\xb1\x3d\xd0\xd4\xe4\x6f\x3f\x0e\x73\x52\x60\xd6\x82\x76\x53\x0c\x30\x35\xd6\x34\x53\xfb\x02\x98\x95\x02\x73\x8e\xb7\xfb\x9b\x9a\x02\xed\xa9\xfe\x78\xd3\xc8\x64\x18\x15\x57\xbb\x43\x1a\xa0\x9b\x63\xea\xb6\x0a\x4e\x02\xad\xda\x7a\x40\x4e\xe4\x19\xd5\xfe\x8b\xf3\x29\x55\xde\x01\x1d\x2f\xf7\x33\x53\xe7\xcc\x99\x2a\xe0\x3f\x15\x03\xf3\x11\x50\xc4\xab\xb6\x1e\xb8\x3e\x1f\xf1\x97\x27\x96\x62\x92\x80\x0b\x70\x12\xd0\xf8\xd4\xc0\x34\xc4\x6f\xef\x7d\xd5\xdf\x27\xf6\x1c\x3d\x78\xb4\xab\xb7\xba\x39\xd8\x12\x6c\x21\x5b\xab\x5e\x01\xb2\x83\x53\xe5\x1d\xb8\xf4\x41\xc6\x48\x11\xe9\x91\xcf\xcf\x60\xe5\xfe\xff\xcc\x43\xfc\x39\x09\x11\xa1\x14\xb5\x3d\x81\x97\x0f\xb3\x30\x11\x99\x7f\xe1\x38\x41\xb5\xff\x22\xb2\xe9\x38\x69\xf4\x5c\x71\xcb\xd2\x8d\xab\xd6\xaf\x22\x37\x65\x4e\x7b\x78\x49\x4c\x69\xde\xc0\x8b\xaa\xad\x07\x6e\xcc\x3e\x9c\xff\x61\xdd\xf6\x73\xe2\xda\x5f\x7f\xdb\x0c\x49\x1c\x2c\xe2\x9b\x0f\x54\x1f\xf2\xbc\x44\xc2\x44\x05\xa4\x01\x09\x37\x43\x9a\x18\x6f\xf2\x49\x50\x8d\x06\x7a\x1a\x30\xab\x07\xda\x1e\xf7\x82\xca\x7c\x54\x4d\xa4\x03\xcd\xa8\xf6\x2d\xc4\xa7\xf0\x09\xa4\x71\x09\x87\x89\x53\x4e\x00\x25\xaa\x32\x8f\x34\xba\x1a\x3d\x0d\xc2\xca\x56\xdd\x99\xa3\x6c\x9b\xbf\x2d\xd8\x2c\xa8\xb6\x3e\xba\xb1\x33\xff\xd0\x31\xb6\xb3\xe6\x58\x73\x5b\x8c\x39\x53\xe7\xbc\x7e\xf1\xc2\xb9\x37\xde\x11\xe5\x7e\x85\x2a\xf7\xd1\xf3\x23\xdf\x02\x9a\xbd\xf2\x41\xe7\xa5\x9d\x27\x91\xd0\x05\x85\xa0\x2e\xa8\xab\xd9\xde\xb5\xe0\xe0\xb2\x9e\x65\xe4\x94\xbe\xf7\xc6\xfe\xc6\x75\x46\x69\x05\x48\x7d\xdf\xc7\x78\x0c\x87\x29\xd5\xd6\x47\xb1\x47\xb1\x64\xda\xe7\x5d\x99\xe2\xfa\x9e\x8d\x3d\x5b\x8e\x91\xdf\xcc\x4d\x87\x49\xc8\x72\x38\x0e\x19\x0d\x4e\x5c\x11\x48\xaf\x5d\x25\x46\x28\x05\x0a\x48\xe1\xcd\x28\x60\x1a\x90\x18\x6b\x19\x4c\x54\x78\x56\x56\xaf\x6e\x5e\x47\xaa\x32\x8f\xd8\x4b\x1c\xc5\x25\xec\xf4\xe6\xe9\x87\x16\x09\xaa\x7d\x0b\x1d\x16\x02\xe7\x39\x80\x1d\x0a\x33\x38\xb8\xe9\x6a\xe7\x81\x9f\x45\x55\xe6\xa3\x2d\xe7\x7e\x38\x70\x9e\x8b\xe9\x7f\x24\x25\x26\xdb\xa8\xff\xf5\x2a\x4c\xa1\x54\x5f\xa7\xdb\xf9\xe9\xdf\xf3\x21\x1f\xa3\xfa\x7a\x0e\x2e\x40\x1a\x27\xe1\x53\x6c\x46\x94\xee\x54\xfe\x36\xf6\xbd\x29\x7d\xc2\xb2\x9e\x65\x07\x17\x74\xe5\x56\x6f\x0f\x6e\x0f\x92\xba\x2a\x24\x5f\xe9\x60\x2f\x75\x7e\x70\x45\x50\x5d\xbe\x04\xf4\x5b\x23\xcf\x73\x72\xbf\xf2\x9d\x37\xce\x5d\x10\x54\x3f\xa6\x5f\x7c\x7d\xce\x54\x11\xff\xa9\x54\x41\x7a\x73\xdb\xb1\x9a\x4e\xee\xd8\xa1\xfc\x8d\x9d\x62\xb0\xb9\xcd\xdf\xc6\xa9\xbe\x9e\x73\xf4\x8c\x6e\x65\xab\xe8\x69\x68\x74\x37\x72\x70\xeb\xd1\x49\x48\x88\x40\xfb\x18\x98\x89\x89\xc0\xe0\x5c\xbb\xd0\xbd\x68\x7a\xf3\x74\xae\xa4\xd8\x61\x2f\x11\x55\x30\x67\x5d\xf3\xea\xea\x95\x1e\x12\x26\x2a\x21\x0d\x6f\x06\x12\xd3\x50\xc0\x9b\x91\x8a\xbf\x45\xca\xda\x55\xe9\x81\x15\x1c\x4e\xd4\xc4\xdd\x6f\x58\x98\x94\xfe\xcd\x5c\xf1\xd8\x96\x9e\x8d\x3d\xeb\x49\xd5\x8f\xe9\x5d\x99\x9f\x4f\x5b\xc2\x62\x8f\x32\x46\xe9\x31\x4a\x08\xd1\x71\x46\x40\x8f\xf2\xfc\x81\x1f\x5a\xce\x09\x07\x7f\xdd\xf3\x1b\x24\xb1\x31\xc6\xfc\x1f\x2f\xcc\x14\x4a\xe5\x1d\xe8\x1b\x98\xb8\x78\x0a\x52\x82\x2a\xb8\x2b\x3f\xdf\xe5\x29\x10\x57\xea\x5e\xd0\x2d\xe3\x72\x72\xfc\xc1\x5c\x71\x63\xc6\xea\xfc\xa5\xdc\xa6\x15\xb5\x4d\xdb\xe2\xed\xde\x7f\x20\xd6\x93\xa6\xcd\x3e\xf7\x8e\x20\xf7\x2b\x67\x3c\x3f\x12\x69\x6e\x64\xc6\x07\x97\x76\x02\x71\xb2\x35\x28\xb6\x06\x5b\x83\x2d\x35\xbd\x5d\x47\x0f\x1e\xed\x21\xfb\xfb\xbe\x7a\xef\x37\xb6\x53\xa9\xba\x70\x20\x44\x67\x28\x54\xde\x2c\x7c\x0a\x68\x7c\x02\x97\xb0\x48\x87\x24\x06\x8c\xfc\xd7\xbc\x2a\xb8\x0b\x9e\xe5\x45\x95\xf7\x00\x48\x51\x1f\x03\x37\x65\x5c\x5d\xf7\xb3\xb0\xfd\xdc\xba\x1f\xce\xb3\xd0\x13\xdf\x86\x25\xb8\x2b\x4a\xc7\x3a\x0a\xf6\x28\x97\x3c\x3c\x6d\x53\xa6\xb0\x6a\xfd\xaa\x8d\x4b\xb7\x90\xa3\xe7\xe2\xa4\x74\x64\x59\x1c\xf7\x05\x32\xf0\xf8\x4b\xc7\xfc\x75\xdd\x31\xb6\xa1\x00\x37\x23\x05\x02\xa4\xc1\xcd\x40\x42\x9a\xa0\xf2\x66\xc1\x44\x65\xb7\xf7\x68\xcd\xde\x46\x52\x75\xe1\x80\xbd\xa6\xd6\x51\xc3\xf5\xf5\x35\x1f\x3a\x29\xfa\x1c\x84\x6a\xff\x01\x98\xe7\xf8\x15\x58\x98\xc1\x26\x23\x7d\x95\x1f\xec\x04\x6f\xb8\x06\x24\xd5\xb3\x76\x1e\xca\xa8\x88\x43\x01\x73\x71\x2e\xa1\x3a\x12\xd4\xfb\x8b\x0a\x59\xd5\xb3\xf0\x32\x35\x66\x0c\xf4\x51\x78\x0d\xae\x8d\xb9\x0c\x37\xf1\x97\x2f\xc3\x35\xb8\x06\xa3\xa8\xeb\xf6\x83\xd7\x8d\x0a\x63\xa5\x64\x87\x42\x75\x04\x02\x54\x5f\xdc\x9e\xf0\x2a\x2f\xdf\x4e\x85\x6b\xc0\xab\x5a\xa8\x26\x88\x10\x0d\xc0\x8f\x19\x83\xd7\xf0\x1a\xa1\x3a\x32\x10\xf5\x59\xb5\x70\x20\xee\xf3\x98\xcb\x7f\x5a\x34\xc6\xcd\x1c\xe7\xc2\x5c\x22\x46\xc9\x5b\xbc\xec\x50\xe0\x5c\x98\x3b\x50\xed\xac\x78\x78\x8e\xcb\x63\x88\x01\xda\xc0\x3b\x44\x75\x24\x8d\xea\xe6\x63\x75\xc4\x4d\x17\x7d\x6a\x22\x29\xc4\xc4\xeb\x21\xf4\xfa\x22\xd8\xc5\xe3\x00\x2a\x65\x16\x2f\x3b\x94\x31\x1a\xa1\x8d\x82\x9b\xf8\x58\x0b\x2e\x5f\x86\x51\x54\x0c\xe1\x0d\x74\x3e\xc7\x19\x5e\xf5\x0d\xdc\xca\x23\x3d\xc0\x93\x38\xce\x39\x31\x9c\x2a\x00\x3e\x46\xf9\x98\x31\xd0\x16\xe7\xc4\x00\x41\x33\x29\x18\x68\xf6\x36\x3e\xe2\x50\xc6\xc8\x1e\x60\xcb\x00\x3a\xd7\x7f\xd0\x09\x60\x7b\x0d\xee\x01\x95\x5d\x02\xbe\x16\x06\xd7\x36\x34\xd6\xd7\x1e\x85\xb9\xa8\x81\x84\xd1\x35\xce\x1d\xbf\xd7\xbb\x5a\xf6\xc2\xf0\xc1\x4e\x38\x0e\xcf\x74\x7d\xfc\x99\xb1\xe5\x58\xc7\x0e\xe9\x78\x53\xc5\xab\xb9\x4d\x40\x4a\xaa\xcf\x46\xec\x2d\xfb\x7f\xda\x22\xa9\xfe\x39\x62\x6f\x19\xec\x8c\x34\x30\x55\x81\x06\xa9\xc6\x5a\x65\x93\xac\xa5\x46\x52\xf5\xfd\x88\xbd\x65\x66\xab\xd1\x6b\xb2\x4b\xf6\x6a\xab\xd5\xb8\xa3\x78\x63\x41\xa1\x9b\xac\x70\x64\x17\xbb\x58\xa3\x45\xef\x34\x19\xcb\xcb\xaa\xf2\x8b\xbd\xe6\x52\x5d\xc0\x50\x52\xa5\xdf\x5e\x58\x56\x6b\xb0\xfa\xca\x0c\x66\xaf\xd9\x65\x36\x59\xdd\xae\xa0\xc1\xe3\x20\x2d\x76\xab\xd5\xc2\xf9\x4a\xcb\x4a\x8c\xe5\x86\x72\x5d\xb9\xcd\x5e\x50\xa8\xcf\xee\x34\x91\x2e\xe7\x26\x87\x4b\x74\xeb\x7d\x1b\x72\xab\x0d\x3e\x73\x87\xad\xca\x16\x74\x38\xcb\x83\xa5\xc5\xf6\xaa\xb2\x00\x19\xa7\xbc\xcc\x5f\x64\x37\xfb\x8b\xcb\xca\x3c\xb6\x7a\x6b\x79\x85\xde\x61\xb3\x18\x8c\xee\x72\x7f\x69\xe5\xd6\xc2\xe2\x00\xe9\xf2\x5a\xed\x1e\xd1\xa6\x37\x05\xcc\xd6\x01\x8a\x4d\x16\xb3\xc1\x6c\xa9\xce\x2e\xc9\x71\x65\x91\x79\xd5\x1b\x1a\xcb\x04\xc9\xb2\xdb\x2e\x79\x6b\xfc\xf6\x2a\x5f\xd0\x57\xed\xf7\xd7\xba\x5e\x76\x6f\xda\x60\x29\xb0\x95\x3a\x8a\xed\x7a\xd2\xee\xf3\xb9\x7c\x9c\xd7\xe3\xf3\xb0\x7e\x43\x93\xcd\x1f\x0c\xe8\x6b\x8c\xee\x12\xb2\xc4\x5d\x5d\x9c\xcf\x95\xd4\x6d\xb5\xb8\xc5\xaa\xbc\x86\xf2\xa6\x4a\xb2\xdc\xb6\xbd\xcc\x2e\x18\xec\xf9\xcd\xde\x2a\x87\xd5\x66\xb3\xd9\x0d\xc1\x42\xbf\x31\x68\xf7\x64\xf5\xf8\xdd\x25\xe6\xad\x95\xa5\x81\xdc\x2a\xdb\xae\x6d\xd6\x02\x9b\xc5\x94\x5b\x41\x96\xf8\xf4\x95\x25\x81\x22\x69\xab\x64\x6e\x32\xd7\xb9\x1b\x8d\xb5\x64\xa5\xb9\xa0\xa9\x94\x0b\xea\x76\x7b\x6c\x62\x59\xf5\xea\x7d\x15\x4d\x6e\xcf\xf6\x0a\xab\xcb\x6b\x70\x95\xf9\x8c\x3e\x83\xdf\xe8\x37\x54\x15\xd4\x6e\xb7\x6f\x2f\xb5\x7a\x1b\xad\x15\xa6\xea\x7c\xa7\xa5\x86\x74\xbb\x5c\x4e\xb7\xcb\x55\x9f\x5d\xe3\x0d\x96\x54\x39\x9b\x0d\x35\xc6\xea\x62\x7f\xa9\x64\xf1\xac\x3f\x5a\xed\xc9\xb3\x18\x8e\x79\x82\xa4\xd3\xee\x74\xb1\xde\xa0\xe9\xcd\x3a\x57\x99\xc3\xb6\xd3\xe3\x73\x7b\x6b\x8b\x5d\x76\xbf\xc7\x5f\x61\x0f\xd8\x2a\xca\x02\x26\xbf\xcd\xbd\x7a\x87\xc3\xe1\x0d\x38\x02\x66\x1f\x99\x5f\x5c\xb9\xcb\xe0\xb1\xba\xac\x1e\xab\xf7\xec\xd7\x9f\xfe\xfd\x4a\x2f\xe9\xf2\x57\x38\x2b\xb8\x06\x7b\x65\x71\xb5\xd1\xed\xb3\x56\xd8\x7c\x9e\x8a\xa0\x3b\xe0\x96\x5c\xd5\xee\x0a\xab\x59\x32\x55\x98\x2a\x1c\x0e\x9b\xdd\x61\x2f\x93\x72\xf5\x06\x2b\x59\x6e\x35\x59\xca\x6d\x16\xbb\xcd\x69\x75\xc5\x9e\xd9\x67\x65\xbb\xeb\xf6\xd4\x74\x55\xf9\xad\x7e\x93\x64\x32\xfb\x9c\x3a\xb7\x95\xac\x2a\x6e\xab\xac\x75\x1c\x31\x1b\xff\x32\x2c\x60\x70\x16\x4b\x46\x49\x2a\xad\xf4\x4b\x6e\x6f\x83\xcf\xef\x09\xf8\xf4\x01\x9b\xdb\xe0\x5f\xe3\x69\x6c\x0d\x54\xb4\x5b\x2b\x2c\xa4\xea\xb3\x91\xaf\x94\x55\x99\x83\x65\xc5\x86\x80\xa3\xcb\x68\x29\x25\xfd\x1e\x9f\x54\xc1\x49\x0e\x77\xae\xd7\x52\x93\xdd\x76\xd2\x6b\x2f\x08\xec\x95\x24\x5b\xc0\x56\x95\x53\x1a\xab\xd8\xba\xaf\xac\xca\xe0\xda\x9e\xe7\x2a\x71\x15\x35\x96\x16\x93\xaa\xcf\xa6\xed\x2d\x33\x1a\xac\xc5\x46\x63\x49\x49\xbe\xab\xd0\x1d\x70\x6c\xd7\xd9\xad\x66\x93\xb5\xdc\x5e\x6e\x37\xb8\xcb\x2c\x86\x7a\x9f\xb4\xd9\xe4\x68\xf6\xd4\x3b\x9b\x4c\x03\x18\x6a\x2c\xcd\x66\x7f\xb1\xd7\xdf\x68\xf3\xdb\x83\x66\x57\xa9\xa7\xcc\x5b\x5c\x9d\x5d\x5f\xe1\x71\xb7\x54\x96\xfb\x49\xd5\x67\x77\xee\x2b\x2b\x0f\x18\x1b\x2a\x2a\x2b\xaa\x1a\x3d\xbe\x1a\xb2\xa2\x35\xc3\x56\xcf\x56\x56\x7b\x1c\x41\xa1\xb2\xb8\x29\x18\x10\x2a\xfd\xc7\x0d\x92\x59\x32\x77\x94\xbb\x8d\x03\xea\x4c\xbc\x83\x55\x98\x02\xc5\x25\x56\xc9\xbd\xc3\x50\x60\xf6\x7b\x7c\x76\xbf\x37\xe0\xf5\x06\x24\x8b\xdb\x51\xd5\xe2\x77\x48\x0e\x77\xa9\xd7\xec\x35\x56\xd9\xbc\x46\x32\x50\x68\x2b\x6a\x35\x07\xec\x8d\x55\x8e\x62\xd2\xeb\x75\x7b\x5c\xac\xab\xc4\x5f\x54\xef\x26\x9d\xce\x7c\xbb\x4d\x30\x1b\x8b\xdd\x46\x8b\xcd\x91\x93\xeb\xb1\x95\xd6\xe6\x3a\x0b\xad\x05\xb6\x42\x7b\xa1\xa9\xdc\x5a\x6e\x35\x9b\x6c\x56\x4b\x81\xc5\x51\xe9\xf6\x55\x55\xf8\x07\xfa\x10\x3e\x72\x2d\x81\x71\xf8\x1c\x95\x2e\xd6\x51\x57\x5f\xe5\xa8\x2d\xf3\xd8\xaa\xdc\x41\x77\x7d\x6d\x30\x58\x15\xac\xf2\xb4\xda\x6a\x2c\x6d\xce\x76\x6b\x9b\xcb\x5c\xef\xf6\x94\x7b\x03\x6e\xc9\x17\x20\xbd\xfe\x80\xdb\xef\xab\xf4\x37\xb7\x06\x4b\x2a\xf5\xd9\xa5\xd5\x65\xde\x0a\x6b\xb0\xa2\xa2\xae\xa1\x2a\xaf\xce\x52\x6f\xf1\x9b\xab\xcb\xac\xde\xa6\x80\xdb\x45\x36\x7a\x2b\xca\xaa\x0d\x35\x86\x16\x93\x3d\xaf\xd2\xee\xb7\x55\xd8\x2a\xac\x55\x6e\xbf\xf9\xc1\xfb\x31\x79\x1a\xf2\x39\x64\x72\x1a\xea\xd5\x8a\x8c\x84\x66\xb5\x62\x63\xa2\x4c\xf7\x65\x52\xa1\x14\xf9\x51\x06\xef\x7c\xf5\xee\xab\x2f\xc2\x9d\xd1\x89\xd1\x89\x29\x37\x2c\x3d\x7f\xc3\x41\xf0\x36\x15\x7a\x22\xf4\x04\x11\x4a\x96\xa7\x31\x4d\xfa\xda\xbc\x3c\x2c\xc6\xe1\xf9\x9b\x04\x9c\xff\x3b\x01\x3a\x25\x1c\x85\x89\x84\xe4\x0f\x54\x55\xb1\x41\xb3\x64\x08\x08\x3d\xb3\x46\xb5\x4c\xe1\x96\x50\x87\x79\x98\x0b\x93\xe0\x36\x98\x7a\x5e\xac\xea\x0c\xf6\x74\xb1\xc9\xff\x25\xf8\xc3\x8d\x7f\x84\x8a\xbb\x70\x85\xa5\x98\x92\x4a\x87\x68\xa4\x95\xd7\x24\x59\x02\x23\x15\xa1\x65\xe9\xc6\x92\x33\xd0\xd1\x7e\xe6\x28\x1f\x92\x92\xae\x1f\x92\xf1\x0f\xa4\x75\x3c\x74\xf3\x6a\xa2\x48\x9d\xf4\xd1\xf5\x60\x26\x6a\x1c\xa4\x80\x4b\xbc\x6c\x88\x18\x52\x22\x85\x4a\xd0\xf0\x02\xb4\xf0\xd7\x5d\xc7\x42\x85\x4a\xd9\x20\x1b\x6e\x04\x35\x69\x6e\xce\x1d\x88\x93\x96\x00\xc7\xa9\x8f\x78\x5a\x1d\xa2\xe1\x3c\x0f\xb4\x2c\x21\xad\x0c\xd1\x51\x9a\x89\x6a\x50\x33\x85\x12\xb0\xff\x2b\x0a\x34\x51\x4d\x44\x77\x8a\x8a\x4a\xb2\x8e\x41\xa9\x9b\x57\x84\x24\xf9\x2a\xb3\x90\xc2\xab\x90\xc0\xe3\x55\xe5\x3c\x2a\x42\x17\xf1\xca\xe4\x98\x7e\x93\x18\xce\x63\x60\x18\x0e\x23\xf4\xc1\x3a\xd3\xdb\x94\xac\xcd\xa7\x22\x5a\xc5\x36\x5d\x51\x8e\x41\x34\xe8\x7c\x5b\x1b\x0b\x62\xb9\x29\x08\xb1\x3f\x00\x0c\x83\x61\x71\xa2\x5a\x53\xdb\xe2\xad\x18\x88\xd0\x01\x59\x54\x3c\x12\x3a\x5c\x87\x3b\x4a\xfd\x5f\xdb\xac\x00\xcf\xc3\x51\x2a\x05\xe2\x3f\x04\x1c\x86\xc3\xe2\x31\x42\xc6\x50\xb2\x56\x09\x3c\x85\x03\x35\x01\x10\xd7\x23\xcf\xc1\x7d\x20\x52\x71\x47\x69\xf9\xab\x10\xcd\xbc\xf8\x41\xe6\x57\x97\xd9\x16\x77\x8b\xa7\x45\x28\x4e\x5f\x51\xbe\x0c\xb9\xa1\x97\x72\x39\x54\x79\xb0\x7d\x02\x26\x7e\xbb\xe4\x47\x11\x58\xc5\x3b\x9f\x7c\x7b\xe4\x57\x0f\x19\x3e\x1d\xbd\x83\x81\xdc\x05\xf0\x23\x1e\x15\x36\xe2\xed\x28\xe2\x52\x5c\x8a\xb7\x83\xb8\xf1\xcf\x0d\x08\xc6\xff\x7e\xff\xc0\x06\x04\xa0\xf9\xfd\x3b\x18\x2f\x5e\x93\xd4\x49\xd1\xb5\x7c\x48\x1b\xa1\x07\x02\x9a\xc9\xfd\xb8\x9d\xf9\xd4\x03\xed\xa8\x12\x72\x87\x8e\x47\x8e\x5b\xb6\xa2\xa2\x36\x5d\xf4\x6c\x77\x6f\xdf\xce\x8e\xc9\x1c\xfb\xe2\x64\xe1\x57\xdb\xb7\xcb\xdf\x79\x8c\x04\x56\xf1\xe3\xb7\xc7\x21\x51\x44\x5a\xfe\x6d\x2d\x9f\x9c\x86\x49\x30\x1f\xe7\xab\x15\xe9\xd7\x34\x30\x1f\x1f\x1e\x98\x54\x19\x5c\x07\x5a\xd4\x0e\x24\xce\xc3\x87\x60\x9e\x6a\xca\x20\x95\x71\x90\x9a\x38\x00\xfd\x8c\x7c\x1b\x4f\x14\x16\x64\x1b\xb3\xb9\xec\x6c\xa9\xa1\x40\xc4\x55\xb0\x9a\x28\x68\x30\xb4\xb7\xb3\xbb\x83\xad\xcd\x4d\xc2\xa6\xae\x8e\x35\xaf\x70\x33\x29\xd5\x1d\x83\x5e\x59\xd3\xb1\xa9\x4b\x68\x6e\x6a\xad\xda\xc5\xb5\xb7\x1b\x0a\x1a\x44\x58\x83\x6b\x88\x86\x82\xca\x9c\x6d\x6c\x74\x5e\x68\x3e\xb3\x45\xaf\xcb\xcd\x13\xba\x36\x6d\xed\x5e\xc8\xc5\x54\xe0\x85\xdd\x5b\xbb\x36\x89\xb9\x79\x3a\x43\xe6\x75\xfc\xaa\x29\x83\x70\x0d\xac\x81\x0c\xbe\xbd\xb2\xfd\x06\x96\x55\xb8\x3a\x86\x25\x3b\x9b\x0d\xab\xa2\xf3\x99\xbf\x67\xfe\x4d\xfb\x9a\x10\x03\x23\x4e\xcd\x7f\x72\xf7\x24\xee\xf1\x27\x33\xe6\x69\xc5\x71\x5f\x10\xa7\x5f\xeb\xfc\xe0\x63\xf6\xc3\xcc\xfe\xf9\xa7\x84\x38\xa5\xaa\x51\x65\xaf\xcd\x9f\xb2\xfb\x09\x4e\xa5\x2e\x9b\x34\x25\x73\xfe\x7c\x11\x47\xe0\x70\x62\xfe\x82\xcd\x4f\x4e\x62\x9f\xd8\xf5\xd4\x6b\x5a\x21\x4e\xe3\xfc\x53\xef\x6f\xf9\x90\xfb\xf8\xfd\xce\xd3\xaf\x89\x5f\x8c\x23\xe6\x69\x33\x26\x3f\xce\xaa\x5a\x06\x4d\xda\x35\xe5\xd4\x7c\x21\x4e\x80\xf6\x54\xff\x96\xbf\x73\xaa\x51\x65\x1f\xf6\xef\x3a\x75\x4a\x8c\x6f\x3f\x70\xaa\x77\xcf\xfb\x1f\xb2\x37\x6c\x7f\xca\x12\xd5\xca\x32\x99\x66\xe0\x79\x54\xc1\x28\x7c\xe2\x90\xb0\xe3\x50\xed\xb1\x57\xa0\x83\x9a\x3e\x57\xb7\x66\x85\x00\xb3\x9f\xc0\xe9\x70\x27\x6e\xe2\x80\xa0\x4a\x5c\xc5\xae\x12\x11\x47\x3d\x7d\x17\x3e\x88\xd3\x7a\xf9\x70\xbf\xe2\x5f\x54\x9a\x9d\x07\x3a\xe1\x0a\x95\xa8\x26\xe0\x0b\x26\xe2\x0c\xed\x25\xe4\xa1\x7d\xca\x2f\xf8\x88\xa4\x30\x50\x7d\x91\xa1\x8a\x88\x33\xba\x97\xc0\x5b\x26\xf7\xde\x0f\x77\x71\x16\x4a\x01\x77\xf5\x7e\x07\xb7\x4c\x16\xa3\x4d\xa1\x8d\x4c\xd3\x1e\xe2\x80\x52\x1e\x0a\x74\x64\xa8\x72\x9d\xb2\x69\x33\xb4\x47\x9e\x24\xa2\x4b\x15\xf1\xe8\x61\x9a\xb2\x5c\xb8\x0a\x9a\x78\x38\xff\xf8\xce\x08\x83\x5d\x30\x4e\xd6\xc2\x38\x57\x5f\x5f\x4c\x7f\x9e\x1c\xd6\x86\x68\x66\x26\x0f\xbd\xd3\x19\xd9\x2b\xdf\xdd\x50\x2d\xb5\xd8\x9b\x53\x6d\x2d\xa5\x8d\xf9\x95\x48\xf7\xa5\xf8\x8c\x06\xb7\x81\x2b\x2b\xb3\x59\x8c\x62\x74\x6a\xe4\x4e\xbc\xe9\x6d\xab\xdb\xea\xb6\xba\x52\xa5\x3d\xde\x2e\x5b\x97\xf1\x97\xa9\x3f\xe0\x4d\x17\xc9\x53\xe3\xef\xdb\xfd\x00\x37\x76\x52\xd6\x8b\xf3\xc4\x17\x5e\xcc\x9c\x14\x98\x28\xdd\x73\xf1\x5e\x48\x78\x86\x9c\x7f\xe9\x87\x2d\xdf\x72\xa7\x5f\xa9\x6a\x3a\x2c\xfa\x8d\x01\x93\x64\x86\xe4\x29\x29\xaa\xf2\x41\x98\x3c\xc5\x68\x36\x99\xcc\xc6\xd4\xa6\x15\x0b\xab\xe6\x71\x0f\xdc\xbb\x65\xfe\x78\x11\x13\x9e\x99\x7a\xaf\xf1\x1e\xd3\xc4\x5d\x93\xce\x2c\x20\x17\x9e\xfe\x30\xeb\x2b\x4e\x35\x7b\xd0\xb7\xdf\xef\x3e\x75\x49\x84\x9b\xde\xbd\xf8\xbd\xf4\x8b\xa7\xcb\xda\x65\xdc\xe3\x75\x79\xdd\x5e\x37\xdc\xf4\x76\x4a\x68\x6a\xe4\x4e\xc2\x22\x55\xd9\xaa\xb8\xca\x4a\xb7\x4f\x12\x81\xee\x6b\xac\xac\x6e\xf4\xb4\xa4\xba\x9b\x8d\x2d\x05\xd5\xa4\x1a\x97\x86\x86\x33\x39\xdb\x56\xe9\x97\x71\xaa\xb6\x41\xb3\x9e\x69\xea\x9e\x25\xe2\xa0\x0b\x6b\x7f\x3a\x77\x9a\x6c\xdb\xd1\x13\x3c\xca\xbd\xf1\x5e\xde\x9a\x73\x22\x0c\x9a\x76\x70\xf8\xac\x79\xe4\xf8\x68\x09\xb3\x66\xd6\xd3\x79\xb3\x39\xd5\xed\xbd\xcb\x56\x05\xdb\xb6\x89\xb3\x4e\x1f\xfc\x09\x06\x5d\x20\xbb\xcf\xbd\xdb\x74\x8e\x3b\xda\xa3\xcf\xd9\x21\x9e\x9b\xb7\x76\x38\x0e\x9a\x46\xc2\x54\x39\xc4\x48\x92\xdb\xed\x76\x79\x3c\xa9\x15\x01\x7f\x45\x45\xc5\x8e\x1d\x29\x1f\x2f\x2d\x29\x27\xf2\xf4\xa5\xb9\x3a\xb6\x4c\x09\x34\x4e\x60\x50\x33\x72\xdb\x8e\xf2\x0a\x73\x45\x79\x45\xaa\xcd\x6d\x77\xd9\x3d\xc6\x8a\x14\xd0\x5c\x21\x80\x50\x86\x24\xf9\x29\xa0\xa7\x47\x75\x91\x7e\x42\xbe\x1a\xa1\x99\xc8\xc7\xf0\x89\xcf\xed\x73\x79\xbc\xa9\xf0\x0c\x08\x72\x7d\x64\x14\x91\x0c\xde\x3f\xf7\x66\x91\x69\x58\xc9\x2f\xe0\x55\x3f\x1c\x50\x2b\x9a\xe1\x1c\x1f\xd1\x28\xd6\x2c\x2a\xd4\xad\x11\xe1\x53\xa5\x0a\xe6\x2c\x8d\x25\x2c\x78\x72\xf3\xba\x75\x62\x64\x54\x64\x14\xb1\x6e\xdd\xe6\x27\x17\xb0\x51\xcd\xe3\x94\xea\x87\x03\x72\x0f\xf6\xc0\x04\x5e\x9d\xd4\xab\x5c\xca\x47\x7a\x70\x23\xa3\xfa\xe1\x22\xbe\x8a\xaf\x2a\xf1\xdb\xd0\x24\x26\x7e\x25\x97\xe3\x4f\xcc\x40\x29\x94\x22\x52\x88\x8e\x47\x0c\x95\x35\x32\x1d\xd1\x28\x55\x3f\x1c\x08\xd1\xd7\xae\x32\xd7\xe8\x58\xba\x42\x05\x63\x06\xb2\x94\xb1\xcf\xcc\xed\xa0\x0a\x0f\x01\x06\x3c\x70\x7b\x82\x17\x68\x70\x00\x1d\x0a\x82\x2a\x51\x4d\x14\xc3\x48\xe6\x8b\x75\x97\x66\xbc\x29\x44\x3e\x92\x3f\x22\x0e\xad\x99\xdf\x3a\x8f\xc3\x9b\x1e\x7e\x18\x6f\xd2\xb6\x6a\x0f\xad\x11\xe5\xd1\x91\xd1\x84\xd9\x5f\x61\xad\xe0\x9a\xcf\x9c\x69\xae\x80\x28\x15\x19\x2d\x8f\x26\x8a\xeb\x0c\xcd\x2d\x6c\xf7\xae\x8e\x83\x2d\x2d\xc6\xe2\x3a\x41\xfe\x28\xf2\x11\x71\x70\x6d\xfb\x8b\x5a\x76\xfc\x8c\x19\xe3\xe7\x2f\x68\x3f\xb8\x56\x88\xd6\x87\x1a\x88\x25\xc7\xb7\xbe\x75\x81\x85\xbb\xe0\x26\x50\xc2\xdd\x17\xde\xda\xb2\xf4\xb8\x20\xff\x12\xf9\x35\x8e\x55\xe2\x9a\x4f\x9f\x1e\xc0\xfa\xb3\xfc\x0b\xf1\xb7\x29\xf7\xf5\xdc\xc3\xe1\x06\x7c\x0c\x27\xe2\x86\xe1\x2f\xdd\xf7\xde\x53\x62\xa8\x21\x5a\x4f\xcc\x7c\xf3\xd2\xda\x2f\x38\x18\x03\xb7\xc0\x2d\x30\x26\xbe\x90\x17\xf7\x94\x04\x29\x76\x7e\x95\x92\x25\xf8\x8d\x97\xe9\x21\x32\x1d\x92\x22\xb1\x8f\xed\x10\x59\xa3\x5c\xca\x47\xfb\xfb\xa8\x88\x06\xe9\x58\x9f\x8e\x68\x1e\xa7\xe4\xb8\x9b\x80\xb2\xa9\xbb\xa8\xa4\x46\x84\xbd\xb8\x97\xa8\x2e\xad\x5f\x95\xcf\x5e\xa3\x95\x11\x29\xac\xa9\xe3\x51\x3b\x30\xd9\x0a\xda\x81\xb9\xd6\x10\x9d\xc1\x5c\x0f\xe4\xd1\x05\x5d\xd7\x03\x79\x5c\xd3\x0c\xc4\x75\x54\x87\x7b\xb5\x7c\xdc\x10\x35\x7c\x35\x8d\x77\xfe\x9b\x82\xe1\x14\x7d\x69\x0e\x05\x5a\xc6\xc9\x87\xe8\xa4\xeb\x87\xe4\x66\xe7\xbf\xa9\xbe\x3c\x1b\xbf\x80\xcf\xe4\x65\x29\xe9\xfa\xce\x8c\x3a\x3e\xa2\x61\x9e\xa2\xe0\x4d\xea\x11\x4a\x9d\x14\xdf\xef\x51\x1d\x2e\x0b\x5f\xcd\xe4\xff\x8f\x9c\x90\xf6\xfd\xff\x76\x9f\xdc\x8c\x12\x24\xc0\x08\x90\xee\xfb\x1e\xe8\x1f\x76\x81\xd4\x08\x09\x40\xff\x30\xb8\xf3\xb7\x46\xb8\x65\x03\x0c\xc1\x9b\x41\x35\xec\xaa\xea\xf9\x32\xf9\x8e\x47\x98\x8b\x2b\x5e\x7d\xb6\x4e\xf8\x37\x28\x89\x2f\xf0\x73\x1c\xf5\x9b\x52\x75\x2a\xad\x57\xa9\x6a\x49\xeb\xec\x72\x77\x72\x0e\x65\xfa\x9a\x4d\x0b\xd7\x2f\xdb\x31\x2f\xa5\xc7\xd3\x67\x9b\xc7\xae\x5e\x57\xb8\x61\xed\xaa\xa6\xf6\x2c\xe1\x85\x71\x84\xea\x54\xda\xf2\x23\x7d\xb9\xe7\xb9\x5f\x3f\x7f\x13\x6e\x12\xdd\x21\x25\x73\xb7\x42\x75\x53\xda\x6c\x54\x29\x3d\x1f\xc1\x96\x2e\xb8\x97\xfd\xe1\xb1\xd7\x46\x4f\x9a\xb6\x66\xea\x26\xe1\xd2\x1c\xa2\xa3\x7e\xd7\xee\x7d\x5c\x57\x73\xc1\x46\xf1\x11\xcc\xdd\x8a\x33\xd9\x02\x4f\x81\xa7\x40\x80\x6b\x0a\x35\x61\x40\x0d\xdc\x42\xc5\xda\xf9\x21\xa3\xba\xa9\x0c\x07\x29\x54\xb7\xdf\x2e\xdf\x7b\x97\x12\xd5\xa8\x7a\x6f\x52\x63\x7d\x53\x6d\x55\x4b\xaa\x5b\xaf\x98\xe0\x98\x30\x81\x4d\x53\xa8\xe8\xc9\xf7\xc2\x17\x4a\x1d\x8f\x3d\x70\x0b\x15\xe3\x82\xea\xf6\xdb\xd5\x38\x19\x0e\x51\xa8\x55\xc6\x23\x77\xc5\x38\xa2\x22\xcb\x9e\x88\xfb\xef\xfc\x26\xef\x01\x3a\x34\x0c\x92\x6c\xbc\x5a\x71\x29\x44\x33\xea\xd0\xe4\xb1\x94\x5a\xd1\xbb\x91\x57\x63\x62\x1f\x13\x2a\x52\x64\x35\x64\xd4\xaf\xaf\x9f\xb6\xfb\x85\x96\x25\x35\x78\x77\xcf\xe8\x97\x57\x1c\x21\x57\x1c\xd9\x7e\xf4\x04\x7b\xb6\xe5\xc4\x91\x6e\xa1\xfb\xc8\xb9\xa6\x0f\xb9\x4f\xde\xdb\x32\xeb\x75\x71\xef\xfa\x7d\xd3\xf6\x0e\xaf\xb1\xa7\xfc\xd3\x1c\xf4\x10\x9e\x3a\x77\x6d\x0d\xfb\xb2\xe5\x9c\xf1\x63\xc1\xf4\xaa\xe9\x90\x69\xc7\x93\x6d\x73\xea\x56\x54\x90\xc1\x27\xb5\x81\xb5\x1c\x3e\x89\x77\xae\x1c\xff\x90\xf8\xd0\xf8\xe5\xf7\x60\x32\x3b\xbb\x6e\x46\xe7\xf3\x42\x6d\x66\x7d\x56\x63\x0e\x29\x7b\x51\x62\x2e\x6e\x3d\x9a\xd3\x92\x4f\x9e\x5a\xbc\xf3\xc5\x79\xec\xb2\xa2\xf4\xcd\xab\x85\x2d\xab\x57\x65\x2e\x2c\x24\x0b\x16\x2d\x35\xae\xe4\x96\x2e\x0f\xd4\xae\x16\x57\xd5\x6c\x68\xcc\x6c\xcb\x6c\xcb\xda\x93\xd3\x5d\xd6\x50\xf8\xca\xba\x4b\xf7\xd8\x53\x56\x28\xf3\xac\x1b\xdc\x8b\x04\xef\x48\xfb\x8b\xe5\x6c\xa9\xb2\xcc\x6b\xf2\x5a\x85\xca\xf2\x56\x63\x77\x19\xa4\xad\x4e\xc9\x7d\xff\x6d\xfb\x6b\xdc\x3f\xde\x09\xd4\xf4\x8a\xbd\xd5\x27\x5b\x4f\xee\x3e\xb1\x67\xff\xce\xb6\xd6\xae\xae\xd6\xbd\xb5\x07\xc8\x8e\x8b\xd5\xef\xfd\x8d\xed\xb2\xef\xb1\x74\x08\xc9\x4e\xb0\x21\x09\x64\xf8\xe4\xb7\x63\xbf\x79\xf8\x8b\xc1\xb0\x01\x8e\x84\x72\x21\xe9\xaf\xbf\xab\xdc\xaa\xf9\xc7\xd5\xc4\x5d\xcc\x67\xf6\x13\x25\x75\x3a\xb2\xaa\xc8\xff\x34\x0e\x66\xf1\x73\xe5\x30\xdf\xe3\x55\x5a\xa1\xf6\xb1\x8e\xe7\x0f\x2d\x3a\xb4\xe8\x8d\x55\x1f\x6f\x26\x37\x7f\xfc\xef\x62\xb8\x89\xfb\xee\x52\x55\x4b\xbf\xd8\xdf\xf2\xc6\xee\x13\x07\x8e\x1f\x3c\xd8\xb3\xe3\x70\xfd\xee\x9a\x9e\xca\x57\x2a\x5f\xa9\xfc\xd9\x02\x23\x49\x95\xa7\x44\x4e\x2e\x6f\x70\xb2\x8e\x76\x7b\x53\x35\xdb\xe8\xaf\x96\x24\xc1\xe7\xdb\xe9\x3b\x16\xd8\xe5\xea\xf0\xed\x0c\x90\xee\xa0\xbb\x52\x62\x25\x7b\xbd\xb5\x5d\x28\x70\xcf\x30\x3d\x6f\x9e\xe6\x49\xc5\x95\x95\xc4\x23\x0a\xfb\xc3\x35\xb6\x1f\xdd\xbb\x5c\x3b\xf4\x2d\xba\xd4\x9a\xe2\xc0\x16\x4f\xba\x77\x4e\x8a\x6a\x47\x2d\xe6\x56\x5b\x70\x1a\x3b\xd4\x34\xa9\x64\xb1\x60\xd8\x50\xb8\x66\xdb\x6a\x7d\xde\xf6\xdc\xcd\xba\xcd\x39\x9b\x8a\x36\x94\x91\xf9\x73\xa6\x1b\xa7\x71\x73\xe7\xd4\x76\xce\x16\x57\xb5\x64\xec\xd1\x75\x6f\x3e\x55\xf4\x8e\xf5\xd3\x12\xe8\x4a\x71\x40\x01\x51\xeb\x68\x6c\x63\x3f\xf2\x1e\x96\x2a\x85\xfa\xea\x1d\x15\x87\xb8\x97\x7b\x3c\xfe\x43\xa2\xa4\xb4\xf7\xb9\x6a\x08\x47\x71\xa6\x63\x25\x97\xee\x58\x6c\x9f\x6f\x27\x55\x95\x76\xed\x3c\xc7\x0b\x5c\xd1\x3c\xb7\xef\x01\xd1\xb3\x66\xad\x6b\x03\x57\x52\xea\x74\x94\x8a\x9e\x71\x84\x6a\x7e\xd0\x56\xeb\x6c\x70\x90\x6a\xe2\xa2\x3a\xac\x67\x26\xc4\xb7\x5d\x54\xb9\x35\xd4\x76\x4a\x4d\xf4\xbe\x10\x0f\x49\x4c\x43\xfa\x80\x29\x0c\x0d\x3f\xc7\x06\x2a\x8d\x9e\x97\xe9\xa4\x0e\x3e\x22\x85\xa4\xeb\x0e\x9d\x7f\x6e\x1c\x7c\x7d\xc7\xdf\xfe\x81\x1d\x7f\x51\xab\x94\xa5\x08\xbd\x93\x8a\x81\xee\xa4\x64\x3a\xe9\x61\x1e\x68\xe8\x8f\x6f\xef\xd8\xbb\x8c\xba\xd6\xbf\x9e\x57\x13\x93\xcf\x53\x69\xc3\xd5\x8a\xb5\x09\x3b\xd5\x8a\xb5\x89\xea\xa4\x9d\xe1\xd9\x4c\xda\xef\xf0\xff\x31\xf6\x26\xf0\x4d\x54\xdd\xff\x70\x6b\x9b\x99\x3c\xf3\x68\x51\x92\xe1\x69\x33\x99\x99\xb2\xca\xa6\x82\x14\x10\x41\x44\x41\x11\x2b\xc8\x12\x64\xdf\x97\xb6\x14\x4a\x0b\xe9\xbe\x25\x69\x9a\xb6\x99\xb4\x4d\xda\x49\xba\xef\x50\x28\xa5\xac\x95\x45\x41\x40\x59\xd4\x02\x22\x44\xf4\x51\x50\x14\xc1\xa5\x3e\x0a\x8a\x9e\x49\x4e\x52\xde\xcf\xa4\xe8\xe3\xef\xfd\xbd\xff\xf7\x7d\x3f\x4a\x27\x77\xe6\x9e\x7b\xcf\xdc\x99\x7b\xee\x39\x77\xce\xf9\x9e\xa3\x70\xf4\x8f\x48\x05\x3c\xd9\xaf\x36\xbf\x26\xb7\x82\xc3\xc5\xb0\x58\x51\x91\x9b\xe9\xc8\x60\x32\x02\x5f\xae\xb4\x5e\xaf\xd6\xeb\x55\xe4\xe6\xe6\x67\x66\x68\x32\x1c\x99\x15\xb9\x1c\x2c\xc6\xc5\x01\x57\x2c\xe8\xa6\x1c\x15\x15\xbc\x56\x41\x68\x15\x84\xa2\xa2\xc2\x51\x53\xab\xd1\x7a\x8f\xc2\x5c\x18\x4c\x81\x1d\xc3\xe9\xd7\x61\xe1\xeb\xb8\x10\x17\xca\xc7\x73\xb8\xf0\x1c\x2c\x84\x85\xe7\x14\x9e\x2d\xbe\x71\x30\x98\xf2\xa7\x78\x9e\x86\xc1\x54\x58\x23\xe4\xb1\x1e\x35\xdc\x64\xa5\x7f\x50\x2a\x80\xc9\xd4\xd9\x5e\x8b\xa8\x8d\x2c\x75\x54\x97\x94\x70\xb0\x00\x16\x28\x4a\x4a\xaa\x1d\xa5\x0c\x3c\x4d\xa8\x7e\x41\x91\xf4\xaa\x7d\xe2\x59\x0a\x44\xaf\x3b\x86\xea\x11\xc7\x52\x01\xa8\x80\x98\x25\xa9\x5b\xb6\xf0\x2a\x40\x99\x3d\x9d\xce\x39\x69\x9a\x06\xf6\xb0\x2f\xfc\xdb\x79\x9c\xef\x22\xfe\xf6\x6d\x46\xfd\xb7\xc2\xf1\x7f\x1b\x3f\x09\x2c\x13\x5d\x9e\xd1\x30\x11\xfe\x15\xf0\x03\x2b\x86\x61\x30\x0c\xec\x70\x1c\x66\x83\xbd\x37\x1a\x73\x04\xfb\xe7\x3e\x16\x7e\x04\x73\xb0\x19\x5a\xf0\x9f\x5c\xd1\x29\xdb\xf9\xaa\x33\x4a\xa1\xfa\x83\xaf\x40\xe2\xb6\x1c\x13\xdc\x82\x06\x88\x0b\x37\xae\x7f\xdc\xf1\xc6\x6b\x2f\x2d\x1f\xa0\x1f\xce\x4d\x48\x3b\x37\xe3\x0b\x06\x86\xfc\x07\x5e\x87\x24\x78\x0e\x09\xe8\x8b\xab\x31\x1b\x07\xe3\x8b\xf8\xc6\x2b\x0d\x4b\x77\xad\xe7\xab\x32\x8a\xf3\x2d\xa9\x05\xd9\x79\x71\x05\x39\x96\xd4\x4c\x73\x46\x99\x32\xf2\xf0\x22\xa0\x02\x5e\xbe\xf0\x1a\x54\x4b\x41\xf0\x16\xcc\xc7\x38\x4c\xc5\x77\x71\x12\x26\xa3\xf0\xcc\x73\x47\xde\x49\xe2\x96\xe3\x4b\xa6\x38\x41\x93\x39\x7b\xc3\xec\x84\x65\xca\x94\x8f\xaf\x18\x3e\x65\x7a\xf7\xee\x3e\xf3\x0c\x83\x09\xd0\x6f\x3f\x05\x43\x61\x28\xd8\xe0\x2d\x98\x05\x22\x3c\xcc\x42\x34\x91\xff\xae\xe9\x8f\xa6\xef\x64\x9e\xbf\x84\x7b\xdc\xd6\x63\xc2\x15\x41\x03\xa1\xe7\xbf\xba\x76\x69\xf7\x82\x99\x2f\xaf\x18\xa8\x1f\xc1\x3d\x9b\x76\x6e\xc6\xe7\x0c\x0c\xfa\x09\x66\xc2\x66\x98\x88\xa1\xf0\x28\xae\xc4\x0c\x1c\x84\xcf\xa3\xee\x95\x86\x65\x6d\xeb\xf9\xaa\xcc\x62\xb3\x25\x4d\xe6\xb9\x30\xc7\x92\x16\xe0\xb9\xff\xe1\x45\xa0\x84\x7e\x1a\xd8\x08\xaf\x42\x05\xf8\xe1\x10\xcc\xc3\xf5\x98\x8c\xef\xe0\xb3\xb8\x15\x0b\x27\x4c\x3e\xfc\x4e\x22\xb7\x02\xa7\xca\x3c\xa7\x4c\x98\xff\xec\x86\xa5\x4a\x4f\x1c\x4c\x65\x8f\xb1\xbf\x7e\xb3\x6e\xe6\x45\x6e\xe0\x10\xc5\x8e\x84\x45\xbb\x5e\x60\x30\x3c\x12\x83\x50\x83\x9a\x3f\x30\x08\xc2\x61\xe4\x69\x08\x7e\xaf\x9c\xc7\x4d\x10\x4e\x08\xd0\x43\x96\xa4\x95\xa4\x6e\x01\x86\x95\xda\x23\x59\xa9\xed\x49\x68\x86\x4b\x60\xc7\xf5\xb0\x1e\xbc\xd0\xdc\x57\x80\x76\x2d\xf1\x32\xac\x57\x5d\xd3\x2a\xea\x3c\x21\xf4\xdb\x96\x7d\xe6\x7d\x9c\xff\x15\x81\x40\xbb\x14\x45\x46\x66\x60\x30\xae\xc3\x43\x0c\x96\xe0\x4a\x58\x13\x48\xd7\x26\x1f\x4b\x60\xe0\x8f\xb3\x16\x9c\xe2\x61\x09\xcc\x53\xc0\xc3\xa8\xc6\x09\x57\x70\x31\xa3\x3a\xe6\x1b\x86\xd7\xf0\x9a\x6f\x98\x6f\x18\x5c\xc3\x6b\xd2\x30\x69\x22\x74\xc0\x71\x69\x3c\xef\x01\x08\xa3\x71\x1d\xac\xc3\xf5\xb8\x0e\xd7\xe1\x7a\x58\x87\xeb\x60\x3d\xac\x83\x75\x44\x18\x0c\x13\x40\xdd\x0d\x51\x52\xa7\x7c\x50\x07\xc3\x6e\xea\xf2\xe9\x80\x1a\xf2\x36\x15\xe2\x11\x25\x35\xdd\x0d\x6a\xe8\x2c\x22\x33\xb7\x64\x19\xb6\xa6\x4c\xfe\x22\x1c\x86\x02\xab\x00\xc2\xa7\x03\x75\xc0\x9f\x4d\x94\x6d\x93\x87\x20\x07\xd7\xe3\x7a\x7c\x08\x73\xf0\x55\x7c\x15\x1e\xc2\x1c\x90\x6f\xf4\x21\xc8\x81\x57\x39\x49\x44\x91\x86\x76\x56\x8b\x06\xa2\x99\xe5\x24\x91\x8c\x66\x79\x0b\x45\x98\x29\xce\x27\x92\xa0\xf6\xb8\x63\x28\xad\x27\x68\x2c\xa5\x45\xc3\x53\x6c\x26\x1b\x47\xf9\x73\xc1\x2d\xb9\x61\x01\xeb\x71\x9b\x02\x88\x0f\x62\xa0\x04\x6e\x3a\x87\xea\xb9\x0f\x6a\xaf\x18\xdc\x25\xb9\x43\x3c\x6a\xaf\x9b\xfe\x9e\xf2\xe9\x7c\x3a\x45\x6e\xae\x39\x33\x43\x03\x51\x2c\x27\xe9\x7c\x3a\x38\xf7\x67\x3d\x41\x72\x87\x48\x6e\x4f\x20\xfa\x55\x27\xe9\xde\x67\x7b\xd4\xe4\x95\x00\x94\xea\xc5\x00\x1e\x5c\xc0\xa7\x51\x08\x20\xa3\xbd\xcc\xaa\x9f\x81\xa8\x7e\x2d\x94\xf7\x9e\x47\xad\x45\x03\xe9\x11\xdb\x6b\x58\xdf\x3d\x0b\x25\xab\xa2\x04\x04\x30\xb7\x03\xa2\x6a\x23\x15\x10\x53\xfe\x5c\xad\x62\x4a\x2a\x2c\x60\x25\x9d\x49\x96\x66\x39\x94\x3f\x37\x3a\xc0\xa9\x7c\x22\xec\xaf\xcb\x1e\x99\xef\xc6\xc0\xee\xc8\x28\xd6\x73\x91\xde\xb4\x21\x2e\x21\x66\x0b\x4e\x44\x05\x4e\x42\x02\xc7\x23\xa5\x9c\x39\x7e\xe0\xf3\x18\x1c\x00\x5b\xc7\xe0\x81\x9f\x7e\x30\x9e\xc7\xf1\xf0\x4f\x9c\x04\x0a\x7c\x16\x14\xeb\xb7\xc5\xed\xdc\xb4\x5b\xe9\xdf\x73\x8a\xf2\xba\x43\x6f\xbe\x78\x25\x8a\x93\x05\x73\xe4\x1b\xe3\x87\x8d\xba\x83\x8a\xcb\x4b\x78\x78\x0a\x83\x60\x34\x06\xc1\x53\x18\xac\x5c\x7e\x1e\x1e\x7a\xea\x5a\x00\xf3\xfd\x1a\x3c\xf4\xdd\x91\xf3\x3c\x3c\x05\xc1\x30\x1a\x82\x60\x14\x04\x29\x6f\xbe\xff\xe5\x1d\x08\xd5\x84\x79\xc6\x41\x25\x4e\x84\x41\x7d\xeb\xe1\x4b\xcf\xcf\x70\x5d\x95\x08\x77\xbd\x03\x69\xfc\xb2\x67\x2b\x7c\x49\x34\x6a\x15\x8f\xd1\xaa\x7d\x3f\x59\x5f\xfa\x04\x15\x0c\x86\xbe\xf0\xc2\xf0\x91\x97\x9f\x87\x10\xbe\x58\x20\x80\xbc\xf2\xe9\x8f\x56\x5e\x1b\x5a\xe2\xdf\x44\xc3\x69\x1c\x07\x03\x70\x13\xa7\x4a\xc4\x97\x9f\x1b\x3a\x7d\x25\xaf\xda\x57\x0c\x83\xf0\x3a\x21\x94\x3e\x59\xd0\xd3\x8f\x13\xe0\xba\x74\x9c\x6c\x2b\xd9\x59\xde\xc4\x9d\x6d\x39\xf5\xfe\x6d\x06\xfe\xf9\xf6\x28\x8c\xe0\x7d\xad\x70\x9d\x0c\x83\x5f\xd8\x22\x16\x44\xd5\x3e\xd5\xa5\x13\xac\x6a\x1f\xb0\x6c\x00\x7e\xf5\x23\x4a\x75\x09\xfe\xc3\xaa\xf6\xe1\x34\x18\x02\x1b\x87\x40\x3a\x03\xb3\x03\xe8\xf7\xb9\x5a\xe2\xbd\xe0\x83\x5a\xe2\xbd\x10\x2d\xd1\xdd\x0f\x0a\x58\xbc\x0f\xf7\x1f\xc4\x4e\xaf\xdb\x98\x99\x98\xc8\x4b\x8f\xb1\xd0\x17\xfa\x2a\x44\xd1\x5e\x51\xa9\xa9\xb4\x54\x98\x44\x6e\x53\x5b\xd3\xe6\xa3\xcc\xf6\x66\x67\x5d\x3d\xbf\xb7\xe3\xed\xbd\xa7\x1e\x20\x89\xfb\x46\x4a\x23\x15\x75\xe9\x5b\x9c\x5b\x98\xf9\x31\x4b\x62\xe2\xf8\xf4\x34\xa3\x3e\x49\xb3\x6c\x47\x72\xdb\x26\x4e\x34\xe5\xda\x73\x98\x9c\x5c\x8b\xc9\xc4\xe3\x1d\xbc\xa3\x30\x99\x2c\xb9\x39\x9a\x1c\x7b\xae\x68\xe2\xda\x36\x25\xef\x58\xc6\x24\xe9\x8d\xe9\x69\x7c\x4c\xdc\x92\x98\xf9\x0f\x92\x32\x4a\x23\x7d\x23\xe1\x0d\xf6\xd4\xde\xb7\xf7\x76\xf0\x75\xf5\xce\xe6\xed\x9a\xa3\x9b\x9b\x36\xb5\x71\x26\xb1\xc2\x52\xc9\x54\x56\xd8\x45\x91\x97\xf9\x83\x26\x56\x91\x98\x98\xb9\x71\x9d\x26\xae\x2a\x10\xbe\x7e\xdf\x17\xf4\x57\x14\xf7\x1f\x10\x14\x08\xe2\x0e\xbc\xa2\xab\x59\x78\x9f\x9a\xce\x82\x4e\xd2\x4d\x67\xa5\x29\xbe\x64\xfa\xfc\xf2\x8e\x09\x29\xcf\x26\x0e\x1e\x30\x73\x50\xeb\xe0\xd6\x99\xf7\x5a\x7f\x6d\xba\x76\xe9\xdd\xcf\x1d\x77\xa4\xbe\xe1\x62\xc7\x9e\xc6\x0e\x93\x52\x20\x3b\x4c\x0d\xb1\x79\x71\x4a\xe9\x3d\xbc\x3b\x9d\xf5\xab\x3d\xea\xe9\xac\xa4\x43\xdd\x74\x16\xdc\x3e\x1d\x0d\x9f\xb0\x7f\xe6\xb0\xc4\x29\xc7\x70\xe2\x77\x38\x88\x4b\xaf\x68\x30\x34\x31\x5a\x45\x06\xd1\xd4\xe0\xaa\xab\xe0\xbf\x83\xc1\xc7\xe0\x59\x98\xf2\x20\xfa\x56\x84\xd5\xac\x57\xad\x0d\x35\xec\xa0\xfe\x8c\x82\xe3\x04\x32\x10\x08\x77\x00\xff\x68\xa0\x1a\x1b\x53\x1e\x24\x26\xf8\x9a\xf2\xe8\xe0\x7d\x16\xce\x43\x2d\x4e\xc3\xb5\xb8\x16\xe5\xe3\xf9\x05\x0b\xed\xe2\x22\xfe\x0d\xe7\x8a\x8d\xa9\xd9\x29\x39\x29\xb9\x11\x7b\xbe\x1a\xfe\x9e\x02\xd5\x9f\xbc\xf0\x3b\x3c\xa4\x81\xb5\x50\x0b\xd3\xe0\x3c\x07\xea\x50\xa8\x66\xf9\xb7\xd9\x3f\x23\x0b\x78\xcf\x87\x5a\xdc\x4c\xff\x15\x52\x60\x60\xc3\xfc\xf7\x51\x3c\xc8\x06\x0b\x5e\x55\x88\xf7\x1f\xde\xe5\xb4\x68\xca\x75\xe4\x30\x05\x05\x56\x6b\x01\xef\x8b\x1c\x06\xcf\x4b\x6b\x14\x25\x8e\x62\x87\x43\xd3\x9c\x5a\xbf\x85\x13\xf0\x1a\x99\x92\x9e\x93\x66\xe1\x71\x99\xff\x42\x61\x76\x69\x56\x85\x31\xc2\x5c\x5e\x51\xe0\x62\x4a\x4b\x05\x5b\x29\x2f\x0d\xbf\x83\x8b\xfc\xc7\x2c\x29\x95\x29\x4d\xe6\x08\xab\xdd\x6e\x2d\x65\xea\x6a\x9c\xd5\xe5\xbc\xb4\x4f\x1b\x9a\x5f\x56\x5d\x58\x6b\xa8\x88\x08\x6b\x94\xdc\xb2\xa0\xd4\x81\x5a\x12\xe1\x36\xa5\x4e\xcc\x64\xa1\x13\xc6\x50\x23\x40\x47\x7c\x4e\xf9\x44\xd0\x75\xbf\x40\x81\x9b\x5c\xca\xa2\xbb\x8b\x42\xf7\x24\xaa\x1b\x75\x3e\xf1\x0e\x85\xba\x11\xe4\x8d\xde\x2b\x23\x40\x27\x89\xa8\x1b\x41\xfc\xef\xb2\x2c\x93\xb4\x8a\x48\x88\x0a\x96\xd4\x00\x94\x57\xed\x59\x48\x97\xa5\xa4\x94\x26\x33\xc9\x29\x05\xe6\x14\xde\xf7\x19\xf9\xca\xac\x59\xaf\xbc\x32\xeb\xfd\x8b\x30\x8c\x42\x1e\xfe\x81\xff\x00\x1e\x78\xf8\x07\xfc\x03\x78\xce\x23\x4a\xc7\xe9\x92\x00\xba\xb7\x14\x36\xda\xa7\x80\x0d\x3e\x25\xe3\xa3\x7c\xc1\xb8\xc1\x17\xf6\x14\x6f\x2d\x12\x8a\x0a\x35\x07\x28\xb1\xac\xd4\x51\xc6\x9d\x3a\x73\x6a\xff\x97\xcc\x8f\xd7\xa1\x99\xad\x64\xaa\xe0\x1c\x7b\xed\xec\x8f\xcc\x8f\xd7\xa0\x99\xad\x62\x2a\xe1\x1c\x7b\xfd\xec\x8f\xcc\x97\xa7\xd6\xcd\x3f\xc3\xe7\x97\x95\x15\x88\xcc\x64\xca\x2f\x7a\xe2\x69\x08\x61\x87\x91\x8d\xb6\x26\x5b\x63\x63\x93\xb5\xf1\xe1\x41\x61\x8d\x30\x9a\x82\xb7\x29\xe9\x41\xf2\xe4\x07\x98\xf6\x77\x29\x8f\x88\x6a\xda\x42\x49\xbd\xb6\x6a\x94\x5f\x4d\xf8\xd5\x5a\x45\x63\x0d\xeb\xd7\x19\xa8\x2e\xb7\xfc\x86\x4c\x67\xa3\x49\x10\xfd\x51\x34\x9c\x20\xe1\x04\x9e\x50\x40\x1c\xaa\x1f\x98\xa8\xf2\xcc\x34\xb8\x72\xc5\x9c\xf2\x08\xb8\x46\x2e\x65\x7b\xdc\xf0\x04\x2b\x75\x06\x40\x26\xc3\xfc\xb9\xde\xce\x2e\x88\x82\x48\x16\x06\x82\x0a\xd2\x40\xf5\x6c\x20\xfc\x55\x75\x5b\xe5\xf5\xe8\xbd\x3a\x1a\x42\xf0\x5f\xc7\x9e\x7c\x99\x3d\x40\x9d\xfc\x23\xf1\xe5\x03\xd4\xcb\x14\x07\x51\xfd\xa2\x93\x5e\x59\xb5\x98\x4b\x4b\x4e\x4e\x49\xd5\x4f\x1b\xf7\xfa\xe3\x46\x54\x28\x31\x8d\x30\x82\xe2\xf5\x5f\xa6\xdd\x48\x6d\x4e\x6e\x4c\x6b\x52\xae\x3a\x96\x74\xb1\x4b\x03\x4b\x61\x05\x3c\x0c\x33\x38\xd5\x6d\x98\x01\x2b\xf0\x61\x5c\xca\x83\xba\x1f\x6c\xc3\x0a\x98\x86\x0e\x74\x60\x05\x4e\xc3\x6d\x83\x3a\x9e\xbe\xf4\x3c\xa7\xf2\x5e\x7a\xfe\x76\x64\x79\xa4\x32\x21\x23\x3d\x7e\x83\x66\xab\xa8\xaf\xc9\xe0\x32\x33\x4c\xfa\xad\x9a\x0d\xb5\x9b\x76\xa4\x73\x79\xd9\x96\x8c\x4c\x8d\xea\xf6\xab\xef\x6c\x3c\xc3\xcd\xd9\x7e\x66\xdd\x87\xcc\x87\x67\xf6\x9f\xd9\xce\x9f\x79\x67\xd7\xf9\x1a\x4b\x6d\x5e\x15\xbf\xa3\xae\xb6\x6d\xb7\xa6\xc5\xd4\x9c\x59\xcb\xd5\xd4\x8a\xcd\x2d\x9a\xdd\xe9\xed\x09\xb5\x5c\xf9\x1f\xb7\xff\xb8\xf4\xa9\xf2\xd2\xa7\x1d\xdf\xfe\xaa\x09\x6b\x04\x35\x7c\x4f\xc1\x28\x16\xee\xd1\x01\xa0\x2a\xad\xb7\x11\x74\x44\x5d\x56\x15\xb4\xb0\x79\x26\x4d\x5e\x49\x9e\x23\x9f\x83\x2b\xe8\x56\xe4\x97\x95\x17\x88\x4c\x5d\x55\x75\x2d\x0f\x3a\xad\x62\x25\x39\x99\xf2\xe8\x43\x77\xb2\x5a\x6f\x23\x39\x9e\xd2\x2a\x56\xa2\x8e\x08\x04\xca\x06\xf4\x00\x7d\x2f\x58\x67\x11\x2b\xdd\xa3\x4d\x05\x79\xf9\x66\x0e\x7f\xc3\xdf\x14\xf9\xf9\xa6\xc2\x3c\xc6\x94\x57\xe2\xc8\xe7\xf1\x1e\xdc\x53\xe4\x3b\x0a\xc5\x72\x4d\x6d\x55\x75\x1d\x07\x7a\xb8\x47\xc8\x03\x1b\xd8\x5e\xb8\x07\x7a\xe8\x66\x3d\x6a\xd4\xdb\x28\xb9\x41\xf1\xcf\x06\x3d\x51\x74\x46\x76\x56\x3a\x87\x7a\xbc\x47\xd4\xf5\x6e\x4a\xdc\x43\x3d\x29\x1b\x09\x62\x69\xb9\xa3\x8c\x87\xdf\xe0\x37\x85\xc3\x21\x96\x94\x33\x62\x79\x61\xbe\x83\x87\x7b\x78\x4f\xe1\xc8\x2f\x31\xe5\x69\x3c\x6a\xec\xb4\x51\x78\xbf\xd7\x09\x0f\x56\x53\xbd\x49\x3e\x51\x0f\xba\xc0\x03\xff\x4d\x52\x83\x6e\x2f\xab\xfa\xdd\x2b\xce\xa2\x61\xc9\x1a\xb8\x88\xa6\x13\xdc\xce\xe9\xe6\xe7\x5e\xd4\x7c\xbe\xfc\xd8\xb8\x51\x1a\x78\x81\xfd\x2b\x01\x02\xbc\xc0\x46\xb3\x5c\x17\xb9\xbb\x70\x77\x72\x2b\xa7\xc2\x19\xe3\x07\xae\x8b\x64\x22\x07\xee\xbf\x30\x9e\x4f\x4e\x2c\xdc\xb0\x41\x83\x2b\xc8\x4f\x13\x4f\xbc\xf8\xac\x46\xf5\x1b\x7c\x46\x5d\x7b\xc7\xfd\x59\x2b\x07\x2b\xc8\x4e\x47\x67\xcd\x7e\x0e\x4d\x0b\xd6\xe0\x45\x5c\x02\x59\x2c\xba\xbd\x8f\x3d\x48\x08\x82\xf7\x37\xb1\x50\x40\x81\x3b\x80\xd6\x05\xe2\x8f\x6c\x6f\x8a\x53\xd5\xf1\x20\x55\x8f\xa1\x88\xf5\xb8\xff\xc3\xf6\x83\x5c\x76\xfc\xc9\x97\xae\x26\x72\x3e\x1e\x32\x29\x08\x27\x61\x53\x2b\x4c\x84\x28\x98\xaf\x91\x44\x72\x0c\x9b\x6f\xb1\x5a\x2d\xdc\x81\xe4\x55\xad\x4b\x98\x7c\xea\xf4\xdc\xcb\xcd\x4d\x65\xae\x7a\xde\x37\x04\x32\x29\x69\x08\x69\xa8\x6f\x32\x37\x33\x0f\xfc\xcf\x96\xac\x4a\x5c\x9b\xcc\xab\x8e\x07\xd9\x2c\x16\x5b\x3e\xf3\x04\x15\x88\xac\x98\x0f\x13\x31\x0a\x36\x25\x72\x18\x4e\x62\x2c\x2c\xc3\x29\x5d\x2c\x4c\x81\x58\x4e\xe2\x49\x55\x8f\xe1\x6a\xeb\xc9\x8f\xbf\x92\x5f\xa0\x0e\x0a\x3a\x41\x0f\xb7\x29\xd0\x43\x67\x88\x47\x2d\xcb\xe9\xde\x8f\x2c\xfe\x7b\xfd\xa2\x21\x9b\xed\x22\x02\x5e\xc8\xa8\x86\x60\x16\xd5\x5a\x0c\xf2\x8a\xa4\xa4\xf6\x76\x42\x2e\x15\xad\xc5\xa0\x2e\x98\xc3\x86\x35\xfe\xcd\x85\xcd\x73\x1a\x3a\xe9\xff\x93\x6f\xda\x5f\x8e\x69\xdc\x7f\x1d\xd3\xfe\x1f\xdc\xd2\xfe\xa7\x53\x1a\x0c\x3b\xc0\xca\xcf\x55\xfe\x17\x7c\x90\xed\xf5\xd3\x54\xd3\xbb\x28\x2e\x5a\x52\x77\x11\xbf\x7f\x3d\xb6\x3f\xaf\xf5\x18\xfc\x22\x6d\xa6\xb8\xa2\x00\x1c\x6c\x97\x47\xa4\x21\x16\x7e\x62\x31\x96\xd3\xa2\x61\x2c\xe5\xd7\xc3\x17\xb2\x8c\x99\xc3\xb6\x77\x91\xdf\x50\x78\x1f\x78\x4a\x80\x15\x94\x47\xad\x55\x9c\x94\xa5\x98\x2f\x8a\x84\x0b\x6c\xc2\xce\xd8\xd8\x84\x84\x58\xee\x7f\x96\xfc\x6a\xf2\xd9\x13\x2f\x7e\x9a\xc8\xf9\x1b\xe0\x24\xe5\x69\x20\x3f\x6d\x3d\xe1\xbe\xa6\xf1\x88\x1e\x75\x0c\x85\x22\x01\xf3\x29\xde\xdf\x19\xcf\x82\xde\x27\x12\x81\x7b\x00\xf5\x55\x16\x45\x98\x20\x9b\xb4\x7f\x4f\x6f\xd0\x23\x62\x14\x3d\xf9\x41\xe0\xca\x50\xca\xa3\x47\x3d\xed\xd7\x8d\xa6\xe4\x13\x28\x86\xfe\xf9\x33\x0c\xef\xff\x49\xdd\x0b\xc5\xfe\xdf\xe4\x10\x6a\xd0\xff\x09\xc7\x2e\x76\xcd\xa2\x3c\xa2\x4f\x47\xd7\x66\x55\x67\x70\xd1\x44\x46\x56\x56\x06\x1f\x4d\x66\x54\x67\xd5\x72\x5d\x44\x6d\x75\x75\x2d\x8f\x22\xb8\x67\xb0\xff\x3f\x2a\xfd\x7f\x5c\x1e\xc7\xbe\x4c\xf1\x28\x6a\xbd\x37\x60\x39\x3b\x9b\xb2\x50\x5a\x6f\x10\x09\x6a\x2d\x31\x25\x86\xd2\xa2\xac\xae\x7b\x0c\x4f\xb1\x45\x6c\x1c\x15\xe0\x5c\x16\xfe\x45\x54\x60\xe7\x18\xd4\x3f\x07\x6e\x43\x05\xf3\xff\x27\xef\xe3\x58\x95\x72\xda\x64\x0a\x45\x7f\x27\x2c\x0f\xa8\xde\xf1\x93\x28\x49\xf7\x02\xa5\x32\x2b\xda\x41\x94\x75\x6e\x9f\x5a\x1b\xda\x18\x40\x0f\xe8\x46\xf5\x08\xb2\x2e\x80\x23\xe0\xee\xc5\x11\x18\x01\xea\x6e\x37\xa5\xa2\x74\x5d\xbd\xbb\x99\xaa\x82\x97\x24\xb1\x3d\x86\x42\x37\x74\x12\xaa\xc4\x5d\x4b\x59\x9f\xae\x8b\xc2\x4e\xd8\x13\x88\x76\xed\x65\x0e\x86\xf5\x9a\xed\x32\x7f\x37\x59\x50\xf7\xe2\x4f\xf4\xa6\x8e\x16\x55\x9e\x46\x98\x4c\x4d\x67\x1f\xd8\xf1\x36\x87\xdd\x55\x62\x97\xed\xf8\x70\xd5\x1f\x27\xed\xa5\xae\x52\x87\x4d\x09\x4f\xa3\x48\xc8\x86\xfc\x74\x16\xd4\x9e\xa8\xf3\x2c\x04\x07\x32\xc3\x40\x37\x1b\x80\xd7\x92\x3a\x69\x95\xa7\x31\x00\x00\x3a\x96\x42\x37\x46\x91\xb1\x8b\x03\x06\xfe\x1f\x27\x03\x16\xfe\x96\x2d\xa9\x8b\x63\x35\xbe\x28\xd2\x48\x41\xc0\xa4\x27\x90\x84\x01\x30\x00\x88\xfa\x80\x91\x6f\xa6\x1e\xfc\x06\x5d\x1c\xd5\x78\xa0\x17\x3a\x4f\x0d\x6a\xe9\x51\xaa\x1b\xa2\x60\x37\x25\x40\x54\xb7\xcc\xaa\xa1\x88\x95\xa2\xce\xb3\xaa\x3f\x0c\xff\xe5\x40\xe5\x31\xa0\x8e\x54\xfd\x61\xf0\xab\x3d\x7a\xfa\xc1\x2c\x56\x79\x0c\x3d\xea\x7e\xf1\x90\xcd\xb6\x13\xda\xd0\x46\x79\x26\x47\xc9\x33\x39\x4a\x9e\xc9\x6e\x12\xee\x05\x66\x72\xbc\x16\x83\xda\x7b\xe3\xcc\x85\x76\xd0\x81\x18\x0f\x62\xbc\x14\xc2\xb6\xf7\x95\xc5\xb6\x6a\xb7\x96\x34\x48\x6e\x5a\x10\xda\xb1\xb3\x8b\xc3\x7b\xed\xa8\xef\x52\x44\x13\x78\x14\xee\x29\x2e\x49\x8f\x50\x23\x08\x8c\x22\xa2\xe3\xbb\x7c\x51\x84\xea\x1a\x46\x11\xa8\x03\xbd\x62\x04\x11\x1f\xaf\x40\x5d\x7b\x3c\xa8\xf3\x48\xd4\x6d\x55\xa0\x9a\x04\xdd\x56\x45\x1e\xaa\xe3\xe3\x51\x47\xb6\xc7\x2b\x54\xbb\xbb\x09\x90\xeb\x42\x94\x2f\x2a\x3a\xbe\x8b\x80\x28\xa2\x5b\x7a\x84\x7a\x99\x00\xb9\xe9\x2e\x02\xf4\x5d\x70\xaf\x5d\x01\x9d\x5d\x42\xbb\x10\x08\x92\x0f\x24\xc8\x09\x96\x1f\x5a\x6f\xe4\x78\x56\x8c\x30\x99\x99\x36\xf7\xf4\x65\x5e\x08\x7c\xbe\xd6\x80\xe8\x53\x13\x5e\xf9\x8d\x47\x35\xe8\x14\x9e\x4e\xb2\xab\x3d\x1e\x74\x8a\x1e\x1d\x11\x8f\x6a\x85\x4f\x2f\x1f\xba\xa2\x15\xe8\x96\xe5\xe2\x14\x94\x65\xa2\xeb\x77\xc1\xc5\xa0\x1a\x75\x0a\xd4\xc1\x5b\x6c\x58\x20\x3a\x42\x47\x27\xca\xba\xb1\x88\x6e\x32\x91\xf5\xaa\x93\x58\x74\x4b\x22\xb8\x93\x64\xab\x11\x44\x6f\x54\x64\x6f\x10\x85\x41\x7e\xce\x6e\x42\xae\x8b\xee\x00\x6a\x9d\x1b\xdc\x44\xac\xfc\x22\xba\x49\x28\xa3\xa4\xce\x48\xd6\x9f\xfb\x99\x37\x23\xf8\x88\x77\x71\x88\x87\x84\x28\xfa\x3a\xe5\x63\xa5\xc0\x7f\x4e\xaa\xbc\x40\x8c\xa7\x24\x75\xbf\xff\x75\x2e\xac\x97\xa8\xd2\xbb\x38\x44\xfa\x4e\x72\xd3\x76\xb9\x96\x9d\x0a\xf3\xdd\x87\xfe\xde\xc5\xd0\xc1\x82\x9e\x7e\x8d\x95\xd4\xa1\xaf\xb1\xf2\xb9\x17\x02\xe7\x3c\x51\x74\xb4\x6c\x7d\x46\x53\x61\x3d\xf7\x03\x7d\x4a\x9f\x87\x78\x48\xaf\x9e\x16\x0b\xca\xe3\xa9\xbf\x77\xf2\xa0\x42\xa5\xf4\x79\x6f\xfb\x9f\x52\x8b\x16\x29\xf2\xf3\x0b\x4c\x79\x9a\xbc\x52\x93\x23\x9f\x93\x58\x1f\x2b\xa9\xa8\x07\xe7\x4c\xa5\xb2\x2a\x71\x7c\xd1\xce\x00\x07\x4d\xd2\xe7\x32\x07\xf7\xe8\xde\xce\x4f\x05\x8a\x9e\x4e\x3a\x9a\x0a\x83\x61\xb0\xb6\xd7\x6b\x20\x93\x95\x3a\x6b\x58\x68\xa3\x3c\x6e\x89\xec\x45\x78\x0d\xe4\x85\xf0\xb8\xff\xcc\x7b\xd5\xe3\x8e\x61\xa5\x4e\x22\x2a\x7a\xfa\x7a\x88\xa1\x24\x71\x14\xb5\x27\xfa\xca\x0d\x8d\xd4\xf9\xa1\xac\x34\x74\x8f\x00\x5d\x74\x57\x17\xa8\x21\x8d\xea\x2b\xcf\x83\x00\xf4\xe5\x72\x29\x0a\x44\xda\xeb\x5e\x2c\x8b\x73\x9e\xed\x71\x2f\xa3\xfc\xba\x18\x36\xde\x73\x8f\x7e\x99\xe2\xbc\x6e\x98\xce\xfa\x75\x64\x1d\xdb\xe3\x36\x04\xd4\x1a\x3d\xad\xf5\x9c\x24\x30\x6a\x04\xf1\xc6\x95\x95\x37\x39\x2d\x31\x85\xb8\x79\xe5\xd0\x49\xbe\x9b\x54\xbd\xd3\x13\x3a\x82\x86\x2d\x14\x90\xf2\x5d\x08\x5d\xa0\xee\x82\x79\x14\x14\x50\x21\x30\x99\x4a\x90\x75\xd8\xa8\x1a\xd6\xef\x36\x50\x5e\x9d\x9b\xf2\xb8\x21\x89\xf5\xbb\x7b\x99\xf6\xb8\x3f\xa4\x7a\x72\x85\xb7\x21\xea\x6d\x8f\xd8\xdd\x2e\xeb\xb9\xdd\x92\xbb\x3b\x44\x5a\x0b\x6a\x7a\x45\x4c\xcc\x0a\xf8\x8a\xe2\x60\xad\x4c\xef\x13\x0d\x94\x47\xe7\xa6\x24\xb1\x97\x33\xd4\x79\xbe\x95\x97\x4a\x0e\xb6\x50\x3c\x74\xd6\xdc\x62\x65\x83\xa0\x47\x24\x7b\x17\x3f\xf1\x2a\x7b\x88\xf5\x88\xda\xd0\xc6\x09\x6c\x64\x63\x8a\x85\xda\x4f\x49\xc1\x6c\x00\x3a\xab\x9d\xf5\xaa\x25\x75\x3b\x1b\x48\x2c\x15\x0c\xd7\x1f\x5c\xd0\x86\x9e\xdc\xcd\x7a\xd5\x1e\xdd\x6e\x36\xac\x11\x75\x20\x2e\x02\x11\x2c\x20\x4a\xb7\x53\xfb\x76\x41\x13\x7b\x90\xd5\x7a\x67\x3d\x38\xa5\x03\x51\xa5\x0f\x92\x9a\x61\x00\x2d\xab\x0e\x2f\xcd\x99\x3b\x4d\xee\xf6\xf2\xe9\x33\x1f\x73\x92\x05\x57\xd3\x2f\xb2\x7e\x9d\x47\x47\xbf\xc8\x6a\x43\x0f\xf8\x2c\xf4\xe5\x39\xa7\x5f\x8a\x65\x5f\x3a\x3d\xe7\x32\xf4\xb0\x3d\x0b\xbd\x69\xf4\xcd\xa9\x57\xc6\x24\x52\x63\xae\x4c\xbd\xc9\xa9\x5e\x0c\x5a\x43\x69\x43\xcb\x7c\x16\x99\x4c\xed\xd1\xd1\x70\x83\xe2\x54\x6d\x41\xd0\x43\x49\xad\xb8\x9a\x86\x3e\x43\xee\x60\x1f\x7c\xf4\xf1\x21\xd8\x07\xd6\x51\x9c\x2a\xd1\x00\x7d\xee\xfc\x02\x8f\x3e\x80\x38\x51\xd3\x91\xd4\x03\x60\x32\x2d\x31\x3c\x00\x4d\x26\x45\xd1\x10\x6a\x00\x72\xd5\xef\x1c\xfc\x07\x79\xdf\xc8\x33\x78\x8d\x41\x3d\x88\xc4\xf7\x94\x4f\xf4\x89\x7f\xdf\xdb\x11\x7d\xe2\x07\xf2\x22\xa3\x27\xa5\xa9\xb0\xf7\x19\x5f\xd2\xea\xa2\xd5\x85\xab\x79\x6b\x66\x41\x7a\xa6\x26\xad\x22\xb3\xa1\xaa\xac\xcc\x59\xc6\x55\x37\xba\xda\x5d\xcd\xca\xd3\xa0\xfe\x18\xa2\x21\x52\x13\x16\x89\xea\x1f\x83\x05\xd0\x43\x94\xac\x3c\x47\x81\x5e\x56\x7b\xdc\x34\xac\x60\x3d\xea\x7e\xb0\x82\x85\xa8\x7e\x78\x16\x77\x2f\xc5\x42\x0e\x27\x11\x58\x88\xbb\xdf\x82\xb3\xf0\xc4\xf7\xc0\xc0\xf8\x0b\x5d\xb9\xa6\xf3\x7c\xde\x89\x13\x85\x27\x99\x93\x27\x4a\xca\x4f\xf0\xe2\x85\x0f\x2b\x2e\x30\x30\xfe\x7b\x64\xf0\x09\x1e\xf4\x30\x8d\x86\x21\x6b\x80\x1f\x01\x0a\xae\xee\x94\x78\xfa\xb4\xe6\x6a\xc6\xd5\xb8\x8f\x38\x1c\x35\xe4\x95\x27\xf1\x9f\x7c\xd3\xa8\x91\xce\x27\x98\x81\x03\x0d\x5b\x87\xf0\x3f\xe0\xc3\x43\x2e\xe1\xd3\x4c\xdc\xf4\x8c\x29\x53\x34\x73\xc5\x39\x75\x3a\x6e\x04\x86\xae\x41\x0e\x87\x68\x30\xc4\x85\xff\x7c\x67\x08\x87\xcd\xc0\x4a\xb4\x1e\x6a\x19\xa8\x84\xfb\xdb\xa1\x01\xc2\xf9\xe3\x77\x5d\x40\x41\x48\x20\x5b\x99\xda\xab\x06\x9a\x95\xc4\xc0\x3c\x09\x99\x4d\x81\xbe\x17\x8b\x0c\x3e\xa0\xde\x58\x79\xe8\x24\xef\xd5\xc1\x72\x79\xae\x7c\x47\xf9\x75\xf2\xec\xd3\xfd\x1f\x00\x46\x02\xe8\x13\x81\xd5\x30\xd0\xda\xcb\x2c\x14\x05\x82\x5b\x7e\x97\xee\xd2\x59\xa6\x1c\x93\x81\xc3\xb7\xf0\xbe\x62\x55\xdc\x4b\x1b\xde\x60\x7a\xdc\x44\xf2\xc6\xb2\x1d\xd5\x62\xa5\x58\xc1\xc3\x5b\x70\x5f\xd1\xd9\xf1\xf1\xee\x93\x8c\xd7\x4d\x34\xed\x32\x6f\xe6\xb5\x28\xc0\x78\x7a\x54\xe4\xc2\x69\x73\x78\x14\xf1\x23\x85\xe7\x07\x58\x4e\x49\x6e\xf8\x8e\xc2\x28\x52\x2a\xc2\xf1\x74\x8b\xa5\xd9\xd8\xc8\x75\x6d\x9a\xbe\x6b\x3a\x83\xb2\xfa\x9e\x1d\xc0\x26\x79\xc0\x96\xd7\x4d\xdc\x82\xe0\x13\x1f\x9f\xe6\xe1\x6d\xb8\xaf\x68\xed\xa8\x7f\xf3\x70\x6f\x92\x46\x54\xc3\x9b\x94\xa4\xfb\x8c\xd5\x86\x26\x48\xab\x68\x57\x47\xda\x9e\x0d\xae\x38\x57\x4c\x9a\x21\x4e\x19\xb9\x61\xe8\x54\x0c\x65\x30\x74\xe8\x95\x3f\x36\xf0\x86\x8e\x98\xfa\x0d\x86\x38\x43\x5a\xac\x2b\x4e\x89\x63\x8f\xc3\xe3\x18\x04\xcf\x31\xf0\x1c\x3c\x0e\x41\x30\xf6\x38\xef\x33\x49\xd3\x9f\xa1\x36\xb1\x92\x0e\xe2\xa8\x40\x83\x70\x8e\x86\xb1\x8b\xf0\x71\x08\xc2\xe7\x18\x7c\x0e\x1f\xc7\x20\x1c\xbb\x88\x37\xc4\xd5\xc7\x76\x18\x76\x1b\xf6\xd6\xbb\x3a\x94\x7f\xec\xfe\xf9\x0a\x84\x32\x10\xfa\xf3\xd4\xc8\xdd\xbc\x2b\x6e\x6f\x5a\x87\x6b\xb7\xab\x7e\x8f\xa1\x43\xe9\x33\x49\x5f\x3f\x43\xa1\x1a\x2e\xb3\x9f\xb1\x16\x4a\xd2\xc5\x50\x7e\x35\x61\xa4\x3c\xea\x51\x94\x4f\x94\x74\xcf\x04\x8c\x21\x5d\x34\x74\x4a\x51\xa0\xeb\x2b\xc8\xa6\xd8\x49\x10\x55\x47\x3c\x6e\x49\x47\x3f\x4b\xa1\x0e\x75\x84\x2a\xad\x80\x02\x1d\xea\xc8\x28\x4a\x75\x04\xd4\x4b\x58\xd0\x81\x8e\x28\x60\x51\x07\x3a\x59\xd1\x50\x93\x92\x3b\x7a\x7a\x00\x1d\x95\x56\xa5\xcd\x66\x41\x49\x71\xaa\x23\xf0\x08\xc5\x83\x6c\x64\xab\xd2\xc0\x2c\x9f\xe8\x51\x13\xa0\xa0\xfe\x42\x78\xee\x07\xd4\xb1\xcf\x6f\xf1\x90\x48\x4c\xba\x05\xd4\x62\xe8\xc7\xc0\x1c\x8a\xef\x7d\xee\xa0\xee\x4d\x83\x12\xc8\x88\xf2\x33\xfb\x57\x16\x94\x9e\x76\x83\xa4\x96\x42\x69\xd1\x5c\x66\xe2\x66\xc8\x55\xee\x41\x3e\x8b\x7a\x02\x48\x76\x04\x69\x2a\x33\x8b\x1c\xe8\x6f\xcb\xf7\x7b\xef\xcf\x3a\x5e\xd1\x17\x05\xf9\xac\xaa\x7f\x50\x90\xff\xde\xdf\xea\x79\xee\xdd\xa6\xfc\x7f\xab\xf7\x5f\x1a\xe8\xc3\xaa\xb6\x4c\x09\xfa\xbf\x9f\x1a\x65\x0f\x82\x3e\xec\x0c\x79\xd8\xfe\x22\x02\xb1\x5b\x6e\x3b\x71\x70\xd0\x5f\xbf\x47\xfd\x33\x08\x46\x51\x68\xc6\x50\xf2\x7f\x32\x05\x6a\xdf\x20\x5a\xeb\x31\x78\xd5\xd0\xc8\xca\xb6\xfa\x61\x59\x49\x25\x62\x59\xbe\x27\x10\x1a\xd1\xc8\xf6\x62\x9f\x40\x0b\xa8\x2b\x40\x2d\x25\x81\xba\x1c\xd4\x7d\x41\x0d\xd7\x59\x79\x4e\xa8\x55\xcb\x0f\xb2\x52\x2e\xbd\x61\x26\x3e\x3c\x1b\x43\x98\xb5\x71\xe5\x55\x9b\xf9\xcd\x55\x8a\x93\x91\x8f\xbf\x83\x4f\x32\xaa\x2f\x31\x02\x27\x2d\x98\x85\xe1\xbc\xd4\x4d\x76\x81\x12\x9e\xfe\x10\x68\x06\x78\x50\x2e\x7c\xe3\x0f\x3e\xf9\xd0\x31\xe3\x49\xb8\x43\xf9\x7c\xa4\xd6\x7b\xd2\xd3\x46\xab\x96\xa7\x50\x9c\x2a\x67\xe9\xf6\xd5\xfb\x93\x39\x2d\x86\x4d\xa3\x54\x5f\x6a\x43\x7f\x25\x41\x43\xc1\x69\x4a\xb5\x1c\x32\x58\xd5\x97\x69\xb9\xb9\x29\xc9\x1a\x7f\x06\xa9\xca\x81\xd7\xd8\x8a\x12\x87\x93\x87\x5a\x56\xb5\x1c\x9e\xa7\x54\x5f\x36\xba\xaa\x9a\x5a\x34\x7f\x72\xfc\xd8\xbb\x95\xd2\x28\x50\x97\x01\xfd\x77\x9e\xf7\x7a\xdc\xd2\x6e\x1a\x1f\x35\xe2\xa0\x65\xa8\x9c\xaf\x84\x99\x24\x90\xa7\xe1\xf1\x63\x10\xe6\x52\xa2\x8e\x94\xc6\x85\xe2\xa3\x16\x1c\xb0\x00\xa9\x59\x4a\x98\x43\xc2\x43\xef\xc3\xd0\xb3\xd0\xd7\xa1\xc4\x45\xa4\xc7\xed\x5b\xf3\xd7\xfd\xc6\x6d\x72\xb8\x12\x79\x98\x4d\xe6\x94\xe6\xd8\x73\x1c\xca\xd3\x48\xe2\xa3\xa7\x70\x44\x7e\xbe\x60\x66\x60\x0b\x59\x5c\x5b\x63\xab\x61\x60\xc4\x0f\xf3\xe7\x00\xc9\x57\xe6\x57\x5a\x2a\x0b\x94\xa8\x27\x41\xb3\x1a\xc6\x5c\xbc\x7d\x44\x89\xaf\x91\xd2\xf3\xa1\xa3\x16\xe2\x98\xc9\xa8\xd9\xaf\x84\x85\x64\xfe\xb6\xed\x45\xad\x70\x87\x52\xf5\xc5\x39\xf2\xa8\x40\x0f\x9d\x42\xfd\x6d\x40\xe4\xe1\x50\xbd\x0a\x1a\x4a\x65\x84\xd3\x14\x64\xb0\x7f\x0d\xc7\x9f\x83\xa1\x7a\x55\x1e\x8e\x37\xe1\x79\xea\xc1\x60\xc8\xf2\x2f\xb8\x52\x4b\x6c\x0d\x91\xae\x4b\xc7\x8f\x52\xde\x2e\xdf\xb2\xb9\x6c\x8f\x6e\x34\xe5\xd5\xc1\x70\x16\x86\xe1\x43\x5a\xc5\xd2\xe0\x23\x5a\x72\x48\x88\xe4\x07\x96\xbe\x2b\x6b\x35\x6c\xb8\xac\x03\xdd\x65\x23\x16\x1d\x07\x82\x8a\xf0\xad\xf7\xad\xbf\xcd\x46\x48\xeb\x7d\xeb\x7f\x67\x8f\x1f\x57\x48\x37\xbd\x27\x68\x7b\xad\xb1\x2e\xc3\x3e\xb3\x36\x3c\xd3\x9e\x6e\xb4\x64\xf8\xfe\xa1\xf5\xfe\x1e\x6e\xc9\x70\xa6\xd7\x5a\x3e\xc8\x08\xaf\xb1\xd4\x39\xed\xb5\xd2\x3f\xb4\x8a\x7f\x86\x7b\x06\xfb\xf9\xa3\x7f\x83\xd8\xd4\x6b\x15\xaf\xc2\x86\x10\x8f\x5a\x5a\x4c\xfb\xfa\x4b\xfd\x61\x0c\x1b\x21\xf5\x97\x06\x28\x2e\x9d\xa7\x2c\x54\x3b\x0d\x83\xd2\x61\x3d\x8e\x80\xa7\x38\xec\x0b\x34\x2e\x72\xe3\xce\x7a\x25\x54\x9f\xa7\xa0\x94\x84\xf8\x0c\xe0\x16\xde\x18\x79\x07\x43\x3b\xf0\x95\x04\xdc\x6e\xcd\x12\xb3\xab\x2d\x4a\x6b\x49\x89\x50\xc2\x54\xb8\x1c\x2e\x3b\x5f\x56\x09\xa3\xe1\x2c\xac\xd5\x84\x05\xd2\xa1\x36\x4b\x9f\xd2\x8b\x97\x56\xcc\x38\x87\x80\x97\x61\xd2\xec\x5d\x0a\xef\x02\x12\xc6\xe0\xd5\xb6\xd7\x2f\x18\x41\x5a\xa0\x80\x05\x15\xf4\xe1\x43\xd9\x6f\xbe\x2e\xfa\xac\xee\xf0\x40\x2e\xd4\xd6\xec\x8c\xaa\x74\x46\x20\xd3\xd3\xb3\x13\x73\x78\x4c\xf6\x2d\xf1\x59\x5f\x7c\xdd\x94\xbd\xea\xd0\xca\x08\x29\x08\xff\x18\xeb\x2b\x54\xac\x30\xd7\x24\xed\x62\x5c\x55\xa5\xe5\xd5\xbc\x34\x1f\x0c\x81\xbc\xa9\x79\xd5\x55\x05\x2e\x66\x57\xcd\xf6\xc3\x66\x7e\xac\x54\x08\xf7\xe1\x0f\xc5\xdf\xbd\x3d\xd3\xb5\xa1\x2d\x74\xe5\x36\x4b\x5b\x6a\xbd\xb2\x32\xf0\x45\xd6\x68\x2c\xb2\x98\x64\x13\xcc\xaf\x4e\xca\xc9\xde\x54\x96\x10\x91\x50\xb6\x2d\xb5\x8d\x91\xdc\x3e\x37\xb1\xa9\x61\xcb\x4e\x33\x67\xb5\xdb\xad\x76\xa6\xa5\xa9\xb2\xc9\xc5\x7b\xd4\x45\xac\x22\x2c\x12\xbe\x0d\x68\x37\xd2\x29\x10\x69\xe9\x3b\xe9\x3b\x85\xef\x3b\xd2\xaf\x3e\x12\xf8\x4d\x4a\xa7\xfc\x51\x73\x59\xd4\x7b\xbe\x23\x40\x00\x6b\x45\xa5\xd0\x90\x5b\x19\x91\x53\x91\x2a\xe4\xe4\xa2\x15\x85\x70\xff\x77\xa0\x27\x74\x54\x20\x4f\xe7\xf3\x2c\xe8\xfd\xf7\xe0\x10\xeb\xb9\x87\x7a\xa2\x8d\x0d\xa4\xe9\x1c\x27\xab\xd7\xa8\xee\xd6\x86\x9e\xec\x6e\xef\xee\x2b\x74\x0b\xa0\x13\xba\x65\x91\xa2\xeb\x56\x75\x43\x67\x17\x5d\x4b\x59\xa8\xd0\x5a\xca\x13\x08\xc9\x94\x97\x53\x15\xc8\xab\xe9\xc9\x43\x52\x5f\x6a\xe5\x1b\x7c\x77\x3f\x08\x63\x39\x55\xf7\x2e\x6a\xda\x81\x99\xa7\x37\xf0\x45\xb8\xae\xff\x0a\x9c\x35\x7b\x71\xd6\xfc\x8c\x85\x5b\x94\x2a\x90\xf2\xc9\xd3\xbb\x0f\x7c\x70\x59\xa3\xea\x86\x5c\x36\x50\x89\xf3\xbf\x4f\xaa\x60\xee\x86\xb5\x33\xa7\x69\xfa\x7f\x3d\xb6\x8e\xba\xbc\xf6\x83\xb9\xbb\xb9\xed\xe4\x4f\x27\x5a\x60\xcc\x71\x0e\x26\x9f\x02\xf1\x8b\x12\xf0\x2b\x7b\x29\x03\x0e\x95\xba\xd9\x29\x52\x54\x97\xa4\xeb\x82\x6f\x7b\x7d\x29\xe1\xdb\x3f\x4b\xaa\x4c\x83\x14\x0d\x75\x5f\xb0\xf0\xdc\x6a\x1a\xae\xb1\x1c\xba\xc9\x64\x16\xf5\x52\x27\x8c\x65\x55\x06\x83\x36\xf4\x0e\xaa\xe9\xcf\x36\x5d\x99\xff\x2e\x87\xdf\xc2\xb7\x19\xb5\x69\x95\xa9\x15\x11\xe9\x98\x07\xad\xb8\xe3\x81\xe3\xa4\xd4\x87\x8d\x89\x89\xb6\xc5\xec\x8d\xc0\xed\xd0\x8a\x79\xe9\x15\xa9\x95\x69\xb5\x19\x11\xaa\x4c\x03\x7c\x83\x37\x1f\xf8\x25\x7e\x76\xe5\x2f\xa7\xc4\x77\x4f\xb5\x5d\xf9\x4c\xe3\xf3\x7b\x62\x69\xd5\xc3\x41\xb9\x0d\x39\xf5\x19\xb5\xf8\x0d\xdc\x0c\xef\xf5\x84\x9c\x3c\xf5\x2f\x37\x48\xdd\xfc\x4d\x53\x27\x6b\x26\xb7\x4d\x3d\xa5\xe3\xe0\x5b\xfc\xb6\x36\xa3\x3e\xa7\x21\x57\x6e\xb9\x0e\xcc\xd8\x0a\xad\x10\xcf\xb6\x38\xb7\x33\xdb\x5b\x02\x6e\x98\xdb\xb1\x15\xf2\xea\x14\x9e\x47\xc6\xc3\x58\xd6\xd7\x29\x75\xfe\xf7\x9e\xa4\x11\xf0\xdc\x17\x6c\x58\xcf\x7d\x41\xd6\xd8\x74\xe0\x0e\x16\x3c\x6a\x59\x6b\xd3\xc5\x50\xd1\x92\x9b\x80\xc1\xec\x93\x2c\xd7\xe5\x53\x47\x13\xb1\x09\x09\xb1\x3c\xaa\x61\x12\x8b\x6a\xad\x22\x88\x86\x68\x16\x75\x4f\xb1\x20\xc6\x51\x3d\xf7\x1b\x53\x82\xff\x23\xcd\x0e\x91\x44\xe8\x0c\x5c\xd0\x3f\xc5\x42\x3f\x8a\x6f\x83\x0f\xd9\x3d\xb6\xcd\x3b\x63\x19\x74\x13\xb1\x9b\x13\x62\x6d\xfc\x0e\xbf\xa8\x88\xb5\xb5\x25\xec\x61\xe0\x27\xaa\x6d\xe7\x1e\x1b\xbf\xc3\x23\x2a\xc2\x04\x98\x28\x6d\x82\xbe\x31\x30\x09\xba\x61\x48\x5f\xad\x62\x1e\x8c\x41\x02\xfa\xaa\x4e\xab\xb6\xdd\x60\x55\xa7\x61\x0b\x4b\xa8\x3e\xc3\x49\xc0\x92\xc7\x29\xcf\x63\x9e\x6f\x68\xec\x3b\x11\xb3\x88\x2a\x18\x08\x37\x1a\xc0\xac\x81\x88\x21\x37\x70\xf0\xb8\x59\xf1\x1b\x20\x9e\xea\xa8\xdb\xcf\x9c\x7c\x2b\x76\x01\xaf\x3a\x2d\x91\x54\x5a\x71\x36\x57\x92\xa8\x90\x5c\x44\x18\x8a\xd0\x17\xfa\xc1\x44\x78\x19\x86\x40\x1e\x4c\xea\xab\x55\xcc\x7f\xd0\x91\x5b\x25\xdd\x60\x55\x6e\xd8\xc2\xca\xbd\x10\xc7\x29\x8f\x6a\xd1\x5f\x9d\x0c\x92\x3b\xc9\xfb\xab\x93\x8d\x71\x10\x4f\xed\xae\x3b\xd0\xdb\x89\x44\x52\xe9\xb6\x2c\xae\xb4\xb7\x8b\xc0\xba\xdf\xbb\x29\x0b\x05\x14\xed\x17\x09\xf8\x56\x52\x2b\x3c\x22\xe1\x99\xe0\x99\x41\x1f\x4d\x59\xb6\x73\x11\xe3\x17\x89\xf5\xb1\x99\x9b\xb7\xf2\x3d\xea\x1e\x71\xc3\xba\xbc\x37\x1a\x96\x45\x2c\x6b\x3c\x9a\x70\x9c\xf1\x88\xc4\xbe\x3d\x35\x3b\x5a\x78\xaf\xda\x2b\xee\xde\x5f\x7e\x32\xf5\x68\x44\x58\x64\x6d\xca\xf6\x14\x40\x88\xee\x2b\x25\x43\xb4\x2a\xf1\x20\x2b\xbd\x4a\xdf\x9b\xf3\x13\x92\x1c\xaa\x74\xc3\x5f\x66\x62\x37\x36\xb5\xe8\xf9\x84\x5d\xf9\x87\xdf\xd4\x5c\x77\x5d\xaf\xbc\xc6\x15\x3b\xcb\xce\x96\x94\x2a\x8b\x49\xd5\xbe\x7c\x24\x90\x48\x42\x92\x99\xf6\xc2\x8e\xeb\x3c\x3c\x04\x21\xed\x10\xa6\x81\xe0\xb1\x67\x07\xf7\x1f\x3e\x27\xd0\xc6\x4f\xba\x97\x35\xb1\xc9\x1b\xb7\xea\xb9\x84\x8d\x2b\xf2\x57\x31\x13\x26\xb8\x2a\x9f\xe5\x8d\xc5\xb3\xcb\x0a\x4a\x94\xaa\xc4\x1e\x91\xb4\x96\x08\xc5\x56\xae\xb2\xa8\xae\xb0\xbe\xa8\xae\x30\x22\xe7\xda\x75\xc3\x75\xe6\xcd\xc3\x8e\x9d\xbb\xf8\x96\xe6\xa6\x5d\x7b\x2e\x0d\x7f\x17\x54\x1a\x20\x7f\x3a\x73\xef\xd7\xaf\x67\x63\x30\x87\x61\x18\x12\x8f\x0f\x69\x26\x7c\xb2\xf9\xf2\x6f\xbf\x35\x38\x7f\xe5\x6c\x2e\x97\xe0\x62\xec\xa4\xed\xb3\xf8\xab\xff\xd6\x7c\xd2\x76\xfc\x0b\x0e\x1e\x6a\xc7\x10\x08\x63\x20\xf8\xec\xd7\xbf\xf2\x61\xbe\xfb\x9b\xd8\x60\x61\x1f\xa5\x4e\xb4\x50\x1e\x37\x0d\x21\xb2\x4e\xb6\x84\x82\x79\x2c\x07\xea\x1f\xe4\x02\x4c\xa3\xbe\xa4\x50\x94\x44\x1a\xa6\xc1\x51\x0a\xa7\xc1\xfc\xc0\x07\x6e\x9c\x06\x83\x70\x10\x4c\x03\x33\xfb\x60\xa7\x38\x1c\x1e\x0d\x86\x5b\xac\xfa\x19\x68\x91\x6e\xd2\xa6\xbd\xf9\xfb\x0f\x68\x1e\x34\xf2\x7c\xf5\xd4\xd6\x19\xdc\x9d\x3b\x0a\xef\xcf\xd2\xcf\xf4\x5d\x76\xc2\xf5\x70\x20\x28\x2d\x3e\xa9\xc5\x27\xc3\x6f\xb3\xd7\x27\x84\x57\xe6\x34\x08\x95\x95\x50\x06\x65\xe1\x1f\xaf\xfc\x22\xe1\x86\x49\xf9\x25\xf5\x80\x78\x09\xf5\xc2\x4b\xf5\xed\xb3\xb8\xee\x6e\x45\x6e\xc7\x3e\xf3\x7e\x06\xcc\x2c\x0f\x6a\x12\xfc\xe0\x57\xf8\x1e\x85\x70\x1a\xc2\x96\x23\xf5\x2d\x72\x0c\xcc\x0f\x6c\x19\x7b\x82\x3d\xc1\x8a\x30\x5f\x6e\x6f\x4c\xbc\xd7\x0d\xba\x10\xaf\x5b\x72\xd3\x38\x18\xd5\xf8\xaf\xc8\xf1\xdc\xc4\xd7\x26\x2c\x5d\x98\xa8\xd4\x86\x26\x49\x3a\xbf\x9a\x04\x9d\x47\x8c\xa1\x7a\x77\x57\x45\xd2\x37\x41\xfa\x1a\xeb\xb7\x19\xb8\xf2\x02\xb1\x48\x14\xc5\xe2\xf2\x87\x07\x6d\x73\x49\x5f\x43\xbd\x34\x41\x13\x16\x59\x48\x79\x45\x2b\x25\x05\x53\x03\x59\xbc\x6f\x09\x28\x9b\xdd\x7d\xa1\xb3\xbb\x1b\xa2\x50\xdd\xad\xda\x27\x89\x5a\xc5\x94\x04\xca\xab\x6e\xa7\x9d\x05\x62\x9e\x83\xb3\xe7\x9b\x8b\xcd\x4c\x51\x91\x60\x2d\xe4\x7d\xba\x11\x8a\xec\x42\x43\x4e\x96\x06\xdf\x25\xc4\x06\x7b\x63\xb3\xa6\xd7\x0c\x8d\x77\x26\x54\x6f\xe1\x54\xdf\xe3\xb2\x57\x1f\xc7\x37\x2c\xc6\xcc\xf8\xca\x75\xbb\x32\x95\x16\xd1\x59\xe4\x64\x9a\x9b\xe5\xf5\xa4\xd8\x06\x04\x6c\x86\x58\xa6\x1d\x43\x08\xec\xb7\xe6\x09\x0c\xc3\x81\x1a\x7f\x27\x4c\x62\x3d\x9d\x24\x3c\x85\x0f\x01\x8d\x43\xda\xb8\xbb\x20\x92\x59\xae\x9c\xaa\x42\x4e\xd2\x8d\x50\xfc\x05\xbe\x6a\x77\xf0\xaa\x7d\xe5\x8e\x52\xd1\x29\x8b\x63\xbd\x96\x58\x19\xdc\xae\x25\x56\x86\x68\x15\x8d\x5e\x37\x5d\x1b\xd8\x35\xa7\xeb\x32\xab\xd2\xf1\x0e\xce\x9b\x88\xc5\x58\xc2\xcd\x9d\x33\x7b\xc6\xeb\xd3\x7c\x7d\x52\xc3\x8d\x56\x63\x7e\xbe\x09\xf5\x3e\x75\xb8\x39\xb7\x38\xd3\x69\xe8\x8a\x0e\xef\xcd\xd5\x53\x52\x22\xd8\x4a\x78\xd8\x79\x03\x3a\xb0\x63\x1c\xee\x2c\x34\x94\xe4\x96\x9b\x22\xba\xa2\x15\x40\xb0\x0e\xbb\xad\xc4\xce\x4b\x6a\xd0\x8b\x0e\x87\xd3\xe6\x8c\x68\x90\xfa\x5c\x3e\x77\xe1\xec\x99\xd3\x11\x60\x04\xd3\x77\x90\x04\x37\x7a\x61\x85\x67\xc2\x17\x7d\x05\x2d\xf1\x05\x7e\x0e\x9f\xab\x6e\x68\x89\x8f\x3d\xa5\xf4\x0e\x08\x4f\x80\x88\x89\xff\x51\xfe\x67\x12\xf6\x79\x0f\x19\x46\x8b\xa1\x04\x3c\x81\x5f\xc0\x25\x16\x0e\x10\xf2\xdf\xe7\x88\xbd\x6d\xb9\x29\xb5\x7c\x5d\x8a\x3d\x3e\x2f\x16\x5f\xf6\xbb\xc3\xe1\x1b\x42\x75\x09\x9e\xf1\x94\x06\x52\x33\x94\x78\x1b\xa1\xe4\x5b\xca\xdb\x1f\xfa\xd3\xb0\x9e\xf2\x2d\x96\x16\x87\xc3\x18\x56\x0a\x1c\x63\xd8\xbb\x83\xc3\xe1\x25\x0a\xcf\xe1\xb9\x70\x38\x87\xe7\xe0\x25\x2a\x42\x6a\x92\xfa\x07\xa2\x11\xff\xa4\xf5\xac\xea\xa5\x1d\x7c\x57\xa6\x84\x73\x70\x2e\x1c\xcf\xc1\x39\x59\x17\xba\x7b\x17\x62\xd8\x08\x69\xb1\x6f\x71\x80\x32\xf8\x48\x6f\x4a\x87\x00\x61\x88\x36\xb4\x58\x0a\x10\x62\x2f\x09\x9e\x83\xf5\x54\xc4\xe0\xbb\x01\x25\x6a\xb1\xb4\xf8\xef\xa4\xd0\x04\xfd\xff\x4e\xeb\x39\x05\xc6\xbf\xf3\x7b\xf7\xae\xcc\x2d\xf4\xf2\x09\xe7\x64\xd2\xbb\x83\x7b\x09\x17\xca\xcc\xde\x97\x0c\x37\xe1\x65\x98\x01\x53\xe1\x2d\x38\xc0\x7a\x7b\xbc\xcf\xd3\xfe\x71\x44\x35\xce\x50\x78\xc2\x89\x45\xbe\x4e\xc4\xa1\x0a\x6b\x01\x89\x3d\xbf\x24\xc3\x2e\x05\x4c\x25\x2a\x31\x12\x16\xbe\x01\x8b\x4e\x36\x41\x9a\xc2\x27\x11\x4b\xa5\x5d\x0a\xaf\x92\xd0\xa2\x05\xde\xa2\x41\xad\xf5\xae\x96\x2e\xe3\x38\xe9\x2a\x8c\x03\xb5\x56\x51\xaf\x08\x6b\xf4\x84\xc0\x71\x98\x07\xc7\x83\x2b\xb4\xc4\xf7\x21\xb0\x03\x86\x53\xb3\xf1\xb8\x42\x1b\x7a\x84\x58\x87\xf3\x14\x5a\x9c\x4e\xcc\x79\x50\x9e\x8e\xdf\xf9\x32\x70\xac\xef\x59\x18\xbb\x13\x1e\x57\xe0\x71\x62\x1a\x4a\x9e\x59\xd8\xe0\x39\x02\x0d\x50\xaf\x55\x8c\x55\x84\x35\x4a\xc1\xb2\xb5\x2a\x9b\x8e\x43\x25\x83\x6c\x49\x8a\xd1\xa0\x93\x0c\x30\x54\xf5\xbe\x57\xa7\x55\x04\x25\x50\x1e\x77\x8f\xac\x1d\xdd\x23\xfe\x9e\xfc\xf7\x97\xc7\xc3\x47\xe3\x23\xf8\xc2\x18\x5c\x9c\xa8\xf4\x30\xa0\x23\xa3\x58\xb8\x4a\xa1\x0e\xc6\x13\x9f\x1e\x3e\x71\xfd\x47\xd8\x41\xad\xa6\x46\x9e\x98\xf0\xe9\x0a\x0e\xc7\x93\xaa\xab\xa8\x1b\x4b\xa1\x9a\x54\xbd\xff\x34\x05\x3a\x3f\x43\xe0\xe2\x56\x7c\xe1\xe6\x68\x78\xe4\x97\x5f\xc2\x45\x67\x49\xa5\xa5\x42\x59\x61\xc9\x2d\xcf\x61\xf0\x1e\xa1\x72\x3f\xce\xe2\x3d\x32\xa7\x3c\xb7\xc2\xc2\x59\x4b\x4b\xad\xa5\x01\x70\xe3\xef\xbf\x57\xe0\x1c\x18\x0d\x7b\xf0\x11\xf8\x80\x81\x0f\x02\x49\x38\xe7\xc0\x68\xfe\xfb\x27\x15\xf9\x65\xe5\xb0\x93\x52\xfd\x58\x61\x2f\xaf\xa8\xd4\x84\x05\xd2\xc4\x2a\xa6\xfc\x2d\x4d\xac\xb7\xd3\x23\xd2\x7e\x3d\xb8\x89\x6b\xec\xd3\x54\x17\x31\x85\x85\x41\x2c\x8f\xee\xf8\x07\xb0\x1c\x61\x90\xc7\x7a\x44\x98\x40\xc1\xe7\x54\x88\x57\xf4\xa8\xd7\xc9\x46\x5e\x2e\x25\x5b\x7a\x81\x54\x4c\x7f\x4f\x6d\x04\xea\x7e\xab\x28\x98\x2f\x8b\xe7\x61\xf2\x63\x17\x25\x35\x1c\x60\x25\xb5\xa7\x93\x5e\x11\xe8\xee\xbf\x87\x30\xad\xd7\x29\xd1\xac\x14\xc8\x7c\x2b\x5f\xf6\xe8\x42\x1f\xfc\x09\x3b\xc0\x7a\xb7\xc2\x9b\xc1\x02\x88\xf2\x31\x04\xae\x53\xd3\x59\xf8\xed\x09\xda\x66\x2a\x30\xe5\xc3\x47\x54\x65\xad\x95\xcf\x82\x55\x38\x01\x26\xe0\xaa\x6a\x65\x86\x2d\x07\x2e\xb2\x0e\xb1\x54\xb4\xc2\x87\x19\x60\x45\x6b\x2d\x7e\xa8\x94\xd4\x56\xda\x66\x2a\xcc\x33\xc3\x47\x54\x95\x4c\x20\x8d\xc1\xdb\x70\xdb\x37\x46\x26\xc8\x86\x8b\x6c\x59\x59\x89\xd3\x2a\xd5\x66\x48\x13\x7c\x13\x6a\x7d\xb5\x4a\x78\xd3\x3b\x2f\x92\x5d\xf7\xff\x8e\x92\x2f\xa9\xfd\x5d\xb4\xaf\x13\xdd\x8a\x7c\xa3\xa1\xd0\xc0\x18\x0c\x25\x76\x23\x9f\x5a\x91\xdb\xd8\xac\xf1\xa8\xc9\xe6\x8a\xc6\x86\x0a\xae\xc1\xb5\x4d\xa8\xcf\x95\x3a\xd1\x1d\xde\x60\xa8\x48\xd1\x6b\xf4\xb9\x29\xa9\x06\x2e\xac\x11\x57\x68\x09\x27\xbe\x09\x6f\xf6\x3d\x05\x9d\xd8\xf9\xa0\xa0\xb2\x7b\x45\xef\x25\xda\x77\xc9\x77\x09\x2e\xe1\x25\xe9\x92\x74\x49\xe1\x6b\xf1\x8f\xa0\x81\x63\x03\xc1\xb9\xf2\x94\xec\x91\x7a\x5a\x5a\xde\x14\x5a\xb6\x46\x04\x72\xfa\xcb\x93\xab\xa5\x9e\x3e\x76\x4c\xb8\xbe\xf8\x38\xf6\x85\xc7\xc2\xa7\x4c\xc1\x30\x61\xca\xd5\x29\x57\x05\x08\xbb\x7a\x55\xa9\x6a\xc4\xc7\xe0\xb1\x45\xc7\x27\x08\x8b\x17\x45\xa8\x62\x7b\xf8\x1e\x6e\xd1\x22\x61\xc2\xf1\xc5\x11\xf0\x18\xf6\xbd\x7a\x15\xc2\x84\xab\x53\x22\xae\x4e\x11\x30\x6c\xca\x14\xe8\x8b\x7d\xc3\x8f\x2d\xbe\x2e\x1c\x3f\xe6\xe5\xbd\x91\xe1\x61\x8b\x59\x10\xbd\x62\x00\x55\x18\x0c\x54\x8f\x9a\x80\xf3\xac\x57\x4d\x3c\xd8\x66\xc7\xfb\xa0\x0f\xb8\xa3\xca\x0b\x8c\xfa\x86\x85\xf2\xe8\xe7\xb2\x7e\xf7\x68\xca\xe3\x86\xcb\x94\x4f\x4d\xe7\x04\x30\x94\x02\x78\x4a\xbd\xfb\xd0\xc3\x29\xbf\x7b\x0e\x1b\x16\xc8\xbf\x15\x0c\xd7\xa9\x10\x6f\x89\x77\x02\xed\x6a\x2a\x68\xcd\xac\x47\xb7\xa4\x0e\xdf\xba\x73\x91\xb0\x35\x01\xdd\x3e\x75\x78\x66\x5a\x61\xa2\x33\x59\xa9\x77\x35\x65\x6f\x63\x40\xe7\x57\xa3\x9b\x30\x19\x0b\xcc\xf9\x3c\x46\xa1\x2e\xcf\x68\xcd\xb1\xe7\x46\x18\xec\x15\xe6\x0a\xc6\xa3\x1b\xcf\x7a\xee\x81\x8e\xdc\xd6\x54\xd5\xec\xe2\xc3\xfc\xb9\x32\xd3\x81\x0e\xda\xe1\x43\x36\x37\x37\xcf\x60\xe1\x2d\x06\x5b\x76\xb9\x09\xa2\x50\x17\xde\x9b\x73\x1e\xdc\x7e\x35\xea\x88\x2d\xc9\x59\xc9\x06\xde\xa8\x2f\x49\xac\x49\x03\xb9\xe3\x5e\xac\x41\x90\xd9\xa9\xa9\x2f\x6d\x35\x34\x2b\x9b\x0c\xc9\xd5\x5b\x18\xd4\x79\x7e\x23\xea\xb2\xab\xd3\x39\x79\x5c\x12\xbc\x37\x20\x21\xc4\xf3\x42\xaf\x08\x44\x2f\x78\xff\x26\x02\x63\x30\x26\x5c\x8a\x91\x62\xfe\x26\x02\x8d\xd0\x14\xc9\xa2\x5a\x0a\x61\xdf\xf3\x88\x50\x1b\x2c\xfc\xf9\x2b\x44\x1a\x2a\x4d\xa1\x17\x2c\x50\xcc\xeb\x1e\xf1\x1e\x79\xe2\x84\x02\xaa\xa5\x03\xb4\xb9\x3c\xbb\xc8\x64\xc2\xc3\x78\x38\xdc\x64\x2a\xca\x2e\x37\x97\xe5\x55\x15\x8b\x22\x1c\x86\xc3\xe1\xa2\x58\x5c\x95\x57\xa6\xc4\x56\xff\xcb\x34\x76\x42\x27\x21\x75\x4a\x9d\x81\xcc\x74\x5d\x5d\x81\x13\xdf\x7d\xb7\x6f\xdf\x07\xc2\xbe\xf5\x11\x30\x12\x47\xee\x5b\x2f\xcc\x5c\xbf\x3e\x02\x8e\xc0\x11\x99\x01\xd8\xe3\xcd\x08\xb8\xdd\x05\x8e\xbd\x2e\x07\x49\x99\x7a\xbd\x91\x2b\xcc\x33\x15\xe5\x31\x19\x99\x8e\xca\x5c\x1e\x8e\x52\xbe\x5d\xbe\x5d\x7f\x5b\x0b\x76\x49\xbb\xe0\x28\x95\x56\x67\xd9\xe1\x6c\x89\x68\x76\x36\xd7\x6c\x67\x24\x7d\x35\xe5\xd3\x93\x20\x4a\x62\xa0\xe5\x28\x59\x95\x89\x0a\xcc\xd7\x7b\x10\x15\xe2\x35\x4a\xd3\xe9\xde\xb4\x3f\x79\xa6\xe2\x12\x33\xbf\xd5\x99\xd9\xbc\x5d\x03\x51\x24\xbe\xde\x7f\xd3\xcb\xb3\xf8\x17\x27\xa4\xe1\xf0\x36\xcc\x2f\xce\xce\xcb\xce\xb1\x28\x8b\x0a\x2c\xd6\x02\xc6\x64\x2a\x2d\x37\xf3\xf9\xe5\x38\x16\x16\xc0\x32\x0d\x08\x17\xe0\xba\x74\x99\x83\x28\x72\x7b\x4d\x73\x8b\x93\x6b\x76\xee\xb0\xd4\xa5\xc1\x3d\xbc\x27\x2f\x8a\x4a\x98\x0e\x5f\x47\xb2\x69\x2c\x74\xf6\x7e\x58\x84\xce\xc0\xfe\xb2\xa4\xa3\x41\x24\x41\x44\xb5\x02\xd4\xd2\x1a\xda\x27\xa2\xa8\xf0\x1d\x20\xe1\x3a\xa5\x80\x4e\x18\x48\x0f\xa4\xf2\x58\x6d\x68\xba\xe7\x2e\xdd\x64\x48\xae\xdc\xca\xf8\xd5\xc4\xd6\xe4\x9c\x64\x03\x6f\x48\x29\x4e\xaa\x92\x5f\x04\x5d\x78\x46\x45\xbd\xb1\x91\x69\xac\x77\xd6\x06\xb0\xab\x75\x55\xf5\xc5\xdb\x0d\x8d\x11\xc0\xf8\xe7\xbc\xce\x06\xc8\xa5\xf1\xb4\xab\xb1\x68\x7b\xb6\xfc\xf2\xea\xc2\x6b\x73\xd3\x9c\x29\x4c\x4a\x9a\x31\x23\x80\xa8\xad\xcb\x4e\x2b\x4a\x72\xa5\x44\x24\xbb\x9a\x72\x5a\x18\x8f\x9a\xe8\xb5\xb8\x81\xc1\x0a\x99\xdc\xeb\xf6\xa8\xe9\x46\x63\x7d\x46\x05\xe7\xd3\x81\x3b\xad\x2a\xa9\x38\xc5\x10\x91\x6c\xc8\x49\xde\xaa\xf1\xab\xc9\xad\x95\xc9\x4d\x06\xae\xd1\xb0\xbd\xb8\xbe\x4a\xd2\x81\x3b\xbc\xb6\xc2\x59\xdf\xa8\x01\x9d\x4f\x4f\x3f\x4b\xf5\xe8\x46\xb2\x5e\xdd\x12\xd6\xab\x0b\xb8\x77\x6f\x65\xe5\x29\x95\x06\x65\xf0\xd2\x3d\x78\x19\xcc\x90\x12\xfc\x33\x94\x86\x78\xd7\x42\x3a\x5d\x54\x6e\x29\xcf\xb3\xe7\x95\x1a\x6d\x79\x85\x4a\xeb\xb4\xad\x51\x0c\x4e\xc6\x41\xff\x81\x51\xd1\xbc\xf4\x2f\xa2\xba\xd2\x55\x5d\xc2\xb7\x40\x68\xb1\x58\xe4\xcc\x2f\x8f\x28\xcb\x37\xd9\x8d\x8c\x6f\x05\x51\x74\xc0\xda\x51\xd2\xae\x94\xb2\x88\x9a\x07\x55\x88\x62\xb1\xd0\x99\x5f\x16\x51\x9e\x6f\x2a\x35\x32\xbe\x58\x02\x86\x5d\x84\xfe\xb7\x61\xd2\xe5\x8f\x32\x6c\x4c\xad\xa5\xd6\x59\x5a\x7b\x08\xc6\x84\x17\x97\x5b\xc5\x82\x32\x4b\x99\xd9\x91\x57\xac\xb4\x15\x8c\x6d\x1a\xc8\xe0\x09\x14\x71\x16\xee\x7e\x9a\x1f\x36\x94\x42\x62\x10\x7b\x91\x28\x8a\x15\xd6\xd9\xe2\x95\x33\xe0\x20\x85\x8a\xde\xf0\x8b\x1f\x09\x7c\xeb\x2b\x28\xc5\xd9\x70\x9e\x81\x87\xbf\x6f\xb7\x95\xf2\xd5\x76\xb1\xa6\xa0\x46\x19\x90\x18\x1b\x70\x03\x24\x48\x7d\x60\x81\x44\x43\x66\x5f\xa0\xa1\x54\x7a\x1a\x52\x54\x59\x5e\xbb\x34\x70\x2e\x8b\xe3\x08\xd5\xb1\xc7\x59\x9c\xe1\x7b\x9a\x54\x65\x49\x7d\xe0\x0c\x39\x8e\x82\x7f\xcd\x63\xf1\x0c\xc4\x13\x77\x3f\xfd\x08\x14\x77\xbe\x9e\x6e\xb5\x71\x0e\x8b\x58\x58\x6e\x13\x6d\x65\xa5\x8e\xb2\x5f\x41\x15\xee\xac\xb4\xd6\xe7\xba\x94\xf6\x7c\xa4\xe1\x61\x5c\xca\x60\x19\xbe\x86\x13\x30\x8d\xc7\xad\x23\xc9\xc7\x59\xfc\xd7\x20\xf6\x47\x9f\x6a\xb8\xcc\xe7\xf0\x41\xac\x77\x36\x0c\x67\xfd\xb9\xc0\x53\x1f\x41\xd9\xcf\xb0\xe4\x1e\x38\x42\xbc\xeb\xe1\x37\x1a\xf2\x71\xed\x35\x7c\xed\x32\x87\x03\xde\xc5\xb0\xb7\x7e\xd7\xdc\xbe\xf9\x21\xa8\x60\x38\x3c\x12\x69\xb5\x71\xe5\xf9\x62\xa1\xb3\xd8\x69\x2b\x77\xd8\xc5\x6b\x30\x24\xbc\xac\xa2\xa8\xda\xe8\x2a\x28\xc5\x20\x78\x08\x57\x34\x2b\x61\xda\x3c\x16\x19\x22\x23\x2b\x3b\x9d\xc7\x57\x48\x5c\xb7\x06\x07\xe1\x48\x7c\x4d\x83\xa5\xa0\x1f\x0d\xaf\x4c\xe3\x80\x99\x0f\xd4\xd2\x11\x1a\x54\xf4\x5f\x30\x0c\x5f\xc2\x48\xd0\xd8\x8a\xb8\xfc\x32\x53\x89\xc9\xda\x9b\x28\x7f\x10\x32\xe1\xa6\x5c\x5b\x86\x33\xd7\x9e\x0f\x6a\x8c\x84\x9c\x0d\x4a\x9c\x4a\xa6\x57\x67\xd7\x72\xc0\x8c\x67\x61\x2a\x09\xb1\x7b\x60\x08\x8c\x85\x95\x9a\x30\xbf\xbf\x31\xc5\xfb\x0c\x3c\x0b\x83\xe0\xd9\x60\xc1\xdb\x2f\xc4\xdb\xcf\xfb\xce\x5c\x16\x9f\x27\x0c\xef\xa6\xbc\x1d\xdf\xa9\x84\xec\xf1\xec\xdd\x79\xac\xdf\x3d\x94\xc2\x88\xde\x07\x04\x83\x09\x88\xbc\xb5\x6e\xca\x7e\xde\x37\x7a\x28\x35\x78\x10\x2b\x3d\x4f\x60\x70\x02\x3e\x34\x1b\xa7\x31\x18\x2a\x0f\x91\x8a\x7c\xe0\x04\x35\x07\x97\xc1\x50\x7c\x09\xc6\xe2\x7c\x65\x9e\x43\x2c\x70\x32\xb0\x80\xa8\x74\x95\xb9\xec\xbc\xc3\x55\x54\x95\x27\xe2\x08\x98\x89\x63\x40\x87\xc3\x60\x0c\xa4\xb6\xc2\xe3\xf0\xd8\x2e\xd0\x29\x61\x92\x3c\xc0\x59\x8d\x29\xd0\x03\x13\x6f\xc0\xa4\x60\x69\x20\x18\x42\xa4\x5f\xfa\xd5\x56\xdb\x58\xf8\x12\x0e\x91\xe3\xa8\x5f\xe7\xb1\x78\xe8\x06\x1c\x1a\xcf\xfe\x46\xf6\xa6\xfb\x8f\x27\xe0\x82\xf4\xa9\xdd\x29\x54\xe4\x8b\x11\xce\x7c\xa3\xc3\xc0\xe0\x3c\x22\x37\xd7\x9c\x6b\xe1\x71\x9e\xef\x99\xb4\x15\xc9\xab\x32\x56\x46\x64\xee\xcf\x3c\xb8\xf5\x2d\x8c\x97\x9e\x0b\x77\xe5\x1b\xca\x72\x19\x7c\x83\x30\x18\xf2\x8d\xf9\xbc\xc5\x28\xe4\xda\x8d\xf0\x89\xef\x6a\x38\x6e\x80\x83\xd4\xc0\x41\x2c\x74\x8e\x83\x50\x6a\x90\xfc\x03\xbf\x84\x43\x2c\x4c\x21\xc2\x7c\xb9\x8d\x29\xa0\x07\x1d\x50\x10\x27\xe9\x20\x2e\x18\x44\xc8\x94\x4e\x82\x31\xc4\xbb\xc3\xbb\x82\x46\xcd\xc8\xd1\xd8\x9f\x93\xa5\x01\x21\x80\x9b\x84\xfe\x3f\x8e\x46\x0d\x0f\xc6\x7e\xe0\xc4\x59\xf0\x0a\x36\x70\x82\x6f\x2f\xf9\x38\xeb\xff\x07\x7c\xc1\xe2\xb0\x41\x2c\xe8\x91\x42\xfd\x50\x0a\xd5\x81\xdf\x3a\xb9\x9f\x89\xe3\x59\xd0\x49\xc5\xf2\xfb\xab\x9e\xc7\xfa\x8a\x81\x82\xef\x09\x68\x80\x59\xf0\x0a\x38\x79\xd9\x12\xf1\xa8\xe1\x33\x56\x4b\x06\x85\x48\x2e\xf8\x81\x2e\xb2\x16\x16\x69\xac\xc5\x42\xb1\xb5\x78\x0a\x9c\x0c\x87\x31\xc4\x1e\x50\xd3\x98\x4c\xc4\x83\x5a\x01\x47\x08\x18\x8d\x6a\xba\x03\xd4\x8a\x8f\x89\x3d\xb2\x40\xfc\xd0\x37\x85\x2e\xb2\x16\x3d\xa0\x29\x79\x16\x4e\x84\xc3\x38\x62\xb7\x4c\x93\x41\xc4\xc9\x34\xc7\x09\xe9\x11\x94\xb5\xda\xe9\x84\x4c\x07\x83\xe3\x58\x0c\x21\x6e\xc3\x4f\x25\x62\x91\x2b\x20\x25\x8c\x76\x23\x83\x2c\x91\x95\x63\xcc\x2e\xe4\x9f\x44\x9f\xc2\x17\x4c\x0c\x03\x9f\xa2\xaa\x20\xd7\x99\xc5\x60\x5f\x22\x3b\xc7\x98\x5d\xc0\x0f\x47\x9f\x02\x91\x18\x2d\x5f\x29\xcc\x91\xaf\xb0\x84\xd1\x68\x31\xe7\xf3\xf9\x79\x45\xc6\x12\xe3\xb7\xf8\x53\x38\x06\x8f\xa6\x60\x00\xb1\x1b\xd5\x0a\x9c\x3a\x9a\x82\xb5\x04\x44\xf9\x7c\x8a\xec\x92\x4a\x63\x15\x03\x63\x88\xea\x00\xc6\x36\x4c\x94\x7c\x0a\x58\x47\xc0\xb3\xf2\xb5\xd2\x07\xd7\xaa\x2a\x03\xd7\x9e\x91\xaf\xc5\xc1\x70\xd6\x97\x6b\x81\xd7\xf1\x55\x88\x86\x5b\xf0\x24\x9c\x83\x57\xf1\x79\x18\xdf\x17\x44\xa8\xc7\xd1\xf0\x24\x84\xc1\x93\xaa\x68\x6d\x68\xa9\x57\x4d\x67\xc0\xab\x38\xfa\x7d\x5c\x5c\xab\x04\x3b\x3e\x49\xaa\xe6\x61\x11\xb9\x66\xb5\xd5\xba\x9a\x07\x41\x2e\x47\xa3\x9d\xb4\x6e\xd8\x20\x6c\x64\x04\x12\x63\x6d\x0a\xd5\x4c\x7c\x86\x04\x45\x71\x51\x91\xa0\xf9\xb0\x21\x26\xde\xc1\xe3\x41\xb2\xd4\x21\x58\x1d\xbc\x25\x5f\xb0\x30\xbe\x21\x64\x6a\x61\xee\xc6\x95\x8c\x50\x5c\x84\x8a\x62\x6e\x23\x46\x2b\x54\xd1\xb0\x94\xd8\xb7\xd7\xba\x97\xc1\x72\x52\x25\xc0\x93\x60\x27\xac\x6f\x76\x0a\x07\x18\x2c\x25\x55\xd1\xf0\x24\x94\x13\xe0\xaa\x82\x57\xce\x37\x43\x41\x1d\x2c\x78\xea\x1b\x1c\xb2\x47\xa9\x7a\xf3\xe6\x91\xf7\xbe\xc8\x81\x08\x25\xc6\xfb\xde\xa4\x71\x1e\x7e\xde\x34\x90\x83\xdb\xe4\x6f\xf0\xf9\x4e\x5c\xcc\x4f\x93\x12\x69\x7c\x01\xb7\x35\x44\x71\x70\x8e\xfc\x06\xb6\xb5\xe2\x0c\x3e\x0c\x45\x2d\x19\xf4\x2d\xe5\x15\xbd\x22\x2d\x6d\x24\x4c\x55\xa6\x0a\xa3\xd3\x37\x52\x1a\x19\x6e\x74\xe6\x8a\xd9\xa2\x12\xd5\x3e\x1b\x2d\x75\xfa\x1f\xa0\xde\x6a\x3d\x27\x75\xac\xb7\xd3\x27\x17\x0f\x9d\xe4\xc3\x7a\x1d\x5f\xe4\xd7\x8a\x08\x52\xdf\xd0\x2a\x8e\x79\x8f\xd0\x32\x79\x2f\x75\x84\x6f\xa3\xb4\x91\xec\x6d\x54\xe9\x4b\xc4\x67\x02\x49\x99\xf8\xff\xd5\x1c\xe9\x53\xfb\xf5\xb4\x8b\x02\x5d\xe8\x83\x3f\x61\x91\x28\x02\x21\xed\x03\x02\xc4\xdf\x61\x10\x3c\x04\xfb\xa1\x0f\x8c\x60\xbd\x3e\xd0\xb0\x3d\xb5\xc3\x58\x55\x8f\x01\xd6\xb3\x9e\xcf\xf0\x9f\xf0\x1b\x5b\x64\xe2\xb3\x8b\x14\xc5\xa4\xcb\x05\xcb\x58\xc8\x22\xe1\x51\xea\x5b\x6f\x0f\x64\x50\x84\xca\x3f\x05\x96\x06\x5a\xfb\x6f\x2b\x7f\x36\x3c\x82\xfd\x0d\x34\x6c\xde\x9f\x6d\x79\x47\xa3\x15\x32\x28\x58\x4a\x3d\xad\x0d\xfd\x01\x7e\x63\xad\x26\x3e\xbb\x50\x51\x42\xba\x9c\xb0\x8c\x25\xe5\x96\xb2\x08\x78\x94\x0a\x83\x11\x94\x47\xdf\x3d\x8c\x95\x69\x3a\x51\x2d\x2b\xaf\xcf\xb0\x1e\x37\xd4\xb1\x7e\xf5\x33\xac\x47\x0d\x75\xac\x4f\xf7\x8c\x6c\x00\xd6\xb1\x28\x3e\xc3\x82\x08\xc3\x59\x18\x41\x69\x43\x4f\xc6\xcf\x7d\x70\x66\x3c\xeb\xd3\x83\x3b\xd0\x86\x27\x4a\x52\xcf\x7d\x40\x21\x4f\x61\x8f\x6e\xee\x83\x86\xfe\x2a\xf5\xb6\x3f\x9c\x45\x51\x52\x52\x01\xfe\xe3\x52\x21\x89\x82\xad\xb0\x81\x42\x55\x6f\x2b\xa6\x4b\xf5\xec\x26\xcf\xaa\xab\x54\x98\x3c\x72\xde\x01\x72\xcd\x24\x4a\x1b\xfa\x15\x6c\xa0\xb4\x68\xec\xad\xb4\x16\x4d\x57\xa9\x36\xad\x62\x7b\x3d\x1b\x16\x29\xec\x62\x21\x2a\x44\x0a\x61\xe9\x98\x84\xcd\xb1\x31\x9b\x77\xec\xdd\xb3\x63\xe7\x5e\x78\x85\xe5\x20\x0a\xe6\xb2\xd8\x39\x96\xf2\xab\x9f\x62\xa1\x73\x14\x15\x00\x61\xa6\x7f\x1b\x73\x73\x20\x87\x6d\x44\x79\xbb\xd3\xe9\x6a\x52\xb6\x9e\xd8\x79\xe6\xba\xe6\x33\x01\xa6\xa3\x1e\xfe\x45\x71\x2b\x57\xe5\xce\x34\xcc\xce\x9d\x63\x78\x7d\xed\xda\x8d\x1b\xe3\x56\xc6\x2c\x5b\x31\x67\x04\xfe\x73\x7d\xa1\x72\x43\xe1\xe6\xcd\x1b\x34\x7e\x9a\x8c\x6d\xdb\xdc\x61\xe5\xf6\x58\xcf\xa5\x7c\x98\xac\x5c\x0f\x41\xc0\x2c\x85\x81\x4c\x2d\xf1\x29\x51\x57\x25\x94\x32\x37\x6d\x17\xb6\x1f\x7a\x67\xff\x91\xda\xf7\xf3\xaf\x6e\x6b\xa9\xdf\xed\xdc\xe7\x3a\x28\x1c\x34\xec\x6b\x3b\x58\xfd\x56\xd1\x71\x65\x55\x41\x9b\xa1\x9d\xeb\x38\xd0\x78\xfa\xa4\x26\x2c\xd2\xab\x86\x7d\x6c\x08\x88\x5e\x1d\xbd\x37\x61\x47\x6c\xcc\xe6\xcd\x31\xb1\x3b\x12\xf6\x7e\xc7\x42\x94\x4f\xa4\x9f\xa0\x38\xec\xbc\x45\x79\xd4\xd0\x49\x41\x67\x35\xe5\x57\x93\x5e\x3f\x0c\xa3\x5d\xed\xa5\x6d\x55\x9a\xe2\xe3\x59\x6f\x6d\x3a\xe8\xda\x27\x1c\x34\x1c\x34\xee\x4b\xdb\xbd\xa5\xc5\x71\x35\xe3\xfd\x75\x47\x56\xbe\x33\x63\xfb\x18\x9b\xb2\x20\x5b\x48\x67\x9e\x27\x32\x08\x1c\x88\xcc\xd2\xf5\x18\xc4\xbf\x96\xfc\x7a\x4a\xac\x55\x19\x67\xdd\xb4\x39\x56\xbe\x91\x0d\x3b\x36\xef\x2e\xe4\xf6\x15\x76\xe3\x3f\x0f\xcf\xd9\xbb\xac\x63\xe5\xae\x8d\x07\xd6\xba\x5e\xaf\x98\xe3\x9a\x5d\x31\xf3\xd0\x2a\xe5\x7e\x16\xf4\x02\x4c\xff\xec\xfa\xa6\x33\x49\x27\x78\x43\x93\xd1\x99\xd7\xae\x84\x36\xe2\xb7\x6f\x6e\xfe\x66\xe3\x4f\xa6\x9c\x89\xdb\xcf\x85\xa1\x1a\x42\x20\xf2\x7d\x50\xbe\x7b\xe3\xdc\x3b\x1f\x83\xfa\xa2\x94\xff\x63\x5f\x01\x12\x20\xea\x93\x5b\x17\x96\xdf\xae\xb8\x98\xdb\x65\xbf\x68\x79\xb7\xe2\x82\xe1\x6c\xe9\x85\x0b\x17\xaf\x43\x82\x6a\xaf\x7b\x9f\x77\x04\x64\xd3\x1b\x8c\x99\x69\x06\x83\xdd\x65\xe0\x40\x4f\xba\x5c\x2e\xbb\x8b\xa9\x77\x66\x6c\xe0\x71\x34\xa9\x2a\x18\x60\x87\xd7\x20\x8c\xee\x20\x3b\x5c\xb5\x4d\x4d\xae\x8c\x38\x2e\x8e\xf4\x3f\x06\xf5\x34\x66\xbd\xf4\x6f\xdf\xc4\x4f\xa4\x89\x5f\x10\xb0\x6c\x1e\xfd\x0a\xee\x26\x52\x64\x59\xcc\x98\x2c\x76\xa7\x95\xb7\x16\x0b\x62\xb5\x06\x9a\x67\xe0\x21\x32\xa9\x38\xa3\xd4\xc0\xa5\x39\xaa\x4d\x8d\xcc\xb6\x6d\xd5\x6d\xdb\xf9\x35\x17\x49\xb0\x83\x48\xef\x29\x6a\xb1\x54\x73\x3b\xf2\xd2\xab\x12\x99\xad\xfa\xec\xa4\x14\x1e\xc6\xbe\xe2\x33\x5e\xdc\x4b\x26\x36\x35\x67\x37\x33\xad\x75\x55\x3b\xca\x79\x7b\x75\xf1\xb6\xdd\x1a\x28\xad\xa5\xa7\x13\x49\xd6\xac\x02\x4d\x46\x81\xd1\x94\xc9\xe8\x0d\xb5\x1d\xfc\x79\x88\xf8\x94\x3c\x60\xde\x91\x5d\xcf\x6d\x4b\x4f\xac\xdc\xc0\xc4\x25\xe6\x6c\x49\xe3\xb3\xd3\xf2\x37\xaf\xd5\x20\x4d\xae\x2d\x4b\xa8\x4a\xe7\xb6\xd4\xb7\xe6\xec\x61\x3a\x76\x54\xb6\xd6\xf1\xe5\x15\xf6\xca\xe2\x6a\xa5\xad\xcc\x56\xd5\xa4\xf1\x2d\xf0\x7c\x42\x77\x18\xea\x52\x92\x8d\xe9\x71\x1c\x8e\x22\xe3\x9c\x19\x4d\x8d\xae\xda\x0e\x4e\x6a\xf3\x9d\xa2\x55\x69\x9f\xac\x1c\x27\x8c\x4a\x1d\xcf\xe5\xcc\x59\xb2\x72\xae\x59\x99\x85\x2c\x72\x02\xb2\x4c\xe0\x58\x8d\x2c\x3f\xb7\x6c\xc9\xa1\x9c\x33\xca\xd4\xaf\x84\xdb\x37\x34\x02\xf9\xb5\xed\x76\xfd\x97\x5c\xe5\xd9\xb7\x0f\x9d\x71\x28\xab\x41\x0b\x9c\x00\x2c\x03\x1c\x70\x42\x16\x68\xf9\xd3\xf9\x6f\xaf\xac\x9a\xad\xac\x7f\x46\x18\x35\x56\x23\x90\xfe\x02\x0f\x4f\xe3\xb2\x17\x60\x19\x69\xde\x9b\x75\x62\xeb\xc7\x59\x47\x33\x8e\x66\x1d\x55\xfe\x9b\x38\x89\x0b\xde\x81\x05\x8a\xab\x04\x2c\xf1\x3d\x42\xaf\x35\x6f\xca\x4e\xe7\xb6\xa4\x25\xe5\x6c\x60\xe2\x92\x2a\xb7\xa5\xf3\xd9\xf5\xe6\x9d\x07\x34\xd0\x8f\x3c\x50\xb6\xb3\xaa\x9e\xdb\x56\xb7\xbd\xb2\x83\xd9\xbd\x3d\x67\x4b\x3d\x5f\x95\x56\x96\xb0\x56\x83\xfd\x48\x98\x81\x0f\xd3\x07\xc9\x4d\x89\x5b\xb2\xb6\x30\x29\x59\x62\x9d\x99\x2f\xa8\x28\xaa\xdd\xae\x81\xa3\x17\x71\x1b\xa9\x7a\x48\x19\x94\x29\xe4\xd9\x8a\x38\x83\xcd\x61\x11\x99\xca\x2a\x67\x63\x35\x0f\x7b\x2f\xfa\x08\x52\x7a\x05\x4e\x47\xb2\x28\xc2\x42\x78\xfe\xec\x55\x20\xae\x5e\xfd\x01\x5e\xf8\xf2\x3a\xdc\xbd\x96\x9f\xda\xb7\x15\x36\xfe\x02\x0f\x4f\xfb\xe5\xdc\xe7\x19\xb7\x6a\xfe\x9d\x77\xdb\xf1\x55\xe6\xed\xaa\x8f\x2d\xb7\x4b\x6e\xde\x86\x10\x95\xdf\xbd\xd3\xbb\x02\x8e\xd0\x87\x73\x9a\x93\xb2\xb2\xcc\x59\x59\x1c\x9e\x22\xb3\xaa\xab\xcd\xd5\xcc\xf6\xca\xa6\x23\x3c\xdc\x86\xf5\xf4\x91\xac\xe6\x4d\x9b\xb2\xf4\xcb\xb9\x65\xb7\xc8\x9e\xc5\x50\x4b\xfb\x2e\x3c\x4e\xaa\xa4\x4f\x16\x4a\x17\x06\xfc\x00\xe7\x9f\x20\x61\x86\xef\x02\x7d\x8a\x5c\x1d\x13\x97\x1a\xcf\x24\xa4\x54\x6c\xcb\xe3\x2d\xd5\x85\xcd\x7b\x34\x12\xf3\xad\x2f\x88\x4c\x11\x0c\xb6\x42\x2e\xbb\xb8\xcc\x5c\xc1\xd4\xd5\x57\xed\x68\xe0\xa5\xb0\x6f\x7d\x26\x12\xbe\x87\xa1\xf4\xb2\xa2\x0d\xe6\x14\x2e\xc6\xb0\x25\x2d\x96\x89\xdf\x58\xb7\x6f\x13\xbf\xe4\x69\xcf\x88\x6f\x49\x15\x31\x3c\x08\x37\x91\x7b\x77\xee\xaa\xdb\xcd\xec\xd9\x96\xb6\xde\xc5\x97\xa5\x16\x6f\x58\xa6\xc1\x45\x24\xdc\x76\xd2\x09\x42\x6a\x91\x89\x2b\x4a\xcd\x4b\x37\x64\x2a\x63\xb7\xae\x4f\x5f\xca\x2c\x8d\xad\xed\x48\xe2\xd3\x5a\x8c\x07\x4e\x6a\xe0\x05\xf2\xa4\xb8\xbf\x7e\x1b\xd7\xb1\x7d\x4f\xed\x51\xe6\xc8\x9e\x8c\xb8\xed\x7c\xdd\x16\x71\xdd\x1b\x9a\x41\x38\x3d\x8a\x5c\x56\xad\xdf\xd5\x54\x59\xd1\x62\xe7\x6c\x76\x5b\xc3\x5e\xcd\xed\x1c\xc2\x77\xcf\x3b\x98\x5e\x96\xb3\x75\x53\x42\x76\xcb\x51\x0e\xd6\x93\x47\xab\x9a\x77\xb6\x55\xea\x97\x71\xb8\x9e\xf4\xac\xf1\xe7\xd1\xa0\x14\x20\x2c\x09\x42\xb9\xf4\xcf\x5f\x3d\x33\x59\x54\x36\xe0\x6b\x38\x4b\xc0\x99\x0c\xce\xc4\x59\x42\x2a\x46\xf3\xcf\x99\xa2\xe7\xa4\x4d\x52\x6e\xc1\x50\x2b\x86\xa1\x52\x23\x90\x48\x0a\xd8\x67\x3b\x86\x72\x75\x93\xce\xcf\xf9\x2c\x4f\x99\x02\xaf\xc1\x2c\x01\x66\x32\x30\x13\x66\x09\x8d\xf0\x1a\xff\x59\x79\xd7\x99\xfa\xcf\x95\xdb\x20\xd4\x06\x7d\x80\xd4\xf4\x64\x68\x43\x7d\xf4\x74\xac\x99\x06\x35\x8a\xfe\x44\xe3\xcc\xa6\xd7\x9a\x66\xb6\x3f\xd9\xf0\x92\xb8\x58\x89\x2d\xbf\x40\x0b\x09\x8f\x48\x03\x15\xd0\x88\x5f\xd3\x27\x4d\x07\xd2\xb6\x71\x1d\x5b\x62\x6b\x97\x31\xcb\x63\x33\xe2\xb6\xf0\x69\x5b\x4c\x6b\xdf\xd0\xe0\x54\xf2\x0d\x71\x6d\x7d\x12\x17\xb7\x6d\x4f\xc6\x11\xe6\xe8\x9e\xda\x8e\x6d\x7c\xfd\x36\xf1\xe0\x49\x0d\xdc\x84\x5b\xf4\x28\xdf\x63\x44\x42\x6a\x5a\x76\x3a\x93\x6b\x2e\xaf\x2a\x92\x25\x40\x45\xa3\x46\x0a\x19\xe5\xe3\xc8\x98\x92\xad\xf6\x2c\x6e\x8b\xd8\x98\xbb\x93\xd9\xdd\xd1\xf0\xe6\x5e\x5e\x47\xaa\x14\x41\x8d\xb7\x89\xc0\xa7\x64\x2d\x91\x02\x07\x58\xe9\x07\x8f\x87\x16\xac\x36\x1c\x0f\xfb\xb9\xc6\xdc\xf4\x96\x18\x06\xf3\x88\xec\x5c\x8b\x31\x9f\x37\x1b\x6d\xd9\x65\x39\x30\x16\xdb\xc3\xad\x36\x41\xb0\x32\xe8\xf0\xe9\xcc\x39\xb6\x1c\x87\x31\xc2\xe8\x70\x99\xab\x18\xc8\x23\xf6\xd4\xb6\x34\x55\xf2\x20\x48\xd1\xce\x5a\x41\xe3\x79\xcb\xd3\x8f\x76\xe6\x1b\xec\xd9\x0c\xe6\x13\x31\x59\xc9\xfa\x1c\xde\xe7\xea\x19\x94\xb1\x49\xd0\x08\x82\x15\xbe\xf3\x07\x73\x29\xae\xfa\xad\x7b\x65\xd2\x2a\x97\xdd\x59\xc6\x3b\x9c\x42\x95\xb9\x12\xbf\x95\x30\xdc\x2a\xd8\x6c\x8c\xb4\xcd\xfb\x6c\x59\xa5\x50\x65\x76\x46\x84\xc1\x53\x14\x6c\xf5\x5e\x85\xad\x21\x9e\x17\x3c\x15\xb4\x60\xce\x41\x1d\x7e\xc7\x65\x98\xb2\xd3\x12\x19\x9c\x49\x18\xf2\xec\xe5\x16\xde\x52\x6e\x75\x3a\x9c\xb0\x10\x7e\x0e\xb7\x09\x82\xc0\xe1\x63\xb0\xd1\xe2\xb4\xba\xec\xe5\x11\x65\x76\xb1\xb4\x82\x81\xd7\x88\x1d\x55\xe9\x99\x4e\x1e\xfa\x62\x92\x60\x15\x34\x9e\x50\x29\x9f\xb6\xe7\x09\x46\x8b\xd1\xf7\x84\x3f\x26\x5c\x10\xac\x02\x07\x95\xbe\x44\x87\x51\x30\x5a\xf2\x22\xf2\x2c\xa6\x02\x03\x83\xaf\x11\x09\xd9\xf5\x35\x26\x1e\xab\x25\xbd\x60\x13\x34\x42\x65\xb3\x34\xc0\xf3\x06\x57\xe7\xac\xa8\x6d\x65\xe0\x75\xc2\x55\x5e\x90\x67\xe7\x21\x15\x87\x46\xb2\x8d\x4e\x6d\xe8\x4f\x85\xac\x67\x89\x34\x92\x96\x04\x52\x4a\x43\x87\x2f\x0d\x4b\x14\x30\xd3\xf3\x2b\x2d\x90\xbe\x47\xb0\x24\x5d\xe0\x63\x0b\x26\x0b\xd3\xa7\x2a\x05\xdd\xfc\x4c\x7c\x94\x4b\xc3\xc1\x36\x1c\x2c\x68\x50\x4b\x0a\x56\x1c\x5c\x8f\x83\xb9\x1a\xec\xf3\xae\x4e\xd0\x7c\x34\xed\x56\xf1\x41\xb3\x52\x80\x81\xd9\xd2\xfa\x02\x4e\x20\xa5\x47\xa0\xa4\x5e\xe0\xf7\x94\x7e\x26\x7c\x74\x59\x29\xbc\xfb\x6e\x0d\xf4\xe1\xea\x61\xb0\x15\x06\x0b\x1a\xd0\x92\x82\x0d\x06\xa7\xc1\x60\x2e\x13\x1e\xd5\x9d\x12\x34\xd3\xaf\x4c\x16\x62\x4b\x95\x02\x96\xd4\xf9\x1e\xe1\x7a\xbd\x26\xa8\xe0\xae\x83\x6c\x88\x34\xc4\xf3\x31\x8d\xb7\xb1\x45\xca\xc1\x2b\xf0\x23\xec\x57\x48\x06\x2c\xa1\xf1\xf1\x11\xd8\x0d\xfb\x14\xc5\xa4\xd5\x6a\xb5\x29\x8a\x48\xfc\x11\xf7\xe1\xe3\xdd\x0a\x0c\x22\xa5\x6c\x3c\xaa\xb0\x92\x36\x9b\xcd\xaa\xb0\x91\x52\x0e\x1c\x55\xf8\xaf\x6a\x43\xbf\xa5\x7d\x72\x13\xb7\xb1\x59\x32\xc1\x69\x85\x64\xc2\xd3\xb4\xcf\x84\x67\xa0\x1b\xf7\x4b\xd9\x70\x45\xe1\xcb\xf6\xdc\xa1\x51\x2e\x99\xf0\x34\xdc\x86\x66\x45\xd8\x79\x18\x13\xec\xed\x81\x31\x21\x5a\xc5\x3f\x46\xd0\x92\x1e\xa2\xfc\x6a\xad\x77\xb5\x47\x0d\x51\x3e\x3d\x09\xd3\xa4\x46\xda\xd3\x82\xcf\xec\x86\x51\xfe\x16\x98\xa0\xf8\x18\x36\xd1\x9e\x38\xbc\x7d\x11\x06\xfb\xe3\xe0\x3b\x05\x68\x60\x3d\x2d\x79\x7d\xce\xbb\xd0\xc7\xe7\x95\x9c\x0a\x78\x1b\xca\x69\x54\x8f\x90\x92\xfc\x34\xa8\xbb\x15\x5a\x9c\xef\xbf\x4c\x7b\x3a\x61\x8c\xbf\x33\x90\xb0\xaa\x84\xed\x2b\x40\x09\xab\xfa\x65\x8a\x57\xf4\xa8\x69\x50\xb1\x48\x42\x20\xe8\x41\xf5\xe5\xc9\x7f\x53\x3c\x70\xfd\x20\x01\xa7\xc1\x34\x4c\xc0\x04\x9c\x86\x81\x63\x20\x8f\x45\x02\x24\xc0\x34\x98\x06\x09\x1c\x04\x49\x4f\xd2\xef\xac\xee\x5c\xb8\x70\xf5\xea\x85\x0b\x3b\x57\xbf\xf3\x4e\x67\xe7\x3b\x9c\xcf\x0a\x89\x34\x84\x82\x59\x5c\x73\x87\xdf\x93\xbd\x3d\xa3\x35\xb1\x35\xb1\x36\xa9\x2a\x56\x79\x70\x88\x09\xcd\x18\xaa\xc1\x50\x11\xcd\x6b\x86\x70\xd9\xb1\x19\x49\x89\x89\x89\x89\x49\x19\xb1\xd9\xca\x35\x43\xd0\x2c\x06\xbc\xe7\xd0\x6c\x3a\x38\x84\x8f\xad\x4a\xaa\x4d\x6c\x4d\x6c\xcd\xd8\x9e\xbd\x47\xb9\xe6\x8e\x08\x66\x08\xd5\x40\xa8\x09\xcc\x07\xef\x70\x55\x7b\x6a\xb7\xb7\xb6\xb6\xb6\x6e\xaf\xdd\x53\xa5\x3c\x78\x07\xcc\x26\x08\x65\x3c\xa2\x9f\xa2\x7f\xb7\xdd\xcb\xff\x9d\xcb\x87\x3e\x9b\x21\x78\xf4\xad\xd1\xb7\x30\x78\x07\xf6\x71\x28\xfb\x3b\x06\x58\xfb\xf7\x1f\x60\xeb\xff\xf0\x20\xec\x93\x8f\xc1\x9b\x47\x8f\x1e\x3d\x7a\x33\x06\xe7\x63\x1f\x65\x7e\x7f\xdb\x00\xa1\xbf\xd0\xdf\x3a\xa0\xff\xc3\x83\x1d\xd8\x67\x07\x06\xdf\x1a\x7d\x6b\x34\x04\x6f\x86\x3e\xf9\xca\xdf\xf3\xef\xd9\x7e\xff\xfd\x9e\xf5\xf7\x87\x07\x41\x1f\x07\x04\xef\xb8\x75\xeb\xd6\xad\x1d\x10\xec\x80\x3e\x4a\xc7\xef\xd6\x7b\xbf\x6b\xc2\x16\xb3\xd0\x2a\x4d\x82\x48\x69\x12\xb4\xaa\x13\xb7\x52\xbe\xb7\xfc\x22\x0d\xe3\x29\xe9\xfd\x7e\x30\x3e\x90\x92\x56\xf4\x0e\xa1\x71\x19\x9e\x55\x48\x43\x08\x78\x06\xf5\xf4\x40\x88\x52\xf8\xea\x89\x81\x18\xa5\x78\x82\x90\x56\x78\xa6\x4b\x2b\xfc\xd3\x15\xf0\x01\x88\x81\x4f\x43\x38\x15\x6e\xc1\x63\x30\x06\x42\x20\x19\x42\xc0\x01\x0b\x21\x34\x58\xba\x05\x5b\xa4\xc8\x96\x10\xcf\x7b\x9e\x09\xf4\xbf\x87\x9f\x7a\x65\x35\xf7\x5c\x8c\x80\xaa\x2f\x62\x2f\xaf\xbc\x7b\xc1\xf0\x95\x12\x42\x1a\xe9\x6a\x0c\x1b\x89\xff\xc4\x30\x83\xfc\xbf\xf2\x17\x0b\x84\x15\x7c\xff\xde\xcd\x2f\xf7\xc1\xbf\xce\xc2\xd8\x27\xea\x70\x80\x12\xf2\xa4\x03\xf4\xcc\x99\x4f\xe5\x3d\x63\xc4\xa1\x69\x38\xd2\x86\x43\xeb\x27\x38\x47\x89\xd1\xe7\x0e\xbc\xf7\xb1\xeb\x03\x27\xbc\xbe\x1b\x74\x56\x78\x7d\xd3\x05\xc3\x55\xe3\xe1\x39\xca\xd3\x3d\x0d\xb4\xad\x63\xcf\xe9\xa5\x55\x78\x02\x17\xf9\xc6\x0a\xf8\x0e\x2c\x4a\x37\x85\xe7\x67\xd6\x0c\xab\x19\xb6\x6d\x44\xc4\xe9\x61\x10\xb6\xe1\xb7\x34\x58\x14\x0b\x9b\x5c\x30\xfd\xe7\xdf\x4e\x67\x42\xf8\x8e\xff\x28\x61\x86\x77\x3e\x6d\xdf\x53\x7e\x60\xeb\xae\x37\x2e\x8e\x6f\x7f\xae\x19\x37\x77\x61\x66\x39\xa6\x24\xf7\x37\x46\x66\x3c\xbe\x7e\xca\xe6\x21\x6b\x73\x47\x6f\xc3\x35\x07\x71\xd5\x1e\x5c\xe5\x9c\x2d\xbc\x74\x72\xb5\x12\x14\x51\x30\x60\x3d\xf0\x59\xb0\x2a\x19\x12\x6a\xe0\xf5\x1f\x4e\xb4\x7e\xb0\xd7\xd5\xb5\x1f\x12\x0e\x40\x42\x07\x6c\x56\xca\xaf\xef\x0c\xb0\xdc\x06\xe2\x0b\x18\xff\x05\xbc\x0a\xfd\xaf\xc1\x8c\x60\x01\x2a\xe1\x97\x2f\x60\xec\x17\x70\x07\x2a\x43\x3c\xdf\x7a\x9e\xa4\xcb\x5f\x7f\x71\xe9\x82\x5d\x73\x5a\x84\xef\x4e\xb7\x2a\xdf\xde\xf9\xf1\xda\xb9\x9a\x2f\x6a\xe8\x9c\xbb\xa8\xfc\xe8\x89\x55\xaf\x27\xae\x8e\x2e\x99\x51\xfa\xf4\x97\x53\x6f\x96\xdf\x2c\xbf\xf4\xb5\xe1\xa6\x12\xa6\x48\x0c\xbd\xb1\x73\x7e\xf9\x92\x32\x64\x9a\x90\xb3\x21\xb3\x75\xb9\x79\x51\xde\xe6\x35\x47\x57\x9e\x37\x9f\xcd\x83\xa0\x1c\x08\xb6\xfe\x51\x75\xb6\xec\xa2\xe3\xf0\x11\xe5\x9b\xfe\x1c\x3a\x65\x5a\xc5\xc8\x29\xab\x90\x9e\x86\xa3\xf3\x70\xc0\xf6\x29\x95\x63\x5a\x56\x5f\x4e\xbf\x64\xb8\x9c\xfb\xb1\xbd\x22\xbc\xc2\x01\x1b\x71\x00\x9c\x14\x20\x1e\x06\x44\x74\x18\xb7\xac\xde\xaa\x81\x7e\x9e\x19\xf4\x16\x1c\x93\x88\xa3\x37\xe3\xe8\xbc\x65\x2b\x92\xd6\xa5\x22\x33\x1d\x47\x1b\x70\x68\xcd\xe3\xae\x41\xad\xcf\x7e\xb0\xae\x4d\x38\x9e\xf7\xe6\x16\x18\x96\x00\x8f\xa7\xc3\x70\xb1\xcb\xbd\xe3\x54\xa3\xf2\xca\xf6\xcf\x2a\x3f\x2b\x83\x71\x35\x30\x31\x1f\x9e\x5e\x76\x3a\xe3\x9c\x7e\xff\x92\xda\x64\x4b\x42\xc1\x56\x25\xd4\xfe\x12\xc9\xfa\x73\x3d\x77\xc0\x1e\xfc\x91\x77\x76\x88\x77\x1a\xac\xa1\x37\x66\xcd\xce\x59\x61\x55\xa2\xa6\x30\xe9\xa7\x8f\x35\x52\x35\x7c\x03\x76\xfc\x5a\x9a\x44\xa2\xb9\x40\x10\xf8\x02\x73\x41\x9e\x95\xcf\xc6\x7e\xb3\x30\x0d\xed\xa3\x94\x18\x0f\x93\x7c\x9d\x24\xce\x02\x16\x6b\xe1\xbe\x83\x83\xb0\x62\xd0\xbe\xd3\x76\x44\x29\xaf\x37\x5a\x22\x28\x44\x1b\x9a\x78\x95\xd6\xc7\x0d\x58\xfb\x44\x91\x12\xdb\x2d\x03\x60\x25\x0c\xd4\x48\xe3\xb0\x1f\x4c\x20\xe1\x8d\x8f\xdf\x82\x69\xae\x9f\x95\x65\x36\x7b\x49\x09\x23\x94\x08\x30\x93\xc3\xcf\x41\xc4\x37\xd0\xe9\x1b\x40\xea\x1a\x5f\xb8\x5b\xc2\x75\x1c\x71\x56\xb4\xf0\x1f\x60\xb4\x42\x1a\xe4\x6d\x8b\x64\x7b\x72\x51\xa7\x25\x4e\x42\x2c\x1b\xe2\x71\x80\x91\xae\xb0\x18\xca\x72\x18\xd4\x6b\x43\x6f\x10\x3a\x4a\x8b\x91\xa8\x27\x73\x0c\x81\xef\x15\xb9\xc5\x39\xe5\x46\x00\x9f\x3a\x3c\xdf\x11\xf8\x5e\x11\x4b\x89\xe5\xa5\x0e\x07\x07\xbf\x4a\xea\x72\x67\x71\xa5\xa5\x22\x22\xac\x27\x17\xc5\xbf\xda\xf3\xee\xa0\xed\x15\x45\x95\x79\x4e\x04\x49\x1d\xee\xc8\x37\x95\x9a\x64\x2a\x53\x5e\x41\x7e\x3e\x87\xbf\xfa\xd4\x79\xc6\xa2\x1c\x7b\x6e\x44\xae\xdd\x65\xae\x64\x40\xaf\xc5\x48\xa2\x8d\xd5\x86\xde\x00\x3d\x59\xe9\x2a\x77\xd9\xf9\x30\xf8\x81\xed\xd2\x12\x27\x43\x32\x59\x8f\x7e\x2e\xab\xc5\x48\xd0\x13\x95\x79\x2e\x83\x9d\xcb\xb5\xe7\x14\x19\x4d\x3e\x35\xfe\x11\x9e\x9f\x5f\x60\x32\x69\x40\xc9\xf6\x46\x29\x48\x6a\xfc\xd5\x99\x57\x59\x54\x61\x8f\xa8\xb0\x97\xb9\x2a\x35\x20\xdf\x0e\x39\x8e\x92\x5b\x13\xe4\xd6\xb4\xc4\x49\xcf\xbf\x68\x50\xb2\x62\x41\x79\xbe\x83\xf3\xa9\xe1\x57\x63\x79\x4e\x71\xae\x25\x22\xd7\x62\x36\xe4\x68\x50\x66\x85\x7c\x5e\x66\x05\xf5\x44\x4e\xb9\xc1\x65\xe1\x2a\x2c\x95\xc5\x4e\x51\x52\xc3\x1f\xe1\x0e\x47\xa9\x28\x06\x52\x1c\xef\xa1\xb4\x8a\xa4\x10\xad\x22\x09\x3e\xa1\x67\xd7\xbd\xf1\xe6\xb2\x0b\xca\x65\x17\xf4\x57\xaf\x6b\x3e\x6d\xba\x74\xe8\x03\xae\x65\xcf\xfe\x03\x27\x0e\xc7\xbd\x19\xdb\x11\xdb\xa2\x3c\x34\x73\x5a\xd3\x44\x66\xf1\x9c\xdc\xe4\x19\xbc\x7e\xc6\x12\x43\x02\xa3\x5f\xe6\x6c\x78\x99\x6f\x78\x69\x8e\x73\x31\x83\xe4\x13\x4b\x46\x4c\xe1\xa7\x0c\x5f\x87\x8f\xe2\x13\x1a\x7c\xe6\x38\x4e\xfc\x09\xa7\x70\x38\xe5\xe7\x9f\xa3\x7e\x65\x76\x1f\x76\x35\xbf\xcb\x37\x9d\x7a\xdb\x75\x90\xe9\x7c\xc7\x98\x7c\x96\x4f\x39\x77\xd4\xd0\xc1\xdc\xf8\xfa\x3c\xfc\xeb\x6b\xfe\xcc\x37\x07\xbf\xda\xf6\xb9\xd2\xf7\xb0\x36\xd4\x49\x97\x59\x1d\x65\x1a\xab\xa3\xa8\xac\x48\x44\x65\xe2\xf8\xc5\x8b\xa6\x2e\x9a\x9a\x34\xb6\x68\xe8\x5b\xa5\x1d\x8e\xe6\xb2\xbd\x15\x7b\x5b\xf6\xee\x7d\xf3\xcd\x5d\x47\x1b\x8e\x2b\xeb\x8f\x39\x8f\x76\x6a\xc2\x22\xf3\x53\xe0\x16\xe5\x99\x2c\xb5\xd2\x82\x7f\xb2\xef\x14\xe9\x99\xfc\x84\x42\xab\xd8\x12\xea\x9f\xfc\x84\xc2\xf7\x81\x67\x32\xe9\xdd\x30\x9e\xee\xe1\xfd\xc3\x08\x2f\x8f\x8f\x29\x0e\xb2\xa1\x3d\xf2\xd1\x3f\xda\xcb\x93\x61\x78\xdf\x4b\xc1\xc4\x60\x01\x56\x41\x32\xac\x02\x0e\x56\x83\x1e\x56\x85\x48\x46\xef\x7e\x3a\x25\xa3\xae\xb1\xb1\xb6\xae\xb1\xa9\x36\x3d\x25\x25\x23\x3d\x99\x97\x9e\xed\x97\xdc\x7b\xae\xa9\xb1\xf7\x5c\x0a\xef\x3f\x89\xaf\xd1\x73\x97\x2d\x9b\xc7\xfb\x5e\x24\xe7\x1e\x5d\x76\xfa\xf4\x91\xa3\xa7\x39\xe9\x45\xf2\xbd\x65\x47\xe7\x71\xde\x23\x69\x74\xcf\x70\xff\x93\xc4\xac\x63\x8b\xdf\xe7\x3e\x21\x6c\x98\xaa\x98\x7b\x74\xd9\x7b\xa7\x8f\x1e\x3d\xcd\x41\x2a\x70\x98\xda\x4b\xd4\x5b\xbe\x4a\x9e\x3b\x76\xec\x7d\x1e\xb3\xbc\xef\xd1\x97\xe1\x5f\xa5\x65\x45\xa2\xb9\x34\xc2\x5c\x62\x2a\x2a\x30\x4f\xc5\xf0\xf0\xd6\x59\xd3\xab\xa7\x32\x53\xa7\x67\x25\xce\xe2\xa7\x42\x78\x41\x99\xa9\xd8\x5c\x18\x61\x2e\x28\x32\x95\x9a\x2f\xe3\xbf\xc2\xb1\xff\xd4\x91\xc8\xe1\x18\x8d\x77\x34\x01\x63\x46\x02\x87\x91\x57\x38\x29\xc9\x97\x45\x9f\x5e\x76\x64\xee\xbc\x65\xcb\xe7\x72\xbd\x5c\xf6\x32\x10\x86\xe2\xb1\x15\x9d\x6f\x35\xa6\x76\xc3\xd7\xb5\xd2\xf1\x8b\x87\x1b\x80\x6c\x28\x6e\xc8\xae\x36\xb7\xbd\xdd\x98\x55\xd7\xb7\xac\x2d\xb5\x5e\x68\x87\x41\x3f\xfc\xf4\xad\xf8\x76\xfc\x2e\x67\x67\xdc\xfe\xf3\x5f\xb7\x9e\xe8\xa8\xd9\x73\x66\x6f\x13\xcc\x80\xf1\xa6\x6a\x78\xac\x51\x55\xff\xea\x07\x3f\x79\x46\x78\x3d\x74\x7c\x71\x91\xde\x69\x53\xba\xcc\x75\xc5\x0d\xbc\x40\x7e\x93\x4d\x3b\x4b\x8d\x0d\x09\x39\x4a\x81\xac\xb3\xdb\xd2\x9c\x25\x4a\xfc\xcd\xf7\x3c\x5d\x5e\x68\x31\x59\x32\xf2\xb3\xb3\x73\x2d\x36\xa5\x40\x66\x17\xd7\x39\xcb\x2a\xc5\xaa\xa2\x3a\xb1\x50\xe9\xe9\x46\xa4\x57\xef\xc6\x3e\x8e\xc2\x89\xca\xe4\xcc\xa2\xcc\x1c\x5e\x35\x34\x28\x68\xd4\xa2\xd9\x47\x91\xb2\x44\x2b\x55\xfd\x82\xde\x0f\x2a\x98\x97\xa9\xcb\x9b\xb7\xc9\x56\xd2\x28\xee\x52\xaa\x1e\x0a\x7a\x34\x48\x6c\xad\xdc\x6d\x6b\xb7\xb5\x15\xd6\xe5\x95\x9a\xed\x06\x53\x66\x52\x9c\xee\x85\xad\x2f\xe7\x4d\x37\x45\x97\xc5\xed\x37\x54\xa6\x66\x14\x15\x16\x5a\xaa\x4c\xae\x54\xa5\x2a\x68\x14\x11\x54\xb3\xb9\x7a\xc5\xba\x54\xdb\x9d\x78\xc7\x86\x0f\x94\x02\xa9\xfa\x87\x72\xc0\xa5\xae\x32\xf1\xa3\x8d\x3b\xb7\x6e\x43\xee\x6e\xec\xc1\x8c\x3a\xbd\x68\x6a\x4c\x7e\x3b\xeb\x52\xeb\x31\xbb\x58\x5a\x50\x90\xae\x0c\xf0\x91\x3c\xe0\xa3\xb1\xd5\x87\x5d\x6d\xc6\x53\x8e\xc3\x4a\x55\xd0\x94\x17\x83\x9c\x9f\x5e\x82\xc7\x77\x95\x2f\xbd\x79\xf7\x23\xeb\x67\xd6\xe3\x47\x30\xe4\xc8\xd6\xe3\x49\xef\x7e\xfa\xef\xfd\x4d\xae\x1d\x15\x45\x4e\xb9\xc3\xd0\x29\xa6\x23\x4f\x0e\x19\x5f\xb8\xce\x9a\x2d\x66\x55\xad\x38\x74\x2c\xe6\x42\xc5\x4e\xbb\xd3\xbe\xab\xb2\xbd\x62\x4f\xfd\x1e\xa7\x52\x55\xa8\x0c\xde\xbd\xcd\x51\x54\x6f\xb4\x5b\x4a\xf2\x04\xb3\x21\x2b\x69\x5a\x56\xb2\x39\xc1\xb4\x31\x6f\x55\x71\x74\x71\x75\xdb\xb2\xed\x39\x65\xa5\x0d\xb5\x75\x4e\x71\x9b\xa3\xb2\x51\x59\x5c\x52\x53\x5b\x29\x96\x96\x08\xff\x5e\x6b\x93\x47\x20\xf2\xd1\x38\x9b\x31\xc9\x96\xa4\x4c\x2a\xae\x4a\x16\x99\x3a\x5b\x46\xaa\xb1\x30\xcb\x92\xfa\x61\x49\x5b\x71\x7b\xcd\x7b\x07\xad\x7b\xad\xdb\x97\x5b\x9f\x53\xe6\x9c\xa9\x6f\x48\xe1\xaa\xb2\x67\xc2\x48\xe0\x5c\x7b\xcd\x7b\x72\xab\xc6\x5b\xf2\xaa\xe6\x24\x9b\x13\x4d\x19\xce\x9a\xed\xce\xed\xc6\x0b\xba\x82\x79\x85\xe5\x43\xab\x8b\xaa\x8b\xf6\x27\xb6\x5a\x94\xdf\x64\x44\x2f\x72\xcd\x52\xaa\x1e\x0d\xb2\x07\x55\x4e\x3f\x52\xd7\x89\xaf\x96\x1b\x3a\x8c\xbb\x31\x72\x27\x3e\xb6\xfa\xa9\x8f\xcb\x6b\x6c\x2d\x76\xe7\xde\xed\xdf\xad\x81\x90\x35\x57\xf5\x87\x93\x77\xe6\x3a\x8f\x26\x9e\x8d\xaa\x8a\x56\xd6\x8d\xab\x88\x49\x1c\xad\xac\x31\x1f\xc8\x48\xd7\xf8\x95\x9e\x8f\xe8\xc2\x22\xc1\xca\xa9\xa6\x84\x16\x06\x99\xac\xe5\x15\xc5\xbc\x58\x6c\x71\x14\x30\x02\x99\x5f\x54\x54\x57\x51\xe8\x28\xaa\x48\x2f\xd8\xa2\x94\xc6\xe3\x22\xba\x24\xdb\x94\x99\x5b\x9c\x5a\xba\xf4\xed\xc6\x66\xa5\x4a\x19\x1c\x14\x24\x90\x2a\xe5\x43\x41\x41\x65\x65\xa5\xa9\xf5\xb9\x35\xc6\xaa\xb2\xd2\x34\x25\xbe\x0c\x71\x74\xa1\xb1\xa0\x58\x53\x54\x9d\x57\x95\x57\xac\x14\xc8\xfc\xe2\x02\x47\xa5\xcd\x6e\x6b\xcc\xb5\x6e\x55\x9e\x82\x6c\xda\x62\xd0\x97\x58\x8a\xd2\xcc\xf9\xe9\xa6\x32\x63\x79\xb5\x58\xea\x52\x0a\x64\x89\xd3\xd8\xd8\x50\xac\x2c\x2f\x37\xe7\x95\xf3\xa2\xb9\x32\xdf\x6a\x51\x4a\x1f\x68\xbd\xef\xd1\x9b\xeb\xa6\xd7\xe7\x43\xbf\x24\x7d\x09\x3e\x72\x65\xeb\x17\x89\xc7\x97\xe3\xb0\x85\x4a\xd5\xa3\xc1\x41\x41\xc3\xe2\x32\x8c\xcf\xbd\x3a\x69\x06\x52\xdb\x1b\x81\x73\xb9\x1d\x67\xd3\x3f\x34\xb5\x15\x1c\x74\xb4\xba\x4e\xed\xac\xd9\xb9\xb0\x6e\x83\x63\x5d\x57\xa1\x52\x35\x3b\x34\x28\xe8\x97\x82\x86\x3b\xed\xf6\xc6\x92\xa6\xf7\x33\xff\x93\x7e\x6f\x26\x4c\x98\xf4\x95\x52\x65\x08\x0a\x0a\x9d\xf1\xf1\xea\xf7\x93\xbe\x49\xfe\x24\xf7\x72\xe9\x25\xc7\xcd\xc5\xd0\xe7\xb9\x33\x8b\xf7\x4e\x6e\x78\xd9\xaa\x5c\xbb\x3e\x3f\x6b\x33\x8f\xca\xd7\x32\x47\x17\x0f\x2a\x1e\x51\x82\x0f\xb9\x06\xe6\x2c\x99\x3e\x6a\xe5\xbc\x39\x73\x13\x30\x64\xdd\xf0\xd4\x85\x1b\xb6\x16\xce\xb0\xa6\xd9\x96\xd4\x56\x7d\x74\xe2\x06\x86\x03\x8d\xcb\x95\x02\xd9\xb2\xf6\x1b\x1c\x8f\x23\x53\x16\x9a\x27\xec\x9d\xd4\x30\xad\xf6\x45\xd7\x1a\xd7\x96\xff\x8b\xb0\xff\x80\x6e\xe2\x0a\xfe\x86\x61\x1b\x7b\xa5\x45\x21\x0e\x20\x2d\x58\xbb\xd2\xae\x09\x01\x42\x09\xd5\x94\xd0\x21\x21\xf4\xd0\x4c\x33\x1d\x8c\x6d\xdc\x31\xee\x4d\x92\x65\xcb\x92\x56\x92\x65\x59\xee\x1d\x1b\x17\x6c\x6c\x8a\xe9\x25\x74\x12\x4a\x68\x0e\x21\x81\x84\x96\x46\x48\xa7\xcc\x4a\x23\xf3\xff\x8e\x4c\xf2\x3c\xdf\xf3\xbc\xe7\xbc\xef\x39\xbb\x3b\x77\xe7\xce\xcc\xbd\x77\xcf\xd5\x6a\x67\x77\xee\xfc\x6c\x1a\xbb\xa1\x20\xbb\xbe\x6d\x9f\xa9\xd9\xdc\x9c\x51\xae\xde\xa5\xde\xa5\xaf\xb2\x17\x92\x79\xf6\x12\xcb\x4e\x43\xa3\xbe\x35\xaf\xb2\x68\x77\x65\xe9\xfe\xf4\xe3\xe4\xda\xd4\x94\xad\xf1\x6c\x48\x62\x40\xf9\xf6\xb8\xc8\xed\xed\x9f\xe8\x57\xe9\xb7\x6e\xd9\x50\x11\xf4\x66\x5a\x56\x04\x3d\xd4\x3d\x49\x86\xde\xdb\x3b\xd6\x5d\x30\x3c\xd4\x17\x3f\x04\x5f\xcb\x7e\xd3\x3e\xf3\x3e\x13\x79\xe8\x10\x6f\x3c\xcc\x3d\xd1\x47\xae\x3b\x1f\x75\x22\xf6\x71\x41\x75\x55\x43\xfd\xd7\x57\xce\x37\x92\x52\x0f\xb5\xc7\xf4\x8e\xbd\x30\xe5\x32\xbe\xf3\x75\xd7\x33\x97\xb7\xf0\xe4\xef\x54\x10\x09\x15\xe0\xdd\x9b\x07\x6f\x05\xe1\x07\xde\xd2\xfb\x4e\x7b\x1b\x15\x36\x79\x6c\xd2\x48\x06\xc7\xe0\x80\xf3\xbf\xa0\x88\xe3\xed\xd9\x79\x3a\x16\x7a\x43\xbd\x20\x07\x05\x4f\x9b\xcc\x26\x13\xf3\x33\x66\xed\xc3\xb5\x05\x4b\x48\x5c\x28\x3c\xa7\xb4\xfa\x4c\x43\xa6\x9e\xe4\xf1\x15\x8a\x70\x36\xde\x66\x81\x54\xf6\x07\x72\x3e\x0c\x87\xc9\xb4\xf4\x7d\x1b\x6f\x33\xd9\xd8\x42\xb8\xab\xfd\x0b\x7e\xe2\x2a\x83\x2b\x82\xcb\x82\x49\x3f\x08\xa5\xa4\xf7\x27\xe0\x75\xac\xb7\xa4\x30\x87\x60\x03\x28\x60\x0a\xcc\x7f\x64\x57\xc1\xdb\x38\x01\x44\xb8\x9e\x74\x4c\xc7\xdb\x54\x24\xce\xef\x8f\xa3\x71\xd0\xfb\x59\xfb\x43\x61\xf9\x58\xd0\x40\x68\x0b\xcc\x5f\x52\x92\x43\x76\x1e\x75\x24\x53\x46\xa3\x91\xe7\x4c\x5d\x20\xe8\xc2\x63\x1c\x40\x19\xf4\xc3\xf1\x5d\xe4\x47\xa0\x37\x6c\xc6\x9e\x30\x5e\x53\x4c\x16\x9d\xfc\xcc\x76\x9a\x91\xbe\x07\x13\x61\xd8\xc2\x01\x20\xe6\x60\x87\x2b\x99\xd2\x9a\x70\xc7\x09\x4c\x88\x22\xa5\xab\x74\x85\x39\x45\xba\xc2\xf4\xe6\xb4\xe6\xb4\xdd\x50\xf4\xf2\x05\x0c\x33\x9b\x7f\x46\xef\xb3\xd8\xdf\x8c\x23\x48\xf0\xce\xa2\xfc\x24\xf3\x21\xcb\x39\x05\x52\x7b\x83\x5e\xa9\x70\x4e\x87\xab\x8e\x7d\xf0\x99\xf4\xa1\xc2\xbb\x40\x88\xa4\x70\x03\xae\xfa\x00\x17\x63\x3c\x2e\xfe\x13\xde\x39\xbb\xfb\xe4\x4d\xf6\x55\x01\x0e\x87\x85\xcc\x93\xf3\xfb\x4f\x5d\x09\x28\x18\x5d\xc3\xe1\xc0\x36\x02\x07\xb6\xa2\xf7\x25\x98\x4c\xc3\x06\x58\x77\x07\x66\xc0\x12\x58\x36\x1d\xc5\x4b\x82\x56\xcd\x63\x87\xe8\x41\x8c\xa3\x98\x31\xcb\x76\xac\x58\x72\x3e\xe3\xeb\x64\xee\xf9\x0e\x02\xde\x0d\x87\x29\x8b\x70\x26\x0d\xff\x83\x91\xd4\x93\xc8\xfb\xab\xaf\xb2\x05\xc7\xf3\x4e\x9d\xa2\x05\x39\x5e\x87\xeb\x2e\xf9\xaa\x55\xd9\x9a\x35\xec\xc9\x79\x13\x9b\xc6\x30\x59\xca\x31\x4d\x13\x4f\xce\xe3\x34\x6b\xb2\x57\xad\xa2\x5d\x72\xb8\x8e\xd7\x05\xf9\xa9\x53\x79\x05\xc7\xd9\xd5\x57\xef\x47\x3e\x61\xa4\x77\x1f\x4b\x5c\x2a\x61\x30\x2c\x84\x63\x5d\x71\x6a\xf3\x3d\x0f\xc3\x7c\x67\x9a\xdd\xcb\x99\xe6\x7c\x4c\x25\xe4\xc4\xc4\xef\x60\xf8\x58\x1e\xbf\x0a\x8a\x8e\x09\x62\x37\x89\x83\x1a\xa2\xf7\x43\x65\x03\xcf\xb3\xf5\xf5\x91\x51\xd9\x5c\x76\x54\x34\x0e\xd4\xa7\x92\xa9\xfa\xa4\xe8\x30\x86\x8f\xe1\x31\x74\x83\x2a\x3b\x34\x92\xe5\xa3\x82\xb1\x14\xaf\xb3\x7a\xbd\xde\x64\xa1\x9d\x8f\xc4\x75\x35\x8d\xcd\x8e\x19\xf5\x6e\xcd\xda\xd8\xf0\x2c\x0e\x96\x36\x50\xc0\x36\x84\x7e\x85\x7d\x98\xce\x3c\x7c\x87\xe7\x39\xf4\x09\x19\xb1\x84\xe3\xf9\x25\x0a\xe7\x11\x7a\x6e\xeb\x8e\x2a\x2d\x5b\xa5\x3d\x93\xd5\xb2\x8f\x14\xc6\x0b\x29\xb6\x7c\x9e\x2e\x2c\x30\x19\x0b\xab\x61\x1c\xff\x84\x01\x51\xc5\x77\xc7\x8a\xb8\x82\x76\xf0\x12\xae\xed\x85\x39\x24\xef\x1d\x8c\x73\xd0\xcb\x75\x4d\xb3\xb9\x6b\x3a\xb7\x3b\x3b\xe0\x27\xa5\xd0\x0e\x32\xa1\x1d\xfc\x65\x13\x1c\x01\x10\x40\x4d\x94\xb8\xe2\x86\x29\x9d\xf6\x35\x4a\x21\x6e\xa9\xe4\xb5\x5d\xec\xf0\x17\x64\xff\x72\x1d\xb2\x37\xdc\x4e\x99\x18\xfc\x1d\xf6\x7f\x94\x2e\x95\xa3\x0b\x6c\xda\xa0\xf4\x32\x28\x85\x38\xaa\x32\xbb\x52\x53\xca\xa2\x5d\x90\x11\x17\xb7\x2c\x3c\x3e\x83\x71\xc9\x44\x33\x16\xae\x59\xbc\x85\x43\xbb\x4b\x46\x68\xd2\xb2\x93\x92\xe8\x95\x92\xe6\xa6\xb2\xfa\x0a\xf7\xa3\xc3\x53\xe2\x08\xfa\x8a\x90\x77\x8d\x20\xb2\x35\x7a\xb5\xaa\x0b\x6d\x1c\xeb\x44\x0b\x4f\xad\xfe\x9c\x05\x7f\x11\xd4\x48\x38\xa8\x83\x00\xf1\x74\x65\x91\xbe\x30\xbb\x80\x43\x5e\x18\x41\x80\xef\x11\x31\x24\xe2\x53\x22\xa6\xa2\x29\xb5\x99\x59\x28\x71\xf9\x3b\xda\xd3\x24\x3e\x9d\xff\xf6\x06\x02\xae\x40\x5c\xd7\x16\xe0\xe5\xb4\x3b\x3a\x60\x9f\xa4\x53\x26\xda\x2d\xe1\x5c\xfe\xc2\xdb\x4a\x78\x71\xe5\xf5\x7b\xf0\xb1\x52\x08\xba\xe2\x0a\x82\x8f\x95\xce\xf7\xae\xe0\x0b\xe1\x6d\x25\xb6\x3b\x5e\xa4\x75\xf9\xaa\x25\x90\x41\xe1\xdf\x42\x64\xcc\xde\x70\x78\xeb\xaf\x2f\xe5\x8f\xcf\x7d\xb7\xf1\xd0\x6a\x32\xb9\xac\x3e\xfe\x33\xe6\xb3\x86\x9a\x8a\x32\xee\xd0\xc9\xef\x0e\x3d\x5a\xf6\xf7\x9c\x70\x7c\x2b\x26\x98\x14\x46\xcd\xe9\x5a\x4a\x69\x57\x88\xfe\x07\x6f\xc3\xed\xde\x90\xf4\xb3\x4e\xf2\xb3\x74\xaf\x82\x38\xed\x90\x51\x78\x0b\x0b\xb1\x10\x6f\xb9\x29\x14\xc2\x2d\xb8\x05\xff\x8b\xba\xf9\x2c\x34\x62\x13\x65\x29\x30\x16\x66\xe7\xe3\x1c\x30\xf9\xc2\x1c\x30\xe5\xd9\x4d\x05\xfa\x02\xb9\xbe\x40\x6b\xcb\xb4\xe0\x91\x67\xbe\x70\x51\x5c\xa0\x2b\xd0\xe6\xb1\x99\x79\x1a\xb3\x26\x07\x8f\x7c\xe0\xeb\x16\x56\x95\x45\xf3\xaa\x54\x39\xce\x41\x13\x1e\x79\xaa\xc9\xd5\x18\x32\xb3\xe5\xda\x6c\x9d\x46\x43\xe3\x45\x31\x1e\x19\x9a\xa9\xd7\x66\xe9\x35\x72\xbd\xc6\xa4\xc9\xcb\x84\x39\x68\xf2\x75\xcb\x66\x6b\x8d\x6a\x8b\x46\x6e\xd1\xe4\x67\xd9\xf5\x70\x64\xa8\x2f\x5e\x14\x6b\xac\x9a\xfc\x6c\xd6\x9e\x5d\x60\x28\xc8\x85\x23\x4f\x7d\xdd\xc2\x84\x36\xaf\x40\x57\xc0\x14\x14\x58\xf3\xf3\x38\x77\xbf\xe0\xc8\x07\x05\x39\x05\x66\x7b\x9e\x3c\x3f\xcf\x5a\x50\x40\xc3\x45\x31\x1c\x79\x46\x48\x63\xec\x96\x7c\x9b\xa5\x80\xf4\x89\x54\x42\x5c\x57\xe2\x19\x19\xbc\xe8\x42\xf9\xfc\x03\xd2\x29\x1c\x80\x3d\x70\xee\x18\x5c\xce\xe0\x4b\x3c\x00\x6b\x94\x70\x08\x96\x82\x1e\x2a\xbf\xe5\xe6\xf4\x0b\xc6\x9e\x28\xa5\x5d\x62\x38\x83\x67\x04\xf1\xde\xbd\x96\xbc\x36\x16\x36\x3c\xa4\x0a\x6b\x75\x8d\x49\x95\x49\x95\xd1\xd6\x58\x35\xb9\x6d\xe6\xb4\x94\xc9\x0c\x9e\x46\x3d\xe8\xe1\x34\x0c\xbf\x0c\xef\x82\xe8\x39\x57\x59\x61\x6b\x54\xd7\x69\x6a\xe3\xca\xa2\x8d\xa4\x6b\x74\x1a\x7e\x83\x3f\xba\xc6\xd0\x70\x5b\x09\xa7\xa0\x1e\x3e\x82\x5a\xe8\xc5\xfa\x54\x3b\xec\x10\xd0\xf5\x92\xcb\xd9\xe1\x08\xe8\xfa\x84\x64\x17\x85\x46\x35\xb6\xfa\x2b\xc1\x5e\x2a\x11\x3a\x20\x20\x44\xa2\x70\xaa\xc7\x4a\x5e\x07\x8c\x50\xc6\x29\x47\x4a\xae\x28\x08\xb5\x9b\xe5\x61\x91\x2c\x96\x6c\x93\xf8\x55\x27\x08\xf6\x6f\x94\xd0\xe1\xd9\xac\x10\x4d\xf7\x52\x88\x36\x0a\x1d\x21\x12\x8c\x13\x81\x8c\xff\xf3\x1a\x0d\x33\x60\x06\x8c\x56\xca\x35\x4a\x9c\x81\x33\x7c\x3b\x1f\x8a\x70\x06\xcc\xd0\x28\xe5\x7f\x29\xc1\xcd\x98\xcb\x0f\x42\x19\x8d\x71\x22\x8d\x04\xe2\x44\x48\xee\x1c\xdd\xfa\x09\x8b\xeb\x31\x31\x2e\xc6\xbc\x65\xd7\x0e\xb9\xba\xb8\x54\x57\xca\x54\x94\xdb\x4a\x8a\x39\x98\x0f\x5b\x08\x1e\x7c\xd1\x17\xe6\xb2\x90\x23\x79\x2d\x13\xc3\x54\xe8\x0b\x3d\x78\x0e\x02\x71\x35\x01\xac\x04\x46\x2b\x31\x08\xb6\xfa\x1e\xb8\x55\xff\x14\x7a\xd1\x10\x37\x52\xe2\x8a\x13\x3a\x28\x98\x25\xc8\x24\x38\x0b\x67\x61\x7f\xa1\x9b\x92\x75\xc8\x44\x3e\x30\xb8\x26\xc1\xc9\x37\x6a\x6d\xbd\x15\xe2\xe8\x52\xe9\x0d\x85\x38\xdd\x69\xa2\xf8\xf4\x03\xfe\x6a\x16\xdb\x0d\x44\xbc\x25\x35\x93\xa7\xf9\x94\x4c\x6d\x3c\xbb\x16\xdf\x5e\xd4\x9f\xa7\x51\x86\x51\x2b\x55\x09\x25\x64\xe0\xee\xe2\x5f\xaf\xd3\x10\xda\xfc\x64\xd8\x4e\x36\xc2\x16\x67\x9d\x68\x7a\xcf\xe4\x6f\x0c\xdc\x11\x96\x1a\x1b\x52\x6a\xa8\xd4\x1f\xca\xdc\x19\x41\xf2\x75\x9b\x73\x47\xb1\x85\x68\x5e\x15\xc1\xd3\x41\x09\xb3\x5b\x07\xc1\x66\x92\x5f\xf2\xf7\x7a\xf0\x66\xb5\xd5\xa9\x85\x3c\xcd\x27\x97\x6c\xcf\x65\xa5\x7b\xb1\xde\x40\x6c\x4a\x4b\xe2\xf9\xb4\xd4\x92\x30\x0e\xc2\x5c\x3c\xe8\xd1\xca\xd3\x3c\xec\xc0\x74\xc8\x2b\x63\x79\x10\x8b\x5b\x2d\x15\x95\x3c\xcd\x97\x55\x18\x5b\x58\x03\x0c\xbf\xbd\x93\xa7\x6f\xd6\xfc\x88\xd3\x9e\xcd\x25\xf9\x8e\xd5\x67\x0b\x59\xb0\xe7\x12\xc0\x98\xe6\x83\x37\x4f\xeb\xec\xe1\x37\x70\x38\xf4\x27\xa5\x37\xd0\x1f\x06\x57\xef\x80\x15\x50\x08\x12\x18\x75\xec\x59\x5a\x3b\xe9\x53\x3d\xf6\xef\x0e\xe8\x06\xb3\x61\x0b\x0c\xe8\xca\xc8\x36\x03\x1a\x41\xd9\x5b\xf0\xfb\x0d\x56\x15\x7e\x05\x4b\x85\x60\x90\xbc\x04\x56\x0a\x0f\x1d\xe3\xc1\x4a\x45\xad\x5b\x98\xb8\xae\x7a\x7d\x75\xfa\xe9\xc6\x23\x0d\x87\x2f\x55\x1d\x49\x3a\x96\x58\xba\x22\x7a\x1d\xf9\x14\xde\xa6\x34\xc9\x71\xda\x64\x5b\x72\xbe\xae\xb2\xa0\xa2\xa0\xbc\x26\xbf\x22\xbb\x22\x2b\x2f\x51\x93\x4c\xc2\x4c\x3f\xea\x12\xd0\x33\x80\xc5\x41\xfb\xb0\x5f\x1b\x8e\x99\xb5\x10\x7b\x2e\x44\xe9\x25\xec\x07\xfd\xd7\x91\x52\x52\x0d\xef\xaf\x81\x99\x5f\x5d\x02\x05\x09\x57\xc1\x9f\xaa\xc4\x95\x18\x87\x73\xf1\x64\x24\x29\xb5\x4e\xc7\x93\x51\x68\x07\x3a\x09\x56\x26\xc1\x4a\x88\x83\xb9\x70\xb2\x09\x4e\x36\x82\x1d\xe9\x4a\x5c\x49\xc2\xe7\x39\x14\x28\x50\x74\xf7\xbd\x66\x36\x36\x3f\xc5\x5a\xdc\xd2\x70\xdb\xf2\x45\xc4\xe1\x25\xdf\xe3\x98\x1c\x9c\x37\x95\x34\x2d\xdd\x5e\x72\x94\x6d\xf8\x31\xe7\xeb\x0d\x87\xde\xff\x03\xcb\x06\x60\x02\x26\x90\x52\x78\x88\x53\x70\xca\x60\x9c\x8d\x23\x68\x3c\x29\xf4\xc4\x39\x02\x29\xa4\xc2\x5d\x68\x83\x78\x76\x86\xc3\x9b\x5a\x7a\x65\x5c\xed\x94\x14\x52\x4a\x4e\x0f\xcf\x4a\x8c\xb0\x85\xe7\x85\x37\x27\x36\xdb\xdc\x8a\xbc\x78\x5f\x7e\xbb\xaa\x21\xa2\x21\x22\x7f\x93\x6a\x2b\xc9\x8b\x35\x11\xe5\x61\xbb\x35\xbb\x35\x2d\xe5\x05\xbb\xeb\xbe\x4e\x7d\xbc\xf4\x32\xe9\xf6\x9c\x28\x94\x40\x5f\x9c\x71\x02\xc7\x6e\x23\x79\x71\xb0\x76\x47\x48\x7e\x70\x7e\xf0\xde\x1d\x7b\xf3\x41\x54\x0b\xef\x84\x3e\x18\xfe\x60\x44\x0d\x4a\x43\xd0\x8b\xe4\xc5\xea\x90\xaa\xad\x6d\xaa\x36\xd5\xbe\xaa\xa2\x36\x12\x48\xe5\x49\x18\x19\x01\x9f\xa0\x04\xfa\xb8\xff\x8b\x14\xc4\x3f\x3f\x48\x14\xde\x91\xdb\x28\x9c\x05\xde\xd8\x1f\xa6\xac\x81\xc0\xb5\x18\x88\xfd\x71\x0a\xce\x42\x6f\x72\x11\x78\x42\xaf\x6d\x20\x67\x80\x86\x5e\x7b\x2e\x81\x27\xe7\xd2\x2a\x08\x3b\x85\xaf\x3f\xc5\x46\xbc\xee\xea\x49\xe3\x92\xeb\x38\x1d\x08\xa4\x59\xa8\x86\x3e\xb0\x04\x8e\xc1\xaf\xb4\xb3\x0f\xd6\x52\x42\x4f\x6c\x84\xeb\xf8\xfa\x73\xd6\x95\x2c\xc6\x5f\x61\x09\x1e\x83\x6a\xec\xc3\x02\x01\xf4\x75\x98\x0e\x4b\xe8\xae\x84\x2f\x3f\x28\xbc\x6b\x0e\xc4\xd4\xf5\x76\xec\x7c\x28\xdd\x2b\xbd\xa1\x20\x52\x84\x59\x14\x7e\x03\xa5\x78\x0e\x9f\xf0\x74\xf3\x93\xba\x5f\xcb\xfe\x24\x79\x81\x1f\x58\x2a\xa4\xb3\xf8\x08\xc4\xf8\x21\x7e\xc3\xd3\xe6\x56\xfe\xbe\x21\x8f\xe4\x21\x55\x98\xe3\x5a\x03\xa3\x58\x34\xe3\x63\xc1\x17\x6b\x78\x5a\x9f\x8d\x7d\xb3\x3f\x65\xa5\x7b\x79\xf4\x11\xd6\xb8\x66\xe3\x47\x6c\x9b\x6b\x9e\x60\xbb\xc7\xd3\x29\xef\x6e\x1f\x12\x32\x7a\x16\xf4\xc2\xf9\xb0\xc9\xf5\x2e\x4e\x80\x51\xae\x81\xd0\x76\x18\x86\x5c\x40\x1a\x8d\xb8\x09\x47\xa0\xca\x48\xc6\x26\x26\xc5\xc6\x56\x25\xd6\x71\xd0\x6a\x02\x3d\x04\xc0\xfb\xf0\x19\xc9\x0b\x09\x78\x16\xd6\x09\x39\xac\x8f\x4b\x55\x0c\x3b\x6f\x41\x7e\x87\x7b\xdb\xe9\x59\xad\xf0\xbe\xe3\xa5\xf0\x7e\x06\x6d\x94\x02\x87\xcc\x15\x21\xf1\x64\x24\x78\xb0\xc2\x2e\xac\x11\x41\x31\xd4\x10\xe7\x45\xe0\xf1\xe4\x27\x20\x38\x41\x21\xf4\x90\x08\xf7\xdc\x07\xce\x1b\xbc\xc7\xfc\x84\x1e\x6c\xe7\x63\x11\x7a\x8c\x19\x89\xde\xdc\x1c\x85\xf7\x1d\xb1\x0f\x8c\x95\x38\x64\x54\xa3\x12\x5f\x88\xc7\x4b\xe0\xc5\x7f\x29\xaa\xc0\xbf\x4f\x7f\x09\x8c\x95\xc0\x6d\x09\xbe\x80\x00\x51\x79\x5a\x29\xd4\x2a\x33\xb5\xb4\xd6\x92\xf9\x26\xdf\xd5\xed\x7f\xf3\x5d\x8d\x93\x40\x00\xbc\x10\x4f\x95\x80\xff\xb3\xae\x10\x4b\xa7\xdd\x19\x40\x8d\x51\x66\x64\xe4\x68\xd5\xac\x2b\x00\x3b\x88\x14\x95\x26\x31\x91\x4e\x28\x48\x2a\x57\xb1\x82\x9b\xa1\x2d\x2c\xce\x29\x66\xdc\x37\x66\xf4\x5f\xa4\x3c\xa4\x7c\x13\x5c\x8e\x76\xa1\xfd\x43\xa5\x1f\x8c\x92\x08\x76\xa0\x94\x5e\xce\x7c\xf8\x9b\xc2\x82\x0a\x0c\xc2\x18\x2c\x60\x60\x99\x12\x3e\x79\x01\xfe\x30\xfe\x36\x97\x02\x7d\x09\x4c\x9c\x80\xc3\x30\x02\x75\x34\xde\x84\x22\x2c\x82\x9b\x60\x81\x58\x18\x0f\x99\x77\x59\x61\xe9\x73\x0a\x03\xdf\xc7\x24\x61\x0d\x51\xad\x89\x2b\xd9\xc1\xb8\xd6\x88\x52\x41\x46\x08\x43\x41\xe6\x9a\x24\x0a\x86\x83\xc4\xcf\x9a\x7b\xdf\xfc\xd4\xb5\xca\xe5\xe3\xf9\xeb\x3f\x49\x62\xf5\x9a\x9c\x78\x93\xe6\x59\x67\x95\x6f\x78\x6e\x43\x6c\x33\x23\x44\x88\x40\xeb\xda\x4e\x24\x14\xec\x4c\xaf\xfd\x2f\x17\xbd\x1d\x64\xc4\x9b\xe7\xaa\x00\x68\xf7\xe4\x61\xbe\xf3\x29\xe8\xbd\x14\x44\x0f\x67\x1f\x2a\x07\x3d\xa6\xe1\xfb\x38\x10\x17\x93\xb8\x0a\x87\xa2\x6c\x70\x7f\x66\xde\xf2\x4b\xf0\xd6\x7a\x2e\x12\xba\x45\x82\x67\x24\x74\x23\xe1\xad\xb0\x90\x4b\x5b\x19\x6d\x54\xf2\xb6\xd5\xdc\xca\x2f\xcf\x1e\x3f\x7d\xe2\xcc\x31\xf9\xed\x2b\xe7\x9a\xdb\x72\x1f\xe7\x9f\x5e\x5c\x85\xbd\x6b\x50\x59\x3a\x3e\x7f\x1b\x89\xc4\xae\x5d\xcb\x9a\x98\x9d\xad\x6d\x5f\x1d\xe3\x8e\x76\xd4\x9d\xb3\xec\x23\xaf\xd8\x62\x9b\x97\x31\x31\x31\x59\xaa\x68\xee\x0c\xcc\x7e\xfe\x18\x86\xeb\x40\x94\x73\x66\x66\x16\x0e\x20\x41\x0f\xb1\x7e\x4a\xd7\xff\xf0\x10\x8f\x1b\x13\x7a\x83\x1d\xe2\x84\x00\x88\x93\xc6\x48\xf7\xea\x24\x8e\x80\xa5\x4a\xf4\x17\x0d\x50\xa2\x0d\x03\x31\x08\x2d\x29\x9c\x90\x0a\xdd\x25\xbf\x40\x77\x09\xcc\x5d\xa6\x44\xff\xf7\x25\x68\x81\x1e\x12\x08\xbf\x46\x0c\x87\x1e\x12\x69\x8c\xbb\xe4\x02\x08\x50\x8a\x04\x5f\xb8\x01\x37\x04\x5f\xce\xe7\x4d\x00\x38\xc4\x49\x64\xae\x37\xc1\xdf\xf8\x02\x5e\xc0\x42\x25\xbe\xc0\x17\xd1\xee\x09\xf4\x42\xa4\xed\xc2\xfb\xee\x0a\x65\xfb\x7f\x09\x08\x17\x06\x43\xc7\xbd\x32\xe8\xc0\x65\x5f\xc0\x80\x7b\xbd\x79\x05\xa9\x96\x16\x4b\xef\x3a\x3c\x04\x7f\xca\xf9\xbb\xe8\xab\xe2\x2f\x0b\x8f\xe6\x93\x10\xd0\x7c\xe5\x4a\x33\xdd\x3c\xff\x0a\x06\x34\xb3\xeb\xf2\xe7\x14\xce\x28\x26\x5f\xff\x2e\x3a\xf0\xc9\x07\xb5\xef\x32\x28\x9b\x5f\x2c\x09\xd9\xc0\x49\x8f\x24\x5b\x52\x72\xd3\xd9\xa9\x86\x25\x19\xa9\x74\xea\x85\x8c\xbb\x06\x56\x7a\x37\x27\x5d\x9f\x92\x4c\x6f\x28\x09\xa9\x60\xaf\xcc\x07\x99\xe8\xc5\xd3\xda\x03\x37\x38\xe7\x73\xb0\x52\xf7\x9b\x88\xf6\xa8\xfa\x0d\x81\x74\x60\xcc\x86\xcd\x51\xec\xc4\x26\xa2\xb9\xa6\xba\x65\x2f\xbd\x37\xa1\x25\xbc\x86\x95\x16\xbf\xfe\x03\xab\xa9\xcd\x33\x86\xc4\x0d\x60\xa2\x44\xbf\xb8\x82\x88\x96\xcb\x3c\xcf\x5d\xbe\xda\xdc\xdc\xcc\x35\x37\x83\x3f\xf8\x3f\x7b\x46\xf2\xcf\x9e\x81\x8c\x05\xed\x41\x88\xdc\xc7\xd3\x0a\xa7\x20\xf8\x53\x7f\xff\x16\xb7\xf9\x2b\xce\xc9\x8b\x78\x8c\xdc\x87\xda\x83\x2c\xca\x86\x3e\xe3\xb9\xa1\xcf\xd0\x1f\xfc\xc3\x9b\xc9\xe6\xf0\x05\xcd\xf3\x18\x7e\x1e\x1f\xc1\x0e\x77\x05\x11\x3e\x7e\xd0\x2a\x39\xa0\xf4\x52\x10\x7f\x3a\x4c\x54\x5a\xaa\x5e\x97\xc6\xe1\x84\x65\xef\xc2\x0d\x18\x75\x86\x38\x57\x79\xfc\xb3\x2f\xe8\x7b\x73\x2e\x4c\x49\x4b\x37\xe4\xa4\xb3\x38\x2e\x60\x05\x8c\x25\x2e\x26\x2e\x3b\xb0\x80\x99\x3c\x6f\xee\xe4\x54\x4b\xaa\x35\x8d\x3b\x83\xfe\x78\xf9\xdd\xe5\xe0\x4f\x5c\x4a\x0c\xd8\xbf\x80\x99\x34\xff\xbf\x9a\xd3\x38\x06\x47\xad\x20\x16\x27\x6e\x59\xb6\x90\x9e\xf4\xc5\xa7\xf7\xca\xca\x2c\xd6\x32\x16\x46\x9e\x79\x81\xd7\x70\xe4\x7f\x35\x13\x3f\x5f\x74\xbf\xbc\x3c\xd7\x5d\xf3\xc1\xe9\xb3\x38\x9e\x58\x54\x75\x36\xe8\x32\x73\xef\xca\x97\xdf\x94\xe9\xcb\x74\xa5\x5c\x00\x4c\x80\xcb\x2f\xcf\xe2\x87\xc4\xa2\xaa\x73\x41\x97\x99\x6f\xaf\x5c\xfb\xb6\xcc\xe0\xae\x59\x06\x93\x60\xfa\x45\xe2\x52\x75\xcb\x91\x2b\xf4\x77\x0b\x2e\x7d\xc8\x76\xb6\x62\x29\xf5\x2e\x5c\x83\xcb\xaf\x5e\xe0\x75\xc2\x47\x88\xbb\xd2\x15\x1e\x6e\x07\xbb\xd7\x0e\x49\xf3\xeb\xf6\x37\x6b\x7d\x3b\x3b\x44\x6f\xc2\xc9\xe6\x88\x77\xa6\x54\xc4\xef\x4c\xfb\x65\xfe\xef\x4b\x7f\x99\x4f\x86\x1d\xbb\x10\x72\x91\x81\x6f\x24\x17\x2f\xb4\xb5\x1c\xe3\x7e\xb9\xf2\xdb\x85\xa7\x5f\xd4\x96\x56\x57\x56\x56\x93\xa0\xf4\x5e\xbd\x78\x51\xd0\x76\x76\xf4\xe2\xd1\x4b\x47\x2f\x21\x63\xb7\x2e\x58\xb7\x8e\x59\xb7\xe0\x68\xdd\x56\x6e\xcc\x85\x91\x67\xc7\x5c\x24\x37\x35\x2c\xbb\x78\x86\x0e\x56\xb2\x8e\x0e\xd1\xb9\x03\xeb\x97\x77\xa5\xba\x6f\x87\xd0\x04\x05\xf1\x67\xbb\x27\xdf\x2e\xe8\xff\x11\xa2\x60\xb4\x10\xdd\xee\x05\x52\xf7\x73\xfb\x79\x98\x85\x65\x50\x80\xbd\x58\x97\x97\x53\x43\x6c\x1c\xba\xa3\x1f\x7a\xd1\x0a\x82\xdc\x4f\xfd\x1a\x76\x2d\xf2\x14\x1b\x74\x25\xf8\xf4\x65\xfa\xd6\x99\xab\x77\x58\x4b\x2e\x6f\x61\xa0\x17\x2a\x71\xde\x5d\x5c\xcb\x60\x0d\xaa\x91\xc5\xad\xa8\xe4\x2a\xca\x8d\x25\x0c\x7f\xdf\x04\x3d\x61\xa7\x04\x5a\x3a\x3b\x60\xb2\x60\xc2\x1e\x70\x9f\xe0\x37\xe7\x06\xe5\xb2\x9b\x2c\xd6\xcb\x07\xf5\x24\x48\x33\xef\x18\x79\x9a\xbf\x67\x82\x5e\x6e\xc1\xdd\x9d\x5f\x7e\x0d\x76\xa2\xf9\x55\xfd\xd7\xd7\x68\x97\xa5\x1f\x85\x29\x9d\xa3\x89\x84\x1b\x1d\xea\x3b\xcc\x8f\x0f\xcb\x1a\xee\x71\x06\x8b\x21\xd7\x98\x4b\x0a\x93\x9d\xd7\xa9\xdc\x58\xf3\xf6\x68\x7a\x4a\xe2\xd8\x20\xf4\x66\x51\xd5\x39\x91\x80\x64\x90\xc3\x70\xe0\x61\x2f\x0d\x74\x28\xf4\x5a\x04\xdd\xd8\xce\x71\x42\x2d\x05\xd3\x94\xf0\x95\x92\x53\x38\x06\x7b\xbb\xc2\x05\x42\x29\x84\x0b\xe1\xf0\xb9\xc4\x4d\x04\x99\x4b\xe6\x0a\x77\x85\xbb\xba\x28\xe7\x53\x2d\x50\x4a\xa8\x15\x0e\x40\x9d\x97\xf3\x16\x54\x49\xb0\x0e\xe5\x84\xc2\xb9\x57\xcc\x8b\xf1\x8b\xfd\x98\x01\x53\x60\x23\x0d\xcb\x21\x18\xc6\xc1\xfe\x93\x2c\x4c\x17\xbb\xe6\xae\xc0\xef\x31\x13\xf7\xd3\x78\x12\x5e\xa1\x41\xd8\xb8\x99\xe5\xc5\x50\x07\x32\xc2\x31\xca\xf9\x29\x85\x7e\x93\xb1\xcf\xb7\x38\xf1\x1c\x2e\xac\x91\xe3\x74\xf1\xcb\xa4\x67\xdb\xbe\x59\x87\x83\x26\xf8\x0a\x35\x28\x22\x7c\xa0\x09\xed\x6e\xff\x4d\x06\x39\x12\x4f\xb0\xa7\x4b\xbc\x9c\x01\x50\x25\x79\x1d\xe0\x92\x11\x91\x4a\x71\xe8\xee\xa8\x7d\xac\x82\x78\x25\xda\xb7\xbb\xb1\x95\x03\x19\xc8\x44\x0a\x87\x1a\xed\x54\xa7\x7d\xb1\x78\x6b\x44\x54\x28\x37\xff\x80\xf2\x8a\xb8\x35\xa2\x71\x2b\xbb\xd8\x61\x47\x7b\xa7\x1d\x65\xff\x4f\x2a\x52\x10\x93\x5e\x07\x50\x0a\x87\x44\xd4\xa5\x84\x32\x85\x58\x0d\x06\xa5\x5b\xcd\x47\x68\x0a\x54\x2a\xba\x7b\x78\x29\x44\x7f\x38\x16\x53\xae\x5b\x38\x97\xd0\xa5\xa6\x1a\x52\x99\xd4\x54\xb3\x35\x95\x73\xdd\x82\xb9\xc9\x78\x83\xc0\x7e\x5a\x38\x8e\x62\x78\xc9\xc0\x4b\x38\x5e\x29\xd1\x72\x82\xdd\x21\xa3\x4a\x32\x8b\x32\xac\xec\xeb\x17\xf0\x82\xc8\x31\xe9\x79\xbd\x5e\xcf\xe7\xf4\x78\xef\xf5\x0b\x7c\x41\x64\xe8\x32\x55\xe9\x74\xba\x5d\x55\xac\x63\xe1\x51\xff\x85\xfe\x91\xd8\x3b\x1b\xbb\xcb\xb7\xc6\xc7\x6c\x5e\x43\xaf\xdf\x19\xd4\x1a\xc7\x2e\x71\xcd\x32\x66\x5a\x32\xf3\xb2\xe4\x59\x6f\x3e\xf2\x04\x88\xec\xf6\x5c\x5b\x1e\x97\x67\xb3\xd8\x8d\xf6\x25\xc2\x2c\xdf\xd6\x9d\x3b\xf7\x1f\xa1\x8f\xc5\x1e\xd8\x5a\xc3\xe6\x03\x73\x00\xba\x9d\x3f\xe2\xf0\xc3\xcd\xbe\xb9\x46\x0b\x6f\xb1\x58\xf8\xdc\x1e\xef\x39\xdd\xed\x17\x5b\xed\x45\x25\xb4\x0f\x1c\x54\x3a\x46\xc2\x6a\x2f\xc7\x9f\xc2\xd7\x14\x74\x87\x8d\xd0\x1d\x36\xc0\x5b\xb0\xe1\x06\x74\xbf\x06\x3d\xee\x41\x37\x92\x17\xf3\xe2\xcc\xe0\x20\xdd\x56\x26\x24\xc4\x6a\x0f\xe5\x90\x46\x0b\x8e\xc2\x6c\x7c\x1f\x75\x38\x08\xf4\x38\x0c\xb2\xd1\x0f\x4c\xa4\x36\x64\x6b\x56\x30\x13\x1c\x92\x67\x0f\xe5\x60\x13\x7e\x01\x1f\xe1\x3d\xf8\x14\xbf\xca\xe8\x5c\xe9\x9b\xd7\xda\x6a\x6d\x65\xda\x5a\x75\xd9\x7b\xba\xd2\xa3\xb7\xc1\x03\x28\x17\xde\x82\x36\x4f\x1e\x8e\x78\x39\xec\x8e\x4c\x0a\xcb\x85\x39\x62\x24\x92\x51\x84\x51\x78\x9e\xc1\x52\x0c\x83\x48\xa8\x86\x6a\x70\xd3\x52\x18\xfc\xe7\xfc\x80\xf3\x1c\x6c\x85\x75\x04\xf4\x42\x1a\x67\x7e\x8d\x5b\x18\xd7\x14\x7c\x86\xcf\x5c\x53\x5c\x53\xe0\x19\x3e\x13\xa6\x08\x8b\xe0\x18\x5c\x15\xe6\x9d\xd2\xed\xcb\xda\xcf\x75\x6e\x13\xf9\x54\x43\xe3\x61\xe8\x07\xb3\x61\x30\x6c\xf5\x14\x5e\xc2\x6c\x88\x80\xd9\x5e\xce\x7b\x02\x41\x69\xf3\xd3\x79\xad\x96\x0c\x0e\x9e\xaa\x0a\x60\x02\xa6\x14\xed\x0d\xe1\xde\xb0\x32\x33\xf9\x74\xbb\x96\x5c\x7a\x1e\xba\xe9\x9a\x99\x66\xe8\x66\x3d\x7f\x9e\xb3\xe7\xf3\x25\x99\x76\x12\x2f\xc1\x5c\xea\xe4\x96\x03\x81\xab\xb7\x6c\x59\x1d\x78\x60\xcb\xc9\x13\x07\x0e\x9c\x60\x05\xae\xcf\xc9\x2d\x07\x56\x07\xbe\xe1\x9d\x38\xe9\xe6\x41\x2e\xf4\xa0\xd6\xc6\x6c\x09\x4a\x64\xad\xc9\xe6\xc4\x24\x1a\x97\x62\x18\x0e\xc7\x72\x2c\xc3\x30\x18\x0e\x4b\x2b\xcd\x95\xb9\x15\xec\x96\xaa\xe8\x03\xc7\xe9\x6b\x67\x4e\x5f\xdb\xb3\x3b\x3d\xae\x86\xbd\x7f\x0e\x3c\xda\xa0\x87\xf5\x06\x5c\xf5\xb5\x14\x16\xe6\x17\xea\x61\x7b\xa0\x6f\x63\x69\x53\x75\x2b\x73\xf2\xc0\xe6\xc0\xc0\x2d\x9b\x57\x07\x6e\x39\x70\x82\xc3\xb5\x47\x16\x60\x1b\xbc\x9d\x03\x9e\x21\xf7\x97\xc9\x6b\x6a\x9a\x4a\xf6\x30\xd7\xce\xac\x98\xcb\x81\x33\x92\xca\x95\x8c\x54\xb2\x3e\x70\x7f\x2f\xbc\x0d\xc3\x41\x06\xb3\x61\x38\x5c\xf2\xe4\xe1\x12\x84\xc3\x70\x58\x00\xc3\x21\x1c\x2e\x79\x39\xa7\x09\x43\xa9\xac\x7c\x15\x9f\xa5\x25\x23\x22\xe6\xa8\xd7\x32\x6b\xe7\x14\xee\x8e\xe0\xde\xb0\xb2\xb2\x78\x95\x2d\x8b\x0c\x3c\xf1\x34\xa7\x81\x69\x78\x9a\x7b\xe2\x04\x67\xb3\xf1\x45\x59\x36\x12\xcb\x60\x24\x05\x16\x09\xfc\xd4\xc7\x7d\x0c\xff\x87\xda\x12\x17\x1a\x96\xc2\xe6\xa6\x9a\x53\x53\x68\x1c\x8f\x0b\xd0\xd7\xed\x6b\xe0\x7c\xf0\x85\xf1\x65\xe6\x72\x4b\x29\xbb\xad\x7c\x47\x6b\x3b\x7d\xee\xe8\xd1\xf3\x8d\xbb\x54\x89\x95\xec\x8d\xe3\xbf\xec\xfe\x27\xf7\x12\x54\xfb\x9a\xed\x76\x5b\x81\x1e\x96\x6c\xf2\xdd\x55\xbc\xab\xbc\x89\x39\xd8\x1a\xba\x69\x53\x68\xe8\xa6\x4d\xdb\xf6\x1c\x34\x72\x38\x6d\xff\x72\xcc\xf9\x47\xff\x34\xe2\xe6\x1a\x79\x65\xe5\xae\xa2\x06\xe6\xfc\xd1\x75\xcb\x38\xb8\x24\x04\xfa\x29\x03\x95\xd0\x01\x43\x7f\x81\xc1\xbf\xc0\x90\x5f\x60\x08\xfc\xe8\xe5\x78\xe5\x58\x48\x2d\x6a\x20\xce\x88\x77\x25\x54\xc7\x6e\x4f\x48\xd8\xce\x62\x8b\xd8\x6f\xf4\x58\x3f\xf4\x1c\xf3\x18\x3c\x59\x9e\x37\xc1\xdb\x34\x0c\xc5\x1e\xa2\xed\x55\x09\xbb\x76\x55\x57\xef\x62\xa1\x4d\xfc\xf2\xc7\x07\x2f\x5f\xfe\x38\xae\x1f\xbb\x50\x0c\x39\x18\x4b\xa1\xe7\x18\x7f\xf4\x40\x8f\xd1\x8f\x5f\xb1\xf0\x8e\xf8\x52\xf4\x8f\xbb\x08\x7c\x47\xbc\xbd\x3a\xa1\xee\x8d\x4a\x6f\x18\x22\xc6\xb7\xbb\xa2\x80\x7e\x04\x96\xf2\x93\xc0\xe0\xe1\x0a\xe2\x98\x27\x0f\xf7\x61\x23\x7c\xfb\xef\x7e\xdf\xcb\x79\xcc\x71\x95\x82\xbe\x9f\xc2\xca\x0b\x04\x28\xc4\x90\x8a\x2b\x61\x21\xa6\x63\x1a\xae\xc2\x05\x98\xcc\x76\x7a\x88\x97\xae\x5b\xbf\x6c\xd9\xba\x23\xe7\x59\x28\xc5\xfb\x62\x2c\xe3\xf5\x3c\x8b\x1a\x08\xc0\x00\xd0\x80\x0a\x56\xc0\x12\xc8\x60\x05\x41\x7c\xee\xe8\xd1\x73\xe7\x8e\xae\x5b\xc6\x0a\xf5\xf8\x0b\x85\x0d\xe2\x65\x6f\x14\xcf\xb1\xb0\x53\x8c\x2b\x97\x60\xdf\xcf\x09\xac\x16\xa3\x0a\x96\xe3\x52\x50\x83\x06\x02\x20\x00\x34\x2c\xcf\x5b\xa0\x8c\xf6\x41\xd9\x95\x38\xe5\x15\x4f\xde\x7d\xf4\x52\x10\xa7\xc1\x9f\xc2\x9e\x83\x06\x61\x4f\xd6\x15\xe7\x08\xe8\x0c\x10\xe2\x44\xd0\xf3\xcf\x3f\xa1\x27\x2b\xc4\x75\x06\x38\x02\x5c\x71\xa2\x2b\xce\x00\x3f\x25\x34\xed\x82\xf1\xdf\xc1\x04\x81\x80\x09\xfc\x77\xbd\x79\xd8\x04\xef\xc0\x46\x81\xe8\xa2\x9b\xbe\x83\x8d\x6e\x22\xfd\xf3\xb4\x74\xbd\x07\xdc\x57\x78\xff\x44\xe1\x7e\xbc\xdf\xb9\x50\x68\x74\x86\x8b\xa5\x11\x1e\xb8\xb1\xf3\x12\xdc\x94\xc0\x7e\x98\x40\xc1\xa6\xce\x85\xb8\x49\xe4\x0c\xf7\x86\x4d\x22\xe9\x4a\x0f\xdc\x88\x9b\xc4\x70\xe0\x43\xaa\x73\xa1\x58\xfa\xe4\x34\xdc\xff\x10\xef\xe3\x78\xa1\xc9\x39\x53\x84\x9b\x5c\x4d\x6e\xb5\x03\x30\x81\xea\x5c\x08\xf7\x3e\xc4\x7b\x38\x5e\x68\x74\xce\x14\xff\x5b\xe3\x83\xb2\x1f\x1c\x3d\x2b\x05\x01\xe6\x78\xf2\x70\x14\x42\xc0\x17\x42\x60\x0d\x44\x43\xad\x97\x73\xb7\x50\x4c\x3d\x82\xb5\xca\x87\x1c\x3e\x13\xa6\x53\x0f\x61\xad\xf2\x11\x27\x5c\x74\x7d\x44\xe1\x6c\x64\x70\x00\x4e\xdc\x18\x94\x57\x1c\xca\xe2\x66\x31\x86\x6c\x26\x1c\x3d\xc5\xf7\x72\xef\xb4\x9d\xfb\x7c\xef\xfe\x5d\x47\x4b\x4f\x91\xe6\xe2\x62\x53\x31\x03\x13\xc1\x2d\x3a\xdb\x6d\x63\xda\x7f\x8a\x93\x36\x05\xd9\x8a\xfe\xb7\xe2\x7d\xf8\x54\xbc\xf3\xd0\x89\xe2\x13\x0c\x4c\xfa\x57\x5a\x70\xc2\x1c\x3f\x25\x54\xd9\x12\x0e\x95\xc1\x08\xe8\x03\xe9\x87\x2d\x97\xc1\x06\x7d\x7a\x0b\xc7\x60\x3c\xfc\xd5\x96\x05\x7d\xa5\x37\x3d\x14\xde\x17\x85\xe7\x94\xb1\x3a\xe7\x18\x48\x96\xe4\xc3\x5b\xf2\xd5\xb1\x04\x8c\xf9\x64\x7f\x13\x06\x32\xab\x36\x65\x6b\x56\x71\x96\x24\xf7\x8d\x63\x83\x6a\x73\x44\x38\x7b\x3d\x89\xc8\x56\xe7\xa8\x55\xb4\xb4\xa7\x7a\x26\x0c\xbe\xec\x47\xcf\x47\x19\x0e\x58\x10\x8d\x63\x60\x66\xab\x89\x35\x95\xc1\xbc\x03\x44\x55\x6e\x51\x79\x25\xbd\x33\xb1\x2c\x3e\x03\x95\xe1\xba\x78\xb6\x22\x2b\x69\x77\x3c\xa3\x56\xab\xf5\x6a\x4e\x3a\x44\x1d\x9e\x39\xcd\xd8\xb2\xc8\x95\xd2\xcf\x37\x29\x47\x95\x9c\x44\x27\x54\xa6\x54\x37\x08\x33\xfe\x28\x3e\xc7\xda\xd5\x36\x75\xa1\x96\x5c\x7d\x13\x58\x34\x5f\x60\x1e\x80\xe4\x9b\xeb\x47\xb9\xc2\xd2\xe2\xc2\x4a\x83\x79\x0d\x7a\x7f\xac\x0b\x23\x73\x22\x4d\xa1\x11\x74\x1a\x9f\x6a\x4e\x65\xb3\x76\xd6\xea\xeb\x98\x2f\xaf\xd6\x18\xbe\xe4\x4a\x3b\x6a\x3a\xf4\x77\x8c\x2d\xbe\x3a\x78\x2b\xac\x74\xc2\xcd\x9c\x5c\x9d\x35\xc7\x9a\x97\xeb\x5b\x60\x26\xe0\x73\xf4\xee\x94\xe2\x58\x08\xe0\x80\xfc\x0c\x94\x47\xc0\xe3\xcb\x81\x3f\x7c\x78\x73\x16\xbc\x85\x12\x08\xc4\xf7\x20\x0c\x8b\x35\xe4\x25\x50\x51\x36\x6b\x65\x71\x11\x2d\xed\xe5\x51\xbe\xb9\x51\xb7\x87\xdd\x5f\x75\xc2\x74\xa8\x00\x34\xe7\x61\x32\x48\x5f\x42\x6c\xf5\xe1\xaa\xa3\xe6\x13\x59\x99\xbe\xef\xe3\xcc\xd4\x75\x38\x19\x65\xe8\x35\x0e\xfb\x04\x60\x9f\xd5\xa4\xb4\xa7\x3a\xde\x44\x7c\x2d\x56\x19\x03\xf5\x69\x97\xb6\xd5\xca\xe7\x7d\xb4\x7e\xd6\xb0\x90\x0d\x29\x3b\x92\xe3\x37\x93\xcd\xd7\xbf\x2a\xbc\xc3\xdc\xde\x6d\x51\xd7\x72\x3b\x35\xe5\xf1\xfb\xd7\x93\x52\xc2\x03\xb7\xbf\xfe\x80\xaa\xc5\x51\x44\x56\xfb\xc1\x9c\x83\xcc\x83\xef\xca\x1a\xbf\xe1\x5a\x53\xe6\xc1\xa8\x30\x66\x2e\x8e\x0a\x0b\x09\xe0\x50\xeb\x60\xa8\x07\xb8\xad\xe3\x38\x21\xed\xa9\x46\x4f\x98\x45\x08\xab\x5d\xbb\xa8\x74\xd1\x42\xd3\x27\xa9\x0b\xb3\x6c\x1b\x7d\x77\x5b\x61\x7a\xc5\x2e\xda\x6a\xc8\x33\x5a\x59\xd7\x3a\x07\x49\xd9\xd4\x6a\x4b\x06\x13\x97\xa0\x36\xc4\x71\x79\x29\x04\x1c\x76\x39\xa9\x61\xe2\xf6\x22\xcd\xf7\x84\xe3\x0f\x05\x71\x8b\x32\x89\x8d\x62\x5e\xcc\x7b\x1b\x72\x8c\x7a\xb3\x99\x30\x59\x29\x93\x89\xf0\xc1\xcc\xef\xcf\x40\xef\x79\xd7\x81\x80\xb7\x7a\xf3\xf0\x48\xe1\x9d\x71\x5a\x5a\x27\x3d\xaf\xf0\xce\x5d\x4d\x99\xb3\x2c\x1a\x95\x8a\x94\xd6\x69\xb5\x53\x96\x8f\xc8\x1c\xa9\xc5\x9e\xd9\x33\xae\xab\x8a\x72\xcb\xf3\x6d\xa4\xcd\x9e\x67\x2d\x64\x0a\x0c\x7c\x8e\x95\xdb\xbe\xe7\x54\x1c\x78\x30\xe0\xf1\xf5\xee\xba\x3d\x9c\xb4\xa3\xac\x28\x4f\x63\xce\x22\x83\x40\x4c\xd9\x52\xb2\x34\xe9\x59\xaa\x6c\xa3\x45\x55\x43\xd6\xa8\x34\x35\x8b\x99\xc5\x49\x09\x71\x51\x5c\xf4\x0e\xb5\x56\x53\x4c\x4a\xeb\x34\x25\x96\xe2\xca\xf2\xca\xf2\xa6\xfa\xc6\x22\xb2\xa8\xb1\xd4\x50\xcf\xd4\x37\x1a\x32\xaa\x38\xe9\x89\xaa\xf4\xa2\x48\x5b\x0a\x09\x00\x7b\xa8\x15\x29\x1f\x6c\x59\xc4\x6e\x5e\x1c\x1b\xbf\x26\xf7\xd3\x5c\x7c\x1b\x96\x4d\xb1\x90\x96\xc1\xb8\x0d\x83\x70\x32\x33\x30\xa2\x64\xe7\x36\x4e\x5a\xb7\xaa\x75\xc7\x59\xd3\x57\x66\xf0\x85\x77\xa0\x27\x8c\x34\x41\xa0\x19\x94\x18\xf8\x87\x99\x34\x3d\x84\x71\x30\xf1\x1e\x23\x6d\x79\xb8\x73\xcc\x4a\xce\x7d\x23\x12\x96\xe3\x43\xd8\xb0\xbc\x85\x1d\x7d\x6e\x5c\xcd\xb8\x73\x2b\x5b\x67\x3e\xfc\xb4\x83\x94\xd6\xa9\xb1\x7b\xe8\x9a\x4d\x61\xe3\x66\x2f\x4f\x98\xbe\x85\x5c\x10\x86\xbf\xe0\x7a\xd7\x1c\xda\x35\x57\xf0\xc2\xaf\x84\x61\xc2\x50\x78\x05\x27\x84\x00\xd6\xa7\x06\xc2\x1c\xad\x10\xee\x09\xef\x43\x98\x63\x0f\x84\x79\x39\xcf\x0a\x5b\x28\x1c\x0a\xc3\x70\x2c\xfa\xe3\x50\x1c\x16\x19\x19\x18\x38\x89\x0f\x3c\x21\x0f\x3c\x69\xbc\x77\xf2\x44\x61\xa1\xaf\xbb\x56\xa5\x1a\x33\x26\x12\x7b\x36\x22\x21\x1f\x99\x30\xe7\xc3\x21\x34\x8a\x7e\x1e\x01\xc4\xef\xdf\x5d\xff\xb9\x9a\x05\xef\x68\x78\xa7\xe9\xc9\xe3\xa6\x26\x5f\x18\x0a\xc3\xdc\x1e\x1c\x81\x4f\x1d\x53\x29\xff\x47\xf8\xf6\x6e\xf4\xda\x4e\xfe\x96\x3a\xfe\xce\x7b\x0c\x12\x23\x46\xa0\x68\xf0\xf5\x0f\x7f\x4e\xe4\x42\xb1\x7b\x03\xf6\xfd\x79\x64\x53\xa4\x2f\x2f\x86\xa1\x38\x0c\xc6\xa2\xbf\x5b\xdb\xed\xcb\xe1\x30\x18\x16\xd5\x18\x78\x82\xbf\x7f\xe2\x84\xfc\xc4\x89\x7b\xfc\x89\xc0\x22\x95\x2f\x0c\x83\x61\x84\xa3\xed\xf5\x01\xea\xf9\xd4\x87\x83\x4a\xd8\x06\xf0\x8e\x80\x77\xfc\x1f\x47\x35\xf9\xba\x15\xde\x28\xe2\x30\xf0\x47\x7f\x18\x86\xc3\x9a\x22\x4f\x04\xf2\x93\x02\x03\xe5\x6f\xc6\xa3\x2a\xf2\x75\x0f\xaf\x50\xf5\xf3\x08\x90\x47\x03\xd9\x26\xe7\xc5\x1f\x54\x7e\xff\xf1\x9f\x0c\x10\x3f\xff\x0c\x22\xce\xe0\x14\x28\x10\x8d\xf8\x19\x89\xfe\x63\xa7\x0e\x4a\x67\x91\xdc\x83\x7d\xa2\x46\x8e\x8c\x8a\xf4\x75\x9b\x75\x5f\x1f\x82\x17\x43\x57\x0b\xe0\xef\xee\x4c\x53\xd3\x9b\xbe\xc9\xdf\x34\xa4\x52\xf9\xba\x07\x52\x54\xf4\xd3\x4f\x8d\x40\x85\x81\x58\xfe\x67\xc9\x37\x8f\x9e\xd3\x3e\x68\xdf\xe7\x1c\x7a\x0c\x24\x57\x3d\xf9\xfd\x8e\x79\x87\x85\x9b\xfb\xbd\x1c\xef\x0a\xeb\x29\x73\xbe\xfa\x68\xb6\x39\xdb\x8c\x6f\x9d\x4c\xc9\x4f\xb7\x6d\x2b\x49\xb5\x1d\xb9\xd9\x70\x3a\x37\xdf\x56\x7a\xfc\xa9\xc9\x6a\xca\x33\xd5\x18\xad\x46\x6b\x8a\x66\x87\x96\xdc\xa1\x5d\x1f\x99\xac\x4f\xc9\x59\x96\x10\xa5\x89\xd2\x2c\x4f\x8d\xcf\x8e\xcf\x4e\x34\xaa\x72\x48\x53\x4a\x6e\x36\x4f\x5b\x74\x45\x19\xc5\xfa\x92\x9c\x9d\xa6\x02\x4b\xa1\xb9\xc2\x6e\xce\x35\xe7\xea\x8b\x72\x73\x73\x2d\x67\x8b\xab\xf2\xaa\x6d\xdf\xd6\x17\x18\xf5\xaa\x05\xd8\x3b\x61\x2b\x99\xb8\x15\xdf\xc2\x89\xb1\x51\x89\x71\xeb\x96\xa6\xaa\x72\x0d\x8d\x16\xab\xa5\xa5\xfa\xcc\xf5\x8a\xea\xcf\x3e\x3f\x7a\xb5\xed\x2c\xc9\x8b\x6d\xfa\xf3\x6b\x4b\x35\xa5\x9a\x8b\x61\xc5\xd9\xc5\xba\x13\x71\x66\x1b\x89\x9b\x84\x14\xaa\x58\xaf\xcd\xd5\x30\x1a\x63\xa4\x36\x4d\x97\x9e\x13\x91\x99\xa1\xcf\xd0\x47\xe5\xe6\xe4\xe6\xe4\xda\x43\x8b\x32\x6a\xe2\x2b\xf4\x76\x23\x59\x55\x97\x97\x57\xca\x95\xe6\xd5\x15\x17\x54\x9a\x73\xad\x36\x7d\x39\xe9\xf8\x14\x29\x6a\x1a\x2e\x04\x6e\x13\xa1\xc0\x48\xd7\x4d\xca\x59\x26\x76\xcc\x83\x74\xe2\x75\xb9\x58\x38\xfc\x90\x0a\x06\x06\x43\xae\xae\xc7\x6e\x03\x76\x43\x84\xd0\xf2\x67\x04\xcc\xed\x1c\x40\xb8\xfe\x76\xc6\x53\xc2\x4d\x58\x45\xb8\x7a\x8a\xb1\x54\x81\x66\xea\xd0\xcc\x88\x94\xa8\xa4\xb0\x34\x79\x20\x8a\xc6\xa5\x62\x2f\x66\x20\xf6\x6e\x3f\x32\x8a\xcb\xcb\x58\xdb\x98\xc9\x68\xb4\x5a\x75\x96\x39\x27\x4f\xc7\x7d\xfa\x00\x96\x2f\x78\xc9\x3c\x10\x35\xb6\xe4\xe5\x35\x72\xbf\x96\xfd\x79\xe0\xfe\x67\x07\xe6\xfa\x9e\x01\x7f\x02\x0e\x39\xef\x52\x38\xe8\x18\x21\x8c\x13\x17\x67\xe6\xab\x33\x3b\xbb\x61\xb8\x21\x8b\x75\x9d\x85\x40\xc2\x25\x13\x8f\x8b\xfa\x34\x51\x6f\xcc\x36\x68\x0d\xd9\x59\x06\x83\x51\x67\xd4\x93\xaf\x2f\x8b\x8d\x26\xa3\x91\xd6\x5a\x6c\xba\x7c\xa6\xc0\xb1\x09\x74\xb6\x32\x8e\x37\xf1\x8e\x12\x34\xb2\x5d\x90\x6f\x71\x6e\xb7\xcb\xbd\x41\x1c\x1c\xef\x82\x7d\x85\xf6\x2e\x46\x3b\xc8\xbc\xa0\x1d\x3e\x57\xa2\xec\x4d\xf6\x55\x90\x05\x4a\x9c\x1d\xc0\x29\x15\xc4\x46\x1c\x4f\xc1\x78\xf1\xe9\x88\xaf\x82\xf7\xb2\xee\x59\x4c\xec\x0d\x9e\xb1\x7b\x05\xd3\xe9\x7f\x45\xa2\x70\x7a\x84\x28\x1d\x2f\x44\xf3\x95\x9c\xc3\x2e\x7e\xba\xf2\xfb\x69\x87\xd9\xce\xb8\xd7\xdb\x67\x29\xc1\xde\x29\xfb\xef\xf8\x0c\xec\xd4\x6b\x99\xdb\x75\x42\xff\xef\x94\xe0\x2f\xf2\xd1\x4b\xc0\x0e\xf6\xae\x14\xf3\xe5\x12\xa1\xa7\x04\xca\x25\xd2\xcf\xfe\x52\x10\xd3\xa1\xea\xff\x48\x76\x3d\x52\x72\x40\x99\x24\xe9\xec\xc0\x76\x6a\x86\x52\x3a\xa3\x7a\xfe\x29\x09\x06\x78\xaf\x90\x48\x47\x9d\xfe\x48\xf9\xe6\x64\xc6\xff\xa2\xd2\x0d\x0f\xdd\x45\x19\xfe\x8b\x8b\x35\xff\x0d\x2c\xd6\x95\x37\xa8\x58\x57\xde\x80\x62\x41\x80\xf7\x87\x12\xc1\xae\x70\x9e\xa6\x26\x29\xa1\xc3\xfb\x43\x89\x74\xea\x48\xb0\xbf\xee\xf8\xff\xd2\xf1\x71\xa9\x30\x4b\x21\x5a\xec\x29\xc8\xba\xbe\x3c\x7a\x29\xbc\xeb\x9c\x31\xd4\xde\x7d\xfc\xa5\xe0\x7d\x5b\xf7\x2e\xe2\xb7\x06\x63\x12\x26\xf9\xba\xbc\x45\x98\x04\x49\x6f\x38\xf2\xe0\xad\xfc\xa2\xbd\x5b\xe1\x08\x1e\xf1\xed\xbc\x0a\x1f\x2b\x05\xd9\x15\x97\x0c\x3e\x56\x3a\xae\x8a\xe1\x08\x1c\x21\xf0\x2e\x4c\x48\x93\xf8\xf8\x05\x2a\x0f\x28\xbd\x1c\xd5\xce\x13\x14\xf8\x0d\x81\x8d\x38\x1e\xa9\x25\x28\x47\x6f\xf4\xfb\x1d\x37\xc2\x38\xa0\x2e\x80\x1c\xbc\x59\xfc\xd5\x95\x48\xc1\x00\xec\x0e\xab\xd1\x1f\x3d\x57\x0e\x18\x82\x03\xa0\x3b\xae\x02\x7f\xe8\x76\xea\xaf\xdf\x58\x81\xad\xa7\xd0\x80\x0f\xf0\x05\x6a\x90\x78\x14\xf6\x1b\x07\x03\x40\xf4\x03\xd0\x20\x03\x8f\x51\x40\x33\x7f\x3f\xaf\x02\x29\xa8\xf1\x01\xbc\x44\x03\x07\x5a\x08\xa1\x60\xdc\xef\xb0\x11\xfc\xc0\x7b\x09\xc8\x91\xc2\xf1\x43\x70\x23\xfa\xa1\xf7\x05\x94\x03\xc5\x09\x1f\x3f\xa7\xd0\x1f\xbb\xe3\x6a\x1c\x30\xe4\xd4\x40\xe8\x06\xfe\xd0\x1d\x56\xc1\x80\xdf\x56\xfe\x8d\x9e\x9c\xcf\x6b\x15\x70\x92\x2b\x0e\x99\x97\x23\xc0\x99\x45\x81\x1d\xfb\x43\xdd\x9b\xaf\x53\x58\x87\x76\x5c\xfb\x18\xfb\x82\xcf\x1a\x76\x7d\xe7\x17\x44\xa8\xa1\x3e\xaa\xd5\xed\xec\xb6\xd6\x37\xb6\x1a\xb8\xf5\x8e\x2f\x08\xf0\x39\xfe\x18\xfa\xc2\x5a\xda\x3d\x3b\x0f\x28\x3d\x79\xa0\x15\x44\x0a\xc8\xbc\x9c\xb2\xe1\x94\x23\x4b\xec\x90\x41\x3a\xd1\xd9\x53\xdc\x19\x20\x14\x53\x9d\x9f\x82\xcd\xd1\xb5\xa3\x8d\x00\xda\x40\x9d\xd9\x76\x7c\x75\x05\xdb\x19\x00\x76\xc2\x9a\x9e\x66\x49\x63\xd2\xd2\xf4\xba\x74\xae\x33\x00\xed\xc4\xea\xe4\x6d\x6b\x96\xd3\x9d\x76\xf1\xda\x5d\x1b\xdb\xe3\x59\x47\x80\x4b\x46\xa8\x2b\xab\x75\xd5\x4c\x75\xb5\xb5\xb0\x92\x73\x04\x08\x32\xa2\xbd\x66\xd7\xa1\x63\xb4\x8f\xd0\x64\x4b\xf0\x14\xec\xc0\x08\x6f\xc3\xdf\x12\x87\x6c\x28\xf8\x4a\x1c\xd3\x3b\xc5\xe0\x2b\xe9\xfc\x05\x7a\x50\x50\x25\x16\x64\x30\x81\xc0\x4a\xb1\x2b\x00\xc2\x28\xd7\x42\x58\x22\x74\xed\xb8\x84\x70\x30\x9d\x2b\xa9\x53\x91\x47\xd7\x54\xb3\xae\x4f\xe0\x53\x42\x78\x4f\x7c\x2a\xe2\xe8\xda\x6a\xd6\x15\x00\x01\x84\x2d\x35\xc5\x92\xc2\xa4\xa4\xe8\xb3\x52\x39\x57\x00\x06\x10\x6b\x13\x22\xd6\xad\xa2\x5d\xef\x89\x5d\x9f\xe0\xa7\xff\x9d\xf9\x8b\xd7\xd4\xaf\x3f\x9c\xc0\x0a\x01\x18\x47\x40\xb1\xc4\x62\x32\x9b\xcc\x66\xb9\xd9\x60\x36\x5a\x8c\x6e\xa6\x2f\x14\x4b\x88\xc3\xd5\xf5\x47\x8e\xd3\x3e\xd0\x64\x80\xc5\x38\x01\xc2\x60\x1e\x8c\xb6\xc1\x52\x03\x2c\x79\x05\xe1\xbd\x79\x68\x12\x56\xc0\x4e\x8c\x86\xa6\xef\x20\x57\xda\xea\xa1\x10\x4f\x50\x78\xef\xa1\xb0\xa7\x2b\x1f\x7a\x8a\xa1\xc8\x35\x95\x82\xde\x97\x67\xe0\xdb\x85\x9c\x6b\x98\x08\x7a\xe4\xdf\xbb\x03\x3d\x98\x32\xd7\x77\x14\x0e\x9a\xfa\x08\x06\x72\x8e\x81\x22\x53\xa9\xa9\xac\x8c\x86\x9d\x38\x1a\xe2\x71\x3f\xee\xc6\x25\xb8\x15\xeb\x71\x2f\xcc\xc6\x95\xd0\x0e\x51\xd0\xef\x77\xd8\x7a\x9d\xc5\xed\xa2\x29\x3b\x06\x6f\x9e\xc6\x28\x9c\x5f\x9c\xa4\xa4\x2b\xd4\xf0\x27\x9c\x15\x4b\x57\x7a\x80\xcf\xdd\x55\x48\xa1\x74\xc4\x16\x24\x38\x3c\x21\xec\xa1\xe0\x18\x14\x8b\xa5\xd3\xd5\x7f\xfe\x18\x8d\xa4\xdf\xac\x8d\xef\x73\xae\xb3\x42\x1e\xa5\x40\x99\x00\x62\x48\x86\x70\xe8\x06\x76\x18\x3d\x1d\xba\xe3\x88\xc3\x1c\x10\x67\x2e\x7e\x07\x52\x5a\xba\x67\x3a\xe4\xe2\xa2\xcf\x31\x82\xf5\x11\x7c\x21\x12\x3f\xba\xf5\x07\xf8\x98\x60\x41\xee\xdd\x2e\xc4\x87\x19\xd0\x8a\xad\x70\x0d\x66\x9c\x12\xbe\x04\x99\x34\xe2\xf4\x0e\x49\xa7\xc6\xe5\x45\x01\x03\xdd\xb7\xe2\xa8\xc9\xc1\xab\x66\x6d\xe3\x9e\x45\x1f\x9b\xf9\x3e\x8d\xfe\x48\xcf\xc6\xfe\xac\xab\xb7\xa3\x41\x04\x7f\xe3\x2d\xea\x8b\xc3\xf5\x5f\x76\x2c\x2d\x5f\xc8\xb9\xdd\x5b\x11\x2c\xc4\x27\xd4\xad\xf3\xb5\xf7\xee\xad\x69\x99\xc6\xe1\x12\x8c\x14\x39\xbe\x0e\xa7\x8e\x7d\xbe\xeb\x78\x29\x07\xac\x08\xfb\x6c\x1a\xf3\x29\x2a\x19\xa9\xcd\x03\xe7\xa0\x37\xbc\x0d\x9f\xc0\x34\x78\x0b\xfa\xc2\x0c\x98\xfd\x07\xf6\xc3\xc9\x1a\x5e\x63\xd4\x70\xae\x11\xa2\x91\xc7\x97\xff\xcc\x4a\x35\x1e\x1a\xa1\x1b\x35\x7d\xf5\xda\xe9\x3a\x0e\x6c\xa2\x3b\x59\x41\xc7\xa6\x30\x52\xbf\xe9\x38\x0e\x2a\xa9\xa9\x70\xfb\xae\xd8\xa7\x1a\x65\x3f\x0a\xfa\x1f\x97\xc3\x10\xe1\x15\x0c\xe9\xad\x10\x85\xc1\x10\xe9\x11\x85\x68\xb8\xf3\x53\x0a\x18\xec\x06\x9e\x48\x23\x83\x9e\xe8\x89\x0c\x32\xe0\x89\x9e\xc0\x00\x0d\xdd\xc0\x13\x18\x56\x7a\xb7\xb3\xb0\x33\x85\x42\x0e\xbd\xd0\x0b\xb9\xa1\x13\xce\x7c\xbb\x89\x95\x1e\x69\x4f\x6d\x4f\x69\x4f\xfd\x7b\x13\x90\x27\xdb\xff\x6e\xff\x7b\x35\x88\x07\xb4\xf7\x3f\xe8\x9b\x5b\x51\x61\xae\x60\x80\x83\x2e\x61\xce\x71\xcb\x91\x4c\xe1\x14\x54\xa2\x02\x27\xbb\x69\x57\x74\xd1\x64\x50\x82\x12\xa6\xb0\xd2\xbb\xee\x22\x2a\x71\x32\x07\x43\xfa\x48\x8f\x40\x2e\x6e\x84\x8d\x98\x8b\x16\xdc\x88\xeb\xd1\x6c\x60\x71\xaf\x6b\x28\x61\x52\xab\x4c\x2a\x66\xc1\xe2\x94\x88\x55\x9c\x4b\x0e\xa3\x08\xd7\x0c\x31\xa4\x8c\x20\xa4\x77\xf1\x83\x16\x50\xa2\x18\xc6\x31\xf0\x31\x0c\x04\x06\xa6\x97\x71\xc2\x5c\xb8\x4d\x40\x2e\x6c\x84\x0d\x60\xed\x7a\x69\xe4\x7f\xeb\xac\x90\x76\x52\xe8\x73\x0c\xde\x02\x7f\x4f\xe1\xe6\x45\x98\x79\x42\xe8\xeb\x3e\x93\x79\x29\xbc\xbf\x75\xbe\x4d\xf9\xf9\xc3\x5f\xca\xc7\xfe\xfd\x58\xd7\x2b\xd7\x43\x0a\xba\x8d\x79\x82\xdd\xd2\xd3\x0c\xfa\x0c\xf6\xbb\xb0\xfb\xe1\xfb\x47\x84\x4f\x92\x87\x4d\x1c\x11\x34\xa9\x39\xac\x24\xbc\x38\xac\x98\x5c\xd0\x72\x6d\xe3\xd7\x0c\x74\x7b\xf2\x04\xba\x71\x4e\x85\xe3\x12\x35\x44\x02\x1b\x95\xae\x50\x31\x9c\xc4\xb7\x88\xda\x03\xc7\x8a\x4f\x32\x05\x76\xde\x68\xe7\x20\x1e\xee\x10\xb0\xda\x0c\x63\xc1\x1f\x56\x33\xb0\x16\xc6\xe2\x58\x5c\x8b\x81\x38\x16\xc7\xe1\x5a\x0e\x7f\x47\x2b\x81\x8a\x0c\x14\xfb\xa1\x1f\x83\x32\xf4\xf8\x09\xde\xde\xce\xe1\xf4\x1b\x04\x7e\x20\xc6\x31\x40\x21\x05\x63\x58\x67\xc0\x40\x25\xf2\x8e\x70\x0a\x68\xf4\x00\x0f\xa4\x51\x8e\x1e\x5d\xf0\x74\x72\xf0\x40\x0f\x90\x03\x0d\x1e\xe0\x01\x72\xd6\xa7\xda\x90\xb0\x2f\x41\x41\xac\x4a\xec\x5d\xa6\x10\x3d\x94\xc6\x38\xee\x0a\x5e\x94\xeb\xe3\xb2\xa9\x45\x3c\x1d\x39\x7a\x25\x76\x3b\x30\xbc\x72\xc3\xa1\xc0\xcf\x72\x84\x09\x51\xbe\xe6\x9a\x52\xc1\x9b\x70\xf5\x15\xbe\xa7\x5c\xb3\xca\xc1\x6f\x2c\x31\x19\x7b\x85\x2e\xe0\x69\x3e\x74\xc1\xfe\x25\x2c\x2c\x45\x07\xc1\x57\xc3\x32\x88\x87\x02\x16\x06\x8d\x20\x9c\x6d\xc8\x52\x3c\x4e\x1d\x89\x3f\xb7\xb3\x59\x30\x03\x43\xf0\x35\xa4\xb8\xbc\xb4\x30\x81\x80\xf7\xad\xb7\x6c\x3c\xcd\xdf\xce\xdb\x75\x95\x85\xc5\x80\x44\xe7\x2e\xe7\x48\x6a\xfe\x8d\x8f\x7e\x1b\x64\x0f\xb4\x2e\x48\x8d\xde\x80\xf1\x28\xf8\x56\xaa\xe0\x26\x2e\x22\x20\x4a\xe8\x7e\xec\x0b\x9e\x76\xf4\xc7\x4b\x54\x92\x1a\xaf\xe1\x4a\x02\x52\x5d\x9e\x7b\x3e\xe6\xe9\x1f\xeb\xa0\x47\xd5\x99\x07\xbb\x0e\x96\x5d\x8e\x39\x42\x22\x08\x8f\x28\xa9\x75\x26\x50\x41\x9f\xf3\x34\xbf\xf5\xd2\xac\x6c\xd6\x35\xd8\x44\x48\x63\x78\x18\x83\xdd\xa0\x07\xde\x66\x71\xe8\x58\x61\x7c\x22\xc4\x08\xdd\x09\x1f\x68\x02\x19\x44\x29\x85\x38\x21\x00\x92\x25\x6d\xd0\x01\xd3\x25\x20\x60\x07\x24\x77\x7d\x35\x84\x9e\x83\xfe\xc4\x9e\x2c\xec\x92\x74\xda\x45\xe0\x23\x41\x99\xe8\xac\x04\xda\x24\x67\x25\x20\x83\x78\x09\x34\xf1\x10\xa5\x54\x88\xfd\x1c\x32\x0a\x76\x49\x50\x06\x71\xa2\x41\x12\x57\x00\x74\x48\x50\x26\x06\x1f\xc9\x7c\xd1\x59\xc9\x15\xa7\x7d\xbe\xf8\xac\xe4\x0a\xac\x90\x08\x32\xf1\xbf\x16\x15\x4e\x3f\x57\xdc\x25\x25\xac\x12\xe2\xdc\x2d\xae\x72\x9f\xf8\x54\x27\x78\x36\x2b\x88\xd3\x5e\x0a\xe2\xe1\x15\x68\x53\xba\x06\x0a\x83\x08\x48\x86\x3f\xfe\x2d\xad\x86\x3f\x94\x02\xa1\xdc\x23\x81\xbe\x12\xce\x25\x73\xc9\xec\x12\x58\x2d\x72\x0d\x74\x0d\xb2\x4b\x20\xf9\xdf\x82\xb0\x59\xa4\x9f\xaf\x9d\x33\x8f\x0e\xab\x8f\xd9\xc3\x42\x87\x68\x4f\x7d\x7d\xcb\x55\xed\x97\xfa\x2b\x9c\xb0\x79\x9b\x44\x50\x43\x6f\xe8\x05\x62\x4f\x1e\x34\xce\x6f\x61\x93\x97\x13\xe1\x5b\x2a\x3a\x3e\x31\x36\x43\x9b\x6b\x53\xb1\x5f\xba\x7f\x8c\x6d\x38\x88\x99\xf0\xa1\x3a\x75\x0a\xa7\x57\xa5\xea\x32\x99\xc8\xa4\xda\xba\xe6\xca\xd2\x9d\x56\xae\xfa\xd7\xa7\xc5\xbf\x33\x30\x19\x86\x6c\x9d\x0a\x14\x57\xa9\x2a\x54\x47\xd3\xcf\x20\x9c\x0a\xdb\x1e\xb3\x2d\x55\x6d\xcb\x53\xb3\x5f\x61\x2f\x9c\x71\x12\x97\x32\x43\xc6\xa7\x27\xcd\xe2\x72\xd2\xb4\x39\xe9\x4c\x58\x4c\x7d\x4b\x4b\x59\x4d\xb3\x9d\xab\x7d\xf4\xa4\x02\x28\x06\xd6\xc1\x8a\xd5\x23\xe1\x03\xae\x2e\xad\x20\x29\xc6\x3d\x23\x4d\xd4\xa6\x6d\x91\x5b\x53\x35\xb9\xf9\xe9\xec\xf7\xc8\x61\xc4\x51\x0c\x62\xde\x7d\x57\x13\x33\x84\xd3\xab\xd3\x75\x69\xcc\xe6\x88\xe6\xf6\x83\xbb\x6a\x1b\xf2\xb9\x66\xf0\x04\x9f\x52\x90\x33\x90\x00\x9a\xb5\x03\x61\x06\x57\x9b\x5e\x96\x14\x4c\xc3\x26\x1c\x4c\xf9\x49\x3a\x55\x28\x53\x88\xd4\xb0\x52\xa9\xf0\xbe\x49\xc1\x39\x3c\x23\x36\x18\x62\xa2\x8d\x0c\xbe\x8b\xbb\x36\x44\x12\xae\x5c\xd7\x18\x68\x16\xd5\x46\xe2\x39\xd7\x3d\x02\xcf\xc1\x19\xb1\xd9\x5c\xdf\x60\x62\xe0\x5d\xd8\x75\xb8\x89\x10\x72\x85\x31\xd8\x2c\xda\xb1\x9b\xf0\x11\x9a\x04\xe1\xd7\x6f\x2a\xae\x57\x7a\x0a\xfb\x8f\x9d\xfd\x0c\x98\x93\xfb\x7e\x7a\x71\xd3\xcb\x51\x07\x13\xa8\x0c\xa3\x46\x93\xc1\xa8\x34\x05\xc5\x46\x2e\x1d\xb2\x4b\x84\x2a\xa2\xb8\xb0\xb0\xa8\xb8\x40\x9d\x61\x62\xcb\x5c\x55\x04\xb4\x60\x28\x65\xdc\x41\x68\xf5\x59\xd9\x3a\x56\xa7\xcb\xca\xd1\x32\x99\xda\x5c\x5b\x36\x97\x63\x35\xe4\xe5\xd1\x5d\xab\x02\xd5\xa0\xe2\x4d\x3c\x5d\x20\x7c\x6d\xca\x23\x0a\xac\xf6\x7c\x2b\x6b\xb5\x58\xcd\x79\x79\x56\x83\xb5\xc7\x7b\xf9\x3a\x6b\xa6\x86\x2e\x72\x7d\x4f\xbc\x6e\x07\x8a\xb2\x1a\xf5\xb9\x3a\x46\xa7\xcf\xd1\x19\xb9\x14\x94\x95\x63\x6f\x42\x67\xb2\xe4\x58\x19\xab\x25\xd7\x6a\xe2\xaa\xa0\x37\x71\x0d\xb6\x50\x56\x63\x8e\x5b\x2c\x27\x47\xc7\xf3\x7c\x1c\x6e\xe1\x76\xe2\x7a\x22\x3b\x37\xc7\x6a\xcd\xcd\xb5\x9a\xd8\x5d\xb0\x81\x00\x1b\x1a\x29\x5e\xcc\x8b\x71\xb1\xa0\xa2\x6c\x3a\x6b\x76\xb6\x4e\x97\x65\x64\x13\xd0\x50\x8d\x1a\x22\xdb\x64\xd5\xe5\x31\x79\x56\x6b\x1e\x57\x07\x1a\xe2\x06\x58\xa9\x7c\x63\xb6\x35\x8b\xc9\xca\xd6\x69\xb9\x04\xb4\x56\xa3\x9e\xd0\xe6\xe9\x6c\xb6\x3c\x6b\xbe\x89\xdd\x09\x7a\xe2\x16\x64\x50\xf9\xc6\x2c\x9b\x96\xd1\x66\x65\x69\xb9\x44\xcc\xa8\x42\x23\x91\x69\xcb\xca\xcf\xb7\xd9\xec\x26\xb6\x1a\x8c\x04\xbc\xc6\xec\x37\xad\x1e\x74\x78\x52\x05\xda\xfc\x4c\x4d\x96\x56\x63\x64\x79\x9e\x4f\x76\xf5\x64\x2b\xd0\x48\x68\x4c\x36\x6d\x01\x63\xcf\xcf\x2f\xe0\x78\xb1\x5b\xa7\x43\x08\xa6\x0a\x33\xf3\x35\x6a\xad\x56\xdd\x25\x99\xea\x0a\x65\xcb\x50\x4f\xa8\x4d\xf9\xda\x42\xa6\xc0\x9e\x5f\xc8\xf1\xe2\x4a\xd0\x13\xdf\x0a\x56\xaa\xc8\x98\x59\xa0\x62\xd4\x1a\x8d\x8a\x4b\x75\x59\xca\x50\x47\xa8\x4c\xf6\xcc\x42\xa6\xc8\x6e\x2f\x32\x71\xbc\xb8\x02\x74\x84\x20\x41\x35\xc5\x8b\xe1\x1b\x09\x90\x4a\x0c\x74\x64\x50\x25\xea\xc2\xf4\x74\xb5\x3a\x9d\x4d\x77\xd9\x4a\x50\x4b\xa4\x9b\x0a\xd4\x25\x4c\x49\x61\x61\x09\xc7\x8b\x4b\x41\x4b\x3c\x10\x54\x54\x99\x51\x5d\x94\xc6\xa4\xa9\x54\xa9\x46\x4e\xe5\x52\x17\xa1\x9a\x48\x33\x15\xa9\x4a\x99\xd2\xa2\xa2\x52\x8e\x17\x97\x80\x9a\x80\xc0\x3e\xe9\x0e\xa9\xb1\x30\xbb\x20\xd3\x2a\xb7\xe4\x64\x9b\x75\x8c\x36\x4b\x9f\xa3\xe3\xb2\xb2\x73\x32\x8d\x99\xa4\x5e\xac\xea\xec\x99\x87\xdd\xf3\x50\x44\xa4\x98\x4a\xd2\xcb\x99\xf2\x92\x92\x72\xce\x7d\x49\x4a\x20\x95\x70\xfe\x56\x49\xc1\x28\x94\x82\x14\x47\x06\x05\x6b\xd3\xb7\xb1\x90\x1f\x87\x61\xb0\x16\x4b\x98\xf9\x0b\x55\xf1\x01\x5c\xbc\x36\x5b\x9b\x42\xbf\xee\x2b\x4e\x2e\xc9\x28\x37\xb0\x6e\x1f\x6a\x17\x8c\x04\x29\xf4\x86\x91\xac\x0f\xda\x21\x5f\xd9\x05\xd6\xed\xb0\x3b\xec\x54\x9e\xa4\xd3\xee\x9d\x27\x11\x64\xde\x79\x12\x9d\xc4\xbb\x2b\x7d\x9c\x18\xfb\x71\x28\x13\x63\x3f\xf8\x0d\xc5\xb0\x5f\x52\x29\x61\x41\x26\x86\x7e\xf8\x1b\x88\x5d\x93\x59\xb7\xff\x23\x3b\x13\x96\x00\x75\xa7\x1b\x2e\x0b\x71\x4f\x25\x42\xf9\xa5\xbc\xe3\x91\x6d\x5d\xe9\x38\x22\x0e\x74\x25\x86\x6f\xb3\xf7\x53\x4a\x7b\xea\x05\x7f\x91\xab\xd0\xf5\x11\xb5\xf8\xf8\xca\x87\xa1\x2f\x8a\x6e\x98\x2e\x99\x2e\x93\x05\x7c\x41\x01\x2d\x25\x49\x0b\x6f\x36\x5a\x58\xb3\xd9\x64\x31\x59\xf2\x9a\xf5\x35\xaa\x12\x52\xda\x66\x2f\xd0\xaa\xac\x69\x8c\x51\x94\x20\x4a\x4c\x4b\x8b\xcd\xe2\x92\xe7\x16\xa0\x77\x33\x7a\xee\x18\x1f\x3a\x66\xfd\xa8\x2d\x13\x43\xe6\x45\xac\x22\x4d\x46\xb3\xd1\xc4\xea\xf2\x35\x16\xad\x0e\x7b\xce\x5b\x3e\x55\xb3\x4e\x9f\x98\xab\xb6\xea\xba\x70\xec\x8d\xb5\x2a\x5f\x9d\xdd\x6e\x28\x60\x2e\x7d\xfb\x08\x3e\xfe\x87\x7b\xb5\x17\x06\xee\x06\xae\x94\xdc\xf0\xe0\xb7\xa8\x2b\xcc\xe9\xd2\xaa\x0a\x0b\xc7\xf3\x26\x9e\x35\x99\x4c\x66\x93\xa9\xb0\x36\xbb\x22\xab\x80\x6c\x8f\x1d\x97\x3f\x87\x09\x09\x32\xe8\x36\x71\x11\x15\xd1\x15\xb1\x55\xa4\x74\xba\xda\xd5\xe1\x1a\x41\x95\xee\x39\x76\xed\xce\x85\xf9\x03\x37\x6e\x8c\x4c\x27\x85\x77\x9d\xc3\x28\xb7\x26\x2d\xf5\xf6\xcb\xcb\xca\x53\x9b\x92\x4d\x06\xde\x60\x32\x1a\xf4\x46\x83\x51\x4f\x4a\xbd\xa7\x1b\x54\xfa\x74\x43\x8a\x21\xc3\x90\xa6\x4f\x75\x1b\xd1\x9e\xe3\x8f\x17\x34\x90\x52\x92\xc4\x9e\x9d\x83\xa9\xd2\xfa\xd2\x86\xd2\x06\x52\xda\x93\x6c\xbb\xd5\x70\xb5\xf2\xf3\x3d\x33\x0f\x2f\x3a\xb1\x91\x94\x92\xde\x76\x6d\x41\x56\x81\xd6\x2d\x38\x38\x79\x70\xf4\x98\x50\xd2\x41\x97\x51\xa6\x2e\xd7\xd8\x98\xa3\xe3\x33\x99\xc8\xf5\x05\x15\x81\x1c\x78\xee\x4a\xd2\x59\x39\x1f\xbd\xc4\x69\x07\xa9\x44\x98\x68\x83\x9f\xff\xc3\x90\x52\xe0\x36\x94\x51\x70\xda\x6f\x94\xe8\x0f\xd7\xbc\xdc\x54\x73\x8a\x29\x43\x6e\x4e\x20\x72\x45\xb9\xd5\x96\x62\x53\x79\x6e\x99\x1c\xde\x13\x0e\x12\x20\x12\xc1\x7b\xae\x83\x6e\x01\x4b\x86\xdc\x94\x65\xd6\x66\xd3\xb9\x22\x73\xb5\xa9\xd8\xec\x96\xf9\x43\x98\x47\x8c\x7a\x05\xa7\xfd\x66\x89\x70\x42\xe7\x60\x02\xc7\x88\x50\x26\x24\xeb\xca\x8c\x65\xfa\x12\xb9\xbe\x96\xc8\x11\x69\x8d\x5a\xa3\x96\x35\xa4\xea\xd3\x74\x69\x28\x73\x25\xfb\xba\x65\x26\x38\x06\x13\xb3\x44\x5d\x3d\x7b\x2a\x11\xbe\x7d\x3e\xea\xf9\x75\x90\xad\x50\x4a\xe1\x0d\xc0\x55\x48\xe7\x6e\xea\xba\x08\x56\x40\x1b\x2e\x81\x3a\x62\xf6\x2b\x38\xe4\x37\x4d\xf4\x12\xc7\xe4\x67\x5a\xb3\x72\xb3\xe4\x66\xbd\x59\x6f\xca\x21\xcd\x22\xa3\xbd\xb4\xa8\x92\xfd\x07\xc6\x10\x33\x5e\x41\xb3\xdf\x1c\x11\xae\xc4\x56\x08\xc0\x5d\xc4\xf5\x7e\x22\x29\xe2\xe1\x97\x5f\x8b\xfc\x60\x6c\x56\x41\x76\x5e\x4e\xbe\xdc\x60\x31\x58\x8c\xb9\xa4\x41\xa4\xcf\x4e\x4b\x52\x71\xef\xe1\x58\xe2\x4e\x3f\xdc\xd3\xe5\xac\x67\xc0\x24\x20\xa0\x1a\x74\x4f\x25\x42\x25\x14\x65\x74\x75\xa7\x53\xfd\xa6\x3f\x71\x9d\xbb\xa9\x9f\x85\xcf\x46\xbc\x12\xbc\x45\x47\x8f\xe6\xa4\xed\xe3\xbe\x0f\x3d\x33\x1e\x3d\x69\xf4\x5c\x36\x7c\x54\x04\x9b\x11\x12\x64\xd8\xc8\xa0\x12\x27\xfd\xd2\x0f\xef\x89\xe0\xa5\xd0\x87\x92\xbe\x56\xef\xde\x65\x2d\xa8\xe6\x0e\x56\x57\x1d\x3a\x47\x9f\x4e\x6c\x0f\xa9\x66\x8b\x12\x62\xf2\x42\x19\xec\x81\xd5\x5d\x8d\x6e\x93\xe0\xb4\x04\xa7\xec\xa9\x04\x92\x24\x2b\x94\xd2\xcf\xba\x5a\x43\x99\xab\x83\xc2\x0e\xe8\x70\xff\x35\x47\x2a\x09\xe9\x03\x0c\xe8\x02\x15\x72\xda\xc5\x9d\x1d\x82\x9d\x7a\xf9\xe8\xd1\x4b\x78\x28\xe1\xba\x7e\x63\x5d\x80\x1d\xfc\x9b\x34\x71\xbd\x79\xf8\xc0\x5d\x5e\xa1\x94\xfe\xb6\xd7\x21\x53\x78\xab\x61\xb1\x04\x64\x68\x87\xc5\x5d\x2f\x0d\xfe\x3d\xa3\xa4\xe5\x7b\xbf\x52\x8a\x1c\x8b\xa1\x98\xc2\xab\x70\xf5\xdf\xb7\x1d\xaf\x65\x57\x24\x5d\x09\x6f\xe0\x98\xf2\xcd\xab\x10\xd7\x62\xd0\x53\xe5\xd9\xe5\x99\xb6\x2c\xb8\x86\xd7\x7c\x6d\x59\xf6\x94\xbc\x14\xd2\xd5\x43\x24\xed\xe7\x27\xc8\xe0\x7b\x89\x02\x3d\x16\x4b\x04\x3b\x68\x95\x2e\xff\xef\xdc\x9d\xef\x14\xe3\x39\xaa\x41\x1b\x5b\x19\xc5\x4c\x06\x99\x20\x55\x8a\xa4\x33\xa7\xbf\x8f\x8f\x13\x16\xf2\xb4\x2e\x45\x9f\x92\x4c\xa3\x17\x78\x4c\xec\x82\x67\xf6\xb8\x0f\x5e\x15\xfa\x72\x5d\x39\x2b\xed\xe7\xc7\xc7\x7f\x31\x0e\x0e\xb0\xd2\x99\xd3\xb1\x9f\x6b\x2b\xf5\xf1\xd2\xc6\xd6\xd6\xf3\x8d\xb7\x6e\x9d\x8f\x0a\x0d\x5d\x1a\xf5\xb1\x7b\xb0\x82\x0c\xec\xc2\x9b\x8b\x35\x1f\x64\xd0\x01\x32\xe9\xc9\xae\x2b\x26\x9d\xd9\xd9\x88\xc1\x94\xca\x9a\xa1\xd7\x64\xe2\x44\x9c\xe4\x8b\x7d\x27\x28\xa1\xaf\x08\x26\xe2\xa4\x7f\xb3\x84\xbe\xc9\x11\x2a\xb4\x8b\x8b\xb5\x45\x2a\x2b\x2b\x8c\xed\x9c\x45\xa5\xa7\x5b\x0b\x54\x5c\x74\x4d\xce\x81\x9d\x0d\xe4\xd5\x7b\xad\xbf\x3f\xa7\x9f\x87\xfe\x3e\xef\x1e\x1b\xd7\x90\x7b\xa0\x61\x67\x7d\x4d\x7b\x4e\x4d\x34\xf9\xfd\x80\xa3\x48\xa1\x2f\x8d\xbe\xeb\x90\x9a\x30\x80\x4d\xcd\x48\xd6\x26\x31\x18\x02\xef\x53\x69\xa9\x79\x85\x19\x5c\x6c\xad\xa1\xbd\x6e\x17\xd9\xd2\x56\x79\xf4\x04\x7d\x22\xe9\x68\x58\x1b\x1b\xbb\xcb\xdc\x5e\x57\xbb\xab\xb6\xdd\x58\xbb\x9d\x3c\xb7\x68\xf7\xd4\x0f\xe9\x0f\x23\xa6\x2e\x5b\xc4\x66\x64\xa4\x64\xa5\x30\xff\x4e\xfc\xae\x81\x74\x74\xdd\x0b\x9d\x5d\x03\xe9\x94\xa1\x8c\x72\xc9\xfe\x92\xb8\x64\xff\x22\xf9\xc8\x92\x95\x82\x4c\xfc\xad\x44\xfa\x4a\x50\x1b\x28\x53\x4e\x8e\x29\x87\x11\x3c\x24\x1c\x56\x60\x25\x31\x4a\x0c\x6e\x92\x9d\x67\xff\xdf\x03\xec\xf8\x77\x80\xee\xc9\x31\x20\xc1\xe9\xfb\x7f\x22\xc7\xf9\xa3\x8c\xc2\x04\x3c\xa3\x55\xf3\xa9\xf9\x6a\x39\x24\xe0\x99\xc2\xf4\x2a\x7d\x49\xa1\xfc\xd4\xbe\x92\x42\x4b\x95\xba\x44\x8e\xf3\x20\x07\xe6\x41\x4e\x61\x89\xbe\x2a\xbd\x50\xbe\x6a\x5f\x7a\x61\xa2\x5e\x9d\x2e\x77\x1c\xc2\x33\x14\x26\xc0\x19\x75\x49\xa2\x25\x5d\x2d\x5f\xb5\x35\x5d\xad\x4f\x2c\x4c\x97\xc3\x3c\xcc\xc1\x79\x98\xa3\x4e\xb7\x24\x96\xa8\xe5\xa7\xb6\x96\xa8\xab\x2c\x85\x25\x72\x48\x80\x33\xf9\x85\x7c\x99\xb6\x50\xde\xe9\xe1\xda\x44\x5d\xd6\x94\xeb\xcb\x0b\x2d\x15\x72\x60\x1d\xb7\x2d\xe5\xea\xf2\x64\x8b\x7c\x41\x41\x8a\x25\x45\xad\x4f\x96\x23\xdb\x79\x5b\x9f\x52\x98\x52\xa1\x97\xfb\x08\x69\xb0\x45\x78\x02\x16\x4f\x47\x32\x94\x41\x3c\x54\x7b\x29\x88\x6f\x1c\xab\x29\xcd\xa6\x4d\x39\xc1\x0c\x06\xe3\x38\x18\x08\xf9\xd0\xeb\xf8\xd5\x1b\x57\x0f\x2d\xc1\xb7\xe6\x24\xcf\xc8\xd8\xc8\x5d\x45\x02\x3e\x6e\xe5\xe9\x7d\xdf\x57\x81\xc7\xaf\x34\xe4\x63\x1f\x78\x1f\x33\xd1\x80\xfd\x71\x31\x9a\xd1\x08\x62\x0c\x81\x25\x43\xd9\xc9\x38\x66\x00\xf6\xeb\xd7\x0f\x97\x41\x1a\xce\x84\xcb\x1f\x0b\x7f\x91\xd8\x26\x82\x3e\xaf\x33\x05\x1a\x3b\xfe\x59\x78\x31\xf4\xa4\xf9\x74\xd3\x83\x63\x90\x0b\x56\xf0\x83\x63\xe4\x85\x9b\xb6\xb2\x9b\x9c\x0f\x2c\x92\xc0\x70\xc7\x07\x6f\x76\x59\x0c\x44\x08\x5e\x14\xd4\xc0\x1c\x78\x8c\x3b\x08\x44\x71\xe7\x07\xc2\x21\x0a\x0a\xc5\xb0\x1c\x29\xc2\x21\xea\x1c\x4f\x01\x8a\xe1\x31\xec\x80\x1a\x9c\x43\x74\x4e\xfe\x89\xc2\x3a\x98\x07\x5d\x3b\xce\x23\x3a\xa7\xfd\x42\x61\x0d\xcc\x11\xfe\x14\x06\xba\xd5\x1d\x22\xbc\x41\xc1\x72\xa0\x08\x2c\x14\xe3\x03\x88\xa5\xf0\x31\xec\x20\x00\xc5\xc2\x9f\xae\x81\x04\x44\xf4\xa9\xcb\xa8\x4b\x28\x61\x3b\x2f\x09\x87\x88\xfc\x8c\x34\x6b\x1a\x93\x96\xa6\xd3\x66\x70\x9d\x97\x5c\x87\x88\x84\xf4\x8c\xd8\x58\xda\x75\x48\x1c\x5b\x1c\x5b\x9d\xce\x3a\xdc\x3c\x6d\x57\x40\x76\x69\xa9\x35\xbf\x98\x73\xb8\xb5\xaa\x4b\x8a\xeb\xea\x68\x1f\x68\x32\x41\x1a\xbc\x0b\x3a\x4f\x5e\x41\x7a\x78\x29\xc4\xa4\xc3\x4a\x15\x99\x8a\x8a\x68\x78\x80\x75\x50\x83\x3f\x62\x0e\x06\xa1\x1f\xae\x1f\xcc\xb6\xad\x59\x54\x33\x9f\xc1\x91\xd8\x0b\x7b\xe2\x07\x51\xb9\x31\xf9\xdb\x39\x7c\xfb\xe3\x89\xd8\x07\x07\xd3\x18\xdb\x95\x8b\x2c\x2e\x83\xb5\x8a\xcc\x22\x93\x48\xe1\x7d\x54\x64\xb3\x19\xf3\x19\x88\x85\xb9\xf0\x09\x44\xc3\x87\xef\xc1\xbb\x38\xe0\x12\xa7\x70\x5e\xc5\x4a\x0a\x3e\x04\xe5\xaf\x30\x82\x85\xab\xe7\x5d\x32\xd8\xc6\xdc\x39\x77\xe2\xee\xcd\xb9\xc7\xe6\x2e\x5d\x1f\x1b\xb4\x85\x8b\x68\x8b\xdc\x1b\xde\x4a\xde\xb8\xd9\xd1\xf0\x3b\x03\xa3\x41\x3e\x04\x27\xe2\x04\xf4\x1d\x8c\x23\x39\xec\x58\x2b\xc8\x30\x86\xf9\xe4\xd3\x35\x33\x67\x7c\xbe\xf6\xd6\x85\x23\x75\x07\xda\xb9\xa6\x90\xe6\xd0\xc6\x10\x72\xf6\xc7\x1f\x47\x0c\x66\x70\x0c\xca\x7f\x85\x29\x9c\xcf\x4b\x89\x53\x06\x55\x92\x91\xca\x5c\x09\x87\x32\x6f\xe8\x03\xef\x84\x2d\x05\x0f\x0e\x57\xe0\x0a\xa2\x62\x45\x40\xc1\x62\x66\xc9\x32\x4d\xf2\x0a\x0e\x57\xc0\x0a\xe2\x3c\x78\xc0\x3b\x2d\xd0\x87\xe9\x9c\xf8\xba\x93\x5a\x0a\x1e\x61\xf0\x0e\xf4\xa1\xa1\x4f\x0b\xbc\x73\x1e\x3c\x58\x70\x6b\x25\xaf\xd0\x04\x2c\xa6\x97\x14\x2c\xab\x58\xc1\x0a\x49\xae\xdf\x29\xec\x83\xef\xb4\x9c\x47\x0f\x0e\xdc\x36\x92\x4f\x9f\xd3\x5c\x60\x2e\x9e\x2d\xa8\x38\xcd\x75\xc9\x2f\x45\x0f\x7c\x27\x0c\xfb\x30\x82\xcc\x1b\x43\xe1\x37\x25\x84\xd6\x48\x04\x99\x12\xa7\xef\x55\x72\x42\x12\x44\x52\x15\xa7\x0b\xce\x5d\xa0\x2f\x68\xce\x25\x9f\x66\xbb\x6c\x9c\x47\x8f\x16\x7c\x07\xfb\xd0\xd8\x27\x0c\xdf\x59\x8a\x1e\xac\x4f\x35\xc6\x41\x9c\x67\x33\xc4\x19\x94\x10\xe7\xa5\x10\x3d\x74\xc8\x28\xe1\x13\xec\x00\x74\xf9\x7f\xc1\x62\x92\x18\x8e\x2c\x86\x18\x2c\xc2\x2f\x68\x7c\x89\x07\xf0\x00\xbe\xfc\x6f\x61\xc2\x17\x10\x03\x45\x70\xe4\x22\x0b\x49\x62\x97\xff\x42\xec\x40\x74\x7d\x42\xbb\xb6\x0b\x7d\x5d\x7d\x85\xed\xc2\x76\xa1\xaf\xd0\x57\xd8\xce\xfa\x54\x2b\x88\xb9\x89\x35\x89\xbd\x2b\x21\x41\xd8\x0d\x69\xc2\x6e\x48\x96\x26\x49\x8f\x54\x3a\x86\x50\x2e\x5d\x9a\xc0\xb8\x26\x08\x3c\x23\x14\x09\xde\xc2\x5b\xc2\xce\x2c\x2e\x5b\x98\x8d\xe9\x30\x03\xe7\x82\x2f\xc9\xc7\x16\xd4\x24\xb2\xbc\xf0\x81\x2b\xde\x25\xc6\x87\x2c\x8f\x6b\x71\x1a\x76\x87\xb1\xec\x20\x50\xb6\x43\xcc\xf9\x7f\x48\xfe\x2a\x78\xff\xd1\xcc\x4a\x93\xde\x03\x31\xc1\xfb\x2d\x5e\x3d\x81\xe5\xad\xe0\xf3\xd5\x73\x16\xfd\x61\x2e\x8e\xc5\xf9\x04\xff\x1d\x8a\xf5\x7e\x2c\x3f\xfb\xef\x31\xfb\xd8\xfe\x28\x26\x78\xa0\x02\xda\x46\xb1\x3c\xf4\xc3\x7a\xe4\x70\x2e\xcb\xe3\x00\x9c\x8a\x73\x60\x36\x8b\xcf\xe1\x6f\xa1\x97\xb0\xbc\xba\x8a\xb4\x5a\xb2\x0d\x46\x06\x2b\x70\x26\x0e\xc4\x72\x0d\xee\x27\x7d\xaa\xd1\x7e\xf8\xf0\x35\xe8\x91\xa0\x20\xd6\x26\xb6\x5c\x3b\x7c\xb8\x37\x7f\xf8\x10\x7c\xa0\x20\xfc\xe0\x83\x43\x87\xa5\x70\xda\xf1\x7a\x00\xb5\xd9\xb4\xd9\x1a\x64\x2b\x7f\xe4\x8b\x03\x1b\x51\xf6\xf5\x07\xaf\xe6\x2d\xf5\x8d\xd9\x1d\xdb\x92\xd0\x4a\xf2\xe2\x25\xdb\x80\xc3\x78\xe0\x71\x18\xb4\x6a\xe5\xae\x5f\x85\x5f\xa8\xb8\x6b\x19\xb7\xbf\xa2\xbf\x2a\xba\xbd\xf3\x1a\xfb\x61\x43\xf1\xfe\xf2\x7d\x95\xad\xf2\xa5\x2d\xc4\x42\x14\x85\xa0\x2f\x72\xb4\xdb\xcb\xf5\xfd\x02\x45\xec\xf9\x96\xa4\xb6\xd4\xbd\xe9\xfb\xe5\xdf\x37\x10\x0a\xef\x1f\x70\x16\x95\x10\x1a\x1b\x16\x13\x31\xef\xbc\xef\x07\x7e\x28\x9b\x86\x03\xa3\x48\x69\x77\x8f\xf2\xb1\x41\x59\x9b\x75\x9b\x8d\x72\x69\x2f\x8f\xb9\x62\x68\xcd\x07\x1e\x86\x01\x07\xf1\x24\x6e\x15\x1e\x52\xf1\x97\xb7\x9d\xdf\x78\x02\x17\xe2\x38\x5f\x29\xa9\x0e\x3e\xb4\x6a\xf7\xe2\xa2\xe3\x90\xe5\x6b\x8b\x08\xb3\x6c\x63\xb6\x85\xe9\xb3\x22\xb8\xe3\x98\xb5\x58\xb5\x2a\x22\x78\xa3\x1c\x17\xc2\xb8\x8d\x81\xdb\x96\xc6\x2f\x90\x43\xfa\x24\x22\x33\x46\x17\x1d\x49\x47\x5a\xa3\xed\x31\x2c\xa6\x4d\xaa\x5e\xb0\x67\xe9\xa1\x40\x39\x2c\x84\x71\x7b\x37\x9e\x8a\xbc\xa8\x92\xaf\xc1\x6c\x22\x7b\x77\x4b\x8e\xe0\x25\xc9\xcd\xdb\xcd\xad\x81\xec\x8b\x45\xa7\x9a\xf6\x1e\x92\xc3\x42\x1c\x77\xe8\xc4\x9e\xf3\xd5\x97\xe5\x98\x76\x8f\xb0\xd7\x5b\x1b\x9a\xe8\x26\x5d\x43\x66\x3d\x0b\xe9\xf7\x08\x17\xef\xe8\x4b\xf1\x62\x6c\xd5\xa2\x11\x87\x22\x87\x09\xe7\xc3\x7c\x6b\x5a\x6b\x5b\xea\x9b\xae\x2e\xf3\x7d\xfa\x0a\x64\x5f\xc3\xc0\x86\x94\x47\xbe\xfb\xf3\xdb\x73\xdb\x4d\xa4\xe3\x76\x67\x0a\x05\x5c\x08\xf8\x2e\x04\x11\xbb\x34\xac\x32\xb4\x7c\x6b\x71\x90\xfc\xc3\x68\x62\xe7\xdc\xa2\x8f\x66\xd0\x33\x32\x3e\x8a\x9b\xcb\x7e\x1f\x9d\x1e\x94\x1a\x9c\x14\x22\x3f\x1f\x46\x7c\x01\xa2\x36\xf0\x05\x8e\xc6\x1e\xc2\x24\x0a\x39\x48\x40\x23\x0c\xc5\xd6\x7c\x72\xae\xb8\xdd\xd8\x9e\xb3\x5f\x9b\x32\xd6\x17\x06\x46\x83\x6c\xda\x53\xbf\xab\xe7\x7c\xeb\x23\x6b\xc3\x6a\x42\xcf\xb7\xf8\xc2\x78\xd7\x24\xca\x15\xe6\xea\xed\xea\xed\x0a\x73\x53\xa1\xb7\x10\x26\x84\x09\x5d\x94\xe5\xc5\xee\xa2\xbb\x8a\x3b\xdc\x27\x57\xc2\xf2\xe2\x91\xca\xae\x37\x74\xf3\x5f\x81\x14\x3a\x60\xe6\x8b\x5f\x61\x0e\x18\x84\x9e\x12\xe8\x0d\x6b\x71\x11\x0c\x85\x89\x5f\x80\xef\x25\xf8\x12\xec\xd2\xce\x87\xc2\xb7\x90\x44\x9d\x59\x64\xdb\xb4\x61\x79\x66\xc0\xb2\x2b\x59\x87\x58\xe9\x4c\x8f\xc3\x27\x8a\xce\x70\x21\x42\x30\x75\x2c\xee\xe0\xaa\xa5\x89\x5b\x57\xae\xac\x09\x3f\xcb\x4a\xfb\x79\x9c\xa9\x6a\x3d\xc9\xc1\xc4\x3b\x54\xaa\x2e\x25\x27\x35\x87\xcc\x4b\xc9\x4d\x49\xa6\xdf\x9d\x37\x79\x40\x22\x1b\xa1\x4b\x4e\x0f\xa3\x43\x8f\x27\x36\xe8\xd8\xef\xd3\x7e\x8a\x1c\x44\x63\xbf\xa1\x6b\x51\xd6\x0f\xdf\x6e\x03\xe9\x57\x47\x0e\x5d\xaf\x61\x2d\xe2\xa8\x72\x55\x7d\x0b\xdd\x9c\xb7\xbf\xb9\x84\xb5\x88\x17\x56\x6f\x7e\xf4\x05\x0d\xe4\x8f\x0f\x40\xb4\x7f\x9f\x26\xa9\x85\x3d\x7a\xb4\xb8\xec\x10\x87\xbd\xc4\x17\x5d\xe3\x29\x4b\x1d\x5f\x57\x47\x0b\x0a\xf1\x4e\xbe\x4e\xbf\x93\x05\xa5\xc8\x10\xc7\xc7\xc5\xd1\xae\xbe\xe2\x18\x3e\xda\x1c\xc3\x0a\x64\x19\x95\x1c\xb6\x35\x3b\x98\x41\xdf\xd4\xe7\xe0\xc1\x41\xa4\xd9\x2c\xd6\x6a\x4d\x59\x4c\x86\xca\x60\x54\x71\xd0\xfd\xd2\x31\x71\xa5\xb1\x42\x5f\xc1\x82\x9f\x48\xb7\xcd\xbc\x6d\x1b\xfd\x02\xbb\x8b\x92\x53\xcc\xc9\xcc\x4a\x8c\x17\x05\xe7\xaf\x3f\x52\x5b\x6b\x2b\xa9\x62\xf1\x6d\x31\x0a\x8e\x15\xd4\xba\x90\x8d\x6b\xd6\x04\x1f\x3c\x76\xbc\xed\xd0\x89\x13\xad\x1b\xd6\xb2\x82\x70\xdc\x4f\x59\x8d\x76\x98\x01\x87\x60\xbd\x90\x05\x9f\xe2\x34\x98\xdb\xfb\x3a\x6c\xc4\xe5\x10\x86\xdd\x20\x18\xfa\xc3\x66\x1c\x04\xeb\xc1\x03\xc2\x20\x00\x22\xa5\xbf\x3c\x14\x7e\xae\xa1\xfc\xa7\x24\xcf\xfc\xe4\xbd\xc2\x1f\x7f\x78\x5c\x7a\xeb\xfa\x6f\xaa\x31\xec\x62\x47\x0e\x35\x31\x7c\x99\xff\x98\x90\xcf\xbe\x7f\xd0\xfc\xf9\xcf\xdf\xb7\xcd\x9e\xce\x42\x0d\xdc\xa5\x62\x3e\x99\x91\x38\x9d\xd9\xbd\x7c\x61\x59\x57\x0e\xab\x01\xa8\xc4\x45\x03\xaf\x21\xf7\xd7\x36\x2e\x47\xbc\x32\x4e\xbd\x60\x15\xbd\xbc\x7a\xc3\xd1\x68\x36\x47\x8c\x9e\x21\x33\x3f\xc1\x1e\x34\x6e\x86\x95\x4b\x61\x1a\x04\xc1\x88\x3b\x90\xcc\x4a\x65\x6a\x68\x75\xbd\xdf\x1f\x3e\xa0\xcf\x34\x56\x9f\x2c\x60\x61\xe2\xee\xe7\x40\xc1\x14\xba\x31\xbb\x41\x53\xcf\xd6\xe7\xed\xb2\xed\xb2\x93\x70\xab\x73\x12\x95\x73\x84\x3f\x7c\x84\x16\x1c\xe2\x76\xe3\x41\x6b\x3b\x8b\xb1\x22\xeb\x26\xe3\xc6\x8d\xb4\xeb\xa5\x78\x3d\xbf\x21\x67\x3d\x0b\xb1\x22\xe1\x77\x88\xa5\xe2\xc3\xb7\xaa\x83\x98\x19\x19\xb7\x2f\x72\xd2\x4c\x0f\xc1\xf3\xa1\xb8\xa1\x31\xa7\x91\x81\xa5\x38\x4d\x2c\xd5\xab\xcf\x1a\xce\xe6\x9f\x65\x31\x51\x64\x8d\x32\x45\x46\xd2\xd2\x77\xd5\xd3\x86\x8a\xa5\x1a\x0f\x5c\x2a\xb6\x54\x56\x59\xaa\x8a\x8a\x0c\xc5\x8c\x54\xaf\xce\x31\xe0\x73\xb1\x74\xf9\x46\x9c\x59\x87\x53\x20\xec\xd2\xe7\x05\x8d\xa7\x59\x57\x87\xc2\x3b\x91\xba\xb3\xec\xf6\xe4\x49\x4b\x66\x4d\x9d\x76\xf1\x93\x6f\x59\xe9\x46\xbf\xbb\x17\x6e\xde\xe1\x7c\x8e\x49\x7e\xf0\x53\xba\x54\x82\xf8\x1f\xe7\xd2\xe7\xbd\xcf\x3f\x5f\xf5\xdc\xa9\x7c\x2e\xbd\x2b\xfd\xc5\xf1\xbd\x73\x15\xf5\xca\xff\x51\x3f\xbf\xb1\x63\xfd\x62\xac\xdb\x0b\x77\xb0\x9b\x36\xac\x5f\xbe\x7e\x0e\xbe\x83\xf3\x91\xc3\xcb\xfb\x5d\xf3\xc8\x18\xcb\xce\xc4\x5d\x66\x13\x6f\x66\x1a\x2c\xd5\x75\x86\xc6\x48\xf8\xe6\x06\x1c\x84\xf1\x60\xd8\x7f\xe1\xc0\x89\xb6\xfd\x64\x7c\xf3\xbe\x8c\x76\x46\x7a\xf7\xe5\xe3\xc7\x2f\x39\xa1\x97\x9a\x82\x3b\x58\x02\x25\x78\x07\xbf\xc2\x52\x2c\xc1\x3b\x23\x6a\x46\x1c\x9c\xc8\x16\x6f\xdf\xad\xd9\x55\x5c\x57\x5c\xb0\x3b\x63\x17\xb9\xed\x7a\x72\xc7\x5d\x1a\xca\x21\x1c\xc2\xa1\xdc\x4d\x31\x1c\xcb\xb1\x1c\xbb\x68\x48\x70\xae\x3d\x94\x8d\xce\x8b\x49\xce\x8a\xc9\x8e\x2e\x8f\x6e\xc8\x22\x33\x0f\x1d\xd6\x1d\x66\xe0\x0e\x94\x40\x09\x7c\xc5\xf9\xbc\x90\x54\x28\x44\xf7\xbd\x60\xa7\x23\x8a\xc2\x91\x28\x19\x8a\xef\xe3\x5a\x3a\xd8\x1e\x59\x12\xc6\x1a\xf2\xf4\xda\x7c\xc6\x24\xba\x90\xf7\xd9\xd9\x9a\x53\xa4\xd5\x6c\x29\xb5\x31\x56\x7d\xe9\x47\xbf\xe1\xcc\x1b\xa9\x72\xb3\x9e\xd0\x1b\x79\xa3\x91\x35\xea\x72\x8c\x3a\x26\xc4\x10\x97\x12\x91\x4d\x06\x85\xa8\x52\x97\xd1\xd8\x07\x8e\xe9\xbe\x7e\x04\x83\x2b\xbe\xfc\x9c\xdd\xa5\x6f\xcb\xad\xcd\x22\xb7\x81\xf8\x8f\x70\xf0\x61\x7e\x86\x0f\x0a\x1f\x9d\xe7\xf2\x0b\x0d\x45\xd6\xc2\x94\x5f\x47\xe8\x96\x9e\xbd\xfa\x45\xeb\x37\xcd\xdf\x5b\x73\x7d\x4d\x26\xde\x68\xe2\xb6\x97\x1c\x1a\xb6\x9f\x39\x57\x09\x3e\xad\x30\x7a\x0a\xb0\x63\x41\xca\x19\xcd\xd9\xf9\xe6\xda\x8a\xfa\x7a\xfa\xcc\xf6\xcf\xa2\x0e\xb3\x46\xeb\x6a\x50\xad\x80\x05\xa8\xfa\x43\xbe\xe7\xc3\xa1\xd5\x63\x18\x24\xd0\x23\x25\xf0\x3d\x0e\x27\x4d\xc2\xfe\x98\x8e\x0b\xe9\xc4\x14\xf5\x0a\xd3\x76\x32\x25\x21\x79\x7d\x34\x9d\x6c\x4a\xb1\xa5\xb0\x3e\xd0\x94\x9f\xe0\xe8\x07\x87\xde\x3c\x82\x09\x77\x9d\x97\xa8\xe5\x21\x21\x01\xcb\x03\xda\xce\x9c\x3d\xdb\x76\xe6\x6c\x5b\x48\x00\xeb\x48\x75\xe5\x52\xc1\x21\x21\x01\x21\x21\x6d\x7b\xdb\xda\xda\xda\xce\xb6\x85\x84\xb0\xa8\x16\x72\xdd\xb2\xcb\x03\x96\xb7\x9d\x39\x7b\xa6\xed\xec\x99\x2e\xd9\x77\xdc\xb2\xc1\x21\xcb\xff\x93\x3d\xb3\xd7\x2d\x5b\x29\xf4\xa3\xe0\xc8\x42\xbc\x06\x91\x28\x30\xae\xfe\xf8\x2d\xd6\xe2\xef\xb8\x06\x3c\x71\x02\xcc\x45\x29\xf7\x11\x46\x41\x1e\x48\x89\xe4\x9f\x6e\x27\xff\xc4\xec\xac\x31\x99\x77\x72\x69\xc7\xb5\xa7\x4e\xd3\x70\x03\xea\xa0\x00\x7e\xab\xdd\x69\xd4\xef\x64\x85\x1f\x5c\x17\x28\x38\x84\x87\x40\x8d\xdf\xe2\xef\x58\x8b\x6a\x74\x9f\xd5\xa2\x1a\x7e\xbf\xdd\x51\x59\xd1\xc1\xc2\x1a\xf4\x0c\x80\xb9\x04\x0c\x04\x4f\xf0\x80\x01\x30\x9e\x76\x3f\x33\x2b\x44\xff\xe3\xa5\x10\xfd\xa0\x20\x5e\x52\x36\x4d\x46\x6e\x06\xa3\x56\xeb\xb3\x35\x9c\xc2\xa1\x7e\x1d\x90\xa0\x52\xc5\x99\x76\xc8\xcd\xb1\xa5\x09\x3b\x33\x05\x0e\xc7\xf9\x3a\xcf\x38\x47\x75\xbe\x78\x7d\x98\xc0\xbf\xc5\x31\xe5\x3b\xea\x32\x59\xbd\x2d\xdf\x68\x63\x2a\x2b\xf2\x4b\x8b\x38\xd0\xc1\x71\x61\x35\x2e\x84\xee\xca\xff\xcb\x74\x62\x49\x8c\x29\x21\xa3\xcb\xa8\x6f\x82\x2a\x23\xce\xbc\xe3\x5f\xa3\x11\xb8\xdc\xd7\xb5\x4a\xbc\xbd\x6c\x47\x9d\xa6\xcb\x56\x7e\xd7\x12\xc5\x22\x0e\x4e\xc1\x3d\xa1\x16\xc3\xa1\xbb\x12\x7f\x55\x38\x07\x50\x2e\x35\xac\x13\x62\x1d\xfb\x3a\x9f\x77\x4a\xf1\x07\x50\x2a\x88\x52\xc7\x75\xc2\x67\xbf\xd2\xed\xa3\x09\x1d\x60\x9f\x9f\xd8\x1b\x92\xba\xdc\x50\xe9\xfd\xcf\x94\xa0\x54\x92\xd2\xdf\x50\x09\x2c\x71\x5d\x02\xbf\x2b\xa5\xf7\xf1\x63\x18\x08\x11\x03\x21\x99\x81\xc5\x4a\xae\x53\x06\xed\x70\x55\x82\x2f\xe0\x9e\x52\xfa\xdb\x54\xa5\xf4\x3e\x04\x48\xba\x72\xbe\xc9\x0c\x4a\x90\x79\x39\xec\x70\x59\x09\xcb\x95\x9b\x24\x9c\xc3\xde\x29\xbb\xad\xe4\xc1\x28\x81\xb7\x95\xd5\x28\x83\xbe\xd8\x13\x7a\x62\x4f\x90\x0a\xf7\x60\x8c\x50\x0f\x3e\xbd\xa1\x00\x2c\x8e\x6a\x30\x4b\xd7\x2b\x44\x36\x94\x51\xad\xc5\xed\x8d\x8f\xd1\x63\xf3\xaa\x66\x2e\xbc\xca\xf0\xb8\x85\x96\x4e\x35\x3a\x3f\x22\xda\x4c\xff\xec\xa9\x61\x4f\xee\xfe\x67\xc3\x63\xba\x29\xfd\x40\x08\x3b\x76\x6c\xd6\xd8\x31\x63\x6c\x63\x98\x90\xf4\x2d\x91\xe3\xfe\x3c\x70\x32\x92\x6b\x4d\xe0\x07\x04\xd3\x46\xec\x20\xd4\xbc\xc6\xa8\x66\xf5\x19\x19\xbc\x8a\xe9\x5c\x24\x92\x56\x66\x64\xf0\x96\x0c\xce\x58\xc8\x17\x14\xd2\xd2\xf5\x46\xe8\x20\xda\xf8\x7f\x5a\xab\xd9\x13\xbb\xff\xd8\xf4\xe8\x8d\xc1\xf1\xe3\xb2\xc6\x8f\x18\x6e\x1b\xc1\x84\x66\x6c\x8e\x1a\xf5\xea\xf8\xc9\x08\xee\x48\x4c\x16\x0e\x5f\x43\x77\x9e\x11\x9b\x96\x12\xa1\xc6\xb1\xe1\xf1\x6c\xe0\xb6\x11\x6d\xfe\x74\x74\xe9\xd6\x16\xf6\xe1\x43\xdb\xc3\x9f\x7f\xc9\xfa\x85\x69\x2d\x39\xd0\xf4\x23\x4a\xd6\xaf\x6c\xe6\x82\x6b\xf8\xe7\xfb\x68\x93\x20\x26\x0a\xf9\x02\x53\x01\x6b\x2d\xab\x30\x96\x33\x8e\xf1\xa2\xb2\x0a\x93\xae\x8c\x33\x69\x78\x8d\x9a\x36\xb9\x18\x22\x94\x1f\x1f\x96\xc0\xae\xdc\x36\x68\xdf\x68\x3a\xaa\x2c\x78\x0f\xfb\xe4\x89\xed\xc9\x0f\x3f\x64\x3d\x61\xba\x40\x86\x54\x50\xe0\x29\xd4\x40\x0a\xf4\x87\x14\x2f\x85\xf7\x6b\x05\xf1\x11\xb5\x27\xa6\x7e\x1b\xeb\xda\x21\xc2\x05\x38\x5a\x15\x3b\x9d\x9b\x14\x33\x6b\xc5\xe2\xc9\xe4\x92\xc9\x91\x43\xd1\x8b\x1e\x56\xe3\x7f\x70\x2a\x7b\x78\xd2\x95\x45\x0f\x82\xae\x46\x7c\x9f\xf8\x9b\x96\x74\x65\xc1\x09\x89\xc2\xfb\x2c\xf4\x57\xe0\x54\x38\x21\x81\x63\xca\x6a\x43\xad\xb5\x92\xcd\x2d\x2b\x2a\x2c\xcb\x25\x73\xcb\xab\xf4\xe5\xcc\x9e\xfa\x8b\x7b\x38\x1f\x7e\xaf\xc4\x93\x87\x38\x67\x07\xc4\xc9\x1e\xc2\x0b\x90\x51\xf8\x02\x65\xf0\x42\x04\x2f\xc0\x7e\x50\x09\xfe\x82\x8c\xea\x7c\x81\x32\xc7\x0b\x51\xa7\xcc\x21\xa3\x30\xae\xeb\x63\x8e\x82\xf0\x7b\x2d\xa3\x3a\xe3\x50\xe6\x88\x13\xbd\x0e\x50\x10\x1e\x07\x95\x0e\x99\xcb\xad\xd1\x81\xff\x4b\xca\x21\xf3\xfe\x57\xd7\x67\xab\x44\xe1\x7d\x5a\xb0\x53\xe3\xa7\x86\xad\x58\xca\xa1\x0b\xe6\x10\xa6\x42\x53\x11\x5f\xc8\x17\x1a\x8b\x0a\x7b\x0c\x00\x37\x67\xc5\xf9\xbb\x61\x0f\x18\x98\x05\xfd\xa1\x3f\xcc\xfa\x3f\xd7\xcd\xaa\x4d\x2a\x93\x9a\x43\x17\xce\x21\x4e\x2f\x9d\xda\x32\x9e\xf9\x97\x8f\xb3\xa0\x3f\xf6\x87\x59\x0f\xee\xb6\x9c\x3e\xcf\x81\xbb\xde\xa8\x36\xaa\xd4\xf4\x7f\x15\xff\x97\x39\xd6\x67\xbf\x52\x98\x06\x53\x85\x69\xfb\x24\x4e\x3b\xd8\x65\x0f\x0d\x4a\x78\x4a\x61\xf7\xa1\x43\xb1\x3b\x4a\x86\x3e\x83\xee\xf9\x26\x9b\x29\x9f\xc5\x6c\xe8\x41\x84\x6e\x5d\x15\xbf\x8c\xc1\xee\x43\x7f\x05\x09\x48\x9e\xfd\x0a\xdd\xcf\x9d\x8a\x0f\xdd\xc7\x81\xbb\xd2\x98\x6f\xb4\xe5\xd3\xd0\xfd\xd9\x33\x90\x40\xf7\x67\x6f\xf4\x87\x62\xf7\x65\xab\x6a\xda\xb6\xb2\x98\x8d\x3d\x08\x93\xd6\x94\xc5\x6b\x79\xad\x31\x4b\xdb\x63\x00\xb8\x39\x6d\xfb\x4e\xd5\x9c\x63\xba\xc4\x25\x1c\xd8\x1d\x55\x7e\xca\x6a\x67\x34\x7c\x08\xb2\x2b\xcd\xe0\xdf\x9b\x87\x0f\x15\xde\xc7\x61\x84\xf5\x8a\x15\x46\xa0\x0c\xfc\xa5\x1d\xc2\x75\xe7\x6c\xaa\x24\x2c\x35\x38\x2c\x1d\xbd\xd7\x8f\x1a\xb5\x1e\xbd\xc9\x58\x75\x5c\xda\x76\x46\xab\x35\x5b\xb4\x5c\x58\x71\xda\xde\xe2\x96\x0b\xf0\x1e\x90\x40\xc2\x7b\x17\x48\xe9\xbc\x96\xe2\xbd\x69\xc5\x61\xa4\x73\x26\x08\x14\xe6\xa0\x7e\xf6\xf5\xd8\xba\xcd\x7c\x6c\xac\x7c\xfe\x7c\xe2\xdc\x40\xec\xde\x82\xbd\x18\x97\x1c\xaf\xe3\x75\x97\xfc\xbf\xfc\x0a\x82\x1c\xae\xc3\x75\x41\x0e\xbd\xc2\xa0\xfb\xb2\xbf\xb8\x2b\x57\xea\xea\xf8\xf6\xd8\x3a\xb9\x74\xeb\xec\xeb\xa0\x87\x1c\x62\xeb\xdf\x54\x71\x11\x5f\x9d\x51\x34\xea\x27\xdf\x37\xb8\x82\xaa\x0c\x3e\xb1\x28\xe3\xa7\x51\xbe\xd9\x79\xf9\x39\x76\x26\x3f\x1f\x66\x4b\x20\x05\x53\xa8\x37\xe8\x83\x23\x7f\xf4\x55\x15\x27\xf0\xaa\x0c\xf8\x45\xf9\xe3\x48\x5f\xe9\x4c\x10\x29\xf3\xf3\x2d\x79\x36\xae\x1d\xe6\x2f\x55\x0e\x15\x0d\x50\x0e\x95\x70\xcf\x20\x43\x02\x01\x5d\xb8\x76\x43\xc5\xf1\x4a\x18\xda\xfe\xaf\xfa\x9b\x36\x46\x8d\xf4\x85\x5f\x94\xe4\xff\x5f\x0b\x3f\xfd\x48\xf8\x80\xbf\x04\xa8\x84\xae\xf5\xec\xa3\x25\xc2\x4b\x47\x10\x05\xdd\xf0\x07\x02\x40\x04\x9e\xf0\x03\x1e\x80\x20\x42\x78\xe1\xdd\xe5\x32\x0b\xff\xa3\x70\x1e\xa3\x22\xc1\x17\xbf\xdd\x82\x1c\x9e\x02\xf2\x13\x22\x76\xfa\xc4\xf4\xf1\xcc\xf8\x89\x25\x75\xd3\x39\x20\x6f\x20\x07\xa7\xfe\x7f\x8c\xbd\x07\x78\x14\x55\xf7\x30\x3e\x21\x99\xe2\x08\x79\x21\xb3\x13\x93\x9d\x9d\x99\xd0\xa4\x89\x08\x46\x9a\x20\x01\xe9\xbd\xac\x48\x0f\x2d\xd4\x24\x84\xf4\x9e\x25\x7d\x4b\xfa\xa6\x12\xd2\x13\x48\x20\x24\x40\x68\xa1\x4a\x11\x31\xe8\xab\x10\x41\x50\x10\xec\x8a\x80\xaf\xa2\x67\x76\xcf\x24\xef\xff\xd9\x8d\xbe\xbf\xf2\x7d\xdf\xf3\xfc\x9f\xdd\x9d\x7b\xee\xb9\xa7\xdd\x76\xee\xdd\x3b\x33\xf7\xe2\xbd\x63\x41\xe8\x45\x8e\x04\x8d\x1e\x5e\x83\xb7\x2c\x66\x8b\x45\xfb\xaf\x31\x90\x0a\xe1\x0b\xe0\x0e\x0a\x49\x3f\xc3\x4b\xa0\xfb\x15\xc6\x9c\xf3\x5e\x8e\x7d\xe1\x18\xbe\x0e\xc7\xe0\xf5\xe5\xd0\x17\xc6\xac\x04\xdd\xcb\x3f\xe3\x4b\xde\xa8\x2d\x9e\x8f\x77\x20\x15\xc3\xff\xf5\x2d\xe9\x18\xc1\xb5\xf8\x96\x1e\x5f\x1b\x89\x1a\xc9\xbd\xca\xfc\xf7\xa1\xfa\xb0\x1c\x46\xc2\x69\xa5\x2f\xeb\x3c\xa5\xe8\xff\xf2\xe5\xec\x07\x14\x3d\x84\xaf\x64\x51\xaf\x74\xae\x64\x95\x4e\xd4\xaf\x64\x61\x80\xc8\xa5\x12\x63\x59\xf5\x26\x3c\xe7\x15\x8e\x6a\x39\x70\xa0\x45\x06\x5e\x2d\x42\x9e\xde\x7a\x20\xb8\x55\xd2\xb9\x25\xaa\x6d\x2b\x59\xee\x3a\xf1\xbf\xd9\xbe\xf6\x1b\xcb\x2a\x1a\xe5\x17\xfe\x63\xec\x03\x77\xbb\xf6\x76\x95\x63\x6f\xbc\x3b\x5b\x4a\x54\x8a\x0a\xe9\xd6\x83\x1d\xf0\x9b\x45\x82\xdf\xb2\x0e\xce\xde\xa2\xdd\xa3\x14\xd1\xaa\xec\xa6\x67\x51\x4f\x73\x17\x73\x1b\x45\xe5\x84\x9b\x43\x05\xb5\xf5\x40\x70\x8b\xa4\x68\x28\x2e\x64\xa8\x53\xb3\x7b\x95\x51\x04\xab\x8b\xa2\x81\xce\x0e\xb0\x76\x40\xa7\x26\xc4\xa6\xd7\xb9\x5d\xe4\xd5\x49\x54\x42\x62\x72\x42\x86\x8c\x59\x5d\x5d\xa4\x6a\x85\x49\xa2\xd2\x49\x9b\x69\x5f\x11\x3a\x6d\x56\x1e\xad\x5d\x7a\xb0\x52\x36\x2b\xea\x79\xcc\xb2\x75\x91\xa5\x19\x89\xd6\x04\x41\x9d\xd4\x65\xa5\xc6\xb0\x66\x5a\xed\x84\x49\x62\x77\x9b\x8e\xaa\x82\x10\xd1\xe6\x0b\xe1\x10\x22\xba\x9f\x60\x75\xd4\x17\xf6\x7f\xf2\x2b\xcf\x4d\x34\xaf\x5c\xa9\x0e\x56\x07\x79\x61\x22\x24\x2a\x83\x94\xc1\xe7\xce\x9a\xef\xaf\x3c\xe7\xbd\xf2\xec\x44\xf3\xca\x55\xea\x20\x75\xb0\x17\x0e\x87\xe1\xe8\x8b\xbe\xb8\x0b\x77\x05\xe2\xd7\x30\x1e\x2d\xde\xd8\x8d\xdd\x24\xce\x81\x39\x34\x74\x43\x37\x58\x70\x3c\x7c\xdd\x04\xbb\x60\x97\x37\xf8\x82\xaf\x83\x43\x19\xac\x0c\x3a\x7b\xce\xfc\xe5\xaa\x73\xde\xee\x55\x3a\xb2\xf6\x47\x97\x3f\x1f\xeb\xc8\x88\x47\xae\xb6\x2e\x5b\x2b\x0f\x6e\xc3\xbf\xc3\x17\xe1\x6b\x16\x5e\xfc\xe5\x7b\x70\x95\x14\x93\x27\xb8\x8d\xf8\x0e\x7b\x3b\x50\xbd\x1f\x3b\x50\x10\x81\xb3\x79\x4c\xc3\x97\x70\x73\x35\x92\xb9\xe3\xb3\x03\xb7\x65\xe8\xa3\xca\xa2\xf6\x46\x56\x66\x64\x67\x66\x67\x66\xc7\x54\x04\x59\xd7\x98\xd0\x35\x03\xfd\x23\x70\x0f\xf4\x65\x6c\x6f\xd0\xe0\xde\x74\x04\x5c\x25\xfb\x2f\xd4\x1f\xad\xeb\x90\x96\xbb\x46\xd1\x30\x2e\x97\x3f\x78\x66\xdb\xf9\xe5\x5b\x52\xd3\x1d\x1f\xc6\x36\x97\x7e\xfc\xf6\xdd\x31\x92\x0e\x5f\xa2\xc6\xbc\x3d\x79\x84\xdc\x35\x97\x4e\xcd\x4d\xc9\x4d\xcd\x5d\xde\xba\x6d\xc5\xc1\xd5\x1d\x93\xc0\x7d\x38\x2c\x9c\x82\x2b\xbb\x5e\xb7\x4d\xf4\x31\xc0\x2f\x4c\x9a\x05\xd6\xc2\x40\xed\xbe\x8c\xb2\x8c\xb2\x4c\x06\x07\x58\x70\x59\x9e\xd6\x80\xbf\xd8\x26\xfe\x89\x2b\x6d\xaf\xc3\xc2\x3b\xe0\xfe\x4b\xc7\x3d\xc6\xbd\xea\x5b\xc8\xb3\x37\xc3\x60\x97\x67\x90\x07\x83\x61\xce\x2d\x18\xec\x04\xf2\x60\xb0\xab\x5d\x63\xff\x9a\xc7\xc1\xea\x4c\x18\x4c\x29\x03\x94\x99\x7f\xc3\x78\xcf\x4d\x1d\x40\x61\x10\x06\x91\x10\x84\xf7\xec\xcd\x3a\xb7\xa6\xae\x16\x1a\x06\xdb\xfd\x78\x9d\xfd\x0d\x0a\x5d\xf0\x38\xa9\xc3\x58\x65\x00\x06\x41\x10\x0d\x41\x10\x44\xc2\x3d\x4a\x99\xa9\xcc\x24\xdd\x41\x66\x1f\xea\xc8\xe5\xae\xb6\x52\x08\xe2\x2d\x8d\x31\xfb\x77\x94\xec\x28\xde\x9a\x12\x15\xca\x2c\x9e\x61\x32\x9b\xb5\xb8\x16\x93\x93\x0d\xe9\x09\x99\x29\xc6\x64\x4b\x72\x56\x52\x6e\x62\xa1\xa1\x7d\x19\x44\x8c\xbf\x55\x5c\x97\xbb\xaf\xb4\xa0\x2a\xb7\xc4\x5c\x68\x81\xc3\x0c\xf4\x33\x67\x99\x25\x1c\x06\x39\x7c\x56\x4b\x74\x53\x50\x31\x33\xf6\x90\xc5\x62\xd6\x02\x8b\x27\x92\xf2\xe2\x85\x08\x4b\x94\x21\x21\x22\x78\x6d\x22\x0e\x29\x1a\x96\xbd\x33\x2f\xa4\x20\xae\x38\xa2\x32\xb1\xda\xc4\x94\x5a\xb3\x1e\x41\xb5\x0c\xbd\x8f\x9a\xcd\x66\x6d\xa3\xb5\xb2\x3e\xeb\x30\x63\xfb\x18\xcf\xf1\x39\xf5\x29\x55\x31\xa5\x06\x6b\x72\x36\x56\x7f\xc3\x20\x7b\xd4\x64\x31\x6b\x83\x0b\x77\x26\x47\x84\x84\xef\xca\xdc\xba\x6f\x57\xfb\x5b\x5e\xe0\x8b\x25\xc5\x31\xc5\xc9\xe5\x09\x35\xc6\x1a\xeb\x3f\x1b\x60\x18\x2c\x29\xbc\xc5\x74\xf9\xda\x7a\xf3\x69\xd0\x67\xab\xd2\x92\x51\x97\x56\x13\xb3\x37\x34\x6f\x72\x25\x5e\x18\xa7\x5f\x1a\x13\x93\x16\x9e\x1b\xc9\x98\x0b\x63\x15\x37\xf5\xae\x74\xf9\xf5\x93\x25\xa5\x39\x65\xb9\x27\x4b\xd2\x7f\x67\x6c\xc3\x91\xe0\x9d\x7e\x26\xe5\x36\xbe\x04\xef\xce\x6d\x0a\x2f\x0a\x37\x47\x27\x26\xa5\xa4\x18\x70\x3c\x86\x33\x53\x5f\x36\x99\xcc\xda\x98\x30\xd3\x8e\x8a\xa0\x8a\xa0\xe6\x84\xc6\x02\xc6\x64\x74\x98\x5d\x96\xdb\x90\x7f\xb6\x08\xae\x7e\x56\x9c\x53\x5c\x50\x51\x62\xad\x32\xd6\x31\xee\xd0\xe8\x3c\xb4\x1a\x8c\xac\x19\x26\xb2\xcb\x45\x88\x66\x39\xfc\xd5\x79\xd4\x80\xaa\x51\x35\xf0\x01\x4b\x83\xa6\x4b\xc3\x77\x69\x50\x63\xd3\x50\x76\x8d\x9b\xb9\x4b\xe3\x18\xd4\x69\xe7\x79\xae\xaa\x15\x35\x8a\x95\x52\x34\x6e\xff\x2f\x88\xe2\x48\x83\x62\xa5\x74\x76\xa2\xab\x93\x87\xcd\xa2\x5d\x0f\x1a\x9a\xc3\x5f\xbb\xf5\xf4\x31\xd1\x73\x24\x2b\x39\xea\x3f\xbf\x32\xa7\xba\x5a\x6b\xef\x5c\xcc\x76\x77\xd2\xa0\x71\xf8\x04\x9d\x8d\xa0\xb8\xb4\x5c\xd4\xa0\x95\xe6\xa2\xd7\x77\x77\xc2\x29\x51\x82\x2a\x11\xba\x59\x77\x68\x54\x34\x50\x20\xba\x1c\xd7\xd1\x87\x34\x0f\xed\xd6\x12\xbe\x1e\x7c\xc0\xa7\xe1\x2c\x6a\x1a\x02\x02\x50\x13\xb2\x2a\x04\x7c\xd0\xa7\x5e\x86\x1a\xa8\xe5\x6b\x61\x30\x0c\xaa\xb5\x42\x17\xfb\x87\x0f\x4e\x7b\x1f\x87\x0a\x38\x14\xa7\x2d\xee\xef\x03\x8f\xc4\x5a\xa9\xec\xcf\x67\x30\x14\x86\x80\xcb\x90\x52\x01\xea\xa1\x8e\xaf\x81\x41\x30\xa8\xb6\x00\xba\x58\x98\x85\xb3\xb0\xe6\x29\xe6\x08\x98\x83\x35\x43\x71\x16\xce\x92\xd3\xd2\x32\x52\x52\xb4\x61\x30\x08\x07\xd5\x48\x45\x10\x0b\xdb\xe0\x92\x00\x81\x20\x4f\x41\x0d\x4c\x90\x33\xf2\xac\x19\x05\x02\xd4\x42\x2d\x5f\xf3\x1f\xb5\x90\x83\x79\xaa\x0b\xc8\xf8\xa7\x80\x7f\xaa\x2e\x28\x63\x0e\xe6\xc1\x23\xb1\xa6\xa0\x20\x27\x37\x4f\x02\x7f\x88\x83\x2c\x20\xe1\x86\x00\x37\x20\x0b\x49\xf4\x87\x38\x39\x3d\xaf\x20\xa3\x40\x70\x87\x1c\x76\xb9\xe8\x62\x86\x78\xd6\x55\xd1\x78\x42\x10\x3b\x98\x55\x48\x71\x96\x68\xb3\xaa\x9a\x59\xa2\x13\xfc\xdf\x71\x9b\xb5\xcb\xca\xcf\x58\xb2\x64\x86\x64\xa6\x67\x2c\xb9\xfa\xa9\xac\x68\x68\xe8\x16\xcd\xf4\xa7\x57\x97\xcc\x90\x55\x0d\xad\x6a\x6c\xd6\x59\xa2\xc3\x0d\xf3\x8e\xf2\x47\xe2\x3b\x16\xac\xd0\xc6\x1a\xc5\x32\x16\xad\x34\x76\xba\x0d\x66\x41\x63\xd3\x7c\x27\xea\xec\x86\x5f\x59\x9d\x9d\xe8\xb9\x0f\x13\x2e\xde\x16\x4b\x44\x9d\xfd\x37\x28\xf5\xb0\xea\xc8\xa7\xc8\x02\xcb\x55\xe9\xc8\x67\x76\x77\x3e\xe9\xa3\xc0\x4b\xfa\xb6\xd4\xdc\xcc\x2c\x63\x52\xca\xba\x24\xff\x78\xff\x1d\x23\x57\x8d\x9b\x36\x6b\xe2\x94\x61\xfe\x48\x84\x4d\x8c\x19\x9f\xf1\xb6\x85\xb1\xac\xd8\x64\xda\x24\x84\xc5\x25\x86\x65\xca\x31\xe8\x16\x83\xae\xce\xab\x5b\xac\xf3\xca\xec\xca\xd8\x17\xbe\x5f\x80\x1c\xaa\x79\x7f\x5d\x73\xbe\x9c\x55\x76\x09\x9e\xe6\x54\x90\xcd\x79\xfb\xeb\x9a\x85\x93\x14\x34\xc3\x2e\xa0\xe0\xc1\x0d\xb9\xf4\x76\xf6\x27\x89\xd7\x18\x33\x8d\x7e\x70\x98\x87\x57\x26\x83\x1b\x0e\xb8\x24\xd5\xcf\x1e\x5a\xb1\x5e\x50\x7f\xa6\x36\x6f\x0f\x0e\x48\x93\x31\x5e\x67\x9f\x4a\x06\x67\x54\xef\x6e\x14\xe0\x0c\x55\x90\x9d\x9d\x6f\x91\xf7\x3e\xbb\x04\x7f\x96\xde\x61\x3a\x8a\xdb\x0e\xde\x10\xae\x5d\x33\x59\xae\xc9\x8f\x2c\x0f\x8b\xbf\x3c\x00\xaf\x5c\x7e\x02\xc4\x05\x18\xc1\x70\x8b\x1b\xee\x54\xdc\xbd\xaf\x75\x7f\xce\xb6\x38\xfe\x90\x2b\x0b\x6c\xcf\x79\xf5\x05\x6a\x77\x5c\x50\xe4\x5e\x19\x26\x63\x10\xb0\x98\xff\x05\x36\x31\xca\x52\x6a\x2e\x1c\x44\x77\xb0\xe2\xdb\x90\xc2\xec\x4d\x8a\x2a\x8c\x12\x94\xcb\x68\xe3\xc7\xc1\x26\x74\x83\x40\xec\x0f\x51\x99\x38\x2a\x1e\x87\xed\xc6\xc1\xc0\xe2\x92\x87\xb8\xe2\x22\x06\x9c\x03\xee\x38\xbc\x74\x08\x04\xe6\xa9\x6d\x25\xaf\xce\xa2\xa0\x41\x9d\x0e\x26\x35\xfb\x90\xda\xc4\x28\xef\x52\xab\x95\xb3\x18\xaa\xe4\xe2\x05\xe5\x35\xc6\x36\x47\xed\xe4\xa1\x7d\x33\x1c\x9d\x02\x35\x52\x43\xea\xee\x8a\x5d\x02\x22\x15\x19\x1f\x15\x99\x2b\x5f\xc4\x85\x2d\xb8\xa2\x1c\xd7\xc1\x3b\xf8\x04\xdc\x55\xb7\x93\x2a\xc5\x7c\x08\xe9\x47\xe0\x14\x34\x69\x9d\x2f\xc0\x02\xaf\xa3\xff\x0d\x1a\x57\x1d\x7d\x52\x39\xc1\x9b\x53\x0f\x06\xc2\x48\x29\xe9\x52\x4a\x58\x7c\x80\xc5\xe2\xfd\x2e\x0e\x48\xd8\x62\xd6\x1e\xba\x67\xae\x17\x74\xf6\x35\x37\xf8\x59\xb0\x04\x47\x3c\xc3\xf9\xed\x59\x25\x5e\x50\x45\xb5\x34\x25\x6e\x2c\x90\xaf\xe2\x19\x12\x66\xc1\xbf\x78\x98\x4e\x61\x69\x17\x4f\xe2\xdb\x14\x0a\x4a\xfe\xe3\xcd\x0f\xdf\x38\xfc\xaa\x77\xf9\x18\x18\xab\xcc\x25\x41\xee\xf2\xe4\x7f\xb7\x79\x92\x30\x91\x1a\xd8\xe5\x49\xe2\x44\xca\x66\xb5\x51\x7c\x38\xca\xf1\x05\x41\xa5\x9b\x8a\xde\x31\x79\xcf\x0d\xda\x15\x12\x74\x38\xf2\x6a\xb0\xfc\xf3\xda\x53\xfa\x69\x5a\x23\x7a\x23\xe9\x8b\xd3\x2c\x8c\xdf\xf4\xbd\xfb\x36\xcb\x35\x30\xa8\xda\x40\x86\x5e\x6c\x49\xf9\x58\x68\xbf\x50\x71\x62\x7f\x64\xd5\xdc\x26\x79\x7e\xd3\xf8\xf3\x96\x1f\x18\xe8\x67\x01\xfa\x6b\x18\x2f\x74\x5c\x48\x48\x3c\x24\x2b\x93\xf7\xf2\xa0\x75\x28\x7a\x95\x8a\xff\x2c\xbd\xda\xac\x0d\xc3\xc9\xe6\x68\xc1\x9c\x1a\xbb\x6b\x92\x84\xd3\x28\x30\x29\x0f\xc9\xe3\xe5\x8d\xc5\xc7\x04\xd0\x50\x50\x06\x9d\x9b\x59\xa5\x11\x35\x20\x64\x94\x96\x1c\x0a\x7c\x30\xfe\x51\xe0\xc1\x06\x78\x01\xd6\x14\xda\xce\x38\xef\x1c\xdf\x07\xfa\xc3\x03\x1f\x36\xd6\x37\x7e\xb9\xbf\xf9\xfb\xa3\xd1\x35\xd1\xed\x8d\xb7\x9a\x3e\x6d\x6c\x6c\xbc\x61\x3c\xfa\xc9\x81\xa6\x2f\xf7\x1f\x3d\x70\xa3\xf1\x8b\x03\x27\x13\x8b\xb2\xcb\x2a\xe1\x3e\x97\xfa\x78\xc4\x3b\xf6\xdf\x75\x6e\x07\x79\xac\xc0\x60\xa3\x3a\x0a\xaa\x30\x98\xd1\x8f\x1f\x16\x34\x44\xe0\x7a\xbd\x47\x10\xd8\x8c\xd1\x10\x0d\xcd\x70\x08\x9c\xa1\xec\x64\x79\xf6\x24\x48\xff\x40\x3e\x14\xc6\x43\x11\xfa\x5b\x54\x09\x8b\x71\x1d\x16\xc3\x3a\x8b\x22\x41\x11\xf8\x33\x87\x6a\xf9\x4b\x0f\x9e\x34\x3e\x13\xa0\x19\xa2\x31\x1a\x0f\xc9\x5c\x32\xd3\x23\x0c\xa3\xb1\x79\xe8\xd0\xc6\x4b\xe3\x25\xa8\x86\xa0\x0c\xe5\x35\xdc\x07\xc1\x8c\x2d\xa6\x6b\x0b\x1f\x9b\x59\x9e\x4a\x73\xbd\xdc\x08\x22\xbb\x3c\x93\xae\x8e\xe5\xcb\xe8\xf4\x44\x32\x83\x4a\x2b\x21\xe3\x33\x2b\x73\xe9\xbc\xc4\xbc\x12\x32\x37\x8a\x4a\x52\xe7\xf3\xce\x67\x3a\x4c\x66\xb3\x49\xc8\xcc\xcc\xa6\x9c\x1b\xc8\x39\x2e\xda\x64\xb7\x8c\x5c\xd2\x94\x9e\x59\x92\x47\x71\xc9\xbd\xfc\x88\x2c\x8b\xc9\x22\x58\x4c\xe6\xbf\x3e\xa6\xde\x83\x4d\x66\x93\x51\xc8\x49\x27\xb9\x01\xbd\x0c\x84\x0e\xff\xf1\x4f\x3e\xac\x2c\xba\x5e\xe2\xdc\x08\x3f\xa2\x76\xef\xbe\xba\xda\xb8\x8a\x30\xd9\xc9\xbb\x3b\x3e\x3a\x4c\xe6\xfa\x12\x7e\x84\x12\x74\x92\xe7\x3c\x88\x2a\x22\x2a\x29\x31\x3a\x53\xe6\xdc\x08\x1f\xe2\x53\xaa\x2a\x33\xb1\x28\x5a\xe0\xfa\x12\x3e\x04\x28\xfe\x0e\x31\x75\x75\x3d\x02\x42\x43\xe3\xa3\xc3\x24\x27\x2b\xd4\x79\x86\xed\x8d\xae\x93\x9c\x12\x6b\xcb\xf7\xd5\xd5\xc6\x3a\xe4\xfb\x10\x43\x89\xd0\xb8\x68\x27\xd4\x97\x80\x31\x6f\xf3\x59\x8e\x41\x51\xce\xb2\x58\x2c\x16\xd9\xe2\x80\x2d\x8c\x39\xcb\x01\x98\xb3\x4c\x16\x4b\xef\xc1\xa6\x2c\xb3\xc5\xe4\xf8\x98\x8d\x16\xc6\x19\x98\x4c\x66\x63\xef\x41\x26\x93\x23\x5f\x8c\xc9\x64\x32\x19\xb5\x0e\xd8\x6c\x74\xe4\xd4\xd8\x7b\xb0\x93\x5a\x32\x59\x1c\x45\x60\x72\x88\x17\x74\xf6\x0b\x39\xfc\x6d\xba\x66\x4f\x49\x94\xc4\x19\x08\x1f\x22\x3a\x21\x29\x4c\xf6\x0b\xee\x41\x45\x25\x26\x85\x49\x7e\x41\x20\xd0\x4e\xf3\x1a\xe3\xa8\xb2\xa2\xd2\xdc\x52\xa1\xaa\x2c\x39\xde\x2a\x57\x14\xef\xcb\x2d\x17\x0e\x99\xaa\x22\x77\x6a\x39\x03\xe1\x46\x8c\xa5\x41\xe7\x59\x4e\x27\xee\x49\x48\x8d\x16\x02\x82\x1b\xdb\x64\xce\x40\x30\x44\xdb\x81\xc6\x23\x15\xa5\x29\x49\x85\xd2\x5e\x9a\x73\x23\xdc\x88\x03\xb3\x29\x27\xfd\x2c\x1a\x86\xb5\xf1\xbb\xc3\x63\x36\x47\x44\xe5\x15\xc5\x49\x25\x35\x64\x6a\x61\x59\x6a\xa5\xc0\x25\x13\x24\x51\x59\x94\x57\x94\x9f\x9a\x13\x9b\x2d\x73\x0c\xe1\x42\x24\x66\x91\x81\x39\x71\x25\xd5\x0e\x55\x24\xd1\x50\x5d\xde\x5c\x5d\x91\x9e\x5c\x2a\x25\x85\x91\xb9\xc9\x71\x79\x31\x42\x5c\x72\x5a\x72\x72\x61\x66\x89\x51\x76\xb2\x97\x1a\xc9\x03\x19\xfb\x92\xc2\xb4\xe0\xb9\x9d\xe7\x92\x0d\xae\x7b\xd2\x92\xe3\x33\x92\x84\x6d\x49\x15\x4d\xf2\x07\xbb\x1a\xf6\xb7\x35\x6e\x3c\x13\xb2\x7a\x21\xcd\x25\x13\x84\x5f\x62\x4e\x72\x99\xe4\x80\x7c\x0a\xac\x59\xb9\x56\xb9\x20\x94\x74\xe2\x1f\x81\x17\x7f\xa4\x3e\x78\x83\x9c\x61\xce\xc8\xd0\xbe\x4c\x85\xe5\x96\x27\x57\x08\x5c\x2f\x82\xf0\x29\x29\xcb\xb3\x16\xc9\xa5\x11\x64\x42\x5c\x74\x7a\x94\xe0\x64\xde\x14\xbc\xff\x84\xec\x48\xed\x7b\x7c\xff\x81\xa3\x12\xbc\xee\xe9\x40\x33\x79\x05\xa6\xcc\x7c\x39\x79\x17\xc9\x19\x08\xa2\x57\x76\x5a\x9a\x25\x4d\x88\x4a\x4e\x8c\x90\xa7\x04\x81\xd0\x48\x3b\xb0\x4c\x9c\x33\xe8\x55\x9c\x5f\x54\x50\x2e\x34\x4e\xe7\xdb\xf6\x37\x9e\x94\x38\x3f\x97\x5e\xbd\x2a\x4b\xd3\x0d\xa5\x72\x42\x18\x59\x60\x30\xe4\x24\x0a\x9c\xc1\x8d\x20\xc2\x62\x63\x77\xef\x2e\x8f\xad\x95\x4b\x4c\x45\xb9\x45\x05\x0c\xc7\xb8\x11\x44\x69\x18\xe9\x4c\x4c\x4a\x48\xc8\x88\x12\xb8\x54\xa2\xaf\xc1\x7f\x57\x63\x9b\x0c\xc6\x59\x3c\xc7\x10\x84\xa1\x9c\x4e\x4c\x76\xd6\x4d\x50\x63\x5b\x5b\x63\x4f\xad\x58\xe5\xbd\x4e\xcd\x86\xc6\xd9\xd4\x2c\xda\xc9\xf4\x1b\xc8\xbc\x03\xd5\x37\xcf\x6a\xca\xcc\x73\xd8\xdd\x63\x72\xf4\x9e\xc4\x08\x47\x65\x10\x7d\xa7\x04\x83\x70\xa0\xc7\xe2\xbe\x3d\x16\x83\x0f\xca\x7c\x8f\xfc\x28\x61\x4b\x8f\xfc\xd6\x4a\xa7\xfc\x9b\x34\x67\xe8\x4b\x10\x07\xd0\x9d\x9a\x45\x9f\xad\xe4\xb3\xb2\x4c\x59\x82\xf3\x31\x2e\x13\xc3\x19\x86\x12\x8c\xc5\x64\x31\x5a\x4c\x8c\xc5\x68\x36\x3a\x9b\xaa\xd1\xd1\x54\x4d\x26\xa3\xc9\xc4\x70\x2e\x04\xe1\xe6\x04\x4d\x8c\xd1\x64\x34\x3b\x7f\xbd\x07\x19\x9d\x0d\xdf\x99\xda\xcb\x68\x31\x65\x59\x9c\xc7\x83\x39\x7a\x86\x39\x2b\xab\xf7\x60\x8b\x25\x2b\xcb\x22\x39\x79\x2d\xce\xc7\xbc\x98\xac\x2c\x8b\x45\x00\x55\xe7\xf6\x5d\x8f\xbf\xec\x50\xbe\xf9\xe8\x3c\xc4\x62\xc4\x77\xa3\x21\xfc\xe5\x5f\xa6\x7e\xe6\x61\xfe\xe3\x06\x0c\xf8\xb8\xf1\xc6\x71\xd8\x5e\x05\x85\x15\xb6\x97\x0f\xc0\xfc\x13\x37\xac\xc9\x0f\x60\x44\x07\xf7\xd9\xbf\xfd\xe0\x23\x9b\x99\xe7\x98\x8b\xc4\xc1\xc4\xa6\xf0\x4a\xa9\x32\x72\x77\xfe\x06\x21\x16\x43\xca\xa9\xe3\x0d\x05\xfb\x2a\x65\x07\x4d\x4d\x55\x49\xd3\x41\xad\x8e\xfa\xf5\x06\xcf\x31\xae\xc4\xc1\x88\xf2\x8d\x52\xd4\xcb\x15\xd4\xf1\xea\x7d\xcd\x32\xe7\x36\xde\x4f\x67\x5b\x36\x97\x5f\x15\xb1\x26\x60\xa7\xc4\xf9\x78\x11\x21\x3b\xb7\x18\x56\x0a\x8e\x84\x57\xe0\xd1\xcf\xd4\x1f\x9d\x33\x87\xc9\x8d\x38\x91\x87\x47\x37\xf0\x11\x0d\x05\xbf\xf2\x73\xd7\xac\x9b\xb5\x6a\x6b\xe5\xc9\x20\xe9\xf8\x31\x92\xf3\xa0\x88\xe0\xb2\xba\xf8\x26\x81\x73\x23\x0c\x07\xaa\x2a\x1b\x4a\xd3\x8a\x13\x0b\xe4\xd4\xdc\xc4\xdc\x50\x2b\xb3\xb0\x3a\xb2\xf6\xb4\xf6\xbd\x53\x6d\xef\xb7\x34\x27\x85\xee\x97\xb6\xfb\x93\x1c\x43\x18\x2a\x62\xe3\x0a\xa2\x84\x5d\x51\x71\x91\x31\x45\x7b\x8e\x26\xc8\x9f\x85\x54\x87\x2d\xd7\x42\xd3\x68\x3e\x21\x38\x2c\x7d\x97\x30\xf4\xad\x3b\x4f\x7e\xb9\xf7\xf9\x93\xfd\xb5\x69\x09\xfb\xe5\xb7\xe8\x86\x90\xf0\xa2\x40\x61\xe1\xea\x15\xf3\x66\x9f\x5e\xfd\xd1\x81\x9a\xa2\xfa\x7a\xf9\x2d\x5a\xe7\xf6\x89\xfa\xab\x73\x76\x65\xfb\x8a\xb2\x0f\x80\x29\xca\x35\xe8\x04\xdf\x67\x8c\x5a\x4b\x77\xfd\x60\x33\xf2\x43\x26\x4e\x1c\xe2\xf0\x99\x86\x21\x13\xbf\x7c\xf6\xec\x4b\xc7\x6f\xe2\x10\x19\x5e\xc1\xa9\xfc\x36\x0a\x07\xc0\xcf\x24\xe7\xc6\x10\x37\xa9\x6f\x31\xfc\x3b\x08\x27\x6f\x52\x07\xf0\x11\x0f\x8f\x60\xfe\x52\x7c\x71\x2a\xd0\xcb\x90\x1e\x0d\x2f\x2e\xa3\x61\x93\xe7\x68\xf0\x26\x93\xd1\x7b\x2e\x3c\xa2\x1c\xf2\x7e\xa1\x6e\x9f\xd8\x3a\x7f\x45\xc8\x8e\x55\x7b\x64\xce\xcf\x8d\x78\x8e\x3e\x24\xbc\x68\x9b\xcc\x7f\xb6\xf8\xda\x34\x49\xa7\x30\xd4\xb4\xc5\x8b\xa6\xca\x3a\xec\x4d\x4f\x7d\x7f\x51\xa7\xa4\xa3\x15\xaa\xf3\xfd\x6b\x9f\xc9\xee\x4a\x23\xd4\xb6\x6c\xbd\x7a\xe8\xd2\x9a\x4b\x6b\x2f\xbd\x7b\xe9\x0c\xac\xc6\x55\x97\xdf\xfb\xe6\x75\x18\x96\x7a\x79\x19\x30\xc8\x40\x0d\x6e\x81\x2d\xe8\x77\xd9\xff\xd2\x91\x7f\x2e\xbd\xe2\x61\xbe\x39\xfd\x2e\x4c\xae\x7e\xef\xc6\xe9\x8a\x8e\x8e\xf8\xca\xf6\x8f\xce\xdc\x80\x05\x37\x96\x77\x9c\x06\xd7\x41\x95\x47\x3f\x59\x72\x6b\xd6\x8d\xca\x1b\xeb\x3e\x3a\x58\x19\xf5\x91\x3f\x4c\xc3\x7e\x37\x67\xdd\x78\x49\x47\xbd\x7a\x03\xc4\x9a\x9a\x8f\x17\xc1\x7a\x9c\x73\xe3\xe3\xba\xa8\x7f\x16\x7c\xb4\xf4\x9f\xed\x7f\xea\x2f\x71\x33\xa6\xcb\x3b\x56\x7c\x5f\x05\x2f\xda\x7e\xe6\x4f\x02\x71\x0a\x09\x52\x39\xa0\xd6\xf0\xf8\xfa\x7b\x30\xe0\x12\xc5\x19\x0c\xbd\xdc\x18\xa6\x2f\x0e\x38\x0b\xe3\xa8\x4f\x27\x91\x1c\x91\xea\x45\xf4\x1a\x50\xf5\x95\x89\x7f\xfa\x27\x89\x41\x34\x2c\x81\xd1\x3c\x47\xf8\x11\x04\xe1\x47\x84\xc6\x18\xc2\x25\x8e\xc8\xec\x95\x4c\x10\xc4\xf8\x4f\xbe\xa2\xaa\xf7\x25\x87\xc9\x70\x3c\x87\x0f\x89\x4c\x8f\x90\x26\x52\x1c\xe1\xd7\x97\x20\x08\xe2\x83\xfb\x74\x65\x75\x46\xa8\x8c\x4d\xca\x16\x7e\xb7\x33\xed\xda\x7d\x8a\x23\x72\x37\xfb\x11\x44\x5f\x67\x92\xe2\x3f\x93\xe7\x08\x37\xc6\x41\x7e\x0a\x88\x93\x48\x90\xdd\x4d\x30\x8a\xe7\x88\xbe\xd3\x1d\xda\x90\xa0\xde\xc2\xf9\x63\x61\x3e\xd9\x1f\x0b\x29\x8e\xf0\x71\xda\x80\xbd\xa0\x90\x1c\x41\x71\x84\x1b\x41\x10\x6e\x06\x64\xb0\x96\xfc\x94\xaa\xbb\x46\x82\x40\xd5\x2d\x22\xc1\x0b\xb6\x51\x3f\xe1\x36\xf2\x0a\xf5\x13\x6c\x23\x71\xdb\x47\xb4\x72\x11\x8f\xf0\xff\x5c\x5d\xb5\x50\xe2\x88\xbe\x7e\x0e\x3e\xdc\x44\x39\xc1\x5e\x04\x31\x61\xcc\x9b\xdf\x92\x58\x82\xb5\xd4\xdf\x89\x60\xa5\x1e\x7c\xf7\xc5\x68\xb2\x47\x83\x0f\x01\x1e\xdf\x53\x9f\xc1\x8b\x31\xe0\x22\xe3\x49\xf8\x89\xc7\x57\x1c\xa4\x06\x87\xf2\xf7\x60\xe8\x25\x1c\x7a\x16\x5e\xa1\xff\xce\xc7\x15\x0c\xc2\x5a\x08\xa2\x75\xe4\x24\xd5\xcc\x27\x04\x6f\xcf\xdc\x29\xe0\xa4\x5a\x2a\x26\x7c\x6b\x5a\xb0\xa0\xd6\x7f\x4d\x15\x19\x2d\x7b\xa4\x94\xa1\x38\xed\x5f\x54\x52\x70\xa0\x29\x48\x88\xa4\xb8\x0d\x7d\x5d\x5c\x08\x82\x18\x83\x5b\xe9\x77\xdf\x27\x39\x37\x82\x70\x94\xa1\x7e\x31\xc9\xf9\xf4\x80\xf8\x58\x71\x87\x7f\x51\xe7\x96\xbc\x77\x95\x84\xc4\xff\x30\x34\x9c\x30\x46\x55\xc9\xd5\x10\x40\xef\x3f\x9c\x1e\x5b\x2b\x57\xc3\x27\x34\x97\x47\x10\x44\x7f\x82\x88\xa0\xb9\xc5\x0e\x8b\x0c\xc4\xbe\x8a\xe6\x9c\x3a\xe1\x6f\x3c\xcc\x88\xa0\xca\x6b\x1a\x73\xf7\x0b\x5c\xbf\x1e\xe1\xd0\xdb\x36\x91\xea\x5c\xfc\xc1\xdf\x0d\x79\xe1\x34\x59\x15\xe8\xbb\x30\x8b\x84\xc9\x54\xb5\x3f\xc9\xf5\xef\xef\x37\x9a\x20\x88\x93\x34\x47\xf4\xf2\x63\x0c\x04\x01\xab\xa8\x13\xc3\x4f\xfc\x42\xda\x18\xaa\xbe\x21\x23\xa6\x52\xae\xa6\x39\x82\x21\x9c\x49\x7e\x11\x14\x47\xf4\x22\x18\x3f\x82\xd8\x77\xe8\x68\x4e\xab\x00\x59\x54\x8d\x3f\xe9\x48\x77\xd4\xdf\x49\x58\xf0\x1f\xda\x3a\x7f\xf2\x24\xcc\x56\xdd\x69\x6e\x86\xc3\xd2\x25\x04\xce\xa5\xb6\x5f\x25\x97\x60\x14\x1d\xfa\x01\xb9\x8c\x0a\x5d\x48\xce\x1a\x63\x68\x9e\xeb\x1c\xcd\x08\xa2\x1f\x11\x8e\x07\x69\x6e\xaa\xc1\x09\x3f\xa2\xf3\x4d\xf9\xc9\xd2\x1e\x13\x39\x54\x3d\xd2\x4e\x73\x8e\xb6\x41\x30\x44\xd4\x1a\x12\x49\xea\x6f\x81\xd1\xa7\xc9\xb5\x18\xec\x90\xa6\x77\x48\x43\xd7\xae\x89\xd4\xb4\xf7\x17\xfe\xdd\x41\x3f\xe8\x94\xbb\x4c\xca\x26\xbe\x43\x6f\x5d\x21\xe1\xab\x58\x7b\xc3\xc1\xe9\x28\x59\xe2\xe9\x27\x34\xd7\xaf\xaf\xb3\xc4\x4e\x94\xa5\xac\x95\xd7\xdd\x78\x8f\x3e\x9c\x5a\xbb\xb5\x44\x6a\x2c\xde\xdb\xd8\xa8\xc5\x46\x65\x2b\xdf\xa1\x2f\x78\x57\xc2\x91\x16\x12\x6b\x3b\x9e\x7c\x4a\xdf\x8a\xdf\xb4\xc4\x22\xdf\xa0\xfe\x6e\x39\x17\xe9\x96\xb4\x9a\x2d\x25\x12\xc7\x3a\xbb\xc4\xe2\x03\xc5\xe5\x8d\x4d\x5a\xa5\x5e\xfd\x83\xc7\x11\x16\xf2\xef\xd6\x33\xe2\x32\x06\x62\x2d\x04\xd2\xea\x5b\xb6\x48\x7e\x0e\xd6\x7e\x44\xd9\xe6\xa8\xfd\x78\xf0\xc4\x49\x6f\xbc\xaf\xad\xae\xc8\x2e\x97\xe0\xc5\x2b\xe8\x49\xad\xdc\xb0\x5b\x2f\x23\x0f\x6f\x7e\xb1\x44\x1b\x19\x93\x11\x27\xa1\xc7\x12\xf0\xa0\xae\x9e\xac\xee\x90\x21\xe5\x1c\xdf\x53\x4e\xc4\xfa\x8d\xef\x21\xb9\xea\x8c\xb6\x7a\x5f\xf6\x3e\x09\xd8\x2b\xc8\x53\x2b\xd7\xff\xc5\x79\x6f\xa9\x36\x2a\x36\x3d\x4e\xc2\x7e\x4b\xa0\x1f\x75\xb0\x35\x7f\x7f\x85\x8c\x13\x6c\x4b\xf9\x39\xb8\x98\x42\x0a\x16\x93\x43\xd1\x4a\xa1\x0b\x58\xc9\xe1\xd4\x28\xdc\x4e\x06\x53\xef\x1a\x0e\x9e\xfe\xf1\x7a\xfc\x3f\x4d\xf2\xfb\xf3\xe9\x51\x1b\xd7\xbc\xe6\x7b\x6c\xed\xb7\xf2\x6d\x67\x9f\xd3\x52\xf5\xce\x3e\xe7\x4f\x81\x3b\xfa\x93\x9c\x9f\x63\x34\x26\x16\xff\x40\xb9\x2b\x8d\x4a\x1b\x0c\x2d\x83\x17\x3c\xcc\xa0\x51\x02\xe0\x15\x7b\x20\xbc\x02\x67\x40\xc3\xc5\xdb\x12\x6c\xac\xd2\x5b\x6c\x88\x6c\x3d\x7b\xb4\xf5\xac\x64\xab\x87\x61\x3c\x97\x7b\x22\x20\x6b\xbb\x14\x43\xa5\xa6\x67\xa4\x9a\xe4\x58\x9f\x83\x16\xf2\x42\x4b\xf1\x35\x19\x7e\xc7\x61\x4a\x6f\x71\x7f\x64\xeb\x19\x07\xb1\xce\x7e\x00\xa6\xc0\x39\x11\x7b\x91\x06\xd3\x9e\x14\x83\x30\x85\x82\xcb\x62\xa1\x00\xbe\x60\x61\x67\x52\xc9\x19\xf9\xd6\xbc\x2c\x6b\x56\x9e\xbc\x2b\x74\x5d\xdc\x56\x61\xf2\xaa\xf3\x77\x7f\xbe\xfd\xe8\xc9\x91\xe6\xb4\xed\x35\x32\x5c\x65\x95\xe1\x59\x7c\xa6\xd9\x68\x34\x4a\x58\xa0\xba\x91\x69\x19\xa9\x19\xa9\xc2\x5b\x54\x6a\x5a\x5e\x7e\xf1\xcd\x1f\x8b\xca\xe4\xd4\xaa\xc9\x10\x99\xab\xcd\xcf\xcb\xcf\x97\x6e\x53\x85\xd6\xd4\xe4\x6c\xf9\x24\x0e\xff\x03\x5e\x23\xf3\x72\xf2\x73\xf2\x85\xcf\xa9\xfc\xbc\xd4\x54\x59\xe9\x7b\xd6\x61\x06\x43\xa6\x1a\xd3\xd2\x52\x84\x09\x14\x37\x1b\x2e\x8b\x45\x02\xbc\x0e\x16\x96\xcb\xfc\xcb\x94\x6c\xab\x25\x4f\xde\x15\xb6\x2e\x6e\x8b\xd3\x14\x99\x5b\xec\xb0\xe6\x68\x73\xda\xf6\x6a\x09\xae\xb2\x30\x03\x86\xf2\x73\xd5\x91\xce\xbc\xec\x11\xe6\x50\x29\x69\xf9\xf9\xb2\x25\xeb\x86\xe2\x4b\xe6\x59\xf2\x72\xf3\x84\xcf\xa8\xfc\xbc\xb4\x14\x59\x67\x63\x50\xe0\xdf\xb3\x6e\xcf\x5b\x27\x44\x53\x69\x69\x3d\x65\x74\xc8\x42\x9e\x6c\xce\x3b\x5f\x20\xeb\xe8\x68\xa5\xc4\x31\xab\x50\x92\x1e\x8d\x85\x8a\x31\x4f\x7e\x3c\x0d\xaf\xc3\x63\x0f\x33\x68\xe1\xe7\x4f\x21\xf1\x2c\x14\xb5\xc2\xf0\xf7\x61\x38\x50\x30\xac\x09\x86\x42\x2f\xe8\x0f\x1a\xee\xc2\x73\x1d\x35\xd9\xd6\x87\xff\x22\xfa\x78\x40\x4a\x78\x66\xc8\x6e\x89\x5b\x4a\x60\x38\x9d\x56\x5c\x9a\x59\x26\x54\x55\x94\x54\x17\xcb\xa5\x75\xf9\x87\x4f\x6b\x95\xb9\x2d\xfc\x47\xc6\x98\x83\xdb\x85\xed\x31\x81\xb3\x33\x64\xe8\x45\xe9\x6c\x3f\xa1\xc0\xaf\x88\xdd\xbc\x3d\x44\x0a\x0b\xf4\x4f\x7c\x47\x98\x35\xb7\xaa\x72\x9b\xbc\x0f\x48\x32\xac\xed\xc3\xe8\x23\x42\x53\x79\x51\x65\x55\x4c\xc9\xbb\x15\xf2\x84\x03\x2b\x5b\xee\x6b\x4f\xed\x3d\x72\xb0\x5e\xaa\x6b\x3c\x5e\x72\x5e\xb8\x75\x21\x2a\xa9\x4e\x8e\x41\x37\x72\xef\xce\xb5\xe5\x6b\x85\xb0\x84\xe4\xd8\xa8\xda\xc4\x93\x71\xb2\x99\x7e\x10\x74\x7e\xdb\x38\x2d\x9c\x81\x9d\xfc\x5b\xb8\x92\xda\x5e\x12\x77\xa0\xb4\x2a\x37\xcb\x2a\x21\x4b\x67\xc4\x86\xa7\x6e\x16\x56\x6e\x2d\xac\x0c\x95\x83\x6b\xe3\x8f\x5e\xd1\xc2\xae\x05\x74\xf9\x6f\xa7\x0b\xf6\x01\x05\x7c\x15\x89\xc2\x63\x1a\xce\xa1\x8e\xcf\xda\x93\x62\x4e\x11\xb6\x86\xa4\x84\x47\xcb\xf8\x3e\x0e\x57\x76\xc2\x4b\x74\xe1\x32\xf2\x58\x49\x73\xf5\x71\xc1\x6a\x35\x19\x0b\x65\x94\xe9\x56\xfc\x86\x57\x76\xc2\x70\x75\x27\xad\x04\x42\x16\x3f\x3a\x6a\xd6\x46\x7f\x69\xed\x06\xfd\x9e\x2d\x42\x64\x58\x4e\x7e\xb8\x8c\x23\x68\x1c\x1e\x4a\xda\xbc\x69\xee\xc2\x73\xf0\xa2\x0a\xd6\x90\x47\x5a\x8e\xec\x3b\x21\xb4\xb7\xc6\x6e\x6b\x90\x1b\x03\xca\x16\xbe\xa9\x55\xb7\xc1\xaf\xbc\xff\xb6\xad\xfe\x12\xe7\xa7\xf1\xdf\xd6\x72\xf2\xe4\xe1\xc3\x27\x4f\x1e\xde\xe6\x2f\xdb\x3d\xd1\xc6\x1b\x4c\xdb\x4d\xa9\x12\x5a\xa8\xec\x40\x6b\xc4\xde\x44\x86\xbb\xf0\x3c\xb1\xb4\x32\xed\x80\x70\xe6\x44\x51\x65\xab\xbc\x77\x10\x19\xba\x65\x71\xfc\x3c\x61\xc6\x3b\xfb\x5a\xb7\xc8\x5c\x15\xb3\xe1\x58\x64\xc7\x57\x5a\x78\xe5\xde\x4f\xa0\xb9\x7e\x36\x62\xc3\x21\xe9\xe0\x86\xbd\x8b\xfd\xb4\xa0\xb1\xc9\x9b\x59\x68\x44\xeb\x17\xb0\x22\xb2\x3a\xd2\xc3\x66\xfd\xe2\x0b\xd0\x73\xad\x3a\xca\xd3\xe6\xc7\x73\x9f\x74\x35\x75\x4d\x25\xb1\xbf\x05\x1c\xbd\xb9\xbf\xc0\xb5\xce\x13\x65\x45\x1f\x23\x2a\x2f\x88\x8c\xda\xd4\xf5\x2b\xff\x84\x05\x5a\xb4\x27\xea\x28\x3f\x7e\xdc\x63\x43\x69\xa4\x25\xd1\xe0\xad\x8e\xc5\x7f\x93\xdc\xa9\x7c\x96\xe4\x5a\x4b\x8a\x2d\x95\x86\x52\xc6\xbd\x47\xc7\x74\xd0\xa0\x1b\xb8\xa5\xb3\x60\xf5\x80\x33\x2c\x68\x9c\xda\x1e\xd8\xeb\xd0\x97\x87\xd5\xec\xf0\x49\xf7\x7e\xb1\xe6\xe7\x5b\x25\xee\xbc\x35\x3f\x35\x79\xd2\x8d\xb9\xf7\x1c\xa1\xcc\x3d\x50\x9b\x95\x5d\xfc\x0f\xf0\xf6\x29\xd8\x01\x56\x2d\xf0\xe0\x0e\xcb\xa0\x0c\x96\x02\x33\x64\xc0\x39\x49\x09\xe9\x9e\xc5\x2b\x2f\x88\xe8\x3a\xdc\xab\x0d\xe7\xde\xc6\x57\xc0\x15\xfb\x31\x5d\x46\x0a\x87\x21\xff\xdf\xec\xff\xcb\xfa\x47\x3a\x32\x84\xef\x31\xd6\x61\xab\x57\x3e\xdb\x63\xa6\xb7\x3b\xfe\xfb\xa8\x68\xb3\x82\x15\x52\x44\x0f\x98\x20\x82\x95\xbb\xc0\x7d\xa5\x58\xc1\x97\x9f\x28\xda\xf4\xab\x45\xee\x42\xc7\x52\xb6\x4b\x4f\x73\x5f\x81\xd5\x73\xa2\xc8\x5d\xb0\xe9\xa7\x38\xe2\xce\xd8\x5f\xb0\xda\x66\x0f\xff\x8a\xe5\xbe\x3a\x1b\xb5\xe8\xd8\x72\x01\x3b\xa9\xe5\x8b\x36\xad\x8a\x92\x67\xe0\x9b\x24\x5e\x1f\xca\x72\x17\xe6\xd1\xdc\x57\x2f\xb3\x8f\xbb\xe7\x53\xd8\xeb\xd6\xe8\x6f\x24\xee\x82\xad\x93\xfa\xe6\xd6\x4f\xd0\x4b\xb6\xcf\x86\x08\x36\x48\x04\x5f\x18\x60\x9b\x00\xfd\xc1\x17\x7c\x44\x98\x0e\xe3\x94\x72\x18\x8e\x22\x0c\x87\x22\xd0\x70\xdd\x06\x9d\x5b\xa2\xb2\x91\xb7\xa6\xe4\xa7\x48\xf8\x22\x95\x92\x9a\x9a\x2c\xcf\xa0\xe7\xa3\x2e\xe4\x6d\x5c\x82\x3a\x18\x02\x6b\x61\x39\x78\x82\x00\x8b\xee\x43\x9f\xe0\xf9\xd2\x0c\x3a\x39\x3f\xd5\x2a\x71\x5d\x06\x60\xbf\x67\xc1\x85\x86\xd7\xb1\xf8\xf0\x50\xac\xc5\xf5\xb8\x1e\x6b\xf1\x00\x6c\xc4\x00\x68\x80\xfe\x10\x71\x01\xfa\x4b\xaa\x87\xfd\x75\x1e\xde\x11\x65\xae\xdb\xb0\x81\x95\xfe\xeb\xae\xbf\xec\x90\xd0\x47\x0c\x12\x61\x11\x48\xd8\x1b\x78\xdb\x60\x90\x61\xb8\xc3\xc8\x97\x61\xa4\x92\x08\x2f\xc3\x13\xd0\x70\x0f\x0c\xdc\x05\x83\x7d\xbd\x2d\x8b\xc7\x8d\xe8\x83\xb1\xb8\x16\x3d\xa7\x3e\x84\x61\x12\xf7\x95\x01\x2a\x61\x26\x4c\x80\x89\xe0\x71\xfb\x0d\x1c\x24\x71\x17\x0c\xca\x07\xd8\x87\x57\xfc\xf1\x3a\x5c\x57\xfd\xa1\xcc\xe1\xc6\xa6\x5e\x07\x57\xd0\x49\xf9\x79\x39\x05\x96\x02\x8b\x35\xb3\x20\x3d\x7f\xe3\x59\x2f\x43\x69\x54\x56\x42\x12\xf3\x2a\x52\x38\x68\x05\x0e\xf9\xcf\xe6\xd6\x7f\x80\x23\x90\xb9\x07\x06\xc5\x1b\x72\x30\x47\xf5\xc6\x03\x18\xb2\x6b\x96\x51\xde\x18\x57\xf4\x5e\xa9\xa5\x2c\xa7\x42\x86\xde\x8a\xdd\x92\x6b\x2a\xc8\xcc\xf6\xce\xc9\x4c\xcf\x4f\x17\x90\xa5\x52\x53\xf7\xa4\x98\x64\xc3\x32\x63\x34\xf9\x70\xe5\xc8\x73\xf8\x82\x80\x35\xb8\x1b\x8b\xf1\x16\xc6\xc3\x3f\xd0\x1b\x76\x82\x00\xc4\x9d\xbb\xd7\xe5\xec\x1d\x45\xbb\x2a\x22\x98\x6d\x4d\x67\x63\xae\x97\xe6\x5a\x4a\x04\x58\x9a\x07\xa1\xf0\x02\x74\x68\xdd\xab\x50\x03\x7a\x17\xd8\xce\xba\xea\xa8\x1a\x1d\x59\xc3\x63\x3f\xe8\x87\xfe\x16\xec\x8b\x1e\x18\x86\x11\x5e\x03\x7f\x07\x8a\xf5\xc6\x2d\xb8\xe5\x7b\xd1\xfb\xf9\x00\xf5\x99\xfa\x8c\x0c\x0b\x4b\xdc\xb9\x5d\x8b\xfe\x34\x6a\xd0\xda\x31\xcf\xb9\x99\x29\xf8\x53\xcd\x07\x4b\x6a\x6b\x65\xe5\x99\xf2\xec\xf9\x80\x3f\x44\xd8\x02\x5b\xfe\x25\x7a\x0f\xfc\x1d\x22\x20\x0c\x3c\xa0\xaf\x09\xfc\x1d\xc2\xbd\x75\xb8\x4e\x67\xaf\xe0\x51\x0f\x7a\x4a\xe9\x54\x3a\x41\x8f\x7a\xb2\xe7\x39\x93\x6e\x57\x1d\xb5\x08\x2a\xd9\x55\x6b\x23\x76\x6e\x93\xbb\x3c\xd4\x3b\xe4\xe2\x77\x76\x4c\x7e\x53\x8b\x93\x40\xc2\x41\x30\xf9\xe1\xad\xe6\x2b\x1f\x48\xd0\x0f\x68\x28\x53\x12\xee\xc2\x50\xa6\xb6\xbd\xea\xfc\x45\xed\xcf\xe3\xfe\xf9\x9a\xd4\xdd\xbf\xbb\x82\xc7\x88\x3d\xe8\xbd\x69\x2c\x86\x32\xe1\xc9\x91\x09\xa1\xc2\x06\xe4\x7f\xab\xdb\x22\xe3\x35\x18\x82\x35\xf0\x03\x1c\x85\x55\xb0\x02\x8e\xa4\x49\xa6\x9b\xd8\xeb\xc0\x2b\x77\xde\xfd\xd5\xdb\xbd\x4a\xd1\x80\xd5\x05\x36\xb0\x9a\x90\x38\x11\x34\xbc\x42\x89\x2b\xe1\x43\x56\xa1\xc4\x15\xc2\x8a\x88\xe8\xa0\xed\xf2\xb6\x0d\x2b\xfc\x87\x09\x43\x57\x9c\x3c\xbc\x51\x6e\xdc\x16\x51\xb1\x02\x3e\x64\x55\x4d\x9c\x48\xdb\xf4\x6e\xe0\x2e\x4a\xf3\x14\x3d\x5a\x55\x3d\x5a\xff\x67\x38\x8f\x6a\x62\x65\xd4\xd3\xe7\x6b\x2a\x1a\x9b\xe5\xc3\x6d\xe7\x4f\x3e\x15\x9e\x5c\x80\xab\x62\xb3\x7c\xf8\xf8\xf9\x93\x4f\x84\xa7\xe7\xe1\xaa\x78\xf8\xef\x94\xf3\xfe\xdb\xda\xe4\xa0\xc3\xd5\xd1\xe7\x05\x1d\x12\xf6\x36\xfe\x8e\xa8\x58\x3d\xff\xba\xb8\x83\x37\xab\x6a\xe0\x03\x51\xd5\x60\xa7\xda\xa9\x74\xaa\x7a\xb5\x93\x54\x3b\x8f\x89\xb4\x7b\x15\x1c\x66\x75\xd4\x45\x57\x9b\xd5\xa6\xe5\x6d\xd9\x60\x62\x61\x3b\x2c\xff\x1a\xfa\x83\x2c\x23\x2a\xad\xbc\x72\x5c\x3d\x41\x3a\xa2\x5f\xc3\x72\xd8\xae\x9d\x07\x9a\x5b\x62\x97\xd5\x66\xa5\x1d\x52\x51\xa3\x23\xd7\x2f\x15\xd5\x59\xd4\xae\xf8\xed\x91\x55\x32\xf4\xc1\x3e\xea\x66\x75\x33\x26\x40\x82\xa3\xf2\xd5\xfb\xea\x7d\x47\x25\x29\xbe\x8a\x2f\x24\x60\xc2\x1f\xa2\xad\x8f\xad\x8f\x83\x8a\xac\x8a\x6c\x2e\xdb\xaf\x75\xaf\x32\xc3\x78\x5b\x1d\x8c\x73\x31\xc3\x78\xfb\xbb\x30\x01\xbe\x83\x71\xae\x3a\xb2\xb7\xad\x93\xff\xf8\xbd\xb3\x37\x1a\x4f\x58\x22\x6a\x25\x13\x5d\x17\x5d\x1a\x5e\xb6\x0b\xf8\xa7\x5e\x91\x07\xa2\x9a\x43\xea\x18\x0b\x35\xe3\xfa\xf2\xec\xd7\xb3\x19\x1c\x92\x8b\x32\x72\x38\x54\x6b\xb0\x18\xb2\x0c\xd2\x75\x55\x50\xe6\xc0\x58\x4c\xd6\x62\xaf\x51\xb3\x07\x22\xe5\x07\xc4\x0f\xfe\x12\x3c\xc2\xb1\x61\xca\x18\x35\x54\xc0\x36\xb4\xe0\x3e\x3c\x82\xed\x10\x89\x95\x70\x09\x86\x81\x74\x18\x5e\xf8\x55\x36\x59\xca\xab\xf6\xd6\x16\xd5\x79\x8f\x83\x57\x22\xd6\x07\x05\x04\x6e\xf3\x36\xd3\x7e\xf3\x86\x46\xbd\x22\xe0\x4e\x1c\x05\x7a\xd8\x04\xef\xc2\x34\x58\x0a\xab\x20\xec\x4b\x64\x70\xd5\xe7\x32\xa6\xfe\xf8\x4c\x95\xe0\xb6\x00\xcb\x61\x22\xf8\xc0\x6a\x58\x81\x63\xbe\xc5\x37\xdb\x65\xbf\xaa\xf9\xe5\x21\xf7\x19\x63\x7e\xca\xfe\x3c\xe7\xd1\x75\x03\x74\x24\xfb\xbb\xab\x8e\x2c\x51\xa2\x79\x1c\x88\xbd\x5f\x46\x19\xe3\xdf\x86\x56\xf0\x9b\x2d\xc1\xc0\x65\x4b\x1e\xa0\xaf\x80\x3e\xa8\x41\x2d\xca\x38\x02\x5c\xd0\x07\xc6\x40\xef\x4f\x4e\xff\x71\x59\xbe\x86\x2e\x29\x31\x86\xd8\xa4\x38\x6f\x33\x3d\xf6\xed\x21\xa1\x3e\x02\x46\xe2\x10\x58\x02\x3b\x52\x65\x0b\x0d\x1b\x52\x61\x21\x2c\x83\x4d\x02\xfc\xb2\x0f\x2f\x60\x0a\x30\xf2\x9c\x83\x17\x27\xdf\x17\x6e\x7f\x7c\xe6\x0b\x93\x9c\x4b\x9b\x3e\x1b\xdb\xb0\xa8\x1c\xdd\x0f\xcf\x3c\x1e\x01\x3a\xe6\xaf\xe7\x3c\x5c\x9e\x3e\x7a\x7e\xfd\x64\xea\x86\x76\xc9\x4c\x57\xc4\x94\x85\x96\x45\xbe\x3a\xdd\xcb\x50\x95\xbc\x37\xba\x94\xb1\x50\x7b\x63\x02\x4d\x11\xc2\x9a\x80\x6d\xab\x33\x72\xa3\x2d\xe9\x72\xe5\xa2\x53\x89\x97\xe2\x19\xe8\xbd\x1d\xa8\x79\xd8\x5f\xfb\xbb\xad\xaf\x8f\x08\x8d\x10\x21\xda\xad\x30\x53\x74\x4d\x67\x6d\x1a\xfe\x43\x11\x06\xb1\x70\x18\x62\x31\x16\x0f\x4b\x36\xab\xe7\x87\xa2\xa4\x7a\x52\xf0\x1a\xbc\xf0\x2f\x58\x08\x01\x5a\x08\x18\x0c\x0b\xf1\x35\x78\x41\x52\x3c\xa9\xbf\x09\x65\xd0\x78\x82\xc3\xa7\x1d\xc3\x3f\xa4\x2e\x2b\xf5\x5f\xcf\xca\xc3\x31\x3c\x06\x7f\xc8\xf0\x3b\x2b\xf7\xdc\x0e\xb4\x5b\x41\xe3\xa2\xa3\x0d\xa0\x71\xb5\x69\xdc\xfe\x26\x90\xe0\x77\xf6\x6f\x01\xf2\x7f\x13\x20\x87\x8b\xaa\x95\xff\x6f\x26\x41\x13\xeb\xae\x34\xf6\xbc\x8d\x35\x92\x75\xcc\xa9\x8d\x22\xcc\x14\xb9\x3b\x06\x5b\xb6\xe2\xe8\xbd\x2c\x4e\x87\xd3\x2c\x4c\x87\x54\xf1\xec\x69\x43\xd4\x71\x19\x17\x63\x0e\xb9\x61\x67\xe3\xa2\x8b\x02\x7c\x4c\xe1\x42\xd0\xf0\xe0\x0a\x43\x49\xee\x07\x43\xeb\xc6\xfa\x15\xc5\xcb\x18\x68\xf7\xc4\x09\x54\xc2\x93\x75\xdf\xcc\xfe\xe8\x29\x78\x79\x29\xe1\x94\xad\x53\xd5\xf3\xf0\xce\xdf\xc2\x24\xee\x8e\xe1\x9b\x96\x7b\x57\xae\x4a\x60\x16\xb9\xc7\x06\x18\x27\xca\xdc\x1d\x83\x23\xd7\x66\x5c\x0b\x6b\xd1\x3c\x73\x6e\xdc\xae\x25\x12\x56\x2a\x83\xc8\xf2\xa4\xa8\xa2\x48\x01\xad\xd4\x1e\x16\x42\xa9\x87\xa8\x21\xd5\x59\xa0\x51\x35\x3d\x9b\xfa\x73\x3f\x18\x50\xc4\x79\xe4\xe1\x79\xd3\x2a\x27\x0b\xdc\x1d\xc3\x6a\xf6\xa4\x08\x91\xb0\x10\xde\x84\xa0\x26\x19\x56\x52\x95\x15\xd6\xf2\x62\x19\xfe\x50\xb6\xdf\x18\x46\xbe\x36\x61\x09\xbe\x88\x5e\x5a\xee\x07\xc3\x49\x11\xcc\xb0\x16\x8a\x59\xc9\xdd\x0c\x7a\xc5\x55\x84\x33\xec\x63\xe7\x03\x3a\x1a\x33\x58\x1d\x63\xbf\x19\x34\x9c\x4d\xd1\x40\xe7\x2c\xd1\x6e\xf5\x1c\xcc\xae\x55\x7c\xf8\x4d\xf9\x41\x5b\x37\x09\xdc\x9f\xdd\xed\xd4\xa6\xa0\x96\x63\xf9\xf2\x2d\x45\x43\x36\xe6\xd5\x57\x37\x09\xf6\xe1\x54\x53\x7d\x44\x50\x9e\x7c\x4b\xd5\x90\x18\xa9\x28\x7c\x48\x64\x64\x88\xd4\xa5\xa1\x38\xdb\xee\x88\xaa\x86\x86\xea\xaa\x7a\xd9\xa6\xa1\x1a\xaa\x22\x43\x64\x65\x50\xd7\x76\xfe\x7e\xfa\x07\x31\x5f\x48\x03\x94\x55\x24\xf8\x46\xe3\xa1\xc7\xf8\x93\x80\x3f\xe1\xa1\x11\xe8\x1b\x2d\x0f\x52\x57\x91\x31\x6f\xa6\x2e\x9c\xa0\x55\x9f\x81\x06\xde\x73\xcc\x46\xde\x13\x41\x43\x3b\x66\x50\xbd\xc1\x0f\x3a\x60\xca\x57\xe0\xf7\x15\x4c\x81\x0e\xf0\x73\x81\xb5\x30\x45\x47\x7a\xc3\x14\x57\x1d\x79\xd2\xa6\xe7\xdb\x03\x8e\xae\x96\xba\x96\x52\xab\x03\x36\xaf\x59\x73\x64\xf3\x19\xd9\xb6\x94\x3a\x73\xe4\x68\xbb\x0c\x3b\x3c\x51\xc5\xd3\x78\x0a\x11\x93\x70\x23\xf4\x85\x45\x48\x4b\x76\x1f\xea\xcc\x91\x23\x67\xda\x03\x8e\xac\x96\xbb\x77\x50\xf1\x97\x52\x2e\xbf\xaf\x05\x15\x4e\xc3\x29\x50\x21\x11\x36\x62\x5f\x5c\x04\xb4\xd4\xed\x43\xad\x0e\x08\x58\xbd\xe6\x48\xc0\x19\xd9\xbe\x83\x2a\xd3\x17\x2c\x5b\xac\x55\x68\x28\xe0\xcf\x04\x1c\x59\x2d\xe1\x62\x0a\x8e\xa0\x27\x1e\x83\x55\xf8\x50\x50\x57\xab\xa4\x4a\xa9\xab\x96\xe4\x2d\x2d\xd2\xcb\xe8\xe5\x60\x5d\xb3\xda\xc1\x0a\x4b\x28\x3c\x02\x9e\x70\x0c\x57\xc1\x23\x41\x59\xa5\x90\x0a\xa5\xac\xba\x9a\x76\xc5\x70\x49\x86\x97\x1c\xa6\xb4\xcb\xee\x6a\x12\x5a\x81\x01\x19\xfa\xd6\x40\x6f\xc5\x17\xfa\x2c\x06\x37\xa5\x16\x7a\x4f\x04\xca\xa3\x08\xa8\x56\xe8\x13\x08\xbd\x3a\xe0\xc5\xa3\xc0\x28\x13\x80\xf6\x85\xde\xdc\x47\xe1\xf6\x05\x3a\xb7\x74\xfe\x44\xe9\x35\x98\x7b\x59\x68\x2c\x08\x0c\x9d\x8d\x82\x4a\x06\x4d\x90\xf1\x85\x2a\x12\x17\x20\xf2\xcd\x86\xc3\x99\x87\x53\x77\x47\x87\x87\x47\x84\xee\x69\x4c\x3a\x60\x38\xc0\xe0\x29\xbb\x86\xaf\x29\x3e\xd8\x70\xe1\x2a\xce\x0d\x28\x91\xa0\x0f\xfe\x4e\x66\x85\x85\x64\x87\x09\x9c\x1b\x13\x1b\x63\x4c\x49\x90\x03\x7e\xc5\x3e\x70\xf3\x5f\xda\x49\x5d\x66\xbe\xe1\x64\x7b\xc3\xfd\x9f\x71\xd3\xec\x7a\xc9\x1a\x51\xb3\x34\x5c\x1b\x13\x1b\x11\x25\x71\x1e\x7e\xd3\x70\x05\x54\x77\xca\x5c\x5f\x03\x8e\xc1\x6f\xf8\x0b\xcd\x0f\x3e\x3c\x06\xe3\x71\xeb\xba\xd8\x90\xa4\x84\x77\x56\xde\x38\x1a\x2c\x45\xd7\x47\xd6\x45\xd5\x31\x51\x51\x89\xb1\x41\x5a\xec\x05\x03\x91\x03\xe2\xd3\x1b\x17\x3b\xf3\xcd\xf9\xc6\x7c\xa9\x64\xaf\x29\xbb\x58\xce\x79\x65\x3f\x92\x40\xa5\x30\xd9\xf9\xd5\x96\x0f\xb6\x5c\xbc\xae\x7d\x7a\xe7\xf1\xe7\x97\xa5\xfd\x55\x07\x4b\x0e\x15\x37\x97\xb4\x94\xd5\xd7\x1b\x2b\x33\x2a\x12\xf7\x32\xdc\x47\xe1\xa5\x49\xc9\xb9\xd1\xc2\x70\xbc\x93\x00\x23\x8b\xcc\x15\xc5\xb9\x72\x61\x51\xad\xa5\x54\x00\x12\x8e\xec\x9a\xfa\x95\x7c\x72\x93\x69\xcc\x32\x2d\xbe\xee\x8f\x43\x91\xc0\xde\x12\xba\x0d\x46\xcd\x12\x7c\x45\xc0\xcd\x38\x13\x28\x78\x77\x92\x9c\x78\x28\xe9\x70\x8b\x96\x6b\xf4\x45\x2a\x99\xc7\xad\x30\x03\xdf\x85\xa5\x6f\x4b\xdc\x47\xe1\x21\xb7\x6e\xc7\xdf\x11\x94\xd1\x50\x00\x1f\x2a\x83\x60\x44\x18\xe8\x70\x52\x9b\xdc\x06\x14\xb0\xf0\xe0\x0f\x2d\xc7\xfa\xfd\xa8\xbf\x3b\x0c\x5f\x43\x49\xdd\x80\xbd\xfc\xa5\x67\xdb\xf1\x75\xc5\x82\x3e\x02\xe7\x9b\x89\x2e\x2b\xde\x7c\x19\x49\xe8\x83\xdf\x1c\xc7\x17\xe5\x82\x88\xb0\xfc\x30\x61\xc2\xcb\x83\x27\x04\x96\xfb\x17\x05\xcb\xc8\x6f\x5b\xf9\x06\x7a\x6a\x1d\x4d\x5a\x03\x6b\x81\x81\x35\xca\x06\x58\x03\x93\x60\xa9\x8b\x19\x96\x83\x04\x3b\x61\x0f\xf8\x5f\x81\x9d\x60\x80\xf5\x30\x1a\xf4\xae\xb6\x7a\xa5\x8e\x9f\x94\xb2\x73\xd1\x4c\x01\x5d\xa2\x80\x00\x1a\xc6\x9c\xfa\xe2\xf6\x3f\x8f\xaf\x1a\x9b\x2f\x83\x3f\x0c\x60\xa1\x0f\x68\x60\x6b\x85\xac\x64\x79\x4e\x4a\xd9\xe1\xa4\x8b\xfe\x0f\xdd\xc7\x27\x56\x8d\xcd\x93\x61\xbd\x83\xae\x77\x0f\x1d\x8c\x84\x17\x79\xac\x4e\xc4\x17\xe6\x4f\x90\x92\xa2\x22\x52\x62\x13\x99\x35\xf3\xf1\x74\x4c\x4f\x6f\xbc\x56\x71\x7a\x81\x1c\x53\x1a\x59\x90\x50\xc1\x2c\x7c\x90\x00\x0c\x54\x6b\xa1\xaa\x04\x5e\xb8\xfe\x40\x2a\x29\xaf\x2e\xdc\x57\xc2\x9c\xbe\x0e\xd7\xca\xe1\x27\x01\x7e\x82\xd3\xb1\x6b\x3f\x94\xcb\x93\xaa\x0c\x25\xb1\xcc\xf5\x71\xa5\xc8\x60\x95\x16\xf4\xb6\x2c\x5e\xa7\x10\x3a\x3b\xa1\x63\x08\xca\xdd\x0c\xe1\x76\x3d\x84\xbb\x98\x21\x1c\x7c\xff\xeb\xe7\x6a\x0f\xb7\x0f\xe2\xa1\x01\x43\x21\x14\x1b\x24\x75\xf3\x50\x56\x67\xbf\xf8\x4c\x4c\x67\xa1\x8e\x86\xe1\xe0\x8e\xee\x38\x5c\x56\x53\x9f\x89\x8a\xc6\xee\xdc\x38\x7e\x28\xdb\xed\x46\xe3\x70\x74\xa6\x48\x58\x67\xb3\x52\x43\x58\x27\x5a\x3f\x48\x54\x36\x53\xd0\x00\xa1\x10\x0a\x0d\xb2\xbb\x52\x07\xc1\x2e\x66\xf0\x7c\x02\xab\x7e\x81\x35\x4f\xbe\x7e\x02\x57\x9f\x82\x87\xab\x8e\x94\x6d\x73\xf9\x83\xd1\x95\x3b\x25\x5c\x47\xed\x8c\x8a\xda\x29\x23\x45\xef\xac\x8c\x3a\x28\xc1\x3a\xea\x60\x45\xe5\x41\x59\x4d\x44\x86\x8f\x4f\x4d\x4d\x90\xf4\x54\x7c\x6a\x7e\x99\x0c\xb1\xb4\x93\x61\x38\xb5\x33\x0a\xfe\x25\xbe\x43\xc5\xa7\xfd\x85\x8d\xaa\xdc\x29\x8d\xa4\x76\x44\xc3\xbf\x44\x3d\x95\xe0\xa4\xcd\xa6\x6f\x9e\x69\xff\x54\x02\x4f\xea\xd4\xa1\xe8\x1d\xfb\xe4\x43\xfb\x0e\x55\x9c\x12\xc0\x9b\xba\xd9\xbe\x66\xba\x8c\xd9\xb4\xf2\xe8\x31\x3f\x63\xf5\xea\xe9\x12\x2e\xa3\xd6\x05\xed\xad\x8f\x96\x71\x36\x1d\x9f\x96\x16\x2f\xe9\xa9\x84\x94\xbc\x32\x59\x79\xd5\x21\xe2\xa6\x04\xe5\xd4\xcd\x33\x0e\x9e\x57\x69\xf0\x50\x54\x1e\x34\x03\x7f\x47\x8d\xd4\x7d\x85\x42\xcd\xc0\x81\xa8\x91\xbb\xaf\xd0\xa8\xf9\x7d\x20\x68\x24\xfb\x15\x0a\x34\xbf\xff\x0e\x1a\xd9\x1d\xee\x89\xdf\xb2\xf6\x21\xca\x72\x1e\x87\x28\x67\x70\x88\x7a\x86\x54\xfa\xe2\x6d\x7e\x3c\x7c\xac\x72\xf8\x31\x69\xc6\x0e\x1a\x3e\xb7\x5b\x49\x65\x3e\x05\x9f\x77\x5b\x49\x08\xb7\x87\xf3\x30\x06\x3d\xc1\x13\xc7\x48\xdd\x7a\x0a\xc7\xa0\x27\x7a\xe2\x18\xb9\x5b\x4f\xe3\x18\xf0\x44\x4f\x18\x23\xd9\xf5\x14\x8c\x01\x4f\xf0\x84\x31\x8e\x61\x18\x0d\x77\xe1\xcf\x46\x9d\xdb\xd9\xcf\x3d\xcc\x40\x82\x17\x50\xf0\x0f\x60\x90\x7a\xb2\xa8\xd1\xce\x01\x3b\xec\x29\x0c\x02\x0a\x7a\x01\xc5\x3d\x6a\xd5\x31\x84\x8d\xe7\x1b\xa2\x6b\x42\x73\x25\x5c\x04\x9f\x93\x39\x05\xd9\xd6\x42\x6d\x63\x68\x5d\x90\x45\xc2\x4d\x60\x27\xb3\xf2\xb2\xf2\xf2\xb4\x07\x77\xd7\x05\xc6\xc4\xa7\x24\x1a\x24\x75\x00\x55\xb2\x27\xbe\x20\x46\x70\x44\xf7\xc8\x5c\xbb\x9f\xea\x43\x95\x18\x1c\x98\xc0\xdd\xa1\x3b\xd3\xb2\x52\xb3\xd2\x65\x0c\xc0\x7f\x93\x51\xc9\x09\xd1\xe1\x46\x8b\xd1\xa8\xc5\xd5\xf8\x0b\x19\x92\x1e\x15\xbe\x4b\x1b\x52\x11\x5e\x9f\x26\xc1\x46\x54\x48\x63\x9a\x29\x3d\xd5\x89\x48\x97\xe0\x1d\xfc\x86\x34\xa6\x19\x53\x53\xb5\x3b\xeb\x43\x9b\xf6\x95\x15\x14\x17\x4a\xca\x40\x2a\xa9\x70\x6f\x0a\x3c\x66\x0b\x8a\x0b\x65\x65\x10\xc5\x19\x72\x0d\x85\x65\xa9\x7b\x85\x83\x75\xf5\x4d\x79\xa6\x5c\x63\xae\x0c\xef\xc0\x77\x64\x7d\x6e\x45\x4d\x83\x36\xcf\x94\x67\xcc\x93\x60\x03\x28\x24\xf7\xa8\xb5\x3e\xb7\xb2\x66\xbf\xb6\x3b\xa8\xeb\x18\x6f\xdd\x93\x90\x1f\x2f\xc4\x27\xa4\x26\xef\x91\xb9\x4b\x06\x54\x29\xf8\x19\xfe\x24\x61\x20\x05\x3f\xe3\x9f\xa4\xce\x7e\xc5\x76\x91\x87\xe5\xf0\x6d\xa1\xa5\x30\xdb\x9a\xe7\x0d\x8b\x70\x39\x89\xcf\x68\xce\xe6\x87\x8b\x71\x75\x7a\x56\x7a\x76\xba\xc5\x1b\x37\x83\x4a\x66\xe5\x9a\x73\x73\xb5\xb9\xe6\x1c\x53\x8e\x64\xeb\xb6\xd5\xf1\x7b\x0a\x4b\xd2\xca\x84\xb2\x92\xbc\xc2\x42\x19\x0e\x51\xea\x79\x5c\x83\x4b\x61\x0d\x69\xbf\xa3\xc3\xe9\xfc\x14\xaa\xfc\x5e\xc7\x2c\x63\xa6\x31\xc3\x94\xe1\xdd\xdf\x53\xdd\x44\xcd\xef\x80\xb3\x70\x0d\x72\xb1\x82\xc4\x5e\x6a\x10\x9f\x6e\xca\x30\x66\x18\xf1\x11\x3c\xf6\x52\xa6\x50\x73\xf1\x43\xb2\x7b\x82\x3f\x9f\x96\x97\x9a\x93\x9c\x9d\x91\xe7\x05\xdf\x28\x2f\xd0\xe8\xb0\x32\x50\xd1\xf0\xb0\x9b\x86\xd1\x30\x11\xae\xe3\x67\xf3\xe6\x90\xea\x0f\x9e\xa6\x1c\x63\x8e\x31\x07\x26\xc1\x0c\x2f\x5c\x42\xe3\x78\xdb\x47\x3c\x8c\x7f\x9f\xc4\x6a\x1a\xa7\xc0\x0c\x32\xb7\x20\xbb\xb0\xc8\x79\xd3\x8e\xdb\x4c\xc0\xf2\x4f\x79\x88\xba\x0f\x61\x68\xc0\x73\xf8\x31\x8e\x84\xd1\x64\x8e\x82\x3c\xb7\xa1\x35\xc7\x92\x6d\xc9\xb6\xc0\x32\x5c\xeb\x85\x1b\xa6\x92\x50\x4e\xdb\xb9\x2a\x5e\x9d\xa4\xbe\x83\xdb\x21\xc2\xe6\x02\xe1\xa4\xfa\x8a\x6a\xe0\xe1\x43\xfc\x02\xcf\xe2\x35\xec\x80\x5b\x64\x40\x36\x8f\x3a\x1c\x48\x42\x2b\xad\xc4\xaa\x59\xfc\x09\x7f\x72\x2c\xa5\xb8\x2b\x3a\x5e\xe9\xa5\xfc\x83\x34\x5b\x4c\x66\x29\x3b\x1d\xbd\xba\xdc\xc8\x3f\x6c\x32\xaf\x12\xaa\x3b\x7e\x08\x5f\x28\x73\x94\x4d\x0e\xab\x73\x4d\xde\x10\xa8\xf6\x26\x4d\x66\xb3\x49\x6b\xc8\xde\x93\x9b\x22\xe9\x50\x0f\x7d\x79\x1c\xb7\x18\xc6\xc1\x61\x52\x87\xbb\xdc\xb0\x85\xc6\x71\xd0\x42\xea\xdc\x1e\x7a\xde\xa7\xd0\x13\xa3\x48\x78\x0b\xce\xf1\xe9\xc6\x74\x63\x7a\xe6\x5b\xf7\xbd\x80\x57\x14\x98\x82\x67\x49\x53\xba\x31\x3d\x4d\x9b\x6e\xc9\xb0\xa4\x4b\xee\x20\xb3\x3a\xb7\x4f\x60\xba\xab\xed\x17\xb7\xae\x26\x1a\xa7\x81\x84\x43\x61\xba\x64\xab\xa2\x60\x3a\x48\x30\x14\xa6\xc9\x3a\xf2\x3c\x8d\xcf\xd1\x4e\x76\xc5\x52\x38\x1d\x25\x1c\x86\x53\x65\x9d\xdb\x27\x5d\xe9\x7c\x57\x11\xb5\x70\xd5\x85\x0f\x64\xc5\x40\x7f\x70\xf6\xfc\x07\x92\x12\x4d\x7d\x70\x76\xc5\x42\x59\x9d\x4c\xbb\x17\x45\x7e\xcb\xda\x27\xea\xc8\x1d\x7c\xb1\x7e\x69\xfe\x52\x41\x7d\x13\x7f\xc6\xc7\xea\x9b\x8b\xf3\x17\x97\x2c\x91\x61\x8c\x32\x09\x1e\xc1\xf7\xca\x9b\xf0\x06\x03\xd5\xf8\x22\xaf\x16\xe2\x2b\xea\x20\x75\x28\x0e\x53\x8b\x4e\x2c\xb8\xf8\xce\xfb\x6b\x61\xa8\xb2\x57\x19\xa6\x8c\x50\xca\x60\xc4\x9a\x6b\xfa\x0b\x0b\x4e\x30\x5d\xbb\x75\xf6\x0f\xf9\xeb\xbb\x6f\xc4\x7e\x9c\x0c\xaf\x2b\x02\x7c\x08\x37\x14\x2d\xf8\x26\x7f\x1c\xf3\x51\xc8\x75\x35\x08\x47\xab\x8c\xca\xe2\xab\xea\x2e\xc6\x7e\x7e\x09\xbf\x13\xfa\x05\x40\xdf\x75\xd0\xe7\xc2\xa3\xc3\x4f\x4a\x9f\x61\x1d\x0e\xc1\x08\x8c\xc4\x97\xb1\xfe\xb7\xb2\xa7\xad\xdf\x5c\x82\xde\xeb\xe0\x1f\x01\xd0\x77\x27\xd3\x33\x94\x8d\x8b\x07\xd1\x1e\x00\xa2\x87\x59\xc7\x10\x5c\x88\x8e\x0e\xd0\xb9\x45\xf3\x5f\xe2\x40\x9c\x76\x1a\x27\x08\x28\xa0\xbc\x6b\x32\x92\xf2\x5d\x24\x51\xde\x8f\x82\x80\x13\x70\xda\xda\x89\x38\x50\xe6\x5a\x71\x94\x0e\x19\x32\x97\xfa\xf6\x7e\x55\xcb\x97\x32\x17\x72\x05\xfa\x81\x67\x33\x48\x02\x0c\x80\x97\xd6\xbc\xfc\xab\xfc\xeb\xaf\xf0\x52\x3b\x0c\x10\x40\x02\xcf\xed\x4b\xa1\x9f\xcc\xb5\x06\x7c\xf5\x45\xf4\x8f\x02\x17\xd2\x25\xc1\x11\x1e\x45\xec\xb3\x6d\x1a\x32\x72\x27\x32\xd8\xe7\x30\x8a\x02\x2e\x45\xcf\x15\xd3\xd1\x4f\xe6\x5a\xa1\xaf\x3d\x8f\x3c\x0f\x6e\xe0\xdd\x00\xff\x10\xc0\x07\x5e\xf2\x1f\xfe\x9b\xfc\xcb\x6f\xf0\xd2\x49\xf0\x11\xe0\x1f\xe0\x1d\xb2\x02\xdc\x64\xe8\xdb\x9d\x47\xde\x44\x3f\xf4\x3c\x8f\x4b\x05\x2e\xe4\x58\x33\xbf\xc9\x82\x5e\xd9\xc8\x6f\x43\x72\x86\xf7\xa7\x48\x22\x7f\x10\xbd\x04\x9c\x88\xde\x9b\x17\xe0\x08\x19\x28\xfb\x54\xf2\xc4\xef\xd0\xbb\x06\xdc\x04\x18\x0e\x2f\xae\xf6\x79\x2e\xff\xfa\x1b\x50\x67\x61\x50\xb6\xa3\x54\x5e\x83\x8d\x3a\xb7\x1f\xa3\x5c\x60\x37\x6c\x81\xb5\xdf\xff\xf5\x7d\x07\x0a\x5c\x75\xe4\x97\x30\x81\x0f\x09\x0f\x0f\x91\x5e\xa5\x42\xc2\x6b\x1a\x64\xdb\x6e\x7a\x7f\x4d\x4d\x83\xf4\x23\xd5\x50\x13\xbe\x4b\xc6\xd6\xae\xdd\x30\x57\x54\xf6\xc3\x42\x16\x4f\xa9\xfb\x1d\xf0\xd4\x1e\x78\x2a\xcc\x15\xa1\x1b\x16\xb2\x3a\x32\x13\x03\x79\x98\x8f\x1c\x8c\xc5\xd9\x27\xa5\xc2\x63\x39\x6d\x6d\x5a\xb8\x84\x26\x30\xe1\x25\xcc\xc5\x10\x9c\x8a\x99\x8b\xa4\x13\x2b\xe7\xd5\xce\x11\x70\x04\xfe\x03\xff\x81\x23\xc2\xb2\x43\xf3\xc3\x64\xf4\x99\xf3\x1a\x0e\xc0\x51\x5a\x0c\x85\x39\x38\x1b\x76\x4b\x3a\xb7\x2f\x29\xd8\x0d\x73\x60\x36\x84\xca\xee\x99\x91\x90\x0f\xf4\x9b\x30\x74\x1b\xd0\xbb\x7f\xd8\x01\x74\xc4\x97\xbb\x81\xde\x0e\xba\x99\x40\x83\x5b\xcb\xb9\x67\xc0\xb6\xb4\x3f\xf3\x30\x3f\x3b\xd9\xba\x15\xa8\x76\xa0\xeb\x61\x28\x72\x40\xb7\x03\x35\x0e\xd6\xce\x04\xaa\x06\x06\x61\x6f\x47\xdc\x81\xda\xda\x7a\xf2\x19\xd7\x74\x61\xd8\x8a\xc5\xac\x9b\xce\x9e\x4b\xdb\x2c\xf8\xbd\xad\x1c\xbe\x27\x75\x64\x08\x3d\x44\x67\xff\x94\xef\x1a\x87\xed\x5d\xc3\xa0\x9d\xb4\x8f\xd1\x91\xe3\xe9\x67\x6e\x3a\xfb\x07\xb0\x56\x47\x8e\xa7\x74\xe8\xad\x66\xf0\xf0\x6f\x71\x87\x1b\x37\xdc\x30\x98\x70\x42\xff\xe3\xc2\x7d\x36\x95\x20\xea\x77\xf1\xcf\xd7\x96\x1d\x1a\xd0\x4e\x42\x9f\x91\x0e\xb0\x79\xc0\x69\x12\x7a\xff\x17\xd8\xe7\x55\xfe\xf7\x35\x65\xcd\x03\x4f\x93\x30\x69\x2d\x5f\xb6\xfd\x79\x7b\xfc\x21\xb2\xb1\xd4\x01\x9d\x8e\x6f\x26\x9b\xfe\x03\x35\x96\xf0\x65\x3b\x9c\x50\x77\xb3\xce\x6d\x0f\x28\x22\x8c\x6d\x79\x4f\x84\xb1\x70\x57\xe4\x08\xe6\xde\x43\x67\x54\x87\x33\xf1\x0a\x7f\xb7\x05\x69\xa4\x5b\x29\x48\x05\xda\x41\xd2\xc2\x23\x45\x71\xef\x6c\x58\xf5\xc9\x56\xa0\x68\xd0\x88\x8e\x6f\xbf\x49\x7c\x2b\x44\x8b\x5b\xef\x52\x18\x05\x47\x44\xdc\xfb\x7f\x5e\xd4\x1f\xde\xe4\x61\x2a\xf8\x80\x0f\x4c\x05\x3f\xf4\x81\xfe\x38\x15\xfd\xb0\x3f\xf6\x47\x3f\x9c\x0a\xfd\xd1\x07\xfc\x64\x9c\xa0\xf4\xe3\xbf\xfe\xb5\xfa\x93\xab\xc7\xa3\x22\x2f\x48\x41\x4b\xc8\x4c\xaa\x39\x62\x7e\xd1\x16\x21\x70\x7a\xda\x3a\x79\x2a\x54\x83\x0b\x4e\xd0\xfa\x22\x11\x35\x7b\xc1\xaa\xc2\x83\x2b\xa4\xa6\x0f\xc9\x6c\x6a\x43\xd5\xb5\xe4\xe3\x42\xe3\xfd\x9c\x53\xf2\xb7\x58\x81\xae\xf0\x8a\x73\xf2\xd9\x5f\x47\x69\x5d\xcc\x70\x5b\x47\xc6\xc3\x6d\x57\xdb\xef\x8a\x85\xc7\x61\xd8\x07\xfb\xe0\x70\x47\x08\x7d\x60\x18\x0c\x87\xff\x84\x0e\xbc\x64\xfb\xdd\xc2\xe3\x70\x27\xd1\x30\x47\x08\x7d\x60\x38\x0c\x83\xff\x84\x0e\xbc\x04\xb7\x6d\xe7\xf8\xf7\x57\x9f\x59\x24\xa9\x6f\x53\x8b\x57\xad\x5e\x2c\xe3\x1b\x5d\xe9\xf0\x06\xfd\xfe\xaa\x33\x8b\x1d\xb8\x45\xab\x57\x2f\x96\x75\xf6\xb3\xf4\xe2\x33\xab\xaf\x49\x3a\x7a\x28\x75\xed\xcc\x99\xf7\x1d\xb3\x8a\x63\xd0\x1b\x7b\xc3\xab\xca\x32\x20\xbe\x83\x01\xf0\xda\xef\x1e\x66\xf0\xd3\x91\x9e\xcf\xe1\x32\x4c\xe4\x92\x74\x64\x91\x7d\x01\x6f\xa6\x4d\x16\x8b\xc9\xac\x85\x12\x5c\xcf\x07\x6c\x4e\xdf\x13\x20\x67\x57\x5b\xaa\xab\xb5\x90\x8f\xcb\x60\x11\xe6\xa3\x3b\x7a\xac\x1e\x35\x51\x4a\x4a\x4c\x8c\x8f\xd1\x46\xed\x8d\xab\x94\xf6\x3f\x02\x16\xde\x12\x60\x2b\x8c\xc3\x57\x71\xbb\xbc\x29\x76\xf3\x16\x6d\x48\x6d\x78\x83\x74\xe4\x72\xeb\x65\x01\x3c\x9e\x8c\x40\x0e\xc5\x97\x7d\x51\x2b\xab\x4b\xf1\x45\xdb\x7e\xf5\x3b\x81\xbb\x80\xf5\x18\x88\xeb\x70\x3f\xee\x87\x48\x5c\x02\x95\x30\x0d\x96\xde\x07\x0a\x5e\x92\xf7\xed\x3d\xde\x52\xa7\xad\x88\xdb\x1b\x1d\xbd\x75\x73\x62\x8c\x34\x09\x7b\xe1\xa8\xa5\xa8\x13\x70\x13\xfa\x02\x0f\x3b\x64\x2e\x09\x36\xc1\x10\xe0\x61\x9d\xa4\x54\x3c\xe9\x3a\xa6\xec\x17\x60\x33\x4c\x82\x51\xb0\x15\x56\xe1\x78\x18\x8c\xcb\x65\x77\xf0\x12\x75\x6e\x17\x6d\x9d\xfc\x3d\x11\x35\x14\x6c\x16\x15\x17\x96\xae\x61\xb9\x15\x3f\x88\xce\x13\x47\xd2\x44\x09\x35\x30\x44\x0c\xde\x26\xab\x9d\xeb\x45\xf0\x12\x8d\xa2\xad\x93\x8f\x4d\x8d\x4b\x4a\x92\xd0\x8a\x56\x32\x29\x29\x0e\x0e\x88\x4a\x3f\x91\x4c\x2a\x4e\xdd\x5b\xae\xf5\x13\xcb\xf7\xa6\x26\x15\x4b\xdc\x0a\x18\x82\x2f\x93\x70\x9a\x76\xc8\x38\x4d\xc3\x10\x78\x59\xf1\x10\xf3\xcb\x05\x98\x2d\xca\x5d\x9a\xf5\x22\x34\xda\xac\x60\x10\x75\x0c\xe1\x0a\xdb\x6c\x56\x1e\xee\x50\x70\xb1\x6b\x24\x09\x4b\x7c\x78\xfc\x97\xad\x84\xb4\x2d\xa4\xba\xee\x80\x86\xc7\xa7\x14\xb4\x29\x1a\x12\xca\x28\x65\xa7\x0e\xb7\xf2\x70\xd1\x36\x92\x84\x3b\x94\x0e\x93\x40\xc3\xc3\x7a\x47\x5a\x03\x05\xeb\x55\x0d\x09\x83\x3d\x71\x7d\x0f\x2d\xb4\xa9\x1a\xd2\xb9\x17\x72\x79\x52\xb4\x35\x4a\xd0\xa1\x81\x8a\x8a\x4e\x8e\x4d\x92\x55\x8d\x6a\x8d\x0e\xcb\xda\x56\x15\xee\x6d\xd7\x77\x5b\xc9\xc4\xe2\xf2\xd4\x7d\xc2\xbe\xf2\xfc\x92\x62\xd9\xae\xb7\x5b\xab\x6a\xb2\x0e\x47\xd7\x7a\xf7\x9c\xd0\xe2\x82\x2e\x30\x24\x00\x86\xa0\x0b\xb8\x98\x1d\x5f\x27\x04\x19\xac\x19\x34\x1e\x70\xc6\x11\xdc\x15\xcd\xa0\xe1\x4c\x57\xb8\xfc\x2b\x3a\x9a\x8b\xe6\xb9\x01\x57\xc6\x8f\x1f\xff\x60\x8f\xe8\xfd\xff\x23\xe0\xf2\x9d\xc4\xa3\x47\x2b\x2e\x6c\x5d\xe8\x31\x73\x5d\x9d\x77\xbb\x48\x72\x73\xaf\x3c\x18\x4f\x82\xc4\x72\xf9\x57\x1e\x3c\x78\x30\xfe\xbb\xef\x82\x44\x07\xb1\x79\xba\xce\x76\xef\x08\xdf\x2e\xf6\xa4\xfe\xb7\xa4\xf1\x13\xc6\xdf\xdf\x23\x7a\x47\xc7\x38\xca\x1c\xb6\xc0\xc7\x35\x87\xe3\xce\x6c\x2a\xf5\xc6\x19\x57\x49\xb8\x40\x73\xe6\xd9\xa8\xa1\x38\xd3\x29\xd0\x64\xb2\x68\xed\x79\x6e\xdc\x3c\x08\x35\x34\x97\x36\x1d\x35\x78\x81\xc2\x19\x4b\x36\x25\xc4\xad\xae\xd9\xe6\x0d\x5b\xf0\x63\x12\x4f\xd3\xf3\xe6\x39\x45\x72\xa6\x2b\x0e\xe1\x4e\x0b\x49\xce\x3c\xbd\xc7\x4a\x46\x19\xa2\x73\x0b\xe2\x39\xf3\x20\x70\xc8\x3d\x00\x1a\xc5\xda\xa3\x85\xe6\xcc\xd3\x15\x17\x96\x52\x35\xa0\x51\x35\xa8\x21\xdd\x83\x44\x17\xe8\x7c\xa2\xdc\xfc\xc9\x55\xe9\xf4\x44\x0d\xbc\xc5\xce\x7b\x8c\x1a\x12\x7c\x55\x3d\x3f\x42\xd1\x3f\x76\xb4\xb5\x0e\xf2\xa0\x42\xf1\xa6\x64\x53\xb2\x31\x39\x2d\x25\x3d\x3b\x23\x89\x99\xbe\x3b\x49\x3f\x1a\xf9\x16\x78\x71\x83\x90\x44\x6d\x68\xc1\x17\x91\x17\x46\x27\x5d\xba\xb9\x5b\xce\x28\x4e\xcf\x4c\x2b\x30\x5a\x4d\x56\x93\xd5\xb9\x4d\x6c\x16\x93\x6f\xbd\x65\x29\x13\xae\xbc\x97\x62\xb8\x2c\xe7\x1b\xf3\xcd\xf9\xf9\xf9\xe6\xfc\xde\x83\x8a\x2e\xbf\x57\x70\x45\x28\xbb\x65\x4a\xb5\xca\x59\x46\x8b\xd1\x62\x64\x14\xdf\x6e\x57\x1e\x66\x06\x42\x35\xce\xfa\x51\xba\x0f\x11\x24\xee\xa0\xf6\x5d\xc8\x7f\x2f\xfd\x3d\xe6\x68\x01\x8c\x3a\x78\x59\xfb\x3e\xbe\x75\x70\x53\x81\x14\x79\x7b\x25\x50\x2b\xde\x67\x6a\xa2\x42\x4b\x03\x17\xad\x5e\xb0\x68\xd1\xea\xeb\x8b\x84\xc0\xd0\x84\xf0\x28\x79\xc5\xe2\x95\x48\x45\xfa\x31\x9b\x52\xf0\xad\x9d\x8b\xb5\xcb\x60\xd4\xce\xa3\x29\x92\x69\x8f\xc9\x60\xd0\xfa\x17\xac\x2f\xdd\x28\xe1\x0e\xea\x3b\x0c\x21\x71\xe1\xe8\x9d\xd8\x80\x73\x20\x5e\xec\x59\xf8\x43\x0e\xb8\xc7\xec\x51\x11\x35\xe0\x23\xf6\x2c\xfe\xed\x37\x70\x3b\x0d\x3a\xa6\x4b\xc9\xe4\x23\xe0\x1d\x1c\x06\xbe\xb8\xec\xf0\x90\x8a\x91\x71\x13\x37\x23\x0d\x7e\x5e\x30\x0b\x2e\xb3\x2f\x53\xb1\xb1\xa9\x49\x49\x32\x52\x48\x91\xdc\x7e\xc3\x8c\xe7\x7f\xaf\xd4\xe5\x51\x81\x41\x11\x81\xe9\xf2\xa6\xd4\xa6\x6d\x47\x85\xbf\xd6\xec\x90\xa6\x54\x2b\xc5\x1d\x33\xb4\xac\x45\xea\x07\x0c\x17\x50\x43\xed\x61\x3b\x28\xf0\xf8\x75\xe3\xcc\xcf\xe5\xb0\x75\x64\xf9\xea\x15\x85\xcb\x85\xff\xb9\x7c\xf7\x89\x19\xac\x54\xcb\xfe\xc6\x16\x98\xfe\x05\x8c\x06\x8f\xe7\xf2\x4d\x1f\x92\xdb\x6a\x18\x3c\x6a\x11\x8a\x7b\xf1\x15\x86\xdb\x69\xa8\xc6\x1d\x30\x13\xa7\xc0\x8e\x04\x86\xdb\x6f\x80\x83\x31\x10\x03\x86\x9d\xd0\xcc\xe8\x94\xcb\x2a\xc3\xff\xd7\xfa\xe5\xc1\xc6\xf4\x94\x03\x32\x0e\xc1\x46\x43\x94\x25\xac\x28\xda\x3b\xba\xb8\x2a\xa9\x5a\x80\x8f\x29\x85\x62\xc3\x45\xcf\xbf\x28\x9d\x0b\x93\x32\x98\x45\x18\x27\xc2\x3b\xac\xec\x0e\xa3\x59\x17\x33\x68\x5c\xc3\x45\x4f\xd0\xa1\x7f\x07\xbe\x75\x40\xda\x96\xb7\x23\x3c\x6d\x5b\xda\xb6\x9a\x1d\x87\xd3\x60\xe3\xd6\xab\xcb\xb2\xf7\x30\x5b\xf7\xa0\xfe\x55\x95\x15\x54\x16\xf5\x3f\x36\xef\x91\xb3\x8b\xaf\x5e\x86\x8d\x2d\x87\xf3\x6a\x0e\xa5\x1d\x4e\x3b\xbc\xa3\x66\x5b\x1a\x83\x6f\x05\xa3\xff\x3c\xd4\x69\x71\xba\xe2\xf2\x26\xfc\x00\x3f\x28\x2e\x5f\xc0\x74\x49\xd5\xd8\x35\x3c\x9c\x64\x55\x0d\xb5\x4d\x94\x55\xcd\x28\xb1\x43\xd5\xc0\xfb\xa2\xa2\xe9\xa0\x7d\xc5\x11\x36\x6b\x3c\xeb\x5e\xb5\x4a\xd4\xd1\x84\xab\x51\x54\xac\x7c\x58\x44\x69\x95\x41\x5e\x06\x6e\xf8\xb2\x1a\x43\x86\xa4\x84\x46\xef\x12\x60\x1b\x1b\x1c\x5a\xd1\x90\x22\xe1\x52\xdb\xa8\x19\xd8\x4c\xee\x4a\xdd\x1d\x15\x2c\xa8\x24\x55\x94\x54\x90\x9a\x65\xb2\xb9\xa9\x4f\xbd\x92\x8a\xf7\xa6\xed\x15\xf6\xee\xcd\x2b\x2e\x96\x6d\xae\xca\x2f\x59\x59\x05\xf9\xc5\x25\xde\xb0\x49\xf1\xe3\x0f\xb3\x48\x9f\x1b\x70\xf1\x4d\x59\x79\x93\x02\x46\xd9\x4c\xee\xcf\xaf\xab\x3c\x20\x34\xd6\x45\x87\x14\xc8\xb0\xa2\x6b\x1a\xf0\xca\xb4\xfc\xfa\xea\xf2\x86\x6c\xef\xba\xac\xfa\x84\xa2\x70\x70\xc5\xdd\x5e\x0a\x49\x5d\xfc\xe2\xdc\x73\xa0\xb5\xee\x6a\x52\xcf\x0a\xb2\xc6\x45\xb1\x42\x14\x9b\xce\xda\xf5\x3c\xfc\x88\xed\x50\x8b\xbf\x6e\x96\xb0\x26\x08\x03\x31\x2c\x02\xeb\x42\xf1\x53\x88\xc7\x6a\xb8\xbc\x83\xc1\x12\x0c\xdf\xc5\x42\x38\x86\x53\x29\x2c\x84\x43\x38\x3d\x5d\xc4\x70\x28\xa1\x3a\xc5\x6e\xab\xe7\x0c\x76\x35\x0b\xcb\x44\xc9\xfd\xb2\xa8\x7a\xa8\x1e\xe4\xbd\x61\xd8\xaf\x1d\x75\xc2\x4d\x11\x74\x6b\xa0\xdf\xa4\x27\xb2\xe2\xa1\x70\x24\x96\x4d\x67\x15\xdf\x68\xb6\x5b\xa3\xb3\x1b\x46\xb1\x6a\x52\x90\x98\xce\x82\xc6\xc5\xdc\xca\x6a\xc6\xdb\x6e\xea\xdc\xae\xf0\xcf\x3f\xb8\xff\xb8\x0d\x18\xa6\xaa\x20\xae\x3a\x42\x58\x48\x45\x1a\x52\x92\xd2\x65\x94\x97\xa0\x38\x1c\x5f\x17\xf0\x75\x14\x7f\x01\x79\x89\x5c\x9c\x6e\x28\x48\x14\x66\x52\x11\x71\x11\x91\x05\x72\x1b\x32\xf7\x47\x3c\x5f\xc8\xe0\xd2\x91\xe8\x85\x2b\x30\x52\x0b\xd3\xd9\x75\x2c\x78\x51\x9d\x22\x44\xa2\x17\xac\xc0\xa5\x3f\x49\x98\xdf\xbd\x62\x14\xeb\xd4\xa9\xb2\x8a\x15\xf2\x58\x57\xbb\x55\x47\x3e\xfc\x5a\x44\xea\x7b\x1c\x7e\x0e\xc7\x46\x7b\x63\x4d\xa0\x23\xf3\x91\x8e\xcc\x7f\x02\x09\x58\x0d\x97\x76\x30\x2b\xc4\x2a\x27\xd7\x04\x56\xd1\x80\x46\xd1\x80\x55\x74\xb2\x91\x77\x87\x61\xbf\x33\x8e\x11\x54\x87\xfd\x56\x4f\x1e\x26\x2f\xbd\xfc\xdd\xd3\xe2\x12\x53\x55\x62\x91\xf7\xea\x93\x89\x45\x51\xa6\xa4\x44\xef\x37\x46\xf6\xff\x93\x04\xef\xed\x22\xb6\xbd\xc1\x62\xdb\x74\x16\xb4\x34\xb8\xa2\xdb\x00\xa4\x93\x12\x2d\x91\x25\x06\xef\x33\xfe\x25\x86\x4a\x4b\x71\x89\xf7\xaf\xe0\x7a\x61\x39\x39\x79\xd8\x6a\xec\x87\x3a\x47\x16\x56\x88\x55\x66\xd0\xe8\xdc\xae\x45\x7d\x0e\x1a\x0f\xc5\x0a\x1b\x44\xee\x37\x1d\xd5\x6d\x4f\xe1\x23\x60\x3f\xee\x86\x08\x6c\xa8\x47\x9f\x52\x7c\x69\x4b\xff\xe9\xfd\x6f\xe2\x4b\xad\xe8\x93\x80\x0d\xbb\x71\x37\x46\x44\xe0\xfe\xff\x77\xfd\x29\x56\x0c\x9f\xfe\x3f\xea\x11\x2e\x1f\x82\x78\xa8\x0e\x85\x4f\x99\x6e\x0f\x54\x61\xac\xc8\xfd\x8c\xee\xab\xb0\xd7\xa4\x89\x12\x76\xa2\xc0\x73\xbf\xc1\x32\x51\xe6\x7e\x81\x06\xf6\xb3\xc8\xad\x37\xe0\x37\xf1\x2a\x8a\x8f\x07\x49\x5b\xe7\x4e\x8d\x9c\x24\x28\x9d\xaa\x86\x57\xad\x50\x42\xfd\x54\xf8\x75\xf3\xed\x73\xb7\x57\x7e\xbd\xfd\xa7\x3d\x4c\x07\xf4\xe5\x27\x4d\xad\x6a\x99\x2b\x73\xbf\x3d\xfe\xed\x2a\x5c\x14\x6f\x7c\x06\xab\x44\x18\x86\x05\xc0\x39\xea\xbe\xe7\x55\x29\x8d\x87\x05\x38\x45\x03\x79\x3d\x1b\xcf\x69\x40\xc3\x7d\x75\x71\x31\x6b\x7f\xfe\xb5\xf8\xda\x2d\x24\x4f\x63\xdf\x3c\xef\x88\xeb\x81\x57\x36\x9d\x83\x7c\x28\xf0\x82\x7e\xec\x53\x96\xe4\x2e\x5c\x44\xda\x59\x6f\x6f\x44\x63\x7d\x20\x06\x61\x74\x0c\x36\x44\xe2\x5d\xc8\xc2\x3a\xf8\x24\xee\x6b\xcc\x82\x3c\x9c\x02\x47\x8f\x41\x66\x33\xac\x82\x65\xc7\x21\x03\xfa\x8b\xdc\x57\x17\xbf\x64\x55\xab\xea\xcb\x3b\x04\x84\xe3\x04\x5c\x80\x3b\x77\x48\xc6\x0a\x63\x45\xa5\x16\xc2\x61\x02\x2c\x80\x9d\x87\xa4\xac\xe8\xac\xe8\x28\x2d\xf7\xd5\xc5\x6e\x8d\x67\xae\x08\xc5\x2c\xcc\x85\xd1\xe8\x82\xa3\x3f\x95\xb0\x7a\x15\xae\xc7\x24\x3c\xac\x8d\xb2\x44\x65\x45\x4b\x18\xdc\x88\x93\x61\x11\x44\x6a\xed\xfa\xae\x4e\x1e\xe7\xe2\x68\x70\x81\xd1\x33\x64\xa8\x3e\x0b\xeb\x21\x09\x0e\x6b\x2b\x4d\x95\xc6\x0a\x09\x82\x83\x60\x32\x2e\xc2\x48\xed\x6a\x56\x72\x87\xc6\x20\x11\x78\xe0\xb0\x2f\xf4\xb5\x6b\x80\x03\x1e\x7c\xc4\xe5\x62\xcf\x5d\x9e\xef\x9d\x25\xc1\x3d\x78\x78\xec\x7f\x37\x35\x16\x7b\x6d\x5d\x38\x4a\x46\xea\x0e\x0e\x6c\xc5\x91\xe1\x68\x09\xc0\x55\xb8\x66\x3b\x66\xad\xc1\xaf\x20\x05\xdb\xe0\xe3\x6d\xcc\x3a\x96\xe2\xce\x3f\x04\x2f\xfa\xa7\xc2\xaf\x0f\xdd\x3e\xc7\x70\x0f\x1e\x02\x35\x05\x06\x6e\x81\x57\x6a\x20\xad\x05\xde\x75\x94\x46\x6a\x23\xbc\xbd\x0a\xc6\x0d\x83\x7f\xfc\x5d\xaa\xdc\xb9\x87\x5d\xd6\xee\x27\x30\x56\xfc\xbb\xea\xbb\xac\xf0\x11\x0f\x0d\xec\xed\xc8\xad\x1d\xf0\x9b\xf8\x3e\x8a\x3f\x0f\x92\xb6\xce\xf3\x8b\x9c\x24\x38\x9b\xc3\x83\x87\xf6\x4e\x55\xcf\x4f\xf2\xab\x6a\x99\x27\xff\xfc\xdb\xfb\x70\x51\xec\xb8\x0d\xab\xc4\xcb\x22\x6e\xc7\xed\xf0\x8b\x08\x03\x59\xf0\x43\xbf\xc9\x93\xff\x2f\x4e\xe1\xee\x3d\xf0\xc1\xfe\xd0\x28\x16\x17\x9b\x2b\x93\x4a\xbc\xd1\xf1\x67\x62\x3b\xec\xf8\x3f\x1d\x45\x26\xeb\x74\x14\x4e\x77\x65\xd3\xd8\xfb\xf2\xe0\x05\xbe\x8e\xa6\xeb\x0b\x13\xa8\x1f\x46\xfd\x37\x11\xeb\x60\xed\x1e\xd1\x1b\xd7\xe1\x5a\x28\x11\x7f\xf8\x81\xc4\x09\xe8\xbb\x8b\x05\x5f\xf4\xa2\xf0\xf2\x0e\x8c\xc7\xea\x3a\xfc\xb4\x1a\xeb\x20\x10\xc3\xa0\x26\x88\x81\x5f\x37\x43\x3b\xd4\xc2\x8f\x5a\x38\x8b\xe1\x90\x89\x6d\x07\xa5\x79\xdd\xb9\xa3\x9c\x7b\x27\x3b\xfa\xfa\x23\x56\x47\x07\xd9\x5c\x78\x6c\x87\xf6\x9e\xb7\xa8\xbd\xd7\xad\x83\x1f\x45\x6f\x58\x80\x0b\x48\x6c\x87\x70\x58\x20\x62\x38\x7a\xd1\x3b\xe0\x32\x56\x43\x3c\x7e\x1a\x8a\x75\x11\x18\x86\x81\x41\x58\xc3\xe0\xaf\x9b\xa1\x16\xdb\xe1\x47\x01\xce\x42\x26\x84\x43\xdb\x41\x19\xbc\xfe\x76\xa3\xed\x34\x2e\xc0\x05\x0e\x69\xa7\xd6\x15\x27\x56\x99\x1d\x3e\xbe\x1d\xda\x61\x8c\xe8\xad\xb3\xdf\x52\xf7\x38\xf2\xae\x23\x0d\x7f\xf9\xc8\x10\x87\xa7\x06\x33\x0b\xd3\x59\x55\x99\xce\x2a\x0a\xdd\x29\xaa\x9d\xaa\xde\x41\x65\x86\x2b\xa2\xab\xdd\xaa\x74\xf2\xab\x59\x74\xde\x9e\x03\xf3\x0c\x56\x02\x8d\x27\x38\x0f\x56\xc7\x9b\x37\x45\xc9\xbd\xca\xbd\xca\xdd\xb6\x08\x4a\x20\x08\xe2\x5d\x74\x64\x3f\x48\x71\xd5\x91\x07\x61\x38\xab\xb3\x37\x51\x6b\x02\x02\xd6\xc8\x3a\x7b\x13\xbd\xe6\x48\x40\xbb\x64\x0b\xbb\xcc\x2a\x02\xd5\x7e\xe4\x48\xbb\xac\x23\x97\xd3\xed\x01\x47\xd6\x48\xee\x6a\x12\x3c\x82\x09\xb6\x7f\x3b\xef\x7c\x2f\xb0\xfd\x0e\xf1\xae\xf6\x29\x6e\xf8\xd2\x05\x5c\x06\x03\xd7\x4b\xa6\xdc\x7c\x63\xae\x70\xa8\xe2\x87\x7a\xb9\x69\xd2\x47\xc0\x6b\xa1\x0a\xd6\xc3\x52\x28\x87\x28\x98\x84\x3c\xee\xc1\x19\xd3\xf1\x21\xc6\x8e\x9f\x7e\xed\x91\x04\x1e\xdf\x80\x3b\x78\x6a\xef\xad\xeb\x18\x87\xd4\x0c\xd4\xbc\xbc\x2c\x7f\x41\xdd\x0a\x69\x2d\xae\x1a\x89\x67\x70\xbd\x76\xbe\x75\x41\xde\x7c\xc9\xba\xa7\x34\x17\x26\x41\x6c\xda\xa9\x3b\xf0\x9e\xf7\xe4\xb6\x3f\x36\x7c\x25\xc0\x9f\xf0\x3a\x3c\x81\x0e\xf8\x0a\x8f\x42\x20\x7e\x8c\x3f\xe3\xf7\x18\xad\x92\xb2\xfb\x48\xf0\x30\x44\xea\x48\x06\x3c\x3c\xf6\x83\x87\xce\xed\x47\xf0\xe0\xa2\xed\x41\xca\xfb\xfc\xee\x95\xc3\x83\x84\x94\xd4\xec\x9c\x54\x79\xd9\xfe\x55\x07\xd6\x9e\x0c\x68\xd9\xf0\x5e\x44\x3b\x93\x99\x6b\xcc\xcd\xad\xf9\xe4\xc4\x11\x6d\xe1\x0a\xd0\xa5\x96\x4b\xf5\x7b\xd2\x0b\x42\x12\x93\xb2\x93\x84\xc8\xb8\x94\x84\x78\x79\xf5\xba\xb0\x35\xc6\x39\x4c\x0a\x6d\x9a\xd9\x3c\xf3\xc8\xb2\x47\xc8\x7d\x8b\xae\x30\x70\x2e\x13\x75\xe2\xe9\x86\x33\xc2\x95\x1f\x5b\x2e\xd7\xc8\xd6\x9a\x82\xfd\x75\xda\x1c\x73\x9e\x31\x57\x2a\x4e\xc5\x71\x0f\x63\x05\xee\x14\xfa\xab\x0d\x3c\xba\x63\x9f\xd6\x8f\x07\xcb\x98\xfe\xd6\x3d\x48\x20\x27\xff\xb9\x01\x78\xf0\xd2\xc2\x53\x38\x0c\x87\xe1\xa9\x23\xc4\xc3\xf8\x14\x9f\xa2\x33\x94\x74\xe4\x16\x37\xd5\x17\xbf\xc7\xef\x55\x5f\x14\x5b\x51\xb8\x89\x2f\xc8\xa8\x53\x87\x91\x5c\xb4\xf2\x06\x68\x49\xee\xd4\x02\x70\x03\x8f\x9d\xc0\x09\x8a\x2f\x7c\x0f\xdf\x2b\xbe\x8a\x2f\x7e\x0f\xdf\xab\xbe\xb2\x7b\x95\xf9\xf1\x88\xbf\x9d\x68\x0b\xab\xa3\x7c\x1e\x73\x49\x06\x67\x34\x99\xed\xb6\x2a\x56\x48\x66\x95\x36\x55\xcf\x97\xb3\x3a\xdb\x43\xbb\xfe\xbf\xa2\x8a\xd5\xad\x9c\x7d\xdc\xd5\xc9\xeb\x6c\x84\xaa\xa1\xb8\x0b\x86\x38\x91\xb2\x6b\xdc\x9c\xd1\xff\x09\xf6\xac\x9e\xb5\x3d\x06\xeb\xe3\xc7\x2e\xe1\x22\x58\x5d\x6d\x7a\x9b\x86\xaf\x66\x37\x88\xb2\x5d\x8f\x1a\x1e\x9e\x43\x1a\x8b\x7a\x6a\xa6\x28\xe3\xf3\xbf\xcf\x47\x7e\x4e\x1d\x65\x25\xd0\x87\xf6\x9c\x71\x0b\x73\xd9\xee\x4e\x0c\xe7\x41\x4f\x43\xb7\x08\x61\x54\xc7\x52\xbf\x83\x63\x85\x38\x43\xea\x9e\x24\xd9\x6f\xd8\x2b\x6b\xd0\x43\x40\x8f\x57\xda\x6f\x0f\x03\x3f\xf1\xda\xf5\xd2\x96\xb3\x32\x24\xa3\xb5\xe7\xf5\x4b\x77\x68\x74\xcc\xb2\xe0\xbf\xeb\xbd\x8e\x9d\x3c\x64\x41\x16\x99\x97\x97\x5d\x60\xd5\x16\x64\x16\xa4\xe5\x49\xa8\x03\x1d\x99\x97\x96\x92\x9d\x22\x24\xa7\x64\xa6\xa5\xc9\x98\xe5\xf8\x38\xa8\xd2\x52\xb2\x93\x85\x94\x1e\xa4\x0e\x75\x64\x5a\x5a\x66\x4a\x8a\x36\x39\x3b\x25\x2f\x4d\x82\xac\x1e\x3a\x27\x32\x59\x9b\xd2\x83\x74\x52\xe5\xc1\x75\xd1\x5a\x90\x9d\x97\x27\x3b\x94\x81\x93\x28\xaf\x20\xd3\x2a\x14\xf4\x20\x9d\x0a\xf3\xb2\x0b\x0a\xb4\x56\xa7\x05\x5d\x49\x90\xc5\xe3\x1c\x98\x43\x86\xd5\x26\x1e\x6a\xd6\x9e\xa9\xaa\x3f\x74\x50\xca\x89\x8e\xce\x8a\xfe\x2b\xb3\x53\x46\x0c\x5b\x8b\xfd\x04\xec\x37\xec\xf4\x9d\x11\xe0\x27\x96\x95\x59\xb2\x4a\xe5\xf1\x0f\x9c\x0c\x87\xb4\xcd\x25\x87\x6a\x6b\x1d\xa3\x45\x55\x24\x58\x8f\xb0\x4a\x67\x87\x5d\x03\x56\x57\xb0\x2a\x56\xde\xa6\xaf\x16\x75\xe8\x07\x56\xb0\x2e\x66\x95\x7e\xa2\xa2\x8f\x66\x75\x68\x80\xce\x38\x56\xe7\x76\x11\xad\xbc\x0e\x0d\x8a\x86\xfa\x41\xb4\xe9\x29\x45\x23\x42\x26\x2b\xbb\x2b\x9d\xa0\x87\xed\xec\xb7\xec\x62\x16\x2a\x59\xb4\x52\x78\xa7\xcb\x4a\xaa\xee\x14\xde\xb1\x59\x49\xb4\x52\xa0\x57\xf5\x24\xea\x51\x0f\x0d\xd4\x25\xc7\x7f\x82\xfb\xa8\x57\x46\x51\x60\xeb\xea\x04\x9b\xad\x93\x54\x46\x81\x1e\xef\x53\x97\xc0\xf1\x17\x1a\xf4\xa8\xa7\xd4\xce\x2e\x2b\x8f\x04\x58\x49\x08\xa4\xdc\xab\x23\x95\x5b\xa0\x87\xfb\x8e\xe9\xb8\x3e\x9d\x05\xbd\x6b\x99\x88\x9d\x3a\xfb\x45\xbe\xff\x1b\x8f\xfe\x78\x2c\x36\xb1\xb2\xd2\xa9\x74\x3a\x6d\xb3\xa6\xb3\x94\xbb\x05\xc2\x70\x5d\xa4\x72\x0c\xc2\xe1\x3e\xeb\x61\x06\x5f\xa5\xcd\xb9\x2f\x8e\x86\x4b\x2c\x13\xbb\xda\x74\xf6\x87\xd7\x44\xc5\x57\x69\xe3\xd5\x36\xc5\x4a\x71\xe7\x95\x36\x4a\x69\xeb\x6e\xbb\x26\x82\x13\xd9\xa9\x58\x95\x4e\xca\xbd\x0a\x59\x1d\xf9\x4b\xa6\xa8\xfc\x64\x7f\xc6\x5b\x8c\xd9\x26\x8b\xa4\x16\x80\x95\xcc\x4f\x48\x28\x88\x13\x42\x92\xc2\x43\x65\x1d\x5a\xe8\xa0\xea\xad\xfb\x13\x24\x25\x00\x13\xc8\xf4\xc2\xa2\xcc\x62\xa1\xb9\xec\x40\x93\xdc\x61\xbf\xc2\xab\xbf\xd0\x4a\x13\x56\x90\xca\x4f\xb6\x6f\x79\xb5\xb5\xdb\x45\x59\x80\x21\x64\x4a\xe9\xde\xf4\x72\xe1\x50\x45\xcd\x21\x39\x53\xe7\x56\xc4\x67\x1b\xb3\x8c\x16\x49\x3d\x02\x35\x64\x4e\x4a\x72\x56\xb2\x10\x19\xb5\x27\xc6\x20\xe3\xe7\x6a\xad\xa2\xed\x72\x27\x8f\x75\x28\xa5\xb6\x2f\x72\xb4\xee\xed\xac\xd2\x87\xd7\xd9\x09\x9d\x9d\x58\xcc\x52\xee\x4a\x35\x66\xd7\x9d\x3b\xbf\xe2\x7a\x38\xec\x58\x73\xb1\xe9\xfc\x46\x20\x60\xc8\x89\xcd\x27\x77\x1c\xcf\x39\x76\xf4\xbd\x4f\x8e\x6d\xbd\x0d\xab\x8f\x7d\x75\x19\xe6\x7f\xf9\xe0\x6b\x8f\x6f\x2e\xde\x69\xbb\x03\x43\xb1\xcf\xa1\xe4\xa6\xec\x4b\x2d\x0d\x20\xb6\xc2\xc0\x36\x88\x6a\x87\xa0\x33\x70\xff\x42\xd1\x85\x9c\xc6\xe4\xe6\xaf\xae\x6d\x3c\x52\x7d\x22\xfc\x1b\xae\x6e\xd6\x6f\x5d\x43\x39\x0f\x82\x20\xfa\x2a\xa1\x28\xf3\x45\xf5\xf1\x67\x76\xa6\xed\x48\x7b\x6b\x59\x56\x20\xc3\xb9\x39\xf0\x59\x61\x27\xc2\x0f\x17\xd7\x15\x1e\x38\x50\x58\xc5\x70\xbd\xbc\x89\x5e\x3e\x3a\x72\xb2\xa7\xa1\xbe\xec\x4c\x53\xda\xa1\xb4\xbb\xcb\x32\x03\x4d\x61\xfe\xe1\xdb\x8b\x77\x17\x06\x1f\x48\xae\x62\xce\x80\x0b\x1f\x79\xa2\xe5\xee\xa5\x54\xe6\x6a\x1a\xf4\x7b\x7d\x8e\x76\xfd\x92\xe0\x85\xe5\xd2\xba\xe2\xe9\x17\x63\x5a\x18\x9d\x7d\x83\x67\xf5\x89\xad\x77\xf5\xa9\xcc\x92\x34\x74\x26\x5f\x0d\xfe\xa0\x5c\x3a\x55\xfc\xe9\xc5\x7d\x2d\x8c\x2d\xd8\xae\xf0\x7f\x3c\x7a\x73\xe8\xd0\x37\xde\xec\xdf\x7f\xec\x17\x4f\xcb\xb2\x4a\xb2\x4b\xe5\xd0\xbd\x8d\x31\xcd\xc2\xf9\xb6\x23\xed\x32\x47\x08\x56\xc2\xd0\xba\xfb\xe0\xb6\x22\xa9\xb0\xa6\x3e\xb7\x41\x80\xcb\x10\xcc\x27\x40\x25\xe2\xfe\x57\x71\x33\x4c\xf8\x0e\x26\xef\x04\x2f\x1c\xcc\xd8\x92\x75\x38\x8c\x4f\xcf\x4b\x32\x27\xa4\x1b\xf6\xc5\x97\xc7\xef\xcd\x2d\x37\x95\xa5\xe5\xa5\xe6\xc5\x1b\xe3\x52\x62\x8b\x23\x8b\x23\x0b\x99\x7d\x69\xa5\x29\xb9\x92\x21\x2f\x22\x23\x26\x26\x32\x3b\xd2\x1c\x9d\x9e\x90\x99\x94\x9a\x94\xcc\x58\x6a\xcd\xb5\x75\xda\xdc\x7c\x8b\x25\x57\xbe\x51\x74\xf3\x74\xf9\xed\xdc\x3a\x4b\x7d\x6a\xa3\xe1\xdc\x86\x03\x9b\xf6\x66\x56\x87\x36\x85\xe4\x85\xe4\x45\x87\xa5\x45\x31\xe9\x19\xe6\x0c\x21\xd6\x18\x9c\x9e\x10\x67\x34\x1a\x33\x4d\x99\x51\x59\x91\xd9\x91\x59\x85\xf9\x85\x79\x45\x39\x95\xcd\xcd\x05\x6d\x16\x26\xc7\x9c\x9d\xad\xe5\x7a\x11\xfd\x08\xe2\x56\xd6\xd7\x95\xc7\x4e\xb5\x9f\xcf\xff\x3a\xe5\xa3\xe4\x8e\x90\xdb\xfa\xa3\x81\xd5\xab\xa2\x33\x02\x8c\x31\x99\x4b\xe3\x92\x19\x13\xc5\xb9\x11\xaf\x11\xc4\xae\xf8\x77\x2d\x1b\x73\x03\xbe\x59\xfe\xf9\xec\x2b\x58\x04\xbb\xf1\xdf\x11\xd8\xb2\x88\xe1\xf2\x09\x1f\x82\xe8\x8c\xbd\x17\xff\x49\xf0\xf0\xe4\x61\x3b\x7c\xfd\x97\x05\x2f\x0c\x58\xeb\xbf\x66\xad\xd7\xa5\x82\x0b\x45\x97\xd2\xb7\x46\xed\x0c\x0d\x0a\x66\xb8\x8b\x04\x41\x30\xc1\xa6\xe0\x9c\x18\x6b\x9c\x35\xf3\xaa\xb1\x3c\xe3\xe8\xaa\x7d\x81\x91\xfa\xcd\x21\x7e\x29\x73\x19\xae\xaf\x23\x39\x79\x4e\x81\xef\xe9\x15\x4c\x4f\x13\x38\xb6\xee\xbb\xe8\x4e\x23\xc3\x11\xb9\x84\x1f\x61\xca\x30\x67\x66\x6a\x8f\x19\x0f\xa6\x54\xec\x28\xca\x28\x4c\xb3\xa6\x46\x19\x23\x33\xa3\x8c\xa6\x2c\x63\xb6\x31\x8b\xe1\x08\x3f\xa2\x2f\x91\x58\x1e\x9c\x13\xe3\x88\xf8\x10\x0c\x91\x91\x6e\xce\x10\xd2\xaa\x62\x6a\x77\xa5\x86\xa6\x86\x04\x65\x46\x04\xc4\xad\x0f\x4e\x5a\xc9\x70\x2e\x7d\x09\x03\x91\x16\x6c\x0e\xc9\x0b\xdd\xeb\x77\x73\xdd\x8d\x24\xc6\x98\x9f\x6b\xce\x13\x42\xcd\x61\x61\xda\x24\x6b\x62\x7e\x62\x76\x74\x6e\xa4\x39\x32\x33\x66\x5f\x64\x4e\x52\x1a\x93\x92\x9e\x9e\x10\xa3\xed\x31\x23\x62\x4f\x54\x52\x6c\x12\xc3\x11\xd3\x89\xf1\x44\x5c\x41\x5c\x56\x6a\x5a\x5a\x9a\x39\x3e\x27\x36\x3e\x2e\x21\x2e\x29\x3a\x21\x37\xd1\x9c\x91\x96\x9e\x9a\x17\x53\x18\x9b\x91\x68\x4c\x34\x25\x18\xf1\x05\x78\x13\x7b\xff\x99\xc1\x70\xc4\x20\xc2\x8b\xe8\x30\x76\x1c\x6a\xba\xac\x8c\x8b\x51\xc6\x67\x2b\xe3\xcb\x1a\x97\x75\x6c\xef\xc8\x06\x22\x07\xde\x84\xde\x99\xf0\xc2\x5f\x92\x4b\x33\x4b\x32\x4a\x24\xce\xc5\xcd\xb0\x8d\x28\x2c\xcf\xdb\x97\x9e\xcf\xe0\x7e\xfb\x7c\xbe\xba\xae\xa0\x21\x44\x6a\x5b\x5f\xea\x93\xb1\x39\xfe\xdc\x8e\x2b\xf3\xea\x98\x9c\xa2\xdc\xca\x1a\xed\xe4\x21\x3c\x30\xe2\xbe\xec\xea\xbc\xe2\xe2\x5b\xe1\xcd\x93\x72\x26\x65\xec\x49\xdd\x93\x9a\x12\x19\xb1\x35\x7e\x53\x0a\xc3\x11\x06\x62\x3d\xb1\xf7\x5e\xfc\xe3\xd5\x57\x19\x60\xc4\x1e\xc9\x5b\x32\x9c\x2f\x44\xb9\x11\xe7\xfd\x6b\x5e\x8e\x18\xcd\x18\xe3\xe3\x4d\x89\x82\xa3\x9f\xf5\x22\x52\xbf\x8c\xb9\xbf\xeb\x0e\x63\x2a\xdd\x6b\x2e\x15\x74\xb6\x6f\x27\xf0\x19\x47\x4b\xfe\x3c\x7e\x82\xa9\x6f\xa8\x4f\x89\xd0\x86\xe7\x46\xe5\x18\xa4\x79\xa1\x3b\x96\xc6\xaf\x64\x5a\x06\xf3\x9c\x0f\x41\xb8\x11\xa9\x05\x69\x85\xe9\x85\xb9\xf7\x0e\xfd\x7f\x6c\xfd\x07\x58\x14\x57\xf7\x38\x8e\x83\x30\xc5\x89\x41\x65\x76\x0c\xec\xec\xcc\x68\x62\x47\xac\x68\x34\x6a\xc4\xde\x0d\x1a\xc4\xde\xc0\x02\x22\x2a\x45\x40\xe9\x9d\xdd\xa1\x33\xf4\x22\x62\x45\xec\x62\x6f\x18\x93\x58\xb0\x8b\x31\xcd\x44\x63\x34\x05\xa3\x26\x31\x9e\xd9\x3d\xb3\x7c\xfe\xcf\x2e\xbe\x79\xdf\xe7\xff\xfd\x3d\xb3\x3b\x77\xee\xb9\xe7\x9e\x7b\xe7\xce\xcc\xb9\xe7\xcc\x9c\x7b\xce\xb7\xf7\x6a\x69\x56\x61\x06\xa7\x4d\x29\x49\xd8\x96\x56\x95\x69\x6b\x53\xa6\x80\x16\x16\xcd\x8e\xf5\xa8\x18\x15\x50\xb8\xa6\x2c\xb2\x96\x86\x89\x73\xb9\xd8\xd8\xac\xec\x2d\xd2\x96\xdb\x45\x5f\xed\xba\x40\x9b\xa8\x93\xd5\x55\x05\x55\x05\xd5\xb9\xee\x2b\xc7\x85\x8d\x4c\x1e\x41\x5b\xe6\xad\xe4\xce\x9a\xce\xca\x67\x32\x4d\x53\xc3\x90\xf2\x09\xd9\x94\x98\x9a\x97\x51\x9b\x74\x23\xfd\x46\xfc\x0d\x5a\xa6\xf0\x80\x99\xe3\x60\x00\xb0\xe8\x8a\x03\x70\x20\xb6\xa5\x03\xd0\xee\xa6\xdf\x06\x07\x57\x18\x20\x41\xb4\x95\xe5\x72\x36\x17\xe3\x7b\x51\x69\xcb\xe3\xdf\xcf\xf4\xdf\x1a\x5b\x6c\x04\x97\xac\x6a\xda\x44\xdd\xc9\xba\x2b\xdf\x31\xd1\x58\x83\x8b\xb8\x45\xf1\xdd\x8c\x8b\x6a\xc2\x8b\x8a\xa0\x57\xc1\xfe\xbb\xd9\x77\xe5\x7b\x59\xb4\x89\xca\x5d\x57\x88\x43\xb6\x24\xd3\x9a\x08\xb3\xb9\x93\x39\xa7\xb2\x4f\x66\xd1\x32\x95\x3c\xc7\xf8\x41\x6a\x70\x46\x58\x82\x1c\xa5\x7c\x74\x30\xf2\xb7\xad\xcd\xb4\xad\x75\xce\x94\x63\xca\x35\xe6\xec\xc9\xdd\x93\xb3\x27\x27\x3f\xa2\x30\xb2\x24\x92\x66\xbb\x3a\x38\x26\x3a\x1c\x9a\x01\xae\x93\x72\xff\xa9\xf5\x05\x5d\xd1\x85\xbc\x2f\xf2\xea\xe4\xe2\x33\xa7\x62\x6e\x65\x9d\xcd\x3d\x96\x73\xc0\x54\xb6\x37\x37\x3a\x27\xbc\x28\xfa\xe8\xa8\x3f\xee\x1f\x00\x17\xba\x3e\x73\x5f\xc6\xbe\x4c\xba\x6d\x29\xb6\x6d\xe4\x4c\x99\x26\xa3\x29\x03\xde\x30\xc6\xd8\xb2\x84\xaa\x54\x9c\x80\xe3\x70\x12\x7a\x60\xce\x04\x8c\xff\x1a\xa7\xc2\x07\x38\x0c\xc6\x6d\x2d\xa8\x28\x36\x56\xd1\x1f\x5a\x69\x2e\x6e\xea\x94\x65\x53\x73\x68\x96\x76\xa0\x1d\x1c\x26\xe4\xf4\xbc\xbc\xf8\x5e\x12\x50\xe0\x0d\xce\x3f\x84\xd9\x9e\xb6\x76\x0e\x0e\x9f\xc5\x9c\xe9\x53\x33\x14\xde\x30\x89\xa6\x24\x63\xb2\x98\x03\x63\xb8\xe4\x6d\x09\x3b\xe3\x76\xd0\xac\x83\xb3\x43\x27\x07\xe3\x39\xf9\x5c\xd6\x39\x3a\x8b\x2c\xca\x2f\x2e\x2c\x2c\xda\x9e\xbf\xbd\xb4\xb0\xbc\xa0\x3c\xa1\x64\x4b\x51\x56\x8e\x9c\x93\x95\x03\x6f\x98\xa2\xdc\xe2\xdc\xc2\x3c\x9a\xed\xea\xe8\xeb\x50\x63\x0f\x7b\xe3\xd8\x13\x3e\x18\x83\x86\x15\xe8\xf6\x09\x76\x1a\x9f\x79\x2c\xe1\x44\xc2\x3e\xfa\x36\x7e\xc4\x99\x64\xd9\x24\x66\x51\x59\xb2\x2c\x4b\xd0\xe5\x3b\x10\xae\x43\x9f\xe3\xc7\xa3\x8f\xc5\x9c\x88\x2b\xcc\x94\xe5\xc2\x9c\xc6\xf2\x0b\xd5\xe7\x6b\xa1\xff\x72\x10\xc7\x82\x61\x94\xd6\x39\x5e\x73\x35\x6a\xae\xe5\xb4\xc1\xb9\xe6\x14\x87\xee\xf7\x50\xb8\x82\xdd\x8f\x43\xb7\xfb\xd0\xf9\x15\xb4\x07\xc7\xc2\x74\x25\xa3\x38\x93\xce\xcc\xca\xc8\x32\x8a\x5b\x92\x12\xe2\x0b\x62\x0b\xe3\xb6\xc7\x6d\x4f\x57\x92\x8a\x92\x8b\xd3\xe8\xf9\xa6\xf9\xc6\xf9\x62\x56\x56\x5c\x78\x62\x58\xca\x26\xf7\x84\xb5\xf1\x4b\x33\x57\xd0\xaa\x21\x82\x5b\x3c\xbe\xe7\x27\x13\x32\xa7\x66\x4e\x39\x11\x77\x83\x36\x2a\xa6\xa2\x62\x7d\xcd\xe3\xb3\x7f\x5c\xac\xf8\x71\x07\x78\xa3\x73\x22\x52\xb4\x8b\x5a\x67\x99\x06\xc3\x1c\x65\x7b\x90\x70\xe2\x75\x18\xf7\x6c\xdc\xfd\x81\x03\xc7\x8e\x1d\x38\xf0\xfe\xb8\x67\xcf\x9a\x9b\x9f\x89\xd6\xa4\x2e\xcf\xc6\xde\x1f\x38\x70\xdc\xd8\x81\x03\x9b\xc7\x3d\x7b\x76\xdf\x06\xab\x30\x10\x5f\x71\xd0\x09\x67\xdd\xc2\xbf\x0c\xce\x09\x95\x06\xe7\x43\x55\xd6\x8d\xf8\x3d\x06\x69\x24\xad\x3e\x37\x7b\xa9\x61\x90\xde\xda\xcc\xb7\x36\x63\xdd\x29\x68\xc2\x33\xf6\xf8\xf4\x4d\x4d\xa0\x98\x75\xf5\x6a\x04\xe8\x9a\x9a\x1c\x65\x5b\xb6\xa9\xc9\xee\x56\xcf\xd7\x76\xe4\x64\xd1\x19\x88\x46\x4e\x5d\xa6\xb6\xd7\xda\x6b\xcb\xb4\x65\xda\xbf\xa9\xda\x5e\x5d\x66\x83\xdb\x52\xa9\xa9\xcd\x43\x95\xd6\xdd\xda\xcc\x05\x93\x40\x09\x5a\x44\x9b\x05\x7e\xfd\x33\x46\x8d\xa0\x64\x46\xed\x3e\x9d\x0b\x14\x16\xef\xf4\x3f\xbc\x49\x42\x72\x02\x03\x24\x75\x78\xdb\xce\x86\xd3\x7a\x38\xc1\x98\x95\xb6\xc8\x15\xcf\xb5\x51\xda\x28\x78\x8e\xcf\xe1\x08\x03\xcf\xd5\x51\x1e\x36\xe1\x57\x8b\xe0\xa0\x5a\x10\x3d\xce\x33\x2d\x6f\x43\xeb\xbc\x0d\x37\xec\x71\x9e\x31\xbf\xb6\xea\x38\x4f\x46\x6c\xd5\x3d\x65\x54\x05\x1a\x18\x8b\xae\xfc\x3f\x76\x9e\x41\x8c\xaa\x03\x5f\xd0\x41\x57\xc1\x6e\x36\x2a\x83\x8e\xb5\x18\xa8\x44\x8b\xc2\x19\xcc\x89\x56\x05\x6a\x04\x08\x62\x38\x98\xc3\x18\xd4\xc6\x7e\x02\xab\x59\x7c\x17\x09\x06\xca\x7b\x0e\xc3\x5a\xb0\x01\x74\x9a\x8e\xb2\x69\xaf\x1c\x9c\x60\xc0\x0b\x24\xc1\xa0\x36\x2e\x61\x5a\x7d\x29\x56\x1b\x72\x6f\xfc\x13\xd1\x40\x79\x2f\x64\xc0\x8b\x02\x9a\x91\x5c\x4c\x82\x4d\x80\xe4\x8c\x82\x59\x31\xa0\x03\xc9\x6a\x06\x2a\x71\x7a\x5f\xe1\x2d\xd8\xa2\x33\x2b\xad\xba\xff\x7f\xa8\xaa\x98\x15\x4d\xf9\x1f\x28\xab\x19\xe8\x44\x8b\x6f\x5f\x41\x4b\x00\x89\x91\xd3\x19\x27\x83\x73\x88\x9a\xc4\xb5\x2a\x16\x85\x28\x4d\x88\xc9\xdf\xc2\xa7\x24\x1b\x33\x53\xa5\xf0\xa4\x98\x88\x50\xbd\xc1\xd2\x15\x36\x32\x70\x1d\xae\xc3\xa7\xda\xfc\xb2\xe0\x43\x31\xfb\xca\xdc\x61\xe2\x57\xf5\x65\x15\x87\xe2\xf6\xb9\xe3\x12\x75\x23\xa1\xba\x92\x20\x08\xb4\x8b\x35\x21\x93\x31\x2b\x30\x49\x70\xf4\x13\x9c\xcc\xcd\xd0\x97\x69\x02\xdd\x74\x12\xa7\xa0\xdb\x3c\xcf\xf1\xd2\x6f\xe3\xd1\xed\x02\x4e\xe1\xa7\xa3\xae\x89\x84\x40\x70\xf0\xc6\x3e\x92\xe6\x05\xbf\x31\x5a\x03\x85\x7d\xd0\xc1\x1b\x03\xc5\xb6\xc2\x29\xe0\x76\xe1\xb7\x7b\x92\xe7\x3d\x70\x9b\x07\x53\xf8\x36\x32\x81\xe8\xf0\x15\xf4\x91\xec\x42\xa7\x23\xa3\x7a\x51\xd0\x07\x1c\xbe\x82\x40\x9b\xcc\x9d\xc9\xd8\xed\x4c\xdb\x5e\x53\xfd\x2e\xfc\x27\xd3\x55\xf8\x2f\x58\x79\x6b\x95\xcb\x1e\x28\xa9\x61\x1d\xbd\x7d\x0c\xb4\x03\x5c\x11\x54\xdb\x15\x60\x1d\x32\xbd\x51\x67\x40\x07\x8a\x75\x0c\x74\xb0\x5d\x14\x1b\xb0\x5b\x27\x07\xd0\xb5\x2a\x24\x5b\xd3\xdb\x01\x34\x81\xf5\xa6\xbd\x41\x67\x14\x28\xb6\xc6\xc1\x07\xed\xee\x81\xd8\x6e\x0e\x5d\x51\x67\x51\x48\x5b\xd9\x11\x81\x03\x1d\xc9\x76\xa5\x1d\xb0\xad\x32\xda\xa3\xfa\x83\x8e\x63\x1d\x69\x07\x5b\x91\x43\xa6\xb7\xca\x0a\x14\xeb\xe8\xe0\x0d\x3a\x83\x25\x91\xb3\xd5\x0f\x11\x48\x76\x67\x90\x0f\xe8\xc8\x08\xa1\x8b\x01\x1d\x54\x47\xc6\x62\xeb\xaa\xce\x28\x84\x08\xad\x0a\xea\x48\xd8\x26\x80\x0f\x63\xd5\x59\x74\x1c\x2b\x52\x89\xa0\xb4\xea\xac\x8a\xaa\x43\xc5\x76\xc5\x29\x03\x26\x6a\x3a\xdb\x65\xd6\x69\x0a\x65\x83\x72\x56\x9b\x12\x79\x85\x01\x85\x74\x51\xff\x1d\x98\x23\x42\x88\x20\xc3\x0a\x41\xb6\xdb\xe1\xfe\x77\x64\x6c\xc3\xf2\xbf\x47\x2b\xec\xdf\xbb\x0a\x76\xce\x61\x1d\xbd\x09\x43\x7b\x07\xb3\xc2\xbd\x1d\xa2\x44\x1d\xb6\x1d\x78\x77\x02\x5b\xe2\xd3\xdb\x76\xe3\xda\x34\x50\x87\xf7\xbb\xa2\xae\xd5\x06\x5b\xf8\xef\xe0\xb5\x9b\xe0\x00\x3a\xab\x8e\x64\x19\xc6\x3e\x78\xdd\xdb\x25\xda\xd0\x6d\x43\x53\xe3\xe8\x6d\x1f\x4e\x87\x09\xa0\xb3\xd8\xf2\x0e\xc4\xdb\xe1\xec\xd1\xae\x9d\xdd\xd5\xd2\x11\x81\x63\xdb\xb5\xb3\x8f\x59\xbb\x09\x0e\xf6\x31\x73\x18\xe7\x60\xd5\xa9\x0a\x67\x6b\x4c\x75\x64\x48\xd6\xc1\xbb\x2b\xda\xca\xbd\x3b\x19\xd0\x01\x74\xf6\xb1\x6f\x67\xbb\x1c\x14\xdb\xdd\xe1\x7d\xdb\xb0\xe9\x5a\x15\xdb\xc4\xed\x6c\x43\xb3\x37\x66\xeb\x76\x57\x07\x6f\xa3\xd0\x85\xed\xee\x50\x03\xbf\x31\x14\xcb\x38\xf4\x6e\x55\xba\xa8\x8e\x0c\xc5\xb6\x4b\xd4\xc1\xc7\x8c\x0d\xc7\xd1\xc1\xd9\xa2\x23\xd9\xc2\x77\xd6\x86\x08\x56\x9d\xad\x79\x4d\xa7\x29\xe0\xc3\x18\x05\xd4\x81\x0f\xc3\xe6\x2f\xf4\x0c\x11\x38\x95\x15\x5a\x75\xa0\x0b\x11\x6c\xa7\x05\x57\x18\xfb\x2e\x44\x20\x5d\x56\xd9\xae\x60\x03\xb7\x5a\x10\x55\x2f\x8b\x17\xfc\x22\x18\x2c\x8d\xe0\x29\x58\xbc\x48\xfb\xa3\xae\x75\xa6\xce\x28\x17\x77\xd6\xd5\xc1\x0c\x98\xe1\x56\x57\xb7\xf3\xa2\x72\x86\x76\x09\xb1\x3d\xaf\x9f\xdb\x76\x3a\x27\x03\x11\x0d\x0a\x97\xb6\x25\x79\x4b\x6a\x2a\xce\xc4\x99\x6e\xa9\xa9\x5b\x92\xb7\xa4\xd1\x90\x05\x59\x14\xee\x03\x1d\xe7\xb7\x7c\xb9\x9f\x84\x0d\xad\x3a\xa3\x60\x14\x5a\x6d\x3c\xc4\xe2\x05\x43\x98\xb7\x0d\x29\x64\xe3\xfd\xbd\x87\x0e\x49\xb6\x06\x88\x43\x87\xf6\xde\x6f\xd4\xbb\xa8\x75\xea\x62\x98\x8b\x53\xa1\xeb\xb7\xc0\xd9\x57\x7b\x3e\xbf\x68\xee\x7d\x1f\x56\x43\x00\x64\x80\x8e\x8d\x33\x50\x5b\xd5\x03\xdc\x81\xf0\x5d\x21\xf9\x62\x56\x46\x72\x56\x3a\x8f\x9e\xd8\x15\x3c\xc9\x3c\x25\x2b\x2b\x57\xaa\xcb\xdf\xbe\xf3\xa0\x7e\x33\x04\x71\x07\xc2\xb7\xaf\xcf\x13\x33\x53\x6d\x18\x12\x72\x20\x91\x79\x05\x72\x56\x8e\xc4\x66\xee\xc9\xdb\x5e\x7b\x40\x6f\xc0\xe9\x38\x9c\xc3\x0e\x63\xfb\x62\x81\x28\x63\x3f\x19\x3b\xec\x13\xc1\x99\x5a\x73\xff\xeb\x88\x6f\xf8\x5f\xce\x5f\xfa\x4a\x82\x2b\x10\x8d\x57\x28\xf3\x52\x9c\xc1\x75\xdd\xd8\x33\x43\xd6\xe3\xeb\x98\x5e\x20\x41\x0f\x3d\xf4\x78\x09\x12\xbc\x8e\x11\xe5\x57\x19\x6f\x36\x8a\xe8\x4c\xf9\xed\x9a\xb6\x63\x44\x3e\x8d\xdd\x8b\x87\x4e\xc4\x4e\x7a\xec\xf4\x78\x22\x74\x2f\x16\x1f\xe6\xdf\xd8\x79\x61\x17\xcd\xc6\x21\x41\x99\xc3\x80\xe2\xd8\x6d\x1f\x8d\x9f\xd7\x57\xd4\x12\xd4\x02\x75\x11\xa9\x14\x9b\xf2\xf9\x47\x19\xd7\x96\x8d\xd1\xfb\x2c\x9f\x3f\x3a\x51\xcc\xa4\xd8\xb8\xc7\x69\x37\x16\x8d\xd5\x83\xce\x9c\xf3\x54\x30\xa8\x0e\x24\xeb\xbf\x41\x50\xeb\x60\x00\x03\xcf\xaf\x40\x30\x24\x43\x35\x24\x43\xb0\xca\xc2\x73\x27\xf3\x0b\x38\xc3\xa1\xd4\xd8\x1b\x78\x18\xac\x87\xc1\x2f\x80\x07\xe9\xa2\x68\x9d\x4a\xa9\x59\xf0\x82\xc3\xc1\xbd\x91\x47\x69\xae\x68\x9e\x46\x81\x34\xf7\x05\xf2\x38\x58\x0f\xc1\x5d\xe0\x6b\x2c\x87\x72\xfc\x1a\x1f\x60\x05\xda\x53\xa8\xc0\x0a\x78\x00\x5f\x43\x39\x54\xc0\x03\x51\x65\x53\x39\xfc\x13\xef\xe1\x61\xfc\x4b\xc4\x8b\x24\xbe\xc1\x93\x70\x18\xfe\x54\x5d\xe1\x24\x54\xc2\x1b\x09\x2e\x92\xf0\x17\xdc\xc3\x4a\xcd\x55\x82\xe7\x66\xfd\x4a\xe6\x1f\xe6\xa8\xe0\x51\x21\xb4\x36\x27\x32\x96\xe6\x66\xc6\xd2\x0c\x93\x05\xbb\xb3\x30\x4b\x33\x37\x9f\x69\x6d\x6e\x8b\x67\x6b\x69\x5e\xc8\x68\xf6\x69\xf4\xbf\x30\xf0\x02\x1d\x7a\xfd\x4f\x35\xf4\x02\x1d\x65\x67\x0b\x10\x01\x0d\x90\xc1\x54\x80\xb3\xab\xdc\x64\x56\x9a\xda\xde\x44\xd9\x8e\xd8\x97\x89\x06\xb2\xd1\xd2\xcc\xa9\x3a\xab\x2f\x61\x55\xc8\x56\x9d\xd9\xf7\xdf\x8c\xc1\xf9\x98\x45\xc7\xa9\x09\x41\x82\x96\x40\x7e\xb5\x71\x62\xe3\x87\xfc\x87\x13\xfd\xbc\x37\x4a\x5a\xc2\x20\x46\x4d\x20\xab\xe7\x9e\x58\x76\x31\x9a\x36\x58\xfe\xd1\x5e\x6f\x60\x60\x0a\xc3\xba\x3a\x0c\x63\xd8\x5a\x87\xd5\x8c\xf6\xda\x40\xbc\x43\x5e\xac\x3e\x71\xa2\xfa\x22\x8d\x53\x63\x38\xf8\x91\x59\xb6\x66\xcd\x32\xc9\xd2\xdc\xea\xcc\xc9\x14\xac\x67\xc0\x24\x88\xec\xcb\x44\xf8\x10\x0e\x3f\x04\x7f\xc9\x80\x0e\x5d\x58\x57\x07\x58\xcf\xd8\x80\x26\xe1\x2d\x5c\x74\xe9\xce\x68\x7b\xad\xf3\xb9\xb0\xe4\x2d\xe1\x1b\xf5\x6d\x6e\x82\x61\xe9\x18\x58\x8e\x5b\x35\x47\x7d\xab\x42\xaa\x8e\xb0\x1c\xb6\xc2\xd2\x07\xe2\x73\xa6\x3b\x83\xba\x2e\xcb\x32\x97\xa7\xf9\x8b\xad\xc9\x64\x5a\x43\xe6\xf1\x13\x7a\x8b\x62\xb0\x38\x70\xad\x0a\x09\x08\x0b\xa1\x0a\x16\x7d\x27\xc2\x16\x12\x16\x8d\x84\x85\x58\x85\xa8\x77\xb1\x57\xc2\x9e\x6b\x91\x9b\x87\x8e\xa2\xf5\x77\x72\x1e\x38\xae\x05\x0e\x7a\xea\x2d\x8b\x0c\xe8\xcd\xb5\xbe\x4f\xde\x87\xb9\xe0\x0e\x02\xb8\x5f\xa4\x6d\x75\xdd\xe7\x82\x3b\x0a\xf7\x71\x2e\xfd\xff\xd5\xbb\xc7\xc1\x3f\x4d\xbe\xeb\x41\x5b\x7d\xc8\xbb\x2d\x3f\xdd\x7a\x5c\x4f\x3f\x67\x50\x01\xdf\x47\x91\x06\xc2\x1b\x7c\x7f\x66\x0c\xc4\xa3\xe9\x7f\x32\x06\x4b\x6d\x13\x67\x70\xd6\xc8\x68\x78\x8a\xbb\x61\x2a\xce\x00\x17\xb0\xfd\x77\xc3\xd4\x6a\x78\x4a\x1b\xd0\x99\xac\xc6\xa7\xb0\x1b\xa7\xc2\x0c\x74\x41\xdb\x7f\x37\x4e\x8d\xc6\xa7\xb4\x81\x58\x6a\x20\x1d\xfe\x64\x5c\x42\x04\x8b\x33\xe8\xea\x41\x37\x1d\x74\x1e\xf6\x75\xa1\x5d\x05\x88\xa8\x97\x41\xd7\x52\x0f\x4a\x3d\x44\xd4\xb7\xb4\x89\x29\x4f\x22\xd8\xcb\x11\x66\x05\xae\x08\xb9\xb9\xb2\x29\x4f\xba\x99\x7a\xc6\x67\x8a\x1e\x5d\xea\x6d\x3c\xb0\x29\x02\xb6\x31\x85\x85\x26\x53\x81\xd8\x98\x78\x70\xa1\x9f\x1e\x3b\xd7\xd7\x53\xec\x13\x1b\xb8\xe9\xcc\xbc\x19\x22\x9a\xa8\xd0\xcc\xd0\xd4\x30\x91\xfd\x49\x45\x07\x6d\x0a\x91\x1a\x96\x19\x1a\xaa\x0f\xa3\x3c\x19\xd1\xaa\x23\x03\xd7\xef\x39\x70\x34\x69\xdf\xfa\x3d\x12\x5e\x83\xb3\xc4\xa6\x6d\xf1\x7b\xf6\xea\x21\x82\x82\x6d\x8c\xc8\xde\x8b\xb0\x91\x90\xd0\x9b\xaa\x0f\x21\xd4\xb1\xd4\x7f\x68\xf6\xb7\x37\x7d\x39\x02\x68\x46\x04\x9d\xf3\xb4\x99\xe1\x4b\x17\x4b\xec\xbd\x88\xb2\x75\x6b\x0b\x82\x78\x74\xed\xd6\x07\xd9\x14\x29\x2b\x3d\x5d\x4e\x53\xdf\x11\x30\x82\x9a\xba\x67\xfa\xe9\xa5\xb6\x1e\xc0\x15\x3c\x4b\x60\xbb\x6f\x06\x02\x29\x9a\x75\x64\xba\xb0\x5d\xae\xcd\xdf\x2e\xd9\xfa\xeb\xa8\x4e\x21\x0a\x0f\xe4\x1d\x3a\xa8\x07\x13\x05\xee\xdd\xa0\x1d\xea\xa3\xa2\x8c\xe9\xd1\x22\xdb\x14\x71\x7d\xe9\xb8\xc3\xa3\xf8\xe5\xcb\x13\x36\xad\x96\xd8\xcb\x11\xfb\x96\xcf\xab\x9c\xcb\xdb\x9d\xa5\x46\x33\xa0\xd8\xbf\xf5\xe8\x64\xb5\x93\x6d\x00\xff\xf3\x03\x1d\xfb\xf7\x23\xb6\xe5\x91\xc5\x19\xfa\x32\x57\xcf\x2d\x98\x29\x59\xbb\xd7\xab\x3b\x28\x16\x1e\xc1\x36\x3b\x40\xd4\x76\xd4\xc3\x0e\xea\xdf\x5c\x3a\x15\x65\x8c\xca\x8c\x16\xc7\x68\x7d\x88\xa5\xc9\x01\x6b\x97\xf0\xd6\x09\x64\xc0\xaa\xea\xfa\x70\x09\xfe\x61\xee\x7c\xfe\xc5\xdd\xa3\x87\xa3\x83\xb7\x8b\xd0\x1f\x57\x10\xa0\x50\xea\xff\xd4\xdd\x51\x6f\xee\x4e\xb1\x2d\x36\xd2\xb6\x21\x19\x34\x7c\xfe\x47\xfe\x12\x0b\x8f\x72\xe2\xe2\xb2\xe2\xd4\x77\x04\x6d\x12\xb5\x3d\x70\x7e\xd1\x0a\x1e\xdf\x47\x12\x29\xec\x06\xd9\x8c\x79\x02\x09\x0e\xbf\x7e\xfd\x4f\xb5\xf4\x40\xed\x4d\xe4\xed\xca\xd9\xbd\x5b\xaf\xa6\x53\xd0\x15\xdb\xbf\x41\x29\x45\xac\xa4\xc0\xcd\x1e\xd2\xd3\x2d\x2e\xce\x94\x19\x27\xb2\x2d\x8f\xbe\xf7\x1f\x7e\x7e\x10\xef\x52\x63\x9b\xcc\x76\x6f\x80\x11\x82\x6d\x86\xa8\x07\x9d\xed\x74\x0b\x40\x07\xd9\xb6\x73\xaf\xaf\x87\x06\xd0\xb1\x17\xce\x5a\xbe\x40\x1d\x77\xed\x5a\x61\xf9\x65\x09\x7e\x79\x44\x00\xb9\xfb\xbb\x3f\x81\xd1\x9b\x07\xaa\x0c\xa3\xf5\x20\xad\x34\xa4\x10\xc5\xeb\xd7\xe5\xaf\xe3\xfd\x99\x6e\x37\x3c\x5e\xac\x96\x4e\x6c\x21\x90\x20\x81\x15\x20\x5a\x80\x6e\x12\x94\x91\xe9\x49\xf2\xc6\x44\x3d\xfb\x63\xec\x80\xc6\x0f\x1f\x06\x88\xe9\x54\x60\x61\x60\x79\xb0\xe8\x71\xfc\xdb\xa5\x7f\xf3\xa0\x33\x2f\xe2\x7c\xa9\x29\xa7\x7d\xae\xc7\x89\xf8\x0c\xfb\x13\xa9\x71\x31\x99\x31\xfc\xcc\x05\xe7\xae\x9e\xd8\x79\xf4\x68\x95\x04\x1f\xde\x27\xd4\x0d\x98\xca\x2d\x0b\x0d\x08\xd8\x2c\xe2\x6b\xf4\x22\xd2\x93\x62\x32\x12\xf8\x29\x4b\xce\xdc\x78\x70\x65\xfb\xe5\x5d\x12\x1c\x07\x37\xa2\xa0\xac\x22\xa7\x82\xb7\x5f\x27\x8c\x35\xa7\x72\xb7\x49\x74\xea\x41\xac\xdf\xb8\x65\x65\x80\x1e\x17\x52\x18\xd7\x8d\xd0\xea\xc9\x09\x73\x3e\xbf\x2b\xb1\x3f\x9e\xb5\xdd\x79\x66\x5d\x13\xa9\xd5\xc2\x62\x62\x61\xf5\xda\x33\x8d\xfa\xbb\x5f\x7c\x7e\xa7\xa2\x3c\x33\xbd\x5c\x64\x7f\x8c\x55\xc1\x80\x34\x37\x90\x84\x6b\xd0\x8d\x38\x5f\xbb\xef\xc2\x25\x3d\xfb\xe3\xd9\x3b\xf3\xaf\x4c\x2c\x16\xd9\x0b\x67\x0f\xec\xda\x76\xec\xa4\x1e\x56\x06\xe3\x4a\x6a\xd6\x02\xdf\x99\xb3\xe6\x9f\xba\x2a\xc2\x59\x6a\x6f\x69\x5d\x6d\x8d\x08\x06\x70\x25\xe0\x0a\x09\xef\x32\x92\x75\x20\xe5\x13\x30\x7f\x4e\x9c\x88\xbf\x0c\x23\xe2\x17\xf8\xa5\xcd\xe3\xdb\x6c\x92\x74\xaa\xee\x77\xfb\xed\xa6\xbb\xc0\x58\x74\xf0\xcc\x26\x9f\x27\xc0\x56\xa6\xf5\x53\x72\x2f\x23\x05\x53\x53\x6b\xa7\x1d\x9b\x2f\xa2\x5b\x31\x38\xf5\x00\x77\xde\x3c\x8e\x5c\x81\x3a\x42\x1b\x5e\x24\x04\xc3\x49\x41\x54\x8f\x93\x70\x04\x3f\x20\x70\xa2\x3d\xa7\x23\xa1\x95\x01\xa0\xa0\x8b\x3f\x74\xfe\xf8\x6f\x51\xbb\x6d\xde\x46\xdc\x58\x34\xfa\xc8\x47\xbc\xb9\xc8\x60\x6e\xb4\xa9\x35\x9a\xee\x29\x03\x0b\xa8\x83\x91\xfb\x82\x2b\x45\xbc\x03\x83\x89\xbc\xe4\xa4\xec\x24\x5e\xfb\xe2\x29\x53\x4f\x3d\xb9\x77\xef\x89\xa8\x7e\x42\x36\x1c\xda\x75\xa4\x54\x6a\x02\x5f\x22\x47\xc9\x2e\x2e\xd2\x2f\x16\x06\x92\x56\x1d\xf9\xc9\xdc\xe3\x5f\x26\x4a\x19\xd5\x59\x5b\xab\xf5\xbf\x08\xe6\xe6\x7a\x6b\x33\xb9\x62\xf5\x06\xff\x78\x29\xf0\xb8\xe9\x50\xa3\xfe\x17\xc1\xf2\x29\xd9\x70\x38\x2a\x78\xbb\xa4\xde\xb1\x6e\x23\x2e\x8f\xd8\xd7\xb3\xa7\xbe\xed\x54\x27\x09\xe6\x09\xa0\x5b\x64\x53\x9d\x88\x4e\xa0\x83\x54\xd0\xb1\x3f\xa8\xcb\x50\xe1\xcc\xd3\xc8\xcf\x2e\x56\xed\x3b\x21\xa9\xb9\x6a\x27\xe2\xc6\xb9\x86\x6f\x7e\xd4\x43\x57\xa4\x81\x40\xe9\xfd\xd9\xb3\x3f\x19\x29\x42\x47\x55\x21\x72\xb7\xe6\x6c\xad\xd6\x43\xc7\xc1\x7f\x63\xc7\x32\x11\xe8\xe8\x3e\x8f\xf1\x1d\x1e\x9d\x3c\xc6\xa0\x43\xa8\xd4\x5d\xf3\x1e\x0e\xaf\x08\xf6\x05\x38\x84\x7a\x3c\x40\x27\x1e\xe9\xbe\x23\x91\xd8\x24\x61\xc7\x78\xcf\x1e\xd8\x49\x1f\x9d\x1d\x9d\x17\x2d\x02\xad\x85\x12\x79\x9b\xe4\x4d\x11\xfa\x35\x79\xab\x0b\x03\xc5\x57\x5a\x0f\x82\xfd\xa1\xd7\x8e\x9f\x27\xfe\xc5\x9b\xdd\x8f\x0a\xdc\xf5\x53\x7e\x33\x92\x4d\x49\xc6\x64\x09\xfb\x5a\x9d\x89\x9d\x24\xd0\x6a\x24\x71\xae\xe4\xe4\xc1\x0b\x7c\xd3\x69\xbf\x99\x49\x46\x5b\x59\xd2\x72\xe4\xb4\x5d\x29\x7a\x8c\xa2\xe0\x32\x6c\x21\x2a\xb7\xed\x52\x76\xf3\xb7\xbf\xf0\x9d\xb8\x7c\x93\x7f\x50\xa8\xa4\xe5\x6a\x1d\x89\x2d\x9b\x36\x26\x6f\xe4\xad\xd3\xc8\x65\xab\xea\x8e\x27\x4a\xbd\xd4\x1e\xb1\x5f\x14\x7d\x11\xf7\x85\x3b\xd2\x6a\x18\x61\x2c\x34\x29\x8a\xfe\xea\xf9\x73\x57\x2f\x9c\x5c\xb9\xb0\x44\x7c\xa1\xf5\x23\x76\x92\xe8\xa6\x9e\x20\x8c\x8a\x49\x29\xd2\xb3\x2f\xae\x9e\x39\xdf\x74\xfe\xe4\x9a\x05\x25\x22\xf4\xd0\x5e\x10\xc0\x92\xec\x0f\x30\xdc\xfc\xb1\xbd\x3b\xe7\xff\xc3\xba\xea\x6d\xc3\xaa\x1b\x09\x3a\x78\x6d\x63\x5e\x4a\x7d\xb0\x9d\x75\xa1\xaf\x9d\x85\xf9\x82\x8e\x7d\x5a\xc9\x3e\x5d\x67\xd6\x41\x5f\xa6\xf9\xb3\x99\xe3\x25\xed\x66\x7d\x8b\x4d\xc9\xb4\x65\xc4\x41\xf5\x4d\xff\xb2\xe4\x59\x14\x7b\xa3\xb2\x9e\x5c\x2d\x7c\xd6\xb0\xc8\x4f\xc4\x10\x6a\x5a\xca\xb4\x98\xe9\xe2\x00\xcd\xf9\xad\x3d\x8c\xd5\xff\x2d\x2b\x63\xef\x57\xc2\x3f\x0c\xfb\x4b\xe5\xed\x4b\x5f\xde\x39\x76\x34\x72\xed\x0e\x11\x3c\x70\x29\xa1\xea\x28\x55\xa1\xde\xb2\x74\xa8\x17\xb4\x13\x54\xed\xca\xa5\x25\x4b\x78\xec\x8a\x24\xd2\xd8\xd5\xc6\xb1\xfc\xc9\x27\x5f\x5f\x7e\x54\x23\xfd\xa2\x3a\x13\xec\xd3\x75\xd5\xf7\x95\x07\x5f\xe9\xd9\x5f\x2a\x21\x84\x82\x4e\x7d\x5e\xa3\x6b\xf4\x66\x1b\xc7\xfe\x6c\xe9\x94\xfa\xf1\x7c\x50\x50\x6a\xdc\x3a\xe9\xc4\xe2\x59\x3b\xa6\xf1\x89\x49\x26\x53\xa2\x04\x1b\x29\x78\x1f\x09\xe8\x80\x1f\x88\x6d\xaa\x55\xb0\xaa\xab\x27\x41\xd1\x74\x5c\x30\xc9\xde\xaf\x54\x75\xf5\xb6\x13\x69\x03\xa8\x3a\x92\xfd\xa5\xb2\xde\x1e\x81\xaf\xc1\xc6\xd5\x22\xea\x21\xbb\x8d\xcf\x45\xd8\xb8\xde\x47\x36\xd6\xaf\xdb\xb0\xdb\x4f\x60\x21\x82\xc5\x08\x03\x41\x5b\xde\xe5\x58\x78\xfd\x30\xe0\xc3\xc6\x01\x7c\x4c\x8c\x31\x33\x46\x82\x32\xaa\x56\xf0\x67\x44\x24\xa8\x2d\x27\x88\x17\xab\x3d\x6e\x74\xe3\xfd\x99\x75\xf9\xeb\x8a\xd7\x4b\x90\x62\xa5\x09\xad\x07\x95\xca\x88\xe6\x81\x24\x30\x7f\x7e\x07\xe4\x6e\xe9\x11\xfc\x42\x94\x5f\x2e\xbc\x76\x4d\x0f\x13\x29\x16\x23\xfe\x5e\xfa\xad\xc7\x71\xb1\x62\xed\xea\x82\xd5\x3c\x0b\xeb\x70\x5d\x01\x67\x63\x53\x31\x99\x31\xa9\x71\x12\xf6\xc7\x67\xc4\xf5\x38\x9f\xd3\x53\x78\x5f\xf2\x2e\x0c\xb8\x0f\x1f\x12\x47\xab\x8e\xee\x3c\xc1\x43\x28\xf2\xdc\x8d\x33\x4b\xa6\x24\x64\xc4\xa4\x27\x49\xe8\x85\xaf\x89\x80\xcd\x01\xa1\xcb\xec\xdc\xb1\x22\xa7\xa2\xa0\x4c\x02\x37\x38\x4e\x5c\xde\xb5\xfd\xca\x03\xde\x80\xe1\x80\x9c\x6d\x92\x69\x3c\xb3\x76\x61\xb5\x08\x8b\xb5\x5a\xa2\xc9\xac\x23\x81\x66\xe0\x5d\x46\xd4\xea\xa9\x6e\x18\x47\xe0\x42\x92\xc5\xe7\x01\x2b\xb7\xac\xdf\x28\xf5\x40\x27\xe2\x36\x85\x59\x66\x91\x48\x2f\xcf\x2c\xaf\xd0\x5b\x0e\x19\xb0\x2b\x67\x1d\xd8\xc6\x26\xe1\x0a\x05\xae\x60\x20\x6a\x6b\xea\x4a\xf7\xf2\x70\x96\xbc\x7a\x6a\xfe\xac\x99\xbe\x0b\x66\x49\xb8\x32\x98\x64\xe1\x35\xac\x24\x4f\x1e\xdb\x76\x60\x97\x34\xb1\xf8\xca\xfc\x3b\xfc\xa5\x0b\xfb\xce\xd7\x4a\xd0\x0d\xae\x11\x03\xa9\x79\x69\x7e\xf1\x0b\xc4\x61\xf8\x0b\xc1\xe2\xf3\x39\x71\xf3\x03\x7c\x78\x17\x58\x5a\x13\x69\x7e\x04\x53\x1c\xe1\x21\x2c\x74\x32\xff\x61\x89\xe0\xaa\x62\xcb\xb6\x88\xd6\xfd\xbd\x19\x6c\x4f\x6d\x59\x22\x88\x70\xce\xda\x08\xc7\x05\xe0\xc9\xca\xb2\x2c\xc1\xdc\x08\xe7\xa9\xca\xf2\xb2\x4a\xc9\x52\x0b\x1d\xb8\x0a\x53\x5c\xe9\x16\x1e\xbb\x91\xf1\x89\x29\x89\xe9\x12\x86\x6a\x95\xa9\x31\x69\x9b\x53\xb7\xb8\xa7\x55\xa6\x56\xa5\x56\xe0\x46\xb5\xd2\xad\xd8\x6e\x88\x84\xef\x93\x31\x71\xf1\x31\x26\x69\x74\xeb\x5c\x22\x39\x27\x25\x3f\x55\x6c\x73\x94\x0e\x3c\x59\x51\x56\x5a\x91\x25\x9d\x54\x7f\x02\x1f\x6d\x0c\x91\x90\x5f\x9c\x5a\xc2\x43\x07\xb2\xb4\xb8\xa0\x24\x4f\x82\xd9\xea\xe8\x53\xda\x23\x22\x26\xab\x2c\xbe\x82\x07\x3d\xa9\x14\xc2\x64\x26\xbf\x20\xa7\xd0\xa4\xd8\x43\x4f\x81\x97\xfa\x17\x4c\x85\xfd\x30\x05\x22\xe0\x99\xa0\xea\x60\x21\x34\xc2\x12\xd5\x1d\xbc\x9c\x2c\xbb\xcc\xf7\xb9\x41\x0b\xe6\x0d\x11\x71\x18\xec\x87\x8e\xe4\xed\xdd\xa9\x89\x5b\xa5\xa3\x9b\xb6\xfa\xcf\xd6\x5f\xc0\xc3\x5c\x66\x7e\x66\x5e\x66\x1e\xfd\xfc\xcc\x95\xbf\xa1\xa3\x1e\x0c\x13\xc1\x09\x89\x63\x62\xf9\xca\x25\xca\xfb\x3c\x9e\x6e\x5b\x82\x06\xfa\x0f\x05\xf8\x0b\x06\x50\xe0\xa7\x39\x12\x89\x79\xc5\x69\x25\x3c\xf4\x23\x8b\x8b\xf3\x8b\xf2\xa4\x7c\x45\x2e\x49\x2f\xa2\xb5\x5e\x06\xe7\xc3\x6f\x04\x8b\xce\x1a\xc1\xfd\x1b\xee\xc8\xde\x3b\x03\xd1\x08\xcf\x04\xdb\xde\xcb\x49\xfd\x13\x2e\x71\xea\x3b\x0c\xf4\x82\x1e\xb0\x00\xdc\x05\xdf\x4b\xc3\x61\x1d\x53\x64\x2c\x4a\xcb\x4d\x3e\x39\xc2\xad\x20\xd1\x18\x9b\x92\x44\x67\x64\x0c\xee\x85\xc3\x79\x33\xd3\xc5\x86\xdb\x1b\x7a\xc0\x7c\x70\x17\xe6\x5e\xfa\x10\xd6\x31\xc5\x46\x25\x2d\xcf\x86\x9b\xff\x1f\xdc\x21\xbd\x70\x04\x8f\xbf\x58\xbe\x78\x23\x80\x57\xdb\x7b\x3a\x17\xa8\x0b\x36\x10\xde\x8e\x4d\x06\x2a\xd1\xc9\x1c\x61\x8e\xe0\x3c\x3c\xe0\x18\x1e\xc5\xb9\x38\x57\x8b\x50\xed\xdb\xbd\xf1\x2d\x2d\x38\x0a\x46\x59\xbd\xac\x5e\x66\x2f\xab\x17\x5c\x61\x08\xf0\xb5\xf8\x72\x9a\x4e\x25\x04\x4d\xd7\xd2\x82\xc7\xe0\x28\xcc\x85\xb9\x6a\x84\x66\xdf\xc6\xdf\xf3\xf0\x80\x51\x38\xca\xec\x65\xf6\x22\x5c\x8e\x33\xe6\x15\x30\x8d\xd3\x16\xaa\xf6\x0d\x58\xd4\x79\x79\x05\x1c\xc5\x7a\xac\x87\x7a\xac\x6f\x69\x41\x5f\xf8\xf4\xc9\x13\x42\xa6\x6c\x59\xe2\x27\xac\xe0\x90\x05\xf6\xa7\x27\x47\x03\xc0\x8e\x01\xf5\x1e\x1e\xe0\x8b\x9f\x12\x32\x35\x64\x08\x21\x53\x36\x08\x6c\x87\xed\xea\x42\x6d\x21\x01\x15\x19\x5c\x2e\x33\x50\x10\x5d\xd4\xba\x35\xe0\x34\x3b\x12\xaa\x1f\xbd\x80\x4f\x5e\x3c\xfa\x1c\x36\x7f\x00\xce\xd0\xee\x77\xd7\x3c\x70\x86\x09\x8f\x1f\xc1\x27\x40\x3e\x82\x39\xe0\x2c\x83\x33\x4c\x7f\xf4\x08\x7c\x80\x78\x0c\xd3\xc1\x99\xdd\xff\x6d\xa3\x59\x52\x0f\x72\xe7\x57\x1c\x9b\x3f\x6f\xc5\x8a\xf9\xf3\x8e\xad\xb8\x70\xfe\xd8\xb1\x0b\xa2\xc1\x39\x39\x8b\xbb\xb0\xa2\x61\xde\xbc\x15\xfe\xf3\x6c\xd0\x0b\x36\x68\xeb\x0e\x13\xd7\xd5\x6b\x68\xb7\xae\x43\x1f\xbf\xf9\xe7\xf1\x4f\x6f\xfe\xf9\xc9\xab\x9b\x68\x70\x4e\xca\xe2\xba\x0e\x85\x57\xc2\x63\xaf\x6e\x62\x6b\xa3\x89\x03\x4f\xec\x04\x9d\xb1\x3f\xf6\xc7\xce\xd8\x19\x3d\xb1\x3f\x74\xc6\xce\xd0\x1f\xfa\x43\x27\xe8\x0c\xfd\xdb\xa8\x43\x7f\xec\x0c\x9d\xb0\x3f\x7a\xda\xe3\xf7\xf5\xb7\x63\x75\x02\x4f\x91\x75\xa2\x1d\xa0\x3f\x74\x86\x4e\xd0\x5f\x62\xd3\x12\x1d\x5a\xe7\x67\x72\x58\x88\x01\x18\x80\x85\x22\xeb\xed\x90\x88\x05\x18\x00\x01\x50\x08\x85\x60\x4b\x0b\x6c\xa9\xad\x50\x32\x0f\x54\xef\x70\x78\x35\x19\x65\xcc\xc7\x26\x3d\xdc\x51\x3b\x0b\x78\x27\x4b\xbc\x0b\xc3\x61\xf9\x11\x58\xc1\xb3\xa9\x0e\xde\xb0\x02\x66\xad\x1c\x0f\x23\x24\x35\x5c\xbb\x63\x23\xec\x6f\xab\x6b\x6b\xc0\x46\x53\x64\x93\x33\xbd\xdf\x12\xb6\x35\xe0\xdf\xd6\x6a\xb2\xb3\x03\x56\xab\xd7\x38\x78\x0f\xe7\xe3\xd6\x87\xf8\x25\x8f\x5f\xe2\xe1\x11\xf8\x1e\xce\x97\x34\x47\xf2\xf2\xc4\x13\x9e\xc5\xd3\xe8\x49\xfd\xfc\x91\x46\x57\x3d\xde\x81\x22\x54\xe0\x36\x4c\x81\xa1\x0f\xa1\xcb\x6b\x3b\xd1\xe3\x0b\xee\xf6\x2c\x5b\x4f\x3f\x84\x8e\xa7\x2f\xc9\x7a\xe4\x5e\x83\xd7\x08\x98\xc2\xc3\x6d\x28\x02\x05\xee\x80\xab\x3f\xd0\x93\x7e\x97\xd8\xe1\xe1\x89\xc5\xd7\x4f\xfc\x76\xf9\x0e\xed\xa2\x25\xc0\x4e\xd8\xf8\xea\x68\x3a\x6c\x51\x3f\x85\x2d\xae\x30\x0b\x62\xd4\x39\x10\xc3\x8e\x32\xeb\xcc\xed\x39\xc8\xb1\x07\xf6\xcf\x81\x5c\x5c\x0e\xcb\x30\x07\x73\x70\x39\x2e\xc3\x5c\xcc\x81\xe5\xb8\x0c\x72\x24\xf3\x08\x67\xe8\xf8\xb2\x17\x76\xc2\x8e\xbd\x7a\x61\x47\xec\xd8\xeb\x25\x74\x84\x4e\x2f\x5f\x42\x47\x89\xfd\x5e\xdd\x6a\xdd\xc8\x85\x9e\x9f\x70\xdc\x73\x2c\x2d\x23\xdb\x13\x57\xe0\x0a\x64\x5f\xc9\xa2\xe7\xfd\x09\xcb\x43\xe7\x2f\x1b\x74\x6e\x39\x90\x63\x9f\xcf\x04\x7d\xc4\xe3\xe4\xf1\xe3\xdd\x7a\xf4\xec\xdb\x67\xf2\x64\x7f\x7f\x79\x6a\x43\x40\x49\xbc\xdb\xd1\x80\x1b\x72\xc3\x51\xd8\x0a\x35\x6e\x7f\xf6\xf8\xa3\xcf\xcd\xc9\x0d\x76\x40\x49\xa9\xdb\xd1\xa3\xf2\x8d\x80\x06\xdc\x0a\x5b\xdd\xc6\xdd\xfb\x49\x01\xb7\xed\x2d\x57\xdc\x81\xbc\x7f\xee\xf8\xb2\xa7\xb4\x4b\x88\xa0\xd6\x3f\x37\x1b\x40\xf7\x33\x63\x19\x62\xf1\xe1\x9e\x4c\xb8\x3b\x64\xc8\x84\x09\x43\x86\xdc\x9d\xf0\xe4\xc9\xdd\xbb\x4f\x44\x58\x8b\xff\xc7\xd5\x4f\x5f\xb3\xee\x23\xbf\x49\xcb\x3c\xb7\xcc\x4c\xbb\x30\xcf\x0d\x3e\xc5\x39\x7b\xd6\xcb\x8b\xd7\xaf\x77\x4f\x4e\x5e\xbf\x7e\xb1\xbc\x7e\x8f\xfb\xc2\x33\x13\xef\x8c\x6f\xc6\x4f\xf1\x53\xb7\x36\x48\xb2\xe2\xb6\x7e\x8f\x7c\x7a\xcf\x9e\xb3\x67\xee\xdc\xb9\x77\xef\xfc\x05\xb7\x59\xf9\x1e\x95\x93\x4e\x7c\xd4\xb8\x66\x6f\x7d\x53\xd5\xc1\xf3\x7b\x6f\xfa\xd1\xf2\xb3\xf1\xd0\x13\x7a\x3e\xbb\x27\x8b\x37\x1b\xcf\xaf\xab\x5a\x43\x2f\x84\xff\xe3\x70\x32\xf6\xc0\x1e\x38\xd9\x96\x42\x0f\x98\x0c\x93\xe1\xdf\xd4\x06\x17\x55\x1f\x18\xde\x55\x98\x8f\x3a\x1f\xc6\x55\x86\x5f\xf0\x17\x03\x79\x12\x7f\x86\x9f\xd9\x1a\xf6\xb6\x81\x14\xec\xf6\x4f\x09\xe4\xb0\x09\x13\x86\x49\x5a\x05\xa5\x85\xab\xac\xe6\xaa\x86\xa9\x1b\x55\x56\x75\x55\xc3\x45\xb5\x82\x7a\x3c\xf9\x8e\x97\x68\xf5\x6d\x3d\xcb\x85\x84\x94\xd4\x44\x4a\x5a\x1f\xd5\x8d\x88\xd8\x16\xbf\xb7\x5e\x7f\xbd\xb1\xf1\x7a\xdd\x9e\x84\xc8\x6d\x22\x3c\xc0\x6b\xf0\x00\xae\x11\x35\xdb\xf6\x94\xec\xe5\xaf\x37\xfa\x4d\x0b\x8e\x5b\x17\xb1\x49\xd2\x7a\x6b\x6e\x44\xe4\xa6\x90\x84\x10\xde\x45\xad\x33\x10\x5e\x67\x17\x9d\x73\x95\x0d\xed\x1d\xd8\xe5\x6c\x8d\x81\xf8\xaa\x3b\x27\x9f\x95\x65\x11\x3e\x51\xc7\xc0\x01\x73\xf7\xa7\xb0\xf2\xc8\x93\x2b\x17\x5f\xe5\x64\x9d\x70\x63\x97\x9b\xb2\xb5\xe5\xb9\xc4\x16\x39\x2a\x5e\x7f\xc4\xf4\x72\xf3\xde\xe1\xda\xcc\xd6\x6c\xb7\xc8\x73\xb8\x42\x5d\x1c\xf1\x05\x04\xa9\xb3\xdc\x4e\xdc\xfa\xf1\xf8\xf7\x39\xf4\x59\x6a\xb9\x09\x53\x65\xf4\x32\x99\x12\xb2\xc2\x4d\xf1\xd0\x39\xf3\xd4\xfa\xe0\xb1\x34\x5b\xb3\x08\x89\xf7\x71\x4d\xd4\xca\x19\xe0\xb6\xe2\xd5\x64\xe8\xbe\xee\xc6\xcd\x9d\x77\xb2\xe9\xd3\x94\x56\x94\x45\xb0\xcb\x23\xe5\xf8\x18\xfd\x5d\xd3\xef\x69\x07\xa6\x9f\xf7\x84\xa1\x5a\xa7\x73\x3d\x66\xe0\xbb\xd8\x1f\x8f\xcc\xed\x3a\x0a\xc6\xe1\x69\xf3\xb8\x51\x30\x39\xe8\x2b\x78\xf7\xc4\xed\x5c\x9a\xad\x39\xa7\x7d\x47\xc5\x66\x85\x25\xea\xd9\xe5\xbf\x65\x81\x80\x03\x1b\x3c\x60\xb4\xd6\x15\x26\x6a\x06\x18\xad\x49\xb4\xa9\xd1\x94\x95\x25\x82\x13\x44\x01\x07\x29\xd0\x1e\x36\xc3\x19\xeb\x74\x37\xdb\x8c\xd1\x62\x8e\x02\x17\xf3\xfb\x51\xaf\x5b\x1c\xe5\x16\xf3\x06\x70\x31\x27\xb4\x38\x59\xa6\x9a\xdf\xe3\x0e\xac\xab\x0d\x0e\x0c\x5f\xb7\x36\x68\x6f\xf8\xbe\x03\xb5\x7b\xf7\x89\xe5\xb3\xb9\xc4\x68\x6d\xba\xd6\x67\xc9\x72\xf8\x53\xfd\xda\xad\xa4\x46\x9d\xa6\xf6\x3a\x7d\x82\x86\x73\x5a\x2d\x77\x3a\xfd\x74\xf2\x29\x71\x4e\x3c\x91\x6e\x4a\xca\x2d\xd0\x17\x66\xe5\x2b\xd9\xe2\xa5\x12\x7f\x18\xd7\x0d\x3c\xb1\xf7\x4b\xf7\x84\xd4\x8d\xf3\xe2\xf8\xd4\xf4\xfc\x82\xc2\xfa\xd3\x05\x45\xd2\x5d\x24\xf1\xbd\xc3\xa8\xe7\x65\x6a\xe9\xd2\xf4\x94\x65\x52\xf9\x54\x22\x2d\x2b\x23\x29\x95\x4f\x4d\xcb\x2e\x34\x4a\xb1\x37\x71\x42\x00\x0e\xe8\xda\x03\xfb\xb8\x97\xa4\x34\x6e\x8c\xd3\xa7\xa6\xa5\xa7\xa6\x2c\xda\x97\x9f\x24\x4e\x40\x62\x15\xba\xa1\x5e\xbf\x38\x6f\x89\xb2\x44\xbc\x55\x4e\xe4\x67\x15\x65\xa4\xea\x53\x8d\x69\x29\x46\x71\x52\xec\x31\x9c\x08\x8e\x38\x00\x3c\x7a\xb9\x97\x28\x75\x97\xcb\xf8\x82\xfc\xb4\xd4\x94\x55\xbe\x69\x49\xd2\x64\x70\x06\x6e\x35\xbc\xc7\x9f\x3d\x9b\x57\x74\x46\x8a\xb9\x45\xe4\x99\x72\x8b\x0a\xf8\xc2\x7c\x53\x72\x96\x54\x31\x05\xc6\x1d\x07\x4f\x70\x78\x01\x7d\xdd\x13\x0a\x16\x6f\x2f\xd5\x17\xe4\xe7\x17\x14\x1e\x0b\x49\x2f\x12\x6f\x81\xd3\x41\xe0\xe0\x3d\xfd\xa3\x2e\xda\x2c\xb4\xa0\x45\x9b\x65\x4b\xc1\xa2\xce\x52\x67\xc1\xbf\xa9\x0d\x2e\xb6\x74\x69\x9b\x4f\x8e\x33\x96\xce\xb0\x95\xc1\x4a\x13\x16\x23\x83\xde\xb8\x16\xf6\x68\xa3\xdc\x6e\xc3\x42\x58\x0c\x0c\xac\x4e\x30\x6f\x59\xe9\x36\x06\xfa\xe2\x3b\xf0\x1e\x0e\x7a\x86\xef\x3f\xc4\x81\x47\xd0\xd3\x44\x5b\x13\xb4\x3e\xdc\x00\xec\x36\x17\x47\xe3\x54\xbd\xe6\x0b\xdf\x6b\x94\x3a\x76\xaa\x08\x5b\xd4\x79\xb8\x72\x25\x2e\x01\xb2\x1f\x7c\xe2\x8e\x4f\xcd\x1e\x84\x81\x1c\x8c\xa3\x39\x2d\x3b\x14\x04\xf4\xca\xc6\x18\xa4\x70\xa2\xbb\xd6\xc7\xea\x04\xa3\x92\x61\xec\x21\x18\xf4\xcc\x5d\x75\x83\x08\x18\xa4\xae\xc5\x41\x6a\x6f\xda\xfa\x75\x14\x87\x23\x91\x47\x1e\x47\xe2\x48\xe0\x91\x87\x91\x30\x12\x78\xb0\xa7\xc8\x03\x8f\x23\xed\xf2\x84\x81\xbc\xaa\x1d\x83\x77\x5d\x2d\xed\xeb\xd5\x4d\x7f\xb0\x87\xd8\x8d\x16\x1e\x15\x4e\x2d\x50\x39\x75\x8e\xea\x9d\x26\xa5\xa9\xde\xb8\x06\x6a\xf0\xc5\x2b\x98\x81\x7d\xfe\xc2\x82\x28\x8c\x58\xf5\x6a\xfc\xa9\x0f\x4e\x3e\x19\xf7\x35\x96\x0c\xc1\x71\x43\x70\x3c\xbe\x42\x3f\x2c\x86\xb5\xf0\x71\xec\xeb\xcf\xbe\x85\xce\xf4\xaf\xc9\x65\x17\x65\x3d\x7b\xa8\xf8\x64\xd0\x99\xa1\x79\x5e\x79\xcb\x3e\xc2\x4e\x91\xe8\x1c\x8d\x0e\xaf\x4e\x02\x09\xd2\x14\xb7\x58\x98\x4d\x00\x5b\x7b\xfa\xba\xac\x3f\x78\x2e\xe7\xca\xe6\x22\x9f\x5c\x74\xce\x1a\x57\x9b\xf8\x33\xb8\xc1\xf8\xcf\xcf\x60\xdf\x4c\xfc\x64\xf8\x6c\x74\xda\x52\xdb\x35\x3d\x6e\x73\x31\xec\x77\xc3\xfd\x58\x80\xae\xda\x3d\x18\x8c\x48\xe3\x03\xe8\x06\x97\x31\x52\xed\xc2\xdb\xe5\x22\xc6\x40\x7c\x17\xf5\x35\x30\x99\x82\x81\xb8\x6f\x20\x0c\x1c\x0e\x86\x6e\xb8\xf2\x31\x46\x67\xd1\x26\x93\x6c\xe2\xb5\x14\xad\x87\xd6\x43\x4b\xd1\x36\xa9\x2e\x9a\x41\xdd\xb0\x49\x32\x95\x95\xcb\x65\x3c\x6c\x86\xd5\x8f\xe1\x7d\x18\x2c\x4d\x7c\x1f\x3b\x06\xe0\x7b\x3c\x06\xa1\x0f\x38\xc2\x70\x74\x93\x3c\xa0\xc3\x14\xf8\x38\x1d\xfc\x68\x59\x3e\x26\x8b\x79\xe0\x77\x13\x3e\x6e\x81\x0e\x34\x0c\x07\x37\xb0\x61\x05\xf1\xf0\x1e\x74\x0c\x98\xf8\x5a\x82\x0b\xd6\x81\x1c\x94\x60\x3b\x88\xc3\x09\x30\x5c\x3c\x36\x69\x4c\xed\x47\xfc\x80\xa1\x21\x7e\x63\x24\x58\xe6\x0d\x7d\xb0\x08\xbf\xd4\xe3\x65\xec\x8b\x45\xb8\x6c\xac\x38\xf7\xc1\x4f\x21\xbf\xf0\xdf\x7e\xb5\xad\xe1\x96\x04\x93\x60\x38\x38\x43\x3c\x94\xe9\x5d\x6a\x30\xf5\x9a\xd9\x0b\x36\x9a\x3b\x46\x3d\x7d\xe9\x28\x83\xce\x40\x7e\x74\xc2\x29\x46\x50\x5b\x38\x30\x04\x02\x3f\x15\xde\x11\x0f\x3f\x3e\xf4\x77\x8b\x1e\xa6\xa3\x74\x15\x87\xa1\x01\xc7\x7e\x32\x07\x3b\x89\x59\xb1\xb1\x72\x2c\xaf\xbd\x83\xdf\x62\x89\xd6\xee\x43\x09\x1c\xc0\x05\x3e\x82\x8f\xc0\xf3\x06\xce\xc1\xd1\x38\x0c\xd7\x62\x47\x0c\x5f\xef\x37\x1d\x99\x98\xd9\x74\xd8\xe0\xa8\xfe\xfd\xf5\xe8\x75\xbb\x3b\x8c\x82\xce\x30\xe8\xcb\xcf\xc1\x59\x9c\x0b\xed\xa0\xe3\x7a\xe8\xc8\xc3\xaf\xf0\x05\x04\xc3\x7d\x20\x25\x6d\x24\x89\xc4\x14\xec\x3c\x1d\xbb\xf0\xe8\x8b\xe3\xa1\x3b\x2c\x92\x0c\xce\x09\x64\xde\xfe\xec\x03\x07\xf4\x13\xcd\x3a\x6e\x62\xe8\xc8\xb0\xa9\xe2\x00\xe8\x8d\x12\xd0\x38\xec\x1a\x7d\xf0\xab\xdf\xf7\xff\xc8\x43\xbb\xef\x26\xa1\xb3\x64\x30\x7f\x69\x40\x0f\x0e\x1c\x2e\x80\xee\x54\x8b\x78\x15\x27\x83\x2b\x7a\xc2\x87\x1e\xf4\xf2\xd1\xbd\x03\x06\xf3\x48\x4e\xba\x06\xb4\xa4\x66\x99\x97\x70\x30\xb7\x00\x46\x83\x04\x3e\x3c\x7c\x02\x1f\xa3\x84\x73\x0b\x24\xeb\xba\xb7\x26\x90\x3a\xd0\xa9\xb4\x00\xd1\x36\xdd\x58\x67\x88\x11\xa0\xa1\x42\x80\x3a\xc6\xe2\x4b\x55\x96\x97\x57\x8a\x06\xd2\x1b\x42\x05\x83\xd9\xfe\xe9\x75\x8d\x60\x8e\x40\x1d\xbe\x1e\xc4\x98\x9b\x83\x04\x7c\x0d\x3a\x73\xc4\x35\xa6\x26\x40\xd8\xf6\xd4\x40\xba\xfd\xe1\x04\x22\xf4\x65\xa6\xcf\x9b\x37\x5d\x32\x58\x7e\xa5\xa6\x5f\x98\xd7\x24\xc2\x0e\x12\x3f\x80\x41\xfe\xb0\x7e\x21\x6c\xfe\x04\x0e\xcc\x80\x72\x18\x00\x29\x87\x2e\x1d\x3b\x77\xfa\x38\x6d\xc9\xe8\xd2\x3c\xee\x8a\xc7\x29\x64\xb4\xc0\x5e\x6e\xf3\x5f\x8c\xfe\x01\x3d\x83\x3f\xdc\xfc\xe9\xa2\xb0\x79\x21\xd3\x63\xc7\x37\x63\xcb\x3d\xfc\xfd\xf8\x27\x17\x97\x9c\x58\x75\x27\xea\x51\x15\xf4\xab\x3f\xfc\x26\x1f\x9c\xd4\xa0\x57\x6e\xc5\x98\xe9\x8d\x73\xd0\x0d\xdf\xa3\x61\x12\xd9\x74\xe1\x42\x93\x64\x20\xdc\xa8\xa6\x79\x17\xa6\x8b\x2e\xa8\xbc\x06\x67\x70\x98\x16\x09\xab\xc1\x41\x8d\x05\x27\x70\x05\x87\x37\x7f\x3d\x84\x76\xae\x65\x7f\x43\x9f\xbf\x7f\x82\x76\x6a\x1c\x38\x41\x47\x70\x4c\x2f\x65\x2f\x44\x1b\x88\xcd\x89\x5c\xa1\x52\x50\x11\xbc\x8f\x96\xa9\xf8\x92\xc4\xc2\xe4\xec\xa4\x9c\x14\x63\x6a\x6a\x5a\x9a\xdb\xb4\x69\x63\xe6\x7f\xb8\x86\x5e\x3d\xa4\x7f\x74\x3f\xde\xa3\x7f\xf5\x21\x2f\x69\xd8\xc1\x31\xe7\xa7\x5d\x9f\x7c\x6b\xfe\x83\xb5\x0f\x83\xbf\x4d\xba\x9c\xb1\x95\xb6\xfb\x91\x17\x33\x6a\x23\xb3\xd7\xa5\xc7\x1b\x57\xa6\xe5\x6e\xa0\x65\x4a\x99\xb6\x75\xc6\x8e\x59\x0d\x7d\xbf\xf4\xfa\x6a\xec\x7d\xef\x27\x3e\xcf\xfd\xe9\x15\x2f\xdf\x6c\x82\x76\x3c\xb4\xfb\x67\xdb\xb1\x57\xd2\xf3\x86\x9f\xbe\xfc\xea\x2b\x5a\xce\xcd\xcd\xce\x16\xb5\x75\x2a\x72\x65\xe5\xf1\x95\x09\x25\xd1\xd5\x9b\xf3\x12\x13\xa7\x4d\x73\x9b\x76\x83\xc8\xc9\xc8\xc8\x4e\xe7\x93\x93\xd2\x12\x12\xa4\xa8\xa8\xf4\xb8\xe2\xc4\x1b\x53\xdd\xa6\x4e\x23\xd2\xd3\x32\xd3\xd3\xf4\x09\xc5\x89\x05\x69\x62\xb6\x91\x48\x2c\x2e\x4e\x57\xf8\xc2\xbc\x9c\xec\x6c\x29\x2f\xef\xd2\xa5\xbc\xbc\xab\xb3\xdc\x52\xf3\xf3\x33\x0b\xf8\xa2\xe2\xfc\xe2\x62\x69\xd7\xae\xf8\xf2\xd4\x82\x19\xd7\xdc\x6e\xdc\x20\xd4\xe0\x39\xdc\x77\x31\x0f\x42\x9a\xc5\x90\x3b\x2b\xae\xce\xbd\x38\xf7\xe2\x8c\x63\x13\xeb\xe8\xbd\xe3\x3f\x2e\x1f\xc5\x8f\x1c\x19\x13\x32\x41\x9a\x13\xde\x77\xe6\xa7\x3e\xb4\x49\x8d\x32\x5f\x20\xeb\xe4\x86\xb2\x52\xf9\x58\x88\xd4\xea\x48\x86\xc7\x45\x6d\x96\xac\xa3\xa8\x4d\xbb\x62\x77\xa4\x89\xe7\x12\x8b\x2b\x4a\x2a\xb3\xb3\xdd\xaa\x77\x7d\xfe\x65\x56\x16\xfd\xf4\x29\xbc\x7b\x0e\x38\x1e\x38\xe8\xb0\x60\xd0\x53\xe9\xd9\xc0\x73\xd8\x01\x75\x7a\x64\x17\xe0\xbb\x83\x06\x89\xec\x85\xd7\x83\x07\x63\xa7\xf9\xa8\xe3\xbd\x86\xd7\x9e\x18\x2f\xa9\x83\xa8\xcf\xb6\x5f\x3e\x7a\x52\xbc\x70\xea\xda\xee\xdb\xfc\xcd\xab\x61\x4b\x4e\x49\xa7\x96\xee\x9c\x35\x4d\x8f\x22\x3a\xa2\x03\x4a\x62\xe8\xc2\x12\x23\xbf\xa1\x30\x61\x55\x46\x7c\xec\xc2\xda\xa4\x3c\x23\x1d\x7f\x62\x4f\xe6\x11\x1e\xe6\x81\x17\x0c\x81\xf9\xe0\x87\x43\x60\x30\xce\xf7\x18\xb4\x7a\xea\x14\x69\xda\x8c\xc0\x61\xc6\x0f\x69\x23\x95\x24\x63\xd6\x47\x7a\x13\xb9\xa6\x61\xf5\xd5\xf0\xa6\xe4\x1d\x9b\x32\xd6\x27\x27\x64\x04\x24\x28\x1b\xe8\x2c\xd2\xa8\x84\xe5\xc7\x8b\x7b\x26\x1e\x9b\x79\x71\xee\xc5\xb9\xd7\x56\xdc\x09\xa1\xd7\xdd\xfb\x3a\xf6\x5b\xfe\xdb\xaf\xcb\xf7\xde\x93\xee\xd4\x5d\x3b\x76\xf1\xe2\xc5\x8b\xc7\xae\xd6\xdd\xa1\xeb\xee\x55\x7c\xfd\xad\x7e\x9d\xfa\x0d\x37\xf9\xba\xf7\x99\x01\x47\xe8\x63\xbd\xba\x6e\x43\x47\xfe\x7d\x74\x8e\x5c\x33\x42\x4a\xce\x4c\x4f\x35\x26\x99\x92\x73\xe2\xf3\x63\xf2\xe2\xcb\x82\x76\x16\xd1\xf5\x3f\xfe\x5a\xf9\x88\x6f\xf9\x75\xf3\xaa\x9f\xa4\x3b\xeb\xaf\xaf\xb8\x37\x93\x4e\xcf\xcb\x33\xe6\xf3\x65\xa5\x65\x25\x25\x12\xfb\x63\x74\xf5\xb6\xd2\xaa\xe8\xca\x36\x05\xb9\x1f\x24\xdf\x8c\x82\x02\x55\x80\x99\x50\x07\x26\x57\xf8\x1b\x7e\x83\xa7\xf0\x04\x6e\x3e\x66\x7f\x34\x90\x1d\x2f\x73\xd6\x28\xfc\x4b\x5b\x0a\xa7\xf0\x14\x4c\xda\x5c\xb2\x2e\x6e\xd7\x3a\x1a\x99\x3f\xa0\x19\x8f\xa8\xc3\x78\x75\x18\x64\x43\xf4\xd1\xbd\xd2\xde\xa3\x11\xb5\x21\xb1\x34\x04\x00\xc5\x45\xed\xec\x99\x3b\x23\x75\x46\x8a\xc7\x4a\x25\x82\x66\x2f\xe4\x26\x2b\xb9\xc7\x73\x4f\xe4\x82\x4b\xc5\xce\xb5\x3b\x83\xa6\xa1\x57\x42\x68\x42\x68\x45\xea\xb6\x2a\x9a\xfd\xb1\xa6\xf2\xf0\x89\x9d\xd7\x68\xf6\xc2\xce\xa6\xf2\x27\xb1\x5b\x69\x4d\x54\x3f\xe1\xd4\xc7\xd4\xab\x3e\x10\x8d\x7f\xe3\x6b\xfc\x04\x37\xe2\x02\x11\x4e\x6f\x24\xae\xc3\x42\xe8\x27\xcb\x7a\xe8\x97\x84\x1d\x37\x4a\xc8\x52\x38\x2f\x55\x8b\xf2\xd5\xfa\xe9\xd9\x1f\xb5\x69\xea\xb9\xcd\x30\x15\x0e\x8a\x05\x89\x85\x09\x45\x49\xb4\x7c\x73\xe2\xcf\x1f\x8a\x10\x05\x11\x84\x8c\xdc\x2b\x68\xa7\xb7\x7a\x45\x72\x30\x1b\x96\x1e\x06\x3e\x57\xc4\x61\x14\x36\xe3\xd3\x33\xb0\x4c\xef\x02\x5e\x8c\xea\x6b\xb7\x7a\xf1\x82\xd7\x17\xfe\x5d\x45\x03\x3a\xf8\x47\xf0\x61\xe0\x9a\x80\xba\x16\x32\x94\xd1\x74\x2d\x54\x28\x83\x3a\xca\x5f\x88\x10\x36\x0b\x46\x81\xfa\xd6\x06\xe3\x60\xa7\xd0\x43\x10\x4b\x99\xb2\x2a\xc9\xaa\x40\xc3\xff\xe6\xd3\x19\x03\x7a\x73\x06\x4b\xa2\x45\x89\x10\x48\xab\x4e\xf3\xe5\x20\x02\x66\x30\x18\xf1\xff\x2e\x08\xfb\x6f\x37\x4c\x4c\x3a\xa3\x7a\x41\x57\xa6\x55\xd1\x22\x3e\x10\xc0\x8b\xb1\x28\x26\xc6\xd2\x02\x1e\x5c\xdb\x42\x0d\xf4\x01\x1f\xdb\x8c\xe5\x63\x0f\x31\x57\xe2\xbe\xe4\x54\x82\x3d\xca\x9c\x3b\xfa\xd8\x36\xf0\x81\x0f\x18\x98\x8d\x3e\x38\x1b\x7d\xa0\x54\x00\x1f\x98\x0d\x3e\x38\x1b\xea\x04\xa2\x35\x18\xeb\xff\x25\x69\x20\xde\x53\x6f\xb7\xc5\xa9\x2b\x59\x72\xca\xad\x8d\x88\xe6\xa3\xf9\xb8\xe1\x46\xd8\x68\x23\xd2\x80\x0d\xa5\x09\x5b\xe5\xd2\x12\x77\x55\x51\x15\xc2\x80\x41\x56\x9f\x0f\x84\xe3\xb6\x8e\x6e\x65\x20\x85\x31\x98\x13\x07\x08\x06\x32\x71\x20\x63\x70\x4e\x84\x2a\x46\xed\x08\x55\x8c\xa5\x63\x34\xe3\x62\x4d\x30\x10\xcb\xe1\x99\x00\x11\xa0\x38\xa9\x8a\xea\xcb\x2d\x5b\x9e\x57\xe4\x2f\x59\x3f\xc8\x15\xcc\x1f\x50\x49\xfe\xcb\xd3\x97\xf1\x96\x66\x67\x20\x18\x3c\x08\x9b\x71\x33\x1c\x84\xd9\x0c\xa4\x32\x12\x46\x38\xe3\x10\xe4\x90\xc3\x21\xf0\x3d\x03\x7e\x30\x18\x06\x83\xdf\x0c\xa6\x97\xe0\xf2\x9a\x31\x2b\xa0\x38\x19\xc8\x3b\x06\xe7\x07\x1c\x76\x83\x6e\x44\xd5\xe6\xb0\xa2\x30\x5e\x53\x9a\xc8\x41\x02\x0c\x12\xa4\xe9\x5a\x33\xe5\xc9\x48\xa8\x0c\x10\x60\x0a\xb3\x63\x47\x51\x55\x95\x04\xdd\xa0\xdb\x9f\x82\x7b\xeb\xaa\x56\x0f\x4e\x53\x72\x05\x55\xa1\xd4\x66\xd5\x97\xd3\x9a\xc1\x17\x15\xf4\xd5\x14\x32\x2c\x2c\x69\xf3\x66\x09\xbb\x61\xb7\x67\x82\x3b\x74\xc3\x6e\xe0\x27\x18\x08\x6f\x18\x29\xb8\x40\x5d\x85\x3d\x46\x9f\xda\xd0\xa4\x36\x37\xa9\x0d\xf6\xd0\x35\xf6\xf0\xa6\x9b\x4b\x36\x65\x47\xa5\x68\x1a\x9a\xdc\x34\x0d\x4c\x31\x05\x31\x72\x4c\xaa\xbb\x55\x87\x0a\x11\x9e\x1c\x13\x1e\xaa\x37\x58\x12\xa9\xc8\xe2\xa8\xca\x04\x31\xb5\xb8\x24\xa3\x94\x2f\x2c\xcc\xca\x2d\x94\x54\x0d\x4c\xaa\x86\xa6\x8a\xd4\x0a\xb9\xa2\xc0\x5d\x75\x14\x88\xed\x4a\xc5\xf6\x9d\xfa\x08\x81\xaa\x49\xdc\xba\xa5\x44\x34\x58\x34\xe4\x39\xb5\x19\xb7\x10\x06\x64\x28\xad\x19\xb6\x10\xda\x6b\xcb\x61\x4e\x6d\x80\x90\x36\x50\x03\x86\x10\x31\x02\x2c\xe7\xec\x47\x06\xe7\x37\x94\xbd\xcc\xe5\x38\xa3\x2a\xb0\x95\x69\x64\x0c\xce\x8f\xba\x34\x32\xad\xaf\xbb\x4c\x12\x24\xf8\x41\x48\x28\x48\x2c\x4e\x13\x55\x05\x15\xc2\x98\x9b\x67\xca\xe3\x3f\x66\x0c\x44\x23\x55\x92\x5a\x9c\x98\x2f\x6a\x0a\x28\x44\x76\x46\x7a\x56\x3a\xef\x52\x53\x13\xe9\x68\xd6\x01\x30\x66\x9d\x59\xc7\x41\x08\xf3\xf6\xf7\x46\xeb\x01\x47\xb4\x14\x9b\xe8\x85\x47\xf0\x0d\xce\x03\x17\x1c\x07\x9f\x62\x7b\x31\x14\xd7\x78\x2f\x9e\xe1\x93\x90\x98\x90\x94\x1b\x43\x03\x2d\xe4\xc6\x96\x27\x56\x64\xd7\xe5\xec\xc9\xdb\x95\x07\xde\x87\xa0\xcf\x37\x40\x02\x49\x27\xdc\xbc\x9b\xd6\xcc\xab\x29\x6a\x0f\x38\x02\x6f\x24\x97\x9a\xb6\x35\x42\x8a\x3d\xa0\x94\x0e\x14\x58\xce\x80\x4e\xf7\xc8\xde\xee\x38\x41\xd5\x75\x79\xbb\xd3\x14\x55\xd9\xcd\xc0\x3f\x5a\x0f\x38\xaa\xa5\x88\x32\x65\xef\xc3\x51\xfc\x67\x2b\x63\x4d\x40\xd9\x40\xbe\x70\x94\x2d\xb6\x9b\x0c\xfe\xe0\xb4\x9f\x29\x55\x81\xb3\x84\xfa\x84\xd2\x14\x3c\x43\x68\x0a\x9c\xe1\x64\x4a\x55\xf0\x8c\xa6\xa0\x1d\xae\x2a\x96\x77\x38\x7b\x46\x7b\xf2\x5f\xe4\x27\xce\xea\xdb\x72\x7b\x3d\x97\x1a\x03\xe1\x1d\xe5\xf8\xd0\x40\x2e\x76\x32\x90\xfb\x2d\x39\x5c\x11\x04\x8e\x02\x47\x1c\x99\x87\x91\x05\xe8\x89\xec\x48\x2c\xa7\x2b\x8f\x1d\x55\x8e\xf0\x0f\x0f\x2e\xe9\x9f\x2c\xa5\x7f\xba\x66\xc4\x64\x74\xa0\xd1\x61\xd2\x7c\xbf\x20\x7e\xd9\xca\x1f\xe0\xa3\xd5\x52\xc2\x99\x08\xe8\xbc\x0e\x16\x87\xc0\xcc\x8f\x1f\x23\x9b\x30\x37\xfd\xa3\xc5\xdd\x3c\x47\x4d\x1a\x35\x7e\xe4\x84\xaf\xfb\xb8\x9d\x6f\x3e\xb6\xa3\x84\xbf\xd4\xe8\x85\xe3\xcf\x48\x27\x70\xa8\xfd\xe7\x45\xe3\xf8\xeb\xdf\x0d\xf9\x9d\x87\xfe\x30\x0b\xba\xc3\x51\x08\x93\x60\x2d\xec\x01\x27\x08\x29\x80\xc1\xb4\x0b\xea\xa0\xbd\xc1\xf9\x36\x7c\xf2\x33\x03\xe7\x05\x6d\x5e\xeb\x4b\x0e\xef\xe0\xe7\x78\x07\x3e\x87\x50\xf3\x3b\x18\x0a\xe7\x08\xb3\x0b\x89\xa1\x78\x8e\xb0\x21\x47\x98\x75\xcf\xfb\xc2\x6c\x28\x81\x08\x57\x19\x1a\xa0\x01\xde\x3d\x62\xe3\x75\xd0\xc0\x5e\x80\xf3\x82\x95\xc6\x66\xee\x77\xb2\xb1\x85\xa8\x27\x1b\x3d\x88\xdf\xc9\x92\xb5\xde\xc3\x09\xf6\xc7\xbd\x48\x86\x85\x75\xfd\xbc\xeb\x9c\xb0\x1d\x7b\x81\xf4\xfe\x81\xc0\x42\xec\xc2\xcd\x30\x06\x7d\x22\x8d\xa4\x52\x12\x52\x8b\x44\x88\x21\x57\xa1\x8e\xc0\x4f\xb5\xf7\xc8\xa8\xd4\xcc\x2a\xa3\x08\x7d\xe2\x88\xa1\x9a\xef\x13\x8a\xbd\xd0\x5c\x40\x54\x65\xe7\xe5\x57\xeb\x55\x57\xaa\x30\x49\x4e\x12\xc7\x80\xae\xe5\x1e\x09\x1f\x3f\xbb\x03\xe3\xa0\xfd\xeb\x0d\xe8\x29\xe2\xb8\x48\xa2\x29\x2b\xa6\xdc\x9f\x57\xff\xb6\xde\xe1\xf0\xf5\x63\xf2\x8e\x42\x54\x65\x17\xe6\x56\xeb\x55\x92\x2a\x4b\x52\xe2\x73\xc5\xe1\xdb\x6a\x5f\x11\xb0\x5b\xab\x24\xa3\x92\x8d\xd5\x99\xe2\xc5\x64\xc2\xa5\x06\x07\xc2\x1c\x18\x0e\x1f\xc0\x40\xc1\x3c\x89\x83\x76\x83\x7f\xc6\x76\x9f\xce\x8f\x58\xb5\x46\x44\xc3\x6f\x38\xed\x32\x2e\xc9\xff\x5b\x5d\xe7\x06\x3f\x8d\x25\x46\xdc\x9c\xf2\xf0\x87\x9b\x37\x7f\x78\x38\xe5\xe6\xf0\xd9\xf3\x83\x16\x85\x8b\x1a\xf1\xfd\xe6\xdc\xe8\x84\x8c\xcd\xee\x48\x6b\x55\xb8\x38\x15\xa7\xcc\x42\xde\xd3\xfd\xc8\xea\xf9\xdb\xe7\xf0\xd8\x6e\xf0\x60\x6c\x37\xea\xd4\xe4\x9b\x6b\xa5\xd4\x90\x8c\xe0\x60\x3d\xde\x06\x33\x2a\xea\x74\x75\x06\x98\x41\x81\xdb\xfb\x32\xea\x53\xf6\x8a\xd7\xf7\x9d\xb8\xf9\x8d\xde\x60\xa9\xc5\x45\xdc\xc3\x9b\x37\x1f\xfe\x70\x73\xca\x88\xe1\x53\xa6\x0c\x1f\x31\xe5\xe6\x0f\xa2\xf9\x3c\x02\xd7\xaf\x1f\x4e\x4f\x9d\xcb\xcf\xc5\xe9\x05\xbf\xf7\x93\x62\xcb\xe5\xda\xf2\xb2\xb2\xb2\x5a\xb9\x2c\x8e\x9e\x75\x19\xb8\xc8\x5f\xf8\x5f\x80\xab\xb9\x72\x59\x6a\x03\x96\xc7\xca\x9b\x62\x63\xe9\x4c\x58\xc1\x0d\x9f\x72\xf3\x87\x87\xb6\x3e\xb7\xd1\x1c\x21\xb9\xd4\xa8\x69\x70\x57\xed\x08\xbf\xbb\xde\x36\x90\x91\x06\xcb\x22\x68\x66\x1f\xb1\xb7\x6f\x9b\x37\x73\xe0\x09\x61\x50\x0b\xeb\x55\xa6\x94\x96\xd5\xae\xf2\x6a\xad\xa3\x68\xed\x48\xd6\x02\x7f\xe2\x9b\xcf\xef\xe1\x76\x74\xc5\xd1\x18\x9a\x8b\x8f\x73\xb0\x18\x26\x61\x15\x14\xf6\x81\x8b\x48\xa9\x5d\x7e\x86\x31\x7f\xd1\xea\xbb\x14\xfb\x08\x4f\xe2\x72\xeb\x88\x98\x74\x75\x25\x6d\x31\x83\x0f\x09\x43\x36\x40\xcf\x31\x20\x88\x50\x85\xbd\x31\x1f\xba\xe3\x65\x5e\xcb\xc9\xc2\x83\x9a\xeb\x3c\x6d\x30\xed\xa2\xd6\xa1\xee\xb0\xfd\x93\x8c\x53\xbd\xf3\x5b\xab\xc8\xc6\x85\x8c\xfa\xda\x00\x0e\x94\x59\xa7\xe9\x38\xd5\x6e\x9a\x66\x77\x4a\xc0\x81\xdd\xff\x01\x69\xa0\x96\xc3\x35\xc1\xa0\x7a\x2f\x61\x30\xc2\xd0\xde\x01\x22\x40\x12\x6c\x62\xc8\x5f\xe6\xfd\xe0\xab\xfe\xf1\x97\xa3\xfc\x97\x81\x70\x6f\x71\x32\x90\x03\xc1\xc4\xa1\x8c\xdd\xb0\x02\xfb\xe1\x21\x5e\x9b\x86\x00\xa0\x4e\x53\xa7\x81\x3d\x85\x6d\x90\x8d\x3c\x46\x42\x2f\x09\x83\xb1\x33\x01\xdd\x7b\xe2\xf0\x47\x38\x9e\xc7\xf3\x98\x86\x69\x78\x1e\xcf\x41\x1a\xa6\xc1\x79\xf0\x81\x71\x7f\x80\xd7\x1f\x12\xac\x47\x27\x42\x3b\xaf\x76\xe3\xcc\x5e\xaa\x40\xc0\x97\x38\x1c\x8f\x83\x1f\xbe\xfe\xaf\x32\x99\xa2\xf6\xd0\x7a\xa8\x29\x2a\x69\x57\x96\x1e\x41\x3f\x09\xa7\xc0\x9f\x1c\xb8\x24\x81\x2f\x3a\xf1\x68\xc0\xd7\x2d\xe0\x45\xda\x58\x83\x6f\x94\x63\xbd\x81\x6c\x74\x32\x10\x85\xe6\x5b\x1c\x3c\x56\xf7\x13\xd6\x16\x72\x00\x7a\x10\x5a\x3f\xab\xc4\x59\x62\x20\xc6\x80\x2b\xcc\x31\x84\xf5\x05\x65\x70\x3e\x5a\xcd\x69\x9c\xd6\xaa\xee\xc1\x27\x84\xf9\x05\x85\x33\x80\xe6\x5a\x63\x30\x06\x55\xed\x16\x61\x6e\x21\x5d\x6a\xcc\xca\x5b\xb9\x63\xf4\x29\x18\x0d\xff\x08\x66\x9d\xba\x83\x03\x86\xe9\x02\x0c\x13\xcc\x5d\x61\xd0\x19\x75\x66\x67\x78\x47\x80\x49\x0c\x55\xb3\x21\x3d\x5e\x04\x77\xaa\x60\xcf\xde\xbc\xba\xc3\x07\x62\x0f\xf1\x15\xdf\xe7\x6e\x97\x60\x35\x25\x33\x9b\x03\x63\xd7\x05\xad\x2c\xf7\xe7\x37\x6c\xc8\x48\xdb\x28\x55\x52\xd5\x4a\xe9\xd6\x1a\xbb\xef\xb5\x90\xb0\xb0\x90\xc8\xd2\xa8\xea\x64\x51\xe3\xa9\xf8\x0d\x79\x91\x12\x4c\x62\xe0\x1d\xc1\xea\x8c\x3a\x70\x86\xa9\x8c\x35\xd5\xac\x83\x66\xaa\x45\x10\xb1\xd9\x6c\xb7\x48\xaa\x89\x84\xa7\xc2\x5b\x6b\x64\xfa\x95\x79\x03\x87\xcd\xe0\x9b\x9c\x1f\x9f\x95\x94\xe6\x9e\x94\x96\x96\x94\xa0\x47\x5d\xeb\x0b\xaa\xfe\xdc\xae\x2f\xb7\x5f\xa2\xc1\xe1\xcc\x59\x70\xba\xc3\xbf\x21\xbd\x77\xdd\xf1\xfb\x91\x87\x62\x61\xe8\xe3\x6e\x6d\x86\x48\x5d\x49\xf4\x9c\x84\x83\x50\x9c\x29\x75\x5d\xbc\x10\xdb\x4d\xe6\x3f\x20\xa1\xdd\xfa\x5e\x0f\xf1\x1d\xfe\x3f\x16\x08\xf0\xce\xcb\x87\xd0\x6e\x8f\x04\x1a\x79\xeb\x2c\xb6\xeb\x7a\x5a\x42\xf1\xea\x6d\x1c\x04\x9e\x7c\x8b\x07\x1c\x17\xc0\x97\x81\xe6\x4f\x05\x6c\xee\xcd\x78\x78\x50\x13\x17\x82\x13\x38\x2c\x92\xc2\x2f\x6d\xfc\x32\xf8\x1c\x6d\x7e\x81\x3a\x32\x21\x3f\xa9\x28\x4d\xcc\xcc\xcb\x37\xe5\xf1\xf9\x79\xd9\x39\x79\x12\x34\x83\x2f\x51\x94\x97\x5f\x5c\xac\x2f\x4e\x2b\x4e\xca\x13\x5d\x6a\xcc\x3a\xd8\x96\x29\x18\x9c\xe3\xcd\xe5\xdc\x57\x9f\x5c\xf6\x16\x65\xcc\xc7\x6d\x90\x2f\x53\x5f\x5d\xbe\x7c\x5f\x82\xc9\x5d\x70\x2c\x76\xc5\xae\x38\xae\xad\x04\xa7\x58\x74\xea\x44\x99\x82\x71\x60\x87\x4a\x6a\x00\xea\xff\xfd\x00\xd1\x02\x9e\x6a\x01\x0c\x80\x3c\xf0\x74\x94\xc1\xd3\x40\x34\x83\xe7\x73\xf0\xfc\x0b\x3c\x9d\x0c\x64\x88\x3a\x8d\xfb\x60\xd8\xb0\xf7\xc5\xd6\xbd\x24\x76\x43\x0a\x48\x9b\x28\x02\xf6\xf4\x56\xd3\xc6\x45\x67\xa4\xba\x90\xb3\x72\x5d\x5d\x5d\x9d\x7c\x36\xa4\xce\xef\xc2\xb4\x83\x13\xab\x68\xf0\xba\x07\xc3\xde\xc0\x14\x1e\x72\x61\x39\x2e\xc7\x9c\x85\x29\x8b\x62\x97\x48\xf1\x01\x35\xcb\x1b\xe2\x68\x63\x61\xa1\xa9\x90\xaf\xaf\xdb\x5a\x5f\x24\x15\xd5\x15\xee\xcd\xdb\x4b\xdf\xd9\x78\x7e\xf2\x48\x3d\x78\x76\x81\x0f\x91\x06\x01\x3d\xf7\x89\x70\x39\x04\x4b\x21\x0d\x6f\xf1\x58\x86\x31\x38\x0a\x33\x87\x4b\xb8\x60\x3d\xf6\xc3\xd1\xb8\x42\x8f\x9b\x60\x3a\x4e\x87\x48\xd1\xb2\x97\x84\xd9\xd0\x1f\x3c\x61\xb6\x04\x39\x5d\x80\x5c\x0b\xed\xa6\xff\x26\x86\x1f\x58\x54\x14\x18\x1e\x18\x9e\xbc\x78\x7b\x20\x7d\x7a\xd2\xf6\x8f\x86\xeb\x3f\x0c\x1f\xb9\x78\x92\x18\x1e\xa8\x2c\x3a\x10\x41\x27\x97\x96\x67\x94\xf3\x32\xb5\x63\x7b\xf1\xb6\x72\xa9\xe9\xf7\x7d\xd0\x0e\x48\x3d\x28\x5d\x60\xc8\x12\xf0\x1c\x02\x5d\xc4\xf0\x83\x8b\x95\xc0\xf0\xc0\x88\xa4\x45\xdb\x03\xe9\x3b\xef\x1f\xc6\x4e\x36\x45\x4c\xb7\x0a\x3b\x4d\xec\x26\x86\x07\x16\x2d\x3e\x10\x6e\xa7\x52\x66\xa7\x52\xb2\xad\x5c\x7a\x02\xef\x9d\x02\x4f\x18\xa2\x77\x41\x05\xae\x1a\x9c\x6b\xe0\x82\xe3\x41\x03\x71\xd2\xc9\x40\x7c\x1f\xcf\x41\x07\x8f\xe7\xd8\x01\x3b\xf4\xed\x8b\x1d\xf0\x9d\xe7\x7d\xa1\x03\x74\x68\x79\x0e\xef\x88\x18\x07\xfb\x39\x98\xb9\x05\x96\x68\x01\xd0\x5f\xc4\xcf\x5e\x6e\xfc\xf1\x96\xfe\x66\x13\xb4\x83\x1e\xa2\x0c\xdd\xe5\x7d\xab\x45\xdc\x0b\x33\x2b\xcf\x9d\x07\xe1\x28\x0c\x85\xa1\x38\x18\x12\xb4\x0f\xb5\x0f\x71\x14\x16\x62\x1e\xe6\x42\xbb\x9e\x70\x12\x45\x11\x4e\xa2\x00\xba\xb9\xe8\xa4\xc7\x76\x48\x8e\x45\x0f\x51\x46\x0f\x79\xfa\x65\xb1\xf6\xb4\xbc\x5f\xd6\xef\x0b\x85\xa1\x36\xe1\x3a\x04\x47\xce\x5f\xf0\x83\xd6\x41\xdd\x03\x23\xc1\xa5\xee\xcc\x53\x31\xb2\x21\xe1\xcc\x59\x3d\x0c\x06\x06\xba\x40\xbf\xad\xa2\x4b\x80\x60\xf6\x05\x9d\x93\xd9\x17\x5e\x73\x1f\x31\xa8\xf4\x13\xd4\xe6\x45\x02\x28\x73\x18\xad\x99\x52\x7d\xbb\xfc\xbf\x30\x1d\x34\x70\x5d\x99\x68\xbb\xb0\x6c\x97\x84\x22\xca\x84\x16\x88\xe0\x80\x11\x34\x5d\x17\x60\x04\x97\x55\x8c\xa5\xd9\x4e\x4e\x6b\x6e\xab\xaa\x36\xbf\x25\x67\xaf\x6a\x9b\xe4\x2d\xcd\x6d\x0e\x37\x2d\xcd\x65\x02\x36\x40\x04\xa7\x36\x43\xbc\xf0\xa9\xa0\x35\xf7\x66\xb4\xe6\xee\x82\x4b\x4d\xc4\x5b\xaf\x15\xcf\x18\x27\x03\xf9\x10\x74\x9c\xc1\x3c\x89\x0c\xc4\x1b\xc6\xcd\xf9\x9b\x4b\xe2\xdc\xe3\x4b\xaa\x52\xaa\x78\xa8\x11\xaa\xaa\x0a\x4b\x4b\xa4\x92\xb2\xfc\x2a\x63\x15\x8d\x3a\xb8\x22\xd4\x67\x6c\xdc\xb1\x96\x47\x05\x75\xa4\x8f\x20\xb6\xb9\x99\xa1\xec\x47\xa8\x50\x6b\x37\x86\x05\x67\x48\x43\xad\x15\x84\x81\xdc\x47\x6a\x6b\x2d\xbe\x1c\x04\xc2\x73\xe1\x90\x20\xa2\x42\x41\x80\x00\x0a\x05\xae\x4c\xdb\x71\x9b\x95\x49\x84\xda\x00\x8a\xda\x6c\xeb\x4e\x03\x44\xd8\x4e\xd9\xc9\x40\x25\x9a\x15\x7b\x98\xd5\x34\xe6\xf3\x39\x77\xa5\x72\x12\x28\x6b\x5f\x62\x56\x71\xe3\xd2\xab\xbc\x51\x20\xaf\x36\x9e\xbc\x52\x2c\x01\x65\xee\x4b\x94\x93\x40\x33\x77\xe7\x7c\x3e\x41\x32\x58\x56\x59\x1b\x38\xa3\x49\x36\xf2\x6b\x37\xec\xdc\x97\x29\x05\xab\x5e\x99\x07\x76\xed\x3d\x90\xe3\x7e\x20\x67\xef\xc6\x9c\xc0\x7a\xcd\xcb\x2d\x27\x70\xe3\xba\xc0\x4c\x5a\x1d\xd0\x04\xf3\x19\x55\xa7\x79\xc1\x7c\x06\x5e\x6b\x23\xb8\xb5\x99\x1b\x42\xd7\xda\x2b\x07\xe6\x6c\xdc\x9b\x73\xa0\x5e\xf5\x72\xcb\x39\xb0\x77\xd7\x81\xcc\x03\x99\xbb\xd6\x65\x06\xd2\x06\x5c\x6c\x3e\xc6\x7d\x59\x76\xbe\xe1\x32\x0f\x23\xc9\xc1\x0c\x34\x0b\x30\x92\xbc\x7c\xde\xdf\xa7\x4c\xfa\x55\x1b\x48\x80\x1b\xd9\x53\x9d\x49\x40\xfb\xd0\xee\x0f\xb1\x03\x8f\x23\x6d\x5a\x48\x0a\x83\x23\x49\xec\xd0\x7d\x04\xb6\x0f\x95\x7a\x6a\x33\x6d\x58\x2e\x35\x76\xdb\x4e\x05\x1a\xda\x26\x0e\x4b\xb8\xaa\x70\x58\x40\x36\x81\x42\x40\x01\x69\xf6\x85\x2c\x2e\xbb\xc8\x58\x94\x56\x48\x17\xa4\x25\xe7\x25\xf1\xd8\x04\x3c\x83\x05\xb6\xdd\x77\x64\x6c\x7c\x52\x5c\xa6\xf4\x29\x46\x64\x26\xe5\x24\xe5\xa7\xb8\xa7\xe6\x2b\xe9\x45\x3c\x34\x91\xd3\x51\x21\x6c\xe5\x09\x49\x71\x19\xb6\x72\xd8\x2d\xbc\x2d\x19\x8d\xd7\x61\xb7\x50\x94\xae\xf0\xb0\x89\x2c\x2b\x2d\x2a\xcb\x95\xbe\x87\xef\x6d\x6d\xfd\xa7\xa4\x88\x87\x88\xff\x2d\xf9\x8e\x2c\x2f\x2d\x2a\xcb\x91\x2e\x41\x44\x4e\x51\x66\x51\x5a\xa1\xfb\x7f\x7a\xd2\xd6\xcb\xef\xc8\xf2\x12\x1b\xf2\x25\x88\x20\x6c\x0f\xa9\xab\x81\x74\x06\x57\xc7\x37\x06\xa2\xaf\x93\xf9\xa1\x1a\xc5\x99\xf0\x1c\x21\x53\xd0\x07\xfa\x10\xd8\xc7\x2c\x73\x32\x95\x85\xe7\xa0\x37\xf4\x26\xb0\xbe\xf5\x32\xa7\x02\x85\x85\x58\xd8\xff\x57\x68\x86\xfb\x84\x4c\x61\x33\xdc\xff\xf5\x57\x28\xc4\x42\x42\x05\x4a\x5d\xa9\xad\xc4\x2f\xf1\x4b\xf8\x12\xbf\x24\xa0\x10\xbe\xe4\xcc\x0b\xb1\x16\x66\x69\xbc\xc6\x63\x2d\xce\xb2\x2e\xb4\x2e\x84\x5a\x9c\xa5\xf2\xa2\x4c\xa9\x3c\xd4\xc2\x2c\xf3\x42\xc9\xc5\x9a\x00\x12\xa3\xce\x06\x0f\x27\xf5\x57\x20\x38\x99\x82\xe7\x14\x8c\x45\x6f\x02\xc7\xaa\x07\x38\x78\x4e\xc9\x6f\xb3\xdd\x10\x38\x50\x41\xd5\x0e\xaa\x87\x08\xeb\x22\x0a\xcf\xc1\x59\x74\x40\x07\x95\xd6\xda\x13\x32\xa5\xd1\x5a\x7b\xfb\x52\xa2\x73\x70\xd6\x56\xac\xda\xd0\x6c\xb2\xf3\x36\xc1\x87\x69\xb5\x3b\xca\x56\x6c\x9b\xab\x6c\x87\x58\x95\xb6\x2c\x3b\xce\xc1\x28\x80\xf2\x25\x63\x55\xcc\xca\x97\x8c\x45\xb1\x2a\xdc\x0a\x61\x1b\x23\xb2\x75\x89\x1e\x96\x66\x8e\x35\x38\x0c\x12\xd0\x8b\x8c\x8a\x4e\x8a\x49\x90\xd8\xba\xc4\xd6\x06\x83\x25\x91\x48\x49\x4c\x8f\x8f\x83\x35\x0c\x78\x91\x5b\xab\x8b\x2a\x4a\x24\x4b\x43\x84\x40\x14\x16\xe7\x95\x96\xe9\xad\x5e\xd8\xcc\xad\x10\x44\xd6\xe0\xf0\x13\x53\x83\x33\x0d\x64\x58\xa6\xf0\xb7\xf9\x2e\x27\x53\x32\xd5\x13\xaf\x24\x6f\x28\x5a\xb7\x7d\xb3\xbb\x59\xb5\x32\x04\xfe\x60\x91\x39\xf8\xa1\x55\x26\x6c\x85\xf0\x83\x45\x26\xac\x2f\x54\x95\x4b\xdc\xbb\x4c\x4e\x5c\x87\x0b\x35\xd5\x4d\x56\xfd\x29\xcb\x9b\x2e\xb6\x72\xeb\xbe\x56\xd9\xac\x9a\x99\xed\x55\x45\x7b\x93\x77\xbb\xf7\x84\x2b\x1c\x2e\x54\xd5\x36\x64\x77\x1b\x36\xa1\xfa\x93\x2e\x35\xea\xc7\xb0\xd7\x51\x6d\x68\x71\x52\x75\x66\xfb\x0b\x0b\x2f\x8c\xa0\xcc\x23\xf0\x11\xb7\x6e\xd2\x88\xcd\x5e\x3c\xae\x34\xe1\xc8\x6f\xd0\xf1\x85\xa9\xc5\x0d\xe8\x41\x30\x66\x24\xcc\xcd\x7a\x9c\x75\xb7\xe0\x71\x1d\x3d\x80\xd2\xbe\x81\x47\x9c\x4d\xe5\xc0\x08\x4a\x55\xea\x39\x75\x94\xd6\x03\x9e\xbf\x55\x1c\x9f\x6b\xa3\x90\x3d\x88\x1d\xae\xbd\x2f\x7e\x3a\x7d\xed\xa8\xa1\x7a\x5c\x05\x0b\xf1\x63\x30\xc2\x47\xd0\xfd\x1b\xa0\x1e\x88\xd5\xa6\x6a\xb9\xba\xba\x5a\xae\xee\xd0\x1d\xa9\x07\xd0\x7d\x34\x7c\xc4\x83\x11\x16\xc2\xc7\xb0\xea\xf1\xda\x6f\x3f\x6d\x92\xae\xbd\x3e\x08\x1d\x80\xd5\xbb\x84\x08\x90\xf6\xef\xab\x1a\x56\xed\x0e\x3a\xbb\x1e\xc9\x43\x9e\x3a\x14\x7e\x03\x1e\x74\x4e\x6a\x89\x99\xe0\x30\x0f\x75\x90\x47\xaa\xac\x33\xe6\x21\x0b\x79\xa4\xd9\xa4\xe9\x38\xfc\x4d\x26\x51\x07\xbf\x51\xaa\xce\xd9\xea\x85\x3a\xb3\x97\x0d\xc3\xea\x85\xac\xd9\x8b\x04\xde\x1a\xca\x25\x26\x27\x27\x8a\x06\xec\x4d\x26\x26\x2b\xc5\x92\xc1\xf9\x6b\xaa\x58\x51\x8a\xc5\x7a\x52\xb5\xdd\xfe\xab\x61\x0c\xac\xc6\x31\xaa\x0b\x28\x84\x5c\x4f\x15\x2b\xc9\x89\x92\x01\x7b\x53\xd6\x16\xcb\xef\x1c\x86\x42\x5f\x42\xed\x4b\x82\x11\xfb\x72\x38\xf3\x6d\xe6\x51\x14\xf7\x70\xea\x8d\x11\x76\x9a\x23\xa6\x4e\x1d\x61\xc7\x1f\x71\x63\xea\x43\xd1\xe0\xfc\x35\xf9\xf0\xc6\x8d\x87\x92\x4b\x4d\x22\x50\x06\xa2\x1d\xf4\x75\x85\x5e\x8c\xc1\x1c\xf5\xda\xe0\x9c\x03\x2e\xec\x23\x8b\xce\xbc\x92\x7b\x86\x63\xc1\x0b\x2b\x80\x18\x06\xc4\x87\xd0\x71\x26\x96\x82\x33\x96\x81\x33\xce\x81\xbb\xe8\x0a\x69\x7d\x61\xe6\x70\x18\x8d\x53\xa1\x33\x2d\xe3\x24\x78\x0f\x16\x79\x8a\xec\xd7\xf0\x18\x07\x43\x7b\x8c\x07\x16\x53\x69\xf6\x11\xbe\xd4\x8e\x72\xa0\xe1\x11\xf8\x1d\xde\x85\x81\x95\xb0\x1f\x0f\xbb\xfd\x4d\xe2\x03\xf8\x8e\x60\xbf\x86\xf9\x46\xd5\xc7\xe0\xfc\x8f\x41\x35\xf2\xb0\xd2\xba\x21\x0a\x7f\x07\x2b\x1e\xa1\x5d\xc0\x8b\x69\x02\x2f\xb3\x52\xaf\x3a\x09\x4d\xe0\x2f\x18\x88\xa5\x16\x27\xae\x30\x30\x32\x28\x28\xa5\x5b\x58\xef\x4d\x7d\x12\x73\xf1\xd9\x21\xcf\x63\xe8\xa0\x44\xba\x95\xae\xdd\xb2\x7a\x6d\x3c\x9d\x99\x9a\x62\x4a\xe1\x43\xc3\xcb\x77\x26\x49\x29\x5b\x37\xdc\x0b\xbd\xb9\x05\x3a\xb8\xaf\x20\xb7\x60\x87\xd0\x29\x1b\xc6\xa7\x44\xb9\x85\x26\x85\xc7\x86\xf2\x29\x29\x59\x39\xa9\xd2\xda\xd2\x2d\x87\x4a\xf7\x29\x35\x6e\xc7\xc0\xe1\xd0\x6f\xb9\xf0\xac\x4f\x71\xef\x6d\xdd\x76\x04\x15\x46\xee\x2f\x3c\x50\xb8\x7f\x7f\xcd\x81\x14\x3a\x08\x3e\x80\x2e\x1b\x40\xc7\x83\x0e\xba\xec\xde\x0f\x1f\x48\x07\x0a\xf7\x47\x16\x06\xd1\xf8\x17\xf4\x98\x2c\xd8\x3d\xe9\xa8\xee\x78\x0b\x6e\x69\xee\x9a\x3b\xde\x42\x7b\x0a\xb7\xf0\x96\xea\xae\xba\xc3\x2d\xb8\xa5\xba\x8b\x56\x5f\xb3\xc2\xa9\x23\xe1\x0f\xfc\x43\x1b\xa9\x8d\xc4\x7f\x53\xf8\x43\x1d\x09\x3e\x82\x64\xd1\x59\x95\xff\x9a\xea\xa0\x02\x7e\x5f\x45\xaa\x87\x20\xc8\xf1\x16\xcc\x33\xfb\x80\x9f\x93\x81\xa8\x36\xaf\xe1\x36\xd5\x86\x14\xaf\x33\x6a\x54\x94\x1b\xac\x80\xd8\x3d\xfb\x0b\x4e\x24\x1d\x71\x4f\xdd\x15\xbb\x33\xb4\x9c\x96\x4d\xb2\x16\x03\x07\xc5\x80\xed\x0b\xd2\x83\xd6\x61\x0a\x06\xb9\x2d\x5f\x99\x31\xe5\xc8\xb2\x23\xcb\x6e\x66\x9c\x38\x0a\x53\x61\xa8\x1b\xf4\xf1\xc2\x4a\x6c\x44\xc7\xcd\x7d\x16\x7c\x3c\xce\x1d\x04\x14\x89\xcf\xaf\x3d\x3c\xf0\x8c\x87\xb9\x30\x08\x07\xa1\xdf\xa0\xc0\xe1\x9f\xce\x94\x40\x40\x81\xf8\xe5\xf9\x25\x78\x0f\xba\xeb\x1f\x47\x3d\x0c\xbc\x27\xc2\x07\x85\x81\xda\xd8\x8c\xd9\xc7\xe7\x7d\x99\xe1\x6e\xca\xc9\x91\x73\xf8\xcf\x4e\x1d\xbb\x94\x27\x9d\x50\xcf\xe4\xd4\x25\xd6\x45\x6e\x73\xc7\x85\xea\x12\xee\xc5\x77\xdf\xbe\xf8\x63\xe4\x77\xbd\xfb\x8c\x1c\xd9\xa7\xf7\x77\xa3\xfe\x90\xac\x94\x01\x7b\x72\x38\x17\x07\xc1\x20\x98\xdb\xbc\xed\xd6\xe1\x4b\x12\x4a\x20\x11\xe3\xfa\x2f\x47\x1a\x59\x3d\x36\x42\x26\x66\xc2\x45\x70\x85\xf6\xc7\x9b\x7f\x11\xed\x85\xab\x3e\x9d\x1c\x31\x9e\xb7\x3d\x71\xdd\x21\x42\x6d\x82\x25\xf0\xf6\x69\x53\x77\xb4\xd9\x5f\xef\x00\x9d\x93\xc5\x19\x7e\x9e\x23\xc8\xe8\x45\xf5\x12\xd0\xeb\xa5\x00\x8a\xb9\x3b\x07\xe3\x70\x06\x74\xc1\xe1\xa2\x4c\x61\x3f\xa4\x66\x20\x37\x42\x4a\x8e\xcb\x89\x2e\x4d\x02\x87\x11\x6e\x19\x79\x05\xc6\x02\xbe\x48\xc9\x2d\xcc\x97\x0e\x9d\xaa\xd9\xb6\xad\x9c\xae\xa8\x3d\x54\x7c\x80\xbf\xd1\xbc\x7c\xf6\xd2\xd5\xd1\x9f\x6c\x90\x26\x04\x0f\x59\x89\x1d\xf5\x93\x5f\x0a\xf5\x54\x7d\x7d\xf5\x85\x3a\xb1\xb9\xe1\xc5\x25\x78\x5f\xaf\x39\xab\xbe\x1c\xcc\x15\x56\x30\xd2\x7f\x83\xf6\xc0\xbb\x02\xfe\x5f\x7e\xa4\x5a\x55\xaa\x86\xc3\x7c\x47\xd8\x01\x09\x30\xfb\x84\xfa\xfb\x5e\x27\xb5\x9d\xc1\xf9\x2a\xf7\xf8\xf6\x9d\xc7\x8f\x26\xdd\x19\x3a\x74\xe2\xc4\x61\x43\xef\x4c\x7c\x2c\xa9\x67\xac\x5d\xb8\x22\x63\x51\xba\x22\x66\x65\x65\xe6\x64\x14\x64\xe4\xa7\xe5\xba\x6b\xa3\xd4\x2a\x42\xa6\xb6\x47\x07\x55\xcc\xe5\x67\xad\x49\x0a\x8f\x91\x64\x4a\x36\x19\xd1\xa6\x5a\x9f\xc2\x0b\x84\xb1\x6c\xd4\xad\x62\x51\xbe\x5b\x1c\xff\xa3\x18\x08\x61\x8f\x60\x78\xba\xe6\x45\xe0\x3c\xed\x85\x31\x46\xd6\x67\x86\x94\xcc\x3f\x16\x5d\x1f\x5b\x97\xde\x50\xb3\xbf\xe2\x08\xd0\xa7\x41\x4f\xcb\x5f\x41\xc0\x63\xc8\x11\x4d\xf0\x06\x5d\x40\x22\x12\x4b\x0b\x0a\x65\xbd\x5c\x52\x52\x11\x2a\xaa\x4e\xda\x34\x62\xe7\x32\xa0\xc2\xc1\x41\xaf\xf5\xc2\xbe\xdc\x40\xcc\x87\x4e\xf8\x77\x76\x72\x4e\x4a\x4e\x8a\x7b\x96\x4c\x56\x04\x7d\xb1\xf0\xde\xb1\xe6\x63\x0b\xfe\x59\x7f\x9f\x96\x87\xc2\x5c\x0f\x28\x14\xcd\xd7\xb5\x9f\x39\xf9\x7d\x18\x8f\x57\x54\x59\x4c\x49\x4c\x96\x45\x39\x31\x39\x2d\x5b\x84\x6b\x5a\x3c\x10\x38\x46\xd6\xd7\x04\xe5\x07\x56\x97\x14\x17\x6c\xde\x1e\xb9\xcf\xa6\xb7\x43\x34\xac\x47\x17\x58\x0f\x27\x61\xbd\xab\x79\x18\xec\xbf\x0f\x39\x90\x0b\xf9\x2d\x97\xa1\xe3\x15\xe8\x70\x85\x4d\x48\x54\xb3\xd4\x23\x1c\x7c\x0c\x55\x59\x58\x45\x98\x5b\x5e\x70\x1f\x8c\x1d\x88\x9d\xc5\x79\xaa\xdb\x45\x12\xdc\x9b\x46\xa0\x93\xa4\xdd\x55\xdf\xe5\xaa\x63\xcb\xa3\x45\x7c\x44\x26\x26\xa5\x27\xa7\x49\x5a\xa3\xd5\x48\x6c\xda\x52\xb1\x6e\x37\x0f\x5b\xc9\xe2\xe2\x7c\x25\x5f\xfa\xec\x7b\x02\x4e\xcc\x24\xa3\xcb\x63\xab\x44\x58\x47\x56\x95\x97\x57\x4b\xe6\x9b\x6a\x47\x0e\x2a\xd0\x17\x7a\x63\xa9\x88\x35\x64\x74\x6c\x6c\xb4\x64\xcd\xa4\xd8\x7d\x0e\xd1\xe5\xb1\xd5\x22\x9b\x90\x08\xb5\x24\x14\x83\x2f\xf4\x85\x0a\x09\x06\x9a\x38\x39\x03\xd2\xb1\x37\x8c\x16\xd9\x83\x89\xcb\x49\x10\x30\xd0\x88\x0b\x65\xbd\x9c\x89\x79\x68\xc0\x61\xe2\x79\x12\xfa\x81\x99\x81\x19\x30\x5c\xf8\x0f\xc0\xd3\x06\x98\x6a\x03\xf0\xff\xc5\x70\xc1\xff\x43\xc5\x40\xfe\xe5\x68\x56\x60\x19\xa3\x5a\xd1\x93\x0b\x1a\xb4\x60\x7d\xa2\x98\x16\x1b\x6b\x8c\xe5\xd7\xae\x55\x94\x60\x09\x87\x9f\x5d\xf9\x72\x1a\x74\xa3\x27\x82\xc7\x16\xe8\x0e\x23\xf4\x30\xa2\x12\xba\xdf\x01\x0f\xf1\x3a\x74\x3b\xf2\x12\x86\x9f\xa5\x95\xfa\x7d\xca\x3e\xbe\xbc\xdc\x98\x56\x2e\xed\x49\x7c\xba\x20\x48\x1f\xee\x87\x1f\x27\x06\x88\x69\x61\x46\xff\xe8\xcd\x74\x42\x7c\xa4\x71\xcb\xe2\xc5\xc5\x8b\xf9\xb8\x48\x53\x52\x82\x14\x13\x9f\xb2\x34\x2d\x8a\x0e\x1f\x1e\x3f\xcc\x4b\xef\x55\x3a\x6c\xfb\x70\x31\x3f\xaa\x70\x69\x45\x3c\x9d\x54\x52\x63\x2a\x3b\x7d\xba\xf8\x34\x5f\x59\x63\x4c\x28\x95\xaa\x37\x67\xfb\xe7\x87\xd1\xc5\x01\x8d\xf8\x71\xb8\x1e\x86\x58\x7a\x70\x15\x15\x05\x25\xa5\xd2\x99\x33\xbb\xae\xdf\xd2\xdf\xda\x78\x7d\xd1\x19\x31\x49\x08\x0b\x33\x05\xec\x0c\xa3\xb7\x87\x95\x06\x07\xe9\x83\xe2\x83\xc3\xc3\xc5\xd0\xb0\x2c\xff\x1d\x61\xf4\x61\x01\xa6\xe2\x54\xae\xa2\x32\xbf\xb4\x44\x7a\xfe\xbc\x11\x74\x20\xe8\x41\xf0\x03\x5d\xdf\xe7\x62\x92\xf0\x4a\xa0\xef\x8d\x3b\xea\xd1\x5d\xdf\x3d\xc0\x63\xfc\x38\xf1\x95\x40\xc7\x97\x54\xa4\x55\xf2\xff\x53\x09\x7a\x40\x8f\xef\x60\x2e\xac\xd0\xc3\x8a\x91\x30\x17\x7b\x40\x8f\xb6\x8a\xd0\x01\xdf\xbd\x89\x43\x71\x8c\x1e\xc7\x4c\xc1\xa1\xd8\x01\xdf\xfd\x2f\x01\x17\xb5\x8f\x5c\x0f\xcd\xf5\x36\x71\x9e\x71\x94\x41\x61\x54\xdb\x91\x13\xf8\xc2\xeb\x1a\x41\x55\x9c\x23\x18\xb3\xa2\x29\x35\xf6\x17\xba\x6f\x01\x06\x73\xa3\x01\x97\x1b\x19\x1b\x88\xfb\x67\xe8\xe3\x6e\xd3\x04\xd1\x28\xb4\x2a\x70\x98\x91\xa9\x69\x82\x64\x55\x2c\xca\x7a\xe1\x7f\x21\x36\x4c\x23\x63\xff\x78\xf5\x50\x00\xfb\xae\x01\x74\x2d\xa0\x7b\x10\xe5\x2a\xc3\x43\x61\x16\xe8\x7e\x05\x5d\xb0\x0d\xae\xb3\x2f\xb6\x79\x01\x3a\xf6\xff\x42\x40\x87\xbe\x07\x05\xf0\x05\xdf\x83\xc2\x49\xd5\x91\x1b\x34\x08\xb6\x09\x4f\x9f\x12\x3f\xc0\xee\x83\x82\x79\x1e\x34\x83\xcc\x80\xb3\x30\x91\x41\xc6\x6f\xd6\xcc\x09\xe2\x94\x8f\x3f\x1e\x82\x43\xf5\xfe\x8c\xc8\xae\xcc\xf7\x64\x24\x36\x75\x62\x7f\x61\x1b\x03\xc4\xb9\xcf\xaf\xdd\x13\x6f\x7d\xfb\xcd\xcf\xf0\x91\x5e\x2b\x41\xdd\x41\x7b\xfb\x1c\xf8\xe1\x60\x18\x8c\x7e\xe8\x87\x83\x71\x30\xfa\xd9\xaa\x81\xb3\x00\x9d\x5e\xb5\x19\x9e\xf5\xc2\x4e\x10\x20\xa8\x22\x1c\xe3\xe6\x82\x34\x00\x5c\xb0\xc3\xd3\x0d\x35\x01\x69\x9b\x36\x44\x6e\xc8\x0f\xd8\x1d\xf9\x6a\xcc\x37\x3d\x4e\x62\x7b\x3a\x54\xd9\x11\xbb\x83\x2f\x2c\xcc\xca\x29\x90\xf6\x95\x56\x1e\x8a\xdf\x47\xc3\xea\xef\xb9\x49\x30\x09\x19\x18\x88\xfd\x81\xa2\x59\x7d\xdf\x0d\x35\x01\xe9\x91\xeb\x23\x37\xe4\x05\xec\x89\x04\x7d\xcf\xbf\xd0\x70\x19\x07\xd2\xa1\x45\xdb\x63\x77\xf2\x85\x05\x59\x39\x85\xd2\xbe\xd2\x8a\x43\x09\xf6\x07\x5e\x75\x12\xa6\xdb\xbd\xd6\x4c\x07\x5f\x74\x06\x5f\xd7\x2c\x03\xfd\x7f\xec\x4a\x4b\xa5\xda\xcc\x05\x9a\xd6\x46\xc5\x04\xd1\x4b\x37\x2d\xdb\xb0\x80\x5f\xb7\xbe\x78\xeb\x26\x29\xa9\x90\x08\xdf\x96\xb0\x6f\xbf\x1e\x68\xe6\xdc\x89\x0d\x4b\xb7\x89\x15\x41\xfb\xa2\x0e\x98\x68\xf5\x3a\xe8\xb8\x40\x61\xc1\xb2\xdd\x27\x37\x89\x31\xfb\xd7\x6e\x0d\xcc\x3a\x90\xb5\x6f\x6b\xc5\x7e\xfa\xe4\xb6\x13\xbb\xcf\xf1\x7b\xf7\x24\x46\x6d\x93\x8a\x52\x88\xed\x9b\x4a\xd6\x06\xe9\xb5\x8f\x21\x94\xdb\x7e\x26\xea\xf3\x45\xdb\xe9\x7d\x93\xc7\x56\x8e\xe1\xd9\x1d\x41\x6b\x33\x53\x83\xa5\xd3\xbb\x2f\x6e\xfd\xa2\xa0\x31\xff\xd0\x99\xd4\xc6\xb4\xc6\x45\x87\xfc\x52\x7b\x27\x0c\x5a\x33\xda\xaf\xfe\xf4\xd1\xe3\x27\x0f\x37\xec\xcf\xbf\x1c\xd4\xb0\xb6\x61\x56\xbe\x7f\x10\x8d\xc3\xd0\xbd\x07\xce\x8e\x40\x7f\xec\x8d\x5b\xdd\x70\x15\xbe\xb3\x7e\x4b\xe2\xea\xf2\x75\xee\xe0\x85\xcd\xc4\xa6\xe2\xda\xf8\x5a\xbe\x48\xc9\xce\x2b\x92\xd8\x95\x90\x02\x1d\x08\x76\x1f\x1c\xdf\x58\x6e\x2a\x33\x95\x1b\xdd\x65\x2a\x3b\x5b\xce\x96\x65\xb9\xc3\xfb\xd0\x11\x88\x7b\xe0\xd4\x28\xd5\x9e\x89\xfc\x7c\x51\x2d\x9d\x9f\x10\x9f\x13\xc7\x97\x95\xe6\xe4\x97\x48\xec\xca\x33\xb5\x35\x9f\x47\x9c\xa1\xc1\xc9\x0f\x89\x7b\xd8\x91\x67\xd7\xa5\xa5\x9a\xd2\xf8\xe2\xbd\xfb\xf2\x0f\xf0\xec\xca\xd3\x27\x93\x22\x8f\x49\xa7\x23\xbe\xd8\x5a\x7b\x9a\xb6\xcc\x03\x2f\x6e\x5b\x62\x44\x69\x04\x9f\x94\x6c\x4c\x4f\x92\x30\x05\x3b\xe0\x89\x5d\x71\x59\x71\x59\x71\xd9\xee\x26\xd2\x68\x94\x8d\xf6\x36\xb1\x23\x12\xe3\xd1\xc9\x4f\x8a\x58\x54\x33\xe7\x4c\x04\x9d\x56\x52\x9a\x59\xc6\xc7\xc5\x67\xa6\x25\x48\x8b\x22\x22\xe7\xd4\x2e\xa2\xd1\xa9\x11\x88\xf1\xd0\x31\xbf\x20\x2b\x9f\x4f\x5c\xb7\x36\x2d\x90\x5f\xbc\xb4\xa8\x66\x85\xb4\xb8\x76\x76\x54\xc4\xe2\xf0\x45\x5b\xe7\x9c\x09\xa7\xd7\xde\xba\xbf\xe5\x01\xbf\x7f\x5f\x4e\x41\xbd\xb4\x78\xc3\xdc\xa8\xd9\xa9\x7e\x69\xab\x17\x15\xf8\xd1\xac\xef\xa2\xfc\x86\x35\x67\xf8\xdc\x5c\x39\x2b\x57\x62\x57\xbe\x28\x79\x7a\xf0\x9b\xc6\xe0\xc5\x01\xcb\x97\xae\xf2\x0f\x4a\xfb\x64\xbf\x3f\x1d\x51\xbd\x2b\x61\x37\x5f\xb3\xad\xa0\xbc\x4a\x82\x61\xe0\xfe\x27\xcc\xae\x05\x7f\xe8\x0d\x5b\xdd\x58\x5f\x58\x05\xef\xec\xa9\x2c\x3e\x14\xbb\xd7\xdd\xa5\xc6\xd2\xd0\xe2\xa8\xbe\xf7\xab\xd9\xf7\x85\x93\xa5\xc1\x26\xf8\x77\xea\xf9\x12\x3b\x62\xc7\x9e\xb6\x5b\x37\x59\x80\x6a\x01\x56\x0a\x18\xaa\x36\x73\x70\x17\x8a\xb1\x18\xef\xe2\x47\xa3\x07\x4f\x1e\x25\xcd\x18\xbf\x60\x0e\x12\xfa\x54\x21\x70\xfd\x9e\x03\xde\xc2\x74\x01\x86\x7e\xfd\xe4\xe6\xd7\xe2\xd5\xbb\x8d\x57\x80\xd1\x43\x77\xc1\x56\xfd\x2e\x14\x43\x31\xdc\x15\x31\xd3\x1a\xc0\x69\x0f\xb4\x07\x31\x31\x72\x68\x45\x8c\x3b\x8c\xc2\x51\x15\x31\x3b\xe5\x8a\x0a\x77\xf5\x81\xfa\x80\x30\x1f\x34\x38\xef\xe4\x62\x2a\x42\xe5\x2d\x31\x18\x80\x01\x6e\x03\x07\x3e\x9e\x78\x63\xc8\xf1\x5e\xee\x77\xef\xee\xdc\x01\x71\x10\x57\x51\x29\xef\x8c\xa9\x70\xb7\x69\x67\x3e\x06\xe7\x74\x98\xe3\x68\x20\xa6\xc0\x0c\x27\xf3\x1b\x4b\x3e\xb7\x3f\xa3\xce\x7f\xf3\x96\xb4\x94\x18\xb1\xaf\xaf\x3f\x4a\x1f\xe8\x27\x6e\xef\xff\xb8\xa8\x38\x2b\xab\x48\x2c\xcf\x92\xe5\x9c\xb2\x9a\x97\x5b\x5f\xd6\xbc\xa4\xf3\xf7\x16\xec\xad\xd7\xab\x5b\xb4\x51\x5c\x5a\x4a\x6a\x9a\xc9\x28\x67\x99\xc4\xa2\x65\x2b\x0b\x97\xf1\x1f\x79\x87\xaf\x99\x20\x25\xa7\x67\x66\x18\x93\x13\x97\xa5\x2c\x4d\x5c\x46\x63\xdf\x95\xe8\x8a\xd3\x70\x2c\x8f\xed\xc7\x7d\x07\xf4\xd5\x06\x70\x79\x70\xec\x7c\xc4\x86\xbd\x52\xb6\x31\x2f\x23\x43\x6f\x4c\xef\x35\xcf\x4b\xbf\xb1\x34\x6a\xcf\xcd\x0b\xbf\x7f\x56\x2e\x16\x1d\x2a\x39\x96\x7b\x98\xce\xca\x96\xb3\xb2\xf5\x79\x91\xc6\x0c\x9c\x87\x04\x38\xc0\x7c\x98\x09\x1d\x60\x13\x2c\x38\x20\xe6\x6c\xab\xcd\xa9\xe5\x61\xd0\xa3\xb1\x38\x04\x9d\xd6\xf4\x8b\xe9\x2a\x65\x1b\x89\xa3\x77\xee\x1f\x7a\xc8\x2b\x95\xe9\x99\x85\x52\x65\xea\x7d\x6c\xbf\x59\x0f\x33\xd4\xad\x5d\x05\x4c\x44\x05\x16\xaa\xa3\x21\x3a\x11\xc2\xd5\xad\xb0\xc2\xf5\x10\x44\xe2\x52\x78\x00\x1a\x34\xb0\xdf\xb2\x5f\x99\x63\x0d\xce\xb7\xb8\x85\xc9\x0b\x93\x16\x89\xc1\xd8\x3f\x18\x07\x04\x63\x7f\x3a\x30\x65\x55\x61\x08\x8f\x6e\xab\xa1\x3b\x38\xc0\xb0\xab\x10\x0c\x1e\x3f\x48\x65\xdb\x77\x29\xbb\xf8\xa6\xbc\x25\x7e\x92\x39\xdd\xda\x9d\xdb\x8d\x14\x4c\x0d\x2d\x12\xf3\x12\x36\x14\xc6\xf3\xa8\x43\x72\xf6\x2c\x74\x90\xd8\x6f\x33\x73\x88\xed\xf0\xe1\xe7\xd0\x1f\x46\xea\x41\x46\x37\x20\x30\x5d\x64\x8f\xaf\x09\xcc\x4c\x0b\x94\xf0\x0b\x3f\x9c\x85\x7f\xe2\x11\x3d\x5e\x82\x09\x38\x0a\x2e\xe6\xd7\xe7\xa6\x88\xc9\x14\xba\xc4\x8c\xc3\xe3\x38\x84\x5f\x1a\x55\xdf\x00\x3c\x0c\xf8\x2e\xbb\x50\x62\xbf\x3a\x66\xc2\xa1\x8d\xfe\x3c\xb6\x9f\x81\xb3\xfb\x4a\xec\x69\x9c\x0c\xce\xd8\x09\xa6\xc1\x56\x98\x07\xfb\x21\xee\xb2\x58\x79\xab\xe4\x4e\xd5\x2d\x9a\xfd\x36\xb7\x2c\x27\xbf\xac\x80\xbe\x04\x4e\x40\x1d\x82\xce\xfc\xed\xcb\x9b\x93\x6e\x49\xf9\x26\xa2\xa8\xb4\xa8\x48\x72\xe9\x1a\x0c\xbe\x8e\x06\xe2\x38\xcc\x75\x32\xdf\x33\xff\xcd\xad\x5f\x1f\x1f\xb6\x59\x5a\xbb\xac\x78\xe6\xa9\x75\x30\x0b\x3b\xbb\x6d\xde\x15\xeb\x1f\x62\x34\x66\x19\x79\x0c\x39\xa4\xf9\xb6\x10\x59\xa9\x69\x59\xa9\xfc\x12\xff\xb5\x8b\x52\xa4\x94\xf9\x87\x97\x9c\x8b\x87\xbf\x3d\xdd\xb4\x4d\x97\x89\xcc\x0c\x39\x93\x5f\xb4\x2c\xd8\x56\xe0\x7b\x64\xe1\xc5\x34\xb5\x6a\xba\x9b\x36\xcb\x44\xcc\x5b\xb2\x72\x5e\xa6\xe4\x9b\x79\x62\xc9\x67\xbc\xea\x4b\x62\x69\x30\xb1\x20\x6d\x45\xc0\x02\xfd\xdc\x13\x2b\x2e\x88\x76\x99\x1b\x5e\xd7\xab\xdb\x2f\x1d\xcf\xdb\x5f\x5f\x78\xcc\xfd\x9e\x3a\xa8\xe0\x70\xe2\x91\xb0\x3d\xee\xd8\x13\x3e\x0e\x3e\xb4\x7a\x9f\xff\x2e\x77\x0c\x83\xde\x44\xc9\xe6\xa8\xfc\x48\x7e\x22\x2e\xe5\xd6\x6f\x8d\xda\x9b\xb6\x3f\xed\x40\xe1\x81\x9a\x3d\x39\x39\x39\xd9\x39\x39\xf8\x3e\xf4\x72\x0b\x3c\x34\xa7\x28\x60\xdd\xf2\xb5\xa9\x9f\xec\xf5\xcf\x36\x66\x65\x66\x1b\x21\x19\xcb\xdd\x0e\xae\xca\x33\xc2\xfa\xff\x1f\x73\xff\x1d\x17\xc5\xf5\x3d\x8c\xe3\x0b\xec\xcc\x0e\x73\x75\x05\x76\x87\xc0\xee\xce\x0c\x2a\x62\xef\xe4\x6d\x43\x83\x35\x1a\x62\xc3\xd5\x88\x68\xec\x02\x0a\x2a\x4d\x7a\xef\x2c\xb0\x94\xa5\x49\x6f\x76\xb1\x61\x49\x14\x45\x63\x8a\xd1\x14\x95\x14\x4d\x8c\xa9\x9a\xa8\x49\x34\xd1\x9c\x59\xce\xe2\xfb\xf7\xda\xc5\xbc\x9f\x77\x7e\xcf\xf3\x7c\x5e\xdf\x3f\xbe\x7f\x7c\xb7\xcc\xbd\xf7\xcc\xdc\x3b\xf7\xde\x73\xee\xb9\xe7\xb6\x73\xb6\x50\xe6\xa5\xd2\x17\xdc\x85\xdc\xf5\xa7\xdf\xd0\xea\xf3\xd7\xad\x29\xd2\x57\x62\x94\x5b\x61\xc8\xea\xe4\x84\x03\x5e\xb0\xd2\x0d\x97\x4b\x13\xa3\x3a\x17\x37\xae\x0a\x77\x5f\x13\x99\xbc\xb4\x3e\x10\x74\xf8\x93\x1b\x66\x49\x93\xc3\xcf\x2c\xad\x5f\x13\xe9\xbe\x2a\x3c\x61\xd1\xde\xd5\xb0\xdb\x12\xe8\x86\xf5\xf0\x74\xdb\xc9\x25\xd5\xeb\xc2\xdc\xd7\x84\xa6\x2d\x3c\xb4\x16\x52\xf0\x9a\x5b\x73\xf3\x81\xea\xc3\xda\xbd\x6d\x19\x89\x4d\x22\x44\xe0\xb0\xd3\xdb\x8f\x07\x1f\xde\xe4\x0e\x5e\x38\x63\x4f\x68\xd5\xe6\xfc\x8d\xee\xcf\x2e\xb6\xd7\xb5\x1c\x28\x3b\xe6\x7e\x16\x76\x94\x9f\x35\x76\xe6\x9e\x73\x57\x36\x36\xee\xea\x99\x03\x9b\xec\x74\xf2\xa3\xe0\xe9\x00\x3f\xc0\x7c\xae\xb8\xb8\xb8\xb8\x04\xff\x05\x67\x93\xda\xc4\xd4\x86\xf8\x86\xe4\xfa\x96\xa3\x6d\xed\x7b\x0f\x43\x94\x65\xbc\xdb\x33\x0c\xa0\xd2\x8b\xc1\x7d\x43\xad\xb6\xa4\xb8\xb0\xac\xc4\xe2\x62\x5e\x16\x7d\x5c\x6c\x6b\xd9\xd3\xbc\xaf\x51\x5a\xdd\x7b\xc7\x2d\xdd\x78\xa6\xb0\x42\xdb\xb4\x37\xaf\xb8\x49\x2c\x2e\x30\x16\x15\x6b\x4a\x2d\xe1\x3d\xb2\x94\x66\xe1\x60\xdd\xa1\xdd\x87\xab\x33\x33\xdd\xa4\x25\xbd\x1f\x5c\x45\x02\x4e\x18\x47\xa5\x95\x54\x64\x55\x6a\x6b\x7f\xea\xaa\x68\x10\x2b\x4a\x4a\x2a\x2a\x35\x75\xa3\x60\x6a\xe2\x1e\x01\xd6\x7d\x0f\xb3\x60\x2c\x10\x58\xcc\x54\x35\x94\xb6\xb4\x6a\x5a\x33\x5b\x92\x1b\x04\xb8\x84\x7a\xfc\x1c\xd6\xe3\x73\xad\xdf\x6b\x59\xc9\xaf\x8b\xe8\x04\x71\x54\x79\x56\x6a\x49\xaa\x36\x6e\xfc\x8a\xd4\x18\x31\x2d\x2b\x33\x35\x45\x13\xf7\x00\xa7\xee\xde\x29\xe0\x82\x19\x38\x16\x5d\x91\xc1\x09\xcc\xf6\x4d\x41\xeb\xdf\xd0\x44\x94\x46\x56\xc7\x08\x9f\x21\x01\x47\x54\x83\xe3\x74\x26\xbf\xb0\x30\xbf\x50\x6b\xbe\xf1\x84\x03\xea\xee\x47\xe0\x0e\x03\x35\x30\x20\x00\x1c\x27\x7c\x2b\x80\xff\x2b\x30\x01\x07\x81\x03\xbe\x82\x76\x38\x1d\xc7\xa0\x07\x2e\x7e\x85\xb1\xd8\x9b\x97\x73\x6d\x4d\x4d\x6d\xe0\x03\x3a\xd4\xa1\x4f\x78\x74\x74\x78\x78\x74\x53\xdb\xa5\xe8\xae\x4d\xc7\x85\xe3\x9b\x56\x34\xe9\xb5\xd6\xb0\x28\xd9\x5f\xe3\xf2\x72\x33\x4b\x29\xa5\x25\x65\x10\x38\x9b\xaf\x00\x27\x39\xc7\xd8\x19\xe0\x25\xf3\xc8\x0b\x37\xc1\x0d\x74\xf7\x1d\x7a\xda\xa5\x59\xdc\xcd\xe4\xee\x1d\x1f\x0b\x5b\xa2\xd6\xc7\xaf\x4d\x67\x9a\x56\x94\x2f\xf3\xd7\xd8\x94\xb3\xfa\x61\x2c\xc6\xe2\x54\xf0\x83\x28\xd8\x09\xd3\x60\x05\xc4\x9c\x3b\x97\x1e\x7b\x46\x28\x3e\x5d\x7d\xaa\xe1\x38\xd3\xb8\x74\x61\xf9\x42\x2d\x5e\xc4\x28\xcc\xc1\x4e\x1c\xdc\x89\x2e\x8f\x06\x89\xe8\xf0\x18\xb8\x00\x18\xa6\x85\xe1\xa0\x3e\x0f\xf6\x8f\xc5\x47\x4f\x3b\xc1\x05\x06\x6b\x70\x1d\x2c\xe5\xc0\x21\x16\xec\x83\x9e\x0a\x45\x21\x86\xe0\x10\x0d\x36\xae\xb0\xf8\xe1\x49\xb4\x17\x72\x1b\x1a\xf3\x1a\xb5\xd5\x05\x14\x84\x82\xee\x09\x6c\x81\x62\x8d\x1e\xbe\xe6\x52\x61\xe8\x3c\xd8\x80\x2e\xdf\xde\x41\xf1\x26\x0e\xbb\x80\xa3\x19\xc8\xc5\x35\xdc\x5f\x9f\xff\xf2\xd3\x51\xb1\xf6\x54\xe9\x9d\x33\x9a\x1f\xa3\x7f\x7a\xe3\x33\x21\xd8\xf7\xb5\x85\xd3\xa2\xf5\x89\x8b\x62\x36\x6c\x62\x82\x82\x23\xfd\x02\x35\x1b\xaa\x36\x37\x85\x08\x20\x1c\x84\x61\x4f\xde\x05\xd7\xbc\x84\x94\xf0\xcc\xa4\x25\x83\x91\xf3\x1e\xb2\x8c\x59\x7f\xea\xd2\xd6\x2b\x5a\xe5\x71\xde\xc5\x00\x5f\x4b\x6b\xbf\xcf\xab\xd8\x73\x0e\x0a\xe0\x8e\xea\xd3\x9e\x76\x29\x83\xc3\x75\x38\x16\x27\xe1\x06\x41\xf5\x33\x6e\xc0\xb1\xf0\x2f\x58\x0f\xeb\xad\x8c\x0c\x36\x9e\x3a\x99\x99\x74\x42\x4c\xda\x99\x16\x96\x1b\xc6\x54\x85\x6e\x2d\x09\xd1\xe2\x38\x54\xa0\x3b\x8e\xc4\x31\x40\xa3\x0b\x8c\x17\x55\x9f\xc2\x38\xa0\xc1\x05\xc6\x1c\xcf\x3a\x9e\x70\x44\xdc\x5f\xb2\xaf\xb2\xad\x86\xa9\x5f\x6d\x0a\x08\xd0\xe0\x3c\x00\xae\x75\x76\xd5\x2b\x33\x34\x38\x73\x0e\x7a\xe2\xb0\xd1\x42\x1a\x9d\x94\x54\x50\x98\x24\x42\xe0\x17\x47\xe0\x22\x2c\xd4\x34\x1b\x5a\xf2\x5a\x04\x83\x3c\xe8\x69\xc0\x93\x65\x0f\xee\xe8\x2f\xe1\x88\xe2\x11\x0c\xfc\xf0\x94\x0b\xcd\x5e\x96\x12\x26\x2c\x8c\x78\xe3\xb5\x59\xda\x75\x9b\x9b\xf7\x6d\x17\x55\xdd\xef\x1e\x84\xe1\x8f\x4a\xbe\x62\x54\x3f\x6f\x1c\xef\x35\x77\x54\x34\x93\xd8\x9c\xbe\x67\x8f\xe6\x97\xeb\x47\x6f\x37\x09\x97\x76\x9f\x39\xd5\x72\x9e\x39\xb2\x72\xf7\xc2\x45\x1a\xb8\x03\x53\xb8\x11\xec\x73\x3d\xad\xfa\x74\x18\xff\x5c\xaf\xc0\x89\xc0\x21\x07\x13\x85\x1e\xbd\x17\x6f\xed\x16\xcf\xf5\xac\x80\x03\x3f\xb2\x3a\xf9\xbf\x25\x37\x6e\xcd\xc0\xf8\xd0\x6c\x21\x2a\xdd\xb8\x3e\x38\x3c\xa2\x6c\xe7\xc0\xc8\x51\xa8\x42\xe5\x8e\x07\x83\x76\x46\xa4\x47\x68\x83\x8c\x27\x5b\xd2\xc5\xd0\xe2\x81\xb5\x6f\xc1\x25\xbe\xa8\xcc\x58\x66\x3a\x83\xce\x19\x57\x34\x7b\x0f\xd4\xb4\x0a\x8d\x75\x89\xcd\xda\xe2\x62\x43\xa1\x51\xcc\x3b\x96\x7b\xec\x98\xa6\xbd\xf0\xec\xee\x03\x02\x90\x4b\x0f\xde\x02\x67\x2d\xd0\x3f\x2f\x1a\x7c\x56\xdc\x1d\x5a\x18\x18\xac\xd9\x9c\xbb\x39\x6f\xb3\x90\x6f\x34\xe6\x1b\x9b\xea\x6a\x9a\xb5\x2d\x87\xe2\x77\x8a\x7e\xe8\x6c\x7a\x53\x93\x6e\xcc\x28\xca\x10\x8e\x4d\xfa\xf4\xf5\x7b\x31\x4c\x75\x6e\x59\x5a\x92\x06\xca\xa1\x98\xf3\x60\x3d\x36\xf2\xbb\x75\xf4\x06\x07\xf3\x8f\x30\x82\xc5\xc0\x3c\x1c\x3e\x6f\x22\xfa\x33\x51\xab\x72\x66\x2c\xd7\xf8\x15\xbf\x6e\x7c\x5d\xc8\x4e\x4b\xcd\x4b\xdd\x14\xda\x16\xaa\x0d\x5e\x13\xb1\x49\x1c\x03\x6f\xd6\x4c\xd2\x24\x66\x25\x65\x25\x09\xab\x07\x8d\x19\xe2\xb1\x36\x3c\x35\x3c\x6b\x47\x16\x13\x97\x93\x96\x1c\xa7\x79\x15\x66\xee\x78\x2b\x53\xd8\xd6\x18\x3f\xf3\x9d\x23\xa7\x76\x9f\xd1\x36\x36\xe6\xe7\x34\x8a\x31\xc0\x9c\xb1\xca\x0b\x5a\x78\xe3\x04\xa8\x1b\x80\x88\xc6\x86\xc6\x82\xc6\xd3\x1d\xc9\x1d\xda\xae\xc4\xee\x03\x0d\xe2\x5b\xa5\x30\x73\xef\x27\x9a\xba\xb4\xaa\x38\xa3\xb0\xa3\x24\xbc\x24\xbc\x02\x65\x67\xc6\x3d\x0e\x7c\xca\x64\x55\x67\x55\xef\xbe\x0b\x6b\xe2\x1e\x6a\x4e\xac\x6a\x09\x11\x82\xc2\x76\x06\x69\xd3\x53\x8b\x8c\x19\xa2\xf1\x6a\xf1\x87\x57\x35\x17\x73\xbe\x88\x3a\x27\xf8\xc2\xbf\x70\xf8\x63\x9c\x9f\xc7\xf4\xe1\xe0\x0d\xd8\x6f\x1d\x05\xf5\x98\xc0\xe4\x90\xc7\x4b\x6e\xdc\xea\x81\xf1\xdb\xb2\x85\xa8\x8c\xa2\xf5\x21\xe1\xe1\xa6\x70\x8f\xbf\x31\x31\x30\x3c\x22\x2d\x5c\x1b\x6c\xc3\xc4\xb6\xe2\x81\xb5\x6f\xc3\x25\xde\x58\x56\x64\xc5\x84\x93\x15\x13\xfb\x6b\x5b\x85\xc6\xfa\x84\x26\x6d\x71\x71\x41\x41\xb1\x98\xdb\x87\x89\xa2\xb3\xbb\x0f\x0a\xc0\x5e\x7a\xf0\xb6\x15\x13\x8a\xfb\x36\x4c\x6c\x2b\x0c\x0c\xd1\x6c\xce\xdb\x94\xfb\x02\x13\xcd\x75\x35\x4d\x7f\x63\xc2\xc9\x8a\x89\xa2\x0c\xa3\x0d\x13\x7e\xf7\x62\xff\xc6\x84\xc9\xbc\xd3\x83\x97\xf6\x43\x3b\x6b\x5b\xe8\x75\x94\x41\x03\x3b\x78\x1d\x7a\xf8\xe3\x22\x4c\x60\x0c\x0a\x5c\x88\x09\x1e\x98\x1b\x1b\xc2\x18\x62\x42\xa6\xe0\x60\xe1\x55\x88\xc4\x0a\x83\x41\x83\xe5\x98\x8a\x73\x2d\x85\x58\x27\x62\x92\x1e\x05\x83\x41\x93\x93\x97\x97\x23\xe6\x17\xe4\xe7\x6b\x9a\x43\xef\x8f\x84\x94\x22\xc6\x08\x07\x21\xe1\x7b\x38\xaa\x85\x95\x60\x9f\x98\x7e\x56\xac\xcf\xa9\x37\x99\x6a\x61\x05\xfc\xea\x56\x56\x9d\x5d\x9b\x54\xc6\x14\xe4\xe6\x16\xe6\x68\x27\x54\x62\x70\x13\x4e\xde\x89\x21\xc1\x73\x03\xb1\xd6\x8b\x31\x04\x44\x0c\x0c\x16\x20\x08\x5c\xee\x77\x19\x34\xe0\x0f\x14\xec\xb8\x08\xe1\xe9\xe7\x7e\x79\x1f\xec\x4e\xee\x3d\xb5\x17\x46\x7f\x7c\xf2\xdb\x93\x77\xeb\x60\x66\xcb\xe9\xd6\x53\x07\xc0\x03\x4e\xc3\x72\x46\x29\x7d\x02\xa2\x9d\xe1\xfd\xf3\xdd\x52\x25\xf0\x52\x55\xf7\xf9\xf7\x1d\x74\xd4\x08\xb3\x9a\x6b\xcb\x6f\xcb\x69\x15\x30\x2d\x09\xa2\x6e\x25\x77\xc6\x9e\x0d\x3f\xe5\x8e\x21\x83\x61\x2e\x4c\x0c\xed\x08\x3a\xb2\xf1\x80\x3b\x4e\xc0\x79\x7f\xc0\xd6\x75\x6d\xab\x1b\x02\xaa\xdc\xa7\x63\x74\x35\xa4\x51\x11\xc6\x88\xc2\xf0\x88\xf0\xbc\xc8\x7e\x9e\x55\x98\x3a\x03\xa2\x02\x92\x57\xc7\xac\x8b\x70\xff\x03\xb7\xe1\x04\x98\xb7\x31\x34\x28\x28\x74\x83\x3b\xcc\xc5\x89\xb8\xf5\xcf\x88\x75\x31\xab\x93\x03\xdc\x21\xda\x07\xd3\xab\xa9\xdc\x88\xbc\x70\x43\xb8\x21\xbc\x30\x22\xa2\xdf\x10\x48\xab\xc6\x28\x9f\xaa\x80\x86\xd5\xad\x6b\xdd\x61\xeb\x9f\x38\x0f\x27\x1c\xd8\x70\x64\x4b\x47\x98\x3b\x8c\x87\x79\x9e\xb8\xed\x54\xf8\xdb\x31\x9d\xc9\xee\xb7\x60\x57\x12\xa6\x53\xad\x39\x6d\x79\xad\x6d\xad\x85\xad\xfd\x3c\x93\x20\xf3\x36\xc6\x76\x56\xbf\x5d\x7f\xaa\xcd\xdd\x13\xb6\xc1\x78\x9c\xd7\x71\xe0\xc8\x91\xfd\x1d\xee\x38\x17\x26\xc0\x56\xcf\xd6\x53\x0d\x6f\x57\x9d\x77\x37\x28\x30\xea\x16\xa4\x26\x51\xc6\xd6\x82\xd6\x36\xcd\x7e\x57\xfc\x12\x77\x63\x0d\x7e\x8e\x5f\x60\x35\xd4\xc0\x97\x70\x0b\xac\xee\x17\xf0\x39\x58\xe1\xb7\x84\x6e\x49\xc5\xf5\x0e\x91\x54\xbd\x43\x2c\x2a\xaa\xb7\x54\x61\x1e\x62\x51\x99\x87\x48\x2a\xaa\x77\x88\xe5\x75\xae\x77\xa5\x34\x8e\x32\x5f\x55\x98\x57\x4a\x63\xcd\x2b\x2d\x63\xa9\xde\xab\x8a\xf7\xcd\xbf\x73\xbd\x26\x49\xdf\x6b\xb2\xe8\xa9\xe7\x6a\x85\xd9\x64\xd1\x9b\x4d\x92\x9e\x52\x7a\xa0\x7b\xb7\x8e\xd2\xdc\xb4\x33\xdc\xd4\x51\x8f\x6f\x3a\xc0\x7d\x1d\xe5\xc5\xe1\x62\x1c\x85\xa3\x71\xb1\xd8\x5b\xa9\xc0\xc5\x30\x0a\x47\xc3\x62\xe1\xcc\x4d\x7a\xeb\xd6\xbc\xd2\x6d\x22\x3a\xb5\x8d\x07\x07\x70\xd1\x98\x2b\x15\x30\x14\xfa\x41\x7f\x18\x2a\x98\x47\xd3\x6d\x37\x29\xf0\x86\xed\x9c\xc5\xe9\x79\x07\x2e\x96\xee\x50\x18\x4b\xc3\xb1\xde\x70\xaa\x2a\xa4\x34\x28\x48\x13\x94\x19\x9c\x1c\x22\x6c\xf6\x9c\xb3\x08\x1d\xe2\x18\x7c\x43\x01\xe7\xca\xc0\x0e\x8a\x7e\x82\x4c\x69\x97\x8e\x52\xba\x41\x8c\xe5\x12\x07\x83\xc7\x83\x1b\xea\xde\x12\x22\xe6\x53\x7f\x6d\xbe\x39\x04\x69\xcd\xf3\xe6\xde\xa9\x8a\x94\xf0\xf8\xa8\x84\x48\xc6\x7c\x84\x56\x36\xa2\xe9\x10\x54\x1f\xfe\x13\x32\x20\xf0\x50\xc6\x21\x29\x12\x46\x9d\x88\xd9\x07\x4e\x2e\x06\xd8\x07\xe9\x87\x60\xe0\x01\x13\x38\xc5\x1c\xca\x3e\x08\x83\x0e\xc2\xa0\xfd\x3f\x1c\x80\x71\xfb\x54\x37\xee\x77\x99\x7f\xd6\xc9\xaf\x72\xed\x51\x1d\x9b\x36\x46\x6f\x08\x0e\x6a\xda\x78\xe2\x78\xf3\x89\x23\x02\x4e\xd6\xf5\x34\x72\x1b\x43\x43\x36\x6e\x0c\x6b\x3f\x2e\x00\xad\x50\xa5\x5d\x4c\x3d\xbe\xff\xf0\x09\xc1\x1a\xeb\xc4\x81\x90\x4d\x22\xd2\x0a\xf0\x75\xdd\x14\x16\x0c\x3b\xd8\xfd\x21\x9b\x04\xa4\x15\xaa\x71\x8c\x0c\x66\xb9\xaa\x18\x59\xea\xc6\xd0\x10\xd8\xc1\x1e\x78\x01\x67\x64\x5d\x30\xcb\x75\x53\x68\xf0\xc6\x8d\xa1\x7d\xe9\x1d\x3f\x70\xf8\xc4\x89\x17\xb7\xa1\xd1\xec\xcb\xa5\x61\xc0\x44\x7c\x03\x47\xa1\x8a\x39\x14\x1f\xdc\xbc\x59\x1b\xbc\x35\x26\x2c\x4e\xdc\x1f\xbb\xb5\x21\x58\x1b\xbc\x55\x62\xf9\xa0\x6d\x12\xcb\x6f\x0a\x89\x0a\x89\x13\x71\x12\xf0\xde\xb0\x0d\x82\x34\xa0\x3b\x0c\xba\xeb\xc0\x0a\x49\xfe\x99\x4b\x97\x68\xf0\x73\x88\xc2\x73\x70\x0f\x32\x60\x13\x8c\x82\x8d\x20\x13\x70\xc4\x3e\x6e\x67\x56\x78\x66\xb8\xb0\x6e\xd1\xcc\x9d\xbe\x5a\x5c\x87\xfd\xe0\x35\x58\xfa\x68\xff\xa3\xae\xaf\xc5\xf8\xf9\xc9\xaf\xce\xd3\xe0\xc8\x4f\xc6\xc2\x84\xce\x73\xa6\xf2\x4e\xa1\x68\x77\x4d\x51\x8d\xb6\xb3\x29\x22\x40\xb4\x2c\x32\x0f\xe5\xfc\xd6\x2e\x98\x37\x6f\xed\x47\x57\x3f\x3c\xfd\xd1\xa7\x9f\x9e\x5e\xf0\xba\x60\x76\xc4\xfb\x1c\xea\x96\xa0\xe8\x35\x4e\x28\xda\x5d\x50\xb3\x5b\xf3\x49\xf0\x89\x79\x71\xf1\xb9\xb9\x71\x42\xda\xea\xd5\xe9\x81\x5a\xf4\x58\xf1\x25\xb8\xff\xd0\xfc\xa8\xf5\x1b\xf1\x8b\x1b\xbf\x75\x3d\xd3\xaa\x9c\x18\x19\xac\x85\xfe\xf8\x1a\x2e\x11\x6d\xf5\x71\x10\xc3\xb8\x9f\xe3\xa1\xff\xac\x6b\x42\xcb\xce\xa0\xd6\x2d\xda\xc8\x5d\x29\x71\x89\x62\x24\x0c\x7e\x1d\x04\xb4\x7f\xc4\x94\x94\x96\x97\x95\x6b\xea\x36\xd6\x27\x16\x0b\xa6\xf2\x23\x87\xab\x34\xc6\xbc\xe2\xdc\x22\xe1\x48\xd0\x8a\xc6\x95\x5a\xfd\x8a\xa8\x0d\x9b\xc5\xa2\x98\x5d\x05\xbb\xb4\xb8\x08\x67\x0e\x43\x4f\xa4\xc4\xe0\x37\x93\xc3\x76\xac\xcd\x4e\x4b\x4e\xcb\x4c\x4f\x8c\x4f\x8a\x4b\x8e\x65\xda\x13\xb7\xd7\x6e\xd1\x62\xc2\x1c\x8b\x2b\xce\x0a\x30\xbe\xde\xb0\x5a\x3c\x39\x14\xfa\x23\xf7\xe5\x0c\x26\x6c\x95\x7f\xc2\x52\x6d\x64\x64\x61\x71\x94\x78\x7a\xd1\xb5\x35\xdd\x31\x21\x29\x41\x99\x41\xf9\xcc\xca\xf7\x3e\xdf\xfe\xa5\xb6\xfb\x93\xd6\x53\x97\xc5\xc5\x47\xf5\x1f\xb5\x1f\x6a\xd8\x5f\x27\x84\xd5\x1f\x8c\x39\xa2\xb5\xf9\xc5\xb0\xfa\x43\x31\xed\x5a\x15\xe5\x24\xb3\x86\xeb\xc5\xb0\x3a\x6b\xf8\xdd\xd3\x9d\x97\x45\xa0\x15\xc6\x02\x70\x3c\x04\xbb\x40\xf5\xd5\xf7\xee\xdf\x3f\x3c\x01\x89\xe0\xa2\x51\x9e\xe3\x1f\xfd\x18\xb2\xe0\x86\x30\xd8\x8b\x3a\xb1\x61\x59\xfd\x32\x2d\xba\x0f\x44\x7b\x74\x43\xb7\x67\x68\x0f\xee\x8f\x7f\x7f\xef\x59\x8d\x88\x61\xe0\x06\xcf\x69\xe3\xae\xc2\x5d\xd1\xa0\xe5\x2f\x71\x1e\x2c\x88\x2c\xcc\x01\x6f\x87\x25\x6c\x8f\x89\x9b\xc8\x87\x8c\xde\x96\xb1\x41\x48\x5d\xbe\x2c\x53\xaf\x9d\xe8\xbd\xbf\xea\x65\xb1\x7c\xc1\x82\xe2\x05\x5a\x54\x20\x13\x17\x8e\x72\xf1\x13\xc5\xdd\x43\x97\xee\xfc\xa4\x81\xfe\xc3\x7f\xc5\xfe\xd8\x7f\xf8\x70\xec\x3f\xfe\xd2\x94\xbb\x5b\x05\x5d\xcf\x3e\xf0\x86\x7b\x8a\xbd\xd0\x0f\x54\x0d\x30\x00\xa6\x82\x6a\x09\x8c\xd0\x82\x03\xf4\x6b\x38\xf8\x97\xb8\xaf\xac\xa1\xf9\x80\x46\x29\xed\xc7\xd9\xa0\x9e\x08\x6a\xa8\x79\xb1\x2e\x67\xb2\xcd\xc1\x3d\x04\xb5\x8b\x01\x38\x70\x01\x4e\xf2\x03\xb5\x39\xc9\x0a\xb2\x05\x55\xa7\x25\xd0\x4b\x6a\x0e\x7e\x67\x75\xd4\xc5\x77\xb9\xd1\xdd\x0b\xd1\x19\x89\x36\x25\xba\xc0\x94\x2e\x16\x6d\x0d\x5b\x1f\xb5\x2b\x78\xeb\xda\xc4\x40\x63\xd4\x0c\xef\xf5\xbe\x6d\xcc\xb6\x6d\x81\x89\x6f\x6a\xbd\x7d\x2e\xbc\xb7\x48\xc4\x4e\x38\x43\x1d\x0e\xde\x98\xb5\x56\x2b\x75\xc0\x58\x85\xea\xac\x04\x13\x60\x02\x75\xf2\xe4\xe5\x96\xf7\xb4\x1f\x7f\x5e\xb1\xed\x8a\x88\x73\x71\xc3\xf4\x71\x06\x74\xfb\x62\xac\xfb\x5f\xa8\x86\x80\x5c\xb0\x07\x67\xc6\xfa\x5e\x67\xf0\xf8\x69\xf4\x97\x83\x6e\x7b\xba\xc3\xc4\xa5\x5c\xd6\x85\xa8\xb3\xa1\x27\x56\x7d\x18\x78\x2d\xe0\xca\x96\xd3\x1b\x4e\x6d\x3e\xdd\x78\x6d\xd2\xd9\x35\x2b\x71\x39\x6e\x77\x5b\xb2\x60\x50\x81\xff\x27\x41\xa7\x0d\x57\x8e\x9e\x86\xcd\x90\xe3\x76\xf2\xc8\xc5\xd6\x77\xb4\x30\x8d\xbe\xfa\xe1\x8e\xc0\x93\x22\x8c\xc7\xf9\x94\x2a\x46\xfa\xd9\x62\xa2\x41\xef\x0a\xbf\xb3\xa0\x97\xba\x83\x58\x04\x1a\xdc\x50\xe1\x03\x4e\xe8\xaf\x55\x9d\x96\x70\x1a\xfd\xda\xeb\x31\x41\x2b\xc4\x23\x2b\x5e\x6f\x78\x4d\x8b\x8e\x34\xce\x9a\x86\x32\x64\x90\x11\x2d\x53\x5e\x66\x7b\xbd\x15\xaa\x18\x69\x02\x0b\x3d\x34\x9c\xc0\x76\x18\x80\xfd\x61\xd1\x54\x98\xf2\xb3\xfb\x8f\x59\x3f\x9e\xbc\x74\xfd\xb3\x9a\x8f\xce\x9e\xfa\xf0\x7e\xd5\xed\x77\x8f\x7c\xcf\x48\xf3\x68\xd5\x59\xc9\x9b\x57\xc2\x62\x16\x36\xea\xa8\x0d\xb0\xd1\x21\x81\xef\xa1\x39\x53\x8e\x29\xb3\x44\x18\x74\x3f\xbf\xc2\x52\x2f\x39\x33\x67\x16\xa2\xfc\xf1\x64\xed\x64\x74\x18\xba\xe6\x75\xd1\x52\x6f\x71\xce\x4f\x1d\x34\x96\xc9\xcc\xca\x49\x4f\xd7\x3c\xdf\x72\x91\xb5\x7c\x20\xf1\xdc\xf2\x99\xe8\x82\x0a\x74\xd3\xe2\x4b\x38\x00\xa8\x77\xa6\x8b\x38\x0e\x28\xb4\xbb\x3d\xed\xfd\xa4\xf2\xdc\x86\x8a\xea\x63\x17\xdc\x2a\xaa\x1b\x8a\xaa\x53\x6f\x2f\x05\x99\x0f\x8c\x43\x8a\x79\xf3\x0a\xc8\x87\x7e\xa3\xfd\x06\xe4\xbf\x9f\xb9\x22\xc2\x38\x90\x83\xec\xab\xdb\xef\x56\x57\x34\xe4\x56\x24\x1d\x7b\xc3\xad\x22\x29\x37\x26\x29\x6d\xda\x62\xb4\xf3\x41\xeb\xf3\x36\x55\x18\x26\x50\x67\xb3\xb6\x15\xc4\x4b\x66\x07\x2e\xb5\x3a\xa6\x28\x29\xf5\xd5\xe5\xc3\x7d\x71\x28\x52\xcc\xe6\x80\x61\x63\xe6\x6a\x0d\xf9\x06\x83\x21\xdf\xd0\x6f\xd0\xdc\x61\x3f\x1f\x0b\x10\x71\x10\xd8\x8d\xfc\xec\xd5\xae\xa4\xca\x5d\xb9\xa9\x89\x5b\xde\x70\x4b\x4d\x2a\x8a\xad\x4e\xfd\xf5\x15\x88\xc0\x57\x2a\xd2\x99\xa5\x37\x1e\xfa\xfc\xa9\x35\x14\x18\x0c\x42\x01\xfd\x67\xfe\xc3\xaf\x6e\xbc\x5b\x5e\x06\xf1\x30\xf7\xf7\x5b\x55\x15\x45\xf5\xa9\xd5\x0c\x8c\xec\x1d\x57\xc3\xeb\x7a\x7c\x53\xd9\x1e\x6f\xc5\xef\x3f\x27\x66\x48\x1b\xa1\x87\x39\xde\xf9\xdb\x2f\xd7\x6d\x11\x0d\x05\x86\x7e\x83\xae\xff\x36\x7a\x53\xa7\x28\x6d\xc4\x9e\xc4\xb2\xdf\xc7\x30\xcf\xbd\x6d\x3a\xdc\xb8\x23\x89\x87\xc3\x5b\x04\x5c\x0d\x8b\xd0\x08\x73\xd1\x0d\xec\x98\x77\xe7\x8e\xf8\x6a\xb0\xd6\x96\x49\x6b\x36\x07\x8f\x98\xb6\x74\xae\x88\x83\xd0\x11\x53\x71\x0a\xae\x47\x7f\x26\x3c\x32\x31\x24\x48\xf3\xdc\x1b\x4a\xf8\xea\x5d\x2e\xe6\xc6\x03\x59\xd5\xc5\x6d\xdf\x37\xdd\x6d\x00\xc7\x2a\xd5\xc7\xf0\x4d\x01\x17\x08\x29\x10\x8a\x21\x87\x31\x95\x6a\x49\xe1\xb6\x40\x01\x74\xc1\xb6\x0a\xcc\xa3\x2c\x77\xa4\xc9\xdc\x02\xb8\x01\x79\xb8\xee\x2c\x7e\x45\x35\xa7\x72\xab\xe0\x1e\x3c\x85\xd5\xd5\xf8\x25\x75\x00\xa3\x39\x55\x63\x65\xd1\x27\x69\x65\xc2\xbf\xae\xdf\xba\x40\x95\x95\xe4\x54\x97\x69\x54\x5d\x7f\xf8\x14\x62\x06\xd5\xdb\x61\xee\xe6\xc6\x49\xaf\xc1\x41\x9c\xf9\x89\x65\x33\x65\x6e\xb0\x6c\xe4\x30\x04\x67\xe4\x41\x26\xc4\xc3\x64\xaa\xb7\x12\xc2\xb9\x79\x52\xa8\x34\x0d\x26\xd5\x5b\x16\x52\x52\x94\xe5\x1d\x6e\xfe\xdb\xa5\x40\x0a\x8a\xf2\x8c\xb9\x85\xee\xe8\xf9\xa0\xf0\x29\xec\xc2\x41\x14\xbc\x32\x9a\xc3\xe9\xa8\x69\x80\x58\x78\x15\xd4\x14\x6e\xb7\xb8\x73\xc6\xdc\x62\x83\xb1\x08\x96\xc1\x68\xb7\xc2\x82\xc2\xa2\x22\x4d\x51\xf3\x21\x88\xce\x2b\xcd\x2f\xca\x2b\xcc\x2b\xc4\x3c\xd0\xba\xa9\xea\x73\x0b\x73\x0c\x39\x79\xb8\x01\x5d\xdc\x72\xf3\xf2\x72\x72\x35\xb9\x68\x3f\xe9\x9d\xdc\xc2\x6c\x43\x6e\x9e\x3b\xf6\x9f\x99\x0d\x03\x28\xeb\xdb\x0a\x04\x74\xf9\x16\xd8\x0f\x28\x63\x61\xa1\xd1\xa8\x89\x91\x36\x52\x45\xb9\xc6\xdc\x42\x01\xaf\xc3\x68\xaa\x20\x37\xd7\x90\xa7\xb5\xcc\x45\x6d\x76\x5e\x6e\x76\x41\x96\xfb\x43\xcb\x96\xa2\x14\x60\x26\xd5\xa4\xb8\xab\x1a\x47\xbf\x99\x9d\x9b\x97\x5d\x90\xe3\x7e\x13\xff\x2c\x4c\xfb\x7a\x4e\x65\xaa\xbb\xaa\x6b\xd1\x96\x5c\xeb\xa3\x39\xee\xc5\x11\xe7\xd0\x50\x9c\x0d\xb1\x98\xed\x56\x98\x57\x64\x28\xca\x67\x0a\x0b\x0b\x0a\x0a\x45\x78\x0b\x92\xa9\xa2\xc2\x82\xa2\x22\x4d\x26\xbc\xfc\xeb\x64\x63\x6e\x89\xc1\x58\xe4\x0e\xc9\xb0\xf8\x05\xb8\x0c\x1c\x29\xa5\xc7\xdf\xea\x29\xd1\xef\x2c\xd4\xd8\x76\x7e\xfc\xa0\xda\xa7\x93\x1f\x83\xf3\xdc\xb0\xd7\xe6\x4c\x13\x2c\xdd\xf4\xb4\xd7\x6e\xfc\x06\x73\x4f\x41\x00\xcc\x13\xb7\x5d\xfa\x5c\x7f\x47\x7b\xe7\xf3\x4b\x07\x2f\x89\x30\xef\x14\x06\xe0\x5c\x11\x67\x4a\xf7\x38\x1c\x8c\x8e\xc8\xe0\x60\xab\x0b\x0c\x0c\x06\x4f\xe8\x73\x07\x83\x15\xee\x29\x98\x9d\x2c\x47\xfd\x79\x2b\x97\x9c\xc4\x83\x7e\x19\x3f\x92\x56\x7d\x09\x6a\x58\xc1\x82\x5e\x51\x97\x54\x1d\xf7\x0d\x5f\x57\x5d\x5d\x27\x2a\x3d\x72\xd9\x17\x9b\xe4\xed\x5e\x98\x20\x72\xe8\xa9\xea\x71\xe2\xc0\xd3\x9a\x70\xdf\x0b\xac\x09\xa2\x2d\xe1\xbe\x17\x58\x5f\x24\x04\xe2\x4e\x6e\xd3\x82\xf9\x81\x3e\x5a\x9f\xf9\x67\x8f\x2f\x10\xb3\x69\x5c\x14\x86\x49\x38\x70\x52\xd7\xcb\xf7\x45\xa9\x9b\xbe\xdf\xf5\xdd\x5d\x18\x1a\x06\x31\xb8\x4c\x34\xfb\x82\x89\x03\xbd\xa2\x36\x71\x77\xfc\x37\x3c\xbc\xc6\x5a\x33\x46\xbf\x70\x23\x58\x34\x3d\x37\xd5\xf0\x3a\xf4\x4d\x65\x75\x54\x57\x37\xab\x93\x77\xc1\xab\xbc\xcd\x50\xbf\xc9\x5a\x5f\x35\x27\xaf\xdb\x2a\xce\x24\x39\xb1\x10\xcb\x4a\x76\xbc\xea\x6e\x8f\x49\x1a\xce\x79\xfb\x2f\x9c\x23\x58\x4c\xf4\x1c\xff\x2b\xdf\xc3\xd8\x63\xe0\x0b\x13\xc4\x1d\xe7\x3e\x0a\xec\xd6\x76\x7f\x74\x76\xef\x39\x11\x26\x1c\x43\x5f\x1c\x2b\xe2\x78\xa9\x96\x53\x79\xa2\xcb\x10\x2f\x74\x46\xe7\x21\x8f\xc1\x05\x9c\x9f\x3c\x01\x67\x41\x75\x17\x9c\x9f\x0c\x41\x67\xb1\x67\xbc\xa5\xc4\xb6\x15\x6e\x3f\x2b\x75\xfb\xb3\x7e\x0a\xa8\x92\xc7\x24\x24\xc4\x08\x96\x6b\x74\x4c\x42\x4d\x83\xf8\x8e\xa2\xa1\xa6\xa6\x41\x90\xae\xd1\x0d\x35\x09\x31\xe2\x32\x05\x14\xcb\x55\x53\xfb\x36\xcf\xa9\xee\x46\xff\x1d\xcb\x04\xdd\xdc\x4a\x56\x67\xf6\x0d\x65\xe1\xe9\x43\x7a\x26\x3f\xd2\x6c\x7a\xf8\x0a\x3b\x12\x9e\x2a\x36\xb2\x2f\x0e\x29\x4a\x6a\xf8\x9e\xef\xab\xf1\x15\xbc\xd9\x04\x31\xac\xad\x34\x30\x76\x33\xf8\xe2\x04\x61\xc7\xaa\x05\x81\xb3\xb4\xb3\x16\x9c\xdd\xbb\x4a\xc4\x09\x9b\xad\x25\xf0\xbe\xbc\xf0\x86\x28\x99\xe8\x1b\x97\xaf\x7c\xdf\x57\x1a\x70\x1e\xf2\xc4\x56\x96\x21\xe8\x8c\x2e\x4f\xbc\xc0\x19\x9c\x9f\x3c\x06\x17\xa1\x67\xbc\x65\x29\x78\xb0\xf0\xa9\xbc\x21\xa1\xe6\x45\xf6\x6d\xf9\xb5\x19\x31\xb4\x65\xbf\xa6\x41\x84\x4f\xe5\x43\x59\x4b\xf7\x78\x56\xea\x86\x1b\xec\x73\x75\x0d\x8f\x4f\x1f\xc2\x42\x7e\x64\xaf\xe9\x21\xbc\xce\x8e\xc4\xa7\x8a\x16\x2b\x1e\xba\x59\x1d\x6d\x45\x86\x0e\x7d\x15\xa0\xd6\xc9\xbb\xfe\x2e\x9c\x8e\xee\xfa\x90\x05\x6f\x56\xea\x78\x68\x36\x81\x29\x97\xd7\x51\x7f\x42\x00\x87\x2b\x51\xc4\x38\xe4\xb0\x52\x8b\x95\x18\x07\x1c\xac\x44\x51\x6c\x83\xc5\x5f\xc0\x54\x98\xd1\xcc\x8c\xfc\x01\x54\x8b\xc0\x43\x0b\x1e\xa0\xfa\xe0\xe1\x0f\x22\xcc\x88\xfa\x02\xa7\xb6\xe1\x62\x06\x73\xcc\x8b\xb9\x14\x56\x32\xa1\x89\x33\xb2\xff\xd9\x40\x9d\x2e\x0d\xb1\x78\x49\x19\x52\xa6\xe4\x29\x0d\x95\xd2\x04\x65\xa3\x8e\x4a\x85\x0d\x7c\x8f\x1a\x1a\xfe\xd7\x53\x69\x92\xa7\x65\xa8\x94\x29\x65\x49\x83\xa5\x61\x52\xaa\x91\x15\xa5\x7f\xeb\x7a\xde\xe2\xe0\xd5\x20\x6f\x18\x86\x7e\x5a\xa8\x61\xd1\xcf\x1b\x87\xe1\xab\x41\xe2\x18\x50\x2f\x83\xf1\x30\x43\x03\x4b\xf8\xbf\x77\x6c\xe0\x8c\x65\x38\x7e\x0c\xaa\x05\x4c\x31\x6b\xb9\x14\x56\xd9\xa7\xb6\xca\x74\x81\x85\xdb\xac\x83\x4e\x7e\xcc\x9c\xc9\x75\xde\xde\xf7\xf3\xef\x1a\x68\xc7\x78\x88\xc7\xf6\x0f\xf9\xa1\xfb\xc6\x74\xfa\x08\x38\x70\x03\xae\x40\xd1\x12\xa8\xc1\x0d\x30\x1a\xa7\xc1\x12\xc1\xfc\x80\x86\x25\x30\x1a\xa6\xc1\x06\x29\x10\x57\x80\x88\x03\x3b\x44\xcb\x5c\xb3\x27\x27\xa9\x79\xf4\x3d\xca\x63\x30\x3c\xe2\x21\x18\x1c\x58\xe9\x15\x5d\x8f\x8c\xeb\x7d\x40\xa3\xe3\x48\xb0\x03\x1d\x7c\xf2\x0c\x02\x60\x55\xb9\xe8\xf3\x13\x38\x06\xf6\x9d\x3c\x74\x3c\x7b\xfb\x27\x11\x56\xa5\x3d\xc3\x00\xfc\x44\x83\xba\x91\x68\x87\x8e\x82\xd2\x92\x92\xcb\xc2\x26\x9b\x12\x59\x87\x1e\x13\x1c\xe0\x60\xdc\x26\x98\x89\xe3\x85\x35\xab\x16\x6c\xb7\xd2\xcf\xbe\xb7\x56\x89\x38\x7e\x13\xce\xc4\x71\x2f\x5f\xf6\x7b\x41\x3f\x57\xbf\x13\x71\x8c\x54\xc3\x81\xb3\xe7\x13\x54\xa1\xca\xd3\x46\x3f\x7f\x78\x81\x0a\x54\x7f\x58\xe9\x07\xda\x9f\x3b\xd7\xf0\xcf\xf5\xd6\xb6\xb8\xae\xc7\xa4\xeb\x69\xb4\x22\xde\xa6\x6d\x12\x9f\x8e\xa4\xe1\x3a\xff\x10\x9f\x2a\x96\xb1\xba\x1e\xdf\x20\xbe\x47\xff\x21\x6b\xa3\xe9\x6e\xd0\x83\xfa\xe0\xc1\xab\xa0\xbe\x65\x3b\x79\x63\x36\xc1\x13\xb6\x47\x0d\x5f\x72\xb3\x02\x97\x2c\x11\x2c\x33\xe8\x25\x81\xef\x75\x83\xdb\x41\x18\x05\x6e\xe2\xc6\x13\x97\x22\x3f\xd0\x7e\x70\xa9\xe5\xc4\x09\x11\xdc\x0e\xe2\x28\x74\x13\x51\x2d\x2d\xe1\xe0\x4b\xf6\x21\x2f\xf4\x98\x2c\x51\x5c\x05\xeb\xa7\xb0\xa8\xc1\xc4\x4d\x65\xb1\x9b\x8e\x4b\xaa\xae\x13\xaf\x6e\x65\xfd\x14\x92\xda\x35\x2e\x29\x29\x4e\x40\xfd\x0b\x20\x5c\xb0\xb5\x3b\xb9\x35\x82\xce\x9c\x0a\x4f\xb9\x87\x81\xbc\x8e\xee\xf2\x67\x47\x2a\x40\xfd\xf0\x9f\x04\x6b\xcd\xeb\x14\x9b\xc6\x64\x6b\x2e\xa3\xac\xbe\x72\xde\x96\x4f\x70\xdb\x06\xa3\xd0\x4d\xd8\xb8\x51\x1f\xb9\x48\xbb\x48\xdf\x72\x62\xa3\x88\x6e\xdb\xac\x79\x9b\x75\x76\xc9\x7b\xa2\x34\x83\x7e\xef\xec\x7b\xdd\xb6\x7c\x6e\xe7\x7b\x4c\x16\x6f\x7f\xbe\x57\x3f\x9e\x35\xeb\x27\xf1\x16\x35\x74\x73\x56\xb6\x2a\x60\xf7\x78\x16\xf4\xac\xa4\xbe\x0a\x93\x59\xbf\xdf\x59\xe8\x96\x0f\x65\xfb\x1e\x83\x1b\x6c\xaf\x95\xcd\x99\xad\xf2\xc2\xd3\x04\xfe\xf9\xd3\xff\x43\x8b\x6a\x44\x13\x14\xed\x80\x71\x28\xdb\x25\x69\xc1\xd7\x7c\x0d\xc6\xb9\xec\xd3\xd1\xef\xa9\x7c\x74\xf2\xfb\xe6\x34\x0e\xa7\x45\xa3\xf6\xcd\xa1\x82\x6a\x35\x38\x4e\x1f\x71\x1f\x97\x69\x55\x3e\xa8\x1c\xb5\x71\xe5\x12\xf1\xdc\x08\x4a\x55\x5b\xd9\xba\xc7\xb8\x47\x0b\x83\xba\x71\x00\x2a\xaf\x88\x06\x45\xca\xc6\x75\xd9\x81\x5a\xec\x42\x57\x08\x96\x26\x8a\xaa\xd5\xd2\xcb\xe0\x0a\x5b\xa1\x0b\xde\x05\x57\xdc\x6a\x79\x59\x50\xf9\x48\x9a\xde\x7e\xdc\xf2\xac\xa0\x79\xe3\xb5\x53\x96\x5c\xfe\xce\x5f\x54\xd5\xc2\x5c\xe0\x41\x09\x21\xb0\x5b\x23\x6d\xb5\xbc\x04\xd7\x2d\x23\x2d\x83\x2d\x3a\xbc\x69\x09\xb6\x6c\x92\xb4\x78\x53\xf2\xbc\x7e\xdd\x54\x77\x4d\x30\x28\x50\x73\xfb\x4f\x54\xc0\x2a\x2d\x7c\x75\x04\x2e\xde\xcc\x14\x95\xd2\xfe\x60\x70\xd3\xc9\x7f\x8a\xb1\x33\x80\x93\x79\x04\xf8\x41\x0d\x38\xde\x85\x61\xd2\x2f\xe0\xe2\x20\x05\x78\x71\x87\x57\x9d\xd9\xd5\x2c\xac\xb8\xf8\xe6\xc5\xcd\xd7\x98\xf1\x30\x66\x2b\x78\xc3\x5c\x0d\x4c\x39\x0c\x83\xbe\x85\x41\x42\xc7\xa7\xe7\xdf\xbd\x74\x99\xa9\xaf\x3f\xdd\xb1\x5f\xd3\x16\xde\x10\xb1\x74\x38\x52\xeb\xb6\x0a\x38\x18\xfd\xe6\x62\x20\x26\x6a\xb0\xf0\x53\x8c\x87\x71\x18\x20\x1c\x5e\x77\x73\xd2\x3b\xc9\x8c\x41\x91\x6f\x2c\xce\x33\x6a\xf7\xb6\xb6\xed\x15\x75\xd4\x2b\xa0\x09\x62\x9f\x7f\x44\x6f\x8a\x08\xdd\x32\x86\x17\x7b\x3e\xa2\x8f\xb7\x1e\x38\x2a\xe2\x36\x09\x38\x10\x83\x7e\x1f\xf1\x87\x50\x9b\xf0\x46\x57\x84\x36\x2b\x27\x37\x53\x8c\x38\xb1\xea\x4d\x4d\x58\xcc\xae\xd0\xc0\x94\xa7\x87\xb2\x84\x48\xf0\xd8\xfe\x18\xc5\x8f\x98\x9a\xad\x1b\xaa\x82\xb4\x29\xdb\x73\xe3\xd3\x2a\x32\xcb\x72\xc4\xba\xd4\x3d\xc1\x15\x71\x4c\x7d\x68\x49\xf8\x16\x5c\x86\x19\x38\x0b\x03\x35\xe8\x03\x8e\xa8\x81\x31\xcb\x04\x83\x22\xaf\xb8\x39\xbd\x58\x6b\x32\x15\x57\x54\xa4\x17\xa4\x17\x89\xc1\xd5\x51\x75\xbb\x0e\x30\x21\x9d\x19\x9d\xef\x83\x3b\xf8\xb5\x80\xfb\xf9\x6d\xbb\xab\x35\xa6\x22\x83\xe9\xd0\x5b\xfa\x9d\xd5\x82\x29\xb6\x20\x6b\xd7\xf6\xdc\xb0\xed\x9a\x75\xf5\x5b\xdf\xde\x73\xbc\xe6\xa0\xd0\x9a\xd8\xdc\xa2\x29\x32\x14\x16\x55\xb7\x6e\x4b\x2b\x15\x5a\xb6\x54\xac\x5a\x8b\x1a\x54\xce\xdb\xae\x49\xdf\x9d\x5e\x66\x2a\x2f\x2e\x2e\x13\xba\xf6\x7c\xfc\xe1\xa1\x73\xcc\xd9\x1b\xf5\xb7\xee\x6a\xcc\x41\xdb\xb9\xc6\xfc\xa6\xfc\x46\x21\x11\x22\xfc\x61\x21\x6a\x60\x3e\xf3\x76\xf0\x28\x50\x2e\xd0\x46\x84\xef\x8c\x08\xea\x7c\xb3\x39\x52\xbc\x31\xf3\xed\x85\x67\xc6\x32\xdd\x38\xbc\x01\xdd\x71\xb2\x06\x03\x97\xe0\x1c\x74\xc2\x71\xc2\xf6\x2d\xe8\x88\x76\x21\x9a\x5d\xad\xe1\x8d\xf7\x40\x80\x95\xd7\x4f\x0a\xf7\x60\xe4\xdb\x30\x07\xe6\x68\x94\xa7\x58\x9d\xbc\x0d\xe2\xb8\xd4\x55\xdb\x53\x36\x34\x63\x14\x4c\x71\x43\xd9\x60\x2a\x25\x25\x2d\x2d\x4a\x5b\x03\xb1\x14\xdc\x62\xa5\x89\x12\xa9\xab\x89\x36\x45\x26\xb8\x5b\xca\xf1\x0b\x0c\xff\x34\x70\x77\xfe\xa1\xf7\x9a\xdd\xcd\x4f\xe1\xbb\x13\xbb\xdb\x23\x93\x17\xb9\x4b\xab\xb1\xfd\xc5\x11\x87\xf9\x7c\x8f\x88\xea\xe7\xe2\x20\x76\x3e\x6f\x16\x51\xdd\x6b\xf3\x49\x22\xaa\x2d\x36\x1f\x88\xa8\x46\x71\x10\xdb\x9b\x02\xe3\x59\xb3\xfa\x08\x6b\xeb\x29\x0d\xa0\xf6\x03\xbd\xaa\xb7\xd1\xac\x06\x3d\xf7\xe7\xbf\x7e\xf0\xf0\xf8\x97\xf7\xa0\x4b\x2c\xa8\x5d\x71\x2e\x0e\x96\xec\x79\x9c\x2b\xa9\x59\x98\xfb\xb4\xf3\xfe\xad\xf7\x04\xb3\x49\xf1\x90\x17\x7a\x4d\x8a\x5b\x4b\x3a\xc7\x0e\xd2\xa8\xd2\x7d\x41\xed\xaa\xa2\x52\x41\xb9\x0a\xec\x7d\xbe\x16\xcc\x81\x0a\x2b\xcc\x1a\x05\xe7\xbe\x48\x40\xe8\x0d\x54\xf8\x4c\x5d\x85\xf6\xa8\xec\xe2\x55\x54\xaa\xcd\xd0\x9c\x08\xbd\x3c\xea\x69\x55\xba\x0c\xd5\xa0\x57\x48\x6a\x39\xea\x51\x4d\x5b\x23\xeb\xe9\xff\x84\x62\x3d\x40\x4f\x2b\x61\x38\xa8\x7f\xe3\x5f\xc8\x2a\x66\xd3\x6f\xbc\xea\x60\xb9\x8e\xaa\xd6\x51\x0a\x6e\xca\x1d\xa0\x59\xf7\xb5\x6b\xd1\xfe\x7b\xf4\xaa\x47\x97\x95\xee\x0f\xc7\xa0\xeb\xfb\xe8\xa9\x85\x03\xac\x0e\x65\x60\xca\xe3\x15\x7e\xfc\x27\x57\x76\xae\x7d\x4b\x98\x89\xee\x95\x38\xed\x11\x2a\xd7\xae\x75\xbb\xc7\xdf\x99\xe2\x56\x95\xdc\x60\xa8\xaa\x32\xd3\x66\xda\xed\x09\xcf\x4c\xc0\x1a\x6e\x21\x0f\x26\x54\x73\xbe\x7c\xfb\xf6\x7d\xc1\x69\xb6\x21\x10\xb7\x90\x57\xc9\x47\xf4\xaa\xcf\xb1\xa0\xf7\xe3\x40\xce\x83\x03\x0f\xdd\x57\xad\x60\x46\x6f\x03\xff\x9f\x62\x38\x0d\xb3\xa8\xd1\xf4\xbf\x81\x3d\x96\x58\x6c\x31\x5c\x17\xf2\x2a\x5f\x0f\x54\x9f\x63\x55\xa9\xbe\x56\x47\xd9\x28\x99\x20\x84\x85\xab\x3c\xa8\xe1\x07\xde\xea\x76\x83\x5a\x95\xea\xeb\x71\x82\x97\xf4\x9c\xae\x47\x86\x7a\x1a\xe9\x4e\xaf\x5b\x73\x04\x5c\xa4\x88\xae\x8e\x83\xcd\x7c\x5d\x93\xa8\x4a\xf5\xf0\x00\x7b\x45\xd2\x89\x53\x19\x67\xb4\x66\x13\x7d\xe6\x54\x59\xf5\x09\x11\x59\x85\xaa\xeb\x53\x59\x06\x0b\x2b\x14\xb7\x6e\x74\x3e\x06\x5a\xa3\xf2\x60\x64\xcf\xf5\xd2\xd3\x24\x5e\xe5\xa4\x96\x5d\xfd\x93\x55\x31\x8c\x0c\x42\x79\x95\xdc\x49\x06\x6a\xd7\xad\xbc\x8a\xb1\xef\x0b\xcb\x6d\x8e\x3d\x23\xeb\xe9\xb6\x98\xfc\x79\x5d\x8f\x47\x9f\xc2\x3b\x41\x25\xb7\x93\x1d\x3e\x90\x1c\xdd\x2c\x6e\x99\x5f\x32\xe9\xec\xa2\xe8\x68\xb7\xac\x2c\x43\x5a\x49\xd6\xc9\xf5\x6e\x25\x59\xe5\x86\x92\x12\xf8\x18\x3e\x76\x2b\x29\x31\x94\x67\x95\xac\x3f\xe9\x96\x55\x92\x66\xc8\xca\x62\x54\xf6\xf6\xb2\xe8\x68\xfd\xa9\x99\xa6\x85\x11\xee\x67\x57\xbf\xb6\x7f\xb6\x16\x0e\xf2\xbd\x6a\x85\xca\x4e\x2e\x1b\x39\xde\xca\xa3\x27\xf1\xcf\xd5\x92\xc9\xc6\xed\xad\xfd\x50\x5c\x75\x52\x9d\x55\x94\x16\xfc\xae\xfe\x07\x76\x86\x17\x54\xf6\xb2\xd4\x33\xfc\x48\x76\x14\x2b\xa8\xec\xec\x7c\x6d\xb9\x56\x82\xc8\x16\x80\x0a\x5c\xc1\xd5\x5c\x0a\x6a\x70\xb1\x76\xdc\xbb\xe0\x11\x07\x5a\xb4\x3b\x84\x0a\x54\xa0\xdd\x56\xd4\x2e\x28\x5d\x50\xfe\x9a\xb0\x7b\xf0\x6e\x8f\xd6\x21\xcc\xac\xba\x4f\xe2\x3f\xd2\x7e\xf4\x49\x6d\x77\x9d\xd8\xfa\x64\xf7\x5f\xbb\xff\x64\xca\xaf\x95\x7e\xf4\x91\x46\x3a\x2e\xf9\x70\xd2\xeb\x16\x05\xfc\x65\xf1\xdf\x21\x58\x5e\x8a\xc4\x6b\x78\x3d\xd6\xf2\x52\x3c\xfe\x02\x1b\xf1\x1c\x74\x22\x53\x91\x5d\x55\x9e\x57\x99\xd3\x94\xdb\x94\xd3\x92\x57\x93\xb7\x3b\xaf\x3a\xbf\x38\xb7\x38\xbb\x10\x37\xff\x89\x43\x60\x5b\x1e\x14\x32\x79\x70\x0f\x9a\xa0\x03\xee\xd5\x31\x12\xd5\x00\xef\xe1\xdb\x16\x3b\x0d\x16\xa2\x27\x86\xe2\xa6\x81\x42\x76\x5e\x6e\x4e\x7e\x56\x5e\x62\x5e\x42\x5e\x42\x4e\x54\x6e\x74\xee\xae\xbc\x94\xca\xb4\x0a\x23\x03\x47\x81\x82\xd5\xb0\x1f\xbe\xd4\x58\x8e\x1f\x4c\x64\xa1\x63\x1b\x07\xa7\x31\x07\x92\xf1\xed\x24\x01\xeb\x52\x30\x14\x23\xb2\xb0\x3e\x17\x67\xdc\xc6\x91\xe0\x34\xb2\x3c\xa3\xba\xb4\xb0\xb2\x68\x5f\xd9\xa1\xba\x03\xc6\x92\xfc\xb2\xac\x92\x7f\xdd\x0a\x00\xa6\x0a\x5c\x6a\x61\x1e\x78\x82\x17\xcc\x6d\x60\x20\xa1\x15\x02\x70\x01\xee\xd2\xa0\x3c\x70\xe8\x2b\x73\x85\xac\xac\xfc\x0c\x63\x56\x5d\x68\xd9\xd6\xa2\x1d\x85\xc9\xd5\x99\xe5\x65\x0c\xf4\xff\xf9\x36\x0c\x83\x29\x1a\x65\x23\xaa\x8f\xb1\x79\xbc\xcd\xf6\x16\xa8\x39\xb3\x29\x8f\xef\x35\x29\xc0\xd4\xf3\xf4\x30\xdf\x88\x6a\xc9\x04\xe3\x78\x88\xb2\x76\xaf\x3d\xbe\x6b\x58\xd4\x43\x09\x0f\xfb\x25\x67\x5b\xeb\x34\xbf\x18\x4d\xdc\x61\xad\x63\x8c\x3b\xac\xea\x2f\x30\xb9\x4a\x26\xb3\x49\xa1\xea\xb1\x58\x13\x91\x4c\x1c\x3c\x05\x91\x1f\x69\x7d\xb6\xd7\x44\x83\xc9\xfc\x94\x5b\xc9\x3e\xd7\xaf\x61\xf1\xa9\xe5\xa9\x42\xf5\xd7\x32\x9b\x0e\x91\x1e\xfd\x2a\x16\x9e\x4a\x36\xe9\xbe\x11\xd5\xf0\x9d\xb9\x07\xbe\xcb\xe5\x75\xf2\x4a\xd8\xc6\x25\x27\xc7\x18\x92\xab\x30\x09\x92\xdc\x30\x09\x93\xfa\x82\xee\xe8\x05\x5e\xc9\x55\x86\x86\xaa\x2a\x77\x48\x82\x24\xeb\xed\xbf\x83\x5e\xe0\x55\x55\xd5\x60\xa8\x4a\x76\xef\x83\x43\xd2\xdf\x41\x2f\xf4\xaa\x4a\x36\xc4\x24\x27\xbb\xa3\xed\x0e\x26\xbd\x08\x4a\xdb\x7a\xc8\x61\xbe\x11\x6e\x5b\xe5\x2e\x93\xad\x3a\x74\xf2\x5f\xa4\xe9\xdc\x13\x1e\xa7\xc3\x74\x37\x98\x0e\xd3\x9f\xf0\xb6\x97\x5a\xf9\x0f\x4e\xb7\x7e\x61\xba\xcd\xef\x85\x5e\xf7\x78\x77\x98\xde\x07\xb4\x7a\xbd\xd0\xeb\x19\x6f\x8d\x62\x05\x3e\xe3\xad\x19\xa2\x9e\x27\x61\x27\xd7\x63\xca\xe3\x9f\xff\x5d\xbb\xa7\xd8\x9e\x4b\xd0\xc3\xf5\x0e\xa2\xe1\x3d\xe9\x03\xca\x3c\x88\x96\xbc\xff\xc3\xdc\x9b\xd1\x04\x6b\xcd\x49\x30\x01\xc7\xd6\x3c\xe8\x2a\xba\xb8\x01\xa8\x6f\xe0\xa5\x8b\x87\xae\xc7\xbc\x07\x82\x8b\xf4\xfd\x1e\xa0\x3f\xb8\x7c\xb1\xa8\x6b\x2d\x8c\x1f\x71\xac\x19\x96\xdd\x7d\x57\xb5\xd7\xec\xab\xa3\x48\xcf\x19\xee\xfd\xf9\x13\x22\x77\x1e\xda\x71\xe8\xc2\x07\x07\x83\x18\x8b\x07\xe6\x73\xe5\xe5\x86\xda\xb4\x72\x46\x45\xcb\x52\x53\x2b\xe2\x0d\x69\xa9\xa9\x69\x86\xf8\x8a\xb4\xf2\xd4\x5a\x43\x45\x05\x03\x53\x66\x72\x35\x35\x86\x3d\x09\x35\x9b\x8f\xbb\xc5\xd7\xec\x34\x24\x24\x04\x07\xbb\x25\xc4\x1b\xc2\x6b\xe2\x19\x6b\xb2\xc7\x36\xd7\xc6\xef\x31\xd4\xd4\xba\xb7\xb7\x53\x68\x07\xae\x5c\x45\x85\xa1\x36\xb5\x9c\x51\x65\xfb\x76\xa5\x55\xc4\x1b\x52\x53\xd3\xd2\x0c\xf1\xe5\xa9\x15\x69\xb5\x86\xf2\x72\x46\x1a\xfa\x2b\x77\xfa\xee\xeb\xe7\xd6\x75\xcc\xbb\x36\x6f\xef\xf4\xf1\x3e\xe3\x3b\x07\xdf\x7c\xe3\xe6\x4a\x60\xdb\xcf\x7c\xcb\xd8\xa6\x8d\xd7\x58\x76\x71\xbb\x50\x8d\xf5\xf0\xfa\x34\x98\x18\xea\xe7\x3b\x12\x9d\x7d\x5f\xc7\x15\x78\xde\xe2\x38\xb2\xcb\xe7\xf4\x33\x20\x1f\x5e\x67\x0a\xc3\xdb\x97\x1b\x34\x6b\x60\x08\x0c\x80\x79\x87\xde\x67\x0c\x17\x6a\x8b\x3e\x12\x8c\x8f\x17\x7f\xf6\xe6\x69\xe6\xe0\xe6\xb2\x25\x2b\x34\x06\x03\x0a\xdb\xab\x85\x75\x05\x11\x69\x43\x23\x99\xe3\x85\x8d\x71\x06\x4d\xe4\x96\x95\xab\xfd\xc3\x27\x6f\x8a\xfc\xf2\x54\x67\x79\x65\x79\x79\x79\x59\x56\x69\x8e\x29\xbf\x82\x01\x86\x8f\xfc\x13\xe6\xc1\x90\x27\xc7\x19\x03\x38\x83\xdf\xad\x76\xa1\xba\xba\xa5\xd6\x54\xfc\x1a\x50\x49\x30\xb1\xee\x54\x5e\x5e\x7e\x5e\x7e\xee\x9e\x2b\xd7\xb3\x1a\x36\x30\x15\x91\x85\xa1\x51\x1a\x43\x60\xd1\x3a\xbd\x70\xbc\xbe\xd3\x60\xd0\x54\xa5\xd6\xec\x32\x68\xa2\xd7\x87\x78\xb7\x8c\x69\x9c\x7a\x73\xf3\x85\xec\x57\x8e\x4d\x00\x87\xbb\x30\xe4\xd8\xb5\x5b\x47\xbf\x4a\x07\x79\xf2\xd7\x43\x92\x51\x9e\xf1\xea\x06\xff\x65\xa1\x8c\xa1\x2a\x28\xe9\x4d\xe1\xf0\xba\x82\xc8\xfc\x28\xc6\xb0\xae\x74\xfd\x76\xe1\x51\xf3\xf9\x35\xe7\xbc\xeb\xb6\x7e\x93\x97\xbe\x94\x51\xf9\xda\xcb\x20\x03\xc6\x70\x52\x86\xc5\x4b\x1a\x62\xc9\x10\x54\x8c\x5c\x66\xc9\xb0\x78\xbd\x38\xf6\xea\x65\x3b\xf6\x9a\x21\x79\x49\x43\xa4\x0c\x51\x89\xb9\xe0\x68\x0e\x00\xc6\xfc\x1a\x38\xda\x41\x31\xd4\x3b\x48\xbb\x75\xd4\x02\xae\xb5\xb0\xba\x43\x90\xce\xd0\x0f\x2f\x4c\xc6\xb1\xc7\xc5\x83\xe8\x44\xfd\x4c\x1b\x6a\xe1\x59\x35\x8c\x16\x30\x65\x27\x8a\x06\x83\xa6\xd7\x9f\xb6\xf4\xab\xa4\x86\x28\x40\x15\xf9\x63\x7c\x6b\x4c\xd1\x64\xf7\x0a\xcc\xc9\xb5\x78\x19\x34\x86\x3c\xcb\x90\x2c\xcc\x16\xf2\x67\xed\x0c\x9f\x10\x8f\xaa\x08\xb7\x21\x0a\xa9\x5f\x25\x65\x66\x68\x03\x0c\x34\xc0\x9d\x14\xa1\xf4\x87\xb3\xd2\xc0\xd2\x53\xcc\x04\x7a\x0c\x86\x52\xf8\xca\x4c\x94\xa5\x60\x3f\x2d\x9a\x69\xec\xe7\x7f\xee\x4f\x51\xea\x52\x40\xfd\x77\x19\x06\xf1\xe3\xfc\x8e\xa8\xc6\x51\xfb\x50\xe5\xf6\x07\x9d\x09\x37\xab\xe1\x73\xca\x93\xde\x8a\x83\xa2\xc7\x26\x45\x8e\xce\x75\x37\xa0\x32\x05\x13\x0b\x05\xe5\x2a\x1e\xe6\x83\xb2\xe3\x2f\x98\xfc\xec\x24\x28\x8f\x81\x63\x87\xf5\xc7\xc2\x7c\x87\x9e\x31\xe6\x18\xee\x48\x49\xf3\x5a\x01\xaf\x28\xce\xe4\x67\x1e\x3a\xa2\x81\x4f\xbf\xe3\x1a\x8c\x7b\x76\x46\x1b\xb7\x26\xe5\xe5\xa0\x67\x59\xac\x90\x55\x54\x9c\x5b\xa2\xdd\x97\x75\xa8\x41\x7c\x7e\x0a\x15\x9c\x14\x0a\x4a\x4b\xa8\x02\xae\xb9\xc2\x4d\xc5\x3a\xbc\x49\xbd\x42\xbf\x09\xd7\x28\xbc\xe6\x21\x85\xc2\x04\x45\xe5\xac\xf2\x99\xe5\x33\xf7\x42\xb8\x1b\x4c\xb4\x84\xd2\x70\x13\xde\xe5\xf0\xab\x8e\x26\xbc\x21\x48\xa1\xf7\x14\xd7\x7e\x2f\x99\x5c\x23\x96\xec\xc8\xdf\x16\xa6\x81\xeb\x18\xc0\x2d\x4d\x5f\x36\x6b\x6b\x54\x45\xeb\x2e\x21\x33\x8c\x42\x7b\x29\x14\x1c\x71\x0c\xdd\xd2\xd4\x54\x7e\x48\x7b\xbb\x68\xb5\x9f\x88\xee\x0a\x98\x6f\x0e\xb7\x32\x46\xb4\x8e\x3b\xe4\x5d\x1f\xb2\xd2\x70\x2c\xfd\xcb\x1c\xdd\x28\xcd\x04\x1a\x76\xc2\xbf\xec\xa0\xe7\x41\xcf\x1f\x3f\x49\x6e\xb7\x1c\x74\xf2\x18\x0c\xe0\xb0\xf3\x6d\xcc\x86\x50\x6f\x38\xc2\x18\x14\xef\x27\xdf\x8a\x3b\x9a\xc5\x80\x03\x5e\x83\x3b\xb8\xdc\xa0\x31\xe6\x15\xe5\x1b\xf3\x99\x5e\x4e\xfa\x83\x4b\x3f\x9a\x7d\x2c\xf7\x38\x63\x50\xd4\x5d\x3f\xf2\xe3\xc7\xd7\x18\x43\x29\xbe\x71\x19\x5f\x11\x96\x9a\x9d\x39\x43\x76\x40\x61\x98\x90\x94\xb6\x33\x6a\x6b\x70\xe3\x85\xd6\xce\x03\x6f\x31\x06\x85\x8e\xaa\xb3\xcc\xe3\xf0\x0a\xce\xc5\x46\x34\xa1\xab\x60\x50\x2c\x89\x9d\x98\x88\x4c\x3d\x63\xb0\xd0\xbf\xe0\x30\x78\x24\xc0\xd8\xdc\x77\x8d\x7f\xee\x06\xef\x66\x78\xf9\x14\x78\x7d\x72\xb6\x29\xf7\x72\xd6\xc9\x8c\x0b\x5b\x72\xd7\x87\x31\x06\xfc\x0e\xd3\x2d\xaf\x35\x08\xaf\x80\xeb\x56\xe8\x36\x68\xc0\x07\x06\xc3\x8c\xdf\xe0\xb7\xed\x05\x6d\x15\x77\x47\x19\x19\x83\xc5\xe9\x0c\x86\xe0\x02\xa1\xfc\xe3\xea\x0b\x8d\x1d\x0c\x38\x83\x08\xaf\x7d\x01\xab\xb5\xd2\x1c\x78\x8a\x7f\x59\xe6\x8b\x9f\x1d\xe5\xda\xe1\x7b\xf4\x86\xcf\xf1\x2c\x8c\x61\x0c\x0a\xfc\x00\xbc\xb1\x2b\x08\x2f\xe3\xa0\x35\xbb\xe2\xa3\xe3\x42\xd6\x4f\x8f\x9c\x99\xb8\xf0\xe5\xc1\x0b\xd1\x69\x07\xf2\xeb\x66\xad\x1f\x95\x8e\x4a\xc6\x90\x1b\x5a\x90\x2f\xe0\xe0\x3a\x9c\x7a\xcf\xa0\x39\xba\x04\x82\x67\x7f\x10\xc5\x18\x4a\x2d\x83\xa0\x0c\xb5\xc2\x9a\xeb\x19\x95\x06\x8d\x01\xdd\x21\xa7\x19\xe6\x0b\x45\x45\xf9\x45\x5a\x84\x47\xf0\x39\x56\x49\xce\xda\xd6\x96\x82\xc2\x16\xf1\x72\xd6\x25\xe3\xf9\xba\xbd\xa6\xbd\xb5\x6d\x75\x70\x0c\x26\x82\x33\xcc\xfa\x09\x1a\x9a\xae\x55\xdc\x2e\xfd\x84\x51\x36\x62\x01\xd8\xe9\xe4\x1f\x5c\xfa\xb1\x0a\x5e\x82\xb1\x76\x47\x4f\x3c\x3c\xa5\x93\x87\x83\x1c\xa2\xaf\x39\xe8\xa8\xe9\xe6\x4c\x2e\x78\x79\x1e\x2c\xc7\x5d\x77\x91\x3f\xef\x1b\xd2\xde\x75\xe4\x22\x8c\x2d\x81\xfe\x53\x41\x39\xb5\x03\xf9\xe0\xe5\x0c\xfc\xdb\x72\x83\x33\x35\x67\x17\xc6\x45\x58\x62\x7a\x67\xe8\x30\x48\x32\x40\x90\xf9\xe9\x56\xb4\xdf\x36\x23\x17\x15\x3b\x9f\x6b\x75\x72\xc4\x39\x70\xc4\xfc\x3a\x83\x19\xd2\x72\x0e\x8e\x60\x2c\xc4\xe3\x61\x3c\x8c\xb1\x18\x8f\x47\xf0\x08\xc4\x62\x3c\x1c\x86\xc3\x10\x0b\xf1\x70\x44\x80\x13\xd0\xc1\xe5\x5e\x0e\x04\xf9\xfa\xab\x96\x4a\x73\xab\xae\xc7\x68\x29\x84\x7b\xcf\xbf\xc3\x49\x3d\x77\x75\xd4\x79\x38\x0f\x52\xef\x39\x66\x21\x3e\xe0\xe2\xf1\x3e\x36\xa1\x3f\xee\x79\xc5\x7c\xa7\x7a\x87\x4e\x7e\xa3\xb7\xaa\x8d\xc9\xd9\xd0\x94\x5e\xac\x85\x4f\xbd\x21\x19\x13\xe2\xf1\x1e\xa3\xb4\xed\xad\xbe\x0a\xde\xff\xe7\xab\xcb\x55\xdb\x14\xbf\x5a\x75\xe0\x28\xe8\xc1\xc4\xa1\x9c\x56\xf9\x7a\x34\xb2\xaa\x46\x8f\x1b\xac\xca\xc9\xea\x1b\x66\xf5\xc9\xad\x3e\xd6\xea\xb3\xb3\xfa\xec\x1b\x6f\xb0\x2a\xd9\xba\x46\x56\xe5\x7b\xf4\x6c\x02\x6d\x33\x22\x05\x72\xba\xa7\x1b\x3a\x60\x22\xdb\xdb\x7d\xd5\x2a\x1d\xf8\xb0\xe6\xee\x99\x56\xc1\x37\x13\xb2\x78\x55\xaa\xd3\x25\x5e\xb5\xc4\xa9\x85\xaf\x39\xab\x68\xe1\xa1\x43\x6e\x60\x55\x1e\x56\x98\xfa\x9f\x30\xc6\x0a\xa3\xfe\x09\xb3\xb7\xc2\xec\x96\xfc\x03\x26\x2b\xbe\xc4\xab\x64\x7f\xc3\x94\x1e\x20\xb2\x10\xcb\x3a\xe8\x68\x41\x9a\xc4\x7d\x53\x1b\x01\xce\x93\x13\xf0\xc3\x85\x6e\xd8\x02\xe3\xc1\xfa\xff\x70\x21\x95\x6f\x2c\x36\x18\xb5\x5f\x54\x80\x7c\xb7\xaf\x88\xd3\x0e\xc1\xa2\xbf\xf6\xd7\x56\x9c\x88\xdb\xef\x1e\xb7\x7f\x53\x45\x58\x1c\x2e\x1a\xe8\x76\x09\xbc\xf7\x7e\x85\xca\x8e\x9d\x3e\xee\x43\xb0\x0b\x5b\x70\x1c\x05\x1f\x29\x60\x13\xa4\xbf\xf3\xe1\x88\x6f\xf5\x7e\xee\x28\x47\x35\x05\x5b\x7f\xe1\x71\xab\x02\xe5\xa0\xd6\x5f\x1d\xf1\xaf\x77\x5e\x77\x87\x4d\x98\x4e\xe1\x47\x0a\x6c\x81\x71\x43\xa0\x6b\xe7\x6d\x54\x6e\xd8\x3b\xcd\xfd\x12\x7a\xe3\xa2\x67\x61\x75\x9b\xd2\xe2\x42\xdd\xe3\xc2\x2a\x36\xee\x8f\x87\x45\x1e\x6e\x38\x6d\x2b\x95\xe8\x5b\x81\xf2\x2f\xb4\xc6\x62\x43\x81\x51\x84\x0f\xaf\x40\x0b\x8e\x47\xeb\xff\xc3\x2b\x93\x6b\x22\xd0\xf9\x9b\x78\x77\x98\xb6\x15\x17\x79\x84\xc5\xa7\x6e\xac\x0b\x73\xaf\x0b\x3b\x9e\xba\xbf\x0e\x16\x3d\x73\xd3\xa3\xf7\x8e\x69\xa0\xdc\xb0\xe7\xb6\xfb\x13\xe8\x82\x16\x18\x67\x7b\xf3\x26\x4c\x5f\xf6\xfa\xa3\x7f\x5d\xba\xea\x0e\x72\x50\x53\xb8\xd5\x76\xa4\x77\xab\x02\xe4\xa8\xbe\xe4\xf7\xe8\xdb\x65\x1f\xba\xe3\x26\x48\xb7\x95\xa7\x05\xc7\x3d\xc1\xae\x3d\x3e\xa0\xec\xd8\xf1\x95\xbb\x1e\xbc\x61\xd1\xc0\xfd\x71\xc7\x2b\xea\xf6\xbb\xd7\xed\x4f\x3d\x11\x56\x8b\x8b\xfe\x72\x53\x3e\x65\x81\x81\x35\x3a\x79\x26\xac\x71\xd0\x51\x17\xa5\x3f\xb9\x78\xbc\x81\x07\x31\x03\x3f\xa9\xc7\x1b\xf5\x98\x07\x75\x75\xd0\x5d\x07\xd7\xe1\x20\x64\xc2\x27\xb1\x70\x3d\x16\xf2\xb0\x2e\x0e\xbb\x19\xb8\xd9\xf3\x32\x87\xdf\xad\xc5\xef\xd7\xe2\x77\x6b\x2d\xf2\x00\x3c\x86\x9d\x51\x16\xc7\x64\x8c\xf8\x16\x43\x61\x22\x8e\xc5\xdf\xf1\x77\x37\xf8\xee\x74\xdf\x4f\x72\xe8\x84\xe3\xd0\xd9\x24\x31\xd5\x10\xf1\x32\x84\xe2\x44\x18\x0b\x4f\xe0\xb1\x4d\x9d\x26\xc8\x75\xb4\x07\xc8\xed\x0c\x2f\x3c\x0e\x3d\xf3\xa5\x62\xee\xdd\x88\xc6\x4e\xcc\x7c\xb2\x6b\xd5\xad\xad\xf8\xaa\x85\xa5\xce\xd1\xf0\x0a\xfc\x01\xb3\xf1\x0f\xea\x3c\x6d\x39\xd3\x33\x9a\x43\x57\xbc\x0c\x97\xd1\x15\x5c\xe1\x32\x75\x42\xcf\x0d\xc1\x4c\xc8\x18\xf2\x07\x64\x50\x1d\xab\xb9\xa9\xe8\x0f\xfe\x53\xef\x80\x3f\x05\x17\xd7\x72\x96\x39\xf8\x14\x9f\x5a\xe6\x58\x5d\x78\x2a\xcd\xb1\xb2\xb0\xbf\x5d\x2b\x5c\x00\xb9\x2b\x7c\xc6\xc3\x2b\xbc\xa0\x84\xe1\x68\x7a\x9c\x08\x93\xa5\x3f\x61\xc7\x6c\x13\xcc\x04\xb7\x8f\x81\xbd\x0b\x63\x5d\x8e\xc2\xe8\x4a\x28\xf2\x04\x46\x1a\xf4\xdb\x41\x18\x05\xb3\xe0\xe5\xfb\xc0\xa9\x1a\x12\x75\xd4\xbf\xe0\x12\x57\x3d\x1a\x5f\x6d\xdf\xd8\xe0\x77\x70\x53\x77\xcd\xcd\xaa\x8b\xc0\xc2\xce\xe2\x43\x4c\xbb\x31\xae\x28\x55\x9b\x58\x90\x9a\x99\x18\x9d\x1c\x83\x43\xf1\x42\x72\xc4\x06\x9f\x81\x55\x95\x5f\x15\xb5\xfc\x02\x5b\x8d\x87\x8b\x1a\x72\x9a\x62\x2a\x62\xca\x23\x13\x32\x53\xd2\xe2\xd1\x0d\xff\x4c\x0a\x67\x22\xde\x8c\x48\xda\x94\x37\x2e\xfb\xd5\x2f\xf7\xff\x5c\x75\xf2\x07\xf8\xf4\xcc\x57\xfb\x2f\x7e\xd3\x71\x39\x62\x7f\xf2\xc9\x5d\x95\x59\x7b\x93\xf7\xb7\x57\x96\x1f\xd8\x53\x5f\x7d\x2a\x93\xd9\x97\x53\x1b\xd3\xb4\xab\x2e\xae\xaa\xa2\xbc\xa4\xc6\x54\x59\xf6\x76\xfe\xb9\xfc\x77\xe2\x2a\x27\x55\x8d\xc6\xc9\x98\x5d\x81\xf2\x32\x1f\x70\x7b\xa7\x62\x36\xf3\xdc\x0f\x43\xb9\x9c\x86\x98\xca\xd8\x9c\xd8\x9c\x94\x18\x63\xac\x31\xa6\x3e\xa5\xde\xc8\xa8\x9c\x52\x1b\x8c\x95\xf5\x39\x0d\x8c\xf4\x31\xd6\x70\x89\xcd\xa1\x25\x51\x09\xd1\x09\x59\xa1\xbb\xa3\x6a\xa2\x0e\x64\x35\xd7\x34\xd5\x94\x1c\x48\x68\x66\x7a\x6b\xcd\x5d\x5c\xcb\x91\xf4\xb3\xc1\xad\xc1\x2d\x81\xe9\x91\x41\x91\xc1\xa6\x55\xed\x91\xed\x11\x67\x4d\x2d\x47\x18\x5b\x3d\xb0\xbd\x53\x38\x95\x53\x6a\xf8\xd1\x80\xf2\x2d\xe1\x41\xe1\xe9\x2b\x5b\xb7\x58\x6f\xb4\x6e\xe9\x4c\x3f\xda\x7a\xb4\xcd\x74\x3e\xe2\x28\xa3\x1a\x28\x03\xb9\xf4\xd8\x5a\x71\xc0\xfc\xb6\x01\xfc\xd1\xf3\x74\x3d\x18\x31\x0b\x16\x60\xea\x74\x5c\x09\xa3\xf0\x24\xda\x4f\xc4\x44\x5c\x18\xee\x85\xc1\xbf\xe1\x64\x46\xe5\x21\xc7\x57\xd0\xfb\x3b\x3c\x0d\x71\x9b\x0b\xfd\x6b\xfd\x0f\x07\x3c\x40\x11\x16\x85\x00\xff\xc0\x68\x2c\x2e\x32\x16\x81\x33\xca\x61\xcd\x07\x27\x61\xca\xa7\x79\x9f\xd6\x7f\x70\x8a\x51\x39\xc9\xad\x92\x1f\x04\x8e\x85\x91\xcc\x73\xc9\x3c\x8c\x8b\xdb\xb3\xa5\x24\x3c\x6e\x67\x6c\xd6\x96\xba\x9d\x75\x3b\x8f\x66\xb5\xd5\xed\xa9\x2f\x39\x1a\xb7\xc7\x9a\x41\x98\x08\x87\xb9\x9c\xe6\xe8\xea\xe8\xec\xe8\xec\xa4\x68\x63\x74\x71\x54\x53\x52\x53\x71\x53\x71\x75\x53\x76\x13\xa3\x93\x37\x3f\x9f\xcf\x65\xb7\x85\xd7\x86\x67\x87\x67\xc5\x87\x97\xec\x2c\x0e\x6f\x8b\x6f\x2b\x69\x2b\xae\x6d\xcb\xda\xc3\xf4\x8e\xea\x71\xe6\x54\x8b\x56\x47\x1f\x5d\x5d\x19\x14\x1d\x14\x9d\x12\xd8\xb4\xa5\x31\xe8\xed\x94\x23\x4d\x47\x9b\x2a\xce\xee\x3a\xc2\x98\x93\x7b\x3d\xb9\x9c\x86\xd8\xca\xd8\x9c\x18\x6b\xc5\xc7\x18\x63\xeb\x93\x1b\x8c\xf5\xc5\x55\xf5\xd9\x0d\x0c\x2e\x83\x2c\x2e\x66\xff\x86\xb2\xed\xbb\xc2\x76\x65\x6e\x68\x08\x6b\x08\xeb\xc8\xdc\xdf\xb0\xaf\xb1\xb4\x23\x66\x3f\x63\x33\x77\xfe\x7f\xfb\xee\xdc\xa3\xa3\x7c\xf7\xd0\xa0\x66\x41\x4d\xac\x7d\x41\xbf\x7e\xb6\x6b\x7f\x1d\x2d\x53\xeb\xe8\x87\x5c\xbb\xca\xee\x91\xbd\xcc\x4e\xd6\x5f\xa6\x95\x1d\x95\x75\xd9\xb9\xdb\x0d\xb6\x1b\x6a\x37\xd2\x6e\xac\xdd\x04\x3b\x1f\x3b\x5f\xbb\xb9\x76\xaf\xd9\x2d\xb6\xdb\x68\x17\x64\xb7\xcd\x6e\x87\x5d\xbc\x5d\x8a\x5d\x86\x5d\x8e\x9d\xd1\xae\xcd\xee\x5d\xbb\x2b\x76\xd7\xed\x3e\xb3\x7b\x60\xf7\x9b\xdd\x1f\xf6\xb3\xec\xe7\xd9\xbf\x66\xbf\xc8\xde\xdf\x3e\xc0\xfe\x4d\xfb\x50\xfb\x38\xfb\x1c\xfb\x32\xfb\x76\xfb\x13\xf6\xa7\xed\xcf\xdb\xbf\x63\xff\xbe\xfd\x27\xf6\x37\xed\xbf\xb0\xff\xce\xfe\x67\xfb\x5f\xed\xff\xb0\x97\x1c\x88\xc3\x00\x07\xb5\x83\xbb\x03\xef\x30\xc6\x61\x8a\x43\x97\xc3\x17\x0e\xdf\x3a\xdc\x73\xf8\xcd\xe1\x99\x83\xd9\xa1\x57\x2e\x97\x2b\xe4\x4a\xb9\x97\x7c\x8c\x7c\x8a\x7c\xba\x7c\xa6\x7c\x9e\x7c\xa1\x7c\xa9\x7c\x95\x7c\x83\x7c\x8b\x3c\x4c\x1e\x29\x8f\x91\x27\xc8\xbb\xe4\x1f\xcb\xef\xc9\x1f\x52\x0e\x94\x2b\xa5\xa1\x04\x6a\x0a\x35\x8b\x7a\x8d\x5a\x44\xf9\x53\x01\xd4\x9b\x54\x34\x95\x45\x19\xa8\xf7\xa8\x4f\xa8\xcf\xa9\xbb\x34\x4d\x8f\xa6\xe3\xe9\x0c\xba\x90\x2e\xa7\x1b\xe9\x36\xfa\x00\xdd\x4e\x77\xd0\xb7\xe8\x07\xf4\x6f\xf4\x9f\x0a\x1f\xc5\x42\xc5\x72\x45\xa0\x62\xbd\x22\x48\xb1\x43\x11\xa9\x78\x4b\x71\x49\xf1\xbe\xe2\x9a\xa2\x5b\x01\x8a\x7f\x33\x83\x98\x09\xcc\x14\xc6\x97\x99\xcb\x2c\x62\xde\x64\x76\x32\xb1\x4c\x32\xf3\x36\x73\xd7\x51\xed\xa8\x71\xf4\x70\x5c\xe1\xb8\xca\x71\xad\x63\xa1\x63\xb9\x63\xad\xe3\x27\x8e\xdf\x38\x3e\x71\x7c\xce\x3a\xb0\x8e\xac\x92\x75\x66\xdd\xd8\xb1\xec\x0c\x76\x1e\xbb\x83\xcd\x65\x6b\xd8\xc3\x6c\x07\xfb\x16\xdb\xc9\xfe\xc2\xfe\xc1\x9a\x89\x1d\x51\x10\x81\x78\x91\x51\xc4\x97\x6c\x26\x91\x24\x81\xa4\x90\x2c\x92\x4f\x8a\x48\x29\xd9\x4d\x9a\xc8\x7e\x72\x84\x9c\x26\x5f\x91\xc7\xa4\x87\x3c\xef\x67\xdf\xcf\xa5\xdf\x4b\xfd\xb4\xfd\x3c\xfa\x8d\xee\x37\xb5\x9f\x5f\xbf\xe5\xfd\x36\xf6\x0b\xea\x17\xda\x2f\xba\x5f\x62\xbf\xf4\x7e\x39\xfd\xf6\xf5\x7b\xbf\xdf\x9d\x7e\xcf\xfb\x3b\xf4\x17\xfb\x8f\xed\xbf\xb8\xff\x8a\xfe\xab\xfa\xaf\xeb\xbf\xb5\xff\x8e\xfe\xd1\xfd\x13\xfa\xef\xee\x7f\xaa\xff\x67\xfd\x9f\xf6\xef\x55\xb2\xca\x97\x94\x5a\xa5\x97\x72\x8e\x72\x83\x32\x52\x99\xac\x34\x2a\x4d\xca\x2a\x65\x83\xb2\x55\xb9\x4f\xf9\x96\xf2\x82\xf2\x13\xe5\x4d\xe5\x2d\xe5\x5d\xe5\x4f\xca\x87\xca\xdf\x95\x7f\x0e\xa0\x06\xa8\x06\x8c\x1e\x30\x7e\xc0\xe4\x01\x33\x06\xcc\x1d\xe0\x37\x60\xf1\x00\xfd\x80\xb0\x01\xd9\x03\x2a\x06\xec\x19\x70\x78\xc0\x99\x01\x17\x06\xbc\x37\xe0\xea\x80\x4f\x07\x74\x0f\xb8\x3d\xe0\xe7\x01\xbf\x0d\xe8\x71\x62\x9c\xfa\x39\x39\x3b\x69\x9c\x3c\x9c\x86\x3b\x8d\x71\x9a\xe4\xe4\xe3\x34\xc7\x69\xa9\x53\x80\xd3\x76\xa7\x48\xa7\x3c\xa7\x06\xa7\x43\x4e\x6f\x39\x5d\x70\xba\xec\xf4\xb1\xd3\xe7\x4e\x77\x9d\xee\x39\xfd\xea\xf4\xc4\xe9\x2f\x27\x74\x76\x72\x1e\xe2\x3c\xd5\xd9\xd7\x79\xb9\x73\x88\x73\x82\x73\xa1\x73\xbd\x73\x8b\xf3\x41\xe7\x23\xce\x1d\xce\x6f\x3b\x5f\x70\xfe\xc0\xf9\x2b\xe7\x47\xce\x7f\x38\xff\xe5\x8c\xce\xff\x76\xa1\x5d\x88\x8b\x93\x0b\xe7\x22\xb8\x0c\x72\x19\xea\x32\xca\x65\xbc\xcb\x6c\x97\xe5\x2e\xab\x5c\x42\x5d\x92\x5d\x8a\x5d\xaa\x5c\xea\x5d\xf6\xba\x1c\x73\x39\xed\x72\xc9\xe5\x7d\x97\x6b\x2e\xd7\x5d\xbe\x77\x79\xe8\x02\x2a\x46\xe5\xa4\x12\x55\x9e\xaa\x61\xaa\xd1\xaa\x09\xaa\x59\xaa\xf9\xaa\x25\xaa\x75\xaa\x20\xd5\x36\x55\xb4\x2a\x41\x95\xa2\xca\x52\xe5\xab\x4a\x54\x15\xaa\x7a\xd5\x1e\xd5\x21\xd5\x09\xd5\xdb\xaa\xf3\xaa\xcb\xaa\xab\xaa\xeb\xaa\x2f\x54\x5f\xab\xbe\x53\xdd\x53\x3d\x53\xcb\xd5\xfd\xd4\xce\x6a\x9d\xda\x53\x3d\x4a\x3d\x41\x3d\x53\xbd\x44\xfd\x86\x7a\x95\x7a\xad\x7a\x93\x3a\x42\x1d\xa3\x4e\x52\xe7\xa8\xcb\xd5\x2d\xea\x83\xea\x0e\xf5\x5b\xea\x0b\xea\xcb\xea\x6b\xea\xeb\xea\x5b\xea\x6f\xd5\xbf\xa8\x9f\xa8\x7b\x38\x3b\x8e\xe6\x08\xe7\xc6\x89\xdc\x48\x6e\x32\x37\x97\x5b\xcc\x2d\xe7\x02\xb9\x0d\x5c\x08\xb7\x9d\x8b\xe2\xe2\xb8\x64\x2e\x93\x2b\xe6\x6a\xb9\x7d\xdc\x21\xee\x38\xd7\xc9\x5d\xe1\x3e\xe3\xee\x70\x3f\x71\x0f\xb9\x3f\x39\x74\xb5\x73\x75\x74\x1d\xe0\xaa\x72\x75\x77\x15\x5d\x3d\x5d\x87\xbb\x8e\x71\x9d\xe8\x3a\xd9\x75\xb6\xeb\x22\xd7\x00\xd7\xb5\xae\x9b\x5c\x77\xb8\xc6\xbb\x66\xb9\x16\xbb\x56\xb9\xd6\xb9\x36\xbb\xee\x75\x3d\xe4\x7a\xec\x3a\x2b\xf9\xc0\x23\x78\x24\xf9\x08\xca\xd9\xac\x1f\x3d\x8f\x17\xfd\xb6\xf1\x57\x23\x58\xa2\x98\xbe\x23\x60\xd6\x34\xcd\xff\xf3\x99\x5e\x0f\xdb\x4c\xaf\xef\x3f\x66\x7a\x3d\xfe\xc7\x99\x5e\xdf\xff\x79\xa6\xd7\xe3\x1f\x33\xbd\xc5\xa0\xa7\x95\xd8\x85\xb9\x98\x8b\x5d\x30\x8b\x17\x20\x6a\x38\x9b\xcb\x2e\x61\xe1\x28\x6f\x5b\x8e\x8b\xe2\x61\x04\xfb\x30\x84\xd7\xf5\xf8\x7e\xcc\xd3\x16\x1a\xe6\x62\x23\xac\x44\x57\x01\x57\xa2\xb5\x04\x8d\x16\x5a\x33\x92\x8e\x4b\x4a\x8a\x13\xfd\xa0\x95\xbd\xaa\x18\xc3\x0a\x23\x69\x89\xc6\xb9\xd0\x88\x2b\xc1\x55\x80\x95\xe0\x0a\x73\xa1\x51\xa2\x35\x64\x09\xff\xc2\x82\x07\x19\xc9\x0a\x64\x0c\x2b\x10\x7a\x28\x4f\x5c\x3d\x58\x98\x88\x1c\x70\x38\x51\x20\x71\x6b\x78\x52\x57\x5d\x5d\x47\x82\xb7\x6f\x0f\x26\x75\x49\xd5\x71\x84\x43\x03\xae\x81\x35\x60\x00\x03\xf4\xb9\x91\x3c\xed\xcd\x13\xfa\x7d\x96\x8c\xe1\x05\xb2\x9a\xc7\xee\x09\x3c\x74\xcf\x64\x49\x5c\x52\x01\x4f\x66\xb1\x22\x19\xc5\x8a\x64\x1e\x2f\xa2\x7e\x1b\x4f\xb8\x59\xbc\x64\x72\x9d\xc5\x43\x13\xcf\xad\x67\x61\x39\x2f\x80\x7a\x38\x6b\x5b\x79\xf3\x7b\xb1\xf0\xa6\xb0\xcd\x7b\x5e\xa5\xeb\xaa\x93\xe2\x44\xd0\xcb\x17\xf1\x64\x08\x2f\x90\x1c\x16\xd4\x8a\x1c\x9e\x28\xa6\xf3\xb6\xfc\x08\xd8\x67\x25\x4c\x04\x75\x38\x8f\x6a\x05\x99\xc7\x8a\x44\x31\x93\x27\x5c\x20\xfb\x77\x26\xe7\xb2\x82\x64\xea\xed\xe6\x0e\x27\x1d\x8a\x6a\x16\xf0\x21\x3c\xa4\xbe\x06\xc7\x53\xe0\x01\x83\x34\xff\xb7\xa3\xf7\x30\x08\x3c\x4e\x7d\x0d\x8e\x02\x3c\xc4\x07\x60\xe6\x09\xbd\x90\x25\xf4\x68\x96\xac\x66\x05\xa2\xc8\x60\x49\x31\x5f\xc9\x36\xf0\xa4\x76\xf7\xee\x5a\x42\x65\x65\xe5\xa4\x67\x68\x32\x8c\xe9\x25\x59\x02\x19\xcf\xeb\xcc\xa9\x3e\x7d\x4a\x26\x09\x8c\x63\x47\xf6\x19\x97\x7d\x78\x8f\x25\x56\xb4\x02\xc5\x43\x2e\x74\x91\xef\x78\x0b\x2f\xa9\x58\x89\xa7\x4a\xb2\xd2\x8d\x19\xda\xf4\x8c\x3f\x79\x69\x8b\x65\xcb\x3e\x96\x58\xcb\x4c\xb6\xf0\x22\x59\xcb\x43\xf7\x20\x9e\x8c\x66\xc7\xf0\x44\x47\xcb\x6c\x25\x06\x39\x4f\xe8\xd9\x3c\xd9\xc9\x8a\xa4\x6f\x55\x50\x3f\x8c\x25\x90\xce\x67\xf1\x02\x19\xcd\x5f\xa5\xc9\x8a\x53\xeb\xba\xc8\x0f\xb3\x6f\x4e\x14\xc8\x8b\x75\x43\x7d\x1f\x39\xa0\xfe\x77\x96\xd0\x1b\x59\x52\xca\x5b\xb3\x9e\xb8\x3b\x9e\xd0\xcb\x58\x82\x6e\x23\x77\xb0\x0f\x47\xd2\x19\xec\xc3\x87\x8a\x39\xfc\x48\x2b\xfa\xf4\x13\x78\xd0\xcf\x64\x89\xa9\xe1\xe4\xef\x75\x9a\xc2\xfc\xa2\xdc\x42\xa1\x34\xc5\xe3\xc3\x6c\x6d\x56\x5e\x48\x48\xd8\xa6\x1d\x9b\xdc\xd3\x0a\xd2\x0a\xd2\xd2\xd2\xf2\xd3\xfa\x79\xee\x4e\xf3\xfd\x2d\x59\x9b\xed\xe1\x97\x95\x22\xe6\xe6\xe5\xe7\xe6\x69\xe2\x4f\x7a\x99\x62\x84\x94\x84\xb4\xb8\x8c\x38\x26\x26\x0f\xb9\xa4\x44\x0d\x7a\x28\x12\x81\x4b\x6a\xc8\x13\xca\x62\xcb\xe3\x2b\x13\x98\xf4\x98\xf5\x5e\xf1\x9a\xbc\x82\xdc\xa2\x3c\x21\xb3\xf2\x2f\xbf\x62\x6d\xd5\xe7\xbf\xef\x2e\x17\xcb\xf3\xcb\xf3\xcb\xcb\xcb\x0b\xca\xfb\x79\x26\x96\x7f\x3e\xb4\x4a\x4b\xf0\x19\x9e\xc0\x13\xf8\xcc\xea\x42\x20\x0f\xcf\xc0\xea\x10\x1c\x68\x9b\xd8\x1e\x48\x7e\xb8\x79\xf3\x07\x91\xf4\x99\x63\xdc\xc1\xaf\xe2\x75\xb4\xcc\x81\x5c\x5d\xc6\x13\x6e\x3c\x4f\xee\xf3\xa0\xde\xcd\x92\x71\xac\x32\x90\x87\x6e\x7f\x96\x64\x95\x08\x01\x9d\x6f\xf0\x96\x2d\x96\x2d\xaf\xb2\xd6\x3a\x5f\xce\x77\x76\x96\xb3\x64\x0d\xab\x43\xdf\x20\x9e\xc4\xb0\x3a\x85\x0c\xf4\xdc\x7c\x96\x70\xcb\x59\xa2\x78\x9f\x25\x13\x67\xcf\x9e\x48\x56\xb2\x7e\x6b\xd8\x91\x84\x9e\xc1\x12\x70\xe2\x7b\xf4\x10\xc0\x12\xa8\xe4\xe1\x2e\x2f\x92\xab\x81\x3c\xb9\xe1\x7f\x79\x4e\x30\x4f\x1a\x4b\xf8\x5c\x9e\x28\xc6\xf3\x44\x71\x9c\x25\x3a\x79\x17\xe8\xed\x0c\xa0\x77\x90\xf4\x3d\xdd\xaf\xf2\x3d\x17\x2c\xdd\x1c\xe4\xf0\xbd\x6b\xcd\x6f\x52\xe7\x57\x8e\x38\x31\x47\x6b\xf1\x7e\xcc\x5a\xbc\x15\x73\x4e\x8c\x38\x1f\x20\x98\xd7\xf6\xae\xa3\xa2\x9a\xe1\x25\xbe\xb9\x45\x94\x52\xa4\x54\x78\x83\x25\x1c\xa8\x78\x54\x80\x02\x06\x82\x8b\x35\xf4\x5f\xb6\x85\x61\x33\x6b\x33\x13\xe1\x24\x10\x30\xb5\xb2\x04\x14\xac\x60\xd1\x4b\xfa\xc3\x2c\xbc\xc4\x8a\x16\xbd\x45\x6f\x62\x7b\xd4\x21\x6c\xe6\xdf\x1b\x03\x9a\x58\x49\xcd\x43\xae\xb5\xa9\xb7\xb0\x64\x31\x2b\x92\x20\xf6\xb9\x7a\x16\x0b\xde\xbc\x28\xe9\x2d\xfa\x36\x1e\xa6\x5b\x7d\x92\xfe\x63\x96\xc4\x55\x27\xd5\x09\x57\x27\x59\xab\xda\xa6\xf2\x8c\x04\xf3\x73\x88\x4e\x9e\x4a\xa6\xb2\xa8\x1e\xc5\x13\x34\x59\xe5\xa9\x17\x27\x9d\xaf\x5b\x5b\x35\x28\x79\xc1\x16\x22\xff\x4b\x3b\xad\xa4\x86\x67\x3c\x31\x65\x96\xa6\x0b\x84\x83\x79\x38\x00\xc6\xe2\xac\x0e\x61\x4f\x47\xf5\xd9\x73\xb0\x97\x5d\xb4\x24\x7a\xe3\x1a\x01\xf4\x3e\xb8\x18\x5c\x70\x93\x16\x28\x36\xa9\x20\xa9\x20\x51\xc4\xf1\xb3\xbc\x70\x02\xce\xea\xe2\x7b\xba\xe9\xef\xd9\xa9\x3c\x74\x28\xa0\x8d\x27\x2f\xb3\x68\x1a\xcb\x13\x29\xc3\x32\x44\x1a\x62\xc9\x20\x5f\xb0\x01\x01\xff\x68\x84\x52\x5f\xe3\x82\x61\xac\xb4\x45\xda\x42\x95\x94\x18\x4d\x65\x1a\x82\x17\xf1\xd2\x45\x60\x70\x8a\x88\x33\x14\x38\x10\x1e\xa1\x02\x8e\xb3\xf5\xac\x00\x33\x14\xc8\xe0\x14\xbc\xb4\x1c\x2f\x6a\xc9\xab\xc0\xa2\xea\x11\xfa\xb6\x32\x50\xca\xaf\x58\xb7\x6e\x45\x52\x51\x72\x71\x8a\x80\x75\x9b\x70\x22\x6e\x41\xbd\xc6\x12\x83\xbe\x18\x85\xc3\xd0\x59\x88\x2c\x8d\xae\x8c\x11\x70\x11\xbe\x9c\x9c\x9a\x1f\x53\x91\xe4\x7e\x77\x64\x45\x52\x63\x7e\x55\x85\xbb\x4e\xb1\x44\x47\xaf\x20\xd5\x6c\x5a\xaa\x21\x2d\x9d\x27\x54\x4a\x4a\x66\x42\x3c\x04\xb1\xe4\xef\xec\x4c\x65\x7b\xf5\xfb\x59\xb3\xde\x9f\x25\xb0\xe6\x2a\x4f\xac\xac\x8f\xb8\x56\xf2\x84\x86\xf9\xbc\x15\x2b\x16\x7d\x1f\x56\xc0\x13\x3d\xf1\x5b\xfc\xf6\x55\x16\x68\xa4\x97\xf3\xf0\x2d\x7c\x6b\x85\x5d\x61\x89\x35\x7b\x2b\xd6\x9d\xea\xea\x3a\x25\xb9\xb0\xeb\x56\x08\xe4\x59\x36\x4f\xac\x74\x42\x70\x2d\xb8\xe1\x02\xd8\x80\x8e\xe2\x6a\x9c\x36\x7b\xf1\xeb\x73\x12\xe3\xe2\x13\x8b\x23\x18\x83\xc1\x90\xaf\x89\x2e\xae\x4b\x68\x28\x28\x34\x14\x6a\x8f\x17\x1f\x2f\x3d\x52\x0e\x33\x4f\xc3\xb8\x3b\xf0\x12\x30\x4c\xf6\xdb\xe7\x72\xcf\xfd\x97\xd6\x53\x50\xf0\x09\x81\x0a\x50\xf0\xdb\xfa\x18\x19\xb1\x92\x8f\x2f\x04\x13\x1b\xdf\x25\xf1\x89\xbb\x6b\x45\xab\x48\x5d\xc6\x93\xd6\x88\x13\x86\xd6\x56\x77\xc2\xed\xe5\x09\x27\x79\xc3\x53\x4c\xc6\x03\x78\x00\x9f\x62\xb2\xc5\x7b\xdd\xda\xa2\xe2\x75\xa2\x7f\xc9\xba\xcd\x53\x66\x8f\xf5\xf7\x5a\xef\xde\xf6\x56\xeb\xa5\xfa\x1b\x7b\x1e\xba\x79\x77\x52\x38\xf3\xd7\xa1\x30\x08\x86\x6b\xe0\x00\x3c\x85\x64\xc9\x5b\xe8\x51\x5b\x4c\x1c\x59\xce\x5b\x11\x58\xce\x92\x51\x7c\x34\x4b\x06\xbe\xfc\xf2\x40\x32\x9d\x95\xd4\xf2\xe9\x2c\x81\x23\xbc\xa5\x43\xea\xf8\x80\xc7\x0e\x8b\x5e\x31\x9a\x15\x2d\xea\xb1\xbc\xa4\xc7\x0e\xfa\x26\x2b\x75\x48\x1d\x1f\xb3\x84\xaa\x4c\x49\x28\x8d\xd7\x12\x78\x0b\x5f\x85\xd9\x78\x01\x67\xe3\x64\x14\xa6\xfb\x08\xb7\x7c\x70\x32\x08\x38\x5b\x8b\x17\xf0\x55\x9c\x8d\x6f\x91\xff\x52\xa2\xac\x06\x0f\x9e\x80\x7a\x05\xbf\x82\x27\xb6\xad\x1c\x26\x12\xbf\x3b\xb1\x96\x04\xf0\x66\x35\x76\x07\xf0\x04\xc6\xf0\xbd\x53\x8d\x7c\x14\xdf\xc4\xf7\x4e\x7d\x8f\x27\x07\x21\x89\xc5\x6e\x1a\x07\x78\x79\xe1\x00\xf1\xb9\x5e\x41\x60\xb1\x95\x85\x38\x10\x18\xca\xef\x6b\x27\xc2\xeb\x5b\x90\xcf\xdf\xbc\x88\x49\x57\xc4\x17\xc6\x15\xc4\x0b\x8f\x1f\xd7\x3d\xd6\xc2\x60\xf0\x88\x36\xc2\x20\xf1\x70\x01\x55\x58\x5e\x50\x6e\xd2\xd4\xe6\xd6\xe6\xd5\x08\xd3\xdb\xc7\x97\xbc\x72\x9c\x89\xfe\xac\xf2\xeb\x2f\x35\x84\x7b\xc2\x5b\xb6\x48\x5b\xdc\x80\x66\x03\x02\xdc\xee\xf1\x56\xca\x76\x93\x54\xec\x3d\xde\xbd\x33\xe0\x99\xad\x76\x28\x82\x6a\x78\xf0\x23\x6b\xee\x94\xf6\x71\x78\xc3\x0b\xbe\x54\x60\x8d\x94\x46\x41\x3f\x1a\xc6\xe2\x35\xca\xd0\xbc\xa6\x7e\x8d\xd0\x70\xba\xe5\xac\x41\x03\xe3\xe1\x1a\x05\x72\x5a\x5a\x4f\x92\x78\x18\xc3\x12\x54\x73\x0b\x79\x02\x0b\xb1\x15\x03\xf0\x34\x85\x6a\x9c\x06\x15\x34\x8c\x85\xa2\xf2\x1a\x53\x4d\x49\xa5\x7b\x51\xa9\xb1\xb4\xb0\x94\x29\xa2\x0b\x33\x8b\x32\x4b\x32\x5b\xd6\xbb\xc1\x44\x2c\xa6\xa0\x80\x26\x8a\xa9\x3c\x39\xc0\x83\x9a\x64\x67\xe7\xe7\x66\x8b\x96\x28\x34\x51\x69\xd9\x99\xa9\x29\x1a\x5d\x8f\x6f\x1c\x5b\x5c\x5c\x50\x54\x2c\x48\x51\x60\xa2\xca\x8b\x4b\x2b\x2a\x35\x3a\xaa\x0b\xb2\x58\x12\xc4\xeb\xa8\xae\x55\x2c\x19\xf8\xdd\xcb\x75\xac\x40\xa4\xfb\xb8\x1a\x12\x61\x35\xbc\x42\xc3\x2a\x50\x82\x0c\xe6\xde\xed\xce\xca\x6d\x14\x70\xa3\x02\x95\xf9\xd4\x88\xb8\x37\xe7\x8b\x38\x0c\xe2\x14\x61\x98\x48\x61\xa0\xe5\x3e\xd9\xce\x82\xc9\x75\x39\x6b\x33\xb5\x36\x91\x25\x8a\xa2\x4c\x63\x56\x49\x96\x79\x55\xef\x2a\xb7\xd6\x88\x06\x53\xbb\x86\x70\x73\x97\x2e\x9d\x3b\x77\xe9\xbb\xd7\x61\x23\x4b\x86\xf2\x33\x78\x62\x60\x61\x1c\x4b\xda\x78\x6f\x9e\xac\x62\x95\xb4\xcd\xf6\x31\x51\x00\xcf\x5a\x4c\x16\x93\xdb\x63\x5e\xb2\x3a\xc9\x95\x35\x59\x1f\xb1\xa4\x56\x5b\x66\x2a\x2c\x2a\x13\x9b\xcb\x6b\x9a\xdb\x34\x84\xaa\xac\x2c\xad\xa9\xd5\x90\xef\x7f\x06\xa7\x4e\x78\x49\x0b\xed\x10\x8f\xb6\x5d\x5a\x38\x11\x87\xde\x04\xd5\x70\x31\xbb\x34\xdd\x98\x5e\xc0\xa4\xa7\xe7\x66\x65\x8a\xe4\x67\x16\x4d\x68\xea\x6b\xf1\x1a\xf0\xe6\x05\x68\xe2\xaf\x58\x47\x9e\x23\xf9\x7f\x1a\x8f\x97\x7c\xc8\x7f\xcd\x1b\x5a\x85\x40\x39\x4d\xc6\x58\x19\xb0\x40\x60\x3a\x2b\x10\xf9\x6c\x96\x70\x38\xc5\x3c\x08\x07\xd0\xa8\xc7\x85\x77\x5e\xbe\xf2\x6e\x55\x55\x59\x79\x71\x99\x7b\x69\x25\x55\x98\x40\xa7\xe5\x27\x27\x6b\x2c\x73\x70\x1a\xd2\x52\x88\x82\xdc\x61\xad\xd4\xf2\x06\x4f\xbc\x79\x30\xc5\xb2\x04\xac\x6c\x1b\x07\x92\xeb\x4b\xdf\x9d\x2b\x90\x36\xf6\x9b\x6f\xbe\x99\xfc\xff\x7f\x25\xd0\x11\xcb\x82\x9c\x25\x65\x39\x10\xc2\x13\x74\x43\x93\x22\x8d\x35\xab\xe9\x1f\x78\x34\x81\x1b\xdd\xcd\x13\xee\x1c\x38\x16\x19\xcb\x4a\x4a\x0a\xdc\xe1\x3a\x5d\x9c\x6f\xca\x2a\xca\x39\x8b\x8e\x6e\x52\xd4\x36\x7f\x1e\xaf\xd0\x73\x61\x1a\x45\xfa\xcc\x49\x77\xfb\xb0\x36\xc1\xef\x65\x56\xd7\x93\x3a\x96\x27\xe0\xc0\x2a\xfd\x79\x03\xea\x09\x78\xb1\x0e\x84\x6e\x66\x09\xdd\xc2\x93\xb3\xac\x6d\xfd\x9a\x4c\xe4\xe1\x25\x56\x20\xb6\x3e\xc2\xda\xec\x4c\xb0\x98\x27\x36\x13\xda\xa0\x26\xad\xa6\xda\x96\x3d\x9a\x3d\xf1\x2d\x11\x26\x01\xdf\xfc\x02\xd7\x41\x83\x64\xa7\xe9\x31\xd1\x16\x3b\x5c\x87\x0d\xf8\xe6\x2b\x82\x72\x84\xcf\xed\x47\xa6\xd2\x52\x93\xa9\x34\x33\xdd\xe7\xda\x6b\xb7\xad\x2e\x99\xc1\x83\x86\xc6\x32\x2c\x25\x8a\xfd\x3c\xa1\xf7\xf0\x84\xd3\xf5\xf8\x0e\x63\x51\x0d\xad\x2c\xa8\x97\xf1\x24\x8a\x95\x4c\xe4\x6a\x12\x4f\x1a\x41\x64\x49\x23\x9a\xe0\x3c\x6b\x67\x80\xf3\xac\x03\xf9\x7b\x51\xf7\x79\x37\x94\xf0\xdc\x68\x56\xe8\x35\xd9\x4c\xf6\x5f\x64\x2d\x26\x85\x55\x14\x06\x57\x3e\x29\x4e\x24\x2f\x54\x79\xf7\x69\xe2\x26\x4d\xac\x48\xb0\x63\x18\x4b\xf0\x08\xc6\x61\x1c\x1e\x21\xc9\x55\x31\x86\xe4\x64\x52\x9b\x59\x93\x52\x49\x6e\x5c\xbe\x7c\x83\x28\x24\x1e\xfa\x53\xd5\xc5\xa6\xca\x6a\x0d\xa8\x15\xe5\xd9\xe5\x19\x25\x42\x46\x49\x6a\x61\x7a\xae\x85\x20\xe3\x46\x20\x90\x15\x24\x8a\x2d\x35\x89\x10\xa5\xb0\x96\x4a\x78\x48\x5b\x0b\x24\xda\x74\x93\x91\x3e\x8b\x76\x3a\xb4\x96\x44\xaf\x88\xaf\x4e\xac\x93\x94\x3c\x51\x60\xd2\x1c\x2a\x29\x3b\x3d\x25\x49\x83\x6a\x45\x5a\x71\x5a\x59\x96\x90\x53\x52\x92\x57\xaa\x2d\x2a\x32\x14\x14\x89\xe4\xc6\x65\xff\x39\x04\x5d\x51\x39\x0a\x5d\x42\xc5\x41\x96\x49\xd4\x0e\xba\x4f\x78\x10\x2d\x6a\x4f\xfe\x21\x71\x48\xe0\xcd\x6a\x38\xc2\x4b\xce\xfc\x07\x3c\xaa\x49\x65\x79\x41\x61\x99\x58\x62\x2c\x30\x6a\x73\x15\xa9\xe9\xd9\xd9\x19\x69\x19\x29\xee\x16\xca\xd2\x46\x8d\x97\xbe\x56\x10\xd4\xcc\x61\xbf\x66\xc9\xd7\x56\x2a\x4d\xe5\xfb\x66\x54\x72\x6c\x7b\x3b\x08\x0c\xf4\xe3\x09\x94\xb3\xfb\xda\x49\x7c\x42\x66\x4a\x0a\xe1\xe0\x81\x42\x52\xc3\x64\x0a\x3f\x56\x58\xf4\xb0\x9b\xb3\x0c\x83\x99\x92\xed\x8f\x33\x29\x02\xfb\xc3\x6c\x7b\xfa\x1c\x74\x8c\xcc\x55\x27\xa5\x46\xf1\xa8\xd6\xf5\xc8\x74\x8c\x8c\x26\xc7\x9a\xda\x3a\xde\xb6\x72\x0d\x3f\xae\x29\xa5\x31\xb6\x52\x88\xad\x88\x2a\x88\x49\xcb\xcc\x49\xcd\x4a\xce\x64\x08\x7d\x0b\xae\xf5\xa9\x20\x74\x2f\xcd\x4a\x2b\x4e\xd7\x62\x94\x4d\xf1\x60\x8e\x38\x15\xbf\xa6\xc8\x7b\xd6\x11\x12\xc4\xf0\xca\xb6\x84\xe6\xa8\x72\x21\xb2\x7c\x47\x76\x5c\x2c\x49\xae\xac\xcd\xaa\xd1\xf6\x69\x8d\x21\x55\xbc\x1d\xf1\xe7\xfb\x76\xaa\x4e\xe2\x89\x62\xcf\xe2\x05\x95\x0b\xb4\x68\x87\x41\x2b\x71\x20\x0e\x84\xa0\x95\x60\x07\x76\x10\x74\x1e\x06\x8a\x84\x86\x2d\xf1\x28\x07\x27\x5c\xad\xc5\xd7\xd0\x13\xa7\x60\x2d\xd6\xc3\x4b\x38\x15\x42\x61\x26\x49\xae\x8c\x31\xa4\xa4\xb8\xaf\x59\x93\x92\x62\x88\xa9\x4c\x76\x27\xd8\x8e\xf1\xf0\x19\x2b\xc9\x59\xc2\x85\xfd\x1a\x36\x7c\x78\xd8\xaf\x61\xfb\x87\xef\xff\xf5\xd7\xfd\x14\xb1\x83\x5c\x9e\x18\x12\x78\xf2\x2a\xdb\x19\xb0\x9c\x27\x13\xf9\xd1\x2c\x89\xe2\x39\x1b\x1d\x9a\x60\x3d\x0b\xc1\xbc\xa4\x86\x6e\x07\x02\x8b\xf8\x7b\xe3\xc8\x7f\x5b\xd8\x37\x80\x9a\xf8\xfd\xcc\x93\x30\x1e\x0e\xb3\x64\x24\x0d\x0a\x9e\xe4\xb2\x30\x7c\x17\x59\xc2\x82\xda\x81\x70\xab\x79\xd2\x98\x6b\x65\xec\x10\x25\x79\x83\x49\xf2\x96\x94\xac\xfa\xdb\x6c\x96\x5c\x65\xad\x8d\x53\x47\x75\xcd\x64\xf1\x16\x41\xc7\x51\xa3\xd0\x11\x1d\x47\x3d\x00\x47\x70\x7c\xd0\x77\x1d\x85\x8e\x02\xe1\xf4\xac\xad\x3b\xbc\xc0\x12\xd8\x60\xe5\x5a\x3e\x6c\x8f\x75\x2c\x00\xdd\x74\x5d\x35\x51\xcc\x63\x89\xd9\xda\x38\xf7\x26\x51\x51\x6f\x75\xa5\xbc\xa7\x85\x31\x30\xf2\xce\xe1\xab\x62\xa9\xb1\xa4\xc8\x58\xc8\x10\xee\x47\x30\x53\x15\x45\x0d\x35\x95\x5a\xb3\x89\xae\x6c\x48\x48\x2d\x12\x7f\x44\x33\x45\x60\xdd\x3f\x0e\xff\x12\xc9\x89\x37\xf4\xf5\xb8\xb6\xfd\x57\xc4\x97\x07\x85\xb5\x15\x9d\x83\x28\xcc\x85\x8e\x6d\x02\x69\x8d\x30\x6c\x8c\x88\x20\x68\xd3\xf8\x4b\x8c\x25\x25\x22\xd1\x51\xbe\x34\x51\x7c\xc0\x92\x19\x2c\x7c\xce\x93\xd8\xb8\xec\x1d\xe5\x51\xee\x91\xe5\xcd\x09\x6d\x5a\xb2\x8c\xf7\x1b\xc6\x12\xc9\x85\x2f\x85\x87\x6c\x66\x4a\xa5\x48\x14\x7b\x9a\x9b\xf7\x08\x8f\xe9\x3d\xcd\x51\x3b\x45\xf2\x94\x35\x10\xee\x33\x9e\x26\x70\x04\xe2\x20\x0e\x8e\x10\xec\x50\x4c\x65\x89\x75\x60\x6d\xa5\x42\x02\x56\x3a\xc0\x39\x68\x95\xb8\xe6\x10\xc8\xe6\x45\x42\x35\x37\x57\x1f\x3a\xac\x21\x1c\x7c\xc4\xef\xdb\xd7\xde\xbe\x6f\x7b\xb0\x40\xbc\xf8\x1e\xbd\x62\x04\x4b\x4a\x0d\x25\xf9\xa5\xe2\xcb\x52\x2e\xfc\x1b\xfe\xa2\xaa\xaa\xaa\x6a\xeb\x34\xca\xf4\xcc\xcc\x74\x02\x27\x9e\xf9\xd2\x6f\x83\x27\x05\x39\xf4\xdb\xe8\x49\xf9\x0e\x84\x0e\x9a\xfc\x7d\x74\x1e\xa6\x01\x0f\x3c\x4c\x6b\x6b\x8a\x0e\x17\x88\x62\x0b\x2f\x40\x37\xdc\x67\xfd\x7c\xd8\xff\x92\x44\xd4\x3b\x09\x94\xf1\x60\x22\x60\x7a\xc0\x12\xf0\xe0\xfb\xc0\xa4\x95\xbf\xfe\xee\xd2\xb9\x02\x89\x7a\xb1\xcf\x9b\xa0\xd3\xef\x43\xc1\x89\x44\x44\x6c\x34\x44\xb4\x12\xcd\x04\x96\x18\x0c\x06\x83\x35\x25\x3d\xe1\x96\xe9\x37\xbd\x36\x6a\xcd\x07\x37\x3f\x3b\x7d\xf9\xfa\x57\x1f\x7b\x4f\x11\x2c\x7f\x91\xf5\x42\x44\x4c\xcc\xae\xb8\x88\xa7\x63\xdd\x2a\xaa\x2a\xab\xab\x2a\x98\xc6\x56\x32\x6c\xce\xac\x21\x9e\xdd\x33\x1f\x0b\xf7\x3f\xfc\xb8\x40\x5b\x5a\x56\x6e\x2c\xcf\x27\x43\x58\x49\xed\x4a\x8e\xe3\x13\xe9\xf9\xba\x5b\x42\x43\x6a\x74\x55\x94\x36\x2a\x3a\x39\x26\x55\x24\x1b\x05\xd5\xcf\xf7\x53\x37\x86\xb6\x1f\x17\xff\x3e\xe6\x47\x14\xe1\x35\x51\x2d\x69\x42\x6e\xa9\x29\xaf\x4c\x6b\x1d\x47\x10\x2b\x29\xcf\x03\xf1\x53\xe0\x2f\x81\x87\x83\x8e\x9a\x45\xd0\x9b\x4e\xcf\x2c\x35\xb5\xf0\xe0\x6d\x63\x6e\x04\xd4\xac\x03\x81\x43\x56\x1e\xab\x26\xb0\x82\x55\x46\xc2\x83\x3e\x09\xcc\x81\x98\xad\x30\x0e\xee\xf2\x50\xc9\x0b\x84\x9b\x4b\x63\xbc\x79\x04\x85\xff\xa2\x31\xbe\x77\x04\x35\x77\x20\x51\xe0\x40\xf4\x44\x05\xce\xb1\x62\xad\xde\xda\x95\x54\x5b\x39\x12\xfd\x23\x4f\x26\xf1\xa8\x27\xdc\x8f\x3c\x91\xba\xad\x6c\x9c\xf8\xb3\xd8\x41\x38\x38\xc2\x12\x8b\xfa\x65\xab\x00\x89\x71\x60\x65\xd4\x8a\xd9\x2c\xb9\xca\x8d\x61\x49\x8f\xb5\x76\xd1\x17\x83\xff\x29\x0e\xda\xda\x9c\xe2\x7f\xeb\xb9\x39\xa8\xe1\x09\xfd\xd9\xb5\x1d\x93\x44\xb8\x82\xd7\xb8\xd4\xbc\xf4\x8c\x54\x2d\xd1\xd7\xe9\x0f\xad\x15\x25\xb5\xc5\x44\xbd\x7e\xf6\xcb\x4d\x5f\x69\xc9\xa9\xe0\xc3\xeb\xd7\x07\x87\xac\x5b\xdf\x1e\x7c\xf2\x64\x7b\xfb\x49\xc1\xda\xce\xad\xfd\x10\x19\xcb\x47\xf1\x21\xac\xb5\xa4\x36\xc4\x5a\xe5\x7e\x54\x2b\xac\x18\x57\xc3\x17\x2c\xe9\x53\x4e\x65\xbd\x12\x78\xc4\xee\x23\x92\x33\xbb\x8f\xc0\x1a\x30\x90\xb4\xba\xfa\x9c\x06\x6d\x43\xbd\xb1\xbc\x4e\x94\xf4\x10\x45\x1c\xce\xa0\x82\x83\x31\x3c\xf9\x5b\x3d\x20\xdc\xe4\x89\xcf\x54\xb4\x5f\x85\x4a\x2d\x2a\xd1\xfe\xdc\xed\xa9\x62\x5f\xb1\xbe\xe7\x89\x62\x22\x9f\x94\x98\x9d\x9e\x2a\x58\x0e\x59\x66\x52\xe4\xaa\xb5\x61\x2f\x61\x39\x32\x71\xf6\xcd\x1f\xc8\x95\xce\xce\x2b\xc4\x24\x74\x14\x15\x2f\xda\x90\xcd\xac\xcf\x5e\x93\x6b\xd0\x10\xb8\xca\x8e\xbb\x47\x3c\xad\xa2\xdb\x24\x9e\xec\xa0\x07\x49\x93\x28\x70\x09\x45\xe5\x03\x74\xd5\x12\xdb\x04\xd7\x6d\xa2\x69\xe6\x49\x6e\x99\xd6\x68\x2c\x28\x30\x8a\x44\x67\xee\x4a\x65\xc9\x87\xbc\x48\xba\x59\x1d\xed\x4b\x0c\x70\x8f\x25\x79\x36\x9a\x25\x70\x92\xb7\xd2\x67\x8f\x09\xd5\x0a\x02\x1d\xd0\x8d\x1d\x0a\xc2\x59\xc7\x8e\x44\xf2\x91\x7c\xe0\x11\xa1\xe3\x92\x12\xe3\x45\xa2\xb8\xcf\x13\xb0\x56\x11\x89\xcf\x4a\x48\x49\x11\x6c\x83\x6c\x81\x4c\x14\x7a\xbb\x69\x82\x9e\xe0\x49\xe6\x5c\xf6\xbf\x41\x6c\xa4\xa3\x08\xd9\xb3\xf3\xb0\x00\x32\xfa\xf0\x9e\x3d\x87\x45\xb2\x1b\xb9\xea\x98\x42\x21\xa3\x2e\xad\x2e\xa5\x86\x21\x50\xd6\xd7\x43\x29\xc0\x8e\x25\x8a\xb9\xef\x2e\xbd\x2e\x80\x3a\x8e\x27\xd0\xc1\x9a\x4d\xbb\x59\x62\x28\xd7\xc2\xf8\x6a\x96\x8c\x63\xe1\x73\x96\x6c\x59\x88\xae\xbe\xc8\x6a\xb7\x86\x95\x54\x85\x8b\xa4\xa2\xa0\xa0\x69\xb7\xf6\x0b\xba\xac\x24\x23\x23\x5f\x24\xa3\x78\xf0\x0e\xe4\xc9\x15\x56\x29\xa9\x25\x35\xd1\xa1\x2f\x4d\xb4\x2b\xa3\x62\xc3\x42\xc4\xe0\x0d\x6f\xac\x1d\xae\x25\x14\x08\x3c\xf1\xb7\xb1\x23\x2a\xaa\xc5\x3a\x9a\x6f\x16\x09\x37\x35\x9f\xb2\xa8\x14\x55\xf1\xad\x09\x75\xa9\x24\x8b\xc9\xca\xca\xc8\x49\xd7\xa2\x9a\x8e\x4f\x22\xfe\x3c\x76\xd3\x43\x78\xc2\xe1\x00\x89\x82\x01\x34\x99\x64\x25\x63\x73\x14\x37\x9b\x25\xc3\x58\x8c\x22\x92\x9c\xb5\x0a\x9e\x04\xd4\x56\xb9\xce\x04\x6a\x88\x65\xc9\x01\x76\xe0\xcb\xdf\x3d\x23\x06\x45\xdf\x97\x40\x6c\x9f\xe4\xa4\xc0\x01\x8f\xbd\x60\x80\x40\x86\xf0\x71\x49\xd5\x75\xd6\xfa\x31\x11\x1d\xa6\x72\x64\x6d\xd0\x91\xd3\xa7\x8f\x58\xff\x41\x6b\x09\xa4\xf0\x92\xbd\x95\xe5\x58\xd9\x48\xb6\xad\xff\x40\x32\x62\x3c\xca\xd1\xe1\xd1\x38\x20\xa4\xf8\xaf\xab\xa5\x95\x62\x51\x61\x41\x61\x91\x86\x18\xc0\x24\xd9\xf1\x10\xcc\x13\x3b\xc3\x09\xde\xc1\x4a\x4c\x67\x59\x42\x77\x9d\xb2\x4a\xd2\x60\x92\xd4\x60\x22\xa8\x0e\xe3\x49\x81\x75\x9c\x4e\x6a\xb5\xb5\x35\x04\x4c\x74\x3b\x41\x43\x20\x2b\x92\xab\x86\xff\x7c\xc9\x24\x03\xa8\xef\xde\x35\xa0\x7a\x92\x96\x68\x0d\x0a\xa0\x41\x7e\xf6\xd4\x57\x22\x39\xca\x3a\x10\x85\x1f\x2f\x5c\x25\x66\x13\xfd\xf7\x2c\x4f\x4f\x83\xdd\x4f\x3a\xfa\x75\x07\x1d\x5d\x46\x2c\x6a\xc9\x44\xc5\x37\xa5\xef\xd9\xab\x21\x8c\xca\x49\xc6\xc8\x64\x2f\x7a\x47\x07\x62\xb6\xb6\x72\x02\xa3\x73\xa0\xca\x4a\xb0\xb6\xc3\x9c\x76\xe4\xb8\xad\x6b\xe9\x6b\xc7\x76\x24\xa7\x2c\xab\x44\x24\x56\xb6\x6e\x9b\x15\x23\x19\xe9\xb9\x59\x59\x04\xd4\xa8\xb6\x0e\x47\x9e\x91\xc3\xda\xc3\x87\x08\xc4\x43\x3b\x19\x49\xa7\x67\x12\xf4\x0a\x43\x0e\xed\x71\xac\x96\xe0\x10\xfc\x23\x0a\xdb\x34\xc9\x85\x04\xfa\xc1\x68\x70\x80\x5a\xe8\x47\xe0\x86\x15\x4b\x8a\x66\x5e\x20\xb8\x1a\x3d\x61\x10\xbc\x01\x7a\x22\xd7\xe1\x08\x2c\xd3\xc9\x3f\xa7\x09\xdd\xbe\xaf\xd4\x64\xda\x5e\x1a\x2c\x92\xbf\xb5\x5d\x43\x14\xc1\x7f\x37\xee\x82\xe3\x3c\x71\x31\xd8\xda\x3a\xdd\x4e\xac\x43\x78\x62\xe1\x2d\x3c\xc1\xc1\x30\x98\xc8\x64\x32\x99\x9d\xcc\x45\xe6\x20\xfb\xef\x0f\x23\x53\x58\x9d\x7f\xff\x5b\xc6\xfe\xc7\xe7\xf8\x1f\x9f\x03\x1d\x6c\x57\x2c\xa3\x64\x32\x79\x81\x7c\xa2\x4c\x26\xcb\xee\x73\xed\x23\x65\x32\xbb\x7c\xd9\xff\xf0\xd9\x19\x17\x11\x29\xf3\x95\x79\x3c\x93\xd1\xb2\x7f\xcb\x64\x32\x5a\x66\xd7\xf7\xfe\xbf\x3f\x1e\x32\x0f\x9b\xeb\xd0\xf7\xb7\x1b\xf4\xe2\x9e\x4e\xe6\x60\xf5\xd9\x0d\x92\xc9\xec\xe8\xff\x4a\xd0\xee\x1f\xb1\xff\x01\xfe\xff\xc2\x87\xed\xe7\x48\xd1\xc7\x15\xcc\x89\xff\xb7\x13\x96\xdb\xf5\xc8\x64\xb2\x58\x99\xaf\x8c\x92\x4d\x96\x79\xc8\xf6\xcb\xda\x65\x1d\xb2\xf7\x64\x5f\x0e\x1c\x34\x48\x18\xf4\xff\x63\xbd\xda\x62\xe3\xb8\xca\xf0\x37\xb3\x73\xad\x63\x9f\xa1\x34\xa5\x6a\x21\x4c\x21\x51\xd2\xa8\xd9\xdd\x44\xbd\x80\x15\x45\xeb\x36\x71\x1f\x28\xf6\xd6\x72\xab\xaa\xa2\x69\x36\xf6\x6c\xbc\x64\xbd\xb3\x9a\x9d\xb8\x32\x42\xd1\x88\x77\xa2\xbc\xf0\x02\x52\x14\xf1\xc4\x53\x14\xa1\x22\x2e\x0f\x25\x48\xbc\x55\x44\x11\x14\x4a\xa1\x98\x94\x5b\xb9\x9a\x73\x06\x02\x3c\x65\xd0\x9c\x39\x33\x7b\x66\xbc\x49\xfb\x50\x4b\xbf\xcf\x3f\xff\xfd\x7a\x66\xf6\x14\x9d\xa1\x7b\xe8\x31\xba\x40\x4f\xd2\x2e\xed\xd1\x01\x3d\x4f\x2f\xd0\x4b\xf4\x0a\xfd\x36\xbd\x4e\xb7\xe8\x36\xbd\xcd\x66\xd8\x1e\xb6\x9f\x1d\x60\x75\x76\x8c\x2d\xb0\x93\x6c\xc0\xce\xb3\x0b\xec\x12\xbb\xc2\x5e\x67\xd7\xd9\x16\xdb\x66\xb7\xe3\x99\x78\x4f\x7c\x2c\x5e\x88\x4f\xc6\x83\xf8\x7c\x7c\x21\xbe\x14\x5f\x89\x5f\x8f\xaf\xc7\x5b\xf1\xf6\xad\x74\x0e\xd2\x7e\x7d\xab\xe2\x19\xd4\xa1\x0f\xd3\x16\x6d\xd3\x53\xf4\x0c\xfd\x22\x1d\xd2\x88\x5e\xa4\x97\xe9\x55\x7a\x8d\xde\xa0\x37\x29\x65\x60\x0e\x73\xd9\x01\xf6\x08\x6b\xb2\x16\x6b\xb3\x53\x6c\xc8\x22\x76\x91\x5d\x66\x57\xd9\x35\x76\x83\xdd\x64\x34\x46\xec\xc4\x0f\xc7\xad\xb8\x1d\x9f\x8a\x87\x71\x14\x5f\x8c\x2f\xc7\x57\xe3\x6b\xf1\x8d\xf8\x66\xea\x39\x79\x17\x48\xbe\x90\x3c\x97\xcc\x25\xcd\xad\xf7\xb6\xbe\xb6\xb5\xe4\x4c\x3b\xbb\x9c\x7b\x1c\xdb\xb1\x1c\x13\x70\x34\xa7\xe6\xa8\x8e\xe2\x80\x24\xe4\x16\xf9\x37\xf9\x17\x89\x09\x23\x94\xfc\x73\xe6\x1d\xb2\x4d\xfe\x41\xfe\x4e\xfe\x46\xfe\x4a\xfe\x42\xfe\x4c\xde\x23\x7f\x22\x7f\x24\x7f\x20\xbf\x27\xbf\x23\xef\x92\x9b\xe4\xb7\xe4\x37\xe4\x1d\xf2\x6b\xf2\x2b\xf2\x36\xf9\x25\x79\x8b\xfc\x82\xfc\x9c\xbc\x49\x7e\x46\x7e\x3a\xf5\x1a\x1f\xab\x8d\xbb\x74\xe5\xe4\x87\xdd\xe6\xe2\xcf\xc0\x2e\xd4\x30\x05\x95\xc7\xa0\x29\x6f\xbc\xb5\xef\xcb\x3f\x79\x85\x1c\xbd\x85\x1a\x5f\x4a\xbc\xb1\x78\xb4\x99\x9e\x6f\x1e\x5e\xfb\x7e\x92\xdc\x4e\x6c\xc5\x50\xf8\x0e\xa9\xc2\x82\x02\xb1\x73\x76\x5a\xbf\xc4\x56\xaa\x4b\xa2\xbe\x56\x8b\x30\x54\xae\x01\x46\x84\x0d\x3d\x02\x34\xe0\x95\xd4\xfa\x24\x48\xf9\x02\x7f\x39\x5d\x48\x63\xfc\xcc\xf1\x14\xf4\xf4\x39\x2a\xf3\x4c\x60\x53\x8f\x30\xc8\x65\x8c\x5c\x47\xd8\x34\x22\x3c\x68\x88\x67\x33\xc2\x91\x5c\x66\x12\xa4\x7a\x5a\x66\xbb\x95\xca\xd5\xc4\x33\xf7\x1d\x8d\xed\x66\x31\x24\x89\x9e\xc7\x29\xc9\x68\x92\xff\x3b\xe5\x5a\x80\x88\x45\xc3\xf8\x94\xf3\x35\xcb\xb4\x2f\xe9\x72\xec\x12\xdf\x50\x79\x2c\x5f\xd7\x81\x97\xee\x94\xdb\x04\x68\x09\x3b\x8f\xa7\x60\x8e\xe9\xd3\x72\x3d\xf4\x68\x67\x9f\x4a\xbd\xc9\xce\x97\x38\x44\x52\xec\x59\xfd\x5a\x26\xbf\xfc\xcb\x35\xce\x73\x97\x7c\xa2\x16\x49\xb9\x8f\xfb\x50\xe4\x2a\x9f\xba\xa8\xb5\x3e\xe6\x3f\x9a\xce\x96\x21\xf5\x43\x8f\x4a\xfe\x5a\x06\x92\x44\x8e\xf9\x8e\x10\x61\xb7\x9c\xf7\x8e\x3e\x66\xf9\x39\xe2\xec\x4a\x75\xd1\xaa\xb3\x64\x02\xa4\x94\x43\x84\x87\xcc\xbc\xee\x02\x6c\x61\x53\x13\xbd\x54\x23\xb4\x54\x51\xc3\x9c\xa6\x55\xe2\x36\x81\x03\x72\x4c\x72\xed\xe4\x99\x31\xa5\x5a\x48\x7d\x6c\xc9\xf5\x29\x78\x51\xd6\x2b\x91\x57\x11\xa3\x06\x1c\xd2\x80\x69\x2d\xc2\xe7\x53\x50\x23\x1c\x52\xa3\xf1\x73\xee\x43\x13\xfb\x62\x94\xe7\xb7\x65\x54\x67\xba\x32\x3b\xd2\x6e\xe6\xbc\x96\xd8\xbf\x69\x33\xc2\xa1\x5c\x57\x97\x6a\x92\x9e\x6a\x06\xa7\x0d\x40\x4f\x21\x9f\x3d\x2d\x93\x9d\xd6\xcb\x7a\xee\xa4\xbe\x8b\x9a\xec\xca\xf7\x3e\xa7\x29\x51\xa9\xd6\x8f\xe7\x74\x4d\xda\xd5\xbb\x81\xd4\xb7\x43\xb5\xaf\x00\x5a\x4d\xdc\x5d\xe0\xe7\x67\xa4\x59\xfb\x64\x0a\x26\x32\x30\x72\x90\xee\x32\x03\x78\x68\xe7\x2c\x63\xaa\x9a\x87\xf0\x7b\xdc\x18\x7f\xec\xe4\xb5\x2c\x6a\x27\xe4\x8c\x42\x0f\x78\x54\x9c\x45\x5e\x26\x70\xd0\x40\x71\x07\xba\x66\x94\xed\x4d\x31\x2b\xc0\xee\x09\x3b\x53\xec\x6c\x2a\x63\x55\xee\xe2\xfc\x0e\xb0\x33\xf9\x75\xa3\x3a\xcf\x42\x36\xbf\x27\xcc\xff\xe0\x91\xea\x2e\x89\x38\xf3\x7b\x99\xe7\x65\xcb\x3a\xe3\xd3\xb1\xc6\x74\x37\xef\x87\xfd\xc1\xef\xc5\x14\xf6\xe7\x31\x8b\xf8\xd3\xf9\xb9\x57\xf2\x71\x5c\xc4\xf3\xd9\x94\x3e\x96\x4b\x12\x29\xe6\x63\x3a\xf0\xc0\x84\x3b\xa1\x0a\xe9\x07\xc6\xaa\x01\x3c\x2f\xe2\x3e\x28\xfc\x58\x26\xf0\x69\x5b\xc4\x5e\x05\x0b\x98\x49\x41\x8f\x26\xdb\xb7\x2a\x67\x5e\x5f\xa9\x0f\x1c\xd7\x81\x29\xab\x92\xbf\x55\xc1\xad\x2a\x2e\xfa\x2b\x9e\x3f\x6a\x48\x36\xc5\x8c\xe7\xfd\xaa\xdc\xf9\x49\x62\x49\x3c\xe1\xbf\xd8\x0d\x73\x82\x9e\x55\x89\xa1\x3a\x13\xd6\xff\xb0\x64\x8b\xe7\x49\x75\xca\x67\xdb\xaa\xcc\x40\xce\x37\xdf\x67\x36\xcc\x4a\x1c\xc5\x0c\x7c\xa7\xc4\x2b\xe6\x51\x07\x3c\xae\xfb\xbd\xb1\xfd\x2a\x08\x3b\xf7\xa7\xef\x5a\x13\xf8\xf8\x24\x19\x71\x87\xef\xb3\x26\xd3\x97\x2a\xf1\x9d\xb0\xcb\xb3\x5a\xcd\x6d\xef\xce\xbc\xb2\x5e\x98\xd9\x8e\x9c\xd5\x80\x03\x39\xbd\xfa\xde\x33\xf2\x79\x8f\xb0\xdf\xc6\x78\xc7\x65\x3f\x9c\x9f\x60\x5f\xfe\x0e\xd2\xcb\xf7\x03\x91\x67\xc4\x28\xbf\xfb\xf7\xd9\x65\x5f\xf7\x55\xe6\x6b\xc7\x6c\x48\xf4\x4f\xd8\x52\x5d\xaa\x60\x4e\x78\x87\x57\xeb\x69\xaa\xd2\xac\x47\x68\x9a\x79\xad\x22\xd4\xa5\x77\xfe\x5e\xf3\x7d\x3f\xa9\xdb\x50\x7f\xc4\x91\x8f\x29\x0f\x16\xdf\xc2\x8d\xe2\xc7\xa3\x82\x29\x34\x04\x5e\xc3\x47\x30\x2b\x70\x4d\xa2\xeb\xb8\x17\x9f\x13\xb8\x21\xd1\x4d\x3c\x87\x97\x05\x6e\x61\x17\xae\x08\xdc\xc6\x3d\xf8\x81\xc0\xa7\xb0\x1b\x3f\x16\xf8\x0c\xf6\xe0\xed\xf4\x17\xae\x66\xf3\x5f\x11\xff\x15\xb8\x82\xfb\x95\xe7\x05\xae\x62\x46\x39\x2b\xf0\x1a\x3e\xa5\x6c\x0a\x5c\x93\x64\x74\xec\x55\xbe\x21\x70\x43\xa2\x9b\xf8\xa6\xf2\x43\x81\x5b\x78\x40\xed\x08\xdc\xc6\x7d\x6a\x6e\x67\x0a\x07\xd5\xaf\x0a\x7c\x06\x47\xd5\xef\x3e\xed\x0f\x37\x83\xde\x99\xb5\xd0\x3d\xde\xd9\xf0\xdc\x67\x3a\x83\xd5\x4d\xf7\x48\xf3\xf0\x13\x75\x77\xae\xdf\x77\x39\x6b\xe4\x06\xde\xc8\x0b\x36\xbc\xd5\xfa\xbc\x3f\x08\xe7\x5e\xf5\x46\xfe\xba\x37\xbf\xb8\xb0\xfc\xec\xdc\x53\xb3\x8b\xcb\xf3\x27\x5e\x6c\x2f\x2e\x2d\xbf\xe0\x05\xa3\x9e\x3f\x70\x1f\xab\x3f\x59\x6f\x72\x1b\xed\xbe\xd7\x19\x79\x6e\xe0\x75\xbd\xc0\x0d\x7d\x37\x5c\xf3\xdc\xb1\xc3\x91\xb7\x12\xa6\xf2\x5d\x3f\xe0\x9c\xae\x3f\x08\xdd\x30\xe8\xac\x7a\xeb\x9d\xe0\xac\xdb\x09\xc3\xa0\x77\xfa\x1c\x17\x19\xf8\x61\x6f\xc5\x1b\xd5\xe7\xfd\x20\x74\x85\xff\x71\xbc\x6b\x61\x38\x9c\x6d\x34\x52\xfd\x4e\xc6\xab\xf7\xfc\x89\xc4\x46\xbf\xb7\xe2\x0d\x46\x5e\x03\x4f\xc3\xc7\x10\x9b\x08\xd0\xc3\x19\xac\x21\x84\x8b\xe3\xe8\x60\x03\x1e\x5c\x3c\x83\x0e\x06\x58\xc5\x26\x5c\x1c\x41\x13\x87\xf1\x04\xea\x70\x31\x87\x3e\xfa\x70\x25\xad\x11\x7f\xf2\x30\x82\x87\x80\x6b\xaf\xa2\x8e\x79\xf8\x18\x20\xc4\x1c\x5e\xe5\x3c\x1f\xeb\xf0\xb0\x04\x0f\x67\x70\x0e\x7d\x74\x10\x60\x1e\x8b\x58\xc0\x32\x9e\xc5\x1c\x9e\xc2\x2c\x16\xb1\x8c\x79\x9c\xc0\x8b\x68\x63\x11\x4b\x58\xc6\x0b\xdc\xe6\x08\x3d\x6e\xcd\xc5\x63\xa8\xe3\x49\xd4\xd1\x94\xa2\x6a\xa3\x0f\x0f\x1d\xee\x3f\x8b\xa4\xcb\xb5\x5c\x84\xf0\xf9\xff\x35\xce\x99\x94\x6f\xaa\xb3\x82\xb0\xb0\xdf\x85\x2f\x34\x33\x9d\xae\xc8\x22\xa5\x04\xe8\x60\x15\x1e\xd6\x79\xec\x67\xe1\xa2\x83\x90\xd3\x7b\x38\x8d\x73\x92\x95\x01\x7c\xfe\xb4\xc2\x33\xcf\x6a\x11\x70\x2b\xe5\x6a\x4c\xaa\xf6\x1a\xb7\x39\xc4\x2c\x1a\x68\x14\xfe\x3b\x25\xbd\x3a\xf7\xf4\xc1\x25\x1b\xe8\x8b\x68\x06\x3c\xe3\x06\xc4\x87\xd8\x5d\xfe\xfe\x1f\x00\x00\xff\xff\x31\xa1\x82\xc2\x98\x0e\x02\x00") + +func uiAppLibFontAwesome470FontsFontawesomeOtfBytes() ([]byte, error) { + return bindataRead( + _uiAppLibFontAwesome470FontsFontawesomeOtf, + "ui/app/lib/font-awesome-4.7.0/fonts/FontAwesome.otf", + ) +} + +func uiAppLibFontAwesome470FontsFontawesomeOtf() (*asset, error) { + bytes, err := uiAppLibFontAwesome470FontsFontawesomeOtfBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "ui/app/lib/font-awesome-4.7.0/fonts/FontAwesome.otf", size: 134808, mode: os.FileMode(420), modTime: time.Unix(1, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _uiAppLibFontAwesome470FontsFontawesomeWebfontEot = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xcc\xbd\x0b\x7c\x54\xd5\xb5\x3f\xfe\x5d\xfb\xbc\x66\x26\xf3\x3e\xf3\x48\x26\x93\x64\x9e\x67\x02\x89\x01\xe6\x19\x79\x24\x23\x22\xaf\x04\x44\xa5\x8a\x88\x18\x29\x28\x0a\x28\x2a\x08\x52\x1f\xc7\x4a\x2d\x2a\x55\x44\xb4\xd4\x5a\x1b\x9f\x85\x7b\xad\xe5\xb6\xda\xab\x2d\x7a\xa7\x2f\x6b\x5b\xb5\xb6\x72\xad\xb5\xb6\x37\x6d\xb5\xf5\x56\xf4\x06\x6a\xbd\x0a\x99\x93\xff\xe7\x9c\x33\x93\x4c\x02\x68\x7b\xef\xef\xf7\xfb\xfc\xe7\x93\x73\xce\x7e\xef\xb5\xd7\x5e\x7b\xef\xb5\xd6\x5e\x7b\xe7\xb2\xcf\x33\x3c\x76\x33\x03\x81\x61\xec\x8f\xb0\x83\xf4\x6f\xef\x22\x1c\x13\x63\xfe\xce\xdd\xfc\xf3\x1d\xe3\xe3\x80\x00\x66\xe3\x72\x5c\x86\x0d\x38\x05\x9b\xb0\x0a\x57\xe1\x72\xac\xc3\x2a\x00\x4e\x9c\x89\x55\xb8\x18\x1b\xb1\x16\x17\xe2\x4a\x00\x09\x9c\x8d\x55\xb8\x12\x57\xe1\x12\x23\x4f\x04\x59\x74\xa0\x80\x0e\x4c\x46\x04\x69\x4c\xc6\x14\xe4\x3f\xb6\xcc\x0a\x38\x0e\xa8\xe0\xb0\x68\xf6\xec\xc5\x0b\xd6\x3c\x3b\xe7\x69\xb0\x9b\x75\xc8\xc2\x73\x66\x9d\x36\x9b\x0d\x82\x07\xbb\x79\x3d\x80\xc8\xe9\x67\x4d\x4a\x6f\x4b\x6f\x29\x02\xb4\x04\x40\xdf\xa7\xd7\x5d\xb8\xde\xf6\x6f\x53\x6f\x00\xec\x7b\x00\x76\xf8\xe2\x0b\xaf\x5a\x3f\x3c\x0c\x0e\xec\xe6\xd5\x00\x2c\x17\xaf\xbd\xe6\xa2\x3b\xfe\xfb\xf1\x05\x40\xe8\x31\xb0\xde\xfd\xab\x57\x5d\xb8\xd2\x7d\xcb\x5b\x27\x01\x78\x03\x40\x7e\xf5\xea\x55\x17\xba\x38\xdb\x93\x00\xf9\xf4\xe6\xac\x5e\xb7\x61\xf3\x69\xd7\xd4\x7f\x0e\xa0\xa7\x00\xdb\xe0\xda\xcb\x3f\x7d\x21\xfb\xdb\x83\xcb\x00\xd7\x7d\x40\x9d\x7b\xdd\x85\x9b\xd7\x73\xed\x2c\x0c\x50\xa7\x0e\xcf\x65\x17\xae\x5b\xf5\xc7\x2f\xde\xf6\x18\xd8\xc5\xab\x01\xfe\xe6\xf5\x97\x5f\xb5\xe1\x1b\x77\x7c\xf9\x01\xb0\x35\x83\x40\x68\xa3\xd1\x36\x9e\x7e\xb6\xe3\xe7\x9b\xcf\xbd\xc0\x35\xfd\x6f\xa8\x93\x8c\x26\x1f\xc8\xbc\x98\xae\x7e\x87\x87\x87\x61\x25\x51\xf7\x5a\xc0\x2a\x9d\x43\x80\x88\x61\x00\x56\x0c\x0f\x0f\x0f\x5b\x69\xa4\xd3\x2a\x3f\xf6\xa4\x1e\xc2\x7e\xc0\x1a\x90\x32\x03\x8c\x5c\x7a\xaa\x62\x25\x09\x27\x5e\x42\x3b\x20\x00\xfc\x76\x3e\x03\xe0\x66\xf3\xcb\xae\x02\xe8\xd6\x63\xfb\x7d\xf4\xb7\xfe\x9a\x2b\xaf\x42\x11\x91\xbf\x55\x60\x10\xcd\xca\x6b\x21\x88\x80\x38\x15\xeb\x8d\x8a\x3f\x05\x50\x09\xd0\x5b\xf6\x77\x3c\xe7\xeb\x2d\x15\xd5\xd1\x30\xdd\xad\x3f\x82\xee\x57\xc7\xc6\x49\xc0\x35\x82\x8a\xcb\xaa\x69\xc4\x6a\x1e\x00\x82\x19\x16\x12\x2b\x7e\x49\x45\xba\x9a\xe6\x78\x8f\x9e\x8f\x37\xcb\x2e\xea\xe9\xb8\x8a\xdf\xa8\x5b\x1d\x2d\xb7\x02\x83\x4d\xa8\xc2\x59\x93\x86\xaf\xa9\xff\x13\xdb\x5a\x81\x85\xc7\xe8\xb7\xb6\xbd\xd2\xd8\xb0\x2d\x42\x2d\xec\x35\xf1\x22\x03\x09\xc0\xbd\x02\xb0\xf4\x44\x6d\x3b\xce\x53\xac\x94\x93\xd3\x1f\x69\x34\xdc\x21\xa8\x23\xb8\xdb\x52\x8b\x1b\x61\x2c\xde\xdd\xc2\xb8\xbe\xa8\xa4\x5b\x6a\x3c\x6a\x4d\x3b\x4c\x5c\x16\x25\x83\x80\xc7\xe2\xbb\x8a\x87\x9a\xfa\xc1\xa9\x35\x78\x18\xed\x93\x91\x76\xd7\x7e\xab\xb0\x0a\xa3\xf1\xed\x3c\x70\x81\x58\xd3\x37\x82\x3a\xa6\x3e\xbd\xdd\xac\x16\xe6\x13\x3e\x2a\xfc\x95\x76\x0b\xe3\xfa\xde\x5d\xf9\x5e\x25\x01\x54\x49\xc3\x8f\xa7\x25\x09\x70\x8d\x81\x5b\x45\xa3\x54\xc5\x7b\xe5\xb1\x56\xca\xe4\x2b\x7d\xc9\x54\x14\x59\x05\x6f\xd5\x30\x7e\x1c\xac\x12\xd0\x5a\x4b\x47\x9c\x6a\xc2\x30\x9e\x66\xa4\x9a\xf6\xd7\xf4\x5d\xb1\x16\x27\x23\x71\xaa\xd9\x3f\x95\x76\x8d\xc0\xc8\x03\x27\xf1\x80\x83\x57\xb1\x40\x7f\x98\x8a\x93\x98\x3a\xea\xaf\xd6\xc1\x57\xc6\x8b\x38\x96\x7e\x8b\xe2\x78\x9a\x1e\x47\x2f\x35\x63\xb3\x1a\x57\xac\x8c\x3f\x87\xa4\xe2\xa4\x4a\x5e\x26\xa8\x60\x55\x9c\x54\xbe\x7d\x3a\x9e\x98\x8a\x15\x22\x20\xe8\x8f\xa4\x82\xc4\x0a\x2c\x82\x0a\x47\x75\x7c\x0a\x2a\x38\x51\x45\xe2\x78\xfd\x5d\xc1\x8b\xbd\x3a\xf6\xab\x61\xa4\x8e\xc1\x77\xbe\x1a\xce\x03\x9c\xfe\x7c\xd2\xf8\xaa\xe9\xbb\x2c\xf7\x59\x80\xe7\xc0\x0b\xd5\x71\x04\x74\xd6\xd0\x58\x4c\x7f\x24\x98\x8f\x58\x7d\x6a\xe6\x33\x11\x68\xd4\x69\x70\x1c\x0d\xd7\x8d\x6f\x47\xa5\xde\x59\xc6\x18\x02\x38\xfd\xa9\xe0\xb3\x3a\x9e\xab\xe9\x46\xf2\x0a\x40\x7b\xe5\x3b\x32\x0f\x49\x95\xb0\x4a\x3f\x44\x24\x75\x78\xb8\x76\x4e\x15\x00\xff\x71\xc6\xca\xc8\x58\xd5\xd3\x58\xc6\xcd\xc7\xd5\xb1\x6f\x35\xd3\xaf\x13\xc7\xd3\x74\x25\x6d\x75\x7e\x90\x3e\xc0\x84\xf1\xe3\xa9\x02\x67\x75\x6e\x36\xda\x65\xad\xcd\x33\xfa\x75\x5b\x46\xc3\x23\xd5\xfe\xb0\xfe\xfd\x73\xa3\xfe\xa4\xaa\x30\x57\xe0\x8f\x48\x80\x5c\x53\xc7\xac\x0a\x3c\x27\x4b\x80\xb7\x26\x5d\x2d\xcc\x5d\x02\x50\x7f\x9c\x79\x61\xfc\xd3\x20\x01\x2b\x45\xe0\xdc\x0a\xdc\x13\x2b\xe5\x58\x25\x20\x65\xad\xc0\x3e\xfe\xb1\x00\x4e\xfd\x11\xd4\xe3\x97\x6f\x19\xf7\xad\xe2\xb7\xa6\x1f\x0c\xb7\x00\xd4\x59\xc6\xb5\xdf\x32\xce\x6d\x19\xef\xae\xf4\x6f\xc5\x2f\x8b\x35\x65\x56\x68\x9c\x55\xe9\xaa\x66\xbe\x65\xfa\x18\xb5\x00\x62\x25\x8e\x59\x60\x8e\x0b\x61\x1c\xfe\x84\x9a\xb2\x2c\xe3\x60\x18\x4f\x13\x96\x0f\xb1\xd8\x5a\xf1\x1f\x0f\x4f\x55\xda\xb6\x8c\xa3\x81\x6a\xbc\xf4\x09\xb4\x21\x8d\x83\x63\x84\x06\x9e\x1c\x13\x37\x42\x8f\x02\x70\x91\x91\xf7\xa9\xd1\xf2\x47\xda\x3f\xb6\x4f\x02\x22\xe0\x94\x80\xa6\xe3\xd1\x45\x65\x1e\x4f\x5a\x8e\x1f\x7e\xe6\x38\xf8\x4e\xb3\x8e\xa5\xd5\xf1\x6d\x4b\x1c\xaf\x5d\x95\xb2\xa3\x22\xb0\x86\x07\x5a\x2b\xe1\xdc\x78\x1e\x46\xac\xd2\xbb\x6a\xd0\x23\x57\x1d\xe3\x95\xf2\x47\xd2\x0b\xc3\x48\x8a\x95\xf5\x48\x18\x3b\x3f\xb8\x6a\x69\x44\x1c\xbb\xe6\x27\xad\x63\xeb\xf2\x8f\xa3\xaf\x63\x68\xa3\x26\xbc\xc9\x5a\x83\x97\xf1\x4f\x0d\x6f\x41\xe3\xc7\xc5\xc8\xc3\x6a\x68\x5d\xc5\x64\x1d\xe7\x15\x18\x27\xd5\xf0\x28\x8a\xf4\x71\x2c\x71\x85\xa3\xae\x3c\xe1\x0a\x43\x7c\x10\x9c\xe1\x0a\x83\xa7\x97\x75\xc6\x19\x45\x08\x86\xe8\xb3\x17\x8f\xe3\x09\x3c\x87\xd7\xa2\xb1\x58\x73\xac\x6f\xd0\x39\xd8\x3c\xd8\x35\xb8\x70\x70\xf9\xe0\x65\x83\xd7\x0f\xde\x3e\x78\xff\xe0\xe3\x83\xdf\x1c\x7c\x69\xf0\x77\x83\xef\x0d\x6a\x87\x9c\x87\x9a\x0f\x75\x1c\xea\x3a\xb4\xf0\xd0\xf2\x43\x97\x1d\xba\xfe\xd0\xed\x87\xee\x3f\xf4\xf8\xa1\x67\x0f\xbd\x74\xe8\x77\x87\xde\x3b\xa4\x1d\x76\x1e\x6e\x3e\xdc\x75\x78\xe1\xe1\xe5\x87\x2f\x3b\x7c\xfd\xe1\xdb\x0f\xdf\x7f\xf8\xf1\xc3\xcf\x1e\x7e\xe9\xf0\xef\x0e\xbf\xf7\x37\x0c\x0f\x1b\xfc\xf8\x9e\x71\x35\x62\xd0\x3d\x18\x1d\x2c\x0e\x2e\x1a\xec\x1b\x5c\x3f\xa8\x0e\xee\x18\xec\x1f\xdc\x37\x58\x1a\x7c\x79\x70\x60\x70\xf0\x10\x0e\xb9\x0f\x45\x0e\x4d\x3e\x54\x3c\xb4\xe8\x50\xdf\xa1\xf5\x87\xd4\x43\x3b\x0e\xf5\x1f\xda\x77\xa8\x74\xe8\xe5\x43\x03\x87\x06\x0f\xe3\xb0\xfb\x70\xf4\x70\xf1\xf0\xa2\xc3\x7d\x87\xd7\x1f\x56\x0f\xef\x38\xdc\x7f\x78\xdf\xe1\xd2\xe1\x97\x0f\x0f\xe8\x35\x0e\xff\x71\x78\xd9\xf0\x92\xe1\xb3\x86\x67\x0e\x4f\xf9\xdd\xdb\xbf\x7d\xf7\xb7\x8f\xb9\x1d\x6e\xbb\xdb\xe6\xb6\xba\x2d\x6e\xc9\x2d\xba\x05\x37\xef\xe6\xdc\xcc\xf5\x37\xd7\xfb\xae\xbf\xba\x0e\xbb\x0e\xb9\x06\x5d\xff\xe5\x7a\xcf\xf5\xae\xeb\xa0\xeb\x1d\xd7\x5f\x5c\xff\xe9\x7a\xdb\xf5\x67\xd7\x9f\x5c\x6f\xb9\xde\x74\xfd\xd1\xf5\x07\xd7\xef\x5d\x03\xae\xdf\xb9\x7e\xeb\x7a\xc3\xf5\x1b\xd7\xeb\xae\x5f\xbb\x5e\x73\xfd\xca\xf5\xaa\xeb\xdf\x5d\x07\x5c\xaf\x38\xbe\x3f\x5e\xf6\xf9\x7f\xf1\xd3\x05\xb2\x6a\xb5\xc4\x2a\xf2\xd5\x98\x04\x26\x29\xfc\xff\xe1\x27\x0a\x36\x89\xb7\x5b\xac\x75\xff\xb7\x2a\x68\xff\x1f\x3c\x3b\x4c\x99\x9a\x76\x03\x6c\x03\xc0\x5e\x06\xb8\x5e\x80\x1b\x04\xf8\xc5\x80\x98\x00\xc4\x01\xc0\xb2\x16\xb0\x6e\x06\xac\x2f\x03\xb6\xc5\x40\x5d\x2b\x50\x77\x00\xb0\x6f\x05\x1c\x2b\x01\xe7\x1e\xc0\x75\x00\x70\x6f\x05\x3c\x00\x3c\xf7\x01\xde\xb5\x80\xdc\x0e\xc8\xaf\x01\x3e\x15\xf0\x0d\x01\xfe\x1d\x40\x20\x0b\x04\xdd\x40\xfd\x4a\xa0\xfe\x05\xa0\x61\x3d\x10\x9a\x0b\x84\x76\x01\x8d\x09\x20\xbc\x12\x68\x6a\x07\x9a\x2d\x40\xf3\x06\xa0\xa5\x15\x88\x6c\x07\x22\x83\x40\xb4\x1f\x88\x4d\x06\xe2\x11\x20\xd1\x0e\x24\x06\x00\x65\x16\x90\x7a\x13\x68\xbd\x0f\x98\xb0\x18\x98\xa8\x2f\xdd\xfb\x81\x76\x37\xd0\xfe\x3e\x70\xd2\x6b\x40\x47\x11\xe8\x78\x0d\x98\xd4\x07\x4c\xda\x0f\x4c\xf6\x01\x93\x1f\x06\xa6\xec\x02\xd2\x3b\x80\xcc\x4a\x20\x9b\x05\xb2\xbb\x80\x5c\x04\xc8\xa9\x40\xee\x29\x20\x1f\x01\xf2\xcb\x80\xfc\x7e\xa0\x30\x17\x28\xec\x01\x3a\xed\x40\x67\x1f\xd0\xf9\x04\x70\x72\x2f\x70\xf2\x13\xc0\xd4\xd5\xc0\xd4\x83\xc0\xb4\x12\x30\x7d\x3d\x30\x63\x3d\xd0\x35\x1d\xe8\x7a\x13\xe8\x5e\x0d\x74\xbf\x06\x14\xe7\x02\xc5\xfd\xc0\x29\x93\x81\x53\x9e\x02\x66\x2e\x01\x66\x7e\x08\x9c\xba\x12\x38\xf5\x3e\x60\x56\x2f\x30\xeb\x4d\xe0\xb4\xa7\x80\xd9\xf7\x01\x73\x26\x03\x73\xde\x00\xe6\x1e\x04\xe6\x6d\x07\xe6\x77\x02\x3d\x8f\x01\xbd\x6f\x02\x0b\x56\x02\x0b\xdb\x81\x85\x2a\xb0\xf0\x00\x70\xfa\x3e\x60\x51\x1f\xb0\x68\x0f\x70\x46\x16\x38\xa3\x1f\x38\xd3\x0e\x9c\xb9\x16\x38\xab\x1d\x38\x6b\x37\xb0\xb8\x0f\xf8\xd4\x64\xe0\x9c\x41\x60\xc9\x1b\xc0\x52\x0b\x70\x5e\x11\x38\x6f\x3b\xb0\x6c\x3a\xb0\xec\x43\xe0\xfc\xdd\xc0\xf2\x56\x60\xf9\x9b\xc0\x05\xfd\x40\xdf\x7a\x60\x45\x3b\xb0\xe2\x7d\x60\x25\x0f\xac\x3c\x08\xac\x5a\x04\xac\x7a\x19\xb8\xe8\x87\xc0\xc5\x7d\xc0\xc5\x7b\x80\x4b\x7a\x81\x4b\x4a\xc0\xa5\xb3\x80\x35\x76\x60\xcd\x01\x60\xad\x0a\xac\x2b\x02\x97\xb5\x03\x97\xf7\x02\xeb\xb7\x02\x57\x3c\x0c\x5c\xf9\x06\x70\xd5\x66\x60\x83\x1b\xd8\xb0\x07\xd8\x38\x0b\xf8\x4c\x1f\x70\x2d\x80\x6b\xf7\x03\xd7\xb9\x81\xeb\x1e\x06\xae\xdf\x06\xdc\xb0\x0b\x50\xf7\x03\x37\xd6\x03\x37\x6e\x07\x6e\x9a\x0b\x6c\xf5\x01\x5b\x0f\x00\x9f\xdb\x03\x7c\xee\x4d\xe0\xe6\xb5\xc0\xe7\x8b\xc0\xb6\xdd\xc0\x2d\x25\xe0\x36\x37\xb0\xfd\x79\xe0\x0b\xdb\x81\xdb\xd7\x02\x77\xcc\x05\x76\x44\x80\x1d\x25\xe0\xce\xc5\xc0\x4e\x3b\xb0\x73\x2e\xb0\x73\x2b\xb0\xb3\x04\xec\x1c\x02\xee\xea\x03\xee\x7a\x1e\xd8\xc5\x03\xbb\x8a\xc0\xae\x41\xe0\x6e\x15\xb8\x27\x01\x7c\x71\x19\xb0\x7b\x09\xf0\xa5\x30\x70\xef\x2c\xe0\xde\xa7\x80\x2f\xef\x06\xee\xeb\x07\xbe\xb2\x18\xb8\x7f\x09\x70\xff\x87\xc0\x57\xef\x03\xfa\x67\x01\x0f\x2c\x02\x1e\x6c\x07\x1e\x7c\x18\x78\xa8\x13\x78\x68\x0f\xf0\xf0\x4a\xe0\x91\x65\xc0\x9e\x1d\xc0\x3f\x5b\x80\xc7\xc2\xc0\x63\x07\x81\xaf\xef\x00\xbe\xfe\x36\xf0\xb8\x0a\x7c\xa3\x1e\xf8\xc6\x3e\x60\xdf\x5c\x60\xdf\x00\xf0\x2f\x9b\x81\x7f\x79\x01\xf8\x66\x04\xf8\xe6\x06\xe0\x9b\xcf\x03\xdf\x5a\x02\x7c\xeb\x7d\xe0\x89\xf5\xc0\x93\x00\x9e\x5c\x09\x7c\x3b\x0c\x7c\xfb\x00\xf0\xaf\x4f\x00\xff\x3a\x08\x3c\xb5\x19\x78\x7a\x03\xf0\xf4\x87\xc0\x77\x5e\x18\x7d\xbe\xbb\x07\xd8\xbf\x15\x78\xa6\x08\x3c\xcb\x03\xff\xf6\x3c\x50\xfa\x21\xf0\x7d\x3b\xf0\xfd\xed\xc0\x0f\x96\x01\x3f\x8c\x00\x3f\xdc\x0f\xfc\xc8\x0d\xfc\xe8\x29\xe0\xb9\x5d\xc0\xf3\x93\x81\xe7\x07\x80\x9f\xac\x04\x7e\xf2\x02\xf0\xd3\x3d\xc0\xcf\x54\xe0\x67\x03\xc0\x0b\xef\x03\x2f\xee\x02\x5e\xda\x0c\xbc\xf4\x36\xf0\xf3\x7d\xc0\xcb\xdb\x81\x5f\xb4\x03\xbf\xd8\x06\xfc\xd2\x02\xfc\x72\x1b\xf0\x8a\x1d\x78\x65\x3b\xf0\xca\x41\xe0\x40\x27\xf0\xef\xed\xc0\xbf\xdf\x07\xbc\xda\x07\xbc\xfa\x36\xf0\xab\xb5\xc0\x6b\x73\x81\xd7\x9e\x00\x7e\xdd\x07\xfc\xfa\x87\xc0\xeb\x8b\x81\xd7\x9f\x02\x7e\x53\x0f\xfc\x66\x17\xf0\x46\x11\x78\xe3\x79\xe0\xb7\x6b\x81\xdf\x0e\x02\xbf\xdb\x0a\xfc\x47\x3d\xf0\x1f\x8f\x01\x03\xfb\x81\xdf\xaf\x05\xfe\xb0\x1e\xf8\x63\x04\xf8\xe3\x9b\xc0\x9b\x2a\xf0\xd6\xf3\xc0\x9f\x4a\xc0\x9f\xeb\x81\x3f\x1f\x04\xde\x7e\x13\xf8\xcf\xd7\x80\xbf\xbc\x06\xbc\xf3\x1a\x70\xf0\x00\xf0\xee\xcb\xc0\x7b\x6f\x00\xff\xf5\x26\x70\x98\x07\xfe\xfa\x3e\xf0\xbe\x0a\xfc\x2d\x0b\x7c\xe0\x06\x3e\xb8\x0f\xf8\xef\x7a\xe0\xc3\x25\xc0\x87\x25\xe0\xa3\x04\x70\x64\x2d\x70\x74\x3f\x30\xd4\x0a\x0c\x3d\x05\x94\xed\x40\xb9\x0f\x28\x3f\x01\x68\x16\x40\x7b\x0a\x18\xb6\x80\xe0\x03\x09\x4f\x80\xc4\xf7\x41\xd2\x87\x20\xcb\xcb\x20\xeb\x4a\x90\xcd\x0d\xb2\xed\x06\xd5\xd5\x83\xec\x3c\xc8\xfe\x30\xc8\xd1\x0e\x72\x02\xe4\xda\x06\xf2\xb4\x83\x3c\xfd\x20\xef\x0b\x20\xb9\x13\x24\xbf\x09\xf2\xed\x00\xf9\x5b\x41\xfe\x87\x41\x81\x25\xa0\xc0\x10\x28\x58\x02\xd5\x6f\x05\x35\x6c\x06\x85\xae\x05\x35\x2e\x06\x85\x0f\x80\x9a\x8a\xa0\xa6\x03\xa0\xe6\x1d\xa0\x16\x1e\xd4\x72\x2d\x28\xf2\x30\x28\x5a\x02\xc5\x36\x83\xe2\x16\x50\x7c\x2d\x28\xc1\x83\x12\x2f\x80\x52\xab\x41\xad\x6f\x83\x26\xf6\x82\xda\x17\x83\x3a\x7a\x41\x53\x36\x80\xa6\xbc\x0f\x4a\x0f\x80\x32\x93\x41\x99\x7d\xa0\xec\x1e\x50\x6e\x03\x28\xbf\x18\x54\x48\x80\x3a\xed\xa0\x93\xe7\x82\xa6\xba\x41\x53\x07\x41\xd3\x76\x80\xa6\x6f\x05\x4d\x7f\x0d\xd4\xbd\x04\x54\x0c\x83\x4e\x29\x81\x66\x3e\x0f\x3a\xf5\x79\xd0\xac\xfb\x40\xa7\xcd\x05\xcd\x9e\x0b\x9a\xb3\x1e\x34\x77\x2e\x68\xde\x66\xd0\xfc\x08\x68\xfe\x9b\xa0\x9e\x03\xa0\xde\x7e\xd0\x82\x7a\xd0\xc2\x22\x68\x51\x11\x74\x46\x3f\xe8\xcc\x01\xd0\x59\xb3\x40\x8b\x23\xa0\x4f\xf5\x82\xce\xee\x03\x9d\x7d\x00\x74\xce\x12\xd0\x92\x2c\x68\x49\x3f\x68\x29\x0f\x5a\xba\x0d\x74\xde\x4a\xd0\x79\x03\xa0\x65\xd7\x82\xce\x7f\x0d\xb4\xbc\x1f\xd4\xb7\x0b\x74\xe1\x5c\xd0\x85\xfb\x41\x2b\x06\x41\x9f\x5e\x02\x5a\xf9\x18\x68\xd5\x06\xd0\x45\xab\x41\x17\xbf\x01\x5a\xfd\x04\xe8\x92\x65\xa0\x4b\x37\x83\x2e\xdb\x0a\x5a\x5f\x04\x5d\x35\x00\xba\xda\x0d\xda\xf4\x3c\x68\xf3\x0e\xd0\x35\xdb\x40\x5b\xb6\x83\x3e\xb3\x1a\x74\xed\x76\xd0\x75\x61\xd0\x75\x0f\x83\x6e\x58\x06\xba\x61\x37\xe8\x86\x0f\x41\xea\x5a\xd0\x8d\x1b\x40\x9f\xdd\x01\xba\x29\x0b\xba\xe9\x61\xd0\xd6\xe7\x41\x9f\xdb\x07\xba\xf9\x61\xd0\xb6\x0d\xa0\x5b\xb6\x83\x6e\xed\x04\xdd\xa6\x3f\xfd\xa0\xdb\x7b\x41\xb7\xef\x01\xdd\xb1\x18\xb4\xc3\x0d\xba\xd3\x07\xba\x6b\x07\x68\x97\x0f\x74\x37\x0f\xba\x7b\x08\x74\xcf\x87\xa0\x2f\xf6\x83\xbe\x74\x2d\xe8\xde\xe7\x41\xf7\xb9\x41\x5f\xb1\x80\xbe\xf2\x1a\xe8\xfe\x6b\x41\x5f\xad\x07\x7d\xf5\x6d\x50\xff\x0f\x41\x0f\xda\x41\x0f\x65\x41\x0f\x6f\x06\x3d\xb2\x0f\xf4\xa8\x0a\xfa\x5a\x2f\x68\x4f\x18\xb4\x67\x07\x68\xcf\xc1\xd1\x67\xef\x12\xd0\x3f\xb5\x82\xfe\x39\x02\xfa\xe7\x17\x40\x8f\x3d\x06\xfa\xfa\x1e\xd0\xe3\x11\xd0\xe3\xdb\x40\xdf\xe0\x41\xdf\xd8\x03\xda\x57\x04\xed\xdb\x06\xfa\xf6\x7e\xd0\xbf\xae\x05\x3d\x35\x00\x7a\x7a\x03\xe8\x3b\x3c\xe8\x3b\xbb\x40\xdf\x4d\x80\xbe\xfb\x30\x68\xbf\x05\xb4\x7f\x33\xe8\x99\x5e\xd0\xb3\xfa\xf3\x30\xe8\xdf\x22\xa0\xd2\x5c\xd0\xf7\xea\x41\xdf\xfb\x21\xe8\x07\x3c\xe8\x07\x6f\x82\x7e\xd8\x0f\xfa\xd1\x62\xd0\x73\xad\xa0\xe7\x0e\x82\x9e\xb7\x83\x7e\x62\x07\xfd\x74\x1b\xe8\x67\xfd\xa0\x17\x3e\x04\xbd\x14\x06\xfd\x7c\x17\xe8\xe5\xb5\xa0\x5f\xac\x04\xfd\xf2\x0d\xd0\x2b\x8b\x40\xaf\x7c\x08\xfa\xf7\xad\xa0\x57\x37\x83\x7e\xb5\x1e\xf4\xab\x21\xd0\x6b\xef\x83\x5e\x7f\x0c\xf4\x9b\xc5\xa0\x37\x16\x83\x7e\x6b\x07\xfd\x76\x10\xf4\xbb\x6d\xa0\xff\xe8\x05\xfd\x5e\x05\xfd\xe1\x43\xd0\x9b\xf5\xa0\xb7\xec\xa0\x3f\x4d\x07\xfd\x79\x2e\xe8\xcf\x7b\x40\x6f\x27\x40\x6f\x1f\x00\xfd\xe7\x5a\xd0\x5f\xc2\xa0\xbf\x1c\x00\xbd\xf3\x26\xe8\x60\x16\x74\xf0\x29\xd0\xc1\xf7\x41\xef\x0e\x82\xfe\xcb\x02\xfa\xaf\x87\x41\x83\x3c\x68\xf0\x05\xd0\xa1\x08\xe8\xf0\x22\xd0\x5f\xd7\x82\xfe\xfa\x36\xe8\x6f\x76\xd0\x07\xed\xa0\x0f\x4a\xa0\xff\xde\x0c\xfa\xef\x01\xd0\x87\xeb\x41\x1f\xb5\x83\x8e\x6c\x06\x1d\xdd\x00\x1a\xb2\x83\x86\x56\x82\xca\x76\x50\x79\x3b\x48\xcb\x82\xf4\xf9\x62\xf8\x65\x30\xca\x82\xb1\x30\x18\xd7\x0e\xc6\xaf\x06\x13\x0e\x80\x49\x8b\xc0\xac\x59\x30\xdb\x01\x30\xfb\x00\x98\x63\x10\xcc\x55\x0f\xe6\xce\x82\x79\xde\x04\x93\xa7\x83\xf9\xda\xc1\xfc\xed\x60\x81\x2c\x58\x70\x32\x58\x7d\x27\x58\x43\x02\x2c\xb4\x0d\xac\xb1\x13\xac\xe9\x09\xb0\xe6\xc5\x60\xcd\x2f\x80\x45\xae\x05\x8b\xae\x06\x8b\x3d\x06\x96\xe8\x05\x4b\x4e\x06\x53\xe6\x82\xa5\xb6\x81\xb5\xbe\x0f\x36\x61\x3b\xd8\xc4\xc9\x60\x13\xdf\x00\x6b\xdb\x05\xd6\xfe\x06\x58\x47\x02\xac\xe3\x20\xd8\xe4\x83\x60\x53\xb6\x82\xa5\x8b\x60\xe9\x21\xb0\xcc\x53\x60\xd9\x0d\x60\xb9\x04\x58\xfe\x7d\xb0\x93\x23\x60\x53\xb7\x83\x4d\x3d\x00\x36\xcd\x0e\x36\x6d\x1b\xd8\xf4\x56\xb0\xe9\xaf\x81\xcd\xc8\x82\x75\x3f\x05\x56\xdc\x0d\x76\xca\x00\xd8\xa9\xfd\x60\xb3\x86\xc0\x66\xef\x06\x9b\xdb\x07\x36\xf7\x7d\xb0\x79\x2f\x80\xf5\xee\xff\xdf\x3d\x58\x0f\x70\x6e\x51\x67\xfe\x25\xa0\x10\xf5\x44\x39\x4f\xd4\x33\x40\x25\xad\xb8\x9e\xf5\xaf\x17\x22\x47\xd6\x8b\x38\x62\x70\xcd\x84\xf3\x87\x21\x3e\x24\xa8\x68\xd2\x79\x61\x89\x3c\xd1\x74\xc0\x27\xc6\xa3\x31\x25\x9b\xcf\x44\x3d\xa4\xe4\xb2\x5d\x94\x89\xa6\x9b\x49\x7c\xa8\xad\xbc\x8d\x8a\x21\x45\x09\x0d\xa9\xfa\x9b\x8a\xe5\x6d\x6d\x89\xd6\xa0\xa0\x06\x5b\x13\xc2\xec\x78\x5b\x79\x5b\x19\x4a\x56\x51\xb2\x0a\x07\xb6\xb9\x2d\x1e\x6c\xb4\x58\x1a\x0d\x29\x64\x18\xa2\x2e\xb7\xb7\x01\xe4\xf1\x39\x59\xac\x83\x65\xbb\x58\x26\x1d\xf4\x08\x63\xbd\xd9\x7c\x81\xf2\x99\x74\x40\xc4\xac\xd5\x17\x2f\xbd\x78\xf5\xac\x59\xab\x2f\x3e\xe9\x92\x73\xca\x63\xbd\x4a\x33\x57\xb4\xbb\x5b\x3b\x85\xc8\xd1\xfe\xf4\xc2\x36\xbf\xbf\x6d\xe1\xca\x85\x6d\xfe\x14\x6b\x78\xb7\x3c\xad\x36\x80\xfb\x71\x4b\xc6\x46\xe0\x3b\x75\xc9\x68\x18\xa2\x2a\xa8\x90\x10\x05\xe0\x46\x44\x7f\xc8\x27\xc6\x63\x29\x12\xe3\xb1\x84\xc2\xdc\xde\x7c\x22\xc2\x07\xbc\x7e\x9f\x44\x01\x5e\xd5\x3e\xd2\x6e\xd7\x3e\x22\x89\xae\xe4\xa4\xde\x6c\x3e\xa1\xed\xfd\xd6\x1b\x77\x68\x47\x9f\xb9\xfc\xf2\x67\x48\xa0\x66\x12\x9e\xb9\xfc\x5a\x3a\x27\xc9\x24\xba\x92\x24\x33\xb1\xa6\x66\x7b\x15\x3a\xfb\xda\xd1\x14\x97\x3f\xa3\x1d\xbd\xe3\x8d\x6f\x69\x7b\x93\x86\x28\x36\xac\x4a\x10\x80\x10\x66\x60\x01\x90\xf4\x88\x12\x2f\x39\x59\x1b\x8b\x75\x50\x4a\x49\x2a\x29\x8f\x2f\x90\x89\xa6\xf3\x9e\xe9\xac\x83\x8b\x47\x63\xa2\xdf\x17\x0c\x04\x9b\xf9\x69\x2c\xdd\xc5\x15\xf2\x85\x2e\x2a\x78\xcc\xce\xc9\x79\xf4\xee\x49\x07\x44\x35\x92\xd4\xde\xbf\x3f\x53\x5c\x37\x99\x68\xf2\xba\x62\xe6\x7e\xed\xfd\x64\x44\x76\x08\x25\x87\x4c\x82\x68\xb7\x1c\x29\x3a\xe4\xbb\xbe\xf7\xb2\x38\x35\x56\xe8\xf0\x11\xf9\x3a\x0a\xb1\xa9\xe2\xcb\xdf\xcb\x9f\xaf\x2e\x9f\x79\xa4\x38\x73\xf9\xf2\x99\x42\x69\xe6\xf2\x08\x87\x44\xf3\x4b\x5b\xdb\x26\x4f\x99\x32\xb9\x6d\xeb\x4b\xcd\x89\x32\x1c\xb2\xcc\xb7\x32\xaf\xd5\x63\xb1\x09\xb2\x63\xcf\x86\xdd\x8f\x08\x53\x42\x49\xaf\x37\x19\x9a\x22\x3c\xb2\xbb\xed\xce\xbe\xa3\x25\x3d\x37\xaf\x97\x61\xf6\xb1\xde\x36\x15\x61\x80\x8f\xa5\xa8\x83\xcf\x65\xf3\x99\x74\x33\x0b\x76\x71\x99\x74\x40\xc7\x29\x77\x6f\xd6\x5b\xde\x61\x8b\xf7\x4e\x9f\xa4\x0d\x74\xdd\x78\xf9\xa2\x44\x62\xd1\xe5\x37\x76\x0d\x68\x6f\x95\xef\x54\xbd\x6c\xa9\x25\x71\xc1\xca\xdb\x4f\x7d\xe3\xc3\xb6\x79\xc5\x44\xa2\x38\xaf\xed\xc3\x37\x7e\xfb\x56\x79\x8f\x59\xf6\xd7\x45\x55\x18\x40\xcc\xa4\x51\x39\xe0\x37\xfa\x2d\x29\x88\xf1\x98\x92\xcb\x16\x64\x9d\x4c\x0b\x49\x39\x9f\x0e\xca\x42\x40\x54\x43\xda\xdd\x67\x93\xdf\x27\xfb\xb5\x6e\xad\x3b\xe0\xf5\xfb\xd9\xd9\xda\xae\x86\x4e\xfa\xe0\xf7\xf2\x74\xf9\xf7\xf4\x41\x27\x77\x4d\x20\xa4\xdd\xaf\xd9\x25\x87\xbf\xc9\x7e\xf0\xa0\xbd\xc9\x2f\x3a\xe9\x7d\x5a\xd1\xe8\x4f\x5a\xe7\xd1\x8f\x27\x4c\xd0\x4e\x9e\x67\x85\x29\x51\x57\xea\xb6\xea\xd4\x6b\xa5\x64\x1d\x09\xc4\x25\x85\x2a\x1c\x27\x06\x83\xbf\x82\xd2\xda\xd2\x67\x9e\xd1\x96\x52\x7a\x1e\x6d\xa1\x6b\xe8\xc7\x06\x5c\x13\x4e\x0c\x16\xf3\xd1\x84\x2e\xba\x5e\xfb\x6c\x97\xf6\x2b\xed\xbc\x1f\xff\x98\xb3\x55\xc1\x4c\x7f\x0c\x94\x3a\x8c\xaa\xa0\xe3\xde\xaf\x8f\xe2\x64\x85\x42\xb2\x5d\x5c\x26\x10\x29\xa4\x9b\x39\xb8\xc5\x88\xe2\xce\x47\x04\x5c\xb7\x64\xe8\x9f\x96\x5c\xe7\xe9\x98\xb3\xb1\xf7\x26\x5a\x7b\x53\xef\xc6\x39\x1d\x9e\x61\xfc\x5e\xfb\xfe\xef\x7f\x4f\x5d\xb7\xac\xbb\xef\xbe\x75\x9f\xfa\xe2\x97\xd6\x9d\xa6\xaa\xa7\xad\xfb\xd2\x17\xb9\xef\x99\xe1\xbf\x07\x50\xa7\x8f\x1f\x49\x1f\x3f\x2e\xb4\x60\x12\xba\x71\x3a\x2e\xc0\xe5\xb8\x01\x77\xe0\xab\xf8\x06\x20\xe4\xb2\x4a\x1b\xc5\xc4\x26\xf2\x05\xa6\x51\x3a\xef\xf9\x04\x3f\x79\xb2\x8a\x41\xe1\x15\x92\xa7\xf1\xf1\xff\x60\xfa\x4f\xaa\x6f\xfc\xc0\x21\x55\x09\x19\xb3\xd8\x09\x5e\x3c\x94\x50\x19\xba\x87\x43\x48\x19\xc2\x68\x8c\x50\x93\x53\x53\x6b\x53\x7d\x52\x99\xea\xf2\x99\x1f\x19\x83\x46\x2c\xce\x5c\x5e\x1c\x89\xa2\x7b\x8f\xe7\x2c\x87\x98\x51\xb0\xa6\xbf\xf9\xd1\xf0\xa3\xa3\x4e\xae\x36\x89\x76\xdc\x52\x6a\x9c\xdf\x39\x62\xd4\x2d\x18\x03\x96\x37\x74\x32\xb5\xfd\xa9\xcf\xcc\x63\x30\xd4\x40\xe3\x30\xf6\x09\xf1\x1c\x7a\xb3\x1a\xb2\xbd\xbd\x59\x66\xbc\x47\xdd\x9c\x7a\xa2\x18\x06\x7d\xca\xec\xcd\x92\xfe\x66\x2f\xd4\x78\x86\x5e\x38\x51\x8c\xa1\xc0\x85\x31\xd7\x1c\x4b\x8b\x20\xbf\x09\xd5\x0c\x32\xa1\xf2\x8c\xf3\x8f\x8f\xff\x3f\xed\x1f\x5f\x1f\x43\x67\xab\x56\x6a\xed\xec\x6c\xa5\xa2\xfe\x1e\x75\x33\xb5\xd6\x57\x56\x4f\x1c\xf7\xf7\xa7\xac\x75\x53\xc4\x70\xea\x2f\x7a\x6d\xc4\x59\x1e\x75\x72\xc7\x0d\xfd\xc4\x04\x35\x85\x99\x0a\xeb\x63\xfb\xe2\xff\x78\x2f\xfc\xfd\x58\x15\xd0\xd9\x3a\x64\x84\x71\xa5\xd6\xce\xa3\x38\x71\x5c\xad\xfb\x7f\x88\xab\x31\xa8\x00\xe1\x1a\x38\xc5\xcf\xf3\xdf\x44\x00\x80\x4f\x22\x49\x8c\x4d\x22\x52\xb2\xdd\x94\x4f\x07\xad\x94\x4f\xb7\x90\xf8\xf9\x70\xb9\x7d\x5b\x78\x51\x78\x9b\x76\x4f\x38\xac\x3b\x48\x61\x3b\x74\x3f\x77\x78\x91\x11\x15\xde\x46\x97\xea\xfe\x70\x58\xfb\x35\xbb\x33\x1c\xde\x06\xc2\x65\xc3\xef\x09\x5e\x7e\x27\xe2\x40\xc2\xe7\x22\x31\x96\xb2\x92\x5e\xb6\x92\x2d\x58\xc7\x96\x1f\xf0\x49\x56\x12\xbc\x46\xc9\xda\xeb\xda\xeb\x66\x49\xa4\x68\xaf\x57\x6b\x23\xa5\x52\xfa\xeb\xa4\x68\x1f\x1b\x1b\x1e\x29\xc5\xe4\x5d\xcc\xf9\x22\x8e\x36\xcc\x32\x7b\xb8\xcd\x7c\xe9\xdd\x12\x37\xfb\x66\x1a\xe5\xf4\x57\x3a\xd0\x44\x99\x74\x33\x55\xb8\x2c\x9c\x88\xcb\xe2\x21\x3b\x06\x64\x47\xd1\x21\x0f\x38\xe4\x1a\xe7\x18\xde\xab\x27\x77\x22\xde\x8b\x0d\x1c\x93\x53\x77\xfe\xa9\x86\x21\x7b\xf2\xd2\x9e\x13\x30\x64\xb5\x6d\x72\x21\x88\xc9\xc7\x50\xed\xdf\x07\x7f\xb9\xa4\xd7\xca\x8a\xff\x18\xd4\x06\xbc\x7f\x37\xa4\x95\x35\x5e\xd4\x87\xdb\x04\xe4\x74\x2e\x88\x89\x7c\x24\xa1\xb0\x5c\xd6\x5b\xc8\x07\x82\x01\x51\x72\x92\xdf\xd7\xcc\xd2\x5d\x2c\x97\x55\x52\x1d\x54\xe8\xa2\x60\xc0\xab\xcf\xd9\xe6\x0c\xad\xf3\xd4\x5b\x5e\xd2\xde\xd4\x9e\xd7\xde\x7c\x69\xcb\x03\x3b\xdb\x2e\x69\x89\xb8\x26\xae\x58\x73\xc6\xad\xcf\xbc\xfc\xcc\xad\x67\xac\x59\x31\xd1\x15\x69\xb9\x74\xe2\xce\x07\xca\x6a\xef\xea\xde\xde\xd5\xbd\x4c\xbd\x4f\x4f\xb9\xe5\x25\x0a\xdf\xf7\x6d\x9a\xb9\x2e\xe2\x6c\x9b\x78\x49\x64\xfe\xab\xd7\xac\x7e\xe6\xd6\x33\xce\xb8\xf5\x99\xd5\xd7\xbc\x3a\x3f\x72\xc9\xc4\x36\x67\x64\x9d\xf6\x2c\x9b\x5f\x36\x26\x68\x66\x4c\xd0\xe6\x06\x59\x85\x1f\x1c\x9d\x17\x90\x1c\x21\x17\x93\x48\x92\x1e\xd3\xaf\xc3\x77\x3c\x3f\x7d\x92\x1f\x5e\x67\xc9\xe9\x35\x5e\xa4\xfe\x63\xee\xbe\xaa\xc3\x7b\xa5\x66\x38\xa9\xe8\xf4\x7a\x0f\x97\x0d\x37\xd3\xdd\x74\xe5\x90\xfe\x71\x72\x7a\x10\x1d\x3e\x62\x78\x04\xdd\x33\xda\x1f\x86\x3c\x71\x19\x80\xac\x12\x13\x7d\x81\xb4\x4e\x41\x2e\x12\xa5\x40\x30\xe0\x93\x9c\x14\x8f\x4d\x22\x51\x12\x25\x03\xea\x49\xa4\xa4\x24\x9d\x90\x94\x94\xce\x26\x76\x51\x41\x99\x44\x1d\xa4\x23\xa3\x9b\xf2\x85\x6a\x68\x26\xdd\x42\xf9\x42\xbe\x60\xb4\xb0\x85\x02\xc1\x42\x3e\x93\x0e\x06\x82\x3a\x0b\xed\x24\x29\xd0\x42\xcd\xc4\xe3\x9e\x03\xf7\xdc\x73\x80\xdd\xe3\xb6\x3f\x2d\xfb\xe2\x73\x6d\xd6\xc6\x1d\x01\xbb\xf3\xd6\xf6\x49\x6e\x87\xd4\xf4\x3b\xa7\x9f\xc2\x53\x26\x7c\xc1\xe6\x72\xd6\x5d\x9f\x92\x2c\xae\xb9\xde\x46\xe7\xbf\x3a\xdc\xee\xba\xef\x38\x1b\x5a\x4f\xb5\x59\x43\x77\x06\x1c\x8e\xb1\x89\x6f\xb7\xba\x1c\xf6\x1b\x13\x46\xe2\x90\xeb\x5f\x1d\x6e\x16\xd0\x6b\xb8\x87\xd6\xfd\xce\x1e\x60\xe1\x7c\x32\xbd\xc4\x1e\xb2\x25\x6f\xb7\xae\x0d\xba\xb6\xa5\xc3\x1e\xc7\x53\x6e\xff\x1a\x6b\xdd\x95\x79\x9b\xc3\x5e\xe7\x3f\xaf\x21\x3d\xa5\x91\xf9\x1d\x46\xda\x8e\x8e\x93\xcf\xb0\xdb\x6d\x8e\xc4\x1d\xb6\x35\xb5\x89\x6d\x9b\x32\x16\xa7\x99\x78\x72\x98\xf9\x8d\xb5\x63\x58\x15\x46\x79\x90\x69\x38\x15\x17\x9b\x7c\x48\x6d\x2f\x0b\x9f\xe0\x97\x3d\x51\x8f\xaf\x59\x97\x51\xbb\x88\xa2\x29\x25\x15\x15\x25\xc1\xa0\xb4\x11\x86\x25\x5e\x1d\xd3\x05\x43\x96\x0d\xb4\x90\xb1\x86\x78\x9d\x46\x9f\x16\x9d\x5e\x3a\x81\x5b\x1d\x52\x9d\x2e\x8e\x2b\x72\x2e\x67\xb9\x8f\x4a\x93\x25\x9b\xf6\x03\x9b\xc4\x5d\xee\x75\xf6\x2d\x9f\x39\x54\x9a\xb9\xbc\xcf\x20\x9d\xdc\x6c\xd7\x42\x7d\x85\x59\xe8\x9a\x4d\x39\xa7\x97\x8b\xd4\x90\x91\xf3\x04\xee\x72\x33\xf7\xc4\x50\x6f\x20\xe9\xf1\x24\xf9\xf9\x1b\xad\x8c\x59\xef\x2e\x3a\xbd\x43\xbd\x67\x5d\xb3\xf1\x2c\xee\x29\xa3\xf6\xaf\x25\xb3\xd9\xe4\xd7\xbc\xe6\xf8\x0f\x01\xe2\x45\x02\x07\xd9\x18\xff\x46\xd3\x3c\x51\x4f\x85\xff\xca\x59\x29\x50\x90\x44\x29\x6e\xac\x0c\x29\x9d\xd6\x74\x49\x3a\xdd\x52\x9d\x8f\xfd\x9e\x60\x33\xe9\x9c\xab\xa6\x0e\x43\x53\x43\x0a\xb1\x6e\xd6\x4d\xff\xd1\x65\x71\x70\x0e\x4b\xb9\xb7\xdc\x6b\xb7\x3b\x2c\x5d\x16\x66\x63\x3f\x8f\x2c\x89\xbc\x6f\x0c\x8d\xdf\xd8\x18\x8b\x68\x11\x9d\xb1\xd5\x19\x5d\x1a\x20\x9e\xe8\x75\x4d\x61\xa7\xcc\xb7\x32\x89\x9d\x52\xfe\x37\x0b\x31\xeb\x7c\x5b\xa3\x85\x9d\x13\x0a\xbd\xf0\x03\xbd\x6d\xda\xea\x6f\xeb\x32\xbf\x39\xb7\xea\x5d\x2c\x23\xa4\xaf\x5b\xd4\x4c\xfe\x71\x0c\x64\x50\xf2\x44\x95\x14\x29\x64\xb6\x22\xea\x11\xf6\x87\x5b\x3b\x5b\x8f\x18\x6b\x2a\xa7\xb6\xf6\x85\xb7\xd2\x66\x9b\x5d\xfb\xb1\x9d\x3e\xad\xf5\xb5\x76\x96\xc1\x6f\x0d\xf7\xb5\x1e\x55\xf5\x78\xb1\xd8\xda\xd9\x1a\x9e\xa5\x6d\x6b\xb2\xd3\xc9\xf6\x23\x5e\x1e\x9d\xad\xd4\x6f\x28\x35\xb8\x91\xb1\xe9\x43\x04\xed\xa3\x9c\xad\x39\xef\x54\xc8\x06\xee\x0e\x8a\x38\xc9\xdd\x4c\x91\x3c\xdc\x8c\x8f\x24\x98\xdb\x9b\x88\xf0\x9c\xea\x75\x9a\x33\xc2\x80\x49\x0e\xfd\x3b\x8f\x68\xaf\x1d\xd9\xb9\xf3\x08\xb5\x1e\xa1\x2b\x5f\xd2\xbe\xaa\x2d\xd7\xbe\xfa\xd2\x4b\x74\x21\x3d\x48\x17\x72\x03\xda\x08\xdd\xe8\xb4\x50\xd6\xa8\x55\x4f\x6b\xe4\x60\x17\xd4\x26\x7d\xe9\x25\xa3\x1f\xd3\x80\xb4\x50\x00\x3c\x38\x15\xa0\x1c\xd7\x41\xba\x98\x22\x71\x7e\xd1\x94\x73\x7c\xf1\x68\x3a\x9f\xe2\x3a\x48\x97\x76\x24\x4e\x0c\x64\xa2\xb1\x5c\xb6\x40\x3a\xe5\xc6\xf4\xc9\xc5\x48\xa6\xcf\x1c\x71\x1d\x87\x14\xe0\xcf\xa9\x27\x9f\xe3\x3b\x0e\x1f\xd5\x93\xd7\xfe\xbe\xdd\xcb\x3e\xe8\x28\x17\x1d\x5e\xf2\x91\xcf\xa1\x0d\x3a\x7c\xe4\x23\xaf\xa3\x5c\xec\x08\xd1\x03\x96\x84\x8f\xce\x72\xf8\xc8\x45\x5e\xc7\xa3\x0e\x2f\xb9\xc8\xe7\xa0\xb3\x7c\x09\x0b\x3d\x10\x62\x61\x9e\x8c\x95\x49\x2b\xf1\x76\xb7\x5b\x3b\x79\x9e\xec\x20\xe8\x01\xc3\x70\xc8\xf3\xf2\x5d\xbc\x4f\x0e\xcb\x0e\x73\xde\x74\xc8\x61\xf9\xe8\xc1\xae\xaa\x1c\x21\xea\x4c\xa0\x0b\x49\xcc\x00\x12\x95\xb9\xb0\xfa\x95\xc7\x74\x7b\x30\x90\xee\xd6\x47\x1f\x05\x24\x9d\x8f\x21\xa5\x90\xcf\x44\x2b\x04\xe1\xf7\x44\xd3\x82\xa9\x41\x22\xc5\xf8\x3c\xda\xd9\x7a\xc4\x60\xd2\xe8\x17\x9f\x9f\x7a\xdf\xd4\x6d\xf4\x72\x6b\xa7\xf6\x5d\x4f\x8b\x56\xf4\xe6\xbd\x5a\xb1\xc5\xe3\x99\x48\x50\x42\xa4\x0b\x5f\x98\xf8\x68\xd6\xcc\xa5\xff\x51\x64\x94\xef\xdb\xd6\xd9\xb9\xad\x93\x79\x26\x34\x69\x45\x59\xa6\x52\xd3\x84\x14\x95\x0c\xb9\xa9\x58\x43\x2b\xf5\x48\x18\x3c\x80\x6f\x04\xae\x11\x52\xf1\x7b\x32\xe9\x00\xab\x10\x4b\x17\xb9\x15\xbe\x86\x5e\xf8\x3e\x9b\xf6\xbd\xba\xfa\x3a\xad\xe4\xb2\x58\x02\x25\x63\xe0\x94\x9c\xde\x17\x46\x68\x66\xe7\xce\x63\xa8\x86\xf5\xd9\xed\xda\xf7\xac\x56\x2a\xba\x65\x9f\x41\x37\x4e\xad\xdf\xcb\xd2\x35\x94\xf6\xcc\x31\xa4\x73\x1c\x58\xcd\x39\xce\x9c\x0c\x4d\x15\x84\xce\x09\xd2\x89\x61\x5d\x5e\x03\xa1\x8d\xba\xeb\xea\xeb\xa8\xe8\xfa\xe5\xc7\x82\xba\xcb\xa7\xf5\x1b\x93\x5c\x9f\xd7\x69\xb7\x53\xb7\xd5\xaa\x95\xdc\xf4\xd1\xc7\x80\x6a\x58\x21\x88\x3a\x0b\xe0\x30\x46\x7e\xb4\x83\x52\x5c\x94\x73\x92\x14\x0d\x46\x93\xa3\xd4\x50\x90\xcd\xd9\x38\x28\x07\xb8\x61\x9a\x4e\x1c\x1d\x28\x4f\x3f\x40\x1c\xd1\xf4\x0b\xa8\xc8\xfa\x94\xd0\x11\x35\xa4\x34\xbc\x67\xcb\x85\xb8\x62\x28\x67\x7b\xaf\x81\x15\xb9\x3a\x46\x83\x9a\x9b\xab\x63\xa5\x07\xb5\x66\x43\x0b\xf9\x87\xae\x19\xac\xb5\x21\x16\x6b\x28\xbf\x36\xa3\x06\x47\x2e\x34\x1a\x56\xe7\x7a\x7f\xea\x8b\xae\x5e\x61\x3e\x48\x81\x13\x0c\x7b\xbe\x3f\x52\x1e\x70\x79\xdc\xee\x48\x24\xda\xc2\x22\x1f\x3b\xe8\xd9\x23\xf3\xbd\x5a\xc9\x6a\x91\x93\x4c\x4d\xca\x5e\x59\x2b\xfd\xec\xe3\x46\x3d\x8d\xc0\x94\x19\x99\x8b\x52\x4a\x37\x29\xf1\x98\x93\xf9\x9a\x59\x26\xad\xaf\xf7\x69\x7d\x61\x97\x44\x7e\x84\xc9\xcc\xa4\xf9\x60\x21\x1f\x0c\x88\xd0\x29\x75\xa2\xc7\xd3\x72\xeb\xae\x9f\x54\x99\xaf\x4d\x07\xe6\x49\x6e\x97\xed\x16\x2b\x59\xd6\x69\x3f\x7d\x6c\x94\x55\xbb\x8b\xe4\x35\x9f\x6d\x9a\x90\x12\xa0\x15\x43\x4a\x6b\xaa\xf9\xd6\x5b\x2a\x2c\xde\xea\x0b\x6c\xcc\x7a\xab\xa5\xc1\xb6\xf5\x4e\x3d\x25\x75\x52\xf8\xa5\x2d\x97\xaf\xba\xb1\xc5\xe3\xa9\xe5\x67\x12\x98\x63\x8c\x02\x86\x68\x2c\x91\x92\xc4\xd1\xf9\xda\xe7\xa2\x66\x32\x81\xad\x2c\xbc\x15\x45\xb1\xd1\x94\x11\x3e\x67\x06\x79\x11\x35\x60\x4f\x07\x84\x3f\x53\x51\x5b\xad\xbd\xb7\x53\xfb\xaf\x35\x37\xca\x59\xbd\xbb\x4a\x21\x45\xbe\x65\xce\x13\x17\xde\xfc\xf6\xec\xba\x89\x96\x40\xc9\x21\x37\xe8\xed\x0b\x29\xf2\xad\xbb\x7e\x52\x09\xfc\xb1\x43\x3e\x85\xee\x25\x79\x27\xf9\xd6\x7c\x56\xce\x2a\x34\x20\x30\xed\x7d\xed\x5b\x97\x5d\x74\xa3\x6c\x16\xa1\x64\xe5\x5b\x66\xce\xfd\xec\x95\x9e\x95\x41\x99\x93\xf5\xec\x4a\x56\xbe\xf5\x16\x33\xc0\x21\x91\x9d\x16\x5c\xbe\xea\x46\x59\x41\xc5\xd8\xea\xf8\xfa\x02\xd0\x38\x8e\x34\xf7\x09\xfe\xf1\x72\x69\xee\x13\xfc\xf2\x38\xad\x95\x7c\x8c\x16\xca\x14\x04\x4e\xf4\xe2\x55\xd9\x31\x64\x78\x38\x43\xcc\x38\xbe\x5b\x95\x1d\x47\x0c\x8f\xa0\x7b\x6a\xf5\xba\xd4\x37\x52\xdc\x5f\x8f\xe3\x2a\x1f\x2f\xb0\x26\x3a\xc3\x19\xee\x21\xbd\x3e\x7e\x41\xad\xc2\xd7\x18\xe3\xbc\xa9\x4f\x6f\xd1\xc7\x78\x4e\x9f\xed\xfd\xb5\x3a\x22\x5d\x16\x44\x04\xba\x24\x18\xa0\x22\xd3\x59\x56\xae\x58\x15\xba\x23\x64\xa1\xf5\x64\x89\xb4\x76\x72\x28\x5d\x7a\xcf\x3d\x97\x6a\x03\x65\x63\xbe\x66\xc5\xd6\xce\xd2\x53\x64\xd1\x3e\x7c\xaa\xd4\xa9\xd3\x65\xb1\x22\x47\x78\x50\x30\xe8\x72\x64\xc2\x53\x72\xba\x54\xa3\x73\x83\x3a\x57\xdd\xc1\xe2\x31\x53\x0f\xab\x8f\x73\x9d\x67\x0e\x04\x03\x99\x74\x17\x33\x6a\x2f\x1a\x0d\x2a\xf6\x5c\xda\x23\x94\x1a\x1a\x7f\x75\xef\x8c\xeb\x96\xdd\x36\xaf\xa4\x0d\x7a\xdc\x21\xa5\xc5\x3f\xf5\xe0\xd3\x6b\xbe\x73\xbd\x92\xce\xdf\x70\xfe\x59\x8e\x90\x22\x60\xae\x72\xd4\xa9\x37\x9c\x3f\xac\xcc\xcd\xf5\xf4\x6c\x2c\x0b\x0d\x8d\xce\x0d\xed\xd9\xf6\x9d\x56\x25\xc4\xfe\x14\x09\x3a\x9b\x36\x4f\x9d\x26\x4f\xcc\x4e\x54\xaa\x67\x4e\x0c\x39\xb2\x47\x87\xd0\xc5\x9c\x14\xf7\x8f\xe5\x51\x9b\x28\xad\x33\xf2\xb9\x2c\x4b\x44\x78\xe6\xf7\xb5\xe8\xcb\xf9\x08\x6b\x56\xa5\xb1\x98\x32\x89\x29\xb9\x6c\x45\xc0\x14\xd5\xe9\xbe\xa7\x03\xb7\x2c\x19\xe5\x46\xe7\x5c\x1d\x9b\xd5\xb4\x4f\xfb\x95\xf6\x4d\xed\x57\xfb\x9a\x66\xc5\xae\x9e\x33\x1a\xb7\xe4\x96\xc0\xd3\xbe\xe9\x37\x0f\x50\x96\x7a\x29\x3b\x70\x33\xbb\xf5\xd1\x5d\x53\xa2\x67\xad\x89\x8c\x32\x9f\x91\x39\xd3\xed\x17\xac\xd8\x45\xe2\x7d\xf7\x69\x47\x76\xad\xb8\xc0\x3e\x7d\x4e\x64\x94\x29\x8d\xac\x39\x2b\x3a\x65\xd7\xa3\x5f\xa4\xfa\x17\xb7\x6c\x79\x51\x7b\xdb\x6c\x57\x84\x03\x3f\x00\xd9\x9c\xb7\x62\x29\x1a\xa1\x5d\xca\xa7\x03\x1c\x94\xac\xac\x7d\x4b\x3b\x62\xcc\xc3\x22\x2d\x90\xb3\x0a\xdf\x7f\x54\x1f\xe1\xb4\x40\x09\x91\xce\x66\x2e\x30\xc7\xa0\x4e\x2f\x11\x5e\x35\xca\x3a\xe9\xf8\xa5\xc1\xec\x48\x43\x71\x9d\xed\xe0\x8c\xed\x83\xe0\x71\xeb\x20\xf5\x53\xb3\x6d\xae\x90\x52\x1f\x8b\xd5\xeb\x8f\x12\x72\xd9\x66\x1f\xa7\x62\xcd\xbb\xfb\xa6\xb0\x90\x6c\xf4\x37\xf9\x1b\x26\xcd\x9c\xd4\xe0\x6f\xf2\x37\x26\x85\x46\x98\x86\x99\xc3\x4f\x8b\xaa\x30\xc7\x80\x67\x1e\xd6\xfc\x23\x30\xf1\x6e\x56\x09\x35\xf6\x64\xb2\x8a\x29\xd2\x8d\x8f\xeb\x22\x9d\x10\xbd\x6e\x96\xd2\x05\xf2\x91\x14\x7f\x77\x8b\xe8\x53\xff\xb4\xdd\x61\x6f\x54\x52\x9d\xbe\xf9\x67\x9d\x35\xdf\xd7\x99\x52\x42\x0e\xc7\x76\xfa\x27\xed\x15\x87\x23\xa4\xa4\xa4\x16\xa9\x23\xf1\x99\x5b\x6f\xfd\x4c\xa2\x43\x6a\x91\x8c\xc8\x57\xfe\x7e\x2c\x14\xb4\x97\xb4\xf2\x34\x41\x09\xa5\x7c\x4d\xae\xfc\x43\x4f\x3d\x94\x77\x35\xf9\x52\x21\x45\x98\xf6\x6d\x2d\xab\xdd\x70\x9e\xa0\x84\x12\x41\xde\xc1\x37\x84\xce\x23\x37\xa5\xc9\x7d\x5e\xa8\x81\x77\xf0\xc1\x44\x48\x11\xce\x83\xdd\x10\xf2\x75\x9a\xe7\x20\xa1\x0e\x2e\xc8\x08\xa2\x11\x2d\x88\x63\x12\x32\xc6\x58\xf5\xc7\x73\xb2\x3f\x9e\x8b\xfa\xe3\x39\x32\x64\x15\x4f\x54\xff\x92\x27\xea\xa1\x4a\xb8\xec\x89\xe6\xe2\x9e\xb8\x27\xea\xcf\xe4\xc8\x4c\xe2\x21\x55\x55\x55\x4e\x55\x87\x54\x5d\xec\xd0\x1f\x0e\xfa\x7b\x18\x65\x95\x57\x55\x3d\x5a\x53\x8d\x6f\x59\x2d\xab\x82\x5a\x36\x82\x38\xe8\xd9\x86\x88\x6e\xa0\x4a\x3e\x3d\x96\xa9\x9a\x11\xce\xa0\xe9\xb9\x98\x91\x50\x0f\xd6\x1f\x18\xfb\x80\xd5\xb5\xe1\xd8\x76\xa4\xd0\x56\x69\xcb\x34\x74\x03\x99\xb8\x27\x23\xff\x2f\x9e\xee\xee\xee\xee\x48\x64\x79\x4b\xcb\x57\x5a\x5a\xbe\xd2\xd5\x75\x7d\x4b\x4b\xb7\xf1\xf7\x95\xee\xee\xaf\x74\x77\x5f\x6f\xfc\x2d\xef\xee\x7e\x66\xf9\x72\x3d\x59\x77\xb7\xa0\x1e\xb9\x51\xb8\xe1\x7f\xf4\xe8\xfd\x62\xae\xe9\x77\x0b\xef\x18\x73\x74\x53\x8d\x8e\xa2\xc2\x11\x51\x07\x8d\x48\x62\x14\xa0\x52\xcf\xa5\x3d\x3d\x97\xf2\x57\x27\x35\x7f\x2a\x9b\x4b\x96\x73\x4a\xae\x37\x4b\xfd\x39\x55\x61\x3f\x4b\xf2\x75\x7a\x64\x8f\x56\xcc\x25\x35\x5f\x32\xc9\x5e\x48\xaa\x39\xea\xcf\xf6\xe6\x94\x72\x3e\x55\xe5\x4d\xef\x96\xd6\x54\xea\xca\x7d\x52\x6d\x82\x19\xaa\xa4\x28\x9f\xcb\xea\x71\xf1\xcc\xdf\x01\x05\xa9\x46\x70\xa2\xa3\x99\x5e\x4d\xea\x71\x6a\x6e\xe0\xef\x80\x2f\x6b\x04\x86\x5b\xe8\xd5\x64\x2e\x9b\x62\x3f\x55\x72\x26\xd8\x1c\x6c\xc3\xaa\x78\x8d\xa0\x62\x31\x56\x62\x03\xa0\xcb\x24\x4e\x5d\xee\x52\x52\x4a\x21\x9b\x2f\xe4\x95\x42\x17\x33\x86\xb1\xa2\xbf\xc7\x3b\x58\xa1\x4b\x0c\x4a\x46\x93\x2a\xf9\x24\x31\x68\x2c\xf3\x05\xca\xa7\x02\x82\x68\xb8\xbb\x29\xaf\x8c\x8a\x72\x35\x7e\xf1\xe2\xd6\x80\xf6\xae\x7c\xd5\x29\x43\xab\x16\xdc\x11\xae\x0f\x88\x44\x16\x62\x76\xbf\x18\x6c\xb7\x70\x02\xe3\xc2\x9c\x7f\x22\x4f\x12\xcf\x27\x78\x79\x12\x4f\x16\xc6\x9c\x01\xd1\xe2\x71\xc8\xbe\x68\x2a\x4c\x8a\x83\x7d\x34\x7f\x51\x40\x7b\x2f\x31\xe7\xfc\xa1\x2f\x37\xd6\xd5\xd9\xea\x37\x73\x5f\x6e\xca\x5b\xa8\x5d\x62\xca\xd1\x77\x79\xbb\x93\xf5\x39\x1a\x78\x3f\x6f\x77\x96\xfb\x1d\x0d\xfc\xea\x63\x42\xf8\xd8\xc9\x73\x87\xae\x2e\x9e\xb3\x66\xe1\xa9\xd3\xf9\x0e\xa7\xa5\x51\xac\xf3\x35\xda\x94\x35\x8a\xad\xd5\x52\x17\x13\x13\xeb\x63\xd6\x0e\xc1\x11\x17\x42\x1b\x15\x4b\xdc\x6a\xf1\x85\x2c\xf6\x64\x34\xd5\x10\x20\x91\xb3\xae\x9f\x3f\x74\xf5\xa6\xd3\x5c\xee\xc6\xd9\x2d\x21\xee\x37\x81\xb8\xab\x79\x84\x6d\xd1\x4a\x23\x4e\x73\xef\xf6\x8b\x42\x65\x5f\x98\xd2\x41\x53\x0b\x60\xa8\xc1\xac\x06\x5d\x98\x64\x51\xc8\x67\xf8\xed\x41\x7f\x34\x95\x8a\xca\x0d\x93\xe3\xda\x1c\x6d\x4e\x62\x92\xe9\xf7\x07\x05\xd5\xea\xe8\x8c\x1d\xf9\xef\x58\xa7\xc3\x12\xa1\x3d\xda\x92\xa8\xee\x17\xac\xb1\x4e\x87\xb5\x3a\x97\xab\xa2\x39\x17\xd9\xe1\xc3\x74\x60\x82\x39\x99\x18\x7a\x9f\x68\x95\x14\x0b\x9e\x8a\xca\xda\xe4\xd0\xe2\xd5\xe5\xb9\x42\x96\x2d\x86\x8a\x42\x67\x17\x54\x4e\x1d\x52\x39\xb5\xbf\xb5\x53\x9f\x71\x4c\x41\x54\x76\x0c\x98\xbc\xcb\x80\x43\xbe\xe2\xf4\x62\x67\x2b\xeb\x6f\xed\x0b\xef\x0e\xb7\x16\x4f\xbf\x82\xa0\xcf\x39\x9d\xad\xfd\x65\x53\xf6\x2c\x6a\x7d\x0e\xb9\x5f\xe7\x66\xfa\x65\x07\xf5\x9f\x7e\x05\x8b\xb4\x76\xb6\x86\x77\x87\xfb\x5a\x87\x71\x45\xc5\x0e\xc0\x94\x99\xa3\x98\x00\x20\x1d\xf0\x89\x31\x25\x5b\x61\x06\x46\x19\xa8\x11\x75\x55\x45\x0f\xed\xe6\xe6\xbd\xb7\x77\xef\x7b\x7b\xb9\x01\x9d\x65\x3a\xa2\xea\xef\x81\x8c\xbc\x2a\xc7\x90\x5b\x25\x67\xca\x17\x8f\xea\x93\xb9\xbe\xbd\x7a\x52\x36\xef\x9e\x4b\x87\x8c\x74\x9c\x7a\xe9\x3d\xdb\xa6\xcc\x99\x33\x65\xdb\x51\x95\x46\x6c\x16\x46\x75\xcb\x26\x2f\xb7\x08\x20\x2e\x1d\xc8\xa4\x0b\x0a\x15\xba\xf8\x82\x4c\xd3\x48\x17\xd0\xbc\xc1\x66\x0a\x06\x8c\x97\xdf\x27\xfa\x63\x4a\x3c\xc6\x4b\xd9\x6e\x4a\x77\x09\xb9\x6c\x07\xa5\x92\x22\xf3\xfb\x9a\xb9\x4c\xc0\xef\x93\xf4\x48\x31\x2e\xb2\x7f\xff\xa7\xe8\xcf\x4f\x96\x95\x73\x86\x7e\xca\x82\x33\x27\x67\x14\xfb\xbb\x54\xdf\x93\xb3\x70\x2f\x46\x77\x4e\x70\x9d\xdd\xe4\x73\xc9\xb7\xba\x44\xea\xd6\x8a\xbd\xda\x5f\x52\xfc\x4d\x14\xb4\xf8\xad\x0e\xa1\xeb\x4c\xd2\xba\x42\xab\xc2\xd3\x94\x5e\x8e\xd8\xd4\xff\x9c\x6a\x49\x72\x8b\xb8\x5f\x68\x5d\x3c\x2b\x0f\x5d\x7d\xba\x54\x67\x93\x53\x2d\x6c\x35\x3b\xe0\x94\xb4\xc8\x42\xed\x4b\x17\xc4\x7e\x3b\xf5\x24\xbb\xab\x49\x54\x64\xc1\xc3\xbb\x9d\xd4\x16\x0f\x0b\x4c\x12\x6d\x76\x8b\xfb\x81\xef\x73\x6c\xaa\xf6\x6e\x43\xa0\xc5\x6b\xb5\xc8\x29\xab\xd7\x67\x71\x56\xe4\x68\x63\xed\xf2\xa3\x0d\x17\x02\xc9\x40\x26\xe2\xc9\xa6\x3a\xf8\x78\x4c\xf2\x89\x7e\x9f\xd8\x4c\x9c\xc1\x3b\xe6\xb2\x3a\x5b\x29\xf9\x8c\x36\xfb\x8c\x81\xdf\xc5\x4f\xa7\x9c\x3b\xd5\xc1\x4f\x22\x5d\x44\x0b\x64\xd2\xcd\x9c\xdf\xe7\xe4\xa4\x66\xd2\x3f\x71\x03\x33\xac\x6d\xfe\x4c\xda\x3c\xa1\xf1\xb4\x99\x17\xcc\x9b\x3a\x2f\x4c\x8c\x2c\xe2\xc4\x53\xcf\xdc\xb2\x22\x33\x75\xe5\x86\x99\xe9\x45\x16\x2a\xbf\xc9\x5c\xdb\x13\x52\x9d\x28\x50\x80\x4f\xe4\x3a\x32\x02\xbf\x82\xde\xbc\x29\xb8\x34\x38\xfb\x73\xd7\x2e\xeb\x8c\x9e\xb4\xb8\x2b\x77\xef\x8b\xb3\x37\x7e\x75\xcf\xb2\xf6\x7d\xed\x97\x6a\x97\xb9\x22\x74\xfa\x95\x33\xdb\xa7\x47\x3d\xbc\x2d\x77\x20\x6b\xd9\x34\xff\x7c\xf6\xaa\x14\xea\xde\xb0\x78\xf6\x25\xd3\xc2\x8e\xf4\x4f\x33\x8d\x97\x86\x3a\x86\xd6\x2f\xe7\xeb\x5d\xf6\xe6\x64\x78\x92\x3f\x2d\x70\xaf\xb6\x59\x1c\x56\x81\xa7\xb3\x98\x4c\xa1\xa9\x8b\xaf\xeb\xc9\x9e\x73\xf2\xd4\x48\x7d\xfc\xb9\xbb\x57\x7e\xf5\xa2\xd3\xc2\x62\xc0\x94\x4d\x79\x7d\x7c\x4e\x05\xfc\xfa\x9c\x96\x2f\xe4\x43\x94\xca\x75\xb0\x54\x41\x17\x4d\xbb\xa8\x20\x4a\x4e\x92\x9c\x9c\x24\x32\xc9\xc9\xb5\x50\x20\x28\x4a\x31\x7d\xf2\x8e\xeb\xfd\xec\x09\x9c\x7e\x4a\x63\xd8\x41\x5b\x2e\xa5\xfa\x19\x0b\x65\x39\xfa\xf8\x75\x53\x27\xaf\xfa\x42\x58\x70\x36\xdf\x91\xb4\xd8\x45\x2b\x6b\xbc\xc6\xc3\x02\x5e\x27\x91\x67\x0f\xe7\xa8\x6b\xab\x6b\xda\x10\xbe\x75\x56\xe6\xa9\xeb\x3f\x25\xc9\xb2\x33\x3e\x53\x62\x59\x56\x17\x6f\x70\xd4\x09\xdc\xc5\xcc\x2a\x08\x56\x96\x4a\xdb\x92\x2e\x79\x52\x74\xaa\x63\x57\xf9\xf7\x8b\xad\x2b\xce\xfc\x94\xcb\xcb\x37\xb6\x17\x38\x1f\xf3\x8e\xd2\xeb\x11\x41\x45\x23\xae\x03\x92\xe9\x80\xcb\xdc\x0d\xd3\xc7\x72\x3c\xa6\x74\x9b\x3b\x61\x62\x1b\x79\x48\x97\x01\x74\x59\x40\x1f\x46\x5d\xac\x9b\xd2\x01\x83\x44\x45\x49\x49\x75\xb0\x54\x07\xa7\xb7\x43\x9f\x8b\x83\x3e\xaf\xdf\x27\x56\x09\xdc\x45\x62\x42\xa7\x61\x65\x06\xe9\x18\xf1\x64\x99\x2e\xd0\xe9\x74\x6e\x08\xba\x4e\x26\x29\x29\x8f\xf8\x72\xd4\xeb\xbb\xde\x37\xd5\x77\xbd\xcf\x1b\x5d\xb4\xa8\xd6\xf3\xd1\x2f\xf2\xf6\x1f\xb7\xef\x6b\x4f\xdc\x91\xa0\xa4\xd8\x5c\xe7\x77\x5a\x26\xf2\x3e\x9e\x09\xa9\xa6\x86\x26\xce\xed\x20\xd1\x2e\x4b\x4d\xcc\xf3\xe9\xf4\xc2\x88\x95\x78\x41\xb0\xb5\xee\x49\x08\x5c\xac\x57\x7b\xf3\x94\xf4\x4f\x33\x9c\xe7\xdc\xb5\xf5\xb2\x48\x8c\xe7\xea\xbe\x18\xdd\xec\x93\x9b\xa3\xa1\x89\x4e\x35\x19\x7a\x30\x14\x7a\x30\x94\xe4\x51\x75\x0d\x81\x1f\x6e\x14\x78\x22\x12\x1c\x75\x44\xeb\x07\x16\x35\x39\xf9\xf6\xc5\xd6\x85\xa7\x91\xc5\xca\x31\x22\x9e\x3f\xa3\xb0\xbc\xfc\xc4\x03\xee\xcb\xe7\x46\xfd\x6d\xee\x56\x9b\xd3\x45\xcc\xe7\xcd\x90\xb5\x31\x12\x72\x4e\xa4\x4f\xad\xa2\x5d\xab\x36\xb2\xc6\x60\xd8\xc7\xdb\xeb\x9d\x8e\x4d\x17\xb3\x90\x97\x6e\x30\x71\xcc\x19\xfa\x80\x0b\x71\x37\x20\x57\xf0\x98\xe0\x83\x81\x71\x48\xcc\x29\x3a\x52\x0c\x24\xb6\x50\xce\xa7\x0f\x83\x13\xe0\xb1\x8b\x65\x95\x5c\xd6\x30\x28\x1b\x8b\x49\x4a\x37\x33\x63\xc3\x84\x8b\xc7\x3a\x28\x9b\xcf\x45\x7d\x01\x9f\x93\x74\xa1\x2e\xa5\x64\x0b\x5d\x5c\x26\xdd\x4c\x3e\xd1\x1f\xcd\x2a\xd9\x2e\x3a\xc3\xc4\xed\x6c\xba\x90\xb0\x29\x1a\xac\x45\xac\xd3\xe6\x11\x66\x34\x5f\xbf\x68\xed\x44\x2b\x11\xa3\xe3\xe2\x55\xb2\x72\x24\xe8\x18\xe3\xeb\xbe\x38\xe1\x7d\xb7\x89\x5b\xa1\xd9\x3e\xbd\x50\xe4\x43\x21\xbe\x58\x98\x6e\x77\xb8\x04\x6e\x08\x9c\xe0\x72\x8c\x0f\xe5\xf5\x50\xe1\x86\x46\x81\x67\xc4\x53\xa4\x06\xe5\x0b\x66\x93\x43\x64\x8c\x17\xce\x28\xec\xce\x16\x9e\x7b\x70\xee\xf1\x51\xee\xde\xf0\x8d\xcf\x3f\xc6\x49\x4d\x16\x69\xfe\xdc\x33\xf2\x82\xbd\xb1\xce\xbe\x69\xb5\x81\xf3\x23\xc3\xa9\xf6\x3c\xe7\xef\xf4\x73\xf9\xf6\x94\x3f\xd1\x12\x67\x2c\xde\x92\xf0\x1f\x37\xd0\x3c\x58\x36\x56\xa7\x61\xec\xae\xfd\x6f\xf6\xd8\x25\x28\xa1\x8f\x0c\x6b\x11\xb1\x62\xd9\x72\xd4\xb0\x2e\x11\x0c\xe5\xaa\x12\x3a\x62\xf8\x44\x54\xe2\x8c\x94\xbc\x1a\x52\x4a\xa3\xc6\x26\x17\x7d\x82\xf3\xff\x11\xdc\xa6\x79\x22\xa7\x56\xe0\x36\x7c\x42\xd5\x5a\xc7\xf0\xb1\xff\x0b\x70\x8f\xb7\x51\xf8\x24\xff\x58\xb8\x6b\xb1\x5d\x8b\xeb\xff\x31\xa6\xff\x9f\xc0\xfc\xc9\xee\x7f\x10\xe6\x8f\xd1\xd5\x8d\xdf\x3d\xf6\x7c\x82\xff\x78\x74\xf3\x71\xf1\x9f\xd4\x76\x82\xec\x30\x58\xdb\x13\xbc\x44\xc8\x8e\x23\x86\x47\x28\x3a\xe4\x23\x38\x51\xcc\x89\xdc\x03\x23\xa5\xd1\x55\xc7\x73\x0e\xfd\x75\xc4\xc9\x1f\x37\xf4\xf8\xd9\xcc\xc3\xaa\xe3\x71\x6a\xea\xa1\x63\x29\x52\xb2\xa6\xc5\xed\x3f\x8a\x8d\x63\xb0\xa3\xca\x0e\xa7\x55\x1b\xb0\x5a\x29\x62\x75\x3a\x64\x41\x95\x1d\x1f\x19\x2d\x14\x0d\x50\x8e\x1a\x6f\xbe\x38\xde\x3d\x9a\x86\x1b\x28\x97\x1c\xb2\x9e\x3d\xac\xbf\x3e\xb9\x65\xb5\x8d\x3c\x6e\x1b\x2b\xba\x7f\x53\x9f\x93\x0e\x5a\xff\xd7\x6d\xec\xd3\x1b\x68\x68\x06\x9d\x56\x8a\x08\x7b\xff\xd1\x26\xb2\x97\xc2\x7a\x09\xa6\xb9\x88\x55\x1b\xd0\xac\xff\x40\x13\x4d\x3d\xa3\x61\x3f\xdc\x62\xf4\x9f\x21\x45\x55\xdb\x54\x15\xae\x9b\x88\x0c\x2d\x93\x84\x94\xc3\xde\xe8\xd5\xd6\xed\xdd\x54\x2e\x6e\xda\xbb\x77\x13\x2b\x6d\xda\x4b\x77\x79\x1b\xed\x8e\x14\xdf\x7f\xb4\x34\xd1\x23\xc8\x74\xd7\xa3\xd5\x98\xbd\x9b\x1e\xa1\x9d\xb2\xe0\x19\x91\xa7\x24\x53\x1e\x70\xa2\x19\x1d\x3a\x26\x75\xf9\x24\x9f\x26\x4f\x34\x47\x41\x2b\xd5\xa8\xb4\x73\x9e\xac\x12\x1c\xa7\xd6\x66\xea\xfa\xfe\xf5\xeb\xfb\xf9\xf5\x47\x54\x2a\xf6\x33\x30\x7c\x64\xb4\x43\xd4\x31\x71\x57\xad\x15\x24\xef\xd6\x13\xae\x2f\x97\xb4\x62\xc9\x48\x4a\x11\xd9\x71\xd4\x40\x18\x5f\x72\xc8\x91\xa3\x86\x2a\x9b\x2f\x55\x6c\x16\x87\x55\xe1\x1d\x61\x0d\x44\xf8\xd0\x80\x24\x10\x2d\xa4\x24\x7f\xc6\x4f\xd9\x78\x4c\x22\xd1\xef\xcb\xa4\x75\xd1\xdb\x4a\x51\x0f\xf9\x5c\x44\x85\x7c\x46\xe7\x04\x69\xcd\x79\xef\x9c\xa7\xb2\xab\x03\x36\xa9\xfc\x07\x29\x60\x93\x58\xb3\x94\xa7\xfe\xa1\x92\xd6\x27\xbc\x93\x7c\x54\xeb\x7b\x34\x91\xcf\x29\xef\x24\xcf\x7b\xe7\xbc\x35\x2a\xd7\x1f\xd0\x53\xd9\x02\x7a\xaa\x9f\x6a\x7d\x43\x25\xea\x67\x03\xb9\xe4\xa3\xd4\xff\x88\xa2\xfc\x25\x55\xe1\x3f\x79\xd3\xf6\x23\x38\x56\xd3\xe1\xa4\x98\x92\x22\xc5\x50\x7c\x73\xa6\x91\x06\xdd\x13\xd5\x76\xb9\xbb\xe7\x76\xbb\xb4\xbb\xa2\xd4\x4e\x7b\xa8\x9d\xab\xd8\x56\x60\xdd\xec\xa1\x23\x51\x45\x89\x72\xe2\xec\x75\x07\xa8\x5d\x3b\x30\xc6\xae\x44\x06\x92\x9e\x98\xb1\x57\x35\x66\x83\x1a\xbb\x8e\xec\xdc\x79\x84\xdb\x35\x6e\x57\xaa\x8f\x2f\x9a\x3b\x50\xec\xd0\xb1\x7b\x87\xa6\xbe\x1e\x42\x09\x7e\x43\xff\x9a\x4d\x75\x70\x29\x25\x66\xb0\xf5\x7e\x5f\x20\x9d\x4f\xfa\x10\x41\x4e\x67\xb6\x0a\x5d\x94\x0e\x04\x9b\xb9\x60\x80\xc1\x47\x4d\x81\xb0\xc4\xc7\x78\x29\x1c\x68\x22\x5f\xcf\xa5\x3d\x0c\xda\x01\x6d\x89\x76\xe0\x0c\xf1\x8a\x73\x2f\x0b\x5b\xd3\xd9\x8c\x25\x7c\xd9\xb9\x57\x88\x67\x90\x9a\x88\x52\x5b\xb4\x10\x74\xbb\x83\x85\x68\x1b\x45\x13\xb9\x9e\x9e\x27\x0f\x68\x07\xa8\xfd\xc0\x9d\x9f\xb5\x3e\x74\xdb\xaf\xcf\x6f\x8e\xc5\x9a\xcf\xff\xf5\x6d\x0f\x59\x6f\x30\xc7\xab\xf8\xa1\xa0\x42\x84\x13\x27\xa3\x0b\x73\x01\x32\x7b\x13\x8a\x44\x62\xa0\x40\xf2\x58\xd2\x0e\x06\x82\x3a\xa3\x9f\x1a\xb3\xa1\x32\x83\xb2\xdd\x94\x0f\x70\x46\x97\x4b\x54\x30\x6d\xe0\xb8\xcd\x1b\x76\x6f\xe8\x63\x88\x78\xb4\x07\x3d\x11\x0f\x2d\x3f\x63\xef\xa6\x21\x83\xca\xb9\x62\x77\xde\xc5\x71\xf6\x29\x4e\x6f\x30\x30\x64\x90\x21\x57\x9c\xb9\xdc\x5a\x74\xb5\xf6\x51\xa4\xdc\xa7\x0d\xf0\xcb\x96\x69\x03\xcb\xc2\x8b\xc2\xbb\xc3\xd4\xb7\x61\xf7\x86\xce\x3e\x56\x1a\x29\xa7\xfc\xf3\x67\xcd\x52\x36\xed\x6d\x90\xdc\x1e\xfb\x14\xa7\x28\x9a\x86\x20\xcb\x67\x5e\xef\xb0\x16\x5d\x6e\xf6\xa2\x36\x50\xee\xa3\x08\x0b\x2f\xa3\xc8\xb2\x70\x78\x77\x78\xd1\x08\xfe\x8d\x7d\xf2\x36\x2c\x1d\x6f\x6b\x3b\x25\x6d\xb2\xd3\xfa\xf2\x54\xdb\x32\x5d\x16\x0b\x06\x64\x73\xff\x72\x06\xc5\x23\x92\x28\x07\x8c\x51\xdf\xc1\xe7\xb2\x5d\xd2\x34\xca\x65\x0d\xeb\x20\x0a\xf8\x04\xb5\xda\x44\x0c\x3b\xe4\xd0\x82\x4e\x9b\xb8\xbe\xda\x3a\x6f\x38\xe4\x96\xfd\xef\x6a\xaa\x31\xfa\xfb\xb5\x67\xae\xda\x74\x12\x17\xb4\xf0\x6e\x9b\x2d\x70\xf2\xc4\xb8\xe4\x8f\x4f\x5b\x78\xf9\xad\x4f\x5e\xda\x9f\x72\xd8\x43\x32\xa9\x32\x8b\x6b\xe5\x6a\x3b\x65\x47\xa3\x10\x8a\xf1\xd5\x56\xbe\x2a\xdb\x1c\xf5\x6e\x8b\x95\xde\xd0\x54\x59\xf0\x4c\x2c\xdd\x74\x8b\xb6\x2f\x58\xc7\x1c\xce\xd8\xc5\x7d\x5b\x3b\xa7\x2c\xee\x5b\x74\xd6\x29\x53\x53\x01\x63\x82\xd1\x54\x39\x5b\x6d\xfb\x0d\x82\x8a\x49\x86\xe5\xa0\xe7\x78\xdd\xaa\x37\xf1\xd8\x8e\xd5\x67\x32\xd9\xdc\x8f\x1f\x6b\xe5\x38\xda\xdc\x91\x1e\xb5\x39\x38\x71\x6c\x9f\xda\x1c\xa2\xe8\xfb\xf3\xd0\x2f\xeb\x67\xd6\x6b\x67\xd6\xd7\x5f\x56\x3f\xb3\x9e\x24\xf6\xf9\xfa\x99\xf5\x97\xd5\xb3\xe5\xda\xf7\xc7\x76\xa5\x8d\x8d\x74\xa5\xe6\xb0\x16\x6d\x9c\x85\x0e\x0c\xfd\xb2\xbe\x9e\x1e\x37\x32\xd4\x6b\x1f\xb1\xcf\x1b\x85\x98\xe7\x66\x30\x0c\x09\x22\x70\x6a\x65\x9d\x31\x54\x4d\x9e\x4c\x3a\x50\x35\x20\x30\x54\x4b\x51\xbf\x4f\xac\xae\xb2\xfa\xe4\x6c\xe8\xa4\xaa\xdb\xf4\x86\x8d\x52\x34\x97\xd5\x3d\x12\xe4\x61\xc8\x59\x45\x53\xd5\x90\x62\x38\xf5\x97\x12\x52\x35\x55\x31\x9c\x32\xc1\xd8\x28\xd0\xa3\x75\xa7\xfe\x52\x42\x2a\xe9\xd1\x04\x76\xef\x3f\x96\x5e\x1e\x5b\x5b\x8d\x1e\xa0\x09\xa0\xbc\xa1\x87\x4a\x91\x92\x1a\x67\x6b\xe5\xf7\xe4\x0b\xdc\x2b\x72\x28\x24\x97\xa7\x5a\xf9\x1a\x6b\x79\xab\x70\x95\x6c\x0f\x1d\x29\x86\xec\x32\x7b\xce\x6a\x2b\x2f\xad\xf2\xdc\x4a\xa8\xbc\xd4\x66\xad\x39\x1f\xd2\x36\xbe\xfc\x13\x54\x63\x24\xca\x17\xc4\x91\xda\x8e\xad\x93\x3d\x27\x87\x8e\xa9\x79\xea\x09\x40\x60\xcf\xc9\xf6\x50\x79\xaa\x01\xcb\x96\x8a\xbe\xab\xe1\x38\xb0\x64\x47\x6a\x3e\xab\xb6\x66\x59\xfe\x98\xda\xe4\xac\x3c\x5a\xbc\xd1\xd6\x6b\x85\x1b\x84\xad\xa8\x03\xac\x24\x1a\xcd\x32\xc6\xe8\xea\x23\x2f\x07\xa3\xd1\xa0\x30\x39\xc8\x2e\x2c\x37\x3b\x7c\x21\xa1\x14\xf2\x39\xca\xcd\x8e\x04\xc6\xd8\x14\xba\x2a\x2b\xfc\x98\x45\x55\x18\x7f\xf4\x07\x15\xcb\x7f\xe3\x14\xc0\x90\x5a\xeb\x13\x8a\xa3\x52\x4f\xad\x04\xa4\x54\x69\xb7\x5a\xcf\x31\xb5\x88\x63\x24\xa6\x31\xe5\x8c\xe6\x15\x4d\xdc\x05\x47\x9a\x16\xac\xb4\x50\x32\x5a\x2b\x4a\x27\xe9\xa8\x63\xcf\xe9\xa8\x63\xcf\xc9\x3a\xfa\x42\xbc\x55\xc7\x9c\x50\x0a\xd9\x75\x9c\xda\xd8\x73\x86\x43\xce\xea\x2f\x7b\x88\x3d\x67\xb3\x8e\x94\x5f\xa5\x93\x63\xca\x0f\x7a\xc6\x6e\x99\xea\x55\x1d\xaf\xc6\xb1\x64\x72\xe2\xda\xad\x36\xf6\xe8\x28\x82\xd8\xa3\x36\x6b\x2d\x30\x63\xc6\xc4\x58\x58\xc6\x03\x31\x52\x7b\x6d\xbd\x63\x6b\x1c\x57\x91\xd1\xdf\x04\x88\x24\x88\xa8\x43\x23\x20\x9b\x93\x82\xd1\x1b\x54\xd3\x23\x7a\x3d\xce\x51\x1a\xd3\x69\x4f\x78\xae\xa6\x5b\xd8\x49\x55\x14\x87\xca\x7f\x32\x6d\xa1\x94\xd0\x30\x42\x95\xfe\xba\x77\xf8\x5e\xfe\x51\xe1\x4f\xf0\x01\x56\x16\x30\xad\xc7\x2b\xf3\x91\x3e\x91\xf2\x77\x95\xdf\x65\xb2\x2c\x3f\xaa\xf7\x44\x48\x96\xd9\x9f\xe4\xac\xfc\xa8\xcc\xbf\x52\x7e\xb7\xfc\xae\xe1\x34\x83\xd8\x9f\x8c\x34\x66\x99\x4b\x87\xef\xe5\x2f\xaa\x94\x79\x8c\x21\xba\x5e\xe8\x59\xe5\x50\x25\xaf\x5c\x7e\xd7\x2c\x9c\xfd\x49\x66\x77\xe9\x35\x18\x1e\x99\xc9\x66\x02\x3d\xe1\x18\xda\x8f\x63\x12\x40\xb9\xac\x12\x8f\x7a\xcc\x23\x3c\x7e\x4f\xd4\x3c\xc7\x93\x89\x7a\xcc\xc3\x3c\x39\x4f\x34\x3d\xd6\x7a\xa7\xa4\x37\xd9\xc0\xfb\xb0\xd1\x7e\x32\x3d\x86\x61\x58\x71\xbc\xf9\x4e\xb1\x12\x73\x6c\x1e\x6a\x3b\xd6\x96\xa9\xc6\x9e\xa8\x02\x57\x15\x9a\x63\x61\xa8\x39\x0b\x74\xdc\x5a\x2b\x32\xef\xf8\x5a\x6a\xdb\xdf\x66\xec\x9d\x66\x27\x51\x21\x9f\xcb\x4e\x22\x25\x1e\x73\x19\xca\x32\x97\xce\xdf\xb6\x90\x64\xbc\x03\x99\x74\xb7\xa1\xdb\xec\xa6\xb1\x30\x5c\x27\x3f\xf9\xa4\x2c\x2f\x95\x1b\x43\xba\x23\xd4\x28\x2f\x95\x8f\x0d\xa1\x9b\xc6\xc1\x46\xf7\x7f\x5c\xf2\x4a\x08\xbd\x74\x42\xdc\x04\x0d\x3b\x2f\x1d\xda\x98\x44\x29\xc5\x84\x35\xa8\x43\x59\xa0\x2e\xaa\x81\x4f\xe0\xbd\xe7\xc9\x59\x59\x5b\xfd\x07\x39\x2b\x9f\xe7\xf5\xd2\xa5\x7a\x15\xac\xc5\x3b\x34\xde\xae\x32\x16\xf6\x2e\x95\x65\xed\x92\x3f\xc8\xf2\x52\x6f\xb8\xd1\xab\xdd\x23\xeb\xe9\xe6\x8f\x83\xa1\xd6\xde\x6b\x2a\x66\x03\xc9\xf1\xe7\xc6\xb2\x1d\x14\x8f\x49\xa2\x81\xb3\x8a\x61\x88\xdf\x27\x4a\x4e\xaa\xa6\xc8\x65\xf3\x85\x2e\x3e\x31\xce\x04\x74\xc4\x66\x1c\x97\x3f\x7a\xce\x5f\x55\x57\x70\xab\x64\x77\x5b\x73\xd1\x58\x76\x72\x4f\xeb\xe4\xee\x4b\x8c\xc8\xb6\x68\x24\x36\xb5\xa5\x81\xd4\x71\xd0\xf7\x8f\x18\x97\xb3\xc7\x97\xdc\x73\xe6\xbf\xd7\x7b\x57\x8a\xf6\x59\xf5\xf5\xd9\xa8\xd2\x11\x08\x6f\x3c\x35\xa1\x47\xcb\x33\x64\xaf\x7f\xca\xa4\xf9\x33\xc6\x13\xc3\x68\x9b\x74\xd9\x6b\x6a\xb5\x4d\x9e\x51\xd2\x33\xf4\xdc\x23\x44\xc8\x8d\x6b\xf2\x18\x8b\x3f\x78\x9d\x7d\x55\x83\xd6\x3e\xd3\x5a\xb9\xe4\xf4\xd6\x34\x90\x1d\x03\x7c\xbf\xd3\xcb\xa0\xc7\xf6\x3b\xbd\x5a\xc9\xf8\x78\xb9\xdb\xfb\x2b\x21\xde\xef\x8d\x87\x77\x94\x0e\x26\x19\x67\x7f\x46\xce\x82\x74\x50\x6a\x44\xe7\xe2\x24\x29\xa3\x33\x40\xba\xbf\x99\x82\x23\xc7\x44\xba\xc8\xd4\xcb\x38\x49\x1a\x49\xdb\x41\xa9\x91\x32\xba\xa8\x30\x92\xb6\x99\x82\x99\x74\x80\xff\xfa\x3a\x7d\x20\xad\x8b\x3c\xb0\xd6\x18\x4e\x6b\x1f\x88\x8c\x0f\xa0\xab\x94\xd0\x1d\xc9\x77\x1e\x30\xbc\x0f\xbc\x93\xbc\x43\x8f\x1f\x17\xc0\x70\xa2\xdc\x23\x01\xd4\x7e\xe2\xec\x95\x80\xb1\x76\x99\x71\xc3\x8a\x1d\xe6\xc1\x1f\xc9\x9c\x18\xbb\x29\x65\x4e\x8c\x2d\x55\xe9\xc4\x45\xc1\x80\x2f\x7f\x22\x3b\xc4\x79\x3b\x6d\x21\xdb\x2d\xb7\xd8\x42\xb6\x9d\x36\xfd\x6b\x1b\xe7\x7f\xf1\xe3\x2c\x13\xe9\x27\xc7\xcf\x34\xe2\x6f\xf8\x78\xf3\xe4\x63\x6d\xa7\xad\x35\xdc\x77\x0b\x55\x16\x8d\x13\x1a\x51\xde\xa5\x2d\xd5\x87\xf7\xeb\xb2\x7c\x91\x9c\x95\xef\x22\x7d\x92\xbf\x48\xde\xf2\xb1\xc6\x94\xaf\x68\x4b\x65\x99\x14\x23\xa5\x91\x45\xcf\x7b\xe4\xef\x84\xf3\x73\xb0\xc2\x6b\x9c\x0b\xce\xa6\xc8\xd8\xb3\x13\x0c\xbb\x4a\xf2\xfb\xe0\xae\x9c\x91\xa9\x9c\xd8\x11\x22\xe7\x94\x9d\xb7\xf4\x5f\xfe\x93\x9d\x67\x0f\x35\xb0\xbf\x7e\xfe\x91\x5d\x47\x76\x0a\x91\x2d\x2f\x6a\x7f\xd4\x9e\xd7\xfe\xf8\xe2\x96\x2d\x2f\x52\x13\x75\x52\xd3\x8b\xec\xa6\x07\x6e\x2e\xbb\xce\x3d\x67\xe7\xcf\xf6\xb3\xc3\xe7\xed\x1c\xda\xf5\x20\x75\x6b\xcf\x69\x7f\x30\x2c\x2c\x9b\x69\x2a\x35\xe9\x2e\x7d\x1d\x2c\x0e\xe7\x44\x08\x3d\x88\x54\xcf\x0e\x19\xbd\x6b\xea\xd5\x72\xa6\x62\xcd\x38\x92\x45\x06\x63\x75\x4a\xb6\x5c\xa4\xa4\xa2\xf4\x24\x73\xd9\x54\x79\x63\x32\xc9\x6e\x53\x72\x59\xa5\x47\x51\xb4\xdf\xb0\x52\xf6\x14\xa6\xaa\xb9\x1e\xed\xf5\xc4\xda\x44\x6f\x32\xc9\xb6\x1b\xc6\x0a\xb7\x2a\xca\x7c\xe5\x52\x45\xfb\x4d\x8f\xc9\x8f\xe4\x84\x52\xa5\x3e\x53\xb7\x65\x2c\xbd\x34\xa2\xa3\x32\x3b\xca\x90\x08\x85\x52\xb2\xbc\x31\x95\xcd\xa4\x7a\x14\x85\x92\xe5\x62\xf6\x94\x53\xb2\xac\xa4\xfd\x46\x51\x7a\x94\x6c\x4e\x61\xb7\x25\x59\x31\x9f\xd4\xc1\xe8\x51\x2e\x55\x28\xd9\x93\x53\x73\x3d\xa4\x24\xd6\x26\x7a\x14\xa5\xbc\x51\x9f\xd0\x91\x1b\x56\xc5\x1e\xa1\x88\xa8\x61\xd7\x66\x36\x6c\x84\xeb\x31\x17\xfe\x4a\x33\x75\xc6\xa5\x27\xd9\xa3\xe4\xf2\x09\xed\x75\xa3\x28\xa3\x21\x3d\x8a\xc2\x6e\x8b\x17\xf2\x49\xbd\xba\xdc\xc7\xc0\xa2\xc3\x6a\xf2\x16\xb9\xe1\x27\xc5\x1e\x41\xad\x9e\xf5\xae\x22\xb3\xd2\xac\x11\xde\xab\x82\x5b\xb1\xc7\x68\x65\x2e\x59\xde\xa8\x28\xf3\x75\x07\x29\xbd\x59\x35\xdb\x4b\x8a\x8e\xbf\x9e\x24\x2b\xe5\x92\xe5\x0d\x3a\x3e\x13\xf9\x9c\xd2\x93\x4c\x6a\xaf\xb3\x52\xb6\xb7\x57\xef\x0b\x25\x99\xec\x49\x8d\xf2\x9c\x25\xe3\x4e\x30\x53\x96\xcb\x79\xe2\x31\xa7\xe0\xf7\x05\x7d\x95\xb3\xe6\x1d\x2c\xc5\x72\xd9\x82\x37\x9a\xf1\x54\xe5\x35\x4d\x97\xa0\x06\x56\x7c\xf9\x4b\x57\xac\xe8\x8a\x0b\x82\xc7\xe5\xb6\x4b\x76\x17\x77\x43\xee\x41\xf6\x93\x01\x25\x2b\x33\x70\xf7\x66\xf5\x54\x3a\x6b\x61\x6f\xc9\x7f\x6a\x63\xff\xaa\xc2\x2c\x31\x6e\x75\xf9\x3c\xd6\x50\x4c\xa2\xa6\x47\x7f\x7c\x33\xdd\xa5\x73\x22\xb2\x36\x86\x07\x08\xea\x3c\x90\x0e\x49\x30\x30\xca\x9d\x57\x87\x9f\x61\xa7\x36\x89\xaa\x7c\x97\x3e\xbd\x98\x4a\xb7\xbf\xda\xb4\x27\x76\xc8\xa6\x31\xad\x92\x95\x77\x50\xaf\x2d\x64\xbb\x92\x0b\xea\x6e\xed\x09\xdd\x6d\xb3\x51\xef\x8e\x8a\x05\x2d\xbd\x1b\x32\xd2\x8f\x18\xe5\xea\xe9\x6d\x57\x72\xf3\x0c\x5b\x5c\x3d\x83\xed\x4a\x5b\xc8\xc8\x90\x55\x2a\x36\x7c\x8e\xe1\x2f\x08\x7f\x15\xae\x32\xe1\x3b\x11\x1c\x27\x82\xdb\xb0\x7b\x3b\x0e\x20\x27\x80\x9b\x15\x8f\x0b\x08\xbb\xeb\xb8\x60\xa3\x6a\x87\x29\x98\x67\x14\x2b\xe3\x71\x84\x58\x47\x46\xc8\x08\x01\xe9\x12\x95\xda\xd9\xaa\xf5\x19\xe7\x37\xb5\x3e\xe3\xb0\x40\xbf\xe1\xa1\xfe\xd6\x4e\x2e\x72\xbc\x50\x23\x7d\xa5\x2e\x06\x41\xe5\x4c\x19\x6a\x9c\x9e\x58\x2f\xf7\xa8\x61\xe6\xca\x97\x2a\x25\x55\x0f\x89\x9a\xb2\xa7\x2e\x3f\xe5\x8c\x33\x31\x2e\x72\x52\x6a\xf4\xdc\x9b\x20\x9a\x47\x77\x4e\xa2\x0e\xea\xa6\x2e\x0a\x0a\x23\xf0\x26\xf3\x01\x9d\xde\x25\x41\xf8\x69\x47\x63\xa8\x18\xba\xb8\x43\xfb\xc0\xa0\x74\xed\x83\x8e\x8b\x43\xc5\x50\x63\x07\xd9\xb4\x0f\x2a\x51\x64\x33\x07\x81\xad\x12\xa5\x7d\x40\x7f\x0a\x5d\xdc\x71\x59\x47\x63\xe8\x4b\xda\x8b\xc6\x51\xea\xcc\x97\x42\x8d\x1d\x97\x75\x5c\x1c\xba\xf7\xde\x6a\x0c\x65\x8c\xd3\xd9\x2f\x8e\xc4\xd4\xae\x07\xba\x8c\x72\x92\x61\xc5\xe9\xad\xce\xf8\xe3\xcf\xe0\x73\x72\x36\xa5\x07\x48\xa2\x5f\x36\x43\xd8\x24\x73\xca\xae\x4e\xf9\xec\x9b\x5e\x47\xc9\xe1\xf3\x39\x4a\x0e\x2f\xf3\xda\x6c\xce\x37\x9c\x36\x9b\xc7\xe7\x7c\xda\x29\x0b\xe3\xf9\x90\xa3\xff\xf5\xac\x53\xf6\x39\x9e\x75\xf8\x64\xba\x88\xad\xb3\x8b\x16\x8b\x68\x2f\xdf\x65\x73\xb9\xaa\x7b\x5b\x22\x84\x22\x1c\x08\xa0\x05\xf3\x75\x2e\xc9\x93\x8b\xfa\x3d\xfe\x0a\xdf\x97\x31\x76\x98\x7d\x81\x44\xd6\x60\x9e\x33\x69\xf3\xdc\x58\xed\x99\x30\x53\xc2\x32\x6e\x3a\x31\x56\xe7\x8c\x79\xf5\x49\x3a\xc0\xf5\x6b\xa5\x44\xb8\x14\x4e\x68\x9d\x3f\xb8\x3e\xd4\xd6\xda\xd9\xc9\x5e\xeb\x6c\x6d\x0b\x5d\xf7\xfd\x56\xda\xe7\x75\xf6\x75\xb6\x1e\x2d\xb5\x76\x9a\xdc\xd4\x53\xe7\xdf\x74\xd3\xf9\x6b\x66\xa8\xea\x8c\x35\xba\x8b\x9e\x72\x7a\x9f\xe8\xa4\x03\xa5\x92\xd6\xde\xd9\xd0\xd8\xc8\xad\x7a\xa0\xa5\x73\x51\x67\xe7\xa2\xce\x96\x07\xfa\x75\x36\xac\x4a\x53\xe6\x89\xc3\x9b\xbe\x73\xd3\x82\x47\x1e\x59\x70\xd3\x77\x6e\xf2\x9a\x7a\x32\xc9\xbc\xc7\x61\xa1\xa1\x57\x8e\xc7\x78\xd1\xd0\xcf\x66\xd2\x86\xd1\x59\x22\x93\x26\x9f\x24\xc2\xd4\x01\x52\x3c\xe6\x64\xf1\x98\x92\xea\xe0\x72\x59\xf3\xdc\xa7\xa2\x3b\x0a\x5d\x7c\xa1\x8b\xcf\xa4\x9b\x99\x00\x25\xf4\x98\xf6\xc6\x1f\xb7\xc8\x4a\xa8\xde\xdf\xb8\xdc\x77\x0b\x49\xdf\x0e\x31\xc5\xd7\xa1\xbd\xf3\x9b\x57\x07\x76\xdd\xea\xda\x19\x74\x4f\x6a\xeb\x6a\x6a\x9b\xd0\xc0\x2c\x1c\xd7\x35\xbf\x2b\xcc\xac\xe7\x7c\xf1\xd9\x75\x85\x27\xbe\xf5\xcd\xbb\x53\xb6\x94\x2f\x96\xaa\x4f\x75\x47\xdc\x9c\x92\x55\x3e\xbd\xf7\xf3\xfe\xfa\x90\x22\xd7\x2f\x97\xaf\x5d\x4d\xe2\x05\x2b\x06\xb4\xef\xaf\x5b\x3b\x49\x98\x5f\xec\x2d\xc6\x27\xf2\x4e\xd1\x21\xc5\x17\xe4\xa7\xca\xfc\x2c\x5b\x26\x77\xd5\x2f\xbf\xba\x29\xe1\x75\x71\xd6\x54\xd2\x96\xf2\x04\xad\xcb\xb6\x6e\xa8\xea\x38\x20\xa8\x22\xe0\x42\x06\x10\xc6\xef\xb0\xf8\x8c\x49\x37\x15\x34\x14\x9c\x42\x2e\x9b\x0a\xa6\x9a\x79\x41\xad\xdd\x27\x1b\xc6\x94\xd3\xfb\xfa\x4e\x9f\x72\x2a\x4f\x4b\xb7\xdf\xb2\xb4\x60\xfa\x66\x72\xa6\xaf\x7f\xc4\x7a\x9d\x97\x17\x6e\x3d\xff\xac\xb9\x73\xcf\xcb\xf4\xa9\x44\x13\x16\x6f\xb8\xf1\xb1\x15\xd5\x90\xe5\x9f\xad\x84\x54\x78\x09\x1d\xef\xbc\x0a\x0f\xa2\x98\x02\x90\x92\x0a\xf8\x2b\xfa\x70\x51\x0a\xf0\x91\x84\xd1\x17\xa6\xa2\xdc\xb0\xe2\x85\xde\x0b\x11\xa4\x94\x6c\x21\x8f\x08\x82\xa2\xba\xfb\xad\x19\xa6\xe1\xd5\x8c\xb7\x76\x7f\x8e\xee\xa4\x03\x74\x67\xf9\xc9\xb0\xef\xba\x6f\x85\x5b\xc3\x5b\xce\xf6\x71\x6b\x7d\xdb\xb5\x54\xf9\xb0\x96\xda\xee\xf3\x6d\xa7\x5f\x33\x27\xfd\x7a\x3b\x2b\x1e\xdc\xb8\xfa\x9a\xa7\xb5\x8f\x48\x7a\xfa\x9a\xd5\x1b\x0f\xbe\xf8\xd7\xbf\xb2\x93\x5b\xc3\xdf\xba\xce\x17\x0e\xfb\xce\xde\xa2\xfd\x72\x56\xfc\x4f\xda\x3b\x14\x78\x2b\x3e\x2b\xfe\x16\x05\xb4\xbf\xbc\x65\x9c\xab\xed\x97\xc0\x0f\xc0\x8a\x06\xcc\xc0\xa9\xf8\x14\x90\x2c\x74\x90\x01\xaa\x77\x3c\x9c\x49\x1d\xce\x8a\x76\x35\x97\x2d\x74\x90\x09\x71\x34\x6d\x9c\x2a\x6d\xe6\x82\x01\xd9\x27\x4a\x14\xe0\x0d\xf5\x33\x1f\x2f\xe4\x13\x05\x25\x55\x68\xa6\x20\x6b\x5b\x78\xce\x8a\x19\x6f\xed\xfe\x1a\xbb\x65\xb4\x15\xf4\x79\xba\x54\x5b\x76\xc9\x14\x9b\xd7\xbe\xc5\xdd\x7e\xc7\xa1\x25\x3e\xdf\x97\xe8\x39\x72\x9c\x7b\x5e\xde\xe6\x15\x42\x89\xe6\x28\xe7\x4e\xde\xff\x59\xaa\xb7\x50\xc9\x97\x9a\x7d\x8f\xb6\xf1\x77\xf3\x0f\xd0\x25\xd7\x5c\xf5\xb5\xee\x0b\xbe\x71\xf2\x4f\xbe\xd0\x5d\x5a\xa3\xb7\x53\xd3\xd8\x65\xa3\xcd\xfc\x2f\x89\x3d\x53\xb6\xef\x3f\xd7\x3d\xdb\xe6\xb5\xf7\x9c\xf2\xda\x2d\x2d\xbd\x2d\xef\x90\xdb\x73\xa1\xdb\x2e\x7b\x65\x66\xd3\x26\xdf\xf6\x56\x9a\x3e\x38\x69\xeb\xec\x58\xf1\x8c\xc7\x9e\xdd\xea\x7d\x6f\xff\xb7\xae\x5a\x5f\xfc\xe6\x05\x66\xdf\xb9\x87\x55\x71\xd0\xa0\xa7\xa8\x4e\x51\xe3\xe5\xbf\x63\xe7\x24\x8e\x02\xd2\x88\x95\x27\x75\x51\x3a\xc0\xd7\xec\xd5\x32\xaf\xcd\x51\xf7\x46\x9d\xa3\x32\x2b\x39\x38\xc4\x93\x9e\x69\xb1\x23\x88\x4d\xf3\x24\xe3\x1c\x3c\xd3\x67\x4f\x7f\xe0\x59\xa7\x2c\x3b\xf5\x17\x6d\xa5\x9f\xd9\xa5\xba\x3a\xc9\xa9\x15\x6c\x0e\x07\xb7\xef\x88\xda\xdd\xdd\x14\x8b\x35\x75\x77\x0b\x6a\x4b\x22\x51\x59\x93\xd6\x0a\x6b\x91\x06\x28\x20\xba\x48\xae\x6a\xbb\x53\x56\x32\x34\xdf\x6d\xa4\x4c\x62\x4a\x4a\xe9\x36\x59\x1a\x2b\x99\xee\xa0\x50\xe8\x22\xa1\xaf\xbd\xd8\xfb\x40\xbf\xe0\x51\x25\x3b\xcf\xb9\x44\xed\x3f\xb5\x72\x4e\x70\xf4\x59\x9d\xcc\x65\x7d\x66\xa8\x8e\x91\xad\xcf\xea\x14\xd9\xf7\x89\xd3\x78\x27\xc7\xea\x54\xa7\x9b\x7d\xa9\xbf\xb7\x24\xf4\x65\x4b\xbd\x0f\x94\xe7\xca\xce\x3e\x91\x38\x07\x0d\x69\xe5\xef\x7b\x9c\x7d\x56\x56\x37\xf4\x8c\xe4\x76\xd8\x2f\xb4\x52\x8e\x38\x0a\x5a\xdc\xee\x3a\xd5\x21\x7c\xb5\xbf\xb7\xa8\xaf\x64\xc3\xe6\x1e\xc5\xb1\xb6\xd0\x55\x2b\xe8\xd3\x71\x15\x10\xac\x58\x72\x27\xc7\x7d\xa9\xd6\x3f\xa2\xbc\xa9\xcc\xc7\x35\xe9\x0a\xe3\xe2\x92\xe3\x4e\x8d\x54\xc4\xbd\x68\xcd\x5d\x02\x01\x95\x22\xda\x00\xf5\x51\x51\x2b\x69\xfd\xe3\xdd\x6c\xc0\x70\xab\xfa\x9b\x83\x1e\x62\xba\xb5\xfe\xd1\xa3\x34\x6c\x60\x34\x9c\x8c\xd2\x22\xa3\x91\xa4\xf6\x66\x8f\x18\x27\xd8\xd5\xe5\x33\x8b\x33\x97\x93\xf9\x51\xb3\xbd\x66\xbd\x91\xa2\x91\xad\x58\xa4\xc8\x10\x28\x42\x25\xf3\x5b\xa4\x22\x8b\x50\xc4\xb0\x7a\x1d\x70\xc8\xf2\xd0\xd7\x8d\x24\x7a\x86\x52\x4d\xf0\x82\xa3\xc6\x85\x27\x02\xb2\xbd\x7d\x33\x97\x2f\x9f\xd9\x67\xbe\x7b\x2b\x72\x4c\xbf\x04\x61\x00\x5e\x14\x70\x05\x40\xa2\xd4\xc1\xd7\x98\x29\x54\xf7\xb0\x67\x50\xcc\x49\x1d\x62\x2a\x5f\x68\xe6\x33\x51\xf3\x28\x01\x79\x47\x22\xa3\x31\x27\x93\x44\xc9\x59\x6b\xe1\x60\x18\xf3\x75\x89\x23\xa9\xd9\xbd\xd3\x17\x04\x9a\x33\x99\x9e\xf6\x01\xe3\x78\xeb\x11\x41\xb4\x6a\x25\xab\xd3\x21\x47\x2e\xed\x5c\x9a\xed\x4d\xcf\xcc\x4e\x6d\x9c\x56\x49\x42\x18\x3d\xee\xa7\x27\x19\xc6\xe4\x85\xd3\x27\xd6\x47\x3a\x9a\x26\x9c\x3a\xe3\x9c\xf3\x37\xcf\x32\xcb\x18\x17\x58\xcd\xc5\xb7\x2c\x7b\xf2\xa4\xc2\xdc\x09\x4d\x86\x8a\x61\xc8\x19\xd6\x4b\x91\x1d\x25\x22\x4e\x72\x06\x63\x1d\x33\x52\xe7\x3f\x61\xc4\x97\x9c\x5e\x9b\xf6\x3d\x6e\x53\x35\x41\xf3\xf4\xee\x8e\xae\x75\x33\x97\x6e\x5e\x74\x76\x26\x6a\x64\x1e\x13\x62\x26\x1f\xdd\x7f\x11\x00\x9d\x35\x75\x33\x3e\x1e\x4b\x89\x82\x28\x89\x4a\x2a\xa7\xe4\x15\x7d\x11\x14\x0a\x0a\xcb\x65\xbb\x28\x91\x49\xf3\x12\x06\xb5\x95\xef\xcf\xee\x79\x4e\x3b\x32\xe5\x14\x4f\x23\xcf\x09\x64\x63\x76\x26\x4d\xf6\x4f\xa8\x6f\xae\xfb\xca\x93\xb7\x0f\x52\xef\xb7\xdf\xa7\xfb\xb8\x0e\xed\x61\xed\xd7\xff\x6c\xf9\xc6\xa9\x4e\x0b\x0b\x78\x89\x77\xf3\x2e\xce\xc9\x2c\xb9\x60\x67\xc7\xdc\xd6\x73\x49\xbc\xe7\xb3\xef\x3e\xb6\xea\x9f\xc7\xca\xfc\x19\xe3\x24\xaf\xdf\x67\x70\x45\xd5\x95\xac\x89\x7c\xcd\x5c\xba\x8b\x1b\x59\xd9\x3e\x51\x9b\xff\x23\xed\x01\x6d\xae\xf6\xc0\x8f\xcc\x93\x1b\x93\xa6\x9f\xd9\x31\xb1\xe3\xcc\xe9\x93\x4c\xef\x10\x94\x90\x66\xde\xba\x56\xb9\x9c\x68\xd4\xc7\x4a\xea\x4f\xb4\x67\x9f\x7c\x92\x66\xfe\xc4\x54\x31\x66\x7b\x95\x00\xcf\x07\x74\x41\x28\xa4\x28\xec\xa2\xd1\xa4\xb5\xd9\x2a\xfa\xe1\xa5\xf0\x8b\x8f\xf2\x11\xf8\x80\xa4\x54\x7b\xb3\x48\x75\x8f\xea\x2e\x43\x35\x7c\x8c\x36\xf8\xc5\x47\xaa\xda\xdd\x47\xe4\x9c\xcc\xde\x92\xe5\x72\xa3\x9c\xab\xea\x87\x07\xc4\x47\xb9\x77\xaa\xfa\xe1\x63\x76\xef\xc4\xbb\x0c\xfd\xf0\x31\xda\x60\xf6\x5a\xb9\x51\xd6\xcb\xca\xc9\x8f\xc8\xb2\xa9\x98\x7e\xc4\x28\xd4\xe4\x8d\x54\x5e\x45\x12\x3d\xd5\x3b\xae\x3a\xb8\xe9\x34\x83\xc6\x9c\x7c\x35\xcf\xfd\x47\x8d\x5d\xff\xea\x46\x5c\xce\xdc\x89\x33\xa5\x55\xe3\x62\x0f\x2e\x4c\x4d\xe4\xc9\xa4\x03\x02\x64\xc7\x50\xd1\x52\x27\xf1\xac\x14\x52\x5c\x54\x94\xa7\xcb\x54\x74\x29\xa1\x12\x2b\xba\xad\xfd\x12\x53\x5d\x5a\xc9\x37\xd5\xa7\x95\xf4\xb0\x72\x49\x0f\x93\x1d\x5c\xa9\x9a\x23\xe2\x90\x79\x9b\xe8\x11\x7d\xd4\x4f\xfd\x4a\xa8\xde\x43\x6a\x20\xa0\xa9\x9e\xfa\x90\xa2\xa9\x75\x25\x1b\xdd\x5d\xef\xd1\xd4\x60\x90\x8c\x20\x52\xed\x25\x6b\xdd\x68\x16\xad\xaf\x46\x7f\xa4\x0a\xe6\x19\xea\xa9\x40\xa2\x62\x6d\xc1\x57\xbe\xb2\xc7\x27\x4a\x42\xc0\xef\x93\x46\x2e\xe7\x33\xf8\x3c\x2e\x6e\xde\xd2\x97\x6e\xe6\x83\x86\xd5\x85\x71\x73\x07\xf7\x82\xf1\x79\x21\x5a\x7f\xf4\xa0\xa3\x9e\xdb\x6d\x5c\xd8\x87\x90\xe2\x76\x37\xb2\x7f\x79\xc1\x54\x74\xbb\x1b\x9c\x76\x5e\x22\xfe\x5f\x42\x4a\xd6\xb8\xed\xc3\xfc\xe3\x4a\x1a\xea\x93\xdc\x96\xe9\x36\xf7\x64\x45\x97\xb0\xea\x26\xb4\x4c\x11\xb8\x82\x92\x55\x1c\xde\x16\xbf\x22\x29\x18\x73\xde\xcd\x77\xec\xfe\x51\x93\xa1\xeb\x50\xb7\x2e\x3b\x5a\x5c\xb6\x75\xeb\x32\x2a\x2e\xdb\xca\xfa\x97\x6d\xe5\xfa\xcb\x86\x9f\x2b\xe9\xef\xc8\xd6\x91\x3d\x71\xe9\x1c\x41\x85\x8c\x89\xa6\xb4\x6f\xae\xcb\xd5\xe3\xee\xe9\x00\xf9\xa3\x31\x51\x22\x29\x3b\xb6\x7c\xe9\x9c\x16\x6d\x5f\xdb\x97\x67\x1e\x2d\xc5\x72\x2d\xb4\xa8\xed\xcb\x33\xf9\x62\x2c\xa7\xed\x1d\x2a\x2d\x7f\x69\x86\xf6\x0d\x81\x2a\x15\x47\x96\x6d\x65\x73\x5b\xe2\xda\x86\xcc\x9c\x50\x73\x4b\x9c\xb6\x67\xe6\x84\x68\x6a\xff\x05\x73\xb5\x0d\x22\xef\xe1\x6b\x80\x21\x14\x87\xc1\x4a\xa2\x61\x5b\x03\x83\x88\xc6\x6f\xe5\x8e\x6e\xdc\xb2\x92\x12\x1a\xbf\x4d\x5b\xb3\xcd\xca\xbf\x9e\xd5\xc7\x6b\xcd\x2e\x2c\x8f\x91\x4d\x57\x13\x7f\x54\x94\xc0\x95\xcc\xba\xaa\x7b\xc7\xe3\x77\x8a\xc7\xee\x0b\x1f\xb7\xc0\xd1\x5d\xdf\x71\xbb\xbc\x95\x5d\xdd\xca\x3d\x2c\x96\xea\xf9\x26\x07\x3c\xf0\xeb\x7d\x16\xf5\x98\xa7\xb0\xa2\x9e\x8c\xa7\xea\x63\xea\x30\xf4\x47\xc0\x87\x50\x05\x98\x1e\xa6\x6a\x60\x60\x18\x02\x8f\xa3\xaa\x2a\xe2\x88\xca\xa9\x65\x70\x20\xf5\xa8\x3e\x1a\x47\x75\x16\x93\x51\x34\x56\xaf\x7c\x41\x94\x4c\x26\x34\xd8\x41\x29\xfd\xa3\xa4\xfc\xbe\x40\x50\xe7\x79\x9a\xc9\xf8\x04\x32\xe9\x2e\x2e\x97\x4d\xe5\x8f\x99\x14\xd1\x79\xca\xac\x86\x53\x4e\x9b\xb1\xec\x9c\xcf\x08\x37\xfe\xe1\xf4\xa6\xf3\x26\xe5\x56\xce\x6b\x0a\x38\x42\xfe\x35\xb3\x36\xdc\x19\xaa\xdf\xf5\xf8\xfa\x1f\x6e\x5f\x35\x85\xba\x69\xe2\xde\x4d\x43\x86\x5d\x13\x57\xda\xb4\x97\xbb\xbf\xc1\xda\xba\x40\x71\xcc\xfc\xcc\x39\x4d\xb2\xb4\xe1\xc2\x74\xe7\x95\x33\xa8\x81\xf5\x6c\x74\x5a\xf8\xee\x33\x69\x29\xb7\x7c\xce\xa6\x2f\xef\x5d\xec\xb5\x9e\x44\x6c\x34\xd7\xde\x31\x7b\xa1\x09\x60\x64\x53\xcf\x93\x29\xc4\xf5\xa9\xa2\x90\x53\x0c\x3d\x7b\xdc\x9f\xa9\xde\xb4\x91\xe1\x07\xf4\xfc\xfb\x7f\xdc\xfc\xd6\xa4\x59\x5b\xba\xaf\xda\xf6\xd0\xf3\xcf\x97\x0f\xea\x41\x86\x49\x42\x71\xd3\x5e\x76\xd6\xdb\xbb\x3a\x3b\xe9\xe7\xd6\xfe\x9d\xff\xfc\x76\xf9\xeb\x66\x5d\xa6\x88\x31\x7a\x27\x8e\xce\x57\xc5\x91\x42\x07\xba\x2a\x92\x5e\x0d\xd7\x9e\xaf\x5a\x5b\x45\x73\x51\xb8\x95\x88\xe8\x0e\x44\x74\x37\x17\x9d\x41\x51\xa9\xf6\x08\xbd\x79\xf1\x5a\xbf\xd7\x39\x73\xb9\x37\xec\xed\x6c\x75\x1e\x36\x6c\x8e\x86\xee\x11\x71\x04\xbc\x5a\xb9\xd8\x6f\xe8\xf7\xa4\x6a\x7a\xe7\x0d\xfd\xb0\x58\xbe\x56\x54\x7b\x72\x47\x90\xeb\xe9\xc9\x89\xc8\xf5\xb0\x6f\x86\xbd\xcb\x67\xea\x6b\x79\x6b\xa7\xc5\x30\x4b\x1a\xfa\xbe\x4a\x2d\xd4\xf5\x7b\x3d\x33\xcf\x54\xad\x74\xf5\xad\xaa\x7a\xd4\xc8\x20\xe8\x6f\xa3\xcf\xe7\x8a\x77\x19\x72\xea\x9c\x8a\xfd\x93\xde\xcd\x86\xb8\xad\x37\x41\xef\x60\xe3\x66\xcd\x0e\x96\x92\x82\x15\x05\x9a\x69\x89\x97\xf5\x26\x2a\xb7\x41\x16\xaa\xc7\x29\x9b\x79\xae\xb8\xbe\x7f\xbd\x3c\x61\xe2\xa2\xf5\x95\x2f\xf7\x83\x15\x1e\x6b\x2a\xd6\xc6\xf5\xbd\x11\x5e\x38\xb1\x35\x5c\xbe\x70\xdf\x33\x0f\xbd\xf8\x2c\xa5\xfb\x1f\x7a\xf1\x26\xfa\x74\x1f\xd7\x11\x8b\xac\xf0\x38\x6c\xe2\xa2\xc5\xe7\x9e\xcc\xed\xeb\x5f\xbf\x7e\xd1\xc4\x09\xf2\xfa\xca\x57\x83\x67\x45\x24\xd6\xa1\x67\x6e\x9d\xb8\x30\xcc\xbe\x7a\xd3\x8b\x0f\xf5\x53\xfa\xd9\x17\x1f\x7a\x66\x9f\xf6\x95\x3e\xae\x2d\x96\xb2\x7a\x56\xd8\xc4\x05\x67\x2e\x9d\x69\xaa\x11\x30\xec\x92\x54\x61\x10\x12\x3c\x68\xc4\x0d\x78\x06\x47\x6b\xec\xba\xcc\xf6\x05\xd2\x79\xcf\x88\xab\xe6\x9e\x1f\xff\xc7\x5c\xf4\xf3\x8f\x5f\xf3\x53\x73\xc9\x0f\x19\x36\x41\x86\x65\x90\x2e\xe4\x8b\xb1\x94\x5e\x8f\x91\x5d\x49\x29\xa6\x79\x90\x51\x16\xcb\xa4\x03\xc1\x7c\x3a\x98\xef\x26\xb3\x84\x40\x30\xe0\xf9\xdf\x64\xe6\x54\x83\x8a\xb8\x7b\x7a\x57\xf7\xf6\x5c\xda\x63\xbe\x35\xd5\x69\xfd\x72\x9d\x3f\xd6\x29\x49\xc1\x4d\x72\x9d\xed\xaa\x64\x6b\x9d\x5d\x0a\x7e\xa7\xce\x4b\xc1\xd8\x84\xab\x25\x47\x9d\x6d\x87\x64\xeb\x72\x07\xed\xbb\x6d\xce\x91\xa4\x81\xcd\x7a\xd2\x58\x5b\x6d\x52\x8b\x5d\x4f\x6a\x9f\xee\x0a\xd6\xed\xb6\x39\x99\x7a\xb7\xdd\x9b\xe1\xb7\x30\x4b\xaf\xd3\xe7\xf3\x39\x7b\x2d\x6c\x0b\x9f\xf1\xda\xef\xbe\xdb\xe1\xc9\xf0\x7c\x57\x67\x25\x22\x33\x41\xe4\x37\xf3\x19\x8f\xe3\xee\x7f\x34\x7d\xe5\x2a\xa3\x61\x83\x09\xcf\xf5\xf4\xf0\xb9\x8a\x43\xdb\xf1\xb4\x4d\xa6\xfa\xf8\x84\xc9\xa7\xd6\x59\xed\x52\xf3\x26\x69\xa9\x6c\x5f\x3b\xa9\xde\x65\xfb\x92\xcd\x7f\xae\x64\xf9\x5c\xa3\xd5\xe6\x5c\x18\x68\x57\xea\xc9\x53\x57\x9b\xd4\xd2\x7c\xb5\xb4\xd4\xeb\x5c\xdb\x51\x93\xd4\x52\xe7\xee\x0d\x4c\x8e\x05\x99\xa7\x3c\xb0\xdd\xed\x6a\x6c\xb8\xa2\x81\xe7\xe6\x2c\xf7\x33\xe6\x5f\x3e\x87\xe3\x1b\xae\x68\x68\x74\xb9\xb7\xbb\x5d\x4d\x41\x3d\x82\x25\x22\xe7\xfb\x19\x9b\x33\x81\xcd\xd6\xe3\x82\x4d\x2e\x6e\xf0\x7f\x92\x6b\xc4\x6e\xc4\xe0\x85\x93\x86\xd5\xab\x5b\x34\xb8\x61\xe3\x3a\x20\x25\xa5\x64\xbb\x84\x42\x17\x6f\xa8\x08\xf2\x89\x08\x4f\x3e\x51\x6a\xe6\x83\xcd\xa2\x4e\x69\x29\x25\xa5\xa4\xc4\x78\x44\x1f\xb1\x89\x42\x17\xe5\xb2\xa9\x66\x12\xd4\xfd\xda\x77\xff\xed\xec\xa5\xd7\xde\x9b\x48\x73\x75\x32\x23\xe2\x98\xc0\x89\x24\x24\xdc\x4d\x7e\xdb\xb5\xb7\xef\xa7\xd3\xe8\x7a\x3a\x8d\x4d\xbf\xfd\x5a\x9b\xbf\xc9\x9d\x10\x48\xe4\x04\xc6\x11\x71\x3e\x7b\x3a\x71\xef\xb5\x4b\xcf\xd6\x0e\xfd\x64\x6a\xf3\x03\xd4\xba\xe1\xba\x9b\x83\x37\xde\xc3\xdd\xa6\xfd\xe5\xe0\x2d\xee\x25\xad\x56\xc9\xed\xe0\x24\x51\xe4\x25\x4e\x22\x51\xf1\x27\x5b\xeb\xe7\xfe\x72\xd3\x6d\x07\x6f\xb9\xa5\x7c\xcb\xe6\x5f\xcc\xad\x6f\x4d\xfa\x15\x91\x24\x4e\xe2\x45\x51\xe2\x9c\x6e\x92\xac\xad\x4b\xdc\x5b\xf9\xa5\x8b\x97\x0d\xde\xbc\xa0\x67\xce\xab\x23\x7c\xb7\x71\x76\x6e\x3a\xd6\x8d\xde\x36\x43\x59\x25\x1e\xcd\xe6\x73\x59\x25\x3e\x22\x09\x79\x32\x3a\x67\xa4\x8b\x98\xb9\x6c\xaa\x8b\xb2\x29\x3d\x3a\xd5\x45\x05\x9f\x31\x32\x8c\x47\x6c\x63\x3a\x92\x46\xe7\x53\x7d\x50\xea\x92\x53\x26\xdd\xac\x8f\xc0\x4c\x3a\x40\xe6\x95\x34\xfc\xa3\x0b\xd3\x5a\x7f\x5f\xb1\x2f\x54\x9f\x9c\x10\x28\xf0\x4a\x43\x7b\x62\x42\xca\x1d\x89\x38\x92\x4d\x93\x82\x93\x85\x57\x6e\xba\xa6\x24\x34\xc7\xbd\x39\x9f\x2b\xd2\xa6\x4e\xb1\x2a\xdc\x74\x7a\xec\x0b\x89\xf3\xfb\xbe\xfb\x99\x0d\x01\x6d\x40\x9f\x3f\xc9\x9b\x58\x35\x75\x4a\x7d\x50\x69\x4b\x65\x16\xdf\x3c\x7b\xf2\xbe\xd5\xbb\xcd\x3b\x6b\x98\x9a\x59\x30\xf5\x67\xd3\x56\x2c\x0f\x5d\xfd\xb9\xb6\xe0\x2c\x21\x1d\xc9\xc5\x13\xde\xb2\x2a\x4a\x2e\x8b\x87\xcd\xfb\x5a\xa8\xd9\x3d\x6f\x7e\x24\x7d\x5a\xc3\x0c\x0f\x2d\x4b\x9c\x3b\x3f\x9a\x58\x70\xaa\x3f\xb0\x6a\xc1\x6d\x0f\x9c\xd4\xd6\xda\x93\x63\x6a\xae\xa7\xfe\xa6\x9e\x5c\xc3\x35\x5b\x27\x26\x4f\xb9\x75\xe3\xf9\x9f\xde\x8d\x91\x3b\x98\x0c\x5b\xd2\x2e\x5d\xb6\xac\x99\xd1\x52\x46\x5f\x1b\xf8\xc8\x9b\x1a\x13\xc9\x29\x98\x18\x13\x82\x81\x60\x33\x0b\xea\x13\xb9\x92\x8b\xa6\xf3\x05\x7d\x45\xac\x4e\x73\x86\xd9\x68\x4a\x49\x8d\x2e\x3f\x85\x2e\xd2\xa7\x30\xc9\x3f\x82\xd2\x11\x7c\xb5\x45\x5c\xbe\x9c\x37\xde\x2c\xac\x38\x47\xbd\xe9\x15\x61\x72\x70\x52\x53\xd2\x11\x89\xb8\x53\x13\x12\xed\x0d\x0a\x5f\x08\x4c\x48\xd6\x87\xfa\x8a\x7d\xd4\x97\x5e\xa8\xee\x5e\xbd\x6f\x72\x3c\x7e\xf3\xe2\x4c\x2a\xd6\x5a\x57\x2f\x4f\x9e\xb6\x2a\xa1\xbd\x67\x20\x2d\x12\xd8\xa0\x3e\x7b\xc9\xfa\xed\x5f\xa7\xe9\x9c\x62\x9d\xc2\x9b\x87\x2c\x35\xc4\x97\x91\x67\x46\xc3\x69\xe9\x16\x25\x39\xcf\xdd\x1c\xfa\xd4\x99\xf3\x98\xc7\xe2\x92\xc4\xb2\xea\x4d\xc4\x73\x91\xb4\x30\x2b\xd8\xf6\xb9\xab\x43\xcb\x57\x4c\xfb\xd9\xd4\x05\xe9\x8b\x77\x7f\xfa\xfc\xab\x67\x9d\x76\x4a\x32\xba\xe2\xac\xb3\xfd\xe9\x05\x37\xd5\x9b\x78\x6b\x6d\x6f\xbf\xff\x16\x61\xc1\xaa\x80\xff\xd4\x05\x89\xe8\xbc\x0a\x4f\xf0\x75\xae\x68\xc8\xe4\x20\xcf\x31\xb7\xfb\x72\xc5\xf1\xb7\xf7\x0a\x03\x47\x7e\x74\xec\xf5\xbc\xb5\x63\x53\x45\x18\x27\x03\x94\xed\xe0\x0c\x49\x5d\x47\x64\xcc\xc9\xf9\x7d\xba\x4c\x54\xa8\xf0\x99\xe3\xee\x4c\x16\xd5\xb6\x53\xfb\x96\xad\xde\xbc\x6a\x6e\xbd\xb7\xcb\x5b\x3f\x77\xd5\xe6\xd5\xcb\xfa\x4e\x6d\xfb\x2e\x3b\x8d\xcd\xda\xaf\xbe\x55\xbe\xd3\x7b\x82\xfb\x94\xb9\xc7\xce\xb8\x76\x5e\x87\x3b\xb3\xe0\xd4\x70\x20\x10\x3e\x75\x41\xc6\xdd\x31\xef\xda\x33\xf6\x7c\xb7\xfc\x32\x9b\xb4\x7f\xcf\x6f\xdf\x2a\xef\xf1\x1e\xef\xba\xe5\x51\x3b\xd5\x88\x00\xb4\xea\xfc\x5c\xd2\x17\x70\xb2\x5a\x5e\xc3\x5f\x09\xa8\xd8\x69\x4e\x65\xcd\xdc\xc8\x8e\xd9\x48\x32\x73\x87\x8c\xa9\x8c\x04\x97\x43\x33\xac\x34\xa9\xe8\x90\x2b\xde\x99\xcb\x97\xcf\xa4\x08\xf9\x44\x8f\x68\xe3\xb9\x7e\xb9\x3c\x20\x67\x15\x63\xef\x27\x44\x25\x25\x2b\xb3\x48\x1f\x1f\xf1\x87\x1c\xa6\x61\xba\xec\x30\x3c\xcb\x67\x96\x8b\x33\x97\x33\x5e\xaa\x63\xe9\xac\x9e\x45\x09\x51\xa4\x72\xc7\x41\x24\xa4\xc8\xe5\x81\xea\x39\x60\x93\xd7\x75\x21\x89\x1c\x50\xc8\x78\xe2\x85\x0e\x32\x56\x6d\x73\x57\xc0\xa3\xf3\x5a\x52\x26\x17\x0f\x70\x19\x8f\xb9\x10\xfb\xc7\xb3\xa1\xef\xfe\xf9\xcf\x1f\xd0\xec\x0d\xf3\xe6\x9c\x4c\xd3\xe6\xb2\x79\x7f\xde\xb9\x79\xdb\x3c\xf6\x67\x8e\xfb\xb3\xe4\x9a\xde\xbe\x81\x0e\xd4\xb2\x9e\x5b\xd8\xb7\x5f\xcd\xce\x9a\x95\xcd\x9c\x76\xda\xd0\xd7\xe8\xf6\x7b\xef\xdf\xb8\x6a\x66\x79\x3b\x6d\x55\xbc\xf1\x29\x5f\x61\x57\xd5\x72\x9b\x86\xee\xdb\xb8\x33\xa5\x0e\x1d\x3a\x65\x19\xec\x84\xc7\xe0\x27\x74\x00\x38\x27\xb5\x51\x2c\xc5\x19\x12\x50\x3e\xe3\xa9\x08\x77\xba\xc4\xe7\x49\x07\x68\xc0\x1b\xf6\x7a\xc3\x5e\xd6\xaf\x84\xb4\xb3\x32\xcc\x63\xa7\x46\xa1\x57\x5b\x1b\x52\xbe\xf2\xe9\x91\xab\x17\xb3\x9f\xfe\x0a\xeb\x27\xc3\xb4\xc3\xb8\x97\x4c\x7b\x3c\xa4\x68\x4d\x76\x4f\x23\xbd\xa5\x84\x3e\xf3\x23\x06\x53\xce\xd3\xf0\xa3\x11\xf9\xcb\xf8\x3f\x83\xc7\xbb\xff\xb7\xc9\xbc\xdf\xb7\xd6\xd0\x7f\xe4\x16\xc6\xe3\xed\xfb\x8d\x9a\xe4\x32\x03\x80\x72\x71\xc4\xfe\xd8\xb8\x1e\x4d\x55\xb2\xf2\xbe\xf2\x06\x73\xfb\x8f\x6d\xdf\x27\x9b\xa6\x8a\xac\x4f\x2b\x55\x0d\x71\x8d\x84\x55\x23\x5c\xe3\x42\x46\xee\x4c\x0d\x21\xc5\xc8\x67\xec\x02\xea\xf9\xb2\x8a\x52\x73\xc7\x54\xd0\xf8\x5f\xc2\xc7\xa7\x41\xeb\x48\x9b\xb2\x4a\x17\xab\x9e\x56\x88\x47\x27\x32\x9d\xf9\x34\x83\x02\xfc\xf1\x48\x90\xae\xda\xbb\x49\x2b\x55\x68\x96\x8c\x96\x68\x03\x15\x9a\xad\x84\x6d\xda\xab\x8b\x5f\xc7\x23\x45\xca\x94\x8b\x35\x94\xcb\x4a\x26\xe5\x5a\x4c\xb2\x1e\x91\xf7\x55\x88\x70\x60\x1e\x40\x4a\x2e\xea\xf7\x05\x92\xb9\xa8\x4f\xea\xa2\x82\xdf\x67\xae\x60\x64\x6c\xfc\x54\xfb\xc1\xdc\x23\x31\x66\xe5\x94\x92\xea\xa8\x28\x96\x72\x35\x52\x31\xfd\x74\xfe\x30\x9e\xe1\x7f\x30\x8c\xf9\x5f\x78\x46\x3d\xeb\x0b\x2f\x5e\x31\x31\xa7\x34\xcd\x38\xb5\x67\xa3\xd7\x39\x54\x72\x7a\x37\xf6\x9c\x3a\xa3\x49\xc9\x4d\xbc\xe2\xc5\x2f\x9c\xd5\xd9\x4a\x91\xe5\x33\x59\x71\xe6\x72\x8a\xb4\x76\xb2\x2f\x3c\xf8\x8b\xbe\x85\x7b\x3e\xe8\xfb\xc5\x83\x4d\x7b\x5e\x52\xe7\xec\xd8\x70\xba\x90\x9f\x10\x5b\x90\xc9\xcf\x3f\xef\x34\xf3\x86\x99\xd3\xce\x9b\x9f\xcf\x2c\x88\x4d\xc8\x0b\xa7\x6f\xd8\x31\x47\x6d\xed\x34\x75\x98\x9d\xe6\x3f\xd4\x1b\x39\xb3\xa0\x4b\x36\x2d\x48\xa1\x1d\x69\xdc\x88\x3b\x01\xca\xa7\x14\x49\x0c\x06\xcc\x77\x21\x9f\xaa\xf8\x83\x79\x25\xa5\x18\x5f\xc3\xdf\x4c\xd9\x78\xcc\x57\xd0\x43\xf2\x94\x45\x04\x7e\x9f\x37\x18\xd0\x65\x09\x27\xeb\x20\xa3\xc1\xc6\x8a\x1c\x6c\x26\xe3\x02\x2a\xbd\xff\x0a\x4a\x21\x1f\x68\xd1\x25\xf2\x2e\x16\x0c\xe8\x6b\x8f\x93\x93\xcc\xa3\xda\x81\x42\xde\x3b\x9e\x9e\x99\xc4\x4b\x56\x81\x97\xac\x41\x41\x12\x45\x49\x10\x27\x31\x49\x22\x4e\xb2\x04\x18\x71\xa2\x45\x10\xcf\x63\x75\x56\x9e\xd5\x59\x3b\xec\xb6\x19\x2c\xc0\x98\x8f\x7d\xd6\x3c\xeb\xf0\xc3\x7b\xbd\x1e\x12\xe5\x6c\x7b\x9b\x25\x18\x63\x42\x1d\x57\xe7\x14\xbd\x13\xed\xee\xb6\xf6\x88\x53\x0a\x4d\x99\x3f\x37\x95\xab\x6f\x92\xe7\x34\x84\xa6\x6e\x9f\x5a\x17\xef\x95\x9b\xea\x73\xe1\xb6\xe2\x0c\x25\x4e\x1e\xef\xbd\x3f\x24\xd4\xce\x17\xb4\x48\x94\x24\x41\x94\xa4\x0e\x89\xe3\x2d\x16\x8e\x9f\xc2\xf3\x8c\x17\x38\x26\x93\xc4\x24\x8b\x24\xce\x91\x78\x4e\x92\x78\x8e\x77\xbb\x5d\x12\x2f\x59\x78\x3a\xcd\x38\x1a\x72\xe0\x6b\xda\xdf\xb2\x9c\xdb\x9e\x6d\x23\x8e\xac\x2d\xa1\x69\x2e\x12\xea\x2c\x12\xdf\x18\x08\x87\x25\x71\x52\x40\x6c\xc8\x7d\x7a\xf6\xe9\x53\xbb\xe6\x8b\x8d\x6e\xb7\xe7\xff\xe3\xed\x4d\xe0\xe3\x28\xce\xbc\xe1\x7a\xaa\xfa\x98\xab\x7b\x66\xba\xe7\xd2\x68\x34\x9a\xd1\x68\x0e\xdd\xf6\x9c\x92\x75\x8d\xe5\xdb\x92\x6d\xf9\xc4\x60\x63\x0b\x5f\x18\x71\xd9\x80\x31\x87\x8f\x0e\x38\x80\x6d\xc2\xe5\x60\x1c\x12\x62\x41\x48\x80\x10\x36\x84\x6c\x0e\x12\x93\xcc\x26\x84\xe4\x5d\x02\xc1\x2c\x6c\x2e\x92\x15\x49\x36\x4b\x12\x48\x78\x93\x25\x09\x96\xa6\xf5\xfd\xba\x7a\x2e\x8d\x65\x4c\xf6\x7b\xdf\xd7\xd6\x74\x57\x57\x57\x75\xd7\xd5\x55\x4f\x3d\xc7\xff\xb1\xf3\x2e\x3f\xb7\xb4\x6f\xce\x8a\xae\x0b\x52\x8d\x36\xa6\x3e\x1b\xdb\x82\x2d\x36\x92\x04\x33\xbe\xbd\x72\x4e\x2a\x62\x27\xe4\x68\xdf\xd1\x79\xe0\x83\xf1\xfb\x28\xd0\x66\x3a\xa3\x0d\x37\x5d\xbe\xae\xdf\x0a\x36\x44\x23\x05\x16\xdc\xb9\x10\xfc\x9e\x74\x6e\xed\x05\xd4\xbb\xd5\x09\x4f\x52\x10\xbf\xe6\x29\xa4\xeb\xa9\x4e\xa1\x66\xbb\xbd\x1e\x72\x52\x5a\x82\x5c\x7d\xe4\x1c\x20\x7e\x9d\x8b\x17\x77\x76\xe2\x91\x58\xf1\x33\x8d\x45\xfd\x90\x93\x65\x35\xeb\x2f\xad\xb3\xec\x14\xab\xa0\xd9\x68\xab\xb6\xce\x52\xd3\x64\x8d\x1e\xa4\x62\x60\x6a\x96\x2f\x82\xf6\x55\x61\x27\x55\xe9\x70\x14\x0d\xc3\x35\x02\x46\xca\x38\xb0\x0e\xf4\xa3\xa7\xa5\x19\x75\x1e\x9b\xae\x31\xa8\xa7\xa5\x43\xcb\x8f\xdd\x7e\x60\x0f\x8a\x66\x8b\xc9\x60\x32\x31\x46\x79\xb9\xa3\xe7\xad\xee\x96\x4b\xe7\x75\x1e\x9e\x3b\x72\x70\x76\x8d\xcb\xe3\xf2\x5c\x52\xd3\xf5\x66\xd7\x57\x2e\xfd\xc8\xeb\x7b\x95\x3b\x27\x3f\xb9\xef\x5f\xbb\x7e\xd5\xe9\xb9\xa4\x66\xc9\x76\x57\x4d\xe3\x12\x65\xdd\xf2\x07\xbf\x73\x53\xcf\x7f\xcd\x91\x87\x1c\x2b\x97\x9a\x18\x62\xc1\x36\x09\xbf\xd0\x7a\xb4\xd6\xef\x6b\xf3\xba\x37\xb8\xc2\x12\x18\x67\xb9\x3d\xae\xf4\xec\x25\xbf\xfb\xd3\x47\x62\x63\x4d\xee\x0b\x5a\xeb\x5c\xf5\x8d\x6d\x3f\x06\xc7\xd1\xcf\xaa\xdf\x9c\xc8\xb4\xd6\xd5\x5d\xbd\xc4\xb3\xde\x1d\x7b\xb8\xe9\xea\xd7\x5f\xfe\xea\xdc\xee\xde\xe5\xb3\x4c\xdb\xd7\xb8\x2f\x72\x0b\x1e\x63\x80\x89\x3d\x54\xa9\x0b\xb1\x02\x21\x8d\xe4\xd7\x41\xb2\x28\xf1\x86\xb4\xcf\x89\x29\x80\x17\x51\x6c\x59\xad\x4e\x58\x9b\x76\x0a\xd5\x73\xfb\x89\x0e\x9d\xa5\x05\xb1\xdb\xe5\x76\xb1\x8a\xc3\xec\xdc\xbe\x69\x63\x6d\xb2\xbf\x7e\xd8\xb8\x65\xd9\x41\xf5\x8f\x2b\x66\x85\x88\xdf\x2c\xf1\x89\xce\x78\xcd\x05\xb5\x22\x2f\x85\xcc\x91\x80\x95\xd4\x89\x5d\xf3\xba\x4c\xbc\x13\x86\x9e\x3f\x8c\x1b\xc4\x5a\xa3\xd4\x19\xef\x71\x88\x75\xcd\x4c\x4d\xd7\x42\x79\x21\x47\x20\x56\x7b\x41\x4d\xbc\x33\xc1\x4b\x66\x3f\x09\xcd\x5a\x01\xd2\xc1\x65\x5b\x8c\xc3\xf5\xfd\xc9\xda\x8d\x9b\xb6\x3b\xcd\x0e\xc2\x2d\x94\x17\x76\xd5\x30\xcd\x75\xa2\xa3\x27\xde\x29\x19\x6b\xc5\x06\x7c\xf8\xf9\x21\x70\xf2\xa6\xae\x79\x5d\x62\x1d\xb1\x06\x22\xe6\x90\xc4\x17\xd7\xb0\x12\x86\x2c\x3a\x9f\x61\x1a\x33\x52\xb6\x0f\xd9\xf4\xcb\xb2\x09\xc9\xde\x27\x58\x54\x5c\x77\xb4\x7b\x63\xe5\x1b\xfa\xba\xad\x63\x98\x70\x3a\x9e\xa1\x1d\x32\x6e\x90\x3f\x10\xcc\x44\x99\x44\xf0\xd8\x85\x17\xc2\x63\x96\x73\xa2\x9a\xa0\x89\x08\x1c\x5f\xbb\x56\x1d\x65\x2f\xfa\x60\x7c\x93\x32\x8f\x6d\x11\xba\x80\xd2\x90\x4c\xb4\x1d\xeb\xc2\xff\x76\x1c\x6d\x87\x92\x02\x80\x16\x64\x43\x0d\x3a\x16\x34\xe3\x76\x21\xb7\x9f\xa5\x80\x7d\x67\x33\xda\x98\xc0\xec\xf6\x36\x8e\xf5\xb9\x4c\xd6\x96\xc6\x26\x81\x97\x2d\x2e\xb2\xf5\xae\x4e\x2c\x70\x7c\xd3\xec\x26\x93\x83\x10\x8f\xb7\xd6\x6d\x32\xcf\x4a\xb5\xcf\x67\x59\x81\x97\x70\x0f\x74\x3d\xca\xcd\x92\x9a\x6a\x1a\x6d\x5d\xc7\x9c\xae\xaa\x69\xed\x02\xb3\xc9\x5d\xeb\xf5\x10\xe2\x30\x35\xcd\x6e\xe2\x39\x01\x67\xee\xde\x4a\x5c\x16\x99\x17\x9a\x1a\x5b\xac\x26\x97\x8f\xe5\xda\xda\x67\x07\x18\x97\xf3\x58\x97\xad\xb1\xa6\x49\x9a\xc5\x3d\xaa\x7e\xbf\x07\x4b\xbc\xc0\xb2\xf3\xdb\x53\xa4\xab\x72\x5e\x02\xd4\x8a\x10\xb7\x86\x45\x54\x1e\x4f\x39\x19\x58\x04\x46\xdf\xa9\x66\xda\xa1\x70\xea\x05\x97\x9b\xca\xbe\x5d\x8c\xbb\x80\xaf\x95\xce\x70\x7c\x9a\x5b\x33\x6f\x33\x0c\x7d\xf2\xdf\xd5\x57\xbf\xa0\xfe\xef\x37\x43\x2d\x6f\x3e\x7d\xd9\xe7\xea\x83\xbe\x96\xe6\x5d\xc7\xe6\x2f\x1f\x58\xde\x7a\x23\x6c\x78\xc1\xf0\xdc\x6d\x77\x8e\x5c\x39\x12\xbe\xec\x62\x66\xe7\x96\x05\xa2\xef\x16\x35\xff\xc7\xaf\x5d\x79\x2f\x73\x04\xef\xbf\x84\x35\xbb\xbf\xb4\x87\x89\x90\xd6\xbb\x56\xaf\x1f\xbc\xff\xcb\xa6\x48\xe3\x6d\xcf\xed\x70\x76\x5d\xdb\x6f\xa2\xfb\x83\xcd\x53\x0a\xf9\x36\x87\x74\xfe\x37\xe5\x10\x06\x49\xc8\x1e\xb4\x87\xec\xba\xac\x8d\x7c\xfb\xa1\x75\x3d\x10\x8e\xaa\xea\xcb\x53\x68\xea\x95\xa7\x8e\xb1\xff\xad\xfe\x7d\xf1\xe2\xe7\xd4\x9f\xe4\x8d\xf8\x6f\x10\xfb\xd9\x37\x5e\xd2\x6d\x9d\xa7\x1e\xa3\xfd\xba\x06\x6d\x44\xdb\xd0\xe5\xe8\x5a\x74\x13\xba\x05\xdd\xa1\x6b\xd9\x38\x1d\x88\xe7\xf4\xa9\x28\xda\xc7\x68\xbb\xb5\x68\x84\xb3\x42\xa4\x81\x6f\xc7\x3c\xe7\xd6\xa6\x22\xe2\xd6\xc8\x84\x86\x48\xb4\x1d\x3a\xa0\x81\xf3\x43\x3d\xd0\x1f\xe9\x07\x3a\xc9\x45\x23\x28\x95\x94\xe4\xd2\x92\x5b\x79\x9e\x76\xa9\x2d\xcd\x49\xbe\xc1\xe9\xc8\xc4\x33\xda\xbd\xa2\xe2\x8e\xfa\xf3\xb7\x6a\xbd\x90\xec\xda\x70\xc9\xdc\xa6\x15\xe1\x36\xdf\x68\x34\x72\xf1\x0b\x17\xdb\x52\xd7\xf8\xda\xc2\x2b\x9a\xb2\x97\x6c\xe8\x8a\x9a\x9c\xb3\x06\xe6\xba\xe5\x6e\x87\xc3\x69\xe3\x2c\x3c\xef\x6a\x31\x99\x84\xbe\xc5\xf3\x5c\x6e\xf0\xd6\xbe\xa5\xfe\xfc\xe5\xb5\xc4\x64\x22\xc4\x64\x0c\xf1\x46\x13\xc7\x1b\x4d\x8d\x46\xa3\xc1\x68\x94\xe2\x06\x8b\xc5\x60\x14\x2c\x73\x89\xcd\x6a\xb0\x5b\xe7\xd9\x6d\x76\xdb\x1c\x6c\xb3\x31\x01\xaa\x09\x74\x7a\x42\xbd\x7a\x19\xeb\x91\xc8\xb1\xde\x4b\xda\x38\x4f\x7a\xc5\xad\x6b\xf7\x5e\xb0\x61\xb7\x31\xe6\xf1\x78\xbd\xe6\x40\x9b\x71\xf7\x86\x0b\xf6\xae\xbd\x65\x38\xed\xe1\x1a\xe7\x99\x4c\x2d\x4d\x81\x18\x43\x8c\xa2\xc8\xb2\xa6\x4e\xb7\x3b\xd2\x21\x00\xc3\x44\xb6\x33\x92\x87\x5d\x06\xf7\x4e\x9c\x86\x4b\x26\x0f\xf2\x2c\x61\x79\x96\xf3\xb2\x66\x23\xc7\x9a\x4d\x11\xde\x22\xf0\xac\xb7\xd1\x60\xb6\x18\x0d\x66\x8b\xcd\xcc\x32\x2e\x86\xe3\x05\x6c\x16\xb0\xd3\x8c\x89\xc7\x30\x4d\xd6\x11\x9e\x86\x4c\x1d\xd1\x3a\x3d\x31\x1d\xaf\x47\xa3\xc6\x50\x00\x71\x4a\xc4\x9b\xf5\x46\x8e\xbf\x76\x7c\xa4\xec\x64\x00\x8f\xe9\x98\x3b\x24\x57\xb4\x35\x18\x3d\x7e\x7c\x34\xd7\x19\xab\x40\x3d\x7c\x16\x78\xf5\xfd\x12\x76\xba\x3e\xa7\xd5\x14\x70\xc8\x50\x15\x36\x50\xc2\x49\x47\x5d\x2a\x19\x09\xd9\xa9\x3d\x84\x36\xe9\x65\x52\x41\x67\x22\x15\x74\x72\xe3\xda\x3c\xa6\x1b\xd9\x0a\x32\xa7\xc8\x82\x20\xbf\xaf\xc8\xc2\x08\x20\x05\x14\x56\xd9\x34\x50\x36\xab\x55\x64\x61\x7c\x5c\x90\x27\x90\x2c\xe0\x91\xfc\x98\x20\x2b\xda\x3f\x5d\x27\x86\x2d\xfa\x4b\xea\xad\xb0\x00\x76\xe9\x4c\x4e\x6d\x19\xa1\x5c\xcd\x4c\xba\x1b\x5c\x8c\xdb\x25\xb1\xa5\x3b\x18\x35\x96\xef\x59\x28\x0e\xbd\x6e\x10\x8c\x77\x61\x59\xaa\xbb\xbd\xa6\x11\xbb\xd4\x6f\xfe\x67\x4d\xd0\x69\xf7\xb2\x63\xd0\xb8\xfb\x9a\xdb\xb1\x80\x1d\x92\xef\x6e\x6f\x18\x2c\xcf\xa8\xbf\x56\xf7\xff\xb8\x26\xe4\x90\xbc\x04\x38\xf8\x8f\x6f\x7c\xf3\xdf\x41\xb7\x12\x56\xbf\xe7\x73\x38\x83\x35\xff\x09\x0b\x5c\xb8\xb1\xe6\xf6\x3a\xc9\x2e\xdc\x7e\xcd\x6e\xf5\x8d\x47\x6a\x1d\x8e\x50\xcd\x8f\xe1\x56\xa8\x7b\x46\x80\x70\xcd\xdd\x3e\x49\x12\xfe\xfd\x9b\xdf\x50\x83\x05\x3b\x53\x54\x90\xad\xd5\xa3\x26\x8d\xc2\x41\x55\xf2\x35\x77\xb5\x6f\x99\x60\x11\x7e\x19\x66\x44\xab\x65\x6c\x1d\x03\x1d\x1d\x03\xd0\x41\x4f\x27\x2b\x0d\x96\x27\xe2\xcc\xa7\x1e\x62\x3c\xe2\xe4\x9f\x45\x0f\xc3\x7c\x49\x6f\x69\xdb\xf7\xec\x1b\x33\x44\xcc\x6c\xb4\x7f\xcf\x06\x97\x0c\xe8\xd9\xb4\xbf\x77\xa1\x8c\x98\x05\xef\xc0\xaf\x04\xbb\x5d\xc8\x1f\x28\x6c\x91\xb3\x35\x71\xbc\x29\x35\x30\x90\xca\x3f\x12\xa7\x6b\xc0\xad\x94\x8f\xd0\x8e\x92\x74\x34\x68\xbb\x42\x07\x17\x42\x61\x11\x5c\x6e\x11\xfc\xd8\x2d\x82\xb6\xae\xa7\x33\x25\xb4\xf3\x80\x36\x68\x88\x1d\xb1\x76\x86\x53\x52\x83\x83\xa9\xa1\xa4\xba\x59\xdd\x33\x67\x80\x89\x38\x38\x69\x76\x47\xa4\xee\xb3\x5f\x68\xe7\xdb\xe4\x5a\x62\xb2\xdf\x44\xdf\x39\x0e\x5f\x86\x97\x92\x43\x8a\x7a\xbd\x7a\x04\x6e\x24\x0a\xe5\xfb\x26\x87\x60\x43\x50\xde\x74\x79\x34\x38\x37\xd1\xdd\xe4\x9f\x13\xaf\x6d\x76\x7f\xa4\xe7\xfa\x35\xbb\xd3\x9b\x06\x72\x03\x9b\x40\x19\x4a\x4e\x36\x92\x6f\xa8\xaf\x36\xa9\x7f\x6e\xa6\x7c\xa7\xec\x14\xe2\x72\x1c\x42\x66\x54\x83\xe6\x22\xc4\x24\x29\x4d\xd5\xa0\xed\x67\x20\x88\xec\xc9\x76\xdc\x20\x62\xa7\x8d\x6e\x6c\xa8\x83\x02\xad\x89\xb5\x39\x4e\xca\xe8\xa8\x9e\x4e\x07\xef\x92\xb4\x09\x8e\xdc\x63\xeb\x5e\x1b\xb8\x74\x49\xfe\x7a\xd6\xa1\xfe\x75\xd6\x45\x9f\xf8\xc6\x27\x2e\x9a\xc5\xe4\x86\x92\x6a\xf6\xf8\x6b\xc7\xd5\x6c\x72\x28\xbe\x6a\x7d\x6f\xf4\xf7\xdf\x32\x74\x0e\x77\x1a\xbe\xf5\xfb\x68\xef\xfa\x55\x4f\x07\xd6\x76\xdb\x6c\x4b\x2e\x85\x59\xd0\x8a\x1d\x89\x2b\xb6\xf4\xf7\x6f\xb9\x22\x91\x7f\x5b\x7d\x2d\x39\xa4\x7d\x75\x43\xc9\xe6\x8d\xc7\x3e\xff\xe7\xa3\x27\x80\xf5\xc9\x0e\xed\xf3\x73\xc8\x3e\x75\xe2\xc4\xd1\x3f\x7f\xfe\xd8\x46\xfa\xcd\xe3\x29\x85\x55\xd9\xfd\x74\x6f\xe6\x76\xf1\x9c\x95\x1e\x3b\x40\xa7\xa2\xb4\x73\x34\xa2\x1f\xfb\x29\x0b\x55\x3b\x66\xd2\xfa\xb1\x9e\xa2\x3e\x6a\x47\xb7\x4b\x3f\x6a\xb9\xdd\x2e\x9e\x1d\x39\xe2\x37\x59\x62\xa7\x52\x96\xfa\xba\xa6\x6f\xcc\x32\x35\x59\xf8\x7a\xc7\xed\xb7\xfb\x9a\x9b\x4c\xb3\xbe\xd1\x54\x57\x6f\x49\x9d\x8a\x59\x4c\xfe\x23\x55\xa9\x9a\xea\x6e\xbf\xbd\xae\x69\x7a\x1a\xac\x54\x65\xc3\x2e\x2d\x9b\xb9\xa9\x9c\xad\xd9\x37\xfd\xd1\x4d\x26\x4b\xfd\xd1\xa3\x7e\xb3\x69\x5a\x9a\x92\x4f\x32\xed\x3b\x4f\xa1\x9d\xd5\xfc\x54\xaa\x55\x18\x6a\xe0\x39\xbe\x20\xdd\xb0\x6b\x34\x61\x62\x1a\x3f\xb5\xc8\x22\xe4\x0a\x0c\xd5\x82\x25\x6f\x91\xd6\xe8\x63\x35\x3a\x93\xd1\xa5\x3e\xc1\x12\x37\x95\xfd\xdc\xf2\x78\x3e\xe7\x6f\xf4\x5f\xb8\xc8\x33\xe0\x11\x62\x8b\x17\xf9\x17\x2c\x0a\x04\x16\x7f\xeb\x7b\x2b\x9f\x2b\x70\x51\x61\x30\x39\xa4\x3c\x70\xd9\x13\x4c\x90\x72\x52\x3f\xfa\xdc\xa3\xdd\x05\x36\x6a\xc0\xe4\xf6\x38\x6b\x45\x0f\x9e\x1b\x12\x62\x0d\x1d\xfd\x91\xfd\x9f\x71\xc1\xf5\x95\xcc\x54\x47\x57\x6a\x75\xcb\xbc\xde\xa3\xad\xce\xec\xca\x95\x35\x5d\x79\x25\x9b\xad\x64\xa2\x0e\xa5\x2e\x3b\xd1\xd7\xa5\x73\x50\x17\x74\xeb\x8c\x40\xa3\x6c\xf7\x59\x7d\x64\x69\xc6\xb9\xaa\x2f\x1b\xba\xed\xa6\xf9\x3d\x27\x50\x45\xfb\xa4\x50\x2f\xda\x8d\x50\x38\x61\xd7\x71\x89\xe8\xff\x76\x86\x0a\xee\xfc\xd8\x49\x9d\xb5\xb9\x12\x41\x8d\xf4\x72\x73\x0e\x97\x5b\x57\xdb\xec\x83\xaa\x6d\x14\xdd\x65\xf4\x83\x2e\x88\xd1\xb7\x1a\x89\xa0\x4e\xba\xf8\x89\x46\x8a\x73\x94\x3e\x1b\x09\x04\x42\x73\x7b\x62\x75\x06\x66\x71\x4c\xf4\x80\x2c\xb9\x9c\x86\x45\x17\xfa\x1b\xfd\xf9\x5c\x7c\xf9\x50\x12\x06\x75\xce\x2a\x73\xc9\x05\x6b\x5e\xf8\x16\xec\xd4\xb7\x5a\x83\x29\x75\xbc\xfb\xd1\x6f\x1d\xbc\xeb\x69\x80\x5e\x12\x64\x9e\xb8\xec\x81\x13\x3b\xe1\x7a\xd7\x67\xf6\x47\xfa\x3b\x1a\x62\x42\x68\x2e\xf6\x88\xb5\x4e\x8f\xdb\x04\x81\xd4\xa0\x82\x15\x4f\xbc\x39\x68\x64\x57\x66\x5d\xed\x24\x1a\x8c\xb8\x7b\xe7\xb5\xac\x4e\x75\x39\x96\x25\x92\x43\x94\xb1\x1a\x58\xba\xc4\xe6\x09\xac\x5d\x95\xcd\x46\x0a\x0d\x9b\x57\x52\x83\xdd\x0b\x3e\x79\x27\x3b\xb4\xc3\xe5\xec\xea\x3b\x71\xd9\xa5\x27\x7a\xe6\xdf\x74\x5b\x28\xdb\xb7\xca\x99\x59\x4a\x7c\x56\x9f\x5d\x36\x0e\xa2\x4a\xfc\xff\xc2\xb8\x62\x8a\xcd\x90\x0c\x35\xf0\xed\xd0\x40\x65\xc4\xbc\x5d\x97\x7c\xda\x29\x7c\xaf\xee\xed\x8e\xfe\xa7\x4b\x1b\x65\xd4\x73\x15\xab\x5e\x3b\x5b\xd8\xb9\xa4\x75\x5f\x81\x94\x39\xe2\x72\x53\xaa\xaf\xb8\xed\xfc\xdc\xb4\x6e\x4e\x9e\x35\x12\xb0\x92\xcd\x2a\x5a\x97\xe7\x67\xee\xf2\x4b\xcb\x03\xe3\x22\xdd\x95\x61\x4f\xe5\x78\x3c\xd7\xa0\x5d\xf7\x21\x46\x67\x69\x28\x4f\x6b\x9f\x24\xea\x41\xbb\x28\x55\x0f\x54\x09\x80\xf2\x7e\xb4\xff\x22\xa3\x8f\x20\x9c\xb0\xd3\xcd\x6a\xca\xae\xd1\xbc\xae\x78\x3a\xa3\x5d\xe1\x12\xea\x04\xd7\x41\xf7\x1e\x1c\x4f\xe5\xac\x91\x94\xbd\x08\x58\x4b\xb5\xbf\x2a\xac\x48\xb5\x5d\x5c\x36\x9b\xff\x80\x5e\x6f\xef\x2a\x77\xba\x52\xd8\xc5\x17\x3a\x3b\x3d\x57\xeb\xec\xf4\xd2\x1b\x6f\xaf\xea\x6c\xfa\xed\x74\x2f\xc0\xd9\x35\x2f\x7c\x6b\xf1\xf9\x46\x6d\x48\x1f\xb4\xa4\x97\x36\x6d\x7e\xbe\x3e\x52\xfd\xfc\x07\x8f\xd4\xc2\xb8\x9e\xbe\x17\xaa\xa7\x54\x11\xb5\xc7\xcc\xa4\x0b\xa6\x87\x3c\xe7\xa8\x07\x70\xc5\xfb\x41\x8b\xa9\xb2\xcf\x64\x51\xc4\xab\x9a\x9e\x93\xe5\x0d\x52\x5a\x52\x8f\x6f\x90\xa4\x0d\x30\x2a\xa5\xa5\x0d\x92\xf4\x1c\xfc\xd5\x1b\x01\x34\x93\xc5\xe6\x73\xba\xa1\xa2\x96\x3e\x2d\x6d\x50\x8f\x4b\x92\x16\x78\xee\x83\x6d\x38\x69\xd9\x50\xb2\x03\x80\xda\x42\x3a\xea\xa1\x64\x33\x4a\x8b\xe8\x8a\x67\x20\x53\x69\x71\xc8\xb2\xf4\xd9\x7a\x61\x54\x13\xa5\x10\xff\x5a\x28\x2a\x8c\x6e\x00\xa1\xba\x68\xdb\xd3\xb4\xf4\x85\xc2\x78\xcb\x05\x85\xd1\x0d\xea\x39\xed\x34\x0b\xe5\x8a\xea\x36\x9a\xa0\x17\xa5\x1f\x4a\x56\xb5\xd4\x39\x43\xe3\x74\x7b\xcd\xb3\x6a\x5e\x7a\x19\x88\xd5\xa5\xda\x41\x4b\x2b\x9d\xa3\x2e\xf9\xf3\x95\xab\x83\x36\x57\x49\x39\x54\x37\x24\x75\xb8\x81\x16\x6b\x1a\x06\x0a\xcb\xcc\x58\x73\x89\xb6\xca\xd9\xe5\xda\x56\xee\xe5\x19\xc6\x00\x9a\xfa\x20\x3b\x38\x33\xfc\x04\x7b\xaa\xec\x1e\x44\xe0\xe3\x3a\xba\x73\x26\xed\x8e\xa4\x33\x7d\xd0\x0f\x5c\x24\xea\xe0\x93\x11\x2e\x5a\xdc\x92\x37\x88\x10\x8a\x88\x98\x17\x81\xd7\x76\x5a\xe9\x48\x34\x41\x6f\xf1\x9c\x1f\x9c\x2e\x6d\x79\xd0\x6e\x71\x2e\xb7\x4b\xc4\x56\x2d\x7b\x24\x1a\xe1\xb5\x9f\x96\xba\x0f\x52\xe9\x4c\x1f\x0e\xb9\xa8\xde\xbf\x1f\x12\xae\x74\xd4\x45\x53\x70\xee\x88\x08\xda\x1b\x1a\xb4\x47\xa6\xb5\x07\x52\xea\xcf\xc5\x6b\x33\x87\x8b\xd7\xf6\xc6\xda\x66\x30\xa2\x11\x23\x54\x05\x87\xd7\x1f\xe2\xce\xb8\xdc\x11\x9e\xe3\x5d\x7c\x3b\x8e\x6a\x4b\xba\xcb\xed\xc7\x19\x17\x9f\xa6\xd4\x89\x56\x2e\x57\xa6\x81\x73\xf0\x6e\xce\x95\xe1\x0a\x4c\x21\x70\x73\x2e\xbe\x81\x0b\x51\x3e\x50\x26\xad\x03\x59\xc7\xfd\x98\xe7\xe8\xdd\x50\xdc\xa5\x73\x8b\x28\xde\x5f\x3c\x4d\x5d\x51\x65\xf4\x7b\xda\x46\xdc\x95\x49\xa7\xb8\x68\xb2\x1d\xa7\x13\xf1\x34\xcd\xab\xb5\x12\xe7\x6c\x88\xf6\x41\xa6\x8f\x44\x28\x3f\x8e\xe7\xb4\x3b\xda\x74\x4f\x63\xc1\x45\x95\x24\x42\xae\xb4\xb6\x27\x8d\x64\x5c\x19\xfa\xf2\x74\x86\x2e\x0c\x7d\x10\xe9\x80\x64\x2a\xda\x0e\xba\x94\x36\x1a\xcf\x34\xb4\x43\x28\xad\x65\x75\x65\xf4\x53\x3a\x49\x3b\x24\x1d\xa2\xec\xe6\x48\x34\xad\x9d\x23\x24\x4d\xd5\xdf\xa3\xe9\x02\xee\x23\x2f\x12\x77\x24\xda\x8e\x29\xba\x65\x24\x1d\x8d\x88\x8c\x16\x6a\x87\x94\x9f\x52\x7b\x3c\xe7\x76\x70\x6e\x47\xb5\x05\x0b\x99\x8f\xad\x1c\x66\x59\xe0\x6c\x62\xa4\xc1\x8e\xdd\x84\x78\x08\xb6\x98\x81\x33\x8a\xd8\x64\xe2\x00\x5b\x31\x10\xc2\x72\x06\x1e\x08\x47\x38\x4c\xcc\xc4\x6a\x33\x71\x46\xc2\xb3\x60\x75\x10\x43\x92\x67\x81\x07\xc1\xc7\x10\x2f\x61\x79\x1e\x03\xc7\x32\xc4\x2c\x33\xbc\xd1\xcd\xb1\x8d\x35\x41\x8e\xe3\x2d\x04\x13\x23\x58\x78\x12\xb2\xb2\x02\x63\x34\xc9\xac\x48\x8c\x16\x23\xc3\x58\xac\x06\x13\xd8\x6d\x06\x30\xb2\x06\x03\xf1\x99\xe4\x5a\xbe\x96\x63\xc1\x6c\x12\xb0\xc8\x61\xc1\x04\x84\x63\x59\x03\xe1\x03\x26\xc6\x63\x67\x19\x06\x08\x23\x92\xf6\x59\x1c\xc7\xda\x70\x83\x81\x15\x39\xde\xed\xc0\x3c\x66\xac\xa2\xc1\xc6\xdd\x77\x21\xcf\x32\x98\x98\x8c\x1c\xb4\xc8\x98\x08\x60\x03\xc2\xf3\x3c\x0b\x98\xd8\x05\x21\xc8\x61\x22\x59\x18\xc6\x62\xc0\x6e\x00\x02\xa4\x86\x00\x66\x38\xec\xb5\x62\xc2\x62\x6c\x30\x72\x40\x4c\xa2\x03\x73\x36\x83\xd1\xc5\xb1\x1c\xc6\x82\xc5\x41\xd8\x5a\x83\xc9\x62\x67\xad\x3e\xbe\x51\xc6\xac\x99\xc7\xac\x97\xe5\x80\x38\x0c\x62\xbd\xc4\x12\x8c\x19\x23\xe6\x00\x1c\x98\x75\xb1\x44\xc0\x40\x30\x18\x39\x6c\xb6\xc8\x3c\x30\x1c\xc7\x37\xf0\x82\xcc\x02\x47\x2c\x0c\xd6\x0a\x0f\x84\x00\xdf\xc2\x59\x79\x16\xb3\x1e\x52\xc3\x12\x03\xe1\x59\x13\x36\x1b\x78\x03\x68\xff\xac\xbc\xc9\x04\xa2\x9d\x71\x72\x3c\x03\x06\x1e\x8c\x3c\xcb\xb2\x46\x8b\x81\x67\xeb\x09\x8f\x09\xe3\xc2\x76\x42\x24\xc1\x64\x23\x16\x23\xb1\x63\xab\xcb\xfe\xdc\xcb\xf7\x12\x99\x48\x1c\xf0\x46\x1b\xc1\x26\xc6\xcc\xf1\x5a\x57\x61\x70\x5a\x59\x8b\xd1\xcc\xb1\x18\x78\x91\x25\x56\xa3\xc8\x08\x98\x70\x18\xcb\x98\x21\xbc\x5c\x8b\x19\x9b\x0d\xce\x32\x50\x52\xbf\x07\x76\x30\x59\x80\x37\x70\x9c\x41\xc6\x2e\xc0\x2c\xeb\x02\x9b\x80\x39\x1e\x33\x40\x8c\x1e\xc2\x5a\x18\xcc\x73\xac\xc9\x84\x01\x58\xc0\x18\x58\x8e\x01\xc6\xc6\x31\x46\x03\x66\x8d\x0c\x67\x94\x09\x27\xb2\xbc\x5d\x30\xd8\x18\x83\x93\xa3\x72\x00\xcc\xba\xac\x35\xac\xc1\x28\x08\x46\x16\x44\x2b\xe1\xdc\x5a\xc7\x5a\x2d\x8c\x95\xf5\xb0\x1c\x98\xc0\x63\x00\x89\xc7\x8c\x91\x61\xc0\x6d\x31\x43\x0d\x58\x0d\x22\x58\xac\x0c\x66\x79\x23\xcf\x30\x60\x62\x80\x65\x30\xe3\x60\xd8\x1a\xc6\x48\x80\xc1\xbc\xc1\xc2\x60\x22\x60\xab\x17\x30\x36\x82\xc8\xb3\x36\x23\x43\x38\xce\xc2\x11\xd1\x00\x30\x7c\x17\x0f\x60\xe3\x38\x83\x19\x7c\x76\xc6\xcc\x63\x91\xb0\xb5\x10\x88\x32\x60\x69\x23\x24\x66\x00\x6c\x36\x72\x6c\x88\xe3\x7c\x46\xcc\x8b\x5a\x1e\xec\x68\xae\x61\x58\x27\x43\x18\x06\x78\xa7\xcd\x85\xb9\x5a\xa7\xd1\xd0\xc8\xf1\x02\x67\xc2\xd8\x4e\x18\x16\x70\x03\x23\x1b\x40\x90\xcc\x84\x93\x38\x86\x35\x78\x30\xa9\xb3\x06\xc1\x68\x30\x72\xbc\xc4\x18\x3c\xc4\x88\x0d\x60\xc4\x40\xea\x0c\x8c\x4d\xb0\xf0\x00\x32\xb1\x1a\x08\xc1\x8c\xa1\xd9\x66\x0a\xda\x6d\xd8\x4a\x00\x80\x61\x00\x13\x62\xe4\xcc\x02\xd8\xd9\x5a\x89\x30\x04\xf3\x98\xb0\xa2\x29\xc6\x10\x6c\x37\xf3\x06\xa3\xd1\x40\x24\xd9\x08\xac\x81\x91\x6d\x46\x8e\x61\xcd\xc4\x86\x2d\x26\x83\x81\xe7\x39\x6c\xb0\x31\xac\x01\xcc\x0c\x16\xcc\x46\x8e\xc7\x00\xd8\xc4\xb1\x93\xb7\x34\x7e\x82\x10\xcc\x03\x6f\xd1\x4a\x6b\x20\x1c\xd6\x46\x1a\x01\x3b\x0b\x46\x16\x73\xac\x83\xb0\x35\x1c\x47\x38\x33\x36\x12\xc6\x46\x18\x96\x98\xe2\x42\xbd\xbd\xc6\xea\x62\xf8\x5a\x03\xb5\x8e\x70\x4e\x39\xb9\x03\x74\xcf\xe4\x44\x1d\xe5\x3d\x93\xb1\x60\x91\x9b\x4a\x66\xc0\x0f\xa0\x6b\x4c\x20\x1b\xa2\xbe\x28\x1c\x3c\xeb\x74\xeb\xee\x28\x74\xd2\x0a\x7f\x3e\xbf\x2e\x9c\x4a\x46\x47\x23\x11\xfc\x44\xf4\x01\xfc\x86\xbb\xe3\x0f\x1f\xd3\x8d\x81\xe6\x1c\x6c\xb5\xd9\xd4\x9f\xff\x0b\xfb\xf1\x9b\x8d\x56\x7b\x41\x16\xf2\x9b\xfc\xba\x70\xf8\x8a\xc6\x74\x2a\x82\x9f\xd8\xf2\x00\xdc\x19\x9d\x77\xdb\x63\x3a\x53\x29\xe8\x37\x37\x98\x9f\x18\xbf\x9c\x6c\x58\xe4\x40\x95\x3e\x39\x75\x3b\x8e\x5a\xd4\x82\xba\x11\x0a\x07\x53\x41\x28\xfe\xce\xe3\xcb\xb5\xfa\x9a\x41\x1a\xed\xaf\x2a\x0c\x9a\x44\x98\xe2\xeb\xe3\x0f\x85\x04\x49\x61\xfa\x41\x51\x26\xb3\x45\xb6\x97\x37\x12\x81\xdf\x9e\xeb\x42\xdb\x7b\xb3\x53\x0a\x7b\x33\x8b\xa8\x9e\xaa\x8b\x2f\xc1\xdc\x45\x52\x76\xdd\x57\x54\x9c\xbd\xd9\x5e\xaf\xca\x14\xdd\x6e\x0a\xc9\xaa\x5c\x6f\xb7\x37\xb3\xa8\x99\xf9\x69\x53\x9d\x2a\xe7\xbd\x14\xd8\x0e\xc9\x5e\xf8\x2d\xbc\x53\xd7\x14\x2d\xe3\x60\xd2\x9e\x73\xa3\x5a\x6a\xbb\x3a\xad\x0d\x82\xce\x22\xe6\x54\xc8\x19\xa4\x7e\x08\xaa\x45\xab\x58\xc1\x48\x45\x4c\xc1\xb7\x0a\x1e\x8b\x78\x21\xeb\x8d\x8c\x4c\x21\x06\xbd\x8f\x36\x0d\xc0\x88\xce\xc2\x83\x91\x81\x4d\x2c\x52\xf2\x48\x0d\xe8\xec\x94\x31\xad\x6a\x63\x8a\x02\xe3\xaa\x02\xca\xc0\x26\x1d\x14\x7c\x53\xa5\xde\xe9\x22\x84\x8c\x38\x93\x76\x17\xd9\x7b\xd1\x48\x3f\x18\xe9\x0a\x54\x64\x3c\xa5\xeb\xc1\x08\x7c\xd1\x89\x91\x8e\x99\x65\x05\x23\xe5\x36\x14\x48\x7b\x7a\x97\x25\xea\x43\xb0\xf5\x9e\xba\xa6\x68\xd1\x61\xd0\x3d\xea\x43\xea\x43\xf7\x68\x0d\x54\x70\x06\x74\x0f\x6c\x55\x1f\xba\x47\xf6\x5a\x2c\xb1\x88\x17\x72\x34\x0d\x6c\x85\xad\x34\x0d\xe4\xbc\x11\x8a\x00\x46\x7e\x3d\x73\x3e\x7f\xb4\x2a\x97\xcc\xea\xb9\xb4\x14\xf4\xdd\x34\x85\xf6\x6e\x56\xd6\xf5\x2a\x11\xc5\x39\xb7\xa3\xd9\xa8\x0b\xcd\x45\xab\xd1\x06\xca\xcd\xd7\x36\x28\x36\x9d\x93\x90\xe1\x9c\x0e\x28\xe9\xb4\xb3\x89\x38\xf5\x61\x99\x88\xfb\xd9\x22\x97\xae\xe8\xbd\x9a\x42\x47\x50\x75\x25\xaa\x40\x0c\x89\x38\x2e\xa4\xc0\x2b\x1f\xb9\xf4\xb6\x55\xbb\xf6\x71\x83\x37\x74\xcf\x1b\x60\x19\xe5\xbe\x1b\x27\x8f\xdf\x78\x1f\xef\x0c\xa4\x17\x6e\xef\x35\x0d\x0c\xdf\x76\xc7\x6d\xc3\x03\xa6\xde\xed\x0b\xd3\x01\x27\x3f\xa9\xe3\xf2\x91\x75\x05\xed\x58\x12\xdc\xb5\xea\xb6\x4b\x1f\x59\xc9\x0e\xcc\xeb\xbe\x61\x90\xdb\xa7\x2b\x3f\x62\x85\xbd\x79\xe5\x72\xb8\xa4\xb9\xc5\x1d\xae\x3b\x9a\x17\x6f\x38\x7a\xf4\x86\xd4\xf6\x3d\xdb\x36\xcf\x8b\xb5\xa4\x5a\x5a\x52\x2d\xb1\x79\x9b\xb7\xed\xd9\xce\xc6\xa9\x6e\xa1\x5a\x5f\x70\x95\x9d\x3f\xb9\x7c\xe5\xcd\xec\x9e\xa3\x75\x61\x77\x4b\x33\x8c\xd2\x9b\x45\x3b\xb5\x7b\xb8\x5d\xec\xbb\x28\x88\xe6\xa1\xcb\x0a\x68\x29\xa1\x06\xde\xcf\xd0\x6d\x5b\x3b\x89\x96\x81\x5d\xd2\x50\x04\x7e\x29\xc6\x65\x8a\xaa\x41\xc4\x9d\x46\xba\x25\xbe\x3e\xcf\x44\x0b\x18\x00\x05\xe3\x31\x97\xd3\xc1\xbb\x69\x88\x7d\xda\xf7\x8a\x2f\xd6\xec\x27\x01\xb3\xcc\x77\xc6\xac\x35\x5e\x4b\x3d\x09\xfa\x5e\xae\x6d\x8a\xf9\x8e\xf9\xf2\x73\x7d\x2f\xfb\x62\xd1\xba\x63\x3e\xdf\x2b\xb5\x4d\xd5\xa9\xc8\xc1\xb5\xc7\x56\xdf\x70\xe3\xea\x97\x57\xaf\x5f\xbf\xee\xa6\x1b\xd6\xbc\xb2\xa6\xea\x1a\xb2\x31\xdf\x2b\xbe\x00\xa9\xb7\x78\x6b\xac\xb1\x4e\x5e\x36\x07\x48\x7d\x73\xcc\xf7\xa3\x5a\xef\x7d\x3e\xfc\x56\xcc\xf7\x23\x5f\xed\x7d\xbe\x68\xcc\xf7\x4a\x6d\xfd\xf4\x44\xf9\x37\xdf\x5d\x7d\xdf\xea\xb5\x3f\x5a\x7d\xc3\xcd\xeb\xd6\xaf\x5f\xf3\xca\x9a\xe9\x97\x05\x8c\x4b\x85\x62\x7b\x23\x7d\x5c\xa0\x54\x92\xea\xaa\xa2\x44\x9c\x71\xeb\x62\x58\xde\x0f\xbc\xf2\xe6\xc9\x89\xdc\xb3\xea\xfb\x77\x5d\x87\xa1\xf5\xb5\x4f\x03\x74\x2f\x1c\x19\x3d\xde\xf4\x91\xc7\x41\x39\xf9\x26\xf0\xcf\x1e\xfa\x79\xda\x67\x7d\x0d\x5a\x9f\xbe\xab\xef\xf8\xe8\x60\xbf\xff\x34\xc2\xe8\xda\x29\x85\x13\xa8\x7d\x7d\x10\xa1\xb0\x0e\xb5\x94\xd1\x35\xfb\x0b\x9a\x36\x2d\xda\x32\x10\x84\x68\xca\x1e\xb2\x3b\xd9\xbf\x75\x2e\x18\x9d\x50\x46\x17\x74\xc2\xdf\xb2\x45\x68\xad\x88\x37\xab\xbe\xad\xbe\x8b\x7f\xa0\xbe\xeb\x50\xd6\x5f\x78\xf0\xe0\x85\xa4\x06\xee\x2e\xe8\xa4\xed\x9e\xaf\xae\x86\xa7\xea\xc3\x70\xb7\xba\x3b\xac\x4f\x3b\x50\xd0\xcd\xe4\xd1\x72\xb4\x11\x8d\xa2\x1b\xd0\x6d\xe8\xce\x32\xe6\x3f\x0b\x94\xbf\x48\xe7\x38\x4a\x9c\x8b\x85\x4f\x9d\xd2\xec\x09\xaa\x98\x4b\x75\x34\x1b\xa8\x0f\x19\x2a\x8e\xa6\xd4\x36\xef\xaa\x87\x42\xa7\xbb\x5d\x3c\x9b\xa6\x30\xdc\x74\x3b\x91\x88\x93\x3e\x0a\x19\xc4\x8b\x14\x23\x08\xdc\xa9\x64\x3f\x44\x29\x8a\x3b\xf0\xf5\x00\x51\x70\xf2\x14\xcc\xbf\x1e\x20\xa3\xbd\x95\xe8\x8c\x33\xb8\x02\x26\x7c\x84\xf5\x2b\x82\xcd\x2e\xe6\x97\x5f\x65\x60\x44\x86\xdf\xb2\xfa\xd0\xbd\x77\xac\xbb\xc8\xcc\x6f\x59\x75\xe8\xbe\xd5\xf3\x8d\xc2\x4d\x37\x09\xc6\xf9\xab\xef\x3b\xb4\x6a\x0b\xcf\x36\xb5\xac\x3d\x7c\xef\xa1\xd5\x5b\x78\x46\x64\x0c\x57\xe1\x67\x44\xbb\x4d\x50\xfc\x2c\xf1\x4d\x6c\x6c\x8f\xaf\xdc\xb8\x6d\x69\x54\x3f\xb5\xaf\x8c\xb7\x47\x97\x6e\xdb\xa8\x9f\x40\x1c\x09\x8a\x2b\xbc\x44\x64\x31\x03\x3f\x1e\xc1\xe3\x4a\x1e\x8d\x19\x31\xcb\x88\x8c\x97\x8c\x28\xf9\xbf\x7f\x09\x9b\xb1\xbe\x48\x7a\xd5\x6b\x1c\x8d\x21\x5b\x96\x37\xc0\xad\x03\x0c\xcc\x9e\xb5\xec\x63\xa9\x35\xcb\xd7\xdc\x3c\x74\x57\x6a\x4d\xbd\x60\x5c\xb2\xc4\x28\xd4\xaf\x49\xdd\x35\xd4\x7d\x45\x74\xc5\x9a\xe4\x5d\xcb\x66\xcd\x06\x66\x00\x6e\x35\xf0\x59\x5b\xa8\xd1\x71\xa4\xf9\x50\xa2\xbb\x51\x3b\xe4\xbb\x13\x87\x9a\x1b\xe9\x01\x8f\xcd\x31\x37\x3a\x0c\x1d\x5e\x62\x63\x30\x81\xdf\x05\x70\x36\xab\xae\xdc\x3d\x62\xc0\x0c\x63\x63\xbc\x6a\x2e\x0b\x27\x8e\x10\x46\x97\xc3\xe8\xeb\x46\x3d\x6a\x40\x61\x94\x40\x3d\x55\x72\x98\xc2\x0a\x59\xb4\x56\x71\xda\xd3\x09\x1e\x82\x46\x08\xca\xda\x22\x52\x70\xd1\x99\x4c\x97\x2e\xb8\xb1\xa2\x44\x28\x3f\x1e\xeb\x8c\xf9\xe0\x84\x6f\x24\x06\x63\xb1\xce\xf9\x3d\x8a\xfa\x3a\xb4\xe4\xe9\xf1\x79\xe8\x51\x29\x32\x01\x46\x31\xf2\x13\x3d\xc8\x94\x20\x05\x20\x50\xf0\x3d\x01\x27\x7c\xb1\xce\x98\xfa\xf5\xd8\xeb\xea\xeb\xf8\x49\xf5\x75\xf5\x51\xe8\x81\x31\xea\x28\x53\x01\x14\x1b\x99\xfc\x3b\xa3\xe8\x57\x94\xa7\xcd\x4c\x1d\x62\xf7\xb1\xfb\x28\x0a\xb4\xa3\x88\xaa\xa1\x23\x77\x14\x14\xf4\x0b\x56\x1b\x40\x99\x4d\xc9\x8a\x6b\x67\x55\x7a\x76\xdf\xa7\xf7\xdc\xbe\x6d\xf2\x6f\xbb\xdf\x38\xf9\xe9\x6b\xf1\xc5\xa6\x5e\x9b\x60\xca\x3f\xb2\x62\xc7\xe8\x7d\x43\xc4\xd0\xbf\x2a\xbb\xa6\x3f\xff\x4d\x6f\x43\x5d\xa4\x06\x1e\x34\xf5\xd9\x2c\x26\x75\x47\xff\x35\xab\xd6\xf7\xe2\x05\xdb\x1e\xd8\xf3\xe9\x6d\xc4\x70\xed\xa7\x4e\xfe\x72\x77\xfe\x11\x93\xc5\xd6\x6b\xc2\x9b\x97\x1d\x1f\xbd\x6c\x68\xf2\x6f\xfd\x6b\xb2\xab\xfa\xf1\x02\x4f\xa4\x2e\x50\xab\xee\x30\x59\x6c\x7d\x26\x78\xb0\x77\xfd\xaa\x6b\xfa\xf3\xdf\xdc\x32\x4d\xb7\x2f\x88\x66\xa3\x05\xba\x8f\x0f\xaa\xcf\x47\xfd\xc7\x94\xed\xfa\xed\x89\x22\xcb\xab\xda\x06\xb5\xda\xe6\xce\xad\x51\x69\x0a\x41\x79\x44\x14\xc5\x61\x52\xff\xcb\x34\xcb\xaa\x4b\xe4\x14\xa5\x33\x46\xb2\xb1\x4e\x55\xa9\xb0\x0c\x56\x4a\xbe\x49\x69\xf3\x7b\x7c\x31\xea\x9c\x48\x11\x67\x9b\xa0\xc6\xe4\x28\x1a\xf6\x4f\x20\x1d\x29\x02\xa3\x0a\xe9\x8e\x3c\x49\xef\xb2\xd4\x6b\xa9\xfa\x96\x6f\xe4\xfc\x38\x7c\x95\xe2\x75\x66\x64\xba\xd9\x8a\x2e\x9f\xa3\x72\x2d\x1d\xef\xf8\x1f\x46\xf6\x9e\x8e\xf3\x77\xae\x70\x05\x7a\xf7\x6f\x67\x0a\xd2\x35\x3e\xc7\x23\x36\x5b\x90\xaf\x45\x51\x46\xa3\x68\x8a\x16\x6c\x52\x51\x6a\x58\xf5\x76\x74\x8e\xf8\xb3\x51\xa5\xa9\xdc\x50\xff\x63\xdf\xad\x94\xb4\x9d\x51\x66\x88\xac\x0c\xbf\x42\xb3\xc1\x3d\x3a\xc0\xf0\x58\x09\x48\x99\xfc\xba\x3a\x06\xfe\x52\x81\xb2\xac\x35\xab\x95\xda\x96\xfe\x0d\xf9\x51\x0f\x1a\x42\x1b\xd1\x15\x68\x1f\x42\x2c\xfd\x0a\x32\xfa\xd7\xc1\x47\xfb\x70\x26\xd5\xc0\x85\xa8\x23\x2b\xde\x0f\xb2\x33\x48\x99\xae\xba\xbc\x24\xda\x47\x85\xc3\x0e\x11\xf3\x89\xd4\xd9\x40\xe4\xc1\x54\x22\xa9\x51\x9b\x1c\x1f\xcd\x24\xec\xe7\x6d\x84\xfd\x57\xae\x1c\x1d\xe8\x9a\xdd\x55\xd7\x72\x99\xd7\x30\xbb\x51\xb6\xcd\xb5\x8d\xc2\xb2\xcd\x89\x1e\xac\x1e\xe7\x3a\x06\x06\x3a\xea\x6a\xda\x43\x6b\x3d\x9b\xe7\x2c\xd9\x36\x7f\xd5\x02\x38\xc8\xfe\x5e\x6f\x07\x49\xd4\x1b\x4a\xfd\xd2\xe5\x80\x0d\xcd\x8b\xee\x18\x65\xdf\xae\xbc\x53\xd9\x5a\x6b\x86\x37\x0e\xac\x6f\xab\xf3\x65\x0d\x9d\xa6\x79\x4d\x12\xe0\xd4\x89\xf5\xd7\x5a\x96\xe2\xec\xc9\x46\x29\xb1\x26\xd9\xd2\xea\xae\xa9\x9d\xd3\x9d\xe8\x5a\xbd\x28\xbe\xba\x3d\x53\xd3\xa3\xfe\x8b\xde\x66\xa2\x24\x93\xeb\xb7\x6e\x6d\x7a\xb8\xc9\x62\x0f\x0f\x1d\x54\xaf\x50\xf7\x97\x6e\x54\xb5\x2b\xa9\xb0\x7f\x4a\xa1\xed\x74\x2e\x9d\xa6\xdc\x18\xd6\x8d\x63\xd2\x3a\x28\xac\xee\x40\xa2\x03\x0a\x0b\x5b\x49\x38\x40\x82\x05\xb4\xdc\xa2\x34\x4e\x37\x68\xd1\xe8\xe6\x54\x46\xd7\x56\x72\x17\xb0\xde\x52\xc9\x68\x84\xa3\x86\xca\xef\x53\x2d\x46\xf8\xae\xcf\x3d\xeb\xb6\x8f\x02\x13\xdf\x33\x70\xb5\xc9\x2c\xb2\x96\x35\x62\x3c\xb5\xfe\xa6\x6b\xe6\xcf\x1b\x18\x78\x7d\xc1\xce\x39\xe1\xb7\xe1\x93\x7c\x93\x7b\x56\x78\xf1\xf0\x92\xe1\x9b\xaf\x59\x79\x67\x97\xd5\xa0\xed\x1b\x77\x58\xfd\x56\x36\xd4\xd6\xd2\xd7\xbd\x24\x3b\xb8\xac\xad\x63\x65\x03\x56\xca\xbe\xf7\xb2\xa1\xb6\x2d\x17\x7d\x45\x39\x28\x5b\x1a\x23\xc3\x37\xf7\x48\xb5\x84\xc3\xf7\x77\x6e\xe8\x9e\xb3\x7e\xc9\xbc\x79\x7d\x8e\x76\x9f\x67\x0a\x45\x53\x57\x6f\xef\x9c\x15\x6a\x9f\x25\x39\xdd\x31\x9b\xc5\x20\x0a\x57\xcc\xf2\x47\xc2\xad\xb8\x61\x69\xc4\xd0\x15\x6e\x74\xba\x6a\xbd\x3d\xbd\xf3\xd7\x2c\xa9\xab\xe0\x8b\x6e\x45\xd7\x22\x24\x47\x3a\x74\x20\x5c\x5a\xa7\x78\x86\x77\x3b\x39\xbd\x41\x5c\x4e\xb7\x5c\x51\x5b\xbd\xc6\xed\x7a\x93\x59\x21\x9a\x49\xb8\x5d\x19\x77\xa9\xb1\xb4\xf4\x2e\xd9\x55\x6e\x39\x5d\x86\x95\xb2\x27\xa3\x91\x6a\x5c\xc3\x59\x61\x03\x11\x6a\x7b\x92\x87\x1a\xd6\xad\xba\xce\xdf\xe9\x07\xdc\x93\xed\x91\x05\x00\x91\x6b\x0b\xf5\xae\xbf\x70\xe7\x05\x9d\x2d\xb3\xec\x8d\x76\x27\x6f\xe5\x18\x56\x6e\x68\xd9\x26\xe2\x35\x2f\x0d\xdd\x20\x71\x4c\x5b\x74\x09\x67\x25\x06\x91\x73\x5a\xbd\x91\xa5\x83\x97\x5f\x79\xdf\x63\x7b\xf6\xf6\xf4\xba\x6c\xf6\x1a\x76\x9d\x24\x96\xdd\xa8\xb3\x41\x8c\xd7\x03\xc3\x13\x06\xb0\x98\x35\x1a\x6b\xc4\xeb\x85\x28\xf7\x9f\xea\x5b\xfb\x96\x77\x07\x3b\x7c\x52\xb0\xd1\xd7\x39\x67\xc9\xa7\x56\x6c\x39\xb6\xae\x7b\x9e\x33\x04\x98\xac\x33\x11\x01\x47\x04\xde\x63\x01\x33\x67\xf5\xf2\x31\xb3\xac\xde\xfe\xdd\x2b\x87\xda\xe7\xce\xe9\x0a\x04\xdb\x3b\x06\x87\xf6\x0e\x3f\x04\xcb\x4e\xd5\x34\x9e\xb9\xa5\xd8\x37\x12\x42\xa6\x92\x0e\x47\xb5\x4f\x81\xbb\xd1\x49\x1d\x31\xa2\xb2\xee\xf6\xaa\xeb\xea\xb6\xf9\x3f\x7d\x5d\xfd\xbe\x6a\x1f\xa1\x18\x15\xf1\xfb\xa8\x46\x74\x45\x78\xfa\x1d\x15\x9d\xfb\xde\x87\x4f\x59\x19\xd6\xb6\xbb\x54\x17\x81\xcd\x0e\x6c\x2a\x63\x1a\xc2\x5d\xa5\xa0\x5a\x0e\x12\x71\xa6\xd8\xf3\x26\xa8\x78\x18\x2c\xaf\xf4\x30\xaa\xcd\xc3\xb5\x53\x9f\x2c\xe0\x51\xc8\xd4\x5e\xb2\x05\x25\x10\x32\x42\x14\x1a\xa9\xbe\x77\x47\x09\xc7\x34\xec\xd6\x66\x8a\x7e\x80\x73\x9c\x99\xcf\x41\xf8\x72\xf5\xe7\xb8\x59\x3a\x73\x46\x4a\x4b\x2f\x48\x12\xcb\x69\xe7\x33\x2f\x6e\xd9\xe2\xf7\x6f\xd9\xe2\x87\x7d\xcf\x3f\xdf\xd3\xf3\xfc\xf3\x3d\xe4\x97\x85\x98\xfc\xa7\x0b\x01\xf2\x4d\x9a\xf7\xf5\xb4\x96\x57\x7a\x41\x4a\x6b\x79\xa5\x17\xee\xa5\x37\xfd\x5b\xd4\x49\x9a\xaf\xe7\xf9\xfc\xa6\x42\x0c\xf6\x17\x02\x94\xf7\x90\x2d\xd1\xff\x36\xe4\x41\xcb\x2a\x24\xec\x41\xbb\xbe\xc5\x2b\x99\xe5\xd8\x1d\x22\x13\x09\xe9\x0a\x11\xf4\x18\x6a\xe0\xf4\x8d\x9f\x3d\x19\xe9\x23\xfd\xd0\x07\x14\x1e\x23\x51\x36\xf6\x56\x7f\x08\xca\xa7\x05\xe3\x77\x8d\xac\xae\xda\x0f\x43\x06\x59\x0c\x5a\xa2\x44\xdb\x94\x6a\x3b\xd9\x2c\x89\x5a\x82\xa2\x6c\x88\x78\x01\x18\xa3\x2c\xbc\x20\xf7\xd7\x8e\x45\xbc\x0c\xf2\x46\x74\x5b\x00\xac\x00\x32\x7e\xd7\x28\xe4\xff\x89\x5e\x32\xb9\x49\x64\x75\x8b\x46\x02\x30\x7a\xfc\xf8\xa8\xf6\x03\x20\x46\xd1\x6d\xf5\x46\x20\x6b\x48\xbb\x3a\x6a\x1b\x84\x17\x64\x6f\x4e\x07\x10\x28\xd3\x30\x4b\x4b\x38\x0c\xda\x44\xa4\x6d\xed\xfb\x20\x45\xc1\x37\x45\xe2\x74\xb8\xdc\xba\x10\xa2\xe0\x05\x53\x27\x29\x23\x99\x82\x7e\x81\x36\xb9\x13\xce\x1d\xc1\xa9\xa4\xd4\x18\x60\x38\xf4\xb2\x7a\xf2\xf4\xd5\x97\x77\xcb\xc6\x36\xc7\x68\xef\x8d\xdf\xda\xb9\xf7\x57\x77\x5d\xf6\xd5\x83\x1b\x5a\x86\x97\xf9\x0d\xd8\x82\x39\x7b\xe2\xf4\x13\x0f\x3c\x71\xf8\xf2\xde\xa5\xa2\x21\xec\x4e\xc7\xfb\xd6\xd5\x6c\xb5\x33\x2f\xab\x45\xf4\xd0\x95\x94\x4f\x1b\xb8\x78\x51\xc3\x97\xa2\x5d\x87\xdf\x3d\x7e\xcd\x0f\x0e\xcc\x19\xd9\x7f\xdb\xbc\x9d\x9f\x0e\x58\x02\xfc\x2c\xce\xed\xe8\xbd\xe8\x81\x9f\x3e\x7a\xeb\xe7\xff\x78\x41\x6f\x68\xcf\x85\xf5\xf1\x81\x6b\xd6\x2e\x99\xad\x6e\x5a\x78\xf9\x06\xd8\xf7\xbb\xd3\xba\x14\xa8\x5c\xb7\xa1\x0a\xba\xbf\x58\x3b\x49\x77\x0e\x56\xa8\x1c\x9d\x7c\x3f\xb0\x72\xa1\x69\xf6\xc3\xf9\x96\xb5\x6e\x63\xab\xf3\xb2\x9e\xaf\xfc\xe7\xc2\x9b\xbf\x3a\xba\xf3\x2b\xfb\x2f\x6a\x59\xb1\x4c\x70\x32\x26\x96\xb3\xc7\x7f\xf4\xd8\xfd\x8f\xdd\x3e\xda\xa3\x55\xce\x95\x9a\xdd\xbb\xd6\xb3\xc5\x63\xff\x5a\xa5\x8d\xf1\x4d\xeb\x1b\xbe\x18\xed\x84\xe8\xaf\xd6\x3c\x74\xe3\x92\xae\x91\x9b\x3f\x3a\xb0\xe3\x53\x01\xd6\x24\xb6\xda\xdd\x72\xdf\xfa\xe3\xaf\x3f\xf2\x91\xc7\xdf\xbe\xa0\xa7\x61\xcf\x05\xf5\xb3\xe7\xee\x5e\xbd\x78\xb6\xba\x65\xdb\x83\x25\x43\xe4\xb2\x6c\xab\x96\xd2\x6b\x08\x92\xd1\xa0\x33\x21\x16\xe0\x04\xe2\xee\x8c\x56\x6a\x9b\x46\xe8\x84\x13\xa9\x50\x2a\xe4\x0c\x39\x13\xce\x44\x35\x85\x4a\xee\xe7\xd4\xe3\x3f\x25\xb5\xb3\xd6\xa6\xb7\xde\x79\xe7\xd6\x8d\xbd\x3b\xaf\xb8\x7f\x6c\x7c\x7c\xec\xb3\x2f\xc2\x85\x57\x5e\x79\xd5\x55\x57\x5d\x05\x52\x25\x0d\x8b\xf7\x7a\x23\x87\x3c\xc9\x74\xe8\xae\x1f\xdc\xd5\xbd\x7d\xdb\x9b\xea\x77\xde\x7c\x75\xaf\x96\xec\x2a\xfc\xd1\x69\xd4\xad\xb6\xfe\x7d\xc6\x88\xd8\x8b\x0b\x58\xc0\x0e\x5c\xe1\x14\x3b\xe0\xe6\xa9\x2a\xb7\x83\x8e\x30\x92\x09\xa6\x82\xae\xb0\x53\x23\xc3\x42\xa9\x44\x2a\xe1\x64\x1f\xfa\x27\xf5\x5b\xaf\xdc\xaf\xbe\xfb\xfc\x75\xd7\x3d\x0f\xb6\xfb\xc1\xff\xd2\xf7\xf7\x7c\xf1\xe6\xd3\x37\xdd\x74\xfa\xe6\xd5\x47\x2f\x9a\x57\xcf\xa9\x23\xf8\x9f\x2d\x64\xeb\xe9\x57\x4f\x9f\x7e\x15\x5f\xfd\x8a\xfa\xcd\xaf\x69\x09\xa1\x19\x6c\xcf\x5f\x97\xfb\xf6\xee\x7d\xaf\x4f\xbe\xbe\xaf\x7d\xc1\xfa\xe5\xa1\xc9\xfe\x7e\x2d\xcd\xe9\xd3\x25\x1e\xa2\xc2\x22\x64\x41\x3e\xd4\x4a\x77\x82\xd4\x75\x29\xef\x4e\x67\x12\xf6\x50\xa3\x43\xc4\x0d\xed\x38\xd9\x87\xe3\x7e\x00\xbb\xfe\x05\x87\xec\x71\x97\x33\x98\x3c\x6b\x46\x27\x08\x14\xe5\x9a\x8f\x2f\x6b\x16\xb0\x82\x51\xf3\xb2\x03\xc7\x0f\x2c\x6b\xd6\x4f\xb8\x79\xf4\xf8\x84\xa2\x7d\x77\x8c\x72\xfc\xf7\x11\xef\xfb\x94\xe3\xc0\x23\x6f\x04\x94\x11\xc8\x1d\x1e\x0e\x3b\xd4\xf1\xdf\xde\x79\xcf\xbe\xe5\xcb\xf7\xdd\xa3\x9f\xd4\x66\x8c\xb4\x0c\x2a\x3d\x92\x6c\xd9\x5f\x50\xa4\x80\x35\xc0\x20\xa2\x20\xa1\x68\x25\x43\xf1\x0c\x12\xc1\x38\x83\x64\x35\x2b\x27\xb5\x03\x75\x96\x44\x2e\xa2\x61\x19\x72\x72\xb2\x88\xf3\x00\x88\x41\x24\xab\xe7\xd5\x7d\x7d\xeb\x4a\xfe\x0c\xd2\xbd\x2c\xd1\xc4\x32\xe4\x80\xea\x4a\xc8\xba\x42\xbe\x9e\x37\x8b\x14\xac\x30\xf4\xbd\x05\xcf\xba\x05\x68\x03\x6d\x67\x5f\x7e\x11\x93\xad\x7c\x8e\x5c\xf4\xa7\xac\xe0\x2c\x53\x51\x66\x1d\x48\xd0\x0d\x38\x4b\xcb\xac\xbf\x0b\x3f\x58\x2e\x7c\xa4\xf0\xde\xe9\xb6\x35\x75\x08\x25\x82\x54\x37\x32\x6c\x0f\xda\x67\x58\x5b\xc7\xf0\x48\x5e\x91\xd9\x2b\xf3\x0a\x1e\xd1\x5d\x67\x97\xd6\x3b\x46\x99\x18\x13\xe4\x00\x33\x32\xa1\xc8\xcc\x4b\x95\x7e\x48\xb4\xf1\x99\x63\x74\xec\xb9\xda\xea\x56\x95\xaa\xda\x69\x7a\x1b\x47\xaa\x9a\xed\x67\x15\x2d\x31\x43\x1b\xd2\xf7\x60\x74\xfe\xbe\x9b\xf6\xa0\x42\x5e\x82\x0a\x65\x3c\x4f\xdf\x91\xea\xf7\x96\xed\x89\xbd\x68\x4e\xe5\xce\xd4\xe5\x66\xdc\x7e\xdc\x8d\xa9\xec\x3b\x9c\x96\x1d\x1c\x8f\x78\x91\x69\xc1\xd4\xb0\xa0\x91\x4a\x71\x0b\x6e\xa2\x74\x46\x79\x6b\x17\x8c\xde\xde\xb5\xe8\xfa\x04\x40\xe2\xfa\x45\x5d\x9f\x87\xc5\x5d\x2d\x5b\x96\xa8\x77\x6c\x34\xcd\x6d\xe9\x4d\xbb\x01\xdc\xe9\xde\x96\xb9\xa6\x0d\xea\xe7\x1b\xfa\xae\x5a\xbd\x8c\xcd\xcd\xdd\x4c\xe6\x4c\xfe\x96\x6a\xe1\x7b\x67\x47\xfe\xba\xb5\xb9\x63\xf6\xec\x8e\xe6\x9b\x7f\x19\x85\x75\x2b\xee\x49\xa8\x13\x59\xbe\xa3\xae\x51\x92\x1a\xeb\x3a\xf8\xec\x3b\x9e\xe6\x63\xfd\xcb\x77\x6e\xa2\x7d\xfe\x34\x87\xd8\x2b\xa8\xdd\x5f\x4b\x01\xdf\xc2\xa5\xab\xea\x26\xd3\x71\x17\xe5\xe8\xeb\x2e\xea\x9d\xf6\xa0\x64\xeb\x80\xa0\x33\x44\x4d\x2c\xe1\x62\xf5\xab\xb0\x19\x2e\x5d\x83\x57\x6d\xbb\xf4\x73\xdb\x98\xbb\xd5\xaf\xad\x5c\xd7\xbf\xd6\x69\x56\xbf\x86\x01\x60\x09\x76\x34\x2f\xba\xb4\xff\xc9\x57\xc8\xdd\x93\x41\xf2\x1f\x10\x5f\xb2\x65\xcb\x92\xa5\x97\x5c\x32\xf9\x8b\xfc\x0f\xb0\x74\xd9\xde\x05\x09\x7f\x22\xff\x63\xb8\x1b\xde\x9d\x35\xeb\x9e\xc0\xac\xce\xfa\x5f\x4f\xc7\xd7\x4f\xd2\x35\x91\xfa\xf4\x8f\x46\xd2\xfd\x90\x4e\xb8\xdc\x74\xde\xc2\x74\xed\xe0\xf8\x2a\x36\x3f\x75\xfa\xef\xe2\xd0\x4d\x2f\xab\xbf\xf9\xd4\x17\xd4\x7f\xbd\x92\x07\xc3\x61\x93\xd5\xc6\x2f\x79\x6d\x6f\xd1\xf3\xff\x96\x7f\x5e\x78\xb8\x82\x33\x7f\xcb\xe5\x20\x1f\xfb\x14\xf8\x5e\x26\x3e\xf5\x07\xea\x6f\x5e\xbe\xe9\xde\x43\xa6\x1a\xc3\x11\x23\x36\x6d\xde\x59\x70\xfc\xbf\x68\xe0\x48\x05\xe7\xfe\x23\xdb\xaf\xbe\xe9\x65\x04\x28\x36\xe5\xe4\xfe\xc0\xfe\x04\xed\x46\x28\x38\x0d\xb4\x96\xe7\x1a\xa2\x7e\xce\xe9\xe0\x45\xb6\x10\xd7\xc7\x50\x73\x68\xd6\x5d\x18\x42\xed\x5c\x2a\x99\xe9\x63\x0b\xbc\x23\x91\xa1\xa6\x25\x6c\xd4\xe5\xb0\x42\x11\x0b\xf6\x0f\xe1\xcb\xa9\xdf\xdd\xfb\x23\x2d\x53\xe8\x80\x18\x13\xb1\x93\xb1\x31\x06\xe2\x23\xb5\x66\xaf\xe4\x15\x62\x3e\x75\xa7\xcf\x68\x74\x99\xfd\xc4\x1f\x31\xd9\xec\x26\x3b\xe7\xc0\xa2\x08\x1b\x67\x4a\x0a\x27\x66\x48\x7a\x00\x50\x4b\x2a\x19\x85\xcb\xc3\xa9\xf0\x15\xe1\x30\x5c\xd1\x98\x4e\xb5\x00\x3a\x20\x8a\xd8\xc1\xd9\x4d\x76\x9b\x29\xe2\x27\x7e\xb3\xcb\x68\xa4\x9c\x32\xc1\x2b\x79\xcd\xb5\xc4\x47\x0c\x8c\x8d\x71\x62\x31\xa6\xbd\xeb\xec\xa4\xea\xce\x99\x92\x1e\x98\x42\x2d\x61\xf5\xfe\x68\x19\xc3\x43\xd7\x27\x0e\xa2\x26\x2a\xd9\x18\x2c\xdb\x56\x97\x88\x39\x39\xdd\x0e\x1c\x4f\x44\xaa\xef\x91\xce\xa4\x23\x8d\x55\x29\x8a\x1a\x71\x60\xe3\x75\xb9\x8f\xbd\xe8\xf9\x1d\x14\xea\x05\x19\xcc\xfa\xe9\x6f\xdb\xb9\xda\x78\x3b\xbf\xbd\x67\x93\xcd\x31\xfc\xe0\x11\x87\xad\x15\x6f\xa1\x77\xf2\x2f\xd2\x13\x2e\xa4\x3b\xfa\x31\x39\x74\xe6\xb6\x90\xfc\xb1\xbb\xde\x85\x21\xb8\x02\x86\xde\xbd\x0b\xe8\x9d\x41\x5c\x70\x8f\x7c\x12\x0e\x78\xdb\xc4\x5a\xaf\x7a\x0b\xbb\xac\x67\xd9\x91\xd8\xf0\xb2\x9e\x6b\x44\x3d\xc5\x8b\xf4\xb4\x47\x4f\x97\x53\x27\x7e\x59\x57\xf7\x0b\xe0\xbe\xaa\x3d\xe4\xae\x77\xd5\x7f\x2e\x61\x37\xd2\xba\xbb\xb4\xf5\x0f\x05\x18\x6d\x4f\x59\x0f\x3c\xc7\xa7\x75\x34\xfa\xc6\xb4\x2d\xc2\x94\xc1\xb8\x42\x0d\xd5\x68\x5c\x14\x24\x7a\x48\xdd\xa9\x3e\x74\xfa\xee\x5b\x2e\xa8\xf5\xb4\x9f\xb8\xb9\xa5\x6b\x41\xef\x0f\x61\xeb\xe9\xd3\xb0\xb2\x02\xa3\x8b\xb5\x7a\xce\x02\xe9\x7a\x17\x3e\x05\x6f\xc1\xa7\x18\xe5\xe8\xdb\x87\x77\xbd\xb8\x34\x3e\xb2\x61\x65\xff\x15\x11\xce\x70\xf4\x6d\x90\xde\xfe\x7e\x19\xb8\xcb\x69\x9f\x01\xb7\xeb\x9f\x20\xfa\xe4\x93\x65\x1e\x04\x42\x0e\x34\x07\x6d\xab\xac\x45\xa9\x0e\xc9\x88\xd6\x0b\x1f\x80\xa2\x00\x1f\x8c\x9f\xe0\x74\x70\xe4\x42\xf5\x65\xf5\xaf\x0f\x8d\x8e\x5c\x12\x6a\xf0\xb5\xa6\x96\x0f\x7e\x02\x4c\x0f\x3d\x94\xff\x34\x1c\x80\x05\xa7\xce\x83\xae\xc0\xce\xf9\x50\xa8\x0a\x77\x31\xca\xce\x67\x76\xac\x3a\xd1\xd9\xb9\xc6\x21\xd7\x9b\xc4\x9d\xcf\xfc\xf0\x99\xb7\x0e\xbf\x7d\x1e\xa8\x85\x89\xbf\x9f\x1f\x65\xe1\xe6\x1b\x4e\x23\x40\x30\x85\xc8\x3e\x56\xa1\xd8\xcf\x2e\xbe\x60\xde\x94\x91\x59\x5d\x38\x51\x50\x86\x77\x3a\x78\x12\x4e\x27\xe2\x64\x8f\x64\xce\xff\x46\xa8\x63\x4c\x76\x3b\xf3\x3d\x75\x94\x31\x48\x82\xc4\xfe\x2f\xc6\x63\x83\xc5\xb2\x97\x7d\x12\xee\x34\x30\x32\xf9\x57\x87\x67\xe2\xe6\x1a\xcc\xfa\x6c\x24\xb6\x1d\xcc\x56\x0f\xe9\x12\xa5\x1a\xbb\xc1\xa4\xce\xde\x82\x2b\x7d\x7f\xac\x9d\xce\x0f\xed\x86\x54\xd0\x99\xa8\x76\x8e\x3c\x63\x1c\x15\xdc\x86\xa6\x3b\xcf\x68\x01\x67\xb0\x80\x22\xc8\xa3\xce\x98\x6e\x52\x38\xa2\x22\xca\x91\x9d\xf1\x6a\x28\x89\xf5\x6b\x6a\x78\x18\x1b\xc1\x28\x39\x34\x12\xeb\xac\x34\x47\xcc\xe5\x8a\xa9\x67\xb8\x4a\x0e\xe5\x8a\x79\xb5\xd8\xdc\x50\x32\xd7\x59\xa6\x4d\x72\x48\x46\x2b\xd0\x85\x05\xba\xa8\xa8\xf0\xee\x8a\xa7\x53\xf6\x74\x5c\xe7\x32\x6a\xdb\x26\xae\x28\x0a\x6a\x87\x68\x3b\x54\x5d\xd2\xc5\x4c\xc7\x25\x48\x23\x6d\xd5\xf0\x83\xdb\x05\xce\x48\x03\x4f\x1f\x47\x94\x13\xaf\x9c\x88\x24\x23\xcb\xb7\x2d\x0f\xf6\x91\xa0\x2c\x98\x2d\xb3\xd7\xcf\x99\x7f\x43\x0b\xef\x64\xcc\x76\xc9\xcc\x38\xf9\x96\xbd\x77\xec\xa5\x97\x92\x9d\x5e\xde\x30\x7f\xce\xfa\xd9\x16\xb3\x20\x43\x1b\x9a\x82\xb5\xdf\xba\x13\x84\xf1\xcf\x06\x21\x8f\x9a\x5b\x9b\x23\xc9\x08\x7e\x3e\x7f\x6a\xe7\x89\x13\x3b\x35\x12\x26\xbe\x7c\x79\x1c\xcf\x37\x47\x04\xd9\xd4\xde\xbe\xb4\xc7\xd4\xc8\xd9\xed\x5c\xa3\xa9\x67\x69\x65\xb8\xbd\xdd\x24\x0b\x2c\xfe\x1a\xd8\xef\x18\x3e\xf6\xeb\x23\x18\xbf\xba\x05\xe3\x2d\x1a\x51\xca\x94\xe4\x2a\x06\xe4\x41\xb5\xda\x0e\x84\x0d\xea\xb2\x94\xe0\x59\xcc\x92\x60\xc9\x86\xbb\x77\xba\x53\x14\xca\xbd\x27\x88\x50\x19\x87\xaa\x00\x92\x85\x3c\xe5\x66\xe2\x9c\x20\x03\x82\x16\xf5\x75\x8c\xca\xc2\x96\xce\x18\x93\x8d\x75\x3a\xad\xda\x5a\xa0\x60\xa5\x33\x06\x63\x10\x28\x61\xc5\xe6\xaf\x84\x16\x75\x6d\x9e\xf6\xf9\x98\xce\xa6\xef\x8c\xa9\x5f\x17\xac\xea\x4e\xca\xaa\xd7\xfb\x8e\xfa\x82\xb1\xa1\x18\xda\x48\x65\x93\xd4\xac\xbc\xb0\x67\xf2\x83\xbb\x60\xd5\xe0\xd0\x3d\x65\x27\xd2\x74\xbf\x9b\x71\xf0\x22\x2e\xa3\x8d\x68\x3b\x43\x6a\xb0\x45\x7b\xae\xf8\x6b\xc7\x3a\x70\x6f\xdc\x8f\xf1\xb8\xec\x95\xaf\x48\x6a\xe5\x8a\x6f\x1d\x1c\x5b\x70\xf5\xed\x47\x6e\xbf\x7a\xc1\x7c\x53\x93\x49\x11\x7e\x23\x28\xa6\x26\xd3\x7c\xe5\xd2\xb6\xee\x1e\xa6\xa3\xa6\xa6\x4d\xe8\x6f\x77\x0c\x6f\x1a\x76\xb4\xf7\x0b\x6d\x35\x35\x1d\x4c\x4f\x77\xdb\xa5\x17\xde\xfb\xb5\x6f\x7d\xed\xde\x0b\x09\xe5\xbc\xb6\xc7\x65\xaf\x1c\x18\x4a\x2e\xde\xb7\xa2\xad\x6d\xc5\xbe\xc5\xdb\x57\x98\x5b\xcd\x9f\xb8\xf7\xde\x4f\x98\x5b\xcd\x2b\xb6\x7f\x72\xf7\xec\xa1\x6b\xe3\xbe\x74\xb8\xb6\x36\x9c\xac\x73\x7b\xda\xe3\xad\xc9\x64\x6b\xbc\xdd\xe3\xae\x4b\x6a\x71\x69\x5f\xfc\xda\xa1\xd9\xbb\x3f\xb9\xf5\xc9\xdd\x73\xe7\xee\x7e\x92\xce\xff\x3a\xf6\xac\x97\xda\xa0\x50\x36\x75\x59\x36\xa4\xfb\x91\xa4\xea\x12\xb6\x0a\x5c\xca\x48\xd9\x50\x5d\x87\x33\x13\xce\x8c\xc9\x82\xc5\xa2\xfe\x8b\xd1\x08\x59\xea\x2a\x72\x44\x90\x0b\x28\x93\x67\xc6\x28\xca\xef\x88\x8e\x22\x09\x23\x39\x41\xce\x09\xb2\x09\xb2\x46\x41\xd4\x52\xcb\x42\x4e\xc6\xc1\x22\x58\x24\x65\x2d\x97\x20\x21\x8b\x18\x81\xd4\x37\x51\x8a\xda\x00\xb7\x94\x25\x40\x45\x59\x56\x3c\x03\x69\xf6\x03\xe4\xca\x2c\x92\xc4\x71\xfa\xe0\x71\x41\x36\xc2\x88\xd1\x67\x84\xcd\x26\x5c\x94\x36\xdf\x79\x3d\x86\xd6\xd7\x3e\x05\xa4\x7b\xd1\xe6\xd1\xe3\x4d\xb7\x3c\x86\x47\x44\x09\x46\xa8\x9c\x67\x8c\x7a\xc0\x1c\x33\x1a\x61\xb3\xe5\x35\x2a\x83\xbe\xe5\x8d\x8c\x5f\x78\x0d\x5a\xff\xe9\x9e\xbe\xe3\xa3\x43\x7d\xf5\xa7\xcf\x2e\x63\x94\x2a\x2e\xeb\xf8\x14\x25\x3d\xdc\x44\x01\x11\xe2\x9c\x65\xd4\x5e\xe3\x33\xaa\x0f\x9b\x2a\x0a\xfb\x01\x65\x1c\x13\xb5\x9a\x18\xd5\x87\x2d\x16\x51\x52\x69\x1b\xc3\x88\xac\xbe\x73\x8e\x42\xa2\x4a\x1f\xe9\x3c\x5a\x8f\x46\xca\x12\x1d\xb6\xa4\xab\x41\x32\x5c\x1d\x50\x90\x02\x1d\x94\x20\x95\xcc\xb8\x02\x19\x57\x1d\x05\xdf\x2d\xa2\x99\x45\xe9\x74\x34\xed\x3a\x12\x4d\xa6\xdb\x71\xd4\xcf\x94\x14\x3b\x74\x51\x2f\x13\xd1\xd5\x36\xcc\xe1\x39\x3b\xe7\xbb\xe6\x2c\xdc\x35\xb6\x6b\x51\x57\xcd\x21\x58\x78\xa8\x66\xf4\x78\xa0\x73\xb8\x33\x30\xb4\x73\x88\x9e\x17\x74\x03\x30\x26\xc3\xfc\x9d\x73\xc2\x66\x35\x57\x50\xe3\xf8\x19\x15\x61\xef\xbf\xf1\xc8\x91\x1b\xe7\x1f\x38\x7e\xed\x06\x6b\x72\xfe\x8b\x8e\x6d\xbd\xc3\xbb\x76\x0d\xf7\x6e\x73\xbc\xd8\x57\xbf\x73\x67\x7d\x5f\xf6\xf8\xe8\x85\x75\xcd\xda\xc7\xdd\x5c\x77\x61\x72\x68\x28\x59\xbe\x9a\xbf\xb7\xc1\x34\xb7\x3e\xd9\x2c\x5b\x37\x5c\x7b\xfc\x00\xf9\x49\x41\xa1\xa3\x64\x5b\xae\xb7\xc5\xb2\x32\xa5\x97\x71\x70\xbc\xdd\xc1\x04\x1a\x7b\x41\xb7\xfb\x4d\xc4\xdd\x54\xec\x43\xbf\x08\xbb\xc3\x15\x48\xeb\xba\xf8\x94\x27\xa4\xf7\x9e\xdd\xc1\xf1\x4e\xfd\x0e\xa5\x24\xe2\x25\xb3\x85\x45\x5d\x3a\x7c\xf4\xa3\x6f\x44\xbc\x9c\xc9\xde\x13\x4a\x0d\x0e\xa6\x82\xf5\xa7\xc0\x70\xaa\x3e\xa8\x85\x43\x3d\x76\x13\xe7\x8d\xbc\xf1\xa8\x16\xd5\xb5\x68\xd7\xd8\x2e\xa2\x2b\x1d\x64\xfb\xb6\x38\xd5\x3d\x27\xdf\x7c\xf3\xe4\x21\xc7\x4f\xee\xa1\x90\x1a\xfe\xc6\xc1\xd1\x41\x49\xbd\x8a\x72\xef\xee\x93\x06\x47\x07\x1b\xfd\x38\xe2\x55\xd1\x3d\x3f\x71\x1c\xa2\x91\x47\x9d\x5b\xfa\x86\x77\xed\x2a\xf8\xfa\xd4\xe5\xaa\xda\x6e\x36\xac\xeb\x46\xb1\x65\x78\x74\x7b\xd0\x9e\x28\xa9\x42\x15\x30\xd4\x13\x45\x8d\x28\x75\x8c\xa2\x3a\x32\x63\x93\x48\xd1\x55\xa0\x30\x3a\xb4\x31\x9b\xdd\x78\x88\x51\x14\x65\x02\x1d\xda\x48\xb2\x1b\x0f\x4d\x20\x16\xe9\x9a\x4f\xe3\x93\xb9\x8d\x87\x58\x74\x08\xe1\x0a\x1b\xb1\x44\x95\x85\xd8\x87\xb7\x0a\x23\xd9\x0f\x69\x08\xf6\xa1\x0c\xbf\x74\xda\x30\x5b\xa0\xed\x1b\x68\x4f\xd3\xca\x42\x50\x1f\xf4\xc8\xa6\xd1\x12\xd3\x38\x08\x9c\xb2\x6b\x38\x9b\x1d\x7e\xff\x5d\x1e\x1d\x1f\x9d\x40\xa3\xc7\xf9\xec\x9b\x27\xb3\x87\x36\xe6\xb3\x1b\x0f\x45\xbc\x8c\x72\x92\xcc\x1a\xdb\xa5\x2a\xf9\xdc\xe8\xf1\xe3\x8c\x51\xfd\xce\x9b\x01\xad\xbd\xf0\xb8\x37\x52\x89\x85\xde\x86\x06\x74\x6a\x80\x2f\x59\x98\xea\x43\x8a\x0e\x19\x97\x8e\xbd\x32\x3d\xcc\x96\x52\x86\x2a\xfd\xae\x2e\xea\xa2\xc0\xff\x5d\x8b\x2a\x61\x14\x22\xc9\x08\x41\x34\x7e\x5c\x90\x4f\x1d\x02\xe4\x8d\xb0\xb9\xbc\xd2\xbb\xcd\x31\xf9\x9e\xf6\x11\x10\xb3\x63\x5b\x2f\xd6\xe1\x61\x47\xa8\x32\xde\x58\x75\xf8\x7d\xea\x33\x03\x23\x59\x20\x81\x43\xa7\x74\xb9\xaf\x6e\xbf\x22\x23\x6f\x01\x03\x77\x35\xf5\x68\xe0\xac\x16\xb2\xf3\xf6\x60\x24\x0a\x11\x28\xac\xf0\x76\x98\x06\x2f\x13\x49\xb1\x55\x52\xc0\x6a\xa9\x20\x7b\xca\x17\x2b\x49\xde\x95\xd8\x88\xef\x10\xdc\x60\xb2\xa8\xdf\xb7\xc0\x56\xaa\xde\x80\x00\x49\x62\x11\x72\x46\x94\xf0\x78\x31\x54\x19\x2b\x89\xcc\x21\xdf\x48\x6c\x42\xd1\x9e\xc2\x51\x29\xfc\x7c\xf5\x8e\x3a\x0b\x74\x59\xce\x48\x0c\xd2\xc8\x81\x33\x88\x8c\x14\x85\x46\xe2\x58\x59\xba\x37\x85\xca\x61\xe4\xa8\xc0\xaf\x3f\x5b\x96\xf4\x45\xf4\x6d\xf4\x23\xf4\x1f\xe8\x4f\x68\x0a\xac\x50\x0f\x6d\xd0\x7b\xb6\xdf\xea\x54\xd5\x35\x5b\x75\x5d\x9d\xbe\xda\x6f\x75\xf5\xfd\xf3\x5d\xff\xbf\xce\x7f\xbe\xf4\xd5\xf5\x05\x6d\x8a\x29\x6a\x5b\x9e\x85\xc5\x04\x4a\x19\xa5\xbb\x02\xaf\x1b\x95\xc3\x53\x15\x61\x72\x8e\xf8\x73\x85\xff\x6f\xa4\xc7\xe7\x88\x9f\x5e\x66\x50\x26\x14\xad\x6e\x14\x18\x0b\x55\x7a\x7f\x1f\x2f\xd5\xf4\x2f\x67\x57\xbc\x22\x2e\xff\x97\x19\x22\x67\x0a\xfd\x9f\x4a\xa8\xce\x14\x59\x3e\x9c\x39\xc6\xa1\x33\x68\x5c\x27\xe0\x2a\xd4\x81\x91\xf0\x81\xdf\xcc\xd7\xd0\xcf\xd1\x7b\xff\xef\xbf\x92\xff\xc9\x28\x2d\xe9\x65\x54\x8c\xd7\x1a\x28\xfa\x1b\x08\xa5\xa6\x6b\x1b\xf5\x42\xc2\x79\x36\xbe\x7d\x22\x58\xda\xc1\xfc\x5f\x19\xdd\x1f\x76\xf4\x4d\x69\x3b\xe1\x6c\xac\x53\x0b\xeb\xa3\x90\xde\xaa\x28\x8f\x52\x78\x5e\x71\x6c\x42\xb6\x33\x06\xb9\x58\x27\x64\xff\x8f\x8d\xd1\xf3\x8c\xa8\xc9\x63\x8c\x12\xd0\x26\xec\xc0\x84\x42\xc7\x15\xc9\xe9\x05\x1d\x19\x29\x29\x56\xe9\xe1\xb6\xf2\xe7\x03\x34\x87\x3a\x1e\x41\x2c\x95\xbd\xea\x74\x9b\x0d\x79\x50\x0f\xda\x3a\x5d\xfa\x4a\x21\x5c\x8b\xe4\x9c\x4c\xbb\xaf\xe4\x3d\x22\x54\x74\x21\xe1\x2c\xf5\x66\x3c\xad\x03\x40\x4c\x13\xd0\x46\xa8\x74\x36\xad\xcb\x66\x4b\xcb\x30\x65\xbb\xa9\x2f\x82\xf2\x69\xd1\xf0\x5d\x1e\xb3\x88\x46\xbc\x28\x89\xe3\x54\xd4\xad\x63\xe7\x17\x83\x80\x22\xde\x5c\x51\x5e\x4b\xbf\x1b\xaf\xfc\x82\x9c\xf5\x8e\xe9\x52\x9c\x02\x0b\x4f\x01\x84\xf9\xef\x5a\x4c\xf9\xa7\xe8\x35\x09\x9c\xf5\x1c\x2d\x88\xdb\x27\x14\x6f\xa4\x28\xb9\x8d\x24\x23\x30\xe6\xcd\xca\x2f\xc8\x54\x5f\x3d\x52\xc4\x96\xd0\x71\xeb\xa3\x68\x36\xea\xa7\x36\xee\x1f\xa6\xea\x1f\x8a\x2a\xa4\xbb\xa7\x19\xaa\x98\xd7\xa9\x45\x85\x52\x3f\x4c\x6e\x22\x37\x56\xa6\x16\x03\x81\x8d\x87\x60\x6c\xe6\xda\xfc\xf1\x03\x89\xc8\x22\x3e\x07\xc5\x85\x9f\x83\x10\x70\x02\xf0\x21\x9d\x04\x6f\x21\xa9\x84\x3d\xc4\x87\xa2\xa9\x44\x2a\x91\x8a\xa6\x32\xa9\x50\x2a\x94\xca\x24\xdc\x09\x7b\x28\xd5\x8d\x75\x5d\x5f\x48\xb8\x59\x3f\xb8\x79\x05\xd4\x37\xd5\xb1\xf1\xac\xfa\xf3\x05\x5a\xf3\x8f\x8c\x65\xb3\x63\xb9\x91\x40\x40\xc9\xe5\x94\x40\x60\x24\xa7\x5d\x53\x62\x68\x01\x84\xb3\xe3\x30\xa2\xdc\x63\xc0\xd9\x40\x36\x90\x55\xc7\x8c\xa2\x31\x00\x63\xe3\x81\x5c\xc0\xe0\x51\x3c\x86\x40\x2e\x30\x0e\x63\x01\xa3\xb6\x11\xcc\x06\x7c\xb3\x4c\x74\xff\x90\x2d\xe8\x9f\x70\xc8\xa3\x4b\x27\x34\x32\xd7\x19\x4c\x65\x68\x7b\x46\x33\xc1\x4c\xd0\xcd\x53\x00\xee\xc1\x14\xa3\x4c\x28\x8a\x72\xf2\xcd\x6c\x00\xc6\x03\x24\x17\xc8\x62\x45\xfb\x5a\x53\x83\x6a\x36\x97\xcb\xbd\x79\x12\xb2\x59\x45\xc9\x05\x26\xc7\xa7\xf9\x4c\x4d\x20\x14\x2e\xbb\x4b\xad\xd2\x7b\xd4\xe1\x41\x28\xfe\xe1\x59\x38\x40\x54\x8f\x4f\x45\x65\xbf\xb5\xb8\xe8\x39\xb5\x52\x76\x9b\xd3\x65\x57\x6a\x8e\x0e\x23\x2a\x3e\xd2\x26\x04\x35\xe7\x8d\x44\xc8\x37\xaa\x74\x13\xab\xca\xf5\x61\x7c\xb9\xce\x54\x2e\x35\xa7\x97\x2d\xa7\xbf\x4b\x2f\x55\xb6\xba\x64\xba\x33\xd7\xac\x5e\xba\xe9\x19\xf0\x9c\xe9\x05\xc3\xa8\x0d\x2d\x23\x7f\x61\x12\xc8\x81\x9a\xb4\x1d\x6d\xb5\x2f\x5c\xde\x08\xcc\x4c\x91\xf8\x5a\x53\xdc\xe4\x35\xa9\xed\x26\x13\xbc\x6a\xf2\x9a\xe2\x26\x93\xba\x17\x0e\xc3\x91\x19\xa3\x9f\xa2\x21\x1a\x03\xaf\x9a\xf4\x24\x7b\xd5\xbd\xa6\x99\xa3\x75\xbf\x6a\x68\x19\xf9\xb7\x62\xb9\x50\x59\xb7\xa5\xec\x53\x97\x99\x29\x12\xaf\xd6\x5e\xae\x3f\xf7\xb0\xba\x57\x7f\x28\xbc\x0a\x47\x66\x8c\xc6\xcb\xf4\xb2\xd2\xab\xc3\x70\xb8\x50\xe2\x76\xd3\xcc\xd1\x5a\xb9\x96\xa1\x8f\x31\x09\x66\xf5\xb4\xf6\x9a\xee\x1f\x42\x9a\x29\x92\x49\x9c\xaf\xd6\xd3\xa2\xdf\x39\xab\xa8\xda\xfb\xe1\xfa\x19\xa3\x91\x5e\xae\xa7\x98\x04\x73\x6d\x65\x7b\x55\xf9\x98\x90\x66\x8a\x64\x12\xe7\xae\xee\x0c\xd1\xf8\xa9\xb3\x3b\xd7\x64\x8a\x6b\x05\x9b\x21\x5a\x9b\x8b\xda\xd0\x32\x7c\x2d\xed\x47\xad\x54\x46\xa8\x76\xb7\x8c\xaf\x2d\xa6\x9e\x36\x6e\xc8\x3b\x33\x37\x16\x9d\xdf\x04\xb4\x0c\xaf\x2e\x3d\xf3\x43\x0f\x82\x73\xf5\x36\x7d\xe6\x32\x10\x98\x04\x59\xad\x3f\xf3\x1f\xe8\x40\xb8\xf2\x5c\x7d\xa2\x3d\xb3\x8d\x49\x90\x6b\xcb\xe5\xfc\x90\x8d\x4f\xda\xce\xd1\x9c\x05\x39\xb4\x4e\x37\x76\xe8\x78\xa9\x95\x28\x3d\xba\x2c\xdf\xe1\x2f\xed\xc8\x93\x7d\x90\xaa\x98\x43\x78\x24\x0b\xef\x53\x12\x81\xcb\x52\xd9\x7e\x7e\x3c\x10\xd0\x9d\xa4\x07\x02\x79\x0a\x91\xc4\x65\x07\x36\xe1\x00\xa1\x34\xc5\x24\xd5\x0d\x5e\x36\x91\x1b\xd8\x14\x5e\xd9\x2b\x68\x73\x88\xd8\x33\x1c\x29\xab\xa3\x55\xe8\x80\x58\xa9\xc5\xba\x36\xb7\x4d\x97\x34\x84\xa0\x02\x7b\x4e\x2b\xab\x46\x02\x16\x68\xc6\x04\x1b\x4f\xb6\x40\x83\x23\x01\x63\x25\x25\xb7\x81\x89\x31\x59\x60\xe8\xeb\x27\x72\x82\xcc\x8e\x8c\xe9\xb0\x4d\x63\x64\x97\xcd\x36\x66\xb3\x01\xd2\xd1\x43\x75\xf4\x5b\x32\x52\x66\x70\xcb\x93\xab\x29\xb3\x7a\x64\x24\x10\x28\xe9\x83\x33\x3a\xad\xe3\x46\xd1\x32\x9d\x13\x9e\xb1\xd5\x2a\x59\x06\x3a\xce\xc3\xe7\x0a\x2d\x20\x10\xbd\xb1\xca\x58\x78\x3b\x28\x03\x61\x5c\xe7\x28\x4f\x6a\x25\x20\x2f\x4d\x53\xd4\x63\xf4\x02\x50\xbe\x89\x5b\xd7\x46\x3f\xd7\xdb\x31\x6d\x82\x6e\xa8\x76\x61\x00\xaf\x50\x40\x24\x34\x25\x0b\x2a\xa2\x75\x44\x82\x9c\xd3\x9a\x60\x0c\x66\x0d\x25\x55\xa4\x73\x1f\x92\x43\x9b\x75\xdc\x24\xda\x04\x3a\xbf\x9f\x2c\x0b\x04\x02\x93\x34\x01\xa3\x1d\x2b\xd7\x1f\x33\x72\x23\x84\x0a\x9e\x6a\xfb\x40\x17\x4e\x96\xbc\x3c\x7f\xbc\xe4\x94\xf6\xbe\xfb\xce\x72\x4b\xcb\x8c\x55\x38\xad\x7d\x6e\x26\xac\x87\xc2\x9a\x1e\xa4\xde\x7f\xca\xf5\xe9\xc3\xdd\x50\x74\x74\x5c\x72\x43\x56\xe9\xee\x67\xe6\x04\x04\xed\x1a\x56\x95\xe1\x5d\x2b\x8f\x3c\xb7\x93\xae\x66\xd9\xd1\xe3\x9d\xb1\xf1\xe1\x5d\x44\x39\xc7\x0d\x9c\xd5\xa2\x77\x0d\xe3\xdc\xce\xe7\x8e\xac\xa4\x4b\xdf\xf1\xd1\x40\xac\x53\x4f\x3e\x43\x3c\x9a\xb1\xdc\x22\xae\xd8\xe6\xa4\x7b\xf5\xed\x4c\xa5\x9b\xa2\x0f\x4e\x40\xd0\x59\x05\xdb\x35\x0c\x8a\x56\xee\x73\xdc\x60\x72\xf9\x6c\x75\x89\x81\x96\xf8\x1c\xf1\x88\x62\xe5\x65\xa7\xb2\x94\x5f\x68\x44\x76\x8a\x8a\xa6\x7d\x7f\xdd\x05\x5b\x03\x1d\x47\x27\x5e\xb2\x18\x2c\x5a\x17\x38\x74\xf6\x6b\xd9\xde\x60\xe6\x14\xba\xd6\x1e\x16\x07\x53\xc9\xa1\xc1\x51\xdc\xab\x0b\xd7\x8f\xd2\x13\x93\xa7\xae\x02\x46\x07\x27\x7b\x36\x1d\xda\xb4\xe9\x10\xf3\x6e\x41\xf4\xae\x03\x9a\xdd\x72\x68\xe3\xc5\xb7\xde\x7a\xf1\xc6\x43\xdf\x1d\x1d\xd4\x12\xaa\xff\xa5\x53\xeb\xba\x20\x3d\x7f\x97\xf6\xc0\xc1\x41\xf2\xbf\xb5\xac\x9b\xf2\x9f\xd1\x6f\xea\x26\x09\xea\x35\x7a\xce\x43\xd3\x75\x46\xcc\xba\x1e\x65\x71\x94\x72\xd5\xa8\x24\x05\xdd\xc6\x8a\xc1\x38\xcd\x7f\x2d\x38\x88\x88\xf9\x22\x88\x69\x3a\x95\x6c\x67\x5b\xa6\xeb\x5f\x39\xed\x89\x80\xec\xe2\xd1\x41\x62\xb5\xf0\x16\x9b\xd5\xce\xb2\xa1\xbe\x2d\xbb\x3f\xf1\xc9\x2d\xe3\x11\xea\xae\x56\xdb\x43\x26\x23\xe3\xf8\x7f\x3d\x92\x82\xb1\xcf\xa9\xbf\xe6\x1b\xbc\x46\xbb\xc3\x6a\x0c\x71\xf3\x33\xdb\xc7\xf6\xac\x4d\xd7\x5b\xa6\x90\x37\x42\x93\x69\x87\x88\x77\x0a\xa9\x57\xde\x56\xc2\x92\x45\xf4\xbb\x9b\x8d\xd6\x6b\x2b\x81\x08\x0d\xed\x90\xa4\x5e\xf6\x2a\xc2\x6e\x1d\x55\xaa\x21\xaa\xeb\x47\xfa\x49\x37\xc4\xfb\x88\xec\xe0\x45\x26\xd4\xd0\xce\x44\x8b\x92\x31\x9d\x6f\xee\xee\x83\x04\x65\xfe\x62\xa5\xa6\x77\x4d\x6f\x8d\x76\xc0\x9f\x28\x05\x9f\x3d\x72\x7d\xd3\x83\x8b\xbe\xb0\xe8\x44\xcb\xf5\x47\xb2\x5b\xee\xbb\x6d\xd5\xe3\xab\x6e\xbb\x6f\x4b\x76\xbc\x37\x72\xfb\xb1\x7f\x39\xbe\x71\xb9\xf2\xd8\x91\x3b\x46\x83\x7d\x77\xd4\x26\xae\x78\xf4\xf2\x63\x8f\x7c\xfc\xd0\x65\x8f\x5e\x9e\xa8\xbd\x03\x76\x0e\xaf\x99\x3f\x7f\xcd\xf4\xc3\xbe\x1b\x1e\x77\x9a\xcd\xce\xc7\x6f\x58\x7f\xeb\x60\x9b\x28\xb6\x0d\xde\x0a\x86\x1f\xed\x5b\xb6\xab\x27\x64\xe4\xe4\xa6\xbe\x6d\x73\x6f\x7e\xe5\x9d\x93\xab\xd6\x5f\xb7\x63\xc5\x9a\x50\x60\xd5\xf2\x1d\xd7\x5d\xb0\x72\x6c\xfa\x77\xe5\xd6\x7a\xa1\x30\xef\x69\x5f\xcd\x07\xce\xbe\xba\xb7\x24\xd4\x19\xcb\x67\xcb\xe2\x67\x26\x17\xeb\x3c\xcb\x81\xd2\x38\xa6\xf7\xb2\x25\x48\x41\xfc\x56\xb5\x47\x25\xdd\x8f\xe5\x1e\x56\x41\x76\x14\x45\x0b\x10\x82\xa4\x0e\x62\xc7\x39\x1d\x14\xb4\x17\xd2\xe1\x60\xaa\xba\x60\xd0\x07\x6c\xd9\xf3\x52\x65\xb9\xa8\xc4\xdc\xed\xe2\xde\x4b\x4d\xe4\x62\x1b\xbc\xea\xcf\xa4\x14\x93\x8d\x6d\xac\x81\x88\x34\x71\x94\xa0\x22\x76\xa1\x56\x68\x40\xad\xf7\xb0\x5d\xed\xea\x4f\x5b\xee\x9b\x37\x91\x2b\x95\x3b\xb0\xf1\x50\x2e\x7d\x91\xcb\x8a\x2f\x0e\xb5\xd4\xab\xf7\x7b\x6c\xa1\xd6\x7a\xb8\xdc\xf5\xcf\x63\xe5\xaa\x3c\x09\xdd\xa9\x05\x9f\xe9\x9b\xa3\xde\x9f\x5a\x50\xae\xcc\xc6\xb1\xd9\xed\x81\x92\xff\xa2\x82\x3f\x72\x1f\x6a\x44\x49\xea\x65\x88\x8a\x50\x23\x14\x6e\x84\xe2\x41\xf7\x81\x1f\xaa\x41\xfd\x90\xad\x1d\x07\x44\x6c\xf3\xe3\x40\x1f\x48\x95\x4e\xca\xaf\x0a\xff\xab\xfa\xaf\x61\x83\xc7\x5b\xd3\x61\xa8\xb9\xfd\xf1\xdb\x6b\x0c\xb3\xe2\x1e\xd5\xa4\xeb\xd2\x0c\xea\xba\x34\x83\x3b\x9e\x7c\x47\x9d\x7c\xe7\xc9\x1d\x3b\x9e\x7c\x07\x98\x77\x9e\xfc\x6d\xb5\xa3\xf5\x97\x6e\xfc\xf8\xc7\x6f\xac\xe9\x30\x18\x3c\xde\xe1\xad\x5b\x87\xbd\x1e\x5b\x07\xfc\x68\x54\xcf\x4d\x3f\x7d\x55\xcb\xb6\xa3\xfc\x18\x9c\xad\xfe\x6e\x67\xae\x9b\x8b\xc2\xf8\xe9\xf2\xfe\x68\x3b\x64\xb4\xcf\xe5\x1f\xa8\x9b\xc1\x13\x9f\x55\xa8\x55\x47\x8d\xd7\x63\xd0\xea\xaa\x66\xfe\xb1\xba\x25\x6a\x3a\x6c\xc5\x6a\x19\x0c\x1d\x35\x37\x7e\xfc\xe3\xd8\xf8\x3f\xad\x9b\x99\xea\xee\xb7\xa0\x4c\x59\x0f\x51\x1b\x62\x1f\xbe\x4a\x4a\xc4\x9b\xa7\xfb\x4d\xac\x78\xd5\xc8\x3f\x56\x13\x5d\x28\x08\x5f\xf9\x87\x0a\x5f\xa0\xf3\x18\x54\x58\x65\xe6\x7d\x38\x0e\x09\x53\xa5\xdf\xd5\x68\x43\xa1\x86\x68\x88\xd3\x21\x20\x82\x71\x92\x95\xc4\x9c\x24\x2a\xa2\xa4\x5b\x3c\x14\x83\x38\x5b\xa8\x4c\xe1\xa4\xbe\xf6\x5a\xee\xbe\x37\xee\xcb\xbd\xa6\xbe\x06\xad\xaf\x11\xe5\x35\xc8\x9d\x95\x47\x0b\x5e\x4a\xab\x53\xd0\xf0\xa2\x38\xe5\x8a\x02\xad\xf0\x38\xb4\x22\x8d\x42\x2d\xf2\x45\xb4\xb9\x38\x84\x3a\xe8\x5a\xb9\x1a\x6d\x46\x97\xa3\xbd\xe8\x56\xca\x79\xfd\x0c\xfa\x32\x95\xe2\xb7\x40\x43\x2f\x24\xbb\x21\x9e\xa9\x08\x47\x2b\xc2\xe0\x74\x84\x82\x5a\x38\x11\x8c\x87\xcf\x9d\xe6\xbc\xf1\xe7\x0a\xb3\x95\x61\x7b\x29\x9c\xd2\xae\x65\xea\x9d\xac\x5a\x26\x60\x1b\xb1\xd9\x46\x6c\x8a\x6d\xdc\x66\x1b\xb7\x15\xae\x18\x64\x9b\x1c\xb3\xd9\xc8\x88\x2d\x5f\xba\x4f\x4f\x30\xf3\x65\xf1\xac\xa2\xc2\x75\xf9\x3c\x6e\xb3\xed\xd2\x32\xbc\xaf\xf0\x68\x30\xf5\x3e\xc5\xce\xe4\x94\xd4\x20\xec\xa2\x29\xde\xad\x38\xe6\xdf\x3d\x2b\x4a\x9d\xe1\xa2\x70\x02\xfd\x54\xf8\x53\xc7\x68\x3a\x5b\x1e\x11\x65\x52\xd1\x7e\xda\x8b\x88\x76\x44\x05\x1c\x4d\x9d\x57\xe7\x42\xcd\x68\x9d\x46\xad\x15\x75\x83\x78\x3b\xf5\x13\x42\xb1\x01\xa0\x4a\x6c\x58\x90\x0e\x16\xad\xe3\xda\x71\xa8\x81\x29\xa1\x47\x64\xa8\xda\x6b\xd1\x62\xcc\xed\xe2\x94\x27\x0e\xaf\xea\xdf\xf6\xf8\xa6\xa7\x7e\xfb\xde\xa9\xcc\x25\x5b\x33\x19\x5f\x6b\xd7\x0d\x13\x57\x86\xea\xa8\xbc\xab\x2e\x34\x38\x3a\xc8\xe6\x42\x26\xfe\x67\x0f\xac\x5f\xe8\xcb\x2e\xdc\x35\x67\x87\xfa\xde\x66\xab\x64\xb3\x05\xea\x43\x17\x7c\xec\xd1\x25\xbb\xbe\xb3\x2b\x92\xb8\xe9\x94\xcb\x58\x5f\x5f\x0f\x7f\xc0\x3b\x37\x04\x66\x67\x0e\xe6\x9f\xd8\x6d\x0d\xd7\xd4\x8a\x2e\xb2\x3b\x34\xc7\x3e\x21\x52\xf9\xdb\x9f\xed\x73\x42\xa9\xc1\xc1\x3d\x79\x36\x2a\xb1\xcc\x75\x21\x31\xe8\xf7\xad\x9f\x63\x34\xc8\x61\xfc\xdb\x90\xc3\xd9\xd2\x1b\xe9\xcb\xc8\xbb\x2c\xac\x4d\x72\x20\xc4\x95\xea\xce\x22\x33\x6a\x46\x71\xb4\x10\x5d\xa3\x7d\x87\x1c\xef\x4c\xcb\xf4\x08\x29\x2e\x9a\x8a\x44\xdb\x8d\xa1\x06\xde\x49\x2b\xe5\x76\xba\x12\x71\x39\xa5\xd5\xd5\xe9\xfa\xff\xd5\x2c\x24\xfb\x95\x17\x5f\xfa\xf2\x17\x5e\xfb\x31\xf9\xdd\x1f\xee\x77\xc8\x6c\xa7\x10\x97\xdb\xbd\xad\xa1\x56\x97\xdb\x2b\xef\xf8\xca\xe5\xb2\xa3\x79\xf6\x0d\x4f\x3d\x71\xb8\x2d\xf8\xf1\x89\x2f\xfc\x8f\xda\x0a\x7b\x72\xb6\xed\xcf\x8e\xc0\xd3\xdf\x33\x5c\xff\xdc\xd5\x6a\xe7\xd7\xaf\x6b\x1b\xe7\x8c\xc4\xc7\x79\x78\x99\x33\x33\x0c\xf9\xe5\x9c\x94\x91\x3b\x65\xc7\xfc\x73\x1b\x0c\xcf\x37\xc3\x1f\xff\x67\x0d\x89\x91\xa0\xd1\x25\x94\x7f\xd0\xa8\x7b\xe3\xac\xe2\x1f\xb8\x1c\xd5\xf6\xa7\x78\xc9\x4c\x0c\x05\x13\xd3\x26\x89\x93\x54\x10\x4a\xb4\x59\xab\x69\x66\x2e\x8a\xda\x56\x61\x79\xa7\x8d\xe1\xb6\xa9\x63\xfc\x6a\xe6\x1d\xfa\xfe\xae\x82\x8f\xd1\xe9\xec\x35\x97\xc3\x08\x22\x74\x40\x3b\x64\xa0\x8f\x42\x58\xcf\x58\x4c\x7c\xd9\x4c\xdc\x36\x13\x5e\xa0\x1e\x65\xdc\x96\x3e\x41\x60\x60\x8f\x1e\xc0\x1f\x9b\xb1\x02\x87\x67\xe6\x44\x31\xc1\x33\xef\x09\x02\x63\x67\xdc\x02\x6b\xd6\x03\xf9\x9d\x33\x57\xae\xac\x1b\xff\x4d\xe4\x44\xdd\x74\xf6\x2c\xc0\xd3\x68\x15\x72\xbb\xea\x80\x02\xd6\x39\x44\x52\x00\x71\x90\xa2\xed\x10\xad\x4a\xe4\xb4\x33\x6e\x17\x56\x28\x82\x8d\x4e\x6e\xd7\x35\x45\xd5\x6b\x65\x99\x13\x1a\x5a\x52\x3e\xce\xe0\xe0\x48\x0d\x6e\xb9\x3f\xfb\xfa\xc3\xd3\xd3\xc0\x27\x4f\x3d\x01\x2f\x2c\x6c\xb6\xb3\x45\xda\xbb\xde\x6e\x6f\x5e\xa0\x5e\x23\x27\x65\x75\xd9\x9c\x07\xf6\xef\xef\xb4\xd8\xc1\xe0\x85\x7b\x3e\xbb\x68\x85\x30\x51\x95\x4e\x3d\xe3\xfb\x97\xa7\x74\x5a\x15\x4f\x3d\xc5\x1d\x60\xc7\x91\x09\xc5\x10\x82\x36\xe8\x00\x62\x77\xb3\x24\x6a\x04\x99\xe2\xb7\x86\xa9\xcf\xa3\x8c\x0c\x91\x74\x26\x2c\x6b\x14\xb8\xcc\xfa\x81\x79\x04\x40\xfd\xd4\x80\xff\x64\x37\xf4\xf5\x58\xe0\x3d\xf5\xfe\x75\xac\xcb\x6d\x77\xab\xfd\x6a\xbf\xdb\xee\x76\xb1\xeb\xd4\x8f\x07\xa4\x36\xf8\xeb\x9b\x8e\x3a\x9f\xf3\x4d\xf8\x6b\x9b\x84\xe7\x9d\x49\x9a\x7a\x60\x60\xb2\xb7\xfe\x71\xd8\x3a\x00\x29\xf5\xd3\xaa\x25\x18\xb6\xbc\xfd\xb6\x25\x1c\x84\xff\x86\x2d\x81\x0c\xbf\x04\xbe\xdf\xd4\xa4\x76\x2d\xe1\x33\x25\xec\x5d\x85\xea\x18\xa3\x32\xa8\x7e\xb0\xa1\x1d\xd2\x54\xc1\xcc\xed\x07\xf6\xc6\xbc\x62\x8f\xb1\x26\x57\x6d\x3e\xe7\x0a\x99\x24\x07\x8b\x04\x5b\xad\x64\xe5\x99\xcf\x4c\xa0\x10\x66\x43\x2e\x9c\xad\x6d\x8d\x99\xb0\xc2\xcb\x62\x53\x11\x6b\x53\xa3\xcd\x31\x62\x51\x27\x45\xf0\x37\x42\x50\x97\x00\x96\xc4\x7c\xc1\x82\x2e\x85\xbe\xd1\x2d\x3b\xa1\xce\xa4\xe3\x6e\x97\xc3\xaa\x2b\xbd\xb4\xe1\xd5\x79\x05\xaf\xce\x3f\xc5\x28\x45\x51\xc5\xe4\xd8\x34\xc9\x05\x59\xfd\x57\x93\xd7\x64\x34\xfe\x8d\x0a\x76\xf0\xea\xfc\xcf\xf0\xea\xfc\x48\x85\x74\x83\x8c\x54\x48\x38\xfe\x66\x34\x9a\xbc\xa6\xbf\x4e\x3e\x25\xa1\x82\xff\x22\xa6\xec\x47\x65\xb0\xcc\x47\x91\xaa\x74\xc6\x33\x0e\x8e\xd7\x7d\xc4\xd4\x01\x65\x80\xd1\xed\x5e\xa6\x38\xcf\x39\xb5\xb9\x2f\x9d\xe9\x63\x53\x85\x08\x08\x74\x0e\x77\x16\xff\xf0\xd7\xe9\xe9\x44\xb2\x15\x8f\xcf\xbb\x43\x59\xdd\x9a\xdc\x35\xb6\x2b\xd9\x5a\x38\xa5\xb7\x65\xe6\x0e\x35\x47\xed\xf4\xd2\x43\xb3\x30\x5f\xa7\xa7\xc5\xf4\x38\x92\xbc\xb0\x46\x7d\xf3\x60\xa4\x25\xd6\xb7\xc0\x5b\x73\x61\x52\xdb\xb8\x27\x2f\xac\x21\xc9\x72\x58\xb5\x7a\xeb\xed\x35\xe1\xe6\x9e\x15\x85\x48\x1d\xeb\x5e\xa1\xb6\x9c\x02\xaa\x41\x61\x94\x45\x1b\xd1\x4e\x74\x1d\xba\xa5\xe0\x21\xb8\xc0\x79\x74\x39\xdc\xba\x4e\x2c\xd5\x71\x89\x54\xd0\x8b\x6c\xc9\x46\x21\x9a\x01\x3f\xf4\x03\x85\xa8\xc8\xb8\xdc\xe0\x02\xbe\x04\x96\xe3\x06\x3e\x42\x95\x11\xfb\x0b\x86\x08\x4c\xc5\x23\xa0\xe2\xd1\xec\xb4\x97\xc2\xd7\xa6\x90\xd9\x63\x36\x1a\x01\x69\x9d\x37\xa6\x7b\x5a\x1a\xaf\xb0\x85\x65\xb1\x0e\x81\xa3\x3e\xe3\x74\xfe\x09\xec\xb5\xab\x6a\x8f\xf9\x7c\xea\x1f\xa5\x90\x13\x86\xd7\xe4\x1f\xf8\x93\xfa\xa7\x02\x9c\x0e\x48\x52\xc8\xa9\x3e\x5d\x40\xcc\x81\xe5\x4e\x7c\x57\xc5\x63\xf2\x7f\xd6\x1f\x0d\x0f\x4c\x7b\x21\x18\xa7\x10\x1d\x09\x40\x4f\x89\x0a\x73\xdc\x71\x9a\x7e\xec\x86\xd5\xf7\xad\x5e\x0b\x2b\x9c\x21\x49\xfd\x63\x2d\xe8\xe0\x3a\x20\xff\xc9\xe9\x54\x9f\x5e\x87\x37\x49\x20\x15\x00\x77\xd4\x3f\xbe\xeb\x74\xc2\xf0\xba\xeb\x69\x06\xf5\x4b\xce\xcb\x74\xa7\x51\xa8\xe2\x91\x9f\x9d\xf6\x32\x6d\x3e\x18\x41\x88\x4c\x52\xbe\x66\x8f\xae\xd7\x39\x4d\xf2\xad\xcd\x66\x62\x65\x2c\x55\x74\x2f\xc0\x42\xd3\xb5\x14\x32\x52\x30\xee\xc7\x38\xe7\xb1\xbd\x6b\xf3\xd0\x03\xf4\xd4\x47\x17\xb5\x46\x9b\x32\x1e\xdb\xbb\x56\xe7\x2d\xcb\xbb\xe3\x17\xf7\xce\x6d\x09\x2d\x16\x24\x8b\xf0\xa8\xc0\x1a\xc6\x60\xd6\xf0\x23\xb7\xac\x02\x4f\x31\x83\x07\x2f\x4e\x6f\xea\xee\xa9\x75\xb9\xd7\xd4\xd8\xeb\xc3\x72\xdb\xea\x63\xa1\xda\x39\x1d\xcd\xd9\xba\x9a\x8b\x6c\x86\xfd\x26\xbf\x00\xa6\xbe\x9d\x0f\x14\xf7\xda\x58\xfb\x9e\xfd\xa8\x7d\x3a\xf2\x85\xee\xa6\xb7\xb8\x90\x39\xb5\x6f\x96\x54\xaf\x6e\x8a\xce\x03\x8e\x78\xb3\xd9\xa2\x2b\xec\xac\x37\xa2\xe8\xbe\x68\x74\x20\xb2\x12\xec\x05\x28\x05\xc1\x58\x3e\x17\x61\x76\x50\xc1\x92\x6e\xf8\x8a\xd1\x16\x84\xb0\xbf\xe4\x77\xa4\xea\x25\x32\xd1\xf7\xd3\x51\x12\x29\xd8\x70\x57\x3e\xde\xef\x83\xa8\x76\x19\x05\x1f\x84\xbd\x90\xf5\x86\x21\x30\xae\xdd\xd4\x0e\x0c\x97\xa7\x09\x09\x05\x44\xd3\x66\x2c\xc4\xaa\xec\xe5\x28\x8c\x96\x6a\x75\x0d\x75\x40\x24\x4a\x5d\x1c\x5a\x21\x98\x4a\xc8\x24\x94\x0a\x52\xc8\x83\x44\xba\x1f\x07\x9d\x21\x22\x83\x33\x48\xd5\x89\x99\x62\x1f\x45\x75\x1f\x36\xd4\x52\x27\x91\x22\x1f\xf9\xfb\x49\x8f\x81\x10\x20\x0c\x98\xac\x9f\x54\x55\xe5\x7b\xcf\x1e\x06\xc7\x51\xec\x34\x10\x42\x0c\x35\x77\x02\xec\xff\xfa\x0f\xf1\xef\xf3\x2a\x61\x92\xcb\x2f\x5a\x9e\xec\x6e\x4a\xb4\x8b\xae\xcb\xbc\xe1\xd5\x97\x5d\x75\xc7\xec\xc1\xf5\x43\x19\xf2\xd6\x63\x8f\x4d\x36\x1b\x2d\x84\x37\x62\x87\xe7\xcc\x63\x10\x02\xdb\xe3\xbf\x61\x22\x46\x8b\xd1\xd2\xfc\x9b\xc7\xd5\xf7\xd4\x9f\xe0\xc7\x5e\xae\xf5\x49\xd9\xd1\x79\xfd\xed\x7d\xc1\xc8\xec\xa8\xb9\x76\x63\xb8\x6e\xee\xde\xad\x9d\x9b\xba\xe7\xb4\xf4\x04\x87\xf5\x75\x88\x9d\x42\x1c\x22\xb7\xa0\x30\x5a\xf2\xe1\xea\xc6\x9e\xbb\x6e\xe4\xc3\xd7\xed\xed\xbc\xca\x90\xe9\x75\x1b\xbe\xe2\xaa\x3b\x16\x6c\xdd\xb6\x94\x39\x7f\xd5\x7e\xfa\x72\x6d\x1b\x9c\x5d\xb3\x81\xcb\xe6\xcd\x99\x1f\x1d\xa6\xf5\x02\x84\xf8\x83\xac\x8e\x37\x87\xc2\x10\x34\x82\x8b\xe3\x81\x8e\x90\x68\x84\xae\x63\xc1\xb8\x8b\x28\x30\x9c\x47\xea\xd3\xdc\x7b\x56\x73\xcd\xa4\x12\x99\x93\x47\x91\x7e\x9b\xd5\x5c\x43\x94\xc8\x1c\x82\x22\xfd\x14\x67\x8f\x49\x35\x0c\xfa\x26\x51\x6b\x53\x43\xc3\xa0\x8f\x41\xad\x4d\x3a\xbf\xef\x0d\x3a\x97\xee\xd4\x31\xb2\x28\x7a\xb6\xd3\xe1\xe2\x9d\x0d\xbc\x88\x75\xf4\xe7\x92\xed\xb1\x1f\x17\xc8\x0f\xea\x23\x24\xda\x90\xb2\xfb\xb1\x4e\xe8\xa6\x92\xd4\x45\x52\x01\xa8\x84\x82\x4d\xa7\x33\x4e\xad\xf9\x9d\x0e\xb7\x8e\x3c\x1d\x77\x71\xca\x85\x2b\x9a\x96\xb4\xcd\x0f\x5f\x15\x00\x97\xb9\xe1\xe0\xce\xf6\xde\x35\xa1\xa6\xd0\x15\x2b\xd7\x5c\xef\x0f\xfb\xdb\xc3\xc3\x9b\x8f\x1b\xc3\x46\x01\x30\xc6\xf5\x61\x72\x7c\xf3\x70\xb8\xdd\x1f\xf6\x5f\xbf\x76\xf8\x8a\x50\x53\x68\x4d\x6f\xf6\xad\x0e\x60\x59\xf0\x84\x5a\xdb\x5c\x5d\xb3\x87\x5b\x56\x6d\x80\xaf\xae\xd4\x6e\xed\x8b\x9e\x88\xb2\x40\xec\xa6\x54\x57\x78\x7e\xdb\x92\xa6\x15\x17\x6e\x58\xd5\x32\x3c\xbb\xcb\xd5\xd6\x1a\xf2\x60\x06\x63\x00\x06\x55\x65\x2d\x94\xa4\x2b\xe5\xaf\x7a\x5b\x81\x2e\x63\x14\xea\xcb\x2e\x41\xbf\x47\xc4\x3b\x4b\xde\xd2\xa9\x02\x7a\x04\x69\x5f\x27\xe5\xbc\xa3\x40\x21\xac\x2d\x09\x01\xba\x24\x04\x5c\x8c\xa2\xfe\xf4\xa7\x14\x86\xb0\xc0\x6f\x00\xf4\x53\xf5\xa7\x91\x64\x44\x07\x59\x8c\x24\x23\x53\xe8\x94\xfa\xf7\x53\xa7\xc0\x70\x8a\x64\x95\x5f\xa8\xcf\x7a\x0e\xe9\xca\x95\x87\x3c\xb0\xe8\x17\xfa\x94\xa1\xe3\x37\x52\x94\x9c\x1d\x2a\x3a\x74\xea\xd4\x21\xac\x1d\x11\x41\xc2\x94\xc2\x5e\x4b\xf5\x5d\xe7\x69\x2b\x3b\xf0\x91\x52\x71\x8c\xa0\x6b\xd1\xf3\xae\x44\xbc\xa2\x90\x67\x55\x20\xca\x57\x62\x1e\xb8\x1c\x61\xd0\x41\xd0\xc1\xba\xbd\x39\x92\x8c\x30\x97\xa9\x0f\x9c\x3a\x94\x49\x8f\x5c\x72\xc5\xb3\xb4\xbc\x67\xd5\x67\xff\x55\xaa\xc9\x6b\x5a\x65\x32\x31\xaf\xd2\xb3\x7a\x53\xfe\xd8\xa9\x43\x3b\x3e\x8b\x57\x6c\xbf\xf4\x6a\xbd\x02\x29\xec\x57\x1f\x50\x0e\x9d\x92\x47\x12\x85\x8a\x78\xa7\x55\x55\x98\xaf\x9a\x4c\xab\x4c\x5e\xed\x11\xda\xf9\xa6\xfc\x31\xad\x86\xd7\x97\xf4\xa4\x75\x3f\x49\x0d\xba\x9e\x43\x3a\x93\x96\xed\x0e\x91\xa5\x0e\x2f\x4b\x58\xe4\x4c\x56\xcd\xee\xdd\xf4\x87\xdc\xbc\xad\x87\xaf\x3b\x90\xb2\x59\x7c\x16\x5b\xea\xc0\x75\x87\xb7\xce\xd3\x15\x5e\x70\x16\x2b\x13\x77\xf7\x2f\xfd\x3a\x79\x3a\x8f\xd6\x3d\x71\xeb\xbe\x55\x4b\xbc\x3c\xc7\xf1\xde\x25\xab\xf6\xdd\xfa\xc4\x3a\x7d\x62\x2c\xd0\x4b\xa8\x84\x0f\x11\x42\x8b\x10\x72\x07\xed\xc1\x70\x95\xf6\xc3\xd9\xd7\x55\x16\x43\x05\x42\xaf\x14\x4a\xc4\x5d\x0a\xab\x9c\x51\xa0\x02\xe2\x85\x54\x28\x81\x82\x32\x94\x3c\x43\xbd\x2d\x2a\x9b\x06\xb2\x03\x9b\x40\x3f\x29\xc9\x21\x85\x41\x39\x08\x50\x10\x0d\x4a\xdf\x55\x84\x97\x4f\x50\x11\x15\x8b\x92\x43\xba\xe7\x3c\xfd\x38\x44\xdb\x8d\x50\x9a\x77\x1c\xf1\x68\xa8\xac\x5f\x1e\x2e\xc0\x3a\x86\xdb\x21\x15\x74\x4e\x57\xac\xcd\xa4\x42\x0d\x85\x3d\x46\x3b\x64\xfa\x98\xb2\x82\x74\x30\x99\xce\x84\x29\x5c\x0c\xd6\x35\xcb\xc9\xe7\x2c\x06\x0b\x43\xd4\xac\x59\x9c\x42\x57\xdf\xab\x2f\x7e\xfb\xb7\x06\xba\x77\x2d\xea\x75\x30\xf6\x98\x4d\x70\xdb\x2d\xac\xdc\x39\xf7\xb2\xce\x9a\x4d\x87\x36\x89\xd0\x2e\x9a\x21\x47\x18\x8b\xc1\xc2\xea\x7d\x3e\xa2\xe6\x6c\x46\x1e\x46\xb0\x64\xde\xe1\x7e\xfa\xda\x49\xba\x54\x91\xc0\xe8\x13\xfe\xab\x3b\xba\x97\x06\x0d\x21\xde\x12\xf7\x98\x02\x83\x73\x17\x48\xcd\xad\x5a\xad\x82\xf5\x66\x09\x8f\x00\x6f\xd4\xea\xd6\x38\x15\xe0\x74\xb9\x64\x5b\x85\x07\x5a\x87\x46\xbd\x12\x8e\x67\x75\x04\x9f\x8c\x0c\xa5\x90\x56\xfe\x4c\xba\x31\x18\x77\xb1\x63\x94\x50\x05\xcf\x03\xcf\xac\xbc\xc6\x81\x45\x55\xe1\x8d\x16\x73\x56\x60\xd7\xaa\xff\xa5\xbe\x4d\x38\xd1\x98\xb5\x5b\xc6\x4d\x36\xb8\x79\x64\xf8\x14\xac\x01\x56\x74\x30\x3a\xc5\x0a\xca\xfb\xea\xfd\x5f\x1e\x1e\x51\x3f\x6a\x33\x8d\x33\x46\xad\xd3\x1c\x50\xb3\x16\x8c\x59\xd9\x01\x8a\x88\x1d\xd7\xac\xfc\xe6\x5d\x72\xc9\xbf\xcf\x69\x7d\xbf\x01\x24\x28\xa7\xa3\x91\x16\xed\x1c\x24\x41\x99\x04\x29\xbe\x35\x77\xfa\x51\xf5\x99\x67\x04\x5f\x6d\xe7\x13\x3f\x54\x9f\xf9\xa1\xfa\x2b\xed\xf8\x09\x66\x72\xfb\x97\xba\x7b\x9a\xf1\x44\x9e\x25\xd9\xce\x40\x70\x72\x11\x79\x56\xfb\xc1\xa2\x95\x4b\x96\x7c\x7b\xba\x1e\x8c\x36\xe1\xa0\x70\x26\x9d\x8c\x1a\xa1\x88\x55\xcf\x51\x6b\x94\x4a\x51\x0f\xf9\xd8\x0e\x59\x56\x5f\x82\x84\x2c\xef\xd0\x76\x74\x73\x64\x19\x5e\x90\x93\xf8\xb6\x2a\xae\xe6\xc7\xb4\xbb\x90\x80\x84\x9c\x94\xb5\x1c\x73\xf4\xc4\xf8\xc7\xe7\xc4\x57\xd7\xdf\x0f\x69\x6a\x6d\x42\x31\xd5\x8d\x05\xf0\xf7\xca\xf7\xe3\x97\xe0\x85\xc2\xe3\x76\xc8\x32\x24\xd4\x97\x68\x41\xc8\xc2\xea\xf7\x6b\xa5\xd2\x8a\xa6\x17\xf3\x25\xf5\x25\x9a\xe3\x7c\xef\x87\x4c\xba\x68\xed\xa2\x43\xe0\x1b\xab\xde\xcf\x7c\xac\xa2\x36\x72\xb9\x92\x50\xdd\x00\xa0\xb7\x40\x75\x61\xa1\xba\x00\x33\xf4\x41\xb1\xf9\x8d\xc5\x86\xa8\xee\x83\xb6\xb3\xea\xa5\x77\x42\x35\x6b\xf9\x1d\xda\x08\xd5\x1d\x86\xf7\xce\xd0\x06\x59\x6a\x3b\x62\xa7\x23\x2c\x13\x94\x83\x56\xe8\x80\x90\xcc\x26\x52\x61\x39\x18\x85\x20\x61\xc3\xcc\xa8\x6d\xf2\xce\x0e\xbc\xcd\xf5\xbd\xe7\x85\x2f\xba\x60\x94\x81\x4b\xe3\xf9\x7d\x56\xb5\x93\x55\x94\xfc\xb7\xf2\xdf\x21\x4f\x7e\x31\xff\xfb\xdf\xa4\x52\x77\xaa\xbf\xdf\x06\x5b\x71\xe0\x2b\xf0\xfa\x99\x2d\x8f\x3c\x42\xc7\xaf\x65\x2a\xcb\xfd\x77\x01\x43\x2e\x68\xc4\x72\x90\x67\xc3\x72\x50\x0e\x66\x82\x20\xb3\x6f\xaa\x7f\x9d\x7c\x23\xbf\x70\x11\x34\xd5\xc1\xe7\xe0\xb7\xf3\x27\x16\xcf\x61\x9e\x8d\x4c\x2c\x66\x95\x33\x2f\xaa\xef\x81\x19\xb6\x1d\x7b\xf8\x61\x58\x0d\x4d\xdf\x2e\xb4\x95\x8d\xd7\x7d\x76\xac\xad\xf8\x56\xf5\x79\xa8\x03\x38\x26\xd0\x18\x3d\x0b\x87\xd6\x0f\xee\x8a\x6d\x73\xc5\x06\xd4\x99\x28\x4a\xb9\xed\x7d\x90\x29\x82\xd5\x92\x9c\x3e\x2b\xed\x70\x18\x18\x8b\xf9\xe2\xbd\xea\x6e\x35\xa9\xee\xde\x7b\xb1\x51\x64\x0c\x0e\x49\x84\x11\x97\xc1\x60\xdd\x36\xef\xbd\xfb\x75\x62\x7b\xce\xc2\xe3\xaf\x1d\x5f\x38\x47\xbf\xb8\xff\xbd\x79\xdb\xac\x06\x83\x0b\x46\x44\x89\xf9\x2d\x9d\x9b\x26\xc7\xd4\x31\x97\x01\x1b\x2f\xbe\xfb\xb1\xc7\xee\xbe\xd8\x88\xf5\x9b\x0e\xd9\xb6\x6d\xc3\x7e\x07\xbe\x9d\x52\xef\x9f\x69\xd8\xb3\x70\xf4\xf8\xf1\xd1\x85\x7b\x1a\x3e\x43\x23\xf2\x37\x3a\xf6\x6f\xd8\x66\x93\x1d\x92\xfe\xfd\x53\xba\x21\x74\x96\x8f\xad\x6e\xb0\xeb\x9e\x48\x0b\x48\x02\xd4\x5b\x2f\x13\x28\x3b\xf5\x0a\x14\x28\x83\x82\xbb\xaf\xb2\x48\x8c\x62\x01\x67\xa9\x3f\xaf\x67\xb5\x92\x6b\x6f\x57\x73\xd3\xe5\x59\xfa\x1e\x9f\x52\x2b\x65\xa4\xdb\x48\x80\xb3\xb9\x02\xc8\x86\x0a\xbf\x73\xc9\x44\x74\x08\x5b\x70\x15\x6c\x9f\xe0\x12\xdd\x51\x29\x65\xff\x7f\xe1\x3c\x42\x11\xfc\x7b\x1d\xb2\xf6\x12\xe8\x7b\x53\xcb\x8f\xd7\x94\xb2\xb6\xe6\x0f\x9c\x57\xb2\x43\xf9\x29\x18\xb1\x0a\x29\xe2\x69\x9d\xb5\x63\xac\xd6\x9d\x3e\x4b\x97\x5a\xe9\x8c\xd1\x76\xca\xc5\x3a\x31\x9a\x39\x4c\x02\xc5\xd0\x8c\x87\x92\xce\x0b\x94\x71\xbd\xce\x2a\x87\xfd\x3c\xd7\x95\xe5\x98\xe9\x00\xe5\x32\xc0\x4f\x66\x0a\x56\xfa\x9c\xe6\x51\x2d\x4a\xa1\x05\x15\xba\x2f\x11\x14\x8d\x50\x39\x11\xf5\x91\x00\x94\xf6\x88\xe0\x76\x68\x8c\x46\x78\x3d\xde\xc5\x48\xfa\x8d\xb3\x3d\x34\x62\x5d\x65\x18\x3e\x2f\xa8\xcf\xfe\x4e\x74\xd8\x85\x07\xdf\x30\x83\x24\x28\x82\x03\x0e\xb2\x3b\xbe\xf4\x3b\xf5\xcd\x07\x45\xa3\x49\x12\x7e\x08\x1b\x4f\xf3\xf4\x86\xc9\x0c\xf5\x95\x9a\x91\xba\x45\x7f\xc3\xef\x60\x91\x00\x0e\x41\x11\x24\x30\xbf\xf1\xa0\x60\x77\x08\x0f\x42\xfd\xef\xbe\xb4\x83\x05\x93\x89\xc6\xf2\xa7\xd5\x47\x7f\x28\x48\x26\x23\x79\xa9\x5a\x5f\xb2\x2c\xc3\xab\xad\xf2\x80\x41\xa7\x72\xea\x9c\x87\xee\x25\xce\xf2\x92\xf0\x4c\x20\x90\x1f\xaf\x0f\x06\x02\x36\x9b\xdd\x7a\x16\x72\x7e\xfe\x01\x69\xa9\x04\x59\x59\x92\xc3\x79\x25\x2c\x1b\x8c\x88\xa0\xf4\x54\x8a\x7b\x91\xfd\x57\x4a\xcb\x75\x20\x64\x64\xcb\xab\x85\x36\x49\xeb\x2c\xe1\x74\x32\xd2\xc0\x47\x8b\x14\x30\xe5\x84\xb9\x5d\x0e\x06\x41\x4f\xfe\x79\xf5\x79\xb8\x0c\x8f\xca\x32\xf5\x3d\x92\x3f\x2e\xcb\x30\x2a\xa5\xc9\xd1\xc9\x3d\xe1\xcb\xc3\x07\x3a\x77\x8d\x75\xee\x0f\x87\xc9\xd1\xf0\xe5\xe1\xfd\xda\xc5\x81\x30\xd3\xa3\x3e\x9f\x7f\x1e\x7a\x54\x2d\x57\x52\x4b\xad\xe5\x4a\x6a\xf9\xf1\xdd\x93\xd7\x85\xc3\x07\x3a\xc7\x76\x75\x1e\x08\x5f\x1e\x26\x47\xc2\xe1\xfd\xda\xc5\xfe\xf0\xe5\xd3\xda\x45\xdf\xfb\x57\x9b\x2c\xcf\xa0\xcb\xaa\x2b\xcc\x92\xb3\xf4\x6a\xa9\xf6\xaa\xce\x62\x98\xae\xad\x4a\xa6\xf9\x35\xed\x98\x81\xc3\x70\x1e\xbd\x2e\x46\xd1\x9d\x3e\x4b\x22\xd1\x91\xdc\xca\x0a\x5d\x4a\xa5\xdf\x53\x3c\x5e\xe2\xd7\xab\x71\xea\x16\x55\x4f\x49\x6e\xa9\x74\x81\x8a\x40\x2b\x11\x39\xc3\x1e\x44\x3e\x84\x80\x6b\x81\x32\x58\x79\x3a\x11\xb4\x87\xca\xee\x7f\xc9\x19\x29\x96\x93\xc4\x7c\xd6\x69\x30\x58\xc6\x8c\x36\xc8\xe6\x62\x92\xdd\x0b\x59\xa9\x4f\x82\x6c\x2d\xf9\x6c\x78\x72\x4c\x94\x24\x87\x35\x67\xc6\x4a\x38\x5c\x0f\x8a\xcb\xa5\x2a\x01\xba\x96\x91\x29\x85\x9c\x61\x91\x36\xda\xe4\x22\xff\xa6\xa0\x4a\x98\xd1\xa6\xe3\x20\xa5\x10\xd3\x01\x9c\x13\xe4\x5c\xac\xb1\x56\xcd\x49\x7d\x92\x9a\xf3\xda\xa5\x58\x4e\xcd\x89\xe6\x31\xc1\x68\x64\x91\x2c\x4e\x3e\xbc\x34\xa0\x2a\x2e\x17\x28\xf5\x91\x30\x56\xcc\x39\xd1\x21\x4f\xa7\x05\x1a\x2b\x68\x01\x88\x96\x69\x81\xb3\x3e\xc3\xa7\xf0\x8e\xc2\xea\xde\xf6\x6f\x05\x72\x40\xa3\x89\x76\x54\xf6\xe2\x3b\x78\x47\x81\x16\x68\xfb\xb7\x42\xe2\x07\x65\x72\x5b\x65\x7f\x96\xe7\x7d\x0e\xd9\x90\xb3\xd0\xa7\x6e\x3e\x94\x0a\xa5\x28\xbc\x02\x6d\x3f\x23\xb1\x43\xc1\x99\x91\xf5\x6c\x1d\xb9\x8f\x9f\x48\x76\x8e\xc0\xab\xa2\x5d\xfd\x85\x5d\x10\xed\x10\xb2\xab\x13\x38\xa0\x8e\xe7\xc7\x89\xb2\xd1\xe7\x3b\xe1\x1b\xf6\x6d\xc4\x63\xd3\xbc\xb2\x7e\xe1\x44\x72\xa4\x13\xbe\x21\x68\x59\x44\x41\xcb\x92\xcf\xe2\x00\x04\xf2\xe3\xea\x38\x1e\xd9\xe8\x1b\xf6\x9d\xf0\xf9\x36\x8e\x9c\xeb\xbb\xaf\x41\x4d\x25\xbd\x4b\x9e\xab\x2f\x7a\x0c\xca\x80\xce\x40\x98\x51\x6b\x3b\x40\xe1\xe1\xf3\xbf\xd7\x1b\x02\xbb\xee\x91\x6a\x2d\x42\xb4\x6a\xd8\x8f\xc0\xb8\x37\x12\x6d\xaa\xd3\xd2\xd1\x96\xc3\xae\x7b\x64\xd6\x8e\x9b\xab\xfd\xe5\xeb\xe5\xa0\xbe\xfc\x8d\xc5\x49\xa7\x0e\x1a\x44\x56\x67\x51\x64\xd2\x51\x9c\xe9\x83\x84\x7e\x75\x16\x42\xd9\x3b\x30\x22\xcb\xea\x98\x3f\x1a\xdb\xfb\x9d\x5b\x2f\xe9\x0c\x9a\x1e\x33\x8b\x3c\xe7\x22\xad\xa3\xed\x8f\xdf\x19\xb3\x58\xbc\x38\x32\xad\xb9\xbe\x0c\x23\xda\x4c\x30\x52\x6f\xb7\x37\x8f\x45\xfb\x37\x8f\xdc\xb4\xbd\xe7\x2b\xff\x61\x21\x46\x0f\x6c\xd9\x9b\xec\x18\x6b\xb6\xb3\x38\x37\xad\xb1\xca\xf3\x3f\x46\x1c\x92\x90\x9f\xca\x53\xc0\x0e\x76\x64\x6b\x87\x82\xe6\xe1\x34\x37\x54\x58\x01\x34\x85\x40\x51\x11\x09\x54\xa8\x18\x9e\xa5\x80\x08\x39\x45\x81\x15\xf9\x5f\x4d\x21\xec\x57\x7f\x41\x95\x14\xf5\xd4\x78\x73\xd5\x92\x5c\xc6\x73\x13\x50\x9d\xb6\xcb\x82\xf2\x47\x93\x08\xc6\xab\x67\x8a\xea\x56\x62\x6e\x94\xdc\x6a\x4e\x1e\x90\xd5\x9c\x5b\xb2\xc7\xb0\x12\x3b\x51\xd0\xf3\x14\x08\x85\x52\xa8\x6c\x22\x72\x71\xa8\x5e\xcd\xd6\xd6\x42\xae\x3e\x14\xca\x07\xa6\x29\x85\x56\xcd\x5f\x55\x65\xd2\xa7\x8b\xc2\x24\x71\xfe\x32\xd9\x63\x79\x25\x66\x97\xdc\x90\x95\x07\x64\xc8\xba\xf7\x9c\xbb\x4c\xf0\x99\x50\x28\x54\x0f\xb9\xda\x5a\x35\x5b\xaf\xfe\xec\xc3\x97\x89\xea\x29\xeb\xf2\xdf\xb4\x1b\xce\x5b\xa6\xac\xf6\xfc\x90\xfe\xae\x9f\x57\xca\x42\xab\x06\xf7\xc3\x15\x4d\x69\xd7\xda\x36\xff\x36\xa1\x33\x31\xcd\x41\x5e\x9e\xee\xe7\x58\x23\x64\xfe\xc2\x2a\x68\x04\xa1\xb0\xdb\xc5\x59\x41\xe4\x43\x0d\x28\x5a\x22\xa9\x23\x99\x52\x30\x8d\xa8\xb7\x6e\x97\x55\x17\x97\xb2\xa1\x06\x8e\xd7\x89\x70\x2e\x14\xe4\xdc\x7a\x50\x84\x50\x90\x62\x4c\x31\xfd\x90\x76\xbb\xc8\x2b\x21\x62\x31\xb3\x8c\x20\x7b\x6a\x83\x0d\x51\xf9\xf7\xea\x23\xfd\x9b\xb5\x06\x1a\xc0\x64\x9e\x56\xa8\x2d\xf3\xe0\x92\xf1\x1d\x1b\xcd\x46\x8e\xb4\x10\x97\xc0\x30\x56\x47\x4d\x6d\xbd\x78\xe0\x07\x71\x78\xcd\x66\x34\x11\x0f\x5b\xab\x7a\x08\x81\x17\xad\x26\x23\xf1\x60\xc9\xac\xee\x9f\xf5\xe2\x41\xa9\xb1\xde\xe7\xb4\x31\xac\x20\x58\xfe\xf3\xa4\xc5\xc9\x00\x26\x1c\xcb\xb2\x0c\x06\xf6\x17\xb2\xb0\x5b\x90\xbb\x66\x49\xe2\x35\xa2\xf4\x2a\x20\x37\xb1\x98\x85\x93\x82\xc0\x00\x10\x86\x10\xac\xec\xb2\x58\xc4\x6b\xbc\xe1\xf9\x16\x8b\x75\x97\xd9\xba\xe7\x30\x61\x58\x96\x01\xcc\xf2\x7c\x61\x3f\x4e\x26\x59\x05\xf5\x97\xb5\x6a\xa7\x73\xf6\x75\x94\x97\xb8\xdb\x0f\x56\xe0\x78\x8e\xba\xc2\xe6\x0a\x0a\x6b\x3a\xe4\x7a\x81\x93\x43\x26\x25\x71\x72\xbe\x28\xc9\xc2\x25\x9b\xb5\x9a\x6e\xfe\xdb\xb7\x9f\x3d\x6e\xc4\x86\x4b\x8d\x82\x60\x62\x9b\x47\xda\xd6\xee\x84\xd9\xd4\x90\xec\x47\xf0\x69\x49\x7c\x44\x94\xe0\x6e\xf5\x5e\x2d\xe5\x71\x41\x86\x83\xb2\x70\xab\x28\xfd\xc7\x93\xbf\xdc\x6f\xa8\x31\x1d\x34\x03\x36\xb2\xbe\xc6\x4d\x43\x3f\x96\xc4\x5b\x05\x59\xfd\xe8\x57\x74\x50\x63\x40\xc9\x29\x44\x5e\xe5\x10\xda\xa2\xfb\x59\x2f\x91\x98\xed\x0c\x5d\x1c\x33\x69\xf7\x2c\x1d\xa2\x37\x9d\x4a\xb6\x93\x68\xbb\x21\x95\x4c\x67\x4a\xbc\x26\x3f\x43\xbb\x4f\xab\x46\xc1\x95\x24\xe3\xf6\x73\xe4\xd5\xef\x9f\x94\xc4\xdb\x05\x79\xe0\xe6\xe1\xf9\x35\xac\xdd\x7a\x29\x6f\xb3\x1a\xf1\xee\x5b\xc2\xe1\x95\x37\xfb\xc3\xc3\xc9\x74\xb4\x6d\x79\xc7\x40\x53\x7b\x8d\xfd\xf9\x87\x64\xe1\x76\x51\xea\xba\x7c\x5e\x8f\xc4\xd9\x2d\x2b\x0d\x56\x51\x20\xee\x4c\xdf\x05\xcd\x9b\x6f\xb0\x37\x87\x07\xdb\x3b\x52\x9d\x23\x99\x05\x61\x2f\x6c\xfe\xc4\x2f\xbc\x5f\xd4\x5a\xe3\x8b\xc6\xd6\xb6\x84\x87\x73\x3a\x6e\x37\x61\x6c\xc6\x5b\xbd\x86\x75\x2b\x7c\xf1\x86\x26\xb7\xd3\x26\x85\x6a\x5b\x9b\xba\xba\x97\x36\x1d\x79\xc5\xff\xcf\x82\x2c\x89\x4f\x73\x0d\xc1\x66\x1b\x27\x39\xee\xb3\x02\x31\x11\x29\x54\xe7\x5e\x37\xdf\xdb\x1a\xad\x0d\xc9\x92\xc3\xdd\x11\xe9\x9b\xbb\xbe\xd0\x67\xb7\xb0\x0a\xea\x2b\xd2\xe0\x22\xf0\xae\x82\xa7\xe0\x28\x8a\x96\x94\x87\x33\x25\x02\x26\x52\xa4\xc3\x8b\xa6\xe0\x2d\xe0\x72\x27\xe2\x2e\x72\x8b\x24\x3e\xee\x7e\xed\xf3\x8f\x41\xa3\x68\x32\x38\xbf\x6b\x33\xaa\x2f\xe7\x8c\xb2\xb0\xeb\xd0\xc3\x2e\x75\x2d\xe5\xa9\x3d\xd4\xf5\x6f\xf7\x6a\x45\x23\xf4\xfb\xfb\x5d\x87\xfd\x49\x51\x62\x9a\x77\x88\xd2\x3d\xff\xec\x78\x46\x7d\xd0\x26\x49\x16\xb8\xfa\x87\x46\xe1\xa0\x20\xaf\x5b\x25\x89\x3b\x44\x69\xb7\x2c\x7c\x54\x4b\xbb\x43\x94\x7a\x57\x4b\x14\xd4\x10\x91\x29\x56\xd1\xa8\xf5\x60\xa8\x00\xe4\x5f\x80\x29\x29\x0d\x37\x9d\xe4\x88\xbb\x65\x97\xbb\x0f\x32\x32\x0d\xbb\x78\x48\x14\x87\x99\xb3\x3c\xe0\x1c\x1c\xde\xf0\x05\x41\x56\xa9\x8d\x22\x04\xf4\xf3\xbf\xab\xdf\x36\x18\x4c\xd2\x77\x64\xd3\x8f\xe5\xb0\xa9\x89\xff\xb6\xc1\xf9\x6d\xbb\xc9\x68\x50\xbf\xff\x63\x3a\xe6\x7e\x09\x0d\xfa\x59\x96\x44\x58\x2a\x89\x97\x0a\xf2\x5a\x49\xdc\x29\xc8\x78\xc0\x66\xb3\x49\xea\x05\x91\x0b\x3c\xeb\xed\xf0\xa8\x6c\x13\xed\xf9\xe7\x64\x61\xa7\x28\xad\x95\x85\x4b\x45\x49\xfd\xaa\x20\x17\xfc\xde\xeb\xfb\x8e\x4e\xba\x57\xd7\x06\x7e\x1c\xd9\xa6\x95\xac\x34\x18\xcb\x9f\x4e\x29\xa4\xcf\x6a\x8c\x7c\xcb\xa8\x9a\x83\xec\x28\x5c\x9d\xff\x81\xfa\x05\x78\x9f\x32\x2c\x79\x59\x78\xac\x28\xa2\x2e\xca\xad\x71\xed\x0f\xc8\xa5\x3f\xd8\xa7\x66\xe1\x61\xf5\xc0\x7f\x5f\x5f\xad\xc8\x76\xbd\x24\xde\x2f\xc8\x78\x8f\x28\x55\xf8\x1f\x32\x20\x0b\xb2\xa1\x1a\x54\x87\xae\x42\x08\xe4\x90\xec\x72\xb8\x93\x69\x39\x13\x74\x07\x13\xd1\x90\x16\xe1\x70\x15\x22\xf4\x3d\x22\xa1\x23\x86\x84\x88\xee\x49\x9a\x94\x4a\x5b\x9e\x0f\x49\xb1\x5f\x82\xf2\xb4\xb3\x8b\x27\x25\x86\x03\x9f\x88\xbb\x30\x5e\x79\x72\x10\x00\xae\x0b\xa9\x6f\x04\xe0\xe1\xa3\xa1\x85\x70\x72\xf9\x23\x2b\x01\xe0\xea\xa0\xfa\x63\x8a\xdf\xfd\xfa\xa3\xbc\xe7\xa4\x87\xff\xdc\xe9\xc7\x78\xcf\x49\xb3\x1d\x8f\xbd\xa2\xd5\xe7\x8b\xc1\xbb\xb4\xd3\x95\x17\xb2\x26\x93\xed\xb0\x97\xbd\x08\x2e\xbd\x84\xf7\x1c\xf0\xf0\x5b\xe0\xca\x8b\x59\xef\x61\x9b\xc9\xc4\x6e\xb8\x5a\x4b\x72\x6f\xc3\x97\x45\x09\xd6\x42\x8b\xfa\x1a\x30\x00\x2c\x7c\x41\x51\x94\xfc\x6b\xd0\xaa\xbe\x0e\x2c\x00\x03\x4f\x29\x4a\x20\x2b\x4a\xf9\x13\x1e\x0f\xde\x99\x3f\xe1\x11\x4d\x78\x27\xa5\xb5\x75\xce\x32\xac\xb7\x0a\x16\x8f\x7a\x02\x76\x7a\xf4\xa3\x45\xb0\xaa\x8f\x17\x12\x68\xfb\xdb\xce\x29\xc4\xbc\xc5\x2a\x28\x81\x16\x53\xcc\x21\x17\xef\x07\x5e\x64\x78\x67\x28\xd5\x10\x75\x86\xec\x0d\x91\x16\xc8\x24\xe2\x19\x7b\x22\x12\xb2\x47\x5a\x20\xe5\x8e\x67\x52\x09\x67\x3a\x91\x4a\x38\xfd\x84\x24\xdb\x99\x06\x0a\x42\x1a\xef\xe3\xb4\x0b\x11\xb4\x8b\x3e\x8e\xb9\x5b\xba\x7f\xcf\x75\x02\x9f\x58\x7e\xdd\xc1\x55\x0f\x0e\x37\x3f\x28\x2d\x96\x7f\x50\x7f\x75\xdc\x60\xe3\x4c\xc2\xd0\xd5\xaf\x65\x83\x0f\xae\x8a\x3d\xb8\xe2\xa6\x9d\xbd\xa7\xfd\xad\x8b\x7a\xd6\xc7\x57\x18\x0c\x73\x22\xf3\x67\xcf\x6d\x9f\xed\x97\x17\xd5\x34\xf6\xc4\x97\xb4\xcc\xe5\xd9\xee\x86\x81\xd6\xee\x48\xa3\x44\x94\xaf\x0e\xf9\x8e\x1f\x5d\x74\xc5\xc2\x0e\x17\x33\x35\x01\x93\x68\x0a\xbe\x96\x80\xfb\x00\xea\xe7\x3f\x0a\x30\xf9\x37\xfc\xde\x24\x5f\xdf\x7d\x49\xfe\xa1\xc6\xce\xc6\x1a\x0b\x87\xd5\x7f\x02\xc2\x5a\x6c\xde\x86\x76\xf8\x7b\x30\x11\x74\x9b\x38\x00\xf5\x25\x00\x62\x10\xdd\xf5\xed\x3a\x2e\x06\xc5\x96\x28\xd8\x4b\xba\xdc\xe0\x72\xb3\xba\xcd\x60\xc5\x92\xcc\x20\x97\x08\x27\x44\x31\xff\x78\x67\x0c\x07\x4a\x10\x11\x01\x06\xc1\x4f\x44\x51\xdd\x29\xba\x02\xb1\xce\x89\xf1\x22\xe2\x83\xee\xcf\xa3\xf4\xdc\x18\xea\x44\x8b\xb5\x36\x75\x07\xed\x2e\x37\x99\xfe\x68\xbb\xc3\x25\x9f\x07\xa6\xbb\xfa\x9a\x3d\x25\x8a\x6a\xcc\x25\xce\xaf\x2c\x4a\xe7\x0f\x66\x82\xa2\xa8\x0e\x33\x8d\xa2\x4b\x2b\x72\xfe\xf9\x72\x69\xf3\xe3\xb1\xce\x7c\xa0\xb4\x37\x03\x71\xa6\xa0\x46\x7f\x36\x4c\x21\x6e\x3f\x87\x90\x09\x35\xa2\x01\xb4\x0a\x21\x48\x74\x40\x24\x15\xe2\x1d\x1c\x0f\x3a\x0e\x53\x71\xfb\xa4\x2f\x3a\x74\x57\xc5\x3a\x83\x29\x48\xf7\x43\xaa\x81\x0b\x71\x2d\x40\xbd\x18\x00\x67\x05\xa7\x96\x30\x25\x3b\x83\xa9\x44\x34\xc4\x27\xb4\xb3\x9c\x90\x99\xc7\xbe\xb4\xd8\x82\x19\xc2\x33\xf9\x77\x4d\xea\xbf\x98\x04\x8b\x59\xcd\x59\x0d\x06\x57\x8e\xea\xb2\xe4\x44\x89\xcc\xcf\x7f\x1d\x76\x5b\x8c\x66\x6c\x24\x16\xe9\xad\x1b\x70\x46\xbd\x9b\xb3\x9a\x45\xa3\xf3\xef\xaf\xaa\xe3\x83\x1d\x7f\xe9\x18\x54\xdf\x5c\xf8\xdb\xff\x8f\xb6\xff\x80\x8f\xa3\x38\xff\xc7\xf1\x79\x66\xdb\xd5\xbd\xdb\xdb\xbd\xdd\xd3\xdd\xe9\xfa\xed\xaa\x9e\xa4\x6b\xab\xde\x5d\x24\xcb\xb6\x2c\xdc\x8b\xac\x50\x5c\x01\x37\xc0\x15\x73\xb6\x21\x01\x12\x0c\x98\xde\x05\x18\x08\xc5\x09\xa1\x3b\x94\x28\x10\x08\xe1\x13\x4a\x42\x08\x21\x81\xe0\x24\x86\x04\x42\x4f\x01\x6c\xdd\xfa\xff\xda\xbd\x93\x2d\x17\x4a\x5e\xdf\xff\x0f\xac\xdd\x99\x6d\x37\xcf\xec\xec\xcc\xf3\xcc\x3c\xcf\xfb\x7d\xdb\xbb\xe4\xb2\x3f\xd6\x38\x49\x01\x22\xb6\x83\x81\x31\x10\x28\x27\x2f\x50\x06\xf4\xc6\x81\x61\xd7\x05\xef\xcd\xc7\x9c\xcb\x6c\x26\x80\x58\xf7\xce\xbc\xfc\x47\x26\x97\x15\x63\xbc\x9e\xd8\xb6\x62\xc5\x65\x97\xad\x58\x81\xaf\xce\xaf\x28\xac\xfd\x8c\x97\x3b\xad\xcb\x1d\x3f\x22\x37\xf5\x95\x72\xc3\x31\x92\x11\x5f\x5b\x0f\xdf\x42\xee\x9b\x8e\x92\x8e\xff\xca\x5a\x38\x2c\xf6\x5f\x4f\x24\xb5\x36\x7a\x44\x3c\xf2\xbc\xe3\xaa\xc0\x42\x10\xb0\x1e\x51\xba\xcc\xc6\xfc\xac\x6e\x97\x35\xa0\x1e\x34\x0f\xa1\xf8\xd7\xbc\xe2\xa3\x67\x0c\x8e\x75\x84\xf8\xa6\x3c\xde\x77\x62\x91\xc9\xd0\xf8\x99\x05\xdd\xd4\xcf\x19\x0d\x39\x67\x64\xb4\x02\xd1\xc2\x88\x91\x39\x84\x8c\x0c\x62\x5d\x43\x27\x92\x7a\x1c\xf4\xfb\x67\xdf\x90\x2c\x0c\x77\x63\xf2\x3b\x8e\xc8\x7f\xac\x94\x5f\x5d\x1f\xc7\xcd\xa0\x7c\x43\x9e\x3c\x4a\x00\x2d\x74\xe2\xda\xc0\xc3\xc7\xc8\x7c\x54\x6d\x1c\xa9\xa7\xd0\x61\x51\xd6\x9e\xa8\x2a\x60\xed\x37\x57\x80\xd1\xe6\xa9\x97\x8a\x6d\xbe\x0b\xcd\x46\x28\x6e\x2c\xf2\x1b\x2b\xf7\x5f\xdd\xe6\xe3\x02\x4b\x18\x6c\x0f\x6a\x41\x0f\x55\xa3\x2c\x1c\x8e\x7a\xd2\x3f\x80\x14\x67\xb0\x91\x30\xb4\x41\x1a\xc1\x51\x9d\x73\x9b\xd2\xad\x3d\xdd\xc9\x89\xf9\x9b\xbf\x42\xe8\x8f\xbc\xf5\xfd\x67\x4f\x68\x4d\x78\x5c\x8a\xc3\x19\x97\x67\x9e\xe6\xc4\xee\x19\x55\x2b\xbe\x7b\xd9\x19\x9b\x77\x07\xb4\xca\xbb\x00\x33\x26\x57\xeb\xc0\xc8\xe6\xb7\xdb\x56\xf4\xae\xed\xcb\xce\x3e\x91\xcc\x6a\xeb\xfa\x33\x06\xea\x9c\x26\x66\x0d\x43\xda\xcf\x9e\x23\xf9\x2f\x3d\x6d\xf9\xae\x27\x71\xcd\xda\xb5\x70\x3f\xe3\xa1\x9c\x36\xbb\xab\x71\xf6\xde\xfc\x5a\x74\x9c\xec\xaa\xe1\x0d\x7d\x44\xf6\xaf\xef\xe7\x8e\x11\x8f\xff\xba\xea\xf8\x16\xb2\xbf\x32\x5e\xbe\x67\xbe\xa6\x22\xc8\xa2\xf0\x07\xef\x39\x91\xf4\xa3\xc7\x8a\x49\xa5\x4e\x58\x1f\x63\xb8\x91\xed\xc5\x79\xd8\x85\x63\x6f\xbd\xe0\xb0\x71\xec\xbc\x1f\x25\x30\xa2\x5b\x64\x44\x83\x4b\x8c\x66\x2a\x71\xc4\x60\xbd\x2d\xc0\x49\x15\x20\x09\x5b\xb1\x41\x9d\x9b\x4a\x06\x28\xb7\xc0\x02\xc3\xe2\x22\x2f\xbf\xd7\x17\x8f\xfb\xbc\xf2\xb0\xec\xd5\x8c\x35\x5e\x08\x79\x65\x72\x58\x75\x10\x09\x8e\x73\x28\xe6\xc6\xf6\x0b\x62\x7d\x5c\xe7\x8d\x73\xa6\x6e\x8e\x7a\xe5\x58\x89\x67\x59\x5d\x77\xd8\xe5\x35\x9b\x19\xab\x5f\xe0\xbd\x89\x9e\x9a\xb0\xc3\x0c\x3c\xef\x22\x58\x13\x09\xee\x69\x6b\x8d\x55\x1b\x5f\x3c\x8e\x7d\x87\x03\x38\x64\xd9\x3b\xbb\xad\x2a\xd4\xd7\x52\xdf\xd2\x10\x5f\x3d\xa1\x0f\x07\x7d\xde\x4a\x80\xb8\x17\x6f\x2b\x89\x63\xbc\xb6\x7d\x4e\xd8\xd5\x1c\xaf\x50\xaa\x9a\x05\xde\x1d\x4c\x96\x35\x07\x3c\x72\x5f\x55\x84\xf6\x08\xec\x5a\x74\x98\x37\xbd\xdd\x88\x31\xf3\x15\x71\x18\x0f\xbf\xbc\x63\x2d\xf8\xb8\xe8\x36\xac\x61\x2c\x05\xb0\x5b\x30\xe0\x8c\x13\x58\x31\xc8\xfb\x0d\x10\x4d\xa3\x4a\xf4\xfa\x68\x22\x44\x49\x64\x8c\x3f\x46\xf8\xaa\x8a\x58\xae\xc2\x9a\x69\xda\x3f\x49\x13\x4b\xb8\x5c\x02\x98\x1d\xe1\x9a\x9e\x84\x97\x17\xfc\x56\xc6\x6c\xf6\xba\xc2\xdd\x75\xcb\x3c\x25\x31\xd9\x1b\xdd\x3c\x75\xce\x8d\x9d\x5c\x5f\xec\x82\xf6\x46\xb3\xe2\xe0\xb8\x04\x41\x8c\xd5\x44\xfe\x9d\x42\x1d\x18\xf5\xf1\xe3\x96\xb9\xd3\xd6\xb2\x82\x87\x8e\x97\x4d\x95\x3d\x81\xe6\xb2\x64\xd0\xcd\x0b\xcd\x55\x4a\x45\xbc\xd9\x15\x9e\xd3\xbe\x16\xe3\x78\x09\xde\xe6\x8d\x03\x54\x7a\x7d\x41\xdc\x37\x61\x75\xbc\xa1\xa5\xbe\xa5\x2f\x84\x90\xed\xf0\x5c\x86\xd9\x58\x47\xaa\x44\x2d\x68\x21\x3a\x15\x9d\x87\x7e\x80\x6e\x46\x0f\xa0\xa7\x0d\x5e\x93\x68\x84\x71\x8b\xa9\xa4\x9a\xca\xa4\x23\xee\xb8\x3b\xca\x45\xb9\x68\x86\xe2\xa2\x99\xe2\x22\x5e\xaa\x38\x7d\xcf\x51\x45\x1f\x21\x77\x94\xd3\xd5\xc7\xa4\x24\x4a\x6e\x61\x8c\x25\xa6\x05\xd2\x86\x13\x6c\x29\x44\xdd\x42\x2a\xa9\xa6\xb3\xe9\x0c\xb8\x85\x48\x0b\xa4\x93\x90\x36\x68\xe9\xc2\x21\x03\x9d\xb4\x08\x7e\x19\x32\xda\x19\xf0\x51\x46\x89\x1a\x60\x98\xee\x54\x3c\x93\x2e\xd0\xf8\x94\x42\x71\xe2\x4e\x4a\x71\x51\xae\x58\x8e\x68\xb1\x1c\xc7\x4d\xe0\x5d\x53\xca\x39\x9d\x5c\xe9\x63\x9d\x9d\xf9\x67\xfb\x7b\xa7\xc1\x4f\xba\x94\x78\xd8\x4c\x77\x02\xb0\x82\x08\x6d\x8c\xad\x3c\x1a\xee\xea\x0a\xc5\xca\x6d\xcc\x41\x4c\xd8\x7c\x99\x74\xa9\x5b\x28\x5d\xe2\x73\x5f\x10\xf1\xd0\xa0\x6d\x6b\x6f\xc7\x6e\xde\xd2\x59\x79\xa1\xf6\x81\xf6\xe1\x85\x55\x1d\x16\x41\xb0\x74\x54\x5e\x84\xe5\x8b\x2a\x3b\x2c\x42\xde\x3e\x7f\x4a\x2a\x33\x8d\x09\x99\xa2\xd6\x5e\x08\xbb\x4b\xeb\x52\x3e\xb7\xdb\x97\xaa\x2b\x75\x3f\xdc\xd5\x65\xc0\x59\x77\xd1\xd6\x50\xac\x1c\x3e\x1f\x3f\xc1\xf3\xde\x4d\x49\xe7\x3e\xe7\xbd\x91\x54\xea\x1f\x13\xb5\x79\x70\xd7\xc4\xad\xda\xe5\x65\xd5\x7e\x2e\x0e\x11\xed\x33\x0f\x76\x04\xc1\xb3\x6a\x57\xda\x5d\x51\x1e\x83\x0f\x6f\x2d\xab\x70\x3f\x62\x2e\x65\x45\x57\x99\xec\x6b\xda\xd6\xe4\x93\xe5\xd2\x86\xbe\x8e\x94\x17\x6c\x6e\x2b\x51\x7f\x63\x2a\x75\x63\x3a\x4f\xfc\xe4\xa4\xaa\x26\xca\xe1\xa0\x9a\xaa\xe6\xec\xb9\x7f\x66\x65\xb3\x9e\x6e\xae\x9c\x49\x34\x41\xd9\x33\xcf\x48\x0b\xa5\xa5\xea\xaf\x36\x6c\x6f\x2c\x95\xe5\xd2\x46\x63\xe7\x6b\x86\xb5\xda\x3b\x41\x27\xf6\x80\x53\xfb\x53\xdc\xe5\xab\x06\xd3\xd1\x73\xb8\x56\xe4\x3b\x84\xa8\x77\x8c\x78\xd9\xb1\xf6\xb1\x00\x9d\x82\xce\x45\x17\xa1\x1b\xd0\x8f\x0d\x3b\x3d\x1a\x51\xb8\x6c\x2a\x49\xb9\xa3\x99\x74\x32\x9e\xca\x84\xdd\x29\x2e\x15\x3e\xc1\x6b\x19\x7b\x79\x99\x28\x97\xca\x18\x2f\x2f\x9e\x89\x1a\x0d\xa6\x05\x52\xc7\xbd\x58\x35\x0b\x99\x74\xa4\x14\x84\xa4\xc1\x80\xcb\xd0\x21\xa3\x89\x64\xd2\x46\xab\x08\x19\x2d\x04\x52\x04\x17\xe5\x64\x45\x56\x52\xfc\x58\xdb\x2b\xb4\x33\xbd\xed\xc5\x4f\xd0\x42\x89\xff\x53\x24\x51\x94\x14\x18\x98\x3f\x7f\xb4\x71\xa5\xf6\xfc\xf2\x53\x21\x34\x6f\x5e\xc0\xe7\x22\x60\x9e\xc9\x96\xa8\xcd\xc2\x1e\x33\x97\x4d\x56\xce\x9b\x57\x5d\x9b\xe5\xcc\x30\xb0\x00\x33\xe1\xc4\x83\x3e\xa5\xab\x5b\xf1\x97\x2a\x13\x26\xc7\x5c\x04\xce\x0f\xcf\x9e\x8d\x5f\xf6\xb2\x73\x1b\x1f\xcb\x7b\x1f\x6b\x9c\x67\xf7\x7a\xd9\xb9\x4d\x8f\xe2\x77\x8d\xf4\xa8\x77\xc9\xc6\x53\xd9\x9a\xb8\x7f\xc5\x24\x78\xc4\x2f\x77\x77\xc9\x7e\xbf\xdc\xd5\x2d\xfb\x61\xfa\x82\x4c\x32\x61\x37\x2d\x00\xc2\xe5\x0b\x40\xec\xd5\x2e\x11\xaa\xc5\xee\x44\xa2\xfb\xea\xc1\xc1\xfc\x2f\xe1\x23\xed\xbb\x15\x6e\x22\x04\xa7\x6b\x1b\xeb\x3c\xf1\x96\xc1\x67\x7b\xbc\xf5\xd9\x37\xf2\xcb\x6b\x55\xd5\x77\x92\x3d\x65\x89\x4d\x98\xb3\x74\x7a\x3c\x95\x8a\x4f\xdf\x33\x3d\x9e\xca\xf8\x7c\x66\xe2\xe9\xdf\x4e\x98\xf0\xdb\x89\xf9\x39\xef\x9f\xd5\xd4\x4f\xbb\xdd\x74\x7f\xd3\xea\x8f\xf4\x34\x23\x08\x4c\x7f\xd3\x6a\x92\xd5\xd6\x68\x9f\x82\xa3\xf7\xe2\xa5\x33\xb5\x2f\x27\xfe\x78\x46\x3c\x95\x92\xfb\x7f\xdc\xaf\x3f\x64\x40\xb3\xab\xad\x71\x4f\x0a\x2e\xd6\x2e\x0f\x63\xb1\x12\xce\x2d\xf8\x52\xe6\xa8\xcd\xd4\x7f\x11\x8f\x14\x84\x80\x2e\x58\xd0\x2a\x9f\x54\xc6\x0c\x66\x10\x19\x70\x8f\x4d\xca\x40\x16\xf4\x83\x78\x96\xe5\x73\x9f\xfc\xb1\x5b\xb0\xe4\x01\x6e\xb5\x59\xcd\xd2\xc7\x65\x5e\xe2\x05\xab\x35\xff\x09\xf4\x5b\x2d\x16\xf1\xe3\x0a\x8f\xb6\xc7\x85\xa1\x44\xf9\x54\x24\x4e\x73\x69\xbd\x89\x08\x0f\x23\x00\x92\xe8\x70\x54\xc3\xa9\x4e\xf7\xe8\x7c\xc8\x5f\x27\x70\x8e\x6a\x7c\x66\x88\xd8\x59\x7d\x34\x77\x3e\x7f\x98\x5f\x44\xae\x04\x63\x05\xc1\x4d\xd0\x92\xd8\x04\x49\x15\x8c\x23\x20\x82\x91\xcb\x2a\x90\x81\xac\x74\xdc\xe2\xcb\x56\x77\xf0\x31\x97\x89\x31\x9d\xfb\x0b\xb3\xd9\xe4\xdc\x1b\xe4\x09\x95\xe1\x1e\x0f\xf0\xda\x69\x00\x94\x10\x7a\xcc\xc5\x98\xcc\xda\x28\x5c\x67\xfa\xd3\x51\x93\xd4\x04\xbc\x15\xb1\xda\xb8\x3f\x80\x76\x27\xcb\xda\x63\xc4\x0c\x5b\x34\xaf\x60\x2d\x1c\xb5\xd9\x1d\xf0\x26\xe0\x57\x9d\x17\x1e\x8f\x59\x83\x2c\x0c\x22\xff\x8b\xb0\x81\x88\x54\x0d\x7c\x92\x0c\x42\x32\x40\x15\x79\xf0\x4b\x41\x64\x58\x70\x00\x4b\x47\xe9\xb0\x1c\xab\xc1\x85\x91\x24\x01\x4a\x0b\xc8\x06\xdf\x7c\x2b\x9d\xca\xe2\x5f\xc2\x7e\xcd\xbf\xf7\x87\xd0\xd0\xd3\x03\x21\x36\xec\x09\x05\x58\x9a\x57\x18\x93\x19\x80\x67\x62\x2c\xcb\x06\x42\x9e\xb0\x23\x08\x07\xb5\x0b\x5f\xd6\x5e\xae\xad\x8b\xc5\xe2\x1d\x9e\xe3\xaf\x60\x43\x70\x10\xae\x3d\x90\x87\xa5\x66\x8a\x24\x08\xda\xe2\x94\x1c\x74\xc9\x42\xb5\xfd\xf2\xf2\xb2\x0b\x2f\xbf\x5c\x9d\xc7\x71\x0e\xc9\x61\xa1\x09\x82\xc7\x66\x82\x24\x29\x4b\xa8\xe4\xb8\xf3\x4e\xfd\xbc\x0b\x15\x70\xb0\xe8\x11\xea\x62\x63\x6d\x55\x42\x3e\x14\x44\xc8\x4c\xba\xc1\xad\x30\x19\xc8\x48\x90\x91\x54\xb7\xd9\x06\xbb\xe0\x23\xed\x1e\x4d\xa4\xaa\x34\x11\x40\x93\xae\x80\xd9\x00\x30\x27\x3f\x03\x66\x6b\x2e\xed\x47\x54\x02\x06\x34\x49\xbb\x1b\xe6\xc0\x7b\xda\x8f\x34\x17\xd1\xa2\xbd\xac\xfd\x0d\xda\xb4\xfd\xa7\x6b\x7f\x32\xf8\xd8\xe3\xa7\x0f\x81\x1f\x03\x60\x6d\x3f\xf9\x07\xed\x6f\xda\x2b\xc0\x6a\x9f\x69\x9f\x6a\x3f\x87\x52\x62\xab\xf6\x73\xed\x33\xa8\x45\x34\xb2\x1e\x42\xd4\x7f\x0c\x1f\x13\x2b\x72\x14\xcb\x83\xa8\x30\x17\xe5\xc2\x5c\x34\xae\x52\x0c\xa8\x60\xfc\x11\xc0\x98\x21\x13\x76\x53\xe6\x83\xb7\x0d\x53\x37\x0f\x8f\x0e\x84\x09\x47\x38\x3f\xb7\x0b\xbf\xd6\x95\xff\xf7\x12\xbc\x64\xc9\x1b\xf0\x56\x4e\x8b\xe6\x1f\x20\x42\x43\xb0\x2f\x9f\xc3\xb9\xaa\x9b\xee\xb8\x11\x7b\x77\x69\x7b\x2e\xc7\x8f\x6c\xce\x1f\xda\x4c\x6c\xce\x9f\x37\x84\xb7\x1d\xb8\xf5\x96\x5b\x4e\xe0\x7b\x31\x1d\x2d\x1d\x87\xdb\x5f\x04\xa3\x1d\xc3\xb9\x8d\x45\x64\x16\x1b\x94\xa9\x84\x28\xd0\x85\x36\x10\x20\xb2\x49\x51\xd7\x9e\x40\x6d\x25\x64\x03\xc5\x56\xd7\x23\x08\xe4\x1c\xd7\xcf\x39\x8f\x74\x73\x63\x6e\x1a\xa1\x77\xb5\xc7\xde\x7d\x17\x26\xc3\x40\xb6\x2f\x9b\xed\xd3\x26\xb1\xdf\x9f\xbc\x71\x56\x69\xb2\x4f\xb0\x3a\x28\xbd\xe6\x28\x87\x55\xe8\x4b\x96\xce\xda\x38\xf9\xfb\x5f\x7d\x0a\x9f\x49\x59\xf6\xbf\x32\x57\xcb\xce\x7d\x65\xbf\x85\x32\xd2\xf0\x82\x9e\xc6\xa2\xe1\xd0\x01\xbb\x0b\xbf\xf2\xae\xf1\x23\xd9\xdc\xb7\x7c\xec\xd1\xa7\xb4\x33\x8f\x7f\xbe\x91\x3e\xea\xbb\x76\x18\x38\x1f\xc7\xfa\xcb\xa4\x0e\x47\xbe\x8e\x45\xab\x18\x54\x47\x85\x2f\x0d\xae\xdf\x72\xff\x96\x2d\xf7\xe3\xfb\x8d\xdd\x18\x8f\x51\xe1\x0b\x1c\xfd\xa1\x7e\xac\xf8\x6f\xfc\xef\x60\x64\x36\x78\xc0\xf9\x30\x95\x32\x43\x4a\x0d\x1f\xe5\xaa\x85\x7e\xa5\x9d\x89\xb3\x83\x5a\x46\xcb\x0c\x2e\xc3\x16\x38\x78\x2c\x52\xc2\x2e\xed\xa5\x7d\xf8\xc1\xfc\xd4\x61\xa8\x3b\x51\x7c\x72\x3f\xb5\x8d\xba\x1d\x59\x8c\xe8\xca\x2e\xbd\x2d\x80\x48\x2b\x09\xc8\xaa\xd9\x00\x48\x09\x60\x58\x90\x02\xa0\xb6\x02\x9f\xc0\x4a\x8c\x62\x31\x13\xc0\x92\xa8\xb6\x62\xde\x88\x87\x90\x95\x04\xa1\xc8\x4a\x1b\x88\x21\x35\x00\x34\x4f\x1b\xb8\x0b\x71\x59\x49\x90\xfa\x99\x56\x52\xcd\xaa\x31\x4a\x94\x02\x40\xd4\x98\xce\xce\x28\xa5\x7e\x39\xd6\xa3\xae\x62\x9f\x3b\xb9\x6d\x0a\x41\x5e\xb1\x70\xc1\xa6\xfd\xc2\xe4\xaa\x3a\xed\x2d\xed\xc3\xca\x44\xbb\x2b\xb0\x50\x6d\xde\xff\x66\x5b\x66\xe1\x6c\x93\xc3\x5e\x15\x9b\xfd\xf2\xb3\x4b\x13\x93\x06\xda\x85\x92\x10\xed\x7a\x1b\xab\xfb\xdc\xb4\xf3\x61\xef\x2c\xaa\xaa\x32\x3c\xaa\x5d\xff\xc5\x2e\x87\xdb\x4e\x31\xd8\x1c\x75\x7b\xcd\x44\x69\xa4\x3e\x16\x38\xf7\x09\xd8\x0c\xe5\x37\x34\x3b\x01\xdf\xd1\xd6\x17\xe2\x06\x06\x38\x97\xad\x89\x5b\xb9\xb6\xca\xbf\x71\xc2\x82\x9c\xc9\x74\x2d\xde\xe4\x8b\x9a\x4d\x35\x75\x8c\x25\xe2\xf5\x47\xcd\x4c\xa9\xdf\x64\x8a\x8e\xba\xbc\xa7\x75\xf5\x08\xb5\x35\x04\x67\x12\x22\x99\xe8\xd0\x2f\x9c\xe6\x2b\xaf\xa4\x23\xf5\xc4\x63\x77\x69\x9e\x40\xda\xcf\x6d\x95\x7d\xab\x6d\xa5\xe5\xbe\xb4\x39\xf9\xfc\xe6\xfb\x26\x7b\xab\x03\x01\x87\x35\xe1\x8a\xcf\x49\xf4\x09\xad\x06\x0e\x6c\xe1\x5d\x99\x8c\xde\xbe\x11\xcd\x2b\xb0\x5b\xcb\x06\x15\x71\x56\x35\xc2\xd9\x8d\x50\x7d\x5e\xaf\x1f\xbd\xcf\xd4\x8d\x0f\x29\x80\xf9\x74\x56\x56\xe8\x90\xe2\x00\x83\xc3\x50\xaf\xd8\xac\x22\x2b\x32\x45\x33\x85\xba\x0e\x10\x92\x28\x91\xba\xad\xe2\x3a\x4e\x31\xec\x1f\x88\x55\x42\xa5\x32\xb3\xd7\x34\xf7\xfc\x15\x04\x56\xab\x27\x5e\xfa\x88\xd0\xa5\x54\xdd\x70\x77\x95\xdc\xe5\xb6\x27\x22\x81\xe7\x7e\x1b\x8e\x25\xeb\xad\x94\xe3\x56\x6d\xd9\x6d\x36\xca\xeb\xa8\xb9\xe9\xcb\x07\x23\x01\xc7\xf7\xcc\x5c\xe5\xea\x3f\x68\x9f\x9e\x3f\x28\x57\xa6\x48\x93\x18\xa3\xc1\x44\xbb\xec\xcb\x1f\x04\xe2\x61\x4f\x30\x48\xd6\x42\xd9\x51\xab\x79\xd7\x57\x26\x44\x61\xb9\x4b\xca\xb6\x74\x9e\x69\x5b\xd8\x55\x37\x57\x08\x0e\x40\xa3\xdb\x4b\x53\x82\x40\x33\x25\x02\xef\x61\xa8\x68\x84\x62\x4a\xf2\x04\xa3\x94\x90\x2b\x56\xd0\xb6\xeb\xeb\x67\xf8\x12\xa7\xf0\x1d\x2b\xf0\x2f\x33\xa2\x1a\x6e\xf3\xd9\x22\x0e\xa1\x36\xd0\xfd\x83\x17\x62\x54\x5a\x88\x58\xfb\x05\xff\x02\xbb\x20\xbb\xc1\x0a\xc9\x63\xc6\x21\x40\xdd\x87\x72\xa4\x5e\xad\x11\x84\xe2\x92\xde\xad\x24\x88\x0c\x17\xcd\xb4\x92\xaa\x81\x30\x18\x76\x87\x39\x21\x80\xd5\x2c\x71\x7f\xbf\x74\xff\xbc\x65\x7b\x56\x4f\x0b\xff\x70\xf2\xda\xee\x5a\x81\x02\x86\xfc\x37\x4c\xd5\x1e\xb0\x87\xba\x6a\xa7\xbd\xfc\x61\xb4\x15\x70\xfd\xc2\x0d\x1b\x1a\x71\xe8\x75\xef\x9c\x45\xab\xe6\x54\x53\x8c\x36\x77\x34\x7f\x20\x90\xce\x04\x00\x8f\x5f\xe7\x2f\x30\xc8\x2a\x74\x94\x4e\xe0\x0c\x17\xce\x84\xb9\x68\x84\x61\x09\xc6\x9d\x32\x7e\xab\x15\x8e\x5b\x0b\x5d\xdd\x5a\xd5\x14\x4b\x97\x58\x00\x0e\xa1\x27\x4c\x40\x95\x64\x4e\xeb\xde\x5e\x39\xe7\x86\x53\x26\x7c\x0f\x6e\x1b\x5f\x7f\x53\x1e\x15\x41\x2a\x2b\x97\x60\xe7\xd3\x30\xd1\x52\x35\x7b\xd9\xec\x92\x3b\xb4\xc1\x86\xb3\x56\x74\x60\xa8\x25\x6b\x8e\x5e\x0b\x25\x0e\xb5\xe3\x3c\x8d\x0c\xd4\x1e\xf1\xc4\x26\x3d\xfe\x8f\xd3\xae\xdd\x66\xb1\xb3\x16\xed\x26\xbb\xc9\x2c\x14\xf1\x02\x01\xc9\x4e\x2d\x67\xb1\x40\xce\xc9\xf3\xa4\xb1\x66\x71\x70\xcc\xa7\x04\xe1\x3c\x35\xa2\x3f\xb3\xe8\xb7\x72\x18\x36\x59\x2d\x06\x89\xe1\xfc\xe1\xe7\xb8\x9d\x76\x18\xd4\x9f\x0e\xa7\xd8\x49\x9e\x3f\x68\x38\x70\x93\xfb\x64\x27\xe4\x2c\x16\x2d\xe7\x2c\x72\x5b\x01\xc1\x20\x22\x6f\x3c\x73\x0c\x05\x7f\x0c\x03\x5f\x2a\x80\x67\x30\x48\x2f\xc1\x31\x85\xc2\xfb\x8e\xfe\x8d\x93\x59\x43\x82\x22\xd7\x16\x41\x8f\x14\x9f\x59\x58\x97\x3e\x1a\x3d\x5f\x02\x91\x1e\xd1\x8b\x70\x4c\xa9\xf0\x0e\xd6\xa2\xdd\xcc\x9a\xc6\x8b\xa0\xdd\x66\x39\xec\x8f\xbf\x86\x46\x48\x36\xa2\x1e\x8b\xe6\x9c\xae\xac\x47\x23\x04\xce\x14\xb5\x6d\x5d\x67\x37\x2c\xbe\x02\x47\x28\x8c\x71\xab\x16\x88\xee\x24\x41\xa4\xd6\x28\x33\xb7\xe5\xea\x16\xcc\xee\x68\x99\x31\x23\x75\xed\x55\x57\xac\x59\x73\xef\xe4\xe5\xcb\x22\xd5\x27\x2f\x99\xb4\x7e\x30\x9d\x9e\x1e\xed\xb8\x58\xfb\x4b\x69\xa0\x2d\x9b\x8d\x77\x11\x53\x7a\xef\x07\x02\x00\x3a\xce\x3d\xf7\x17\xa1\x50\x38\x02\x04\x50\x9f\xed\xdf\x75\x59\x20\x10\x89\x74\xc4\xda\xbb\x52\x83\x6b\xb6\x3c\x47\x6e\x6a\x99\x32\xa5\x2d\xeb\xb2\xd2\x57\x9d\xbe\xb2\x9c\x70\x12\xa4\xed\xb0\x3f\xbf\x81\x45\x5e\xd0\x0e\x10\x70\x71\xce\x60\x73\x2a\xee\xf1\x3d\xf9\xd9\xfa\x1f\x9d\x1b\x3d\x9b\xf8\xfe\xe8\xd9\xd8\x95\x3f\x7b\x10\x57\xe3\xbf\xe7\xcf\xc0\x99\xfc\xfa\xd1\x8f\xce\xc5\x57\x11\x67\x8e\xbe\x8b\x6f\x32\xf8\x23\x0d\xdc\x59\x6a\xab\x31\xde\xfb\x91\x8a\xa6\xa2\x05\x08\xa1\x64\xd6\x18\x9f\xc8\xe2\x9e\x2a\x8c\x62\x85\xc6\x5d\x80\xb2\x34\x02\x2a\x5b\x74\x73\xd7\x98\x5c\x50\x8c\x35\x42\x08\x80\x3b\x9c\xce\x1a\x9e\xac\x41\xc8\x26\x25\x35\x2b\x89\x8c\xf1\x65\x14\x3f\x8c\xa4\x08\x6f\x85\x24\x29\x24\xc2\x13\x21\x51\x0c\x49\xa3\x07\x2b\x9a\x9b\x66\x37\x37\x93\xd3\xdb\xab\xa7\x34\xcf\x6e\xbe\xb8\xb9\xb2\xa2\x19\x7a\x13\xed\xf8\x47\x2b\x73\xa3\xa7\xe4\x4e\x9f\xc4\xd8\xec\xcc\xe4\xc5\xbf\x5b\x3c\x99\xb1\xdb\x18\xb8\x5a\x3f\xdf\x5c\x51\xd9\x4c\x96\x4a\xfa\x73\x0a\xff\x5e\x6e\xae\xd0\x06\x2a\x9b\x9b\x2b\xe1\x47\x15\xcd\x7c\x7e\x49\xa2\xfd\x6f\x7a\xee\x6f\x85\x6d\x7b\x02\x5f\x0f\x57\xa9\xcf\x9e\x7d\xf6\xb3\xea\x0e\x3b\x43\xdb\xce\xaf\xa8\x38\xdf\x46\x33\xf6\xfc\x55\x63\x77\x55\x36\x35\x21\xb3\xa1\x77\x7d\x69\x70\x6e\x38\x50\x04\x4c\xe0\x86\x38\xa4\xa0\x07\x3e\x35\xf0\x54\xa2\x74\x26\xad\x26\x25\x5a\x66\xb2\x92\x08\xb2\xde\xef\x30\xb4\xde\x7f\xb7\x12\xcd\x20\x43\x5a\xd1\x15\x9e\x82\xbe\x23\x4a\x06\x87\xac\xae\xf9\x18\x23\x9d\x9c\x2d\x4e\xa7\xe8\x9d\x3c\x43\x8b\x6a\x36\x9d\x49\x10\x0a\x2d\x09\xd1\x04\xd0\x4a\x56\x56\x64\x9a\xa1\x03\xa0\x5b\x86\x8c\x11\x00\x25\x25\x45\xda\x08\x5e\x35\x86\x58\x42\xef\xfb\x09\x7d\x48\x80\x02\xc7\x09\x43\x2b\x72\x61\x44\xa0\x44\x49\x60\x29\x86\xc5\xfa\xb8\xa0\xb7\x4e\x16\x1b\x5d\xa2\xa8\x5f\xa2\xbf\x07\xa3\x94\x86\x77\xa5\x71\x77\x00\xbb\xb3\x4a\x42\xef\xb0\x24\xb1\x10\xc8\xaf\x5f\x60\x2c\xe0\x66\x0d\xea\xfc\x56\x10\x41\x2f\x90\x5b\x94\x92\x0c\x9d\x4a\x52\xba\x48\x64\x61\xa8\x52\xd2\x09\x60\x22\x7a\x52\x12\xd4\xac\x9a\xd6\x95\xb9\x28\xab\xab\xfd\x58\x12\xf5\x27\x24\xb3\x10\xc0\x7a\x71\xc0\x80\x66\x21\x0c\xf0\x22\x86\x25\x94\x42\x55\xe8\x3f\xa0\x57\x82\xae\x1d\x42\xc6\x28\xa2\x5e\x38\x82\x11\x68\xa9\xe0\x02\x8a\xd5\x56\x6c\xcc\xc6\xc9\xfa\x49\x63\x1e\x8e\x50\xb3\x6a\x61\x7c\x4c\x19\x60\x36\x4c\xf1\x5a\xd1\xd0\x3c\x8d\xc7\xb2\xa0\x8b\x21\x16\x1f\x5c\xac\xe9\x00\x85\xaf\xb1\x9a\x49\x8a\xa7\x16\x92\x0e\x8b\xc7\x44\x68\x37\x90\x24\x45\x10\x8c\xc5\x4c\x72\x24\x60\x0c\x98\x98\xa5\x92\x0c\x41\x60\x06\xcc\x60\xe9\x8d\x7a\xc2\x73\xc2\x56\x25\xe8\x00\xab\xd9\xed\xb2\xdb\x81\x8d\x94\x88\x24\x29\x58\x15\x47\x13\x6d\xa2\xc5\x92\xb8\xdf\x62\x75\xb9\xed\x14\x57\x22\x3a\x57\xba\xc0\x5c\x5e\x42\x40\xc4\xef\x2b\xc5\x60\xe6\x18\x0b\x4d\x5a\x19\x0e\x40\xf0\x70\x02\x80\x68\x36\x29\x60\xa7\x2c\xac\x68\xf1\x89\x35\x2a\xae\xf0\x85\x28\xb3\x95\x22\xcc\x36\xa1\xc7\x5c\xe5\x2d\xc9\x5a\x00\x9c\x25\x15\x9c\x1c\x09\xfb\x44\x3b\xc6\x34\x6d\x65\xec\x84\x7f\x7a\x56\x74\x57\x88\x04\x04\x4a\xed\x2e\x69\xba\x09\x03\x6d\x72\x87\x48\x4c\x93\x14\xc6\xb1\x04\x55\x46\x0a\x3f\x34\x3b\x89\x60\xc0\x54\xc1\x26\x14\xd2\x4e\x03\x21\x58\x12\x1b\x2e\xa8\x92\xac\x36\x0c\xa2\x99\x76\x13\x12\xc6\x1c\x16\x1d\x31\xe8\x9a\x96\xbf\x95\xb0\xd2\x66\x4c\x58\x08\xc2\x4a\xc0\xed\xd8\xcc\xd1\x94\x99\xa2\x31\xc1\x56\xb8\xcc\xd6\x87\x2c\x36\x82\x26\x49\x82\x25\x4d\x38\x4b\xd9\x09\x87\xd9\x4c\x11\x18\x2c\x98\x24\x4d\xac\x09\x9c\x2c\x56\x05\x11\x33\x1e\x29\xee\x95\x4d\xf2\x62\x3f\xb7\x44\x76\x49\x96\x48\xa0\x6a\x36\xdf\x27\x54\x4d\x8a\xa5\xfc\xa5\xbb\xdb\xf9\xf6\x58\xa5\x87\xb2\x44\x00\x2c\x16\xb0\xb0\xb3\xb9\x80\xc7\x9d\x09\xa5\x22\x66\xbb\x0b\xdb\x28\x12\x22\x04\x11\x11\xb6\x45\x3d\xa7\x76\x48\x95\x95\x84\x4b\xb0\x6c\xac\xed\xae\xb6\x92\x04\x80\x2b\xc0\x98\xe2\xa2\x2c\x9c\xc9\xda\x48\x9c\xee\x57\x3a\x32\x2b\x62\x0d\x13\x28\x2a\x1a\x39\x45\x9d\xe7\x30\xd1\x2e\xab\xc5\xe7\xcb\x46\x5c\x3e\x97\x99\xc5\xa2\xec\x72\x0a\xbc\xa5\x7e\x7e\x59\x53\x4b\x4f\xa6\xd6\xaa\x84\xc2\x61\x82\x05\xd6\xe1\x75\xfa\xc8\xd3\x80\x07\xda\x46\xb0\xe0\x20\xac\x76\x5a\x1b\x00\x13\x47\x51\x26\x2b\x80\xd3\x42\x98\xf4\x17\x8e\xb5\xeb\x5d\x1e\x47\x89\xcf\x59\x6a\x89\x30\x95\x54\xed\x99\x82\xd0\x76\xdb\x59\x65\x98\xac\xde\x94\x50\x9a\x83\x2e\x1b\xb4\x0e\x04\x62\xa2\xbb\x23\x62\x22\x02\x00\xc9\x34\x10\x9d\x25\xbc\x83\x21\xdb\xa9\x40\x99\xdb\x4c\x98\xb6\x3a\xcc\x04\xc9\x34\x74\x02\x34\x04\x1d\x55\x41\x4c\x58\xcd\x50\xca\x8b\x01\xa8\x88\x91\x0e\xd6\x26\x01\xeb\xa5\x4c\x92\xc3\x0a\x98\x03\x9b\x99\x33\xb3\x34\x61\xb5\x13\x74\x90\xe4\x49\x8a\xc1\x24\xe9\x90\x00\x6c\x4e\xde\x61\x26\xcd\x98\xa2\x48\x9a\x60\x80\x6d\xf6\xda\xac\xad\x41\x33\xc1\x94\xb4\xd5\x76\x97\xd2\x3f\x6c\x70\x2d\x31\x79\xdc\xc1\x36\xbf\x9f\x07\x20\x3b\x4e\xb3\x85\x48\xe9\x7b\x66\x47\xa2\x8c\x70\x34\xd5\x25\x3c\xdd\x26\xa7\x09\x53\x66\x26\xed\x74\x4c\x96\x4d\x74\xa2\xa4\x4b\x2a\x05\xfe\xac\x90\x7b\xf9\x3c\xaf\x2b\x1e\xb2\x12\x15\x9c\x17\x63\x33\x05\x0e\xe1\x69\x13\x43\x90\x84\x85\x66\x00\x3b\x55\x12\x5c\xfb\xac\x9c\x09\x48\x12\x48\x1f\x41\xe1\xf7\x31\x6d\xc2\x0e\xb0\xdb\x69\xd2\x4e\xd1\x04\x6d\x23\x80\x3c\xf0\xbc\xad\x44\x12\x45\x4e\xb0\xbb\x48\xbe\xd7\xe7\x64\x5c\xe6\x52\x91\x03\x7d\x88\xf2\x87\x4a\x00\x9a\xed\xa4\x95\xb1\x71\x56\x69\x8e\xd5\x59\x1b\x8f\x99\x6d\xa4\xc5\x15\x89\xf4\x84\x05\x8a\xb0\x3b\x2a\x68\x8f\x4d\xb4\x3a\xba\x59\xce\x4c\x97\x98\xe8\x10\x4b\xd0\x55\xe9\x0e\x85\x7b\x2a\xdd\x1b\x31\x7b\x9c\x62\x69\xa2\xd6\xe5\x5e\x92\xed\x16\x2e\x4d\xaf\x7e\x6e\xfe\xe6\x4a\x37\x94\xfa\x2a\x6e\xe9\x5e\xbc\x7e\xcd\xf2\xa6\x57\xe6\xd4\x4d\x2a\xc3\x38\x12\x0f\x00\x98\x78\x5b\x29\x15\x67\x67\xaa\x13\xcf\xed\x98\x44\x85\xeb\xa2\x25\xae\x78\xa8\xc4\x6a\xed\x9d\x64\x0b\xa6\x02\x3e\xab\xa3\x18\x1f\xaf\xeb\x62\x2c\x0a\x21\x05\x25\x50\x12\xb5\xa2\xd9\xe8\x64\x84\xe2\x32\x11\x65\x58\x92\x51\xc4\x54\x92\x90\x15\x32\xac\x8f\xd2\x52\x81\x0e\x58\x91\x15\x16\x98\x10\x25\x33\x7a\x27\x07\x11\x26\x4b\xe9\xe3\xbb\x28\xb5\x92\xbc\xac\xe8\x77\x19\xbd\x49\x2b\x24\x03\xa4\x94\x3d\x2a\x82\xa0\xe2\x64\x8c\x9d\xd9\x2b\xb7\x5e\x18\x75\x3c\xf6\xfe\xf9\x2d\xee\x90\xf6\x2b\xed\x6a\x98\xdb\x9f\xbc\xe2\xe2\xcd\x72\x9c\x74\x2d\xdd\xb0\xe5\xe2\x91\x10\x24\x88\x37\x7f\xfb\xcb\x39\xe5\xab\xae\x1c\xfd\x14\x00\xf0\xf4\xbd\x5f\xf4\x4d\xdf\xb1\x6e\xc2\xa6\x49\xcd\x8e\xfd\xc4\x2e\x30\x0b\x5d\x53\xce\x9d\x50\xc2\x63\x33\x11\x9b\x3a\xb1\xbb\x39\x53\x19\xb0\x6c\x3a\xc6\x0e\x8b\xe9\x77\xd2\xee\xa9\x73\x76\x4e\xb5\x5e\x8d\xaf\xa8\x6b\x5d\xc4\xb0\x5b\xfe\x32\x6f\xde\x0d\x83\xdd\xac\x1d\xa8\xdf\xbf\x76\x47\xc7\x67\xd7\x7c\xdc\x1c\xfc\xf8\xdd\x29\xef\x10\x67\x00\x5c\xbe\x9b\xbf\xe7\x77\xde\x09\xd9\x66\xb7\x16\xf9\xc7\x03\x60\x2b\x69\x6f\xe8\xf1\x67\x2a\x28\x0f\x45\x91\x04\x45\x33\x14\x7e\xfe\x44\x78\x8c\xc5\xfa\x6b\x45\x83\xba\xfd\x91\x20\x6a\x20\x41\x66\xd2\xa9\x64\x80\x28\xf8\x5e\x41\xd4\xa0\x67\x32\x50\x73\xa4\x02\x47\x6f\x82\x18\x5b\x47\x69\xc5\x05\xe2\x2d\xda\x60\x9a\x2d\xa0\xcf\xe9\x5a\x51\x36\x95\x24\x45\x97\x5b\x60\x44\xf2\x2a\xa5\x71\xee\xd4\xba\x65\x01\x7f\x85\xcb\x71\x59\x65\x77\x59\xac\xca\x5b\xd3\xb0\xfa\xbe\xa1\xee\xdc\xaa\x2e\xb9\x77\x76\xf3\xae\xf9\x62\xa8\xbf\x23\x35\xa3\xae\x22\x59\x9a\x4c\xfd\xfb\xee\x9e\xef\xae\xea\x84\x95\x7f\xb9\x65\xfb\xb2\xa9\x3d\x97\x6a\x07\x9f\x5c\xe5\xec\x2f\x66\x80\xd2\x33\xf0\x46\xf2\xa4\x6c\x95\xc7\xea\x61\x18\xa7\xd3\xcb\x4d\xf5\x84\x23\x9e\xf6\x6a\x75\x5e\x22\xd8\xb6\xaa\xa7\x65\x41\x73\x9c\x8d\x89\xac\x50\xa6\xa4\x42\xd5\xd5\xa1\xe6\xea\x85\x3b\xe2\x13\xcf\xbe\xec\x96\xbf\xf4\x3b\x57\x3d\x09\xd4\xa5\x3d\x53\x97\x6d\x2f\x64\xb4\x83\x7a\xc6\xb0\xcf\xab\x0e\xe5\xc8\xff\x33\x62\x59\xda\x50\xb7\x11\x71\x35\xb6\x1e\xa2\x1a\xf8\xe4\x49\x83\xa6\x58\x1e\xb7\xca\x99\x55\x69\x0b\x30\x2c\x69\x38\xf8\x02\x0b\xca\x11\xf8\x54\x22\xeb\x05\xe2\x1f\x71\xca\xef\xce\xd7\x4b\x41\x1a\xa2\x52\x20\xfc\xb1\x18\x20\x3c\x76\x32\xe8\xd6\xfe\x58\x2a\xcb\xa5\x30\xdf\x15\x79\xd7\x31\xb5\x95\xa4\x69\xd1\x97\x0c\x6b\x9f\xda\xcd\x26\x6d\x50\xec\xb1\xa9\x7d\x03\xc4\x86\xc5\xed\xe2\xcd\x64\xeb\x54\x72\xda\xd3\x52\x24\x22\x1c\x7c\x90\xa1\x61\xc8\xeb\x28\x75\x6c\x6f\x71\xcb\x72\x69\x45\x69\xdc\xf7\x51\x8f\x76\xae\xf6\x4b\x4e\x74\x57\x89\x82\xc5\xac\xf9\x4a\x18\xb3\xd8\x47\x6d\x57\x17\xaf\x58\x31\xfa\x3e\x07\x0d\xb0\x03\x1d\x33\xef\x50\xb0\x54\x8e\xf3\xd4\xfc\x06\x8c\xd3\x11\x17\xab\x19\x3a\x33\xec\x2b\xae\xd8\x1e\xce\x0d\xcb\xde\x03\xc6\x92\x0c\x95\xf3\xca\x23\xa4\xb1\xde\x3b\x8a\x0c\x62\x72\x6c\xac\xe4\x1a\xeb\xb9\x04\x7b\xe4\x22\xf9\x30\x17\x22\x85\xa8\x7d\x06\xff\x63\x61\x15\x4a\x21\xa2\x6e\x5e\x34\xfc\x98\x8e\x22\x67\x49\xab\x7c\x26\x4a\x14\xd9\xda\x8c\xd8\x6f\x09\x0e\x43\xba\x51\xa8\xbe\x2c\x55\xfa\xb7\xea\xcf\xcd\xb2\x77\xa4\x33\x31\x9c\xe8\x1c\xf1\xca\xe6\xcf\xab\xff\x56\x9a\x2a\xab\x77\x02\xea\x59\x0a\xb9\xa5\x3d\x80\x9c\xda\xd0\x8e\x9f\xee\xd8\xf1\x53\xd8\x57\x56\x5f\x09\xb3\xce\xd7\x4e\x73\xb8\xbc\xb2\xf6\x49\xa2\xb3\x33\x01\x4e\xd9\xeb\x72\xc0\x0d\xe7\x6b\xf7\x56\xd6\x97\x95\x7a\x20\xb7\x72\xa5\x96\xf3\x10\x43\xfa\x0d\x3b\x0a\x65\x25\xf5\xb2\xc6\x0d\x4f\xdc\xa2\xb2\x1b\xfd\x8a\x7d\xa1\xce\x0e\xe3\xb3\xa1\xfa\xfe\xfa\xf6\xce\x85\x9d\xc6\x5f\x7d\x7f\xfd\xea\x7e\x9c\xeb\x5f\xad\xed\x33\x4a\x43\xb4\x6b\x05\x9e\xbc\xa1\xd1\xd5\x46\x49\x5e\xd1\x6a\xf5\x3d\x71\x99\x66\x60\xfc\xc1\x70\xff\xea\xd5\xf0\xe2\x91\x72\x14\xde\xa3\x1b\x85\x11\x8a\x43\x2b\xc8\x8a\x3c\xc6\x6a\x87\x19\x16\x44\x29\x36\x7e\x82\x87\x82\x41\x27\x57\x5a\x53\x36\xbb\xc5\x13\x6b\x6e\x8a\x79\x5a\x66\x97\x27\x4a\x39\x27\x39\xf7\x98\x0e\xe6\x7d\x78\x43\xec\x1d\x0a\x7a\x21\xe2\x2f\x2b\xf3\x47\xc0\x1b\x1c\xea\x15\x77\x9e\xa0\x8f\xa8\x3a\x84\xe8\xdf\x51\x87\x90\x03\xf5\x20\x84\x0a\x84\x6d\x42\x00\x27\x5b\x21\x4e\x33\x06\x38\x94\x12\x37\x62\xac\x29\xc3\x2d\x38\x2e\x2b\x72\x1b\xe8\x7a\xa6\x1a\x37\x7c\x84\x29\xd5\x20\x9b\x37\x30\x7c\x28\xc3\x11\x57\x12\xa9\x91\x05\x37\xbc\xf6\xfe\x6b\x37\x2c\x28\xec\x60\x15\xe9\xd4\xde\xb4\x3b\x58\xed\xcd\x87\x2c\x21\xcb\x43\xda\x9b\xac\xc3\xae\xbd\xe9\x24\x29\xf3\x43\x0f\x99\x29\xd2\x09\x31\xbb\x83\x85\xd8\x43\xe6\x88\xf9\x21\x88\xb1\x0e\x3b\xc4\x8a\x27\xb1\xf5\xc8\x63\x16\x2c\xb8\x21\xe3\xa0\x86\xb4\x97\x9c\x16\x0b\x3d\xf8\x85\xdd\xfe\xc5\x20\x6d\xb1\x38\x21\x39\x44\x39\x38\xdb\x17\x5f\xd8\x9d\x0e\x6a\x08\x92\x85\xb3\x36\x5b\xe1\xac\xf6\xd2\x10\xe5\x70\xda\xbf\xf8\xc2\x56\xb4\xfd\x9e\xa2\xce\x43\x2e\x54\x87\x50\x5c\xef\xd7\xf4\x6e\x8d\x36\x7a\xc0\x54\x32\x16\xa7\xc9\x62\x57\xe7\xca\xc6\x0c\x4d\x99\x05\xb7\x41\xaa\x6d\x68\xe2\xe4\x47\xd9\xfa\x47\xb4\x17\x1e\x5a\xf6\xab\x43\x4b\xee\xfd\x70\xfb\x65\x40\x80\x3c\xa8\x5d\xb0\xef\x46\x6d\xff\x4b\x9b\xd6\x3d\x0b\xae\xeb\xaa\x38\x57\x78\xf6\x82\x5d\x07\xae\x3c\xe7\xcc\xf2\x20\xcb\xbc\x67\x7e\x08\xb2\x8f\x8c\xdc\xd1\xac\xfd\xe8\xf5\xed\x1f\xde\xbb\x64\xf3\x33\xff\xf7\xaf\x4d\x2f\x81\xff\xc6\xeb\x40\xfa\xf5\xb9\x34\x2e\x2f\x0f\x4e\x7b\x79\xdd\x95\x07\x76\xa5\x5c\x41\xb6\xac\x80\x6d\x46\x8f\x14\xd7\xb4\x2b\x8b\x1e\x8c\xc6\x72\x7e\xf8\x38\x3f\xfe\xe3\x62\x5b\xda\xc7\xa1\x69\xe0\x25\xe3\xbf\xe0\x76\xd9\x7b\xc0\x38\x43\x23\xaf\x8c\xef\x2c\xc0\xff\xa1\x51\x03\xe9\xc3\x58\x85\x85\x3b\x8f\xe0\x70\x18\x38\x1e\xa1\x43\xc3\xf4\x10\x35\x82\x3a\xd1\x64\x23\x12\xaf\x12\x04\x46\x12\x05\xa3\x19\xb0\x64\x94\x8b\x72\x91\x04\xae\x19\xa3\x5e\x6c\x83\x22\xe9\x43\x13\x70\x8a\xfe\x7d\x04\x0d\x84\xa0\x22\x40\x10\x84\xd3\xd9\x90\x48\x0f\xc9\xde\x7d\x5d\xaf\xf0\xbc\x2b\xeb\x7a\x8e\x12\xda\x3b\x4f\xae\xcd\xa5\x4e\xeb\x69\x62\x1d\x8f\x0a\x7e\x0f\xcf\x13\xdc\x0b\x8d\x05\xb8\x8f\x3d\xbc\x9c\xe6\xf7\x10\x7d\x7b\xf8\xb4\xcc\xef\xd9\xe7\xd5\x26\xe6\x73\x8f\x83\xe5\x71\x3c\x3f\x2d\xdf\xbb\xfe\x37\x7c\x9a\xe7\xf9\x67\x29\x67\x79\xc8\x4b\xe4\x46\x73\x3e\x45\xb1\xb3\x2f\xbb\x9d\xae\x8c\xf0\xb7\xb5\xc3\xba\x60\x72\xe1\xc6\xc2\x63\xb4\x3f\x62\x74\xc1\xe3\x8f\x23\x04\x87\x0e\x21\x60\xce\x25\x27\xa1\x0b\x0c\x9f\x41\x9a\x61\x71\x00\x1b\x40\x1a\x01\xcc\x42\x94\xa2\xe5\x1a\x48\x10\x0c\x4b\x4a\x82\x41\x81\x11\xa5\x75\x09\x13\x04\x56\x0c\xb4\xad\x54\x3c\x00\xfa\x18\xa9\x6f\x03\x44\x52\x6d\x25\x0d\xec\x08\xc3\xe0\xd2\x5b\x8a\x14\x20\x04\x03\x0f\xc6\x98\x15\x6f\xc5\x6a\xb6\xb0\xfe\x81\xa5\x78\x56\x94\x98\x73\xa5\x3d\x9e\xf2\xb2\x40\x90\xe1\x13\x11\x12\x2e\x49\x12\x0c\x63\xaa\x90\x0f\x21\x4f\xbb\x20\x04\xfa\x1b\x3a\x3c\x84\xc5\xc3\x3b\x80\x21\x49\x57\x74\xdd\xa4\xab\xd7\x2c\xf2\x94\x58\xa2\xa7\x2f\xbb\xa4\x99\x26\x48\x47\x05\xb8\x6c\x22\x45\x39\x4d\x42\xda\xe1\x2c\xcd\x56\x96\xf9\xed\x98\x76\x99\x2d\x14\x66\x19\xba\xa4\xd9\xee\x72\x8a\x99\x9f\x0e\x64\x04\x1f\xcb\x60\x02\x03\xcd\xb1\x26\x57\xa4\xa2\x35\xde\x5c\x43\xda\x28\x12\xd3\x82\x05\x42\x4a\x92\x26\xbe\x68\x7f\x37\x94\x49\x55\x34\xf8\x2a\xaa\x82\x18\xef\x98\x4f\x39\xe4\x40\x09\x49\x09\x36\x9b\x7b\xf6\x84\x1a\x13\x50\x9e\xe8\x84\x4a\x47\x09\x4d\xf1\x04\x59\xde\xd1\xe5\xf1\x58\xca\x76\x0e\x03\x7d\x89\x53\xa4\x68\x1e\x63\x33\x49\x58\xdd\xc9\x95\xfe\xd2\xe6\xb9\x75\x7e\x0a\x4c\xb1\xc6\x65\x3d\x65\x9d\x76\x5b\xc4\x8c\x45\xde\xea\xc5\x60\xa3\xb8\x60\xb8\x31\x3d\x4f\xb6\xb6\x46\x6a\x82\x66\x4c\x7a\x2b\x17\xb4\x2e\xdb\x68\x71\x10\x04\x10\x04\x60\xca\x61\x36\xb8\x82\xef\xa1\x3f\xa7\xa6\x20\x8b\xd1\xe3\xd5\xa0\x59\x68\x39\x3a\x0f\xa1\xf8\x61\x9b\x58\x1f\x8d\x8d\xa4\x24\x66\xa5\x31\xbc\x4f\x29\x00\xf1\x04\xc4\x18\x9a\xd4\x3f\x44\x35\x1b\x8b\x0b\xac\xde\x2b\x26\x20\x93\x76\xa9\xd9\x98\x6e\x0e\x06\x20\x6b\xe0\xa2\xe9\x9f\xad\x61\x5a\xe2\x00\x14\x01\x43\xb3\x32\x43\x17\x4c\xca\xb8\x71\xcc\x38\xa4\x24\x40\x37\xd9\x75\x13\x1d\xdf\xee\x16\xa2\x91\x69\x6e\xd1\xd5\x3d\xe3\x2c\x93\xd9\xce\x96\x32\x5c\x80\x0d\x3c\x5c\xfd\xd7\x55\x2b\x67\xd4\xd4\xfc\x66\xc5\xaa\xc5\x60\x35\x0f\x6b\x87\x76\xbd\xad\xfd\x89\x35\x0f\x03\xec\x7a\x1b\xe2\x20\xf7\x5e\xf6\x73\x2d\xaf\xbd\xab\xfd\xfb\xb5\xed\xdf\xcf\xdd\x0d\xf3\x7a\x3b\xaa\x49\x9a\x75\xd0\xf4\xf7\x7f\x9f\xa8\xae\xc6\x14\x6b\xb1\x35\x2c\xec\x3e\x6b\x66\x09\x6f\xaa\x94\x24\x91\x11\xe6\xb6\x79\x2a\x48\xca\xeb\x69\x86\x59\x73\x52\x8a\x39\x99\xf5\x9a\xfc\xb1\xd6\xd6\xfb\xe6\xf8\x6b\x6d\x41\xff\xe6\xcf\x46\x23\x13\x1d\xac\x37\x1c\x99\x10\xf2\xdd\x60\xf7\x51\x94\xd5\x1e\x64\x29\xeb\xe0\x92\xa1\x58\x64\xef\xe2\x45\x0b\x7d\xa5\x0f\x37\x0f\x5d\x39\x91\x95\x3e\xdc\x55\xd8\xed\xec\xbe\x74\xc7\xb2\xd6\xae\xf5\x8f\x9e\xbe\x0e\xc8\xdc\xdd\xdf\xed\x6d\xbf\x9c\xb5\x61\x02\xe3\xa6\x96\xb6\x75\x76\xd6\x4a\x92\xae\xc6\xe5\x78\xf1\xe0\xe6\x7a\x49\x64\x4c\x95\x52\xdb\x90\x9d\xf2\x7a\x3c\xe5\x94\x7d\xfa\x50\x7e\x9d\xcf\xeb\x4a\xfa\x06\x1e\xea\x9e\x90\x71\xd1\xc1\xfa\x1a\xda\x3b\x65\xbc\x6e\xb1\x16\x99\x11\x8f\x4a\x11\x32\xf8\x6d\x5b\x41\x0d\x00\x70\x02\x66\x64\x2e\xed\x8a\x81\x93\x91\x71\x86\x13\x49\x17\x79\xc6\xbd\xcf\xfe\xe2\xde\x8b\x9f\x89\x44\x9f\xd1\x6e\xc8\xff\xfa\xe1\xbb\x20\x46\x66\x1e\xfe\x75\xfe\x41\x88\xdd\x15\x19\x1c\x9c\xf3\xc5\x65\x97\x7d\x41\xb5\x68\xbe\x51\xed\x3b\xa7\xbc\x0e\x9e\xc7\x61\xc2\xef\xf3\x15\xda\x3f\x5e\x3f\x05\x6e\x19\x85\x77\x02\xbf\xd7\x1e\x2f\x62\x3d\x23\x6a\x13\x8d\xd0\x4a\x84\x80\x25\x74\x55\x95\x46\x8c\x81\xf2\x91\x8d\xa9\x2c\x4e\x10\x4a\x2b\x04\xb0\x94\xd5\xd3\x94\x9e\xa6\x82\x90\xcd\x24\xa8\xac\x1a\x20\x59\xec\x00\x51\x60\x5a\x29\x51\x62\xf5\x0f\x99\xd6\x93\xd4\xa6\xd0\xdc\xc1\x65\xa7\x0c\x4e\x6f\x76\x72\x6b\xb4\x5b\x5e\xe1\xbd\x5e\x7e\x0f\x54\x2e\x89\x4d\x1e\x9c\x7b\xf2\xec\x93\xc2\x6b\x9f\xff\xde\xda\xb6\x92\x8c\x97\x11\x27\x75\x2f\x1e\x98\xdd\x5e\x4d\x4f\x3c\xef\xe4\xd9\x2d\xa9\xb0\x48\x91\x36\x93\x6f\x52\x7d\x9a\x95\x53\x3d\x67\x34\xc7\x28\x5a\x70\x99\x18\x00\x82\xad\xc9\xce\x5d\xbc\xad\x1b\x2b\x2d\xd3\x66\xcd\xec\x6b\xe2\x38\x29\x49\x7b\xa6\xf4\xaf\x3f\x6b\x27\xfc\xa4\xff\xac\x96\x10\xc1\x06\x4a\x2c\x96\xfd\xda\x97\xe0\x95\x4b\xe0\xb5\x27\x58\x97\xc9\x5e\xd5\xbb\xf5\xa4\x1a\x21\x3a\xad\xaf\x6a\xc7\x30\x10\x98\xe0\x4a\xeb\x7b\xd7\x4d\xf4\x73\x7c\x79\x53\x5b\x5b\x9d\xc3\xb9\xa9\x87\x16\x26\xf4\xae\x5e\x73\x49\x77\x49\x4f\xff\xfc\xb9\x27\x4d\xcc\x3a\x1c\xe4\x42\x2f\x23\xb5\x65\x1a\x83\x58\x9a\x76\xde\x40\x4b\xc0\x05\x04\x41\x5c\x71\x21\x23\x35\x25\x64\x5c\x87\x48\xe4\x3e\x84\xc8\x7f\x52\xc8\xf0\x24\x17\x8c\xf8\x2a\x43\xc3\x82\x82\xcf\x3e\xb8\xc3\x9c\xfe\x17\x77\x8f\x31\x32\x91\xff\x5c\x37\xa3\x41\x1b\xcd\x7f\x3c\x63\x1d\xf9\xfb\x83\x15\x63\x7f\xeb\x66\x10\xd3\x66\xac\x03\x5f\xe7\xac\xf5\xda\xbf\xc0\xbe\x7e\x56\x27\x4c\x3c\x84\x0e\xc1\xe4\x43\xe8\xd0\x0f\xba\xba\x66\xae\x5f\x3f\x4e\xcf\x2c\x41\x71\x7d\xd4\x44\x5f\x49\x63\x2a\x7e\x45\x70\x17\x99\x2b\x12\x99\x8e\x91\x6c\x16\x88\x4c\xef\xfe\xba\x40\x2f\xbc\xf3\x04\x7c\xa6\xf7\x7e\x5d\xc0\xd7\x51\x3a\x71\xb1\xac\x47\xb3\xb1\x8e\x27\x63\x75\x7d\x65\x59\x79\xbb\x36\xac\x17\xf0\x08\x15\x2b\x0c\xd9\xf9\xe1\xaf\x2d\xec\xbe\x62\x11\xa1\xcd\xec\x1f\x63\x64\xd5\x0e\x7d\x6d\x69\x8f\xd3\xdf\x0b\x73\xa6\x47\x8a\x79\xac\xfe\x7e\xdc\x6a\x03\x92\xbd\x02\x57\x08\x3b\xe3\x04\xaf\x0c\xe8\x6b\x02\xd4\x46\xf2\x39\xaf\x6c\x2b\x86\x8d\xd9\xe4\xd1\xe7\xbe\x45\x3c\x18\x83\x78\x14\x3c\x12\x87\xef\xfa\x0a\xc6\x80\xe2\x7a\x6e\xc5\xd7\xf1\x06\x14\xa3\xeb\x21\xf4\xb5\xf4\x01\x45\x1f\xf7\x45\xd4\x3e\xe4\x46\x59\x84\x40\x32\xd4\x31\x5d\x1b\x53\x25\x7d\x6c\x45\x29\x5d\x29\x95\x8c\xde\x88\x28\x00\x89\xa9\x06\xb9\xa8\x5b\xa0\x15\x3e\xec\x0e\x4b\xe1\xa4\xc4\x13\x87\x96\x34\x6a\xaf\x3c\x7e\xa3\xf6\xf9\x0d\xbf\xb9\x87\xdb\xb4\x0b\x98\xbd\x5b\x5f\x3b\x1b\xfb\x1a\x0f\x21\xbb\xb3\x8c\xfb\x58\x2b\xf3\xc4\x89\x21\x6c\x62\x67\x67\x3b\x07\x97\x75\xc7\xe1\x2e\x6d\xb9\x13\x7e\x59\xc6\xed\x87\x45\xbf\x7e\xf0\xcf\x37\x80\xf9\xc6\x87\xa1\xa2\x75\x47\xf6\xed\x0b\xf6\x6a\x5f\x6e\x7f\xcb\xbb\x36\xc7\x44\xe1\xad\xb0\x87\xb0\x72\x25\xa9\xb6\xc1\xce\x09\xdf\x61\xb4\xb7\x73\xb9\xa8\xd6\x70\x02\x5e\x9f\xac\x22\x13\xd9\x54\x92\x61\xc1\x70\xa7\x94\x0b\x53\xba\x52\x21\x36\x4b\x12\x53\x49\xde\x75\x9c\x77\xa2\xcd\x72\xef\xdf\x67\x54\xc9\xb3\xac\xe4\x0f\xa2\x95\x8a\x3d\x14\xd8\xde\xb4\xdc\x77\xba\x2f\xdd\x67\x6d\x48\x3a\x9a\x1d\xdd\x43\x37\xfd\xf5\xcd\x03\x47\xbd\xcf\xed\x7f\xa0\x4d\xda\xbf\xf8\xa1\x86\x37\xef\xce\xfe\xea\x49\x1b\xb3\xc8\x33\xe4\xe9\x4a\x3f\xa8\xfe\x49\x7d\x10\x64\xf0\xc1\x79\x47\xad\xa0\xc1\x61\x1e\x0c\xdd\xfe\x15\x30\x59\x30\xc3\x0e\x3b\x18\xb5\x41\x66\x7c\x7a\x2c\x0c\x2b\x9e\x15\x4b\x41\x60\x28\xf7\x58\x82\xcb\xa2\xe2\x49\x32\xf7\xa4\xf6\xc4\xcf\x86\x59\xd7\xeb\x04\x6d\x31\xdb\xa5\xf7\xc6\xf6\x2e\x76\x98\x75\xc1\x7a\x87\x57\xd2\xd6\x17\x77\x4f\x00\x69\x1c\xc5\x23\x3f\xd3\x9e\x78\xd2\xc5\xe2\x53\x3a\x81\xb6\x38\x73\x92\x69\xd2\xa2\xc3\xa9\x03\xba\x55\xf9\xf0\x59\x94\xa0\xe7\x36\x2e\x1a\x4b\x68\x25\x76\x10\x9e\x62\x5d\xae\x71\xb1\xdf\xd1\x22\xfa\xb4\xbb\x18\x66\x54\x10\xe6\x70\x67\x74\x78\x55\xec\x5b\xc6\x83\x6b\x05\x56\x4b\x6d\xd8\x30\x7e\x87\x0a\x31\x28\x43\xdf\x18\x1d\x7e\xdc\xf5\xc6\x93\xbe\x2e\x5a\xbc\x18\x17\x6b\xca\x51\x08\x29\x06\xe3\x5f\x7f\x61\xf5\x2d\x53\x30\x82\x13\x50\xa0\x35\xce\x36\x41\x26\x95\x94\xc2\x86\x06\x63\xb8\xa2\x02\xa3\x8a\x02\x23\x65\xd3\x0a\x84\x69\x26\x42\x3b\x00\x58\xa8\x04\x22\x95\x24\xa2\x7c\x2a\x29\x4a\x10\x20\x53\x54\x58\xc6\xa7\x9f\x79\x73\xae\xdd\xce\x33\x8d\x53\xa7\x36\x32\xbc\xbd\x3d\x77\xf3\x99\xe4\xbc\x8a\x6d\xce\x79\x9b\xaa\xab\x37\xcd\x73\x6e\xab\xa0\x33\x99\x19\xdd\xdd\x07\x67\x11\x9f\xbf\xf1\x71\xc3\x6a\x9f\x5f\xdb\xe7\x9d\x57\x3d\xb4\xa8\xf4\xa6\x9b\x4a\x17\x0d\x25\xe6\x7a\x21\x44\xb2\x35\xc9\x9e\x18\x3c\x3f\x6a\x3e\x0b\x86\xdb\xdb\x6b\xc2\x9e\x12\xcc\x79\x38\x5c\xe2\x09\xd7\xb4\xb7\x33\x22\xe1\x48\x55\xc5\xaa\x52\x0e\x42\x64\x46\x63\xab\x63\x81\xda\x2b\x6b\xb5\xdf\xcb\x15\xb5\x1e\x8f\xb6\xcf\x2b\xc3\x2b\xb0\x0f\x5e\x91\xbd\xda\x3e\xd2\x1e\x2e\x71\xf7\xb7\x17\xbf\x8f\x1c\x8d\xd0\x80\xe1\x9f\xac\x7f\xac\xba\x85\x58\x58\x45\xaa\x01\xea\x48\x72\x8c\xa0\xa1\x0d\x88\x23\x49\xa5\xe8\xc6\x1a\x84\xf8\x91\x64\x11\xde\x8e\x76\x00\xaf\x66\x21\x4e\x50\xd4\xc7\xad\x27\x2d\xba\xaf\x9e\x99\xd9\x54\x33\xd5\xa1\x6a\x2f\xa8\xa6\x99\xcd\x35\x7d\x0e\xf5\xba\x52\x77\xcb\x0c\xb5\xea\xc6\xe5\x37\x7a\xc5\xe6\x01\xb5\xea\xa6\x4c\xe1\x44\x16\xb2\x59\xd3\x2c\xfd\xe2\xcc\x6d\x6e\xb1\x79\x56\x73\xd5\x4d\xcb\x77\x7b\x46\x47\x21\xbb\x5c\x7b\x01\x7f\x31\xa3\xe5\x3b\xe1\xa6\xbb\xdc\xde\xa6\xd9\xd9\xea\x3b\x56\xec\xf6\x48\x7a\xe2\xf6\x8c\xb9\xbf\xa5\xa6\xcf\x91\x81\x86\xac\x69\x86\xfe\x94\xcc\x2d\x1e\xa9\x79\x56\xb6\x7a\x78\xf9\xb0\x7e\x89\x5a\x75\xab\x4a\x4f\x6f\xaa\xee\x71\x64\xb5\x5f\xd4\x9b\xb4\x03\xcb\xa1\x69\xe5\xb1\x73\x35\xe5\x86\x27\xd5\x31\x3e\x22\xc0\x15\x89\xec\x1b\xa0\x48\x65\xaf\x14\x5b\xec\x58\x03\x2e\xe2\x65\xd0\xc9\x56\x4a\x8d\xb7\xc2\x78\x27\x12\x62\x5f\x30\x1c\x79\x36\x73\x72\x67\xe7\xc9\x35\x4f\xd5\xd8\x2a\x2c\xf5\x65\x44\x7b\x59\xbd\x5a\x3e\x3a\x52\x56\xdf\x12\xaf\x79\x58\x21\xfc\xac\x9f\xf7\xb8\x05\xb7\x87\xf7\xb3\x7e\x02\xac\xd1\xb6\xa3\x7d\x4d\x0e\xee\x83\x87\xa2\x82\xb8\x35\x36\x61\x42\x68\x63\xc8\x24\x9b\xb4\xbe\xb2\xfa\x7a\x7c\x5a\x79\x63\x7d\x59\x7c\x7a\x49\x68\xad\x17\xf3\x66\xce\x6c\xa1\x28\x8b\x99\x33\xf3\xf8\x47\xd2\x74\x34\xb6\x96\x68\xc4\x1e\x50\xa8\x0d\x4d\x42\x33\xd0\x77\xd0\x1a\x84\xf8\xb4\x0a\x32\x36\x10\x32\x09\x63\xe9\x47\x76\x14\xe6\x34\x74\xdb\x89\x3f\x7c\x28\x22\x47\xb3\xb1\x54\x92\x94\x0a\x21\x9e\xb4\x24\x52\xbc\x28\x19\x63\xa0\xe8\x16\x30\xc3\x67\x33\x69\x14\x22\x45\x97\x13\xd3\x64\x28\x26\x63\xa7\x2b\x8b\x42\xb1\xac\xcb\x89\xe5\x58\x88\xa4\xb1\xd3\x25\x9e\xd7\x05\xab\x7e\xf1\x11\x65\xa2\x1c\x26\x1f\xd9\xa7\xbd\x9f\xa8\xe0\x59\x9e\x7f\x71\xca\x79\x36\x8e\x26\x1c\xb6\xfe\x0d\x3f\xd4\xfe\x51\x3c\xc6\x84\x2c\xcb\xe1\xa4\xe7\xae\x00\xeb\x72\x8b\xda\x4b\x92\x36\xda\xc5\x88\x44\x9b\x46\x7f\x08\xe4\xd6\x6d\xab\x97\x13\x9b\x17\xbf\xf2\xe3\x7f\x36\x8d\xde\x06\xa7\x43\xdf\x27\x3b\x77\x7e\xa2\x3d\xa4\x5d\xa9\x3d\xa4\xa7\x60\x16\xcc\x87\x96\x77\x2e\xbc\xf0\x1d\xed\x19\xed\x4e\xed\x19\x3d\x85\x73\xb7\x5f\x3d\xca\x2f\x86\xb3\xc0\xc4\x2b\xcd\xfe\xf9\xf6\x43\x88\x68\x24\x28\x1c\x2e\x05\x0b\x98\xc1\xe6\xe2\x59\x30\x69\x8f\x69\x26\xa2\x7d\xec\xe8\xf0\xe3\x2b\x86\x66\xa8\x36\x0f\xef\x73\x04\x6c\x31\x6a\xe5\xab\xf9\x8d\x34\x55\x15\x22\x07\x7e\xf4\xcc\x6f\xb4\x5b\x96\xe0\x3b\xef\x5e\x59\x81\xd3\x47\xfd\x70\x9f\x51\x98\x2f\x1f\xbd\xf0\x1d\x68\x39\xa6\x0c\x87\xb9\xa0\xf4\xfa\x77\x21\x9f\xae\x41\x50\x72\x4c\xff\x46\x62\xaa\x9b\x26\xdd\x02\x29\x71\xc0\xc7\x55\x59\xc9\x90\x12\xd9\xaa\x7d\xb2\x5f\xfb\xc1\xef\x7f\x05\x8b\xde\x78\x43\x7b\x0f\x32\xef\x13\x7b\xe2\xf9\x7f\x5d\xb1\xfe\x56\x70\xff\x9a\x46\x07\x50\x4e\xd8\x9d\xdf\xf5\x83\xcf\x77\x7b\xef\x93\xf7\x5d\x7a\xed\xbb\x01\xaa\x5f\x6b\xd3\x36\xad\x3d\x69\x62\xe9\x7d\xe1\x2d\x63\x3e\xe6\x06\xef\x94\x0d\xc9\xa8\x16\x21\x33\xb8\xa3\xc5\x26\x1c\xcd\x40\x98\x4b\x71\xe3\xfe\x8e\x60\xc7\x51\x63\xc9\x14\x31\x42\x8c\xe4\xca\xfd\x07\x2c\xfe\xf2\x1c\x20\x40\xb9\xb1\x7f\x4d\xfe\xf2\x2f\x73\xe5\xfe\x26\xba\xc9\x5f\xfe\x45\xae\xdc\x4f\x23\x2d\x57\x40\x00\x39\x84\xf2\x88\x18\xf7\x57\x80\x27\x1d\x91\xbd\xfa\xf9\xa2\xfc\xe6\x42\xec\xba\xae\x2f\xf0\xa2\xd1\x50\x54\x9e\x12\x93\x6a\x91\x6f\x2b\xce\x02\x23\xba\x05\x86\x2f\xfa\x78\xca\x2a\xaf\x77\xb6\x59\x35\x3e\xc6\xeb\x45\x7f\xe4\x22\xef\xd3\x7e\xaf\xed\xd6\x7e\x7f\x1f\xe9\xc2\xad\x62\x5a\x24\xfb\xc5\x83\xc3\xa4\x8d\xcc\x9f\x55\x59\x4f\xb7\x35\x36\x62\x8b\xd9\x31\xe2\x30\x5b\x70\x63\x63\x87\x75\x8e\xf6\xa0\x28\x92\x43\xa4\x8d\x24\x87\xf0\x13\xda\x2f\x26\x9c\x33\x61\xc2\x39\x13\xa0\xf9\x61\x86\xc1\xce\x84\x49\x1b\x06\x78\x29\x72\xc3\x69\xb1\x9e\x09\xb2\x36\x9d\xb5\x5a\xad\x56\x16\x7e\x22\x4f\xe8\x91\x5f\xde\xbc\xcc\x94\x30\xc1\x10\x80\x36\x8c\x00\x9d\x71\x28\x47\x5d\x51\xf0\x69\x01\x5e\x8e\x46\x18\x5e\x46\x58\x11\x53\x49\x35\x00\x2e\xa9\x95\x50\xf5\x64\x1d\x4b\x30\x34\xb1\xc0\xde\x5a\x59\xde\x6e\x2f\xd3\x0e\xdd\xbf\xa8\x31\x59\xd5\xd5\x76\xc9\xcf\x2b\xe2\x97\xcf\xdf\x50\x93\xcd\xd4\x37\xfa\xdb\xa3\xd3\x2c\xbb\x70\x57\xbe\xc5\x6a\xc5\xcf\x4c\x80\x67\xa1\xec\xfb\x0e\xc7\xaa\x0f\xb5\x5f\x4c\x68\x79\xef\x8a\x17\xe7\xb0\xac\x72\x4a\xe3\x77\xb9\x2f\x8a\x9c\x38\xd4\x5f\x8c\x31\x14\x41\x58\xff\xca\x0a\xf3\x5d\x4e\x57\x36\x96\x0a\x49\x8c\x1c\x8d\x18\x4a\x5e\x2a\xd9\x4a\xa8\x61\x02\xe1\xd7\x6c\x8f\x68\x3f\xfe\xe3\x4d\xda\xfe\x97\x36\x6e\x7c\x09\xfc\x37\x41\xd5\xeb\xbf\xd9\xfc\xe8\xb6\x3f\xe5\x72\x7f\xda\x36\x67\xd7\xe0\xc4\x30\xad\xf5\xe1\x8f\xba\x5a\xde\xd0\xee\x1d\xd1\x2f\x80\x46\xf0\xbf\xb4\xf1\x57\xbf\x5a\xbf\xfd\x6d\xed\x8b\xb7\xb7\xd7\x4e\x5e\x38\x10\x2f\xf8\x95\x15\xfa\x09\x27\x2a\x41\x11\x34\xcd\x58\x8d\x10\x19\x3a\xa4\xc8\x86\x13\x7d\x2a\xa9\x66\x93\xb1\x22\x60\x73\x92\x2a\x6a\x9c\xa2\x9a\x96\x23\x8c\xac\xf0\x92\x20\x26\xb3\x06\xb6\xa9\x22\x33\x04\xcd\x14\x03\x3d\x24\xda\x2d\x90\xa9\x64\x2c\x93\x56\x5a\x21\x36\xae\x97\x88\x85\x48\x91\x9c\xe4\x74\xb6\x6a\x1f\xb5\x3a\x9d\xb4\x8b\xae\xdd\xb8\xa1\x8e\x76\x69\xaf\xa6\x7b\x33\x99\x5e\xf8\x59\xa6\x37\x9d\xee\xcd\x1c\x9c\x78\x6a\x6c\xfb\xc3\x6d\xcf\xeb\x07\xe3\x59\xef\x5b\x3c\x3d\xe1\xa1\x6d\xd1\x74\x72\x62\x3c\x48\x83\xe7\xd9\xe7\xc0\xc3\x04\x62\xb0\xe4\x04\xdf\x23\xac\x71\x3a\x5a\x5b\x1d\x4e\x9a\xae\xab\xa3\x7f\xd7\x9b\x4e\xc7\xe5\xf4\xfc\xb8\xfe\xcc\xf4\x40\xdd\xc4\xd8\x7c\x1a\x7c\xd5\xf1\x74\xa6\x37\x93\xac\xa3\xdc\xda\xf3\xcc\xfc\xf8\xc4\xba\x68\xa3\xc3\x57\xba\xf3\x85\x17\x76\x86\x4a\x1c\x0d\x8f\x1f\xf3\xc0\x9d\x3b\x3f\x39\x1a\x07\xcb\x61\xb0\x39\xe9\xfd\xa9\x51\x4f\x91\x62\x3d\xe9\xd5\x14\x1f\xab\x26\x91\x3a\x9c\x52\x8d\xca\x91\x15\x55\xd2\xdf\xdd\x57\x54\x55\x21\xda\x5e\x39\xde\x6f\x89\xb8\xd7\x6e\xcf\x7c\x90\xb1\xdb\x29\x27\x55\xf1\x52\x05\xe5\xd4\xb4\x44\x6b\xa2\xba\xbd\x1a\x06\x0a\xfb\xd7\x9b\x2b\x2b\x82\x6b\xae\xcf\xde\x0b\xd5\xc1\x50\x75\x75\xa8\xd6\xfd\x24\x47\x36\x5f\xbf\x2a\x50\x55\xd9\x1c\xf2\x52\x9f\xdc\x7d\xcf\x27\x74\x49\x10\x52\x47\xe1\x4f\x5c\x63\xb7\x67\x32\x76\x3b\x4d\x57\x54\xd0\x57\x07\x13\x09\xe3\xce\xe2\x7e\x52\x45\x73\x70\x1a\xf9\x2f\x25\x54\x55\xdd\x5e\x5d\x59\x41\xb9\xb4\x7f\xd3\x53\x43\xcd\x15\x81\xa4\xbd\x44\xda\xb4\x67\xcf\xa6\x12\x8f\xbd\x0e\xf6\x9f\xd8\x2e\x09\xa0\x5a\x03\x91\x59\x2d\x82\x8f\x1d\x76\x4b\x31\x04\x2c\xb8\x9c\x94\x02\x95\x29\x3a\xaa\xb4\x00\xa3\xb8\xf5\x06\x74\x94\x9b\xe4\xc9\xf3\xcf\x1a\x3e\xcb\x2f\xfb\xae\x59\x37\x30\x63\x9d\x4f\xe0\x7d\x70\xd1\xd5\xfa\x6e\x7e\xf3\x59\xb7\xad\x83\x19\xc7\xda\x2f\x7b\x7d\xad\xd3\x57\xaf\x9a\xae\xbd\x23\xf8\x7c\xc2\x86\x4d\x03\x6b\xd7\xf4\x83\x87\xf7\xfb\xf9\xec\xdb\x9b\xb6\x0a\x3e\x3f\xbf\xd9\xeb\xdf\xdc\xbf\x76\x2d\xec\x39\xd6\xaa\xd1\xfb\xa8\xdb\x99\x1c\xb5\xc8\x28\xb7\x81\x8b\x54\x28\x74\x21\xc4\xfe\x30\x79\xbd\x51\x68\x86\x0a\x8f\x9d\x91\xd4\xc2\x29\x52\x6e\x9e\xd9\x3c\xfa\x93\x07\x0e\xc2\xe4\xe6\x99\xcd\xf9\x1f\xdf\x3f\xfa\x0c\x5c\x0a\x93\x0f\x3e\xf0\x93\xd1\x1d\xcf\x34\xcf\x6c\x26\xea\xcf\xa9\x68\x6e\xae\xc8\xdf\xf8\xe3\x2f\x0e\x3e\x00\x16\xed\x40\x65\x53\x53\x25\x3e\xfd\xde\xcf\xfe\x7d\xdf\x85\x8d\xb7\x6a\xff\x7d\xe0\xe0\x97\xf7\x83\xad\xa5\x51\xfb\xac\xa2\xa9\xa9\x62\xbc\xbd\x62\x47\xa5\x08\xc5\xb9\x30\x17\x2e\xd0\xa3\x9e\x40\x3f\xa6\x46\xf2\xed\x5a\x68\xd1\x0e\x3c\x02\xfb\x16\xed\x68\x1f\xff\x7e\x87\x61\x1f\x1e\xd9\xb1\x48\x0b\xe5\xdb\x77\x90\xa5\x47\x3b\xec\x99\x10\x42\x5e\x13\x22\xdf\x45\x14\x32\x23\xbb\xc1\x4d\x56\x8a\xe2\x06\x6e\x8e\x3e\x3c\x84\x4b\x20\xca\x01\x97\xe2\x08\x77\x2a\xc3\x87\xb9\x70\x26\x9c\x09\xc7\xb9\x28\x07\xe3\xd3\x93\x7f\x9d\xff\x00\x26\x6f\x86\xeb\x5e\x7c\xf1\xc5\x01\xec\xce\xff\x13\x26\x6b\x8f\xe9\x07\xae\xc7\x42\xfe\x03\x98\xa4\xed\x85\x49\x9b\xc9\x77\x47\xcb\xf1\xde\xfc\x3f\x61\x8d\x76\x29\x76\xe7\x27\xe1\xbd\x10\xf8\xf5\xaf\xb5\xbf\x8e\x0e\xdc\x3e\xb0\xbb\x70\xf0\x70\x72\xdc\xf7\x65\x36\xb0\x51\x6b\x51\x7b\x81\x7f\xa7\x10\xf3\x31\x2e\xe5\x2c\x02\x79\x33\x9c\x9a\x11\x53\x49\x6c\xe4\xa3\x85\xcc\x71\x86\xb8\xd8\x97\xa9\xf4\xf9\x2b\x32\xda\x7f\x8a\x09\xbc\xf5\xfe\x73\x05\x5e\x52\xe7\x6c\x79\x35\xd5\x79\xee\x5d\x3f\x39\xb7\xb7\xeb\xa7\xaf\xaa\x2d\xe7\x12\xd2\x51\x4e\x94\xdd\xb9\xf9\x0e\x70\x73\x30\x23\xb7\x40\xdf\xe7\xeb\xc0\xf6\x14\x31\xad\x71\x31\x9d\x3f\xbf\xfc\x25\x1e\x2f\x07\xdb\x53\xb1\xd1\xc7\xca\x5f\xe2\xe1\x8b\xa3\xeb\xd7\x82\xca\x0f\x99\x99\x17\x69\x84\xb6\xa3\x27\xd0\x0b\xe8\x25\xf4\x26\xfa\x1b\xfa\x3b\x7a\x0f\x7d\x88\x3e\xd6\x6d\xd0\x00\x21\x05\xb0\xc4\x62\x26\x41\x45\x1d\x20\x4a\x01\x26\x08\x22\x8b\x19\xb9\x10\x40\x92\x56\x5b\xb1\x22\x1b\x26\xaa\xe1\x79\x43\x16\x94\x6d\x7d\x48\x6c\x25\x0a\x16\xb5\x34\xa6\x61\x63\xba\x88\xd2\x81\x33\x69\x55\xd1\x3b\x10\x23\x46\x4e\x52\x59\x42\x52\x13\x8c\x92\xc0\x15\x10\x8d\x30\xad\x94\x1a\xc0\x6d\xe0\x96\xb2\x6a\xab\xa9\xad\xe0\xb3\xc4\x62\x26\x00\x6e\x81\xd0\x1f\x18\x20\x0a\x9a\x9d\x2a\x31\x50\x00\xa6\x56\x5a\x71\x0a\x18\x45\x3f\xc9\xa7\x24\x06\x32\x6e\x07\xb4\x61\xf2\xb9\x29\x17\x9d\xb2\xb4\xa3\x32\xbc\xa0\x79\x42\xed\xc6\x1b\x63\x55\xcd\x3e\x25\x71\x4a\x8f\x85\x26\xcd\x74\x15\x13\xa4\x5c\x04\x0d\x00\x8c\x89\x23\xa2\xe7\x87\x94\x30\x26\x70\x93\x0a\x1e\x3e\x76\x4d\x4b\xc9\x69\xab\xfd\xb4\x5b\x0b\x04\x9d\x1e\x8e\x85\x77\x4d\x56\x37\xef\xa3\x48\x89\x76\x78\x99\xdb\xcd\x5c\x09\xe7\x78\x04\xe0\x0e\xb1\xe6\xb2\x1a\xb5\xc6\xd2\x5d\x49\x0d\xb4\x56\xa9\x15\x82\xdb\xe2\xb1\x25\x89\xb2\xea\x28\xb4\x50\x1c\xc3\xd2\x16\xc6\x4c\x32\x0e\xaf\xab\x86\xdd\xba\xc0\x59\xd6\xdd\x56\x3a\xc9\x64\x0b\x85\x44\x9b\xf8\xf9\x16\x7f\x55\x79\x49\x84\x8d\x5a\x2b\x4d\x0c\x2e\x9f\x3e\xfa\x10\x5b\x5f\xc5\x11\x95\x9f\x2b\x7b\xb3\x66\x5f\xa9\x54\x82\x37\x6e\x6e\x69\xd7\xbe\xac\x3d\xa3\x07\x6e\x25\xa2\x0d\xa9\x7a\x92\x71\x4f\xef\xf0\x6b\x13\x86\x68\x4b\xb5\x8d\x7f\x35\x68\x29\x27\x36\x02\xd6\xff\x5f\x4c\xd4\x4c\x5c\xff\x9d\xc9\xf5\x2b\xd4\x96\x80\xda\xe6\x8c\xdf\xb8\xe7\x89\xab\xbe\x83\x49\xca\x4c\xc5\x99\x52\x5b\xa0\x24\x2e\x86\xbd\x6d\xe5\x7d\x0e\x70\x5b\x9c\xc1\x5e\xd1\xde\xd0\xe2\xc6\xde\xcc\xa2\xad\xd7\x09\xa4\x77\xb5\xe8\x74\x48\xc4\x0a\x56\xb4\x5b\x48\x0a\x83\x3d\xc4\xc5\x45\xce\x21\x12\x65\x4e\xef\xa3\xc3\x75\xb1\x08\x21\x78\x9c\x2e\xbe\xaa\xc7\x1b\x72\x12\xac\x3d\x16\x6c\xf7\x97\x94\x95\x61\xab\xe3\xf7\x94\xdb\xe4\xa0\x2d\x14\x85\x09\x12\x2a\x03\x61\x6f\xc2\x77\x92\xd9\x5c\xed\x07\xe8\x83\xc5\x8b\xdd\x31\x45\xaa\xe6\x1a\xf8\x3e\x87\x39\x33\xfb\x8e\xe7\x2a\x09\xb3\xc5\xcc\x67\x19\xeb\xe8\x4c\x6f\x65\x30\x9b\xa8\xa7\xaa\xad\x44\xcc\xf6\x93\x5a\xed\x15\x07\x30\x0e\xab\x89\x81\x4a\x6c\x67\xf0\x59\x02\x07\xb6\xfc\x96\x93\x6c\x74\x1d\x80\xf1\xe4\x82\x8d\xeb\xa2\x11\xf5\x11\x92\x50\x16\x2d\x42\x3b\x10\xa2\xe4\xe2\x6c\x48\x34\x52\x70\x1f\x37\xa2\x2d\x0d\xb7\xe6\xc2\x57\x66\xb8\xd4\x31\xa9\xa4\xe1\xb0\xa6\x66\x21\x9d\xc0\xba\x22\x12\xa5\x13\x84\x61\x16\x19\xa3\x5a\x6b\xc1\xf7\xd9\xf0\xf8\x12\x8a\x63\x7d\x26\xdd\x4a\xa9\x46\x93\x55\x8b\xf6\x11\x79\x29\xc5\x07\xd6\xf6\x6e\x6b\xa7\x4c\x56\x07\x03\xa6\xc8\xca\x93\x93\xe5\x73\x2a\x19\x5b\x15\x2f\x48\x99\x1a\x4f\x69\x9d\x97\x35\x73\x12\xe1\xa0\x59\xb3\x93\xe5\xad\xbe\xa8\xd5\x64\xa1\x2c\x12\xcc\xb7\x48\xd5\x81\x70\x6e\x7b\xcc\xd7\x33\x7d\xee\x6a\x75\xdd\x6e\x8c\xfb\x4a\xbb\x26\x36\x5c\x7d\xce\xa6\x90\x77\x5a\xc7\x24\x21\x5a\x13\xf2\x97\x66\xb6\xbc\xa2\xfd\x53\x7b\x45\x7b\xf7\xb5\x9c\xd2\x34\x30\x65\xa0\x86\x67\x7b\xa3\x2d\x81\x58\x95\x69\x5b\x43\xd5\x7d\x95\xee\xd8\xac\xae\x93\x54\x25\xc9\xb3\x62\xa4\x8e\xb4\xd1\x82\x25\xe4\x27\x08\x32\xec\x63\x6c\xe7\xd7\xb0\x0e\x8b\xad\xca\x23\x98\x18\x01\xdb\x49\x0b\x49\x13\xd8\xc1\x3a\x38\x9a\xb4\x41\x8d\x58\x5d\xed\x3f\x69\x26\x94\x35\x36\x96\x01\xdc\x70\xda\xea\xb4\xc0\x75\x4c\x6d\x07\x68\xe9\x69\x05\x22\x92\x28\xdf\xf0\xd2\x6e\xed\xef\x3f\x3b\x7d\xdd\x2f\xc1\x3f\x3c\xef\xae\x2d\x6b\xa6\xb4\x97\x5a\x4c\x71\xa1\xcc\xe3\x9f\x37\xe3\x06\xb9\x74\x9a\xcf\xee\x99\x30\xf9\x9c\xad\xf7\xa2\xf1\xd8\x5b\x01\xd4\x8c\xe6\xa3\x0d\x08\x81\x03\xb3\xa0\x8c\xc5\xf3\xaa\x72\xb6\x0d\x24\x86\x16\x24\x31\xd9\x46\x10\x12\xa3\xc8\x11\x5a\x08\x12\x4c\x0d\x4e\x80\x9a\x28\xe0\x08\x89\x52\x56\x2c\x04\x91\x2a\xb4\x5c\x03\xaa\xa4\x2b\x60\x35\x84\x1a\xc4\x01\x60\x02\x40\x08\x34\x23\x1a\x91\xc3\xd9\xb4\x1c\x71\x10\x4a\x1b\x6e\x05\xc9\xe8\x38\xc8\xc4\xf0\x35\x81\x8e\x3d\xb3\x9c\xab\x7b\x66\x6d\x98\x37\x41\x4c\x74\xd8\xae\xb1\xc6\xe3\xf1\x65\xf1\xc0\x35\xb7\x3e\x65\xbb\xd6\x16\x5f\xd6\x1b\x2f\xbd\x76\xf8\x9a\x5b\xaf\x09\x74\x57\xf9\x26\xce\xdf\x30\xab\x6f\x9d\x6d\xe6\xbd\xc4\xd2\x0d\xb3\x7a\xd7\xb2\xb3\x1f\xef\xb6\x5e\x63\x5c\x13\xb8\x76\xf8\xda\xe1\x6b\x4b\xdb\x6b\xdc\x7d\xa7\xe1\x25\x7d\xde\x44\x97\xed\x1a\x5b\xbc\x77\x99\x71\xe2\xd6\x6b\x4b\xbb\x1e\x9b\x6d\x5d\x37\x6d\xd6\x06\x78\x79\xf8\xda\x40\x7b\xc2\x3d\x71\xfe\xc6\x59\x93\x57\x3b\x67\xff\xa8\xc3\x76\xad\x35\xbe\x4c\x8e\xeb\x17\x62\x97\xfe\x8b\xbd\xcb\xf5\x5f\xbc\x76\xf8\xda\x40\xd7\xde\x39\x8e\xd5\x3d\xb3\x36\x9e\xdc\x2b\xd4\x1c\xbc\x6a\xd6\xc6\xc1\x49\xfe\xaa\x6e\xe3\x92\x65\xc5\x1f\x0c\xb4\xef\x99\x65\x5d\x47\x4a\x53\xcf\xb2\xce\x7a\xb4\xab\x58\xde\xe2\xa9\xae\x6a\xef\x94\x25\x1b\x0b\xbc\x1d\x05\xcc\x8c\x09\x68\x2e\x5a\x80\x16\xa3\xa5\x68\x05\xba\x08\xdd\x8e\x10\xe8\xd5\x65\xb8\x7e\x16\x9c\x39\x95\xa2\x87\xa2\x2a\xeb\xdd\x21\x2d\x14\x1c\x39\x15\x59\x31\x82\x8e\xb3\x29\xfd\x24\x96\x44\x46\x30\x7c\x3c\x0b\x2e\x9b\x84\xe1\xa0\x19\xd5\xaf\x52\x8d\xd5\x30\x35\x49\x49\x0a\xc4\x39\x0a\x24\x42\x21\x24\x55\x02\x8a\x03\x89\xd1\x7f\xc2\x40\x84\x29\xcc\x8b\x18\xf7\xa6\x92\xc6\xc7\x05\x9c\xb1\x94\xad\xa4\x15\xce\xf0\x6e\x51\x39\x2a\x59\x05\xa9\xa4\x9b\xc3\x3b\x41\x12\x84\xaa\x4a\xa6\x9b\xec\xea\x9a\xe1\x21\x83\x04\xdd\xe7\xde\xc6\x72\xdd\xd8\xb4\xc4\xa4\x04\x30\x06\xca\x2b\x79\x5c\x16\x12\xe8\xb8\xb5\xb1\xe6\x54\x6c\xe9\xb4\x9a\x4b\x48\x12\x13\x25\x7e\xa2\x24\xdd\x6e\x3b\x97\x22\xed\x2f\x13\x8c\x4d\x0e\x04\xbc\x12\x4b\x02\x11\x16\x6a\x63\x3c\x87\x9f\x6a\xfb\xfe\xc1\x2f\xf0\x23\xf9\x5e\xf2\x8d\x25\x0f\x9f\xfa\x87\x25\xd5\xaf\x6a\x09\xdc\xa2\x1d\xb8\x39\x5b\xb6\x7d\x57\x63\x78\xe6\xf4\x4f\xdb\x4c\x16\x13\xe9\x0f\x93\x3d\x7b\x26\x2d\xbe\x6c\x96\x23\x18\xb7\xc0\x55\xa3\x07\xd8\x7c\x82\xb1\x53\x40\x00\xe5\x58\x59\x81\x13\x18\x5a\xa0\x89\x14\xe0\x05\x82\x31\x99\x85\x52\x2a\x83\x97\x4e\x5b\xec\xc0\x24\x26\xe7\x7a\x1e\xf1\x05\x2e\x32\x43\x04\x5b\x4d\x80\x39\xb0\x50\x0c\x43\x72\x34\x87\x69\xc2\xe9\x8c\xe2\x28\x49\x58\x00\x6c\x6e\x9c\x6c\xa0\x92\x33\xfc\x74\x1a\x43\x1d\xec\x73\xd8\x25\x87\x8d\x90\x1c\x5e\x82\x20\x49\xd6\x86\x77\xfd\xad\x22\x7f\xdd\x3f\x48\xd3\x7b\xf9\x6c\x10\x5f\x1e\xcc\xff\x23\x78\x66\x07\xd1\xf4\x18\x6c\x39\xc0\xd9\x87\x3b\x4f\x2a\xb1\x4d\x4b\x30\x66\x93\xd5\xe1\xc2\xf1\xba\xd2\x18\xc3\xb9\x69\x32\x77\xf0\x57\xff\xa5\xff\x65\x07\x4c\x66\xcd\x40\x53\x31\x16\x72\xcf\x9d\xb9\xd2\xad\x0d\x1a\xf1\xc6\x63\xd8\x0b\x0a\x52\xd1\x24\x34\x07\x2d\x45\xeb\xd1\xf7\xd0\x35\xe8\x2e\xf4\x28\x1a\x39\x3c\xd3\x73\x98\x1c\x96\x3a\x1a\xb2\x5c\xd7\x1f\x82\x10\x00\xf7\x11\x1a\xbd\x02\x1e\x3b\xf7\x0d\xf9\xff\xaf\xaf\xe7\x0b\xc0\x62\x61\x0e\x42\x9d\x83\x83\x9d\x39\x7d\x43\xed\x6b\x9c\x78\xf5\x8a\xd1\xe1\xce\xc1\xfa\x32\x3c\x5c\x36\xe4\xbf\xd6\x5f\x96\x0f\x19\x40\x47\x5f\xb9\x01\xf4\xff\x76\x7e\x68\xb8\xac\x3e\x9f\x23\x73\x83\x9d\x47\xd8\x95\x6f\x8f\x9c\x33\x21\x8f\x56\x5c\x3d\xd8\x49\xa3\xb2\xfa\x32\xff\xb5\xfe\xa1\xb2\x83\xb9\xc3\xb7\x01\x7b\xa2\xa4\x76\xc2\xa3\xff\xcb\x05\xb0\x13\x50\x7d\xd9\xb0\x86\x90\x50\xf0\xa1\xa7\x51\x71\xed\xa6\x0d\x4d\x47\x8b\xd1\x2a\x74\x9e\xc1\x20\xf8\x63\xf4\x33\xf4\x32\x7a\x1b\x7d\x8c\x0e\x81\x03\x82\x50\x03\x6d\x27\x98\xf1\x3b\x4c\x92\x58\xa8\x77\xee\x7f\xcc\x13\xff\xe3\xfb\xfc\x36\xed\xe3\x58\x20\x9f\xff\xd7\xe7\xfd\xff\xb3\x7c\x94\xe1\xac\x72\xb0\xe0\xa5\x32\x72\x84\x76\xe0\xeb\x37\xb9\x6f\x7b\xe1\x91\x0d\x46\xe3\x98\x89\xbe\xf5\x5d\x80\xfe\xf7\x5f\xa2\x91\xec\xfd\xd2\x98\xe7\xa2\x73\x5e\x59\x1b\x07\x39\xfb\xd9\x37\x25\x1f\xf8\x06\x08\xa4\x13\x27\x0f\xb2\x87\x81\x53\xf0\xff\x70\xdb\xe8\xff\x70\xed\x51\x30\x4c\x08\xa3\xf6\x43\x4e\x72\x84\x1a\x42\x41\xa4\x20\x64\x3e\xd6\xc9\x0e\xe4\xb4\x3a\xe6\x2c\x24\x89\xc2\x58\x94\x29\xb9\x5b\x7b\xb3\xe8\x5b\xa7\xbd\xe9\xf7\x97\x4e\xf7\xef\x87\xd5\xfb\xfd\xfd\x7e\xbf\x36\x5c\x70\xb0\x7b\x53\x7b\x73\xf4\x79\xc3\xb5\x2e\xa7\xe5\x0c\xd7\xba\x7a\x88\xe9\x17\xf8\xf7\xef\xd7\x6f\x78\xa7\xe0\x5b\x47\x15\xb9\x97\x73\xc8\x81\x4a\x8d\x55\xa3\x19\x08\x81\x50\xb0\x7b\x32\x69\xc3\x2e\x81\x02\x57\x0c\x14\x87\x50\x2a\x49\xba\xdc\x82\xc1\x17\x13\x8d\xd0\xd1\x48\x26\xdd\x8a\xe3\xe3\xae\x76\x0b\x2c\xc4\x0d\x6e\x98\x82\x3a\xd5\x0a\x84\x4d\x9e\xdb\xd2\xb7\xa5\x59\x9e\xdb\x32\x75\x73\xb3\x76\xcf\xcc\xa9\x7d\x3b\x26\x1a\x1b\xb8\xf8\x1c\x70\x3d\x16\x69\xeb\xac\xec\xfe\xb8\xad\x33\xdf\xfb\xe8\xea\xbb\x5e\x81\xc9\x2d\x73\xe5\xe6\xcd\x53\xf5\xed\x16\x38\x75\xea\xcc\x89\x3b\xfa\xf4\x0d\x59\xd6\xbc\x72\xda\xba\x1b\x7b\xf4\xed\x0d\xf9\x57\xfb\xcf\x59\x75\x63\x6f\xff\xfa\x55\x37\xd5\x3c\xa3\xbd\xb7\x2e\xd1\x52\x6a\x9d\x3f\x6f\xd7\xec\x57\x7f\x74\xce\xab\xd3\x56\x36\xf7\xde\xb0\x6e\xda\xca\xe6\x9e\x1b\xd7\x2d\x5b\xdf\xdf\x7b\xe3\xaa\x73\xfa\x7b\x6f\x5a\x85\x00\xb5\x1f\x42\x78\x84\x46\x46\x6c\xa8\x40\x33\xbc\x58\x0c\x76\x2f\x14\x3e\x19\x00\x3c\xb2\x76\x71\x35\x8e\x79\x47\xbc\x31\x5c\xbd\x78\xed\xac\xab\xef\xb9\x7a\x16\xf1\xc9\xe5\xcf\xc6\x47\xff\xcf\xf0\x04\xcb\xc4\x9f\xbd\x3c\xf7\xaf\x9b\x6e\xfa\xd7\x11\x4c\x91\xb1\xb8\xa3\x20\x42\x14\x70\x94\x52\x0d\x76\xfd\x25\x16\x90\x54\x8b\x58\x21\xc6\x24\x6a\x00\x88\x1c\xce\xe5\x73\xed\xf8\xa7\xf9\x89\xf9\x89\xd4\x81\x58\x30\xdf\xee\xef\xf4\xe7\xdb\x83\xb1\x84\x8c\x47\xc4\x2a\x11\x8f\xc8\x89\x45\xb0\x08\x6f\x79\x6f\x8d\xa6\x69\x38\x8f\xa2\xcd\x9c\x96\x73\x3a\x21\xc7\x35\x47\x09\x54\xd6\xc9\x02\x32\x99\x0e\x21\xb6\xb3\x00\x95\x87\x0e\x21\x53\x81\xc7\xe4\x48\x54\x74\x27\x42\x54\xdc\x28\x07\x05\xc5\xbd\x32\x96\xd7\xcb\x45\xd1\x11\x25\x2e\x2b\xc5\x44\xb1\x80\x71\x63\x93\x4d\x4a\xc6\xe0\x4b\x05\x00\x1b\x24\x42\xed\x70\xa5\x76\xba\x76\x3a\xf5\xbb\x71\x99\xaa\x42\x7a\xaf\x36\x49\x9b\x44\x7d\x29\x87\xb5\xf6\x92\xf6\x12\xad\x9d\x24\x30\x55\x4c\x86\xe5\xca\x28\x3c\x50\x19\x85\x11\x29\x2b\xc1\x48\xb4\x12\x1e\x88\x55\x0c\x8d\x40\xe3\xee\xd5\x7b\xf6\xec\xc9\x5f\x32\x96\xda\x70\x07\x58\x76\xaf\x7e\xf2\xc9\x27\xf3\x2d\xda\x50\xac\xd5\xb9\x8f\x65\xf7\x61\x8c\xb1\xbe\x77\xb6\xc6\x60\x58\x6e\x77\xfe\x14\x2e\x93\xdb\x9d\x23\x16\xcb\x88\xb3\x5d\xd6\x56\xff\xd4\xd9\x5e\x58\x53\xd1\x4c\x88\xc2\x88\x40\x66\x14\x44\x32\x4a\xa0\x0e\x84\x20\xec\x0e\x13\x11\x9a\x09\xcb\x44\x32\xab\xa6\x70\x38\x82\x33\x69\x54\x68\x91\x4c\x58\x10\xe3\xe1\x64\x26\x1d\x0d\x67\xc2\xba\xad\x1e\x0d\xc7\xc3\x49\x83\xe2\xc8\x68\xb0\x44\x34\xcc\xd4\x6b\x00\x87\x46\xe7\xaf\xa6\xe1\x5a\xd7\x9d\x6d\xe7\x70\x6f\x9d\xaa\xed\xfd\x7d\x1e\xa8\x97\x2e\x7e\xf1\x34\x9c\x3f\x73\xdd\xc1\x2c\x94\xbd\xf8\x4b\xed\xb7\x50\x32\x6d\xc1\x53\xda\xa8\xf6\x4f\x3c\x30\xe7\xc2\xb3\xdb\xee\x5b\x7b\x56\xdd\x49\x6b\x73\x13\xf3\x37\x91\x7b\xb6\x68\xbf\x5d\x3e\xff\x99\xfc\xa3\xed\xaa\xf6\x22\x98\x5e\x7f\x05\xf8\x0b\xff\x7c\x11\x17\x58\xb5\x31\x79\xd7\x43\x4f\xf5\x4c\xbd\xec\x75\x7f\xd7\xd6\x05\x0f\x0f\x84\xee\xdc\x38\x65\xf3\xcc\x46\x6f\xf1\x1d\x8e\xcd\x67\x06\x50\x1c\x55\xa1\x0e\x34\xc9\xe0\xf9\x39\x66\x34\xe4\x8d\xd9\xa7\x4c\x5a\x31\x26\x1a\x88\x68\x26\x95\x74\x0b\xc5\x1d\x15\x91\x33\xe1\x6c\xe6\x08\xba\x8f\x1a\x65\x81\x48\x4a\xd1\x56\x20\xc2\xee\xf0\xf8\x95\xb0\x57\xb5\x4b\x60\xeb\xd9\xc3\x97\xae\x54\x7a\x67\x4e\xbd\xff\xf6\xf5\xdf\xd9\xfb\xe4\x16\x6c\xe9\x9e\x0c\x37\xc0\x55\xdb\x72\xbb\x6f\xfe\xee\x8b\xad\x17\x5b\x7b\xea\xd6\x58\x35\x72\xe2\x0a\x68\xd3\x7e\x7e\xf4\x2a\x98\x76\xf9\xe8\x87\xeb\xd6\xdc\x5c\x91\x5e\xdd\x30\xbd\x82\xd3\x9e\x7e\x6c\xfe\xa0\xf6\x93\x37\xd6\x2c\x0b\xf5\x4d\xb0\x08\xe7\xff\xe4\xbe\xed\xdf\xdb\xfd\xb3\x48\x19\x9c\xb9\xa9\xbe\x13\x2c\x53\xc7\x6c\x2d\x66\x0c\xe7\x5e\x41\x6d\xe3\x58\x0b\x8c\x39\x58\x69\xcc\xff\x4c\xd1\x35\x73\x18\x87\x50\xa4\x0a\x28\x0a\x46\x1f\x52\x03\x1c\x65\xb8\xcf\x64\x51\x2a\x89\xe8\xc4\xa5\x2f\x5c\x7a\xe9\x0b\xf9\x4b\x76\x2d\xf3\xf9\x96\x4d\xed\x08\x06\xaf\xed\x73\x0f\x08\xa1\x73\x26\x2d\x23\x5e\x79\x70\xeb\x79\x0f\x3e\x78\xde\xd6\x07\xaf\xd6\xfe\xf3\x84\x36\xc5\xf6\xf4\xf9\x1b\x7f\x5a\xf2\x2e\x5c\x30\x7d\xd0\x2e\x82\x1f\x83\xf5\xf1\x27\xc0\x4a\x06\xf5\xfb\x2f\x3d\xf8\xd4\x2b\xbb\xe8\x8a\xe0\x35\x7d\x53\xdb\x83\xa6\xb0\xa9\xb9\x87\x78\x7b\xeb\x83\x0f\x6e\x3d\xef\x81\x07\xce\x7b\x52\xfb\xaf\xf6\xf3\x6d\x0f\x5c\x7b\xd6\x42\xd8\x73\x53\x2d\x86\x6b\x1e\x07\x93\xf6\x1f\x74\x94\xed\x68\x42\x3e\xd4\x85\xa6\x16\x91\x00\xdc\x82\x58\x98\x1c\x93\x15\x23\x7c\x39\x2b\xd7\x40\xf6\xc8\x44\x58\xcb\x98\xe1\x11\x4f\x16\xdf\x13\x43\xe8\xd2\xc7\xc7\xe6\x97\x0b\x75\xa2\x1b\x87\x7f\x5c\x3b\xbc\x66\xcd\xb0\xe6\x3c\x6b\xa0\x7e\xb0\x24\x9d\x68\xde\x50\xe2\x49\xb5\x0c\x88\xc2\x00\x31\x5a\x78\x13\xf7\x09\x57\x2c\x5e\x76\xbd\x05\xe6\x5d\xfd\xea\xab\x57\x5f\xf9\x5b\xfc\x17\x33\x3f\xa5\x55\x7b\xbd\xf0\x82\x3e\xdf\xf9\xfc\x25\x97\x9c\x7a\xda\x25\x44\xf9\xf0\x9a\xb5\xd3\xfb\xd7\x68\xcf\xdf\xb9\xae\xb1\x56\x10\x3c\xa9\x96\xe6\x0d\x9e\x30\x85\xcf\x28\xbc\xcc\xeb\x26\x2c\xdc\xf0\x83\xa5\xa3\xaf\x5e\x75\xf5\xab\xbf\xb9\x52\x7b\x0a\xe2\xeb\xe1\x77\xeb\xef\xbe\x5b\x1b\x3e\xf5\x92\x4b\x9e\xdf\x79\x09\xa2\x91\xf3\xd0\x6c\xfa\x63\xea\x10\xb2\xa3\x00\xaa\x46\xcd\x68\x8a\x81\x9a\x44\x30\x71\x63\xf1\xb5\x15\xab\xa2\x0f\x14\x96\x70\x00\x91\x80\x36\xc8\xaa\x0a\x10\xac\x81\xac\x2b\x11\xbc\x5e\x03\x40\x13\x71\x85\x6f\x05\x29\x40\x01\x2f\xd2\x0c\x4b\x31\x32\x11\x57\x54\x22\xae\x26\x88\x1a\xa0\xb2\x62\x10\x44\xa2\xdb\x81\xb5\x85\xb1\x56\xa7\x95\x71\x98\x23\x78\x5a\xd5\x43\x57\xb4\x7d\xa7\x36\x48\x90\x4f\x71\x98\x31\x45\xa7\xff\x80\xce\x3d\x61\xab\xe3\x5d\x93\xae\x34\xbd\xfb\x2a\x73\xcf\x5f\x1b\xf2\x4a\xcd\x1f\xb5\x67\xf8\xbf\x08\xfd\x65\x9e\xba\x68\xad\xa7\x16\x5f\xf3\x3b\x97\x55\xb4\x97\xc5\x5a\xc2\x13\xad\x91\xbf\x43\xc3\x96\x9d\x6f\x6a\x8b\xae\x89\x0c\x4c\x68\xe6\x38\xb8\x2a\x98\xb5\x59\x15\x58\xa5\x5d\x26\x96\x12\x0d\x71\x5f\x7d\x6f\x6c\x21\x63\xc3\x8d\xda\x05\x0b\x27\x5f\xbe\x7c\xa6\xdb\x0d\xa7\x79\x9b\x39\x57\xdb\xb9\xb3\xf3\xef\x6b\xd7\x95\x46\x09\x92\xa1\x76\xc3\x2a\x58\xb1\xc7\x29\x8a\xc4\x03\x6d\xda\x0f\x1e\xb7\xc1\xa9\x41\x3f\x89\x05\xb1\xaa\x24\xab\x3d\xab\x5d\x15\x9f\x16\x15\x22\xa2\x68\x71\x11\x93\xe1\xf4\x67\x3e\x3c\x49\xfb\xbe\x30\x7b\xde\xf5\x8b\xba\xec\x76\x20\x7c\x0e\x47\x4b\xa1\x8d\xb4\x9b\x0a\x6d\x9e\x43\x25\xa8\xeb\x08\x5a\x04\x1f\x26\x12\x60\x90\xeb\x1f\x3e\x32\x3e\x70\x34\x3c\x16\x40\x3a\x46\x24\xc2\xb7\x82\xde\x3c\x24\x3e\x95\x14\x61\xdf\xe0\xf9\x83\x83\xe7\x6f\x27\xbe\x98\x87\x3d\xe6\x3c\x32\x7b\x30\x45\x18\x87\x34\x17\x3b\xb4\x7a\x78\xf5\x28\x5a\x3d\xbc\x7a\x88\x75\xed\x58\xe4\x5f\x2e\xdd\x76\x32\x81\x4e\xbe\x4d\x5a\xee\x5f\xb4\x03\xb6\xea\x17\x0d\xc2\x3e\x38\xcd\xc4\xf3\xa6\x7c\x49\x21\x8b\xb4\x1c\xeb\xca\xf5\xaf\x5e\xdd\x9f\x2b\x6c\x5d\x2c\xe4\x16\xed\x80\xdb\x07\xcf\x3b\x6f\x50\x5b\xb4\xa3\x10\x57\x6b\xd2\xbb\xdb\x14\x6a\x42\x13\xf4\xb6\x7e\xd8\x56\xfb\x9a\x02\x17\x70\x96\xc3\x45\x46\x2c\x89\x1f\x8b\x9b\x85\x23\xb2\x17\x8f\x30\xa1\x45\x3b\x4e\x58\xf4\x5c\x01\x15\x2f\xa7\x0b\xf0\xe5\x81\x42\x71\x4f\x1d\x27\x37\x19\x36\x8e\xe1\xdc\x8e\x45\xba\x10\xed\x7a\xf1\xdb\x0b\xdb\x23\x42\x14\x00\x68\x75\x51\xb4\x90\x51\x4d\xb0\xbd\x50\x01\xa3\x8f\x1b\x59\x04\x28\x74\x08\x51\xfb\x0c\xf9\x50\x4c\xff\x50\x03\x63\x58\x7f\x99\xb4\x81\x39\x9c\x56\x75\xc9\x0e\x6f\x0b\x7c\xc2\x74\x25\x14\xb7\xd4\x3e\xd9\xab\x25\xc1\x12\x2b\xd1\x46\x4a\x62\x16\xd0\x92\x5e\x99\x87\x5d\xef\x18\xdb\x67\xf5\x6d\x8e\x4f\xeb\x1b\xd9\xfb\x2c\xec\xe2\x65\xef\x3b\xb0\x6b\x7e\x5a\xe6\x2e\x91\x4b\xa2\xd1\x12\xf9\x12\x4e\x4e\xf3\x70\xc5\xe1\x4d\x8e\xe7\xb5\x1c\x9f\x96\xb5\x33\x8c\xcd\xb8\xbe\xc6\x8d\x2a\x51\xb7\xe1\x0b\x53\x04\x4d\x2a\xf4\xf2\xc5\x30\xec\xac\x9a\x56\xe4\xf0\xb8\xa3\x21\xe3\x28\x9f\x56\xe4\x98\x31\x9f\x78\xf8\x6a\xd2\xa0\xe7\x83\xf1\xae\x69\x4b\x03\x3f\xd7\x2e\xb8\xbe\xc2\x27\x52\xa1\xf3\x57\xfd\xf5\x5e\x9e\xe5\xfd\x43\xd1\x0f\xb5\x5f\x5d\x77\x75\x6d\xb4\x84\x09\x6c\xda\x06\xd2\x6f\x3c\x6c\x49\xf4\xf4\xb2\xad\xda\x03\xf7\xff\x7a\x58\x0a\x96\x07\xad\xa5\x17\xfc\xe8\x16\xa8\x5e\xea\xe6\x4b\x2b\x5f\x3c\x16\x7e\x7e\x62\x88\x5f\x17\x31\x57\x0a\xa5\x26\xdf\x52\xab\xef\x83\x32\xf7\x25\x15\xf6\x54\x49\xd4\x14\xde\x62\x8f\x02\x57\x23\xf5\x4c\xa9\x61\xe2\x81\x60\x85\x29\xde\xdd\x62\x2b\x5f\x70\xcc\x62\x10\x14\xb8\x6c\x69\x84\x78\x5d\x1b\x96\xc2\x5c\x98\x21\x98\x30\x07\x4a\x98\x0b\xab\xbc\x1a\x26\x91\xf6\x1b\x0f\x48\x1a\x55\xb5\x33\xa0\xbd\x0a\x35\x1e\xed\x3d\x38\x58\xb5\x33\x00\xd5\xe4\x6f\xf2\x3f\x0d\x6a\xdf\x09\x68\x1f\x07\xa0\x06\x4f\x0a\xc0\x2d\x01\xe0\x02\x08\x21\x0e\x21\xf4\x03\x33\x22\xcf\x42\x2c\x8a\x1b\x8c\xf6\xcd\x68\x32\x9a\x89\x4e\x46\xa7\xa0\x35\xe8\x3c\x74\x09\xba\x0c\xdd\x8c\xee\x43\x23\xe8\x77\x08\xc5\x55\xbd\x95\x46\x68\x37\x61\xf4\xd8\x71\x95\x48\x2b\xb2\x5e\xb7\x0c\x21\x48\x63\xe4\x01\x19\x90\x0c\x3f\x7f\x35\x9b\x54\x25\x46\xd7\x81\x15\x35\x9d\x4a\x02\x21\x31\x42\xd4\x38\x9e\x4a\x06\xe1\xc8\x89\x60\xd1\x71\x47\x51\xf5\x3e\xde\x0c\x3c\x23\x18\xcc\x48\xbc\xde\xe3\xab\xc7\xe6\x0a\x99\x42\x5c\x78\x03\x10\xfa\x69\x7d\x0c\xe4\xd3\x59\xfd\x73\x1a\xcb\xb5\x42\x52\xe4\x99\x3a\x23\x87\xf9\x4c\xb6\x18\x8c\x6f\xe0\x37\x1b\x5a\x9d\x7e\x00\x19\x8b\x14\x84\xd3\xe9\x04\xbb\xc5\xcc\xb2\x2c\xd8\xcd\x22\x54\x58\x6d\x76\x93\xd3\x64\x07\x8b\x95\x36\xb3\x56\xb3\xf9\xe0\x07\x82\x80\x59\xcc\x71\x98\x9d\xeb\xf5\x62\x93\x59\x92\xcc\x26\xf0\x3e\x51\x52\x62\xb5\x60\xb7\x1b\x5b\xac\x83\x92\x84\x6d\x76\xb7\xdb\x6e\x1b\x72\xbb\x31\x4b\x9b\x05\xc1\x4c\xb3\xb0\x4d\x7b\xdb\xed\xb6\x30\x4e\xec\x72\x61\x27\x63\x19\xe4\x79\xab\xc9\x85\x9d\x4e\xec\x32\x59\x4f\x76\xb9\xb0\xc0\x63\xa7\xd3\x6e\x32\xdb\xe0\xa2\xe7\x1c\x0e\x87\xc0\x02\xcb\x3a\x04\xc7\x29\x2c\xeb\x14\x9d\x60\xb3\x81\x53\x74\xbc\xc6\xba\xbc\x2e\xa0\x69\x1b\xb6\x98\xad\x26\x86\xc5\xe4\x92\x3b\xcf\x1e\xfd\xc8\xee\xf2\xcf\x1a\x7a\x06\x02\x5c\xa6\xe1\xec\x3b\x77\x7f\x8a\xad\x16\x96\xb5\xe4\xff\xf3\xa9\xc5\x9e\x7e\x15\xf7\x3a\x4d\x14\x65\x72\xd2\xf9\x27\xe1\x9f\x60\x61\xac\x66\xc6\x0e\xa7\xe7\xb6\x9a\xcd\x5b\x73\xe6\x89\x2f\xff\x9f\xd9\xf2\xc2\xcb\x66\x2d\x09\xff\xfc\xcf\x87\x56\xeb\x87\xff\xb1\x51\xa3\xff\xb6\xdb\xff\x3d\x6a\x0f\xbe\xff\x5f\xa7\x99\xf9\xef\xfb\xb4\x59\x13\xf1\x19\xda\xf9\xff\x65\xac\xae\xff\xc2\x16\x97\x75\xba\x56\xf5\x6f\x93\x95\xff\x37\xfc\x8e\xb7\x86\x34\xfa\x33\xb7\xfb\x33\x38\x60\xb6\xdb\xf3\x1c\x7e\x5f\xc3\x1f\x5b\x1c\xac\xf5\x63\xd0\xac\x2c\x1b\xd0\x84\x0f\xac\x4e\xa7\xf5\x03\xf8\xc0\xe6\x74\x6a\xa6\xbf\xdb\x5d\x2e\xfb\xda\xb3\xf1\x16\xc2\x61\x66\x28\x93\x2b\x7f\xe5\xd9\x77\x60\x97\x9d\xd8\x21\x59\x22\xda\x97\x23\xe2\x9d\x87\xf9\x06\x91\xc1\x61\xec\x33\x10\x48\x11\x0a\xc5\x54\xb7\x60\xcc\xd0\xb7\x80\xf8\xf5\x39\xd2\x00\xa7\x2e\x64\xd3\x59\xcc\xc3\x1f\xe1\xc6\xf5\x2f\x69\x37\x6b\x43\xda\xcd\x2f\xad\x87\x1b\xbf\x21\xbf\x17\x86\xe1\xe4\x97\xc6\xf2\x2f\x11\x68\xf6\xcc\x7b\x0a\xfe\x18\xf7\xcc\x1c\xbd\x67\x5c\x06\x2a\xc6\x65\xc8\x8a\x09\xe7\x4c\xc8\x15\x72\xb9\x09\xe7\x8c\x9b\xcf\xe5\x91\x17\x45\xd1\x20\x3a\x05\x9d\x85\xce\x43\xdf\x43\x08\x8e\x9f\xaf\x93\x18\x2e\x2c\x2b\x20\x1b\xce\xd6\x19\x2e\xcc\x81\xb1\x5a\x26\x89\x8c\x40\x33\xee\xc2\x9c\x39\x83\x0d\xde\x3e\x45\x36\x70\x8f\x24\xd1\x9d\x55\xb3\x6a\x02\xd4\x6c\x13\x4e\x1a\xf1\xf7\x62\x29\xd0\x8c\x08\x59\x95\x05\xa0\xa5\xac\x9a\x56\xb3\xaa\x9c\x91\x33\xb2\x22\x30\x84\x7e\xa9\xa2\x3f\x85\xa6\xe4\xa8\xfe\x4d\xa6\xa9\x27\xfc\x65\x87\x01\x94\x73\x65\x43\xfe\xf3\x61\x83\xc5\xa6\xfd\xd2\x06\xa7\x68\x43\x65\xf5\x79\x84\xb5\x70\xaa\xa9\xf1\x8a\x80\x93\xc5\x40\x77\xd4\x7e\xb7\xed\xad\x7b\xaf\x9b\xe7\xb0\x7b\x80\xb2\x90\xe6\xc1\x59\xac\x19\xa7\xd5\xee\x98\xc7\x6e\xb7\x06\xdd\x20\xd9\x5c\x66\x8c\x01\xdb\x54\xcd\x97\x9e\x95\xea\x81\x6d\x0e\x3b\xd0\x8c\x81\x50\x61\x83\x2d\xdf\xbb\x0a\x8b\x54\x5f\xca\x57\x1f\xc0\xeb\x3d\x67\xf5\xd5\xb2\x24\x79\xbe\x31\xc5\x36\x06\xc3\x5c\xe6\xef\xd6\x2e\x2c\xb5\x41\x83\xed\x80\x8b\x44\xf5\x65\x30\x7c\x00\xe1\x19\xde\x00\x53\x27\x06\x00\x03\xc8\x65\x61\x4f\x93\x76\x80\xb1\x01\x69\xf1\x96\x2d\xad\x36\x3b\x30\x9e\xb5\xfa\xc2\xad\x03\x37\x24\xcb\x1c\xee\x1a\x1a\x13\x54\x60\xf3\x84\xdd\x9a\xcf\xf3\xdd\xb2\xb9\xc4\xa6\x8a\xf9\x4c\x9c\x28\x23\x49\x00\x0c\x22\x0b\x90\x5f\x9e\xf5\x01\x47\x75\x9d\x31\x7b\x55\xbd\xd5\xe3\x07\x40\x47\xb5\xb3\xc2\x3b\x9a\xf9\xed\xde\x0d\xef\x4e\xf1\x29\x3e\xab\x66\x33\x29\x29\x00\x12\x9f\xe2\x0d\x48\x3f\x82\x76\x40\x34\x9d\x80\x4c\x02\x14\x22\x6a\xe8\x76\x51\x45\x56\x88\x54\xe6\x1b\x6b\x7a\xf9\xc4\xdd\xb7\xe4\x18\x02\x93\x04\x50\x44\xee\x96\xdd\x13\xb5\xdf\xcd\x3f\x85\xc2\x98\x04\x0c\x34\xbe\x6c\xed\x65\x98\x02\x92\xc4\x98\x3a\x65\xfe\xb7\xa8\x36\x22\xb7\x32\xbf\x12\xde\x11\xbc\x4e\x93\x87\x88\x98\x35\x1f\xbe\x6a\xe5\x4a\xad\x57\xf0\xba\x09\xc6\x8c\xa9\x90\x19\x87\xf3\x6f\x9b\x83\xb4\xdb\xed\x15\xe0\x91\x95\xc7\xd7\xc3\x49\xdf\xae\x1e\xe2\xee\x70\x26\xaa\xb6\xe2\x26\x10\xa5\x00\x0e\x42\x54\xcf\x13\x85\xca\x30\x20\xdc\xa2\xb2\x22\xd7\x80\x91\xe7\x89\x6f\xac\x04\xa8\x86\x92\x29\x4b\x29\x0b\x05\x18\x48\x4c\x31\xc4\xca\x3e\x88\x76\x8f\x3c\xd3\xa5\xbd\xd7\xbb\x94\xb4\x11\x18\x03\x49\x5b\x57\xf4\x69\x7f\xee\x7e\xf2\xe9\x6f\x51\x0d\xef\xaf\x58\x71\x2b\xc3\x9b\x48\x9a\x64\xcc\xe4\xad\x2b\x56\x00\x07\xde\x95\x2b\x6f\x61\x78\x92\x20\x69\xab\xed\x96\x95\x2b\xb5\x4f\xb4\x77\xc6\x7c\x64\xc6\xcb\x5f\x6f\xf8\x02\x7f\xdb\x1a\xc8\xa4\x92\x05\x9e\x6e\x45\x8e\x86\xdd\x29\x0e\xa2\x9c\xfe\xe5\xba\x05\x86\xfe\x66\x99\x43\x30\x69\xd1\x45\x7d\x15\x5d\xd3\x7b\xdb\x6a\x07\xb4\xcb\x16\x02\xb5\x7e\x43\x3a\x58\xdf\x1a\xfc\x76\x02\xde\xe5\x90\x72\x03\x33\x36\xf8\xf8\x95\xf9\xd7\xc0\x03\x36\x57\x78\x60\x5e\xd0\x71\x22\x99\x2a\x50\xf2\x5b\xf6\x3c\x5c\x38\xa3\x4a\x40\x16\xdc\xa5\x84\x6f\x14\x81\xcc\x8d\xa2\x91\x1c\xe4\xb4\xfe\xe1\xd5\xab\x87\x57\x7f\x8b\x72\xc3\x88\x36\x32\xa2\xdf\x92\x5b\xad\xdf\x82\x90\xf9\x70\x59\xc7\xe6\x65\xf4\xf2\xaa\xa8\xd7\x40\x59\xcf\x44\xdd\x54\x26\x5a\x5a\xdc\xbb\xbf\x59\x86\xa8\x3b\x9a\x09\x73\x60\x44\x08\x1b\x5e\xd0\x59\x3e\x93\x72\xa7\x92\x22\x2e\xaa\xd1\x38\x97\x03\x64\xfc\x11\xcd\x5f\x2b\x5d\x2e\xa7\x21\x7c\xc9\x4a\xd3\xe5\x7f\xbe\xdc\xe4\x3e\x25\x37\x5d\x8c\x3c\x61\x70\xbd\x91\xb9\x71\xff\xc1\x37\x49\x9c\xcb\x1d\x40\xf8\x37\xda\xed\xbe\x92\x93\xce\x38\xe3\xa4\x12\x5f\x1b\x4c\xcd\xe5\xbc\x9a\xd7\xe0\x67\x3c\xec\xf3\x3a\xee\x5d\x35\xa0\x3e\xc3\x9b\xed\x5b\x8d\x13\xee\x31\xd6\xc8\xc3\xc4\x0d\x6a\x16\x92\x6a\xd6\xa9\x14\x90\xd5\x44\xa7\x81\xba\xa2\x24\xd5\x6c\x5a\x49\x80\x7e\x44\x30\x8e\x7c\x73\xe3\xfc\x40\x30\xb8\x23\xef\xdc\xa1\x1b\x06\x3b\xee\x74\xc2\x43\x41\x7e\xdb\x36\x67\x56\x70\x53\xdc\xa9\xa7\x72\x94\xdb\xf5\xa4\x4f\x98\x33\xc7\x95\x95\x31\x9f\x4e\xf3\x98\x17\xbe\x4d\xef\x94\x30\x89\xf9\x7d\xa2\x09\x9b\xef\x32\xe6\x8d\xef\x72\xe4\x27\x79\x6e\x81\x6b\x6f\x71\xd3\x1c\x97\x71\x6f\xd6\x9e\xde\xec\xce\x38\x1d\x57\x0a\x8b\x46\x17\xf1\x38\x96\x11\x1a\xae\x6c\x10\x32\x2e\xee\x04\x6d\x3a\xf5\x6d\xbf\xd3\x63\xe7\x86\xa8\xb1\x5a\x33\xd0\x30\x53\xc9\x6f\x1e\x0a\x0d\x16\x62\xcd\xd8\x12\xa7\xeb\xd5\xc2\x9a\xb5\xcf\xc1\x6c\xfe\x56\xe3\x18\x91\x1b\xbb\x17\x72\xe9\x3e\x6c\x12\xf3\x23\xba\xfc\x60\x99\x0f\x16\xf3\x09\xde\xbf\x8a\xa6\xa0\x05\xdf\x52\xb2\x56\x08\x42\x00\x1c\x60\x30\x1a\xd1\x46\xf8\x4a\x58\x64\x08\x83\xb7\x08\xda\x40\x91\xb3\x6d\x90\x15\x25\x48\x80\xca\x17\xae\xd5\x4f\x2a\xdf\xfc\xf2\x87\x4c\x5e\x6b\xca\x4a\x98\x1e\x79\xc4\x44\x58\x53\x56\xaf\xe9\xaf\x2c\x4b\x92\x2c\xfb\xd7\x63\x8f\x6b\xe7\xd8\x1d\xf8\x62\x2c\xda\xdb\x8a\xfb\x6f\x55\x23\x56\xc2\x24\x9b\xbc\xd6\x7f\xfd\xcb\xea\x35\xc9\x26\xc2\x0a\xd5\x3c\xcf\xf3\xda\xab\xc7\x1e\xcf\xd3\x58\xb4\x13\xfa\xa3\x2d\x58\xb4\x8f\xfe\xdc\xee\xc0\x08\x90\x72\xe8\x1a\xea\x0d\x1a\x19\x1e\xba\x6e\x3a\x4a\xe3\x02\xb1\x8f\x05\x94\xb0\xe8\xd5\x75\x27\x55\x3e\xcc\xb8\xce\xb0\x10\x49\x80\x32\x7e\xba\x8f\x7a\xe3\xb4\xef\x74\xfc\xea\xb6\x9a\xfe\x01\x7f\xc7\xf2\x53\xd7\x0d\xcd\xf1\x81\xcf\x3b\x77\xe3\xa6\xe9\x77\x9f\xb3\xf3\xb6\x57\x1e\x7a\xe0\xa9\x46\xa6\xa4\xab\xa9\xc3\x15\x6c\x4c\x66\xda\x7f\x7b\x5b\x2b\x7e\xf6\x39\xe9\x42\xed\xb3\x5b\xbd\xd5\xb5\x5c\x66\xed\xa5\x7f\x01\x06\xce\x7c\xf9\x8f\xda\x35\xda\xc7\xcf\x0d\xdd\xfd\xe1\x64\x28\xdb\x3b\xf2\x9f\x57\x47\x6e\x39\x0f\x48\x9b\x12\x5a\x3a\x63\xce\xfc\x53\x16\xfc\xf4\xf5\xe2\x9a\x3e\x53\xe8\xd7\x68\x64\x41\x2c\x72\x21\x37\x2a\x41\xd5\x08\xf1\xc0\xc5\x29\x55\x31\x43\x7c\x6c\xc2\xd9\x0c\x12\x47\xc5\x81\xa3\x38\xa1\x48\x2a\xa6\x9b\x24\x05\x13\xfa\x0f\x78\x81\xf6\x80\xf6\xf0\xcf\x7f\x4e\xa4\xf0\x02\xed\x5f\xda\x03\x53\xc1\xa9\x7d\xa2\x7d\xf2\x7d\x98\x96\xbf\x83\x7c\xf1\xe7\xda\xc3\x60\xcf\xdf\x41\xa4\x22\xa3\x2f\xba\xab\xdc\xa3\x2f\x46\x22\x44\xca\x5d\xe5\x26\x52\x11\x58\xa5\x9d\x09\x4b\xdf\x8e\x6d\xdb\x36\xfa\x26\xec\x7a\xe8\xed\xef\x3e\xf2\xc8\x23\x8b\xde\x86\xa5\xda\x99\xda\xc7\xdb\x00\xc7\x1e\x82\x5d\xda\x75\x95\xf9\x3f\x97\x4b\xf9\x3f\xdb\xed\x38\x22\x95\xe3\x48\xb9\x84\x23\x76\x7b\xfe\xcf\xd2\x18\x5e\x2b\x32\x21\x6a\x03\x8a\xa2\x39\x85\x36\x69\xcc\xda\x45\xc3\x95\xd8\x58\xe1\x38\x0c\xe0\x11\x4b\x19\xeb\x1c\x34\x18\xc6\x73\x02\x94\xc3\x78\xe1\x01\x2a\x55\x9c\xc5\x63\xc6\x7c\xc0\xa2\x91\x02\xab\x96\x69\xd5\x45\x1f\xdc\x45\x3a\x88\x83\x93\x00\x53\xf7\x7c\x70\xe6\x42\xdb\xee\xb3\x17\x4f\x9d\x02\xca\x83\x77\x82\xe7\x76\x38\xf0\xeb\x1f\x6e\xb9\x68\xa9\xb3\xcd\xd6\x35\x55\x9d\x3a\x35\x53\x35\xa3\xa3\xa3\x67\xc6\x9a\x8e\x8d\x77\xfd\x70\xf3\xa5\x27\x2f\xea\xec\x4b\xf7\xf7\x36\x54\x4e\xef\xe8\xec\x19\x58\xd5\xb6\xe9\x1e\x3c\x9a\xf8\xe5\xa6\xdd\xef\x81\xe5\xef\x77\x9c\xf9\xd3\xac\x52\xb9\xee\xb6\xc6\xeb\x9f\xb8\x55\xfb\xe0\x76\xda\xa3\x7d\xb2\x69\xe7\x29\x42\x0f\xdb\xd1\x95\xcd\x74\x57\x74\x0f\x0c\x74\x57\x5c\xba\x7e\xe3\xce\xef\x9c\xde\xde\x99\x6a\x98\x50\x38\x70\xc9\xd1\xf1\x07\x05\xec\x4d\x05\xd5\x20\xd5\xe0\xe4\x3c\x2a\x68\x20\x16\x62\xa4\x6c\x52\x52\x41\x95\xd3\xaa\x42\x3b\x51\x48\x55\xe8\x88\xc2\xb8\x42\x59\x83\x5b\x96\x92\xb2\x4e\x85\x11\x05\xfc\xc2\xf1\xae\xff\x78\x44\x3b\xff\xde\xa7\x07\xee\x19\x78\xfa\xe0\xa7\x4f\xfb\xfd\x4f\xcf\xc7\x9d\xb0\xa5\x70\xe0\x85\x22\x55\x2c\x71\xea\xd3\xf3\xe7\x3f\xed\xa7\xd1\x09\x3c\x85\xd9\xf9\xfa\x4d\x07\x3f\x35\x6e\xb8\x57\x3b\x3f\xff\x94\x71\x00\xe4\xbf\x14\x6e\x36\x3d\x7d\x6f\xe1\x71\xc6\x7c\x4d\x88\xde\x47\xbd\x8e\xc2\x46\x8c\xd6\x98\x83\x93\x2b\xa6\xba\x69\xe4\x16\x02\x38\xd4\x8a\x33\x69\xa4\x64\x44\xd2\x45\xef\xbb\xe8\xef\xda\x88\x36\xac\x8d\xfc\xfd\xa2\xa7\xa1\xff\xa5\xb7\xb4\xb7\x8a\xbc\xb6\x4b\xb4\xb7\xde\x7a\x09\xfa\x9f\xc6\xb9\xfb\xf5\x93\x17\xfd\x1d\xda\xef\x7f\x0d\xd6\x7d\x12\xdc\x5f\xad\x0d\xbf\xbb\xbd\x40\x63\xbb\xfd\x5d\x18\xaa\xde\x1f\xfc\x44\xbb\x04\x21\x40\xfc\x21\x44\x7f\x44\x23\x74\x0a\x42\x7c\xd6\xa5\x26\xeb\x04\x86\x25\x0d\x67\x12\x23\x80\x1d\x12\x7a\xf7\x44\xd4\x80\x1a\x80\x20\x64\x0d\x6f\x20\x5d\x61\xd4\x4f\x1a\x09\xd6\x88\x8a\x2f\x04\xbb\x27\xc8\x1a\x90\x53\x62\x5d\xc0\x24\xb9\x8a\xbe\xe5\xbc\xe9\x0f\xcf\x52\x60\x2a\x6b\xaf\x0f\x53\x3d\x93\x93\xcb\xa6\xb6\x3a\x9d\x8a\xdf\xe1\xb3\xb3\x96\xf2\xea\x0a\xd6\xbe\x4c\x99\x26\xf0\xa0\xb8\x85\x5b\x87\xc3\x0a\x41\x8a\xd3\xfd\xfe\xa5\x55\x03\x3c\x1f\x8c\x08\x35\xe1\x79\x33\x26\x89\xee\xe6\x1e\x0f\x19\xaa\xa8\x2b\x67\xed\x2c\x63\x29\xab\x9e\x5e\xd7\x5d\x59\xeb\xe7\x81\xf8\xb3\x76\xe6\xa1\xbd\xda\x43\xff\xbc\x00\x5f\xfd\x06\x6c\xda\x06\xd8\x94\x5a\xb2\xfe\xda\xab\xee\x9c\x94\x54\x9c\x41\xce\x99\xda\xb1\xf6\xd4\x40\x69\x49\x5d\xd8\x4b\xd3\xeb\xb8\x89\x5e\x5f\xed\xaa\x50\xf0\xd1\x87\x13\x6b\x22\xe1\xf8\x24\x8e\x5b\xc7\x4e\x2e\x2d\xad\xbf\x61\x6f\x7b\x75\x50\x08\x73\xce\xcc\x96\xf5\x5b\x56\x2f\x3d\xa9\x85\xe3\xec\x44\x69\xa4\x33\xd9\xdf\xbb\x64\xd9\xf6\x49\x5a\x5e\x3b\xf5\xdd\x2b\xbf\x80\x81\x82\xde\x63\xb4\x35\x1b\xf2\xa1\x32\xd4\x8f\x16\xa1\xd3\xd1\x46\x74\x11\xba\x0e\x21\xca\x2d\xc7\x14\x55\x94\x54\x51\x62\x44\x60\x44\x89\x91\x9d\xaa\x44\x33\x12\xed\x16\x40\xa2\x49\x26\x93\x55\x95\xac\x2a\x65\x09\x46\x14\x18\x89\x66\x14\xfd\x5c\x44\x51\x65\x85\x91\x15\xa3\x59\xea\x67\x55\x25\x9b\x94\x18\xfd\x31\xe0\xa6\x8b\x97\x29\xd9\x18\x72\x32\x4a\xb6\xe0\x7b\xa9\xca\x8a\xaa\xdf\x62\xdc\xa5\x37\x05\x34\x2e\x18\x86\x2c\x04\xc7\x1c\xe5\x06\x4f\xac\x78\x45\xbb\x79\x45\x63\x69\x55\xc7\x95\x6f\x72\x1d\xf9\xbf\x9e\x24\xfa\x1a\x4e\x3e\xb9\x21\xc0\x0f\x44\x29\x53\xe3\x0a\xed\xe6\x57\xea\x3b\xb8\x37\xaf\xec\xa8\xda\xf4\x1e\xcb\xfe\x23\xd8\xb5\xb7\x61\x7e\x6d\x7a\x61\xba\x76\x7e\xc3\xde\xae\xe0\x3f\x58\xf6\xbd\x70\xe7\xde\xa6\xb9\xb5\x55\xa7\x57\xd5\xce\x6d\xda\xdb\xa9\x55\x74\xd4\xeb\x97\xcb\xd1\x86\x15\x30\x44\x3a\x4f\x6e\xf0\x89\x27\xc5\xa2\x03\x7c\xa0\x41\x6c\x88\xca\xfa\x8f\xd4\x77\xfc\x06\x86\xc0\xfe\xbd\xfd\xda\x2f\xb4\x3b\xb5\x5f\xec\xff\xde\xf7\xf6\x43\x33\xcc\x87\xe6\xfd\x0f\x9e\xe0\x03\x59\xd2\x49\xbf\xfc\xff\xe3\xec\x3b\xe0\xa4\x28\xd2\xbe\xeb\xa9\x4e\x33\xb3\x3b\xb1\x67\xba\x27\xef\x4e\xea\xd9\xbc\xec\xc4\xcd\x3b\xc0\xb2\xa4\x25\xe7\xbc\x20\x39\x48\x92\x28\xc2\x90\x04\x45\x3d\x45\xc5\x80\x81\xd3\x03\x11\x39\x14\xf5\x54\x14\x75\xf5\xce\x33\x60\xba\x3b\xbd\xf7\xf0\xd4\xc3\x3b\xef\xde\xd3\xf7\x82\x7a\x49\xd8\x9d\xe2\xfb\x75\xf5\x6c\x00\xf5\xee\x7b\x5f\xd8\x9e\xae\xae\xaa\xee\xae\xaa\xae\x7a\x2a\x3c\x4f\xfd\xff\xc7\x83\x35\xb1\xba\xa3\x15\x93\x0b\xb1\xd5\xdb\x98\x08\x3c\x09\x77\x3f\x19\xa8\xad\xf5\xce\x5f\xb5\x82\xfc\x31\x78\xfc\x1d\x7e\x10\x14\x4e\xae\x38\x5a\x17\xc3\x33\xc6\x96\x4d\x2e\x1b\x3b\x73\xd4\x03\x83\x6d\x5f\x1a\x0c\x5f\xda\x06\x3f\x30\x6a\x26\xf5\x9a\xd5\xfe\x40\xab\xed\x0b\x83\xe1\x0b\x5b\xeb\x03\xed\x58\x19\x84\x0b\x26\x97\x3d\x5c\x5b\x56\x1b\x38\xfe\x4e\xee\x11\xb2\xf0\xc9\x40\xa2\xd1\xbb\x68\xc5\xaa\xf9\xde\xda\xda\x80\x12\xa8\x2d\xab\x7d\xb8\x6c\x72\x01\x1e\xc4\xbf\x93\x43\x34\x65\x7b\xfa\xa7\x16\xdf\xff\x6d\xd6\xf9\x42\xbf\x7d\xb1\x16\x54\x87\x86\xa0\x25\x68\x2d\xda\x89\x50\xc4\x1e\x0a\x26\x13\xf1\x18\x93\x3f\x4b\xe9\x24\x1f\xea\x31\xbb\x77\xf0\x0e\x3b\xfd\xf1\xe3\x78\x4c\x9d\x76\xa8\x62\x98\xce\x40\xa2\x29\x31\x4e\x7b\x8d\x90\x3a\xbe\xe1\x92\x1a\x6e\x7c\x4c\x8a\x27\x43\xaa\x9f\x0f\x42\x0e\x55\xfc\xc6\x1d\x21\x87\xdd\xcf\x50\xe5\x91\xa6\x88\x49\x5d\x4e\x81\x8a\xdb\x66\x2d\x9b\xb7\x30\x3c\x62\xd4\xa8\xb0\x72\x64\x74\x5d\xac\x71\xf2\xfa\x86\x0a\xa5\x74\x75\x49\x6b\x7b\xf9\xb9\x8e\xd1\x9e\x9a\x9a\x51\xd3\x0d\x91\xa1\xd7\x61\x7c\x1d\x03\x17\xfc\x4a\x32\xa1\x0f\xe9\x97\x30\x37\xb0\x8d\x61\x60\x2c\x2c\xe6\x6c\x45\xb5\x4a\x86\xbc\x36\x60\x58\x4d\xac\xad\x06\xcf\xef\xaf\x12\xfb\x74\x50\x4b\x06\x6e\x9f\x34\x71\x7a\x3c\x72\x8d\xcf\xb7\x66\x72\x6c\xb1\x99\xb1\xb6\x26\x9d\x4c\x64\x61\xe5\xe0\x90\xe5\xf4\xe0\x8c\x89\x2b\x72\x56\xe8\xcc\x57\x8e\x71\x7a\xf5\x64\xae\x27\x0d\x3b\xab\x64\x79\x00\xd9\x18\xd3\x6f\x72\x8c\xff\x04\xaf\x1b\x6f\x77\x16\x55\xaf\x63\x00\x9f\x8d\xa4\x1a\x14\x27\xfe\x20\x9c\x4e\x45\xc2\xc9\xd4\x84\xcb\x30\x5e\x79\xd4\x7a\x11\xf1\xa7\x29\x06\xb6\x85\xae\x61\x2e\x47\x1b\x10\x8a\x24\x42\x41\x87\x3d\x1e\x63\xd4\x1e\x49\x75\xa8\x2d\x83\x32\xa9\x53\x64\x16\xce\x61\x09\x04\xa9\x69\x72\x52\x9d\x3c\x24\xf3\x7a\x7c\x39\x06\xa1\x54\xd2\x9a\x88\xc6\x79\x87\xd5\x1e\x71\x50\x54\xab\xa4\x35\x9e\x0c\x52\xc4\xfe\x78\x92\x86\xc4\x1d\x41\xa5\x1c\xac\xf6\xbc\xe5\xb7\xd6\xff\xe1\x09\x87\xef\x3b\x7e\x47\x43\x63\xc3\x96\x2d\x1b\xc0\x18\x2e\xb7\xec\xdf\x52\x12\xad\x1c\x3a\x79\xf2\xd0\x4a\x72\xfb\x90\xcd\x57\x0e\x7c\x6a\x70\xcb\xb0\x39\x2f\xdc\xd0\x31\x7e\x1e\x3c\xf5\x31\xcb\x7e\xcc\xe2\x59\x43\x17\x35\x4f\x8f\xf9\x74\x58\x70\xf2\x0e\xa5\x83\xff\x1d\xff\x88\xb9\xce\x34\x69\x4a\x53\xee\x8b\xd1\x75\xf5\x63\xc7\x34\xd4\x4b\xf3\x17\x2f\x60\x66\x36\x8d\xbf\x65\x0f\xbc\xf5\x46\xa1\xa1\xbc\x74\xdb\x13\xb2\x4e\x89\x16\x95\xca\x0e\x7f\xe5\x84\x3a\xf2\xae\xab\x6e\xd9\x88\xc3\x8d\x6c\xe9\xa4\x15\x5e\xd6\xf9\xf0\xb8\x7d\xa7\xaa\xbb\x5f\xa8\x9c\x86\xe7\xce\x0e\x06\x66\xe4\x0e\x4e\x3b\xf9\x93\x68\x49\x63\xc7\xd4\x06\x98\xc3\x62\xfe\x85\xf6\x54\xa8\x74\xcb\x0b\x2c\xb9\x75\x27\x6b\xba\x6a\xca\x94\xfa\x86\xa9\xdf\xe4\xa5\xd6\x43\x88\xe1\x85\x28\x13\x02\x6b\xfc\x1b\xfb\x3d\x4a\xc1\xb0\xea\x5e\xa7\xbd\xec\xe0\x46\x10\x16\xe0\xff\xba\xc4\x28\xdd\x0e\x7f\x23\xaf\x0d\xa8\x98\x09\xb5\x44\x24\xa7\x99\xeb\x2f\xe5\x9e\xad\xbb\x88\xd8\x57\x79\x84\x7c\x14\x2b\x48\x03\x07\x13\xb0\x28\xf1\x42\x28\xa8\x44\x15\x0d\xb9\x31\x99\x48\xc5\x58\x8b\x2a\xfe\xf3\xd0\x1d\x14\x4a\x4c\x03\x16\x72\xd8\x65\x0d\xfc\x38\x99\x68\xc6\xf1\x18\xcb\x8c\x58\x33\xa6\x31\xde\x9c\xfc\x57\x25\x78\x1c\x9c\xdd\x8f\x4d\x0e\xa5\xad\xb5\xa4\x69\xa8\x65\xf5\x21\xf8\xcb\x3d\xe4\x6f\xf7\x65\x06\x3b\x64\x8e\x0b\x3b\xe2\x75\x73\x1f\xcf\xb6\xb7\x67\x1f\x7f\xf9\xf1\x6c\x7b\xc2\x60\x54\x4a\x0d\x99\x59\xf7\xfc\x6a\xfd\x7d\x60\x64\xed\x87\x56\x87\x06\x8f\x21\x37\x12\xa7\x14\xc0\x1e\xfb\xd6\xbf\xbd\xf8\xa3\x1d\x8d\xd3\x47\x86\xca\xc6\xae\xae\x22\x3f\x21\x7f\xbf\xc7\xc4\x45\x1c\x76\x99\x35\xe6\x6f\x6f\xcf\x3e\x3e\x77\xcd\x62\x7b\x89\xdd\x24\x5e\x7d\xd3\x86\x5f\xdd\x33\xf3\x1e\x04\xc8\x96\xef\x07\x97\x20\x04\x79\x43\xd9\x74\xc2\x46\x57\x9e\xfd\x7c\x11\xa8\x95\xce\x61\xf7\x83\x23\x3f\xaa\xaa\x62\xa3\x4a\x48\xe0\x05\xbf\x86\xbe\x19\xea\xa1\x94\xa1\x86\xb6\x55\x4c\x52\x23\x96\x89\xa5\x53\x49\x0a\x14\x13\x14\x4c\xa0\x15\x52\xd2\x02\x26\x9d\x64\x04\xab\xe9\xd4\x35\xfb\x4e\xed\xde\x5d\x33\xbe\x31\x16\x2c\xb2\x17\x42\xda\xc6\xb0\xa3\xa6\x44\xc3\x7a\x87\xd5\x51\x60\x01\xc0\x5c\xc3\x70\xfb\x84\xb4\x0e\xb3\x5c\xe6\x2f\xc9\xb5\xe3\x32\x66\x9d\x29\xa3\x2b\xfd\xe1\xf8\x50\xeb\xfa\x89\x03\xed\x45\x05\x0d\x76\xd6\x80\xf1\x80\x8d\x46\x8e\xd5\xd9\x86\x97\x02\xcb\x32\x32\xfe\x40\x0c\xd8\xeb\x2d\x52\x73\xe1\x3e\x28\x6f\x1c\x94\x76\xa4\xea\x47\xb7\x5d\x31\xb6\x9e\x9b\x30\xd8\x94\x28\x04\x8e\x83\x35\xaf\x2f\x2f\x5f\x63\xb6\x17\x3b\x8a\x30\xb0\x77\x0f\xb1\x47\xaa\xca\x58\x27\x3f\xd7\x26\x89\x1c\x66\x01\x2a\x4b\x18\xb3\x3b\x15\x29\x89\xfa\xb0\x04\x18\x63\xa6\xe0\xf9\x66\xc6\x5e\x3a\x98\xd5\x43\xaa\x0a\xc4\x9e\x71\x57\xb3\x0e\x71\x2f\x53\x9c\xf0\x00\xaa\x44\xc3\x29\x86\x6c\xdf\xa0\xbd\xbf\xaa\x1b\x7f\xbb\x37\x28\xa1\x20\xab\xd6\x07\xda\x38\xa3\x42\x3a\x6c\x4d\xd8\xd4\x71\xa9\x04\x76\x5e\x90\x35\xd0\x39\x0b\x1d\xa9\x4a\xb8\x35\x56\x5a\x3e\x68\x50\x79\x29\xe3\x8a\x97\x78\x2a\x2b\x3d\x25\xf1\x3f\xd5\x68\x3e\xf8\x78\x22\xaa\xfa\x44\x13\xe4\x9f\x45\xd1\x87\xc9\xa7\x0f\xca\xa1\x80\x7b\x40\xb3\x67\xbc\x3e\x37\x8c\x7c\xfc\x63\x18\xf5\xca\x63\x50\xf7\x0b\xbc\xf2\xba\x75\xe9\x57\x0f\xb4\xaa\x11\x1e\x04\xef\xc3\xdf\x07\xef\x23\xac\x61\x7c\x2c\x5e\x12\x8d\x93\x39\xde\x8a\x4a\x8f\xb7\xb2\x02\xfe\x7a\xb9\xc7\x31\xf6\x6e\x72\xfe\x9e\xd1\x23\x18\xc6\xc0\x5a\xf1\xb6\x0f\xce\x40\xd1\xc3\xe0\x7d\x70\xd7\x67\xb9\x96\x75\xef\x4f\xf9\xd1\x8a\xc8\x8d\x5f\x81\xff\xab\x1b\x6f\xfc\x9b\x86\x5f\xc2\x5f\xe4\x11\x45\xe3\x90\x84\x3c\xb0\x70\x84\xd1\x20\x92\x92\x56\x3d\x44\x94\xa8\x86\xae\xcc\x7f\x1a\xe0\x2f\x22\xce\x63\xb2\x16\x18\x49\xc3\x57\xb6\x22\xa3\x5e\x94\x99\x8e\xae\x5f\x90\x75\x11\x06\x07\xf9\xac\xd9\x6a\xe7\xfe\xe1\x2c\xb9\x80\x7c\x16\x1d\x77\x8a\x9c\x95\x59\x21\x60\x87\x59\x6c\xa8\xfb\x8a\x07\x4c\xa5\x25\x22\xd3\xa9\xef\xc3\x4b\xb8\xc8\xfd\x0b\xb9\x51\xf1\x25\x6f\x85\x9e\xb7\xe6\xdf\x09\x22\x70\x7a\xe8\xff\xde\xdc\x97\xe4\x97\x36\x9f\x49\x2f\x4a\xa4\x24\xc2\x30\x21\x3e\x1b\x22\x67\x3e\xba\xb0\x10\xc6\x32\x73\x48\xb0\xef\xed\xff\x45\x4e\x39\xe8\xdb\x7f\xf2\x92\xa9\x34\x6a\x67\x3a\x1d\x17\x4c\x5c\x79\xf7\x2b\xd7\xe1\x6d\xdd\xbf\xbb\x44\xee\x24\xa8\x4c\x50\xc7\x1f\xa1\x60\x58\x9b\xcb\xc6\xa5\xbc\xe9\x3e\xb5\xe8\xe7\x05\x59\x12\x7a\x24\x11\x85\x0b\xa6\x1f\x97\xbb\x94\xd0\x56\xdb\xbe\xcf\xa3\xcd\x6f\x93\x4f\xef\x39\x4e\xde\x58\x21\x80\xee\x3a\x83\xd9\x22\x0c\x7f\x6f\xc3\xe2\xe7\xaf\x1f\x37\xee\xfa\xe7\x17\xcf\x7b\xb2\xed\xba\x22\xab\xb5\x8c\x64\xdc\x4a\x49\xd4\xbf\x63\x19\x88\xb7\xde\x03\xde\xb7\x73\x17\x7a\x8c\xf7\xce\x51\x23\x34\xc6\x4b\x5e\x23\x9f\xbe\xbd\xf9\x96\x5d\x06\x97\xee\x7a\x3d\x36\xcc\x59\x3c\xee\xfa\xe7\xdf\x7d\xfe\xfa\x71\x43\x07\x5d\xef\x8f\x96\x28\x6e\xe8\x2c\xb3\x5a\x8b\xb6\x2f\x58\xb9\xf9\xed\x3b\x49\xaf\x35\x5f\x47\x8f\xfd\x5a\x9f\xfd\x0a\xe5\xfa\x37\x61\x0b\x1d\x87\x5b\xaa\xe0\x92\xdd\x64\x3b\x48\xb7\x36\xb2\xa6\x43\xf0\x85\x8f\xc0\x2d\x97\x29\x0e\x39\xb4\xf0\x91\x3f\xf7\x8f\x44\x9e\xfe\x86\x6e\xb0\xf9\x62\x96\x7f\x99\xcb\xa2\xdd\x08\x71\x79\xeb\x33\x2a\x25\xd3\xa9\x24\x93\x88\x6a\x6c\xe3\x0e\xc6\x2e\xfb\x99\xfc\xac\xae\x7f\x8c\xa8\x35\x91\xaa\x62\xa3\x55\xd0\x43\xfb\x14\x8f\x69\xb3\x37\x13\x16\x78\x87\x68\x97\xa5\x78\x40\x95\x45\x62\x22\x5a\x85\xbf\x3d\x06\x7d\x2e\xbf\xbf\xe2\x64\x65\xc5\x63\x15\x4e\x77\xb0\xa2\xde\x12\x00\x30\x46\x72\xb3\x14\x23\x40\xc4\x92\x89\x95\xb8\x9c\xd5\xa7\xaa\xca\x8f\x95\xc9\xae\xa2\xd2\x94\x39\x00\xaa\x8c\xd2\x99\xf4\xe6\xc6\xaa\xb0\xd3\x59\x75\xaa\xaa\xec\xe1\x32\x97\x2b\x58\x5e\x6b\x0e\x01\x18\xdd\xf8\x39\x97\x11\x20\x64\x1b\x17\x77\xb9\x2a\x1e\xab\x28\x3f\x5e\xee\x72\x85\x2a\xeb\xcd\x21\x08\x5a\x1a\xab\xc3\xce\xac\x20\x94\xba\x8a\xfc\xac\xc1\xe0\xd8\x00\x7b\x1c\x06\x96\x35\x38\xc8\x8d\x37\x49\x06\x1e\x7c\x45\xee\x0a\x41\x28\x73\xfa\xfd\x9c\xc1\x20\x6f\xac\x63\x2a\x99\x2a\x4f\x2c\x18\x75\xf2\x06\xd6\x4b\xc3\x2a\xdc\x7e\x0f\xe6\x0d\x8e\x7d\xa4\xd3\x51\xc0\x30\x05\x0e\xc8\xec\x73\x14\x30\xb2\x92\x0f\xf4\x02\x67\x90\xaf\xef\x1e\xb7\xc1\x61\x10\xb0\xcf\xef\xae\xa0\x18\x43\xce\x8b\x59\x96\x70\x59\x54\x91\xc7\x8f\xa0\xdb\x4f\xfa\x0c\xb4\x43\xbd\x2e\x25\x4a\xfb\xa8\x74\x2a\x9d\x2a\x85\x98\xc4\x92\x88\x33\xc6\xba\x79\x26\xec\x5a\xee\x0a\x7f\x2f\xe4\x5e\xee\x0e\xdd\x3a\x6f\xeb\xa0\xcc\xd4\xa9\x9b\x56\x42\x0c\x7e\xe3\x0a\x73\x83\x87\xfb\x32\xc0\xbb\x0a\x92\x5d\x59\x57\x38\xec\x62\x5f\xee\x6a\x56\xcf\xf0\x45\x61\x75\xfd\xa6\x75\x37\x1d\xd9\xb8\xbe\x34\x12\xa6\xf3\x08\xb5\x4e\xa1\x7e\xbc\x23\xd5\xa8\x05\x0d\x46\x43\x11\x8a\x38\x02\xc9\xc8\x37\x2c\x85\x03\x49\xd1\x11\x4a\xaa\x67\xe6\xf2\xb0\xcb\xd7\xca\x1c\x21\x4a\x53\x09\x1d\xe4\x10\xa6\xf4\x5a\x79\x5c\xb7\x43\xdd\x87\xce\x9d\xe3\x51\xae\xf8\x5c\x9f\x27\x93\xed\x73\xe3\xcc\xb9\x73\xdd\x87\xb2\xd9\x6c\xb6\x1f\x88\x9c\x02\xd9\x6c\x16\xa3\x6c\xb6\x1b\x65\xb3\xec\x25\x21\x04\xf5\xbf\xca\x47\xd3\xf4\xdb\x79\x6e\x7a\x04\x31\xc9\xc2\x17\xab\x65\x18\x51\xeb\xa9\x45\xed\x47\x23\x6a\xe5\x2c\x96\x2c\xaa\x74\xe2\x24\xbb\xc0\xa5\xd8\xce\xdd\xcf\x3d\x47\xfe\xf9\x1c\x26\x77\xce\xdc\xba\xfb\xb9\xe7\x76\x6f\x9d\x09\x8b\xf1\x73\x60\xa0\x4e\x72\x27\xc6\xb0\x78\x26\x46\x6a\x94\xe7\x76\x17\x4a\x4f\x4e\x56\x83\x26\x3f\x29\x15\x6a\xb7\x4d\x7e\x52\x72\x4a\x4f\x4e\xbe\xa4\xad\x52\x5e\xfc\xb0\xb6\x07\x36\x95\x88\xa6\xa5\xb8\xb6\x94\xec\xb0\xd3\x0d\xce\x94\x1c\x2f\x4d\x37\xc4\x7e\x63\x2b\x1f\x87\xae\x99\x3a\xb1\xe9\x4b\x8c\xbf\x6c\x9a\x38\xf5\x9a\x6b\x1e\xdb\x8a\xbf\x6c\x9e\x30\xf5\x9a\x6b\xa6\x4e\x68\xfe\x12\x6f\x7d\x0c\xae\xe9\x3f\x54\xca\x3d\xb6\xb5\x7e\xa3\xc5\x64\xd9\x58\xbf\xf5\xb1\x6b\xae\x99\x2a\x58\x36\xd6\x5d\xf3\xd8\x35\x75\x1b\x2d\xc2\xd4\x6b\x98\x73\xfd\xc7\x4d\x42\xef\xdc\xd1\x8a\xaa\x51\x33\x6a\x47\x53\xd1\x7c\xb4\x16\x21\x44\x97\x7d\xe9\x0a\x2f\x55\x4c\xa4\x53\x20\x0b\xb2\x64\x37\x53\x04\x84\xbe\x89\x5c\x3c\x26\x53\x43\x59\x91\x2e\x1e\xe7\xad\x66\x25\xbb\xcc\xf7\xbf\x4a\x69\x75\x97\xca\xcf\x68\xde\x74\x85\x6a\xd5\x35\x6c\x97\x84\x06\x8d\x66\xc7\x43\xec\x03\x5c\xcb\x8f\x54\x18\xec\x2e\x63\x41\x99\x2d\xb8\x7d\xa2\x8b\x79\xa6\xea\xef\xad\xa2\x98\x99\xb6\xf2\x79\xd2\x45\x7e\x4b\xba\x9e\x5f\x49\xe1\x54\x9f\xfa\x7e\x46\x4c\x8a\xad\x5d\x86\x42\xa3\x61\x86\x5e\x6f\x70\x1b\xa6\x1b\x3e\x2c\x70\x16\x4c\x37\x18\xf4\x1e\xfd\x0c\x7d\xb1\xcd\x44\x81\x4f\x3a\x4c\x27\x6c\x5e\x9b\xcd\x6b\xbb\x63\x86\x1a\xd5\x60\x98\x6e\x70\x1b\xf4\xcc\xdd\x31\xbb\xa1\xe2\xc8\x72\xd7\x00\x03\x57\x32\x71\x7b\xb0\x00\x7e\x58\xf5\xb7\x56\x31\x29\x66\xbe\xff\xd4\xf7\x7a\xde\x01\x7e\xe0\x9e\x5f\x39\x2d\x23\x8a\xad\x50\x91\xbf\x51\x3f\x43\xef\xf9\x2b\xfd\xd5\x53\x9f\xe7\xe8\xb3\x0f\xe5\x5f\x65\xb3\x0d\xe9\x79\xbf\xde\xe0\xce\xe3\x12\xa8\x65\xcb\x22\xbb\xfa\xe5\x21\xc2\x31\x01\x7c\xd9\x12\x10\xa4\x9a\x40\x88\x8a\xb2\x12\x95\xb9\x48\x9a\x17\xd2\xa2\x10\x75\xd8\xe5\x34\x27\x0a\x52\x2c\x1d\x15\x23\x78\x2e\x14\x41\xd1\x0a\x72\x2f\xf7\xcd\x35\x20\x76\xc5\xed\x0b\xbf\x68\xb9\xf6\xc0\x5f\x93\xe4\x13\xf2\x49\xf2\xaf\x07\xf6\x34\x7f\xb1\xf0\x76\x3f\xb4\xed\xbb\x6a\xdd\x3f\xd7\x5d\xb5\x0f\xda\xf0\xbb\xef\xbe\x4b\x1e\x63\xb3\xdf\x32\xc1\xed\x1a\x76\xa6\x8b\x99\x76\x0e\x06\x17\xbe\xdd\xbe\xe5\xfe\xfb\xb7\xb4\xbf\x5d\x48\x9e\x3f\x37\x8d\xe9\x3a\xb3\xab\x84\xfc\x72\x48\x34\x3a\x04\xca\x4a\x10\xe5\xae\xcb\xf3\x43\xf7\xec\x29\x18\x4e\x59\x43\x36\xa1\xeb\xd0\x03\xe8\x71\x74\x5a\x95\x0e\x3d\xcc\xd5\x79\x2a\xf7\xcb\xae\xe1\x3f\x84\x47\x7a\x8c\x9a\x42\xff\x29\xe6\x7f\x0e\x0f\x24\x13\x1c\x4b\x81\x1d\x9a\xd9\x70\x31\xeb\x67\xad\x97\x45\xb1\xf6\x12\x87\x82\xc6\x12\xa9\x51\x45\xf6\x39\x71\xe6\x5b\xbd\x73\x2f\x7b\x15\x8c\x15\x0f\xbe\xf8\xbf\xb9\x0b\xb2\x39\x42\x76\x90\x1d\x39\x62\x8d\x8f\xbd\xf1\x09\x30\x42\x33\x14\x3e\x79\xe3\xd8\xb8\xb5\x2f\x8e\xe2\x21\x59\x8f\x72\xae\x8f\x47\xb4\x8f\x5d\x94\xac\xf9\x36\xdf\xfd\x8a\x67\xfb\x76\x8f\x92\xfb\x5f\xdc\x02\xd7\x1b\x0d\x8b\x31\x2c\x30\x18\xad\x89\xf6\x91\xa3\xea\x23\x91\xfa\x51\x23\xdb\x13\x64\x4a\x5f\x8c\x89\xdb\x3d\x8a\xe2\xd9\xde\xab\xf7\xcb\xe3\x22\xd8\xa9\xf5\x4e\x5d\x1e\x07\xac\x57\x2e\x89\xa9\x78\x80\x2a\xfa\x7a\x3c\xa8\x2a\x21\x26\x43\x2f\xb4\x1b\xd7\xeb\xc2\x9d\x8a\x5b\x71\x13\xe4\x56\xce\x0b\x4e\xfc\xc7\x8b\x88\x45\xda\xa5\x5b\x81\xa3\x4e\xa1\xfb\x2c\x39\x64\x33\x41\xb1\xc9\x86\x0f\xf5\xb8\xd8\xce\x1c\x72\x2b\x39\xda\x55\x60\xc4\x2c\x91\x73\x19\xdc\xd9\x9d\x25\xf9\x4e\x41\x71\x33\x48\x86\xf4\xb9\x3e\xd2\x73\x6d\x9c\x4b\xd3\xec\x53\x47\x9c\x76\x01\x64\x81\x67\xa3\x10\x4a\x82\x62\x6b\x01\x19\x52\x31\xea\x09\xa9\x18\xff\xeb\x48\x84\xac\x3c\x70\xe8\x41\xd2\x70\x8a\x1c\xf8\x11\x2c\xdd\x52\xfd\xe0\xa1\x03\x70\xb3\xb2\x74\x44\x84\xac\xfa\x1c\x6e\x51\x96\xb2\x0d\xca\x12\x85\xac\x3a\x70\xe8\xc1\xea\x2d\x34\xca\x29\x78\x45\x8d\x73\x4b\x64\xc4\xb2\x08\x59\xf9\x39\xdc\x1c\xa1\xba\x7f\xd7\xc5\x42\xfe\xbf\x29\x6f\x9f\x03\xd5\x53\x56\xa2\xfe\x28\x08\xdf\xc2\x75\xe9\xe7\x62\xa9\x78\x8a\xc2\x7b\xa6\xe4\x98\x1f\x37\x73\x69\x5e\xb0\x69\xbb\xef\xd2\x0c\x55\xfb\xe7\xf9\x12\x44\x4a\xbe\xe0\x07\x39\xdf\x07\x38\xac\xe9\x94\xc4\x2c\xd9\xf6\xf8\xb6\x6d\x8f\x6f\x83\x7f\x6e\x9d\x3e\x6d\xdb\xb6\x69\xd3\xb7\x7e\x92\x19\xd3\x75\x74\x42\x43\xf9\x8c\xa1\x33\xe2\xd3\xbc\x93\x70\xab\x87\x67\xdd\x21\x61\x25\xd7\x22\xb7\x2a\x43\xe3\xc3\x9b\x46\xfc\x74\x53\xd7\xc4\x65\x83\xd6\x2d\x1e\x3d\x99\x05\x5d\x40\x00\x76\xca\x98\xc5\xeb\x06\x2e\x99\xd0\xb5\xc9\x55\x16\x65\xcd\xcc\xec\xc1\xec\x67\x83\x67\x3b\xa2\x65\x8c\x77\xc2\x86\x0d\x13\x26\xae\x5f\x3f\x31\x7f\x26\x5f\xe3\x83\x53\x86\xb7\xce\xcc\xcd\x91\x83\x92\x59\x00\x16\xbc\x3c\xe3\x72\xcf\x60\x19\x00\x86\x2f\xb0\xc8\x45\xce\xdb\x17\x91\xdf\x3d\xb9\x3a\x54\x5c\x1d\x5f\x0d\x6d\x80\x75\x40\x4e\xac\x89\x55\x17\x87\xd7\x3c\x09\x9e\x45\xb7\x47\x12\x1e\x6c\x60\xf0\x53\xc3\x16\x2e\x1c\x96\x1b\x61\xf6\x24\xd4\x32\x9b\x7f\x31\xcb\xdf\x93\xd7\xd3\x9a\x91\x4b\xad\x59\x94\x4e\xcc\x2a\xa6\xad\x01\x6b\xc0\x91\x06\x2b\x04\x84\x50\x32\x60\x15\x99\xec\x2d\xb8\xe8\x96\x5b\x72\x5d\x93\xa1\xed\x2c\xe3\x25\xa3\xc9\xb3\x67\xcf\x92\x35\x2b\xd8\xd1\x64\x34\x3c\xae\x1e\x39\x1d\x61\x3c\x5d\xff\x7d\xf6\x2c\x7b\xac\xbb\x80\x8c\x3e\x7b\x96\xbd\x16\x02\x5a\x1d\x9e\x76\x11\xb8\x63\x5c\x0e\x49\xa8\x1c\xb5\xa0\xd1\x68\x81\x2a\xa9\xb0\x5a\xd4\x74\x10\xa5\xcd\x82\x29\x80\x67\x94\x37\x03\x4b\xf7\x35\x2a\xcd\x20\xc7\x64\xba\xf5\x0d\xd4\x0e\x30\xaa\x30\x14\x9c\x33\xcf\xf3\x00\xea\xb7\x01\x85\xc2\x7a\xca\x92\x8d\x93\x04\x9e\xe3\x85\x34\xaf\xa1\xad\x52\x93\x1a\x3f\xc8\x0c\x07\x5c\x61\x34\x75\x31\x64\x64\x81\x63\x1b\xef\x80\x06\x73\x8d\xcb\xe9\x39\xc0\xd4\x6c\x24\x7f\xb6\x86\xc4\x42\x4e\x67\x2b\x0b\x19\x9f\x1f\x5a\x31\x51\x76\x31\x75\xc2\xc3\xf1\x88\xdb\x74\xac\xda\xc4\x59\x43\x03\x60\xfd\x99\xd1\x3a\x6f\x6e\x3a\xd7\x50\x5f\x4b\xae\xd5\x79\x4a\x61\x54\x7d\x89\x9e\x51\xf0\x41\xc6\x67\x26\x3f\x1d\xec\x04\xb9\xca\xe4\xf7\xc3\x88\x6b\x62\x7a\x6f\x64\xc0\x01\xfe\xec\x36\xf2\xa1\xb1\x58\xa7\x9f\x5d\x66\x76\x14\x9a\x0c\x23\x9e\x68\x13\x0b\xf4\x06\xe5\xd3\xb4\x39\x3a\x15\x07\x5d\xb1\xf6\x1f\xb5\xe2\x51\x3e\x5b\x50\x5f\x4e\x4e\xa7\x7e\x69\x37\x39\x0c\xe0\x18\xe5\x88\x39\xca\xad\x10\x1d\xe4\x11\x24\x3c\x6e\xa1\xdd\x3a\x15\x4f\x0e\x79\xca\x67\x99\x0d\x21\x5b\xee\xa5\xd7\xa2\x76\x43\xbb\x59\x87\x79\xbb\x54\x5d\x02\x0b\x1e\x19\xc4\x8b\x56\xf9\xa3\x3a\xba\xbf\x5f\xd3\xe3\x64\x2f\xd9\xfb\xe0\x41\x21\x54\x41\x39\x6b\x02\xd6\x00\x1d\xe5\x59\x29\xcc\x63\xf2\x92\x43\x1d\xc3\xd2\x45\xc2\x80\xd5\x2e\x5c\x02\xe9\x10\x48\xb2\x88\x64\x21\x9b\xcd\xd1\x9d\x1a\x1c\x22\x08\xf7\x3b\xba\x51\x56\x49\x28\x7c\xf6\x02\x2a\xe0\xce\xb8\x95\xec\xaa\xb1\xe7\xb3\x63\x57\x01\x52\x6f\xba\x88\xb2\x59\x06\xd1\xfb\x50\xaf\x3e\x9e\x1e\xdd\x19\xa6\x53\x03\x12\x66\x33\x5d\x9d\x81\x22\x85\xfd\xa0\x8b\xda\xaa\xb2\x99\x2c\x62\x51\x19\x32\x0a\xbf\xa4\x78\x0b\x45\xa8\x0e\x8d\x43\x28\x9c\x6f\xb5\x0e\x7b\x3a\x58\x05\xc1\xfc\x2e\x9a\x74\x33\xc4\x34\xf8\x79\x8a\x7f\x15\x0a\x9a\x18\xcd\x3f\x15\x2e\x66\xa9\xbf\x18\x8c\x2a\xe1\x62\x36\x8f\x0b\xd6\xe7\xcf\xda\x4b\xf6\x5f\x33\xfe\x9a\xc5\xb8\x7d\xdb\x8e\x6d\x23\x19\xdb\x1d\x86\xd1\x7f\xfa\xc3\x9f\x46\x1b\xee\x40\x17\x0b\x0a\xf7\xfe\xf1\xce\x49\x8f\x6c\x9b\x5f\x8f\xad\x07\x0c\xbb\x60\x23\x64\x61\xe3\x2e\xc3\x01\x52\x50\xf0\x04\xd9\x46\x6a\xc9\xb6\x27\x0a\x0a\xac\x77\x18\x9e\xc3\x2c\x76\x63\xf6\x39\xc3\x1d\xc6\x5b\xed\xc5\x15\x15\xc5\xf6\x2d\xb1\x58\x2c\x76\xc0\x66\x34\x8c\x9a\x3a\x75\x94\xc1\x68\x3b\x00\x16\xdd\x92\x2b\x2a\x9a\x9b\x2b\x0e\xd8\x0a\x0d\xbb\xf6\xef\xdf\x65\x28\xb4\x1d\x00\xb3\xfe\xde\xfb\xef\xbf\x57\xaf\x46\x7c\xf6\xcd\x37\x9f\x55\x23\x22\x64\xd4\xf6\xcd\xd0\x75\xcc\xfe\x5a\xa9\x16\x34\x12\x4d\x40\x57\xa0\x65\xe8\x6a\x84\xd8\xcb\x38\xe1\xd0\xff\xf2\x0c\xd6\x3c\x8a\x88\x14\x4b\xf5\xf7\xeb\x8f\x75\x67\xe9\x67\x83\xdd\x7f\x8c\x0b\xd9\x91\x4b\x47\x8e\x5c\x0a\x67\xe8\x89\x68\x27\x66\x64\xff\xab\x6f\xf5\x64\x46\xb6\x2f\x6e\x6f\x5f\xdc\x4e\x7a\xee\xef\xd9\x8e\xc7\x21\xb7\x42\xbd\xce\xb4\x27\x2e\x50\xcd\x39\x97\x4d\xb4\x27\x97\x6a\x77\xab\x7f\x70\x86\x9e\xc8\x99\xfe\x57\xdf\xea\x99\xcb\x42\x9f\xf6\x1e\x5f\xd4\x82\x3a\x29\x2c\xb5\x36\xdf\x20\x87\xa9\x1f\x83\x2e\x20\x35\x1e\xaf\xfe\x22\x8c\xf4\x17\x11\xf7\x57\x1e\xa1\x28\x1a\x42\xd7\x41\x70\x20\x14\xe4\xcd\xc0\x08\x26\xa0\x9b\xa0\x9a\x99\x74\xaa\x01\x28\xfd\x0d\x15\x20\x92\x2c\x45\x35\x4a\x27\x7b\x28\x1a\x14\x78\x86\x16\x51\xba\xc7\x22\xdd\x0f\xdc\x5f\x6d\xd2\x14\x12\xac\x70\x29\x1c\x9b\xc6\x5c\xd4\xd5\xe5\x70\x32\xfa\x90\x2d\xac\xe7\x94\x9d\xbb\x17\x3d\xba\x6a\x61\xd2\x59\x00\x0c\xcb\x8e\xb9\xab\x6a\xec\xc7\xab\xf7\x4d\x9f\x3e\xdf\x86\x27\x40\x01\x39\x2b\xf9\x98\x3f\x72\x95\x3e\x3c\x39\xb8\x6d\xc0\xb2\xd5\xcc\xe6\x89\x1b\x49\x6b\xc0\x2d\x92\x23\x66\x77\xc0\xef\xa8\x3d\xb7\xea\x37\xb5\x11\x2c\x47\x97\xcc\xb9\xa3\xad\x85\x67\x80\x69\x78\x62\xd9\xf6\xcf\xc6\x97\x60\x80\x0e\x5d\xee\x9f\x86\x80\xc4\xbd\xe8\x53\xdc\x62\xe9\x0f\x54\x19\x1e\xcd\xf7\xb5\x06\x64\x43\x2e\x54\xa2\xce\xaa\x64\x24\x06\x30\xa3\xa4\xe2\xc0\x0b\x98\x49\xa5\x6d\xa2\x4d\xf5\xd1\x83\x85\xc1\x40\x03\xd4\x1c\xd8\xe0\x54\x40\x04\x43\x07\x19\xb4\xed\x8b\x42\x9b\x9d\xf9\x41\x4d\xfb\x98\x93\x25\xec\x2f\x3e\xf9\x1f\x28\x0f\x91\xa6\x52\x82\xd8\xc5\x0b\x06\x93\x0f\x5d\xe3\x58\xd1\x02\x8b\x1c\x21\x6e\x2d\xd3\xe1\x26\xb7\x91\x85\x70\x0a\x12\x96\x10\x39\xf8\xea\xcb\x90\x02\xef\x47\x9f\x92\xe3\xf0\x3d\x72\x3a\x27\x92\xd5\xf8\x2e\x26\x9a\xeb\x24\x53\xc9\x16\x3c\x00\x17\x40\x25\x78\x2c\x2e\xb7\x9d\x2c\xd2\x74\x23\x7a\x6d\xdf\x88\x19\x39\x91\x17\x35\x6b\x3c\xf4\x10\x4a\xb5\x40\x33\xa4\x65\x8e\x51\x42\x01\x81\x8d\x50\x5a\x20\x31\x0e\x4c\x5c\x0c\x71\x74\xa7\x08\x2f\xe7\xd7\x53\xab\x41\x90\xe2\x52\x2a\x9d\x88\x6a\x8b\xf8\xa9\x22\x88\x84\x82\x02\x13\x4f\xc7\x25\x39\x7e\x79\x2d\x16\x9e\xbe\xde\x94\x60\xd8\x42\xa6\xf0\xc2\x8e\xfa\x82\x0c\xf9\x3b\x86\x34\x98\x1f\xb0\xba\xd7\x0f\xdb\xf3\x28\x70\x91\x23\x8b\x8f\xe0\x3b\x87\x8c\xbd\xfa\x1e\x80\xfd\x03\x94\xc6\xe8\xe4\x36\x49\x1e\xb1\x72\xc7\xbd\xf8\x86\x9a\x8a\x9a\xaa\xb6\x94\x19\x3a\xb3\x03\xa5\x7f\x9e\x08\xbd\xc7\x99\xef\xce\xb6\x27\xbe\xa6\xd5\x49\x87\x12\xed\x38\x18\xb9\x49\x6f\x28\x36\xa4\x37\x42\x34\x65\x1c\x33\x93\x8c\x98\xd6\xb6\xc1\x47\x30\xde\x9e\xdb\x8a\x77\x58\x3c\xeb\x67\x2f\x1c\x26\x87\x1d\xfe\xe2\x40\xc1\xcd\x41\xd8\x38\x7f\x69\xab\x2b\xe8\x90\x02\xe0\xd2\x1d\x4c\xe5\x9e\xec\x90\x46\x30\x2f\x77\xd1\x87\x71\xb4\x6e\x3a\x7b\xcb\xc6\x8a\x5c\xa8\x1c\xc5\x51\x06\x0d\x45\x53\xd1\x15\x68\x11\x5a\x8d\x36\xa3\x7b\xd0\x33\xe8\x55\xf4\x7b\x74\x1e\x0a\xc0\x05\x95\xd0\x08\x23\x60\x2a\x5c\x0d\xfb\x10\x02\xa5\x87\x9c\x23\x1e\x4b\x2b\xd8\x96\xe6\xb1\x4d\x4e\xd9\x70\x54\xb2\x61\x81\xae\xa9\x27\xe9\xba\x1a\xc4\x93\x21\x47\xdc\xd1\x80\x93\x21\x21\x1a\x72\xc4\x93\x72\x3c\xcd\x38\xca\x21\xd9\x00\x8e\x78\x34\x16\x4f\xa7\x12\xd5\x10\x2c\x07\x47\x3c\x19\x0f\x27\x7a\x95\xfa\xe1\x98\x1c\x62\x35\x59\xcc\x87\x82\xa9\xbc\x2b\x28\x07\xa3\x41\x85\x6a\x53\x12\xe9\x54\x4d\x2c\x49\x4d\x5b\x6b\x64\x87\xe4\x10\xbc\x10\x12\xf8\x10\x1f\x89\x27\x13\x4a\x34\x28\x68\xec\xc7\x8e\x78\x32\x11\x8f\xf9\x80\x9e\x1c\x72\xbc\x09\x42\x8e\x9e\x69\x76\x0b\x24\xaa\x41\x51\x03\xe4\xb4\xb6\xf2\x4b\xd7\xd1\x43\xc1\xa8\x9a\xfe\x14\x5d\xe4\x6d\x52\x93\x9f\x0c\x39\xd4\x2c\xd8\xe3\xb1\x74\xcf\x2e\x2f\x35\x2c\xaa\xbe\x29\xde\xf7\x16\x39\xad\x48\xf9\xc0\xa8\xb6\xa5\x88\x3e\xf7\xf2\x97\x5e\x72\x43\x3e\xb0\x27\x4c\x08\x86\x78\x81\xa7\x7a\x39\x3b\x5d\x9c\x4c\xab\x13\xe3\x74\x2a\x99\x88\x2a\x51\xb5\x9c\x94\x6f\xe0\xfb\xcc\xc9\xde\xb5\xe8\xf9\xbd\xe3\xc6\xed\x3d\xbd\xf8\xae\xec\xce\xd9\x73\x1e\xdc\x3a\x73\xc6\xb6\x6d\x33\x66\xce\xda\x31\x67\xf6\xce\xec\x5d\x8b\x4f\xab\x61\xcf\x2f\xba\x0b\x2f\x10\xac\x02\xe3\x63\x39\x9e\xe7\x18\x9e\xe5\x74\x98\x61\x30\xc3\x52\x1a\x58\xc0\xc0\x33\xd0\x25\x49\xa2\x4d\x92\x6c\x22\x1c\x6e\xe4\xda\x60\x8f\x14\x96\x25\xd1\x76\x41\x0e\xcb\x72\x78\x0f\xc6\x40\x4d\x60\x31\xc6\x0c\xb0\x98\xde\x84\xe1\xc2\x69\xbf\xcf\x55\x6c\x36\x15\x39\xcd\x7e\x7f\xc0\xef\x0b\xf8\x8f\xf8\x7c\x56\xb7\x4f\x51\x7c\x5e\xf3\xe3\xd5\x26\xd9\x25\xdb\x0b\xa5\x80\xdb\x5f\x6d\x74\x16\xb9\xec\x46\x57\xc0\x17\xd8\xa1\x33\x1a\xc5\x01\x03\xfc\x5e\x6f\xb5\x63\x81\x4f\x89\xfa\x03\x92\xc9\xe6\x08\x0a\x0b\xc2\x3b\xe5\x42\xbf\xdf\x67\xd0\xe9\xf5\xb6\x68\xc0\x27\x9a\x6c\x56\x9b\x2c\xdb\x44\x8b\xc9\xee\x0d\xbc\xed\xf7\x9b\x3d\xbe\x68\xd4\xe7\x35\xed\x96\x0b\x7d\x3e\x35\x9a\x6e\x9b\xcf\x67\xae\x8d\x46\xbd\x3e\xd3\x68\xac\x26\x4d\x1d\x91\x62\x96\x61\xb1\x7a\x45\x53\xa8\xa6\x7a\x51\xff\x06\xc4\x3e\x32\x69\xdc\xde\xd3\x8b\xd4\x62\x99\xb4\x0c\x9a\xa0\x71\xc2\x15\xe4\x17\xe4\xbd\x2b\xae\x80\x0a\xa8\xbc\x7a\x19\xf9\x31\xf9\xf1\x52\x35\xc6\xe2\x45\xa7\xf7\x8e\xeb\x3e\xcb\x30\x56\xbb\xd1\x68\x37\x1b\x8d\xa4\x0e\x33\x06\x0e\xd4\x52\x30\x72\x15\x8a\xd3\x65\x13\x9d\x53\x8a\x8b\x34\x87\x2b\xec\x52\x4f\x3e\x60\x69\x2a\xb0\x56\x3e\xac\x9a\x08\x4c\x13\x31\xc9\xe9\x03\xa7\xd3\x6e\xd9\x33\x32\x1c\x1e\xa9\x1e\xad\x83\x2d\xf6\x92\xe6\x12\xbb\x33\xc8\x63\xd6\x60\x2e\x70\x9a\x9c\xf6\x80\xea\xb4\x9a\x64\xab\xd3\xe4\x12\xa4\x26\x4f\x69\xa9\xa7\x29\x76\x53\x49\x51\x71\x54\x94\xcc\x81\xc2\xe2\xa8\xdd\xb2\xa7\x3d\xc4\x7a\xd9\x92\xe6\x12\x8b\xd3\x08\x4e\xc5\x59\xe8\xb4\xec\xeb\x79\xd4\xe6\x9e\xe0\x7d\xad\x9b\x87\xda\x4b\x1b\x4b\xed\x8c\xfa\xc5\xd4\x12\xc1\x34\x15\xea\x3f\xf5\x9b\x63\x6a\x4b\x0d\xec\xef\xfb\x8b\x02\x8d\x9f\x9e\xca\x02\x03\xb2\xd2\x95\xbf\x41\x68\x0a\x9a\x87\x96\xa2\xd5\xe8\x1a\x74\x3d\xba\x9b\xb2\x1c\xf2\xe5\x14\xff\x55\x8a\xd8\xa9\x83\x4b\x28\xe5\x60\xed\x21\x87\xe7\xf2\x3a\xe4\x54\x5f\x93\xa2\x44\xa1\x1a\xc6\x35\x6d\x55\x54\x97\x9c\x37\xf4\x49\xf6\x34\x0a\xb0\x9a\xa0\x10\x73\x81\xbe\xf1\x42\x84\x32\xd1\x8b\x69\xb5\xf5\xe5\x0f\x88\x53\xcb\x2b\xf5\x75\xc9\x6f\x68\x0d\xa1\x2e\xec\x6b\xb4\x5a\x9b\xbc\x61\xfe\x8b\x8c\x68\x6f\x39\x3f\x61\xfe\x98\x39\x73\x46\x54\x36\xfa\x07\x0e\x84\x4c\x69\xda\xe7\xf0\x38\x7c\xce\x60\x69\x5d\x45\x63\xb8\x2a\xa2\x13\xbd\xd2\x00\xb9\xac\x62\x68\x3c\x03\x52\xa4\xb4\xa6\xa5\xa5\xaa\x5c\x29\x29\x19\xb1\x68\xe1\x88\x32\xf6\x5f\x03\xef\x27\x3f\x21\x0f\x13\x3b\x21\x7c\xc0\xad\x74\xff\x70\xe9\x81\xa5\x4b\x0f\x00\xbe\x79\xe8\xf4\x69\x43\x6f\x7a\xf7\x99\x0d\x6b\xd7\x6e\x78\x06\xf6\x8c\x5d\xd2\xde\x5c\x3b\x77\xa0\x1e\x02\xa3\xd2\x5f\xeb\xd2\xa3\x46\xa5\x85\xaf\xd3\xa3\xf0\xbf\xe2\x01\xf7\x87\x9e\x22\x63\x62\xc1\x9a\x11\xb3\xc8\x13\x4a\x7c\x1a\x8c\xfa\x63\x49\x85\xdd\x60\x33\x59\x1c\x9e\x8a\x48\xba\x24\x54\x6a\x31\xf2\x85\x92\xdd\x53\x51\x92\x69\x2a\x1d\x15\x19\x18\x1b\x30\x58\x19\x65\x5f\xb0\x7f\x41\xee\x69\x6c\x2e\x99\xba\x7f\xfb\x0d\x03\x14\xfc\x13\xf5\xa5\x4b\x75\x30\xf9\xdc\x39\x72\x4c\x5f\x3b\xbd\x76\x44\x1d\x79\xe2\x06\xcb\xe8\xea\x04\x79\x62\x37\x0e\x77\x15\xd6\x8e\x1e\x5d\xcb\xfe\xbd\x76\xf4\x68\x75\x38\x6e\xeb\xfd\x76\x18\x15\x20\x13\x72\x20\x2f\x0a\x21\x05\xd5\xa3\x31\x68\x06\x7a\x1b\xfd\x16\x9d\x07\x0e\xf4\x10\x86\x16\x98\x87\x90\x18\x8f\x42\x5a\x15\xc6\x8e\x90\x23\x22\x27\xe5\x84\x2a\x7e\x63\x11\xed\x04\xda\x89\x8b\x47\x23\xd6\x50\x52\x08\x45\x1d\xa1\x68\x48\x08\x89\x71\xd1\x1a\x97\xd3\x60\x37\xb1\x41\x25\xe4\x08\x45\x85\x80\x35\x20\xa7\xe3\xb1\x88\x23\x64\x8d\x3b\xb4\x87\xf5\x6e\xe2\xb2\xc6\xd3\x71\x99\xca\x7a\x47\x20\x99\x8e\xf9\x20\x90\xf4\xe3\x54\x8f\xa7\x35\xe4\x88\xaa\x7f\x54\x14\xaa\x7d\x2f\xbd\x12\x7a\xe7\xb8\x34\x20\x28\x24\x03\x0e\xa5\x1c\xd4\x43\xa0\x7b\x90\xe4\x78\x32\x1e\x4b\xab\x1d\x85\x86\x93\x9e\x56\x13\x6d\xe7\x05\x3f\xf8\x20\x44\xab\x86\x9a\x94\x18\x55\xd1\x51\xbf\x44\xaa\x8a\xa1\x9e\x72\x4c\x82\xfe\xc9\xb4\x86\xac\xa0\x55\xe0\x64\x42\xd1\xf6\xd7\x37\x80\x23\x14\x74\xd8\xa5\x94\x1f\xd2\x0e\xbe\x27\x8c\xa7\xfa\x88\x7c\x98\x1f\x18\x6b\x4f\x71\x04\x93\x89\x06\x70\x04\x15\x13\x4b\xb1\x2f\xd2\xb4\x74\x92\x1b\xa6\x55\xe2\x81\x23\xda\x1e\xbc\xe9\x26\x68\xba\xe2\xf9\x92\x89\x13\x4a\x21\x50\x36\x7e\x5c\x39\xf9\x5c\xfd\x85\x33\xd3\x2a\xba\xa5\x41\xb3\xeb\x66\xef\x72\xed\x71\xb5\x5d\xd5\x71\xe5\xd2\x49\xa3\xf0\x9d\x05\x56\xaf\x33\xea\x2c\xd5\x6f\x1d\x3b\xe1\x22\x02\x76\xec\xf8\x77\x56\x90\x8f\xce\x9e\xbd\xf3\xb6\xdb\xb8\xf7\xb4\xba\xb5\xd2\x95\x76\x7d\x20\xae\xb6\x63\x9f\xc1\x00\xb2\x9c\x29\x9d\xa4\x77\xd5\xba\x7e\x17\x7c\xea\x49\xd7\x29\xf9\xfc\x90\x92\xe3\xce\x9a\xdc\x0d\xe5\xe5\x3f\x95\x1e\x1e\xad\x55\xc3\x8d\x71\xff\xc9\xb4\x4c\x7e\x52\x54\xfb\x33\xb9\xf5\xf3\x54\x8c\x3c\x08\x53\xd2\x89\x5f\x38\x1a\x8a\x4e\xe8\x74\x2c\xb6\xd6\x15\x1d\x6d\xcc\x55\x3a\x25\x97\x6d\xa0\x33\x38\x64\xe0\xdd\x03\xea\xc9\xff\xb8\x1c\x6e\xeb\x40\x00\xae\x50\xb6\xb5\x65\xee\xaa\xa9\xc7\xd6\x5f\xfd\xea\x8e\xdb\x6e\x23\x7f\x1e\x84\xff\xb5\x70\xeb\xd6\x60\xb0\x26\x16\x4c\x94\xec\xd8\x10\x0e\xd5\xd4\x84\xfe\xea\xcc\x5c\x73\x4d\xc0\x15\x29\x8f\xb8\x92\x25\xdb\xd7\x87\xeb\xc7\xdc\x36\x73\xf3\x2e\xf7\xb5\xae\x91\xdb\x77\xb7\x08\x65\xe6\xa2\x42\x2b\xef\x09\xfb\x66\xce\x5d\x71\xc5\x1a\x66\xf2\xf2\xdc\xb5\x63\xc6\xd4\xa4\x53\xa3\xaf\x3c\xdb\x18\x18\x52\xe2\x6b\x82\xaf\x7c\x8d\xca\xf2\x6a\xf2\xe5\x7b\xef\xbd\xf7\x5e\x63\x23\x98\xc9\x45\x80\x67\x9e\xc9\xbd\x67\xf7\xdb\x8d\x02\x86\x19\xd3\xa7\x83\x79\xda\xb4\xee\x5a\x30\xd7\xd5\xa4\x53\xb9\x9f\xfd\x3e\x3d\x66\x4c\x1a\x1f\x69\x6a\xaa\xaa\xaa\xae\xbe\x02\x4c\x93\xe5\xc2\x42\xc0\x4d\x4d\xf5\xf5\xb0\xb9\xa2\xa2\xa2\x42\x92\x24\x69\xee\xdc\x8a\x8a\x27\x60\x8f\x1a\x33\x37\x5d\xca\xff\xab\xaf\x27\xd7\x36\x34\x4c\x33\x2e\xbc\x82\xd5\x4d\x71\x3a\xbb\xe4\x12\xbd\x3e\xe8\x4b\x55\x06\x1c\x57\x80\xd9\x0f\x47\x9d\x25\x7a\x7d\xc0\x9f\xd4\x87\xcc\x92\x41\x98\x07\x66\xf0\xe5\xae\xaa\x05\x73\x6d\x4d\x3a\x85\x1f\x26\x5f\x82\x39\x77\xd5\xe4\x7a\x97\xc5\x20\x28\xe1\x68\x59\x9d\xcb\xa2\x07\x3e\x62\x5a\x10\xaa\x77\x19\x0b\x81\x2b\x88\xf8\x55\x4f\x3b\xcb\xe3\x41\xe4\xab\x33\x67\x1a\x1b\x77\x5f\xdf\x80\x81\x31\x58\x7d\xa2\x52\xf2\xfe\x45\x04\xe8\xf4\x69\xb5\x7d\x16\xf4\xb6\xcf\x02\x24\xa3\x10\xaa\x47\x13\xd0\x95\x68\x37\xba\x1f\x9d\x40\xa7\xd0\xeb\x79\x36\xaa\xfc\x3a\x51\xc4\xce\x87\x04\x75\x46\x10\xf3\x43\xff\xf5\xa3\x08\x05\x1d\x11\x18\x5e\x6a\x80\x58\x0b\x34\x63\xaa\x25\xe3\xc4\x14\xf5\xee\xb7\x7b\x9b\x77\xd8\x1b\x40\x9d\x8e\x95\x43\xd0\x0c\x94\xc8\x9f\x1a\x07\xc8\x5a\x40\x1a\xfe\xbf\x9f\x64\xd7\xee\x10\x93\x09\x1a\x5f\xa0\x70\x27\x69\x30\x41\x3e\x81\xd2\xe5\x72\x18\x7f\x16\x8f\xf8\x42\xb1\x88\x37\xc2\x58\x2b\x2a\x8a\xad\xb8\xc0\x26\xb9\x9d\x30\x27\x1e\xf6\x85\x55\xdf\x0b\x47\x47\x35\x1f\x12\xf1\x40\xd0\xf1\xed\x76\x6c\x83\x42\x9b\x45\x62\x26\xcf\x83\x64\xa9\xea\x63\x62\x3c\xad\xc3\x16\x0c\xa9\xf7\x36\xda\x58\xe3\x10\x11\x5e\xd6\x71\xa3\x0a\x84\xa5\x15\x9c\x75\x24\xa7\x8b\x56\xc2\x78\xe3\xa8\x02\x01\x5d\x84\xad\xa3\x9a\xef\xb7\xd3\x87\x8c\x2f\x64\xbf\xf9\x10\xf7\x10\xf5\x21\xbe\x46\xab\xfa\x90\x8f\x8c\x23\x0a\x68\xd4\x41\x22\x3e\x3f\x9c\x2b\x8b\x06\xac\xb8\x40\x2c\x09\x0b\x6b\x2e\x19\x57\xaf\x8f\xd4\x14\x7b\x23\xf1\xc0\xc6\x32\x3f\x2c\x2b\x60\x1d\x0f\x87\x63\xf4\xfa\xa6\x86\xa4\x48\x16\xf3\x06\xf1\x4a\x9d\x81\xc1\x73\x7f\x0b\x1c\x6f\x08\x94\x2c\x1f\xde\xd0\xe6\xb4\x17\xea\x2d\xe0\x30\xe8\x0d\xf7\x1c\xb0\xe8\x39\xbc\x66\x17\xbb\x4a\x67\x34\xc0\xaa\xda\xfc\x2d\xc6\xab\xbe\x79\x0b\x58\x58\x0b\x1c\x07\x53\x01\xe9\xc0\x9c\x5e\x04\x31\x24\xc1\xb2\x02\x19\x7e\x73\x49\x57\x8c\x0c\xfd\xfa\x62\x33\x8a\xa1\x61\x68\x0a\x9a\x81\x96\xa3\xab\xd0\x3e\x74\x50\xeb\x87\x43\xc1\xa8\x3a\xfa\xe5\x42\x29\xda\x0b\xd3\x7e\x37\xdf\xed\x0a\x79\x44\x6e\x75\x2c\xab\xd0\x6e\x37\x9d\x82\x74\x28\x69\x66\xe2\xf9\x6d\x94\x9a\x41\x17\x47\x3b\x60\x21\x1a\xb2\xc6\xad\xa9\x78\x4c\xa4\x3d\x38\xdd\xe5\x1a\xcd\xa3\x49\xa6\xfb\x26\xf0\x34\x80\xcf\xdf\x4f\x87\xbf\x4a\x34\xfe\x0d\x4c\x4e\xbe\xc9\x21\x06\x64\x9b\xcf\x5b\x07\x4f\x5d\xc9\xc7\xe2\xe7\xff\x34\xa8\x35\x5c\xac\xd4\x0f\xb2\x0d\x1e\x3f\xaa\x6a\xc0\xc0\xc1\xd1\xa2\x01\xbe\xf1\x45\xb6\x61\x1d\xe3\x06\xc4\x21\x2a\x76\x6c\xb7\x55\x59\x9b\x2b\x94\xe1\xc5\xd5\xc5\x85\x65\x70\x9d\xd9\x58\x5c\x6d\x30\xec\x3c\xe0\xae\xb5\x54\x1f\x38\x80\xaf\xac\x2c\x19\x9a\x49\xea\x76\x1d\x08\x17\x4f\x88\x37\x91\x8a\xaa\x41\x55\x55\x83\x98\xc7\x06\xc4\x66\x77\xac\x6c\x49\x2f\x5d\xd0\x60\xa9\x1b\x5a\x6e\x97\xb9\xaf\xf1\xa5\xb3\xa4\x4d\x43\x22\x21\xfd\x39\xff\xe4\x79\x9f\x35\x0c\x74\x19\x25\x93\x3b\xb0\xaa\x58\x89\xb6\xd5\x0f\x74\x9a\x64\x4b\x91\xcb\xb6\xba\x34\x52\x0a\xa1\x95\x7b\x1c\x6b\x74\x8b\x7e\x3d\x31\xec\x2f\x58\x2f\xc4\x5e\x71\xed\x63\x8a\xfd\xb5\xa4\x14\x62\x45\xe4\x51\xf8\xaf\x8f\x37\xd7\x25\x6a\xab\x73\x57\xbb\xee\x28\xa8\x1d\x08\x3f\x51\xdf\x5c\x4d\xfe\x67\x75\x4b\x66\xd7\x9a\x6c\x63\xba\x64\x51\x91\x28\x56\x9b\xf0\xc9\x4b\x3e\x1c\x83\x4c\x17\x91\xf0\x15\x8f\x68\x3b\x6f\x41\x08\x6c\xb2\x5a\x40\x76\x3e\xa8\x44\xb9\x58\x82\xb6\x65\xb5\x97\x01\x89\x17\x34\x34\xb6\x54\x0b\x28\xc9\x66\x36\x99\xb0\xa5\x7b\x16\x9f\x04\x3f\xc8\x90\x92\x64\x5e\x6a\xfa\x73\x7b\x82\x64\x0e\xbc\x77\x3b\x00\xb2\x58\x1a\x26\x15\x2f\x62\xe3\x3a\x30\x7c\xfd\x98\xc1\xa3\x9b\xa8\x03\xc3\xb3\x62\x6c\xfc\xd4\xa6\xe8\xe7\x2f\xe8\x6a\xc7\xd6\xea\xb6\xbc\x90\x84\x07\x0c\x1e\x1d\x3e\x4e\xee\x79\x2d\xd1\xbe\xf4\xc0\xed\x4b\x1f\x2d\x9e\xd4\x60\xb1\x0c\x5f\xc4\x67\x0c\x1e\xfd\xf9\x63\x3a\x6c\xe8\x30\x78\x74\xdf\x2f\x0e\x96\xcd\xbc\xf5\xd8\x57\xfb\xee\x04\xce\x2b\xda\x4b\x6a\x6b\x4b\xec\xa2\x6d\xfb\x2c\x58\xa6\xc3\x06\x6d\x3f\x5b\x5f\x3e\x24\xa4\xa0\xd1\x08\xb1\x7d\x89\x8f\xeb\x21\x4f\xcd\x68\x81\xde\xdc\xa5\x03\x0a\x93\xb6\x81\xfc\xff\x91\x31\x56\xcb\xca\xf0\xdc\xbf\x98\x15\x65\x3f\xda\x3d\xeb\xae\xe9\x03\xd8\xce\x9e\x8c\xde\x8e\xff\x71\xa4\x69\x65\x13\x0c\x9e\xf8\x1f\x33\xfa\x58\x3e\x73\xf0\x3f\xf8\xeb\xa9\xeb\x5a\xe6\x2d\x8f\x93\x2c\xc9\x68\x19\xdf\xfe\x1c\x58\xe6\x92\x7b\xd8\xa3\x1d\xff\xbf\x19\xef\xc5\x38\xe6\xb2\xbd\x7a\xae\x34\x9a\xa1\x71\x17\x52\x11\x6a\xd5\xd0\x9e\xfe\xd3\x35\x04\xa2\x4a\x34\xc0\x0b\x5c\x0f\xaf\xa0\xd6\x40\x42\x3d\x1c\x10\x69\x6d\x1d\xa7\x08\x54\x79\x89\xbe\x1d\xa6\xa9\xbf\x3b\x77\x0e\x3a\x07\x08\x06\xf2\x63\x83\xc0\xac\xb4\x99\x3a\x34\x02\x07\xaa\x70\x84\x64\x9b\x79\x74\x09\x64\x4a\x46\x9b\xdb\x20\x69\xb2\x1d\xc2\x54\x95\x93\xa3\xb7\x7e\x87\x9b\xf9\xcb\x3a\x3d\xc6\xfa\xdb\x33\x26\x5b\x77\xfb\x84\x4d\xeb\x26\x30\xcf\xd0\xd7\x3c\x14\x49\x24\x22\x0f\xd9\xfa\x61\x19\x57\x50\x4b\x47\x04\x1a\xe4\x10\xd2\x20\x5d\x18\x9f\x3a\x72\x0a\x36\xf5\xb7\x96\xea\x51\xab\xe1\xef\xb2\x41\x61\xb7\x0e\x5f\xbb\xa9\xee\x2d\xf2\x67\xb0\x9c\x09\x4e\x58\x34\xbe\xd6\xb2\xde\xb2\x73\xd8\x0d\x27\x9f\xbe\xa9\xf5\x06\x3d\xbf\x81\x37\x74\xff\x27\x1b\x15\x78\x7b\x45\x6c\x74\xb9\x04\xd2\x3b\x67\xc0\xa2\xf7\x94\x0e\xab\x5c\x61\xb1\xb4\x95\xd7\x3c\xbd\xff\x8e\x57\x06\x94\xb5\x09\x7a\x3d\x53\xfe\x9f\xac\x58\xfa\xeb\xe1\x4d\x68\x1e\x42\x34\x0f\x26\xac\xd1\x89\x02\x67\x37\x61\x21\xa8\x49\xb6\xfc\xd2\xaf\x8d\xa2\x4d\xb6\x68\x4c\x9c\xb2\x24\x30\x34\xc3\xcd\x6c\xd2\x82\x02\x41\x9a\x57\x55\x46\x4a\x45\x1a\x65\x1b\xf4\x83\x2b\x47\xcc\x9b\xcb\x66\xb7\x6c\x9e\xd7\xb4\x6c\x6e\xc7\xa1\x49\x38\x31\xe2\xea\x1b\x46\xf2\xa2\x30\xa7\xda\xcb\x25\xee\x9f\xfd\xfd\x93\xbb\x7e\xbb\x7b\xca\x5e\x05\x17\x80\x9e\x5b\xcf\xe9\x38\xbc\x91\x73\x15\x7b\xeb\xa7\x0e\x1a\x40\x7e\x40\x3e\xec\xb1\x84\xff\xf4\x64\x81\x5b\x57\xaa\x03\x6c\x58\xd8\xb5\x9b\xf2\xf8\x51\x7e\x3e\x98\x0a\x47\xf1\xf9\xe5\x9b\x9b\x96\x1f\x99\xbb\x6a\xf3\xee\x57\xad\x2b\x8f\xcf\x8b\x63\x48\x06\x62\x83\xa6\xbe\x78\xe2\x5e\x30\x1c\x1c\x9a\x11\x6b\xf9\xc2\x02\xae\x20\x77\xb7\xd3\x19\x75\x83\x3e\xda\xb4\x7e\x34\x84\x61\x66\x4f\x11\xdd\xac\xc7\x05\x35\x85\x85\x46\xfd\x84\xe9\xea\x23\xa1\x16\xbc\x6f\x6f\x26\x53\x7b\xed\xb6\xe8\xba\x5e\x08\x95\x20\x84\x24\x8b\x19\xa8\xd6\x9f\x0f\x56\x03\xf0\xe5\xc0\x45\xc5\x64\x22\x0d\x79\xa5\x7d\x11\xa4\x53\x7a\x88\x82\x83\x6f\x3d\x3d\xfb\x93\xc5\x06\xc3\xcf\x0d\x6e\xc3\x92\xdc\xe1\x48\xf2\xcc\x45\x94\xc9\x46\xf0\x8c\x25\x9a\xdf\xe2\xdf\xcc\xea\x7e\x05\x67\x3a\x73\x9d\x3c\x3a\x4d\xfe\x35\xeb\x37\x8b\x0d\x6e\xc3\xcf\x0d\x34\x6e\x36\x03\xe8\x4c\x92\xc6\xa5\x7e\x8b\x3f\x99\x7d\x21\x43\xe3\x76\xe6\xed\xc8\x08\xd5\x43\x96\xe6\x39\x3a\x04\x24\xf4\x92\x73\x52\xe2\x06\x09\x85\x82\x55\x38\xe9\x67\xe2\xb1\x74\x33\xcb\x8f\x69\x5b\x52\x49\x9e\xdc\x3d\x77\xd3\xd6\x1f\xcd\xc4\x5b\x1b\xba\x9f\x8d\xee\x99\x00\x2c\xf9\xc7\x7f\x5d\xfd\xc2\xda\x7a\xa1\xb5\xb6\xd9\x5c\x6a\x72\x0d\x1c\xb1\x70\x31\x8f\x66\xb5\xb5\x4c\xcd\xed\xbb\x7a\xc6\xa9\x6d\xd9\x89\x78\x70\xaa\xeb\x9f\xed\xcb\xa5\xa1\xef\x93\xbf\xcf\x7a\xe0\xcd\xf5\x5c\x2c\x1a\x8c\x0c\x9a\xd5\x10\x36\x5f\xa2\x0f\xad\xec\x45\xd3\xa3\x08\xd5\x31\x8a\xa1\xa9\x41\x5c\xe2\x38\xbd\xc2\x6a\xb5\xa1\x2c\x95\x79\xc0\x62\x3f\x16\x1d\xc1\x2a\x88\x6a\xd8\xb1\x02\x85\xf0\xfa\xf6\x0b\x75\x26\x93\x6a\x00\x6b\xa0\xf7\xbf\x36\xa3\xd1\xac\xa9\xd8\x64\x9f\x4e\xf1\x9b\x17\x02\x3a\x8f\x2a\xc7\x2a\x5e\x7f\x79\xc8\x59\x22\x49\xbe\xf0\xd8\xaa\xca\xb1\x61\xbf\x43\x8e\x3a\x43\xe5\x7e\xaf\x32\x76\xba\x16\x18\xa4\x17\x95\xf9\x38\x95\x55\x63\xc3\x3e\x49\x2a\x51\xe3\x7c\xf3\x16\x1a\xea\x2f\x0f\xad\x1a\x9b\x01\xd4\xf3\x3f\x33\x76\x55\x17\x1a\x56\x9b\x1c\x29\x7a\x83\x5e\x51\x99\x8e\xbf\xf3\x22\x4b\xb2\x90\xf5\x7a\x9c\x1e\xc9\x64\x11\x5d\x6e\xaf\xcf\xe5\x12\x2d\x26\xc9\xe3\xf4\x78\xa9\x2f\x75\x41\xa6\x53\x0b\xf5\xba\xb5\xd0\xcb\x22\xba\x5d\x1e\xa9\x73\xec\x2a\xe8\x24\x99\x9e\x63\x15\x63\x19\x35\x61\x64\xd2\x57\xe1\x2c\x2e\xaa\x57\x6e\x6b\xff\xce\x0b\xad\xcd\x53\x7d\x15\xa7\x8e\xc3\x03\x8e\x80\x35\x6e\xd5\x43\xc0\xaa\x07\x1d\xfa\x1a\x65\x79\x04\xe8\x7c\x16\x3a\x71\x26\xcb\xa3\x0b\x59\x16\x75\x67\x71\x06\x67\x72\x9d\xbd\xdc\x28\x9d\xb4\x1f\xb4\x20\x09\x21\x3d\x68\xac\x4f\x16\x5b\x38\x2e\x06\xec\x58\x10\x03\xd6\x18\x6b\x63\x10\x0e\x2e\x25\xbf\xbf\xf7\x67\x9a\xbc\xf9\xd9\x73\x0c\xb7\x71\xf9\x0f\x72\xe8\x67\x30\xf7\x6d\x7c\x6d\xee\xe3\xe5\x1b\x7b\xa4\x50\x0e\xdd\x4b\x7e\xbf\x14\x3f\xc0\xa0\xb7\xc9\xfd\x97\xa4\xad\xa8\x27\x6d\x6a\x97\xa1\xb6\x34\xb5\xb9\x45\x69\x0b\x83\xa8\xb6\x70\x4e\xd3\x2b\xa0\xa8\x65\x53\x6e\x8f\xc1\x6d\xf8\x8c\x74\x74\xe2\xe1\xaa\x03\xde\xdd\x64\xb1\x3a\xe0\x09\x93\x4d\xcb\xc3\x39\x32\xca\x61\xa5\xb1\x7a\x22\x69\x71\xa2\xb6\x3c\xdf\x92\x80\xd8\x29\xa8\x43\x1d\x49\xca\x7e\x46\x66\x35\x9b\x61\x3e\x5a\xc5\xa8\x95\x30\x0f\x5a\xa2\xed\x11\x09\x04\x29\x92\x31\x8e\xc7\xfc\xbc\x9c\x47\xdb\xe6\x29\xa8\xab\xec\x07\x39\xe4\xc7\xb2\xa0\x44\xe9\x40\x92\x2b\x34\x18\xfc\x89\x70\x04\x86\xfc\xe2\xf6\x86\x25\xa3\xdb\x63\x75\xfe\x9a\x82\xe2\x86\xa9\x1b\xc7\x77\x9c\x58\xf8\xfe\xbd\x27\xc7\xd5\x7a\x26\x9a\x7d\xb0\x93\x5c\xbc\xf5\x1f\x7b\xa7\xdc\xf2\xea\x92\x29\x37\x2f\x9a\x52\xdf\x50\x56\xef\xee\xb8\x6e\xdc\x5a\xa5\x65\xfc\x94\xa9\x23\x6a\x0b\x98\x47\x57\x8e\x9e\x34\x00\x0a\x25\x3f\xbb\xdd\xed\x95\x47\xd4\xb4\x31\x19\x3e\xe4\x2b\xf5\x18\x0d\x33\xbe\xdc\xff\x52\x24\x35\x67\xec\xb6\x31\xd7\x7a\xc7\x2d\x99\x5a\xb2\xf2\xf1\x8e\x43\x7f\x9d\xd3\x92\xbc\x33\x18\x86\x3b\xef\x03\xd8\xbf\xe4\x8d\x3b\x66\x2a\xcd\xf3\xe6\x5f\xbb\x76\x7f\xea\xb5\xb9\x63\xcb\x1a\x8b\x8b\xe4\xca\x86\x25\x6d\x16\xeb\x95\x3f\x60\x19\xb9\xac\xc0\x53\xc9\x5d\x51\xe3\x00\xc7\xa0\x4b\xfa\x82\x29\x54\x67\x9f\x88\x56\xe1\x68\xa2\x67\xf9\x2a\x24\xc9\x69\x25\xaa\xe1\x91\xd8\x29\xf2\x2d\xe3\x03\x89\x1a\xae\x72\x6a\x19\xc9\x0e\x4d\xf6\xa7\x7b\xa1\x8b\x69\x33\x17\xe2\xdf\x82\x53\x7f\xe7\xe7\xa1\x70\x89\x9e\xc5\x35\xe1\x94\x15\xec\xe2\xac\xa8\x21\x30\x24\x3e\x76\x0b\xb6\xcc\x9d\xef\x2b\x89\x79\x60\x42\xc3\xdc\x36\xb9\x2e\x3a\x64\x4c\x76\xc2\x82\xa7\x96\x32\xec\xac\x13\x2b\x9e\x9d\x65\x2f\x68\x2c\x5b\x33\x6d\xed\x9d\x3f\x58\xbc\xea\xaa\x2a\x5d\x48\x2a\x0d\xa7\x6b\xdb\xcb\x96\xdd\xb9\xf8\x12\x1e\x83\x4f\x7f\x38\xc8\x60\x8c\x78\xb1\xb1\x00\x87\xab\xcd\xe6\xf0\xd0\x94\xc1\x67\x5f\x3b\x56\xb0\x74\x4c\xf5\xe9\xcc\xde\x52\x37\x57\xdf\x76\x73\xf5\xed\x0b\x37\x0c\xab\x59\xf5\xcc\x7c\x58\xfe\xd4\xea\x2b\x3d\xce\x15\x63\x87\x9d\x58\xb7\xe4\xe8\xb2\x0d\x8e\x39\xf5\x33\xea\x5a\xa3\x9e\x7d\xf8\xf7\x97\x6e\x78\x60\xf2\x3a\x5e\x0d\x43\x34\x7e\x19\xf3\x6e\x38\x51\x85\x43\x01\xc9\x66\xc1\x42\x20\xd6\x0c\x36\x8b\x09\x87\x02\xc1\x2a\x6c\x69\xc6\xf1\x40\xcc\x0f\x6c\x36\x6f\xc7\xaa\x9d\x18\x6a\x15\x4b\xb6\x6e\xd8\xb7\x6f\x03\xec\x58\xfc\xfc\xf5\x3f\x53\xfb\xb6\x1c\xea\xe9\xe5\x18\xd5\x85\x9d\x7d\x37\xf4\x9c\xa6\x93\xbf\x93\x37\xc9\xdf\xa7\x8f\xbb\x1e\x1e\xba\x6c\x7c\xd0\x6f\x3f\x21\xa2\x68\xf9\xc8\x09\xda\xdb\x71\x3e\x35\xc0\xf6\x9a\xf5\xdb\xfd\xd0\xfb\x9e\x85\xbd\xef\x66\x1f\xbf\xe4\x8d\x40\xf2\x8f\xee\x19\x43\xdc\x72\x49\x62\xa8\xfc\x47\x48\xaf\x9e\x4c\xc8\x86\x9c\xa8\x82\xa2\x72\x05\x82\x4a\x0b\xa8\xb5\xdf\xa2\xb6\x8d\x68\x5c\x89\x72\x10\x10\x24\x99\xa5\xa0\xfc\xa2\xa4\x99\x3c\xd3\x71\x43\x31\xb2\xa0\x62\x94\x4c\xa4\xd2\x51\xb5\x1b\x55\xeb\x0d\xb2\x20\x75\xce\x46\xe9\x69\xe3\x01\x47\x20\x9a\x77\xc5\x64\x48\xc5\x63\xf8\x02\xf9\x69\x49\xc8\x79\x7a\xe0\xb0\x5d\xa7\x4f\xef\x5a\xfb\xd8\x83\xcf\xda\xea\x60\x35\x14\x93\xe2\x2b\x96\x38\x38\xee\xf4\xae\xc6\xa6\x13\x66\x83\x64\x76\x84\x6c\x27\x66\x9d\x06\x1d\x34\x92\xf3\xe4\x26\x72\x7e\x4c\xdb\x40\x72\xbf\x2d\xf0\x8a\xdc\x7d\xf4\x14\x39\x0f\xc2\xa9\x35\x0b\xae\xa3\xa6\x95\x90\x85\x27\x26\x7d\xac\x19\x46\x06\xec\x50\x30\x63\xc1\x29\xc8\xb6\x15\x77\x15\x9d\x26\x5f\x9f\xbe\xe5\xaf\x93\x5a\x6e\x83\xec\xae\x45\xb7\xff\x04\x74\xa7\x9d\xa4\x5b\x4e\x98\x0a\x7c\xc0\xce\xd9\xb1\xeb\x34\xd0\xe7\x82\x70\x6a\xee\x0f\x5b\xe6\x91\x72\xf7\x0f\x3e\x04\x01\xd6\x80\x90\x7e\x5a\x49\x28\xd9\xac\x92\x50\xbc\x64\x55\x45\xff\x7d\xd5\x02\xad\x39\xe5\x68\x64\x1f\x02\x57\x8f\x3e\x59\xec\x01\xa3\x62\x78\xaa\x0b\xc6\x97\xf0\x08\x87\x2e\xc7\xb7\xb2\x26\xd2\x62\x33\x84\x8b\x59\x49\x16\x7b\xf4\xc3\xac\xa6\xbb\xf5\x0d\xe3\x42\x72\xf7\x52\x39\xc4\x0d\xe3\x14\x3f\xab\xf8\x95\xff\xf6\xda\x73\x59\xbb\xd7\x6b\xc7\x59\x3b\x1c\x57\x23\xe7\xd0\xc8\xa5\x23\xb3\xae\x45\xfa\x93\xe0\x81\xc9\xe0\x39\xa9\x5f\x22\x43\x41\x3f\xfd\x2f\x2e\x84\xac\xec\xf3\xc9\x24\xeb\xaf\xaa\xc2\x57\x96\x78\xbd\x25\xde\xdc\x8c\xdc\xe1\x6c\x72\xe4\xc8\x64\x56\xfb\xc5\x33\x56\xad\x84\x9f\x8e\x5e\xdf\xd8\xb8\x7e\x34\xa9\x5f\x48\xfb\x85\xbd\x3a\xc4\x7d\x8d\x0a\x50\x15\x1a\xaf\xed\x36\x09\xe4\xbf\x1d\x97\x88\x6a\x38\x56\xf1\x80\x12\xce\x6f\x23\x08\x68\x8a\xac\x80\xc4\xc6\x63\xcd\x18\xd4\x89\x81\x66\x44\x19\x0a\xa2\xa8\x26\x3f\x1a\x80\x0e\x38\xc3\xf1\x18\x92\xe3\x31\x89\x7b\x3a\x16\xce\x0d\x0a\xc7\x62\x61\xfc\x42\x18\x74\x72\x77\x99\xea\x66\x6e\x98\x4a\x3e\xf8\xe1\x49\xf2\x8b\x47\x65\xe6\x97\xaa\x47\xf7\x55\x53\x21\xfa\xc3\x5d\x5f\x9d\x58\x0c\x6b\x63\xe1\x9d\xd6\x9d\x1f\x92\x77\x1e\xfa\x27\x59\x76\xc5\xf3\x6a\xe8\x2e\xeb\xce\x0f\xa1\xe6\xe8\x3f\xe0\xf6\x2b\x4e\x87\x63\xf8\x77\x6d\xf1\x78\x5b\x7c\xf2\xe4\x89\xb1\x50\x38\xf6\xbd\xa3\x8f\x92\xf7\x4e\xf6\xb8\x17\x3d\xfa\x25\xec\x0a\xc5\x26\x4d\x7a\x88\xbc\xf3\xd1\x4e\x30\x9c\x8d\x85\xe9\x15\xd4\x7c\xb4\x93\xfc\xf3\x6c\x0c\x21\x1e\x15\x5c\x44\xec\x3f\xf2\xdf\xd6\x83\x2a\xd0\x3a\x8a\x29\xce\xc8\xb6\x64\x22\x14\xa4\x7b\xa5\xab\x30\xd8\x45\x55\x7c\x32\x6a\x93\x60\x28\x39\x75\x2a\x99\xa0\xfd\x0a\xcf\xe4\x55\x5a\x29\x6b\xa2\x0a\x34\x80\x2c\xde\x61\xf7\xb3\xe9\x18\x85\x4f\xd2\x20\xc9\x1d\x76\xc9\x21\xf0\x0e\x25\xca\x87\xf2\xd4\x6b\xc9\x44\x5a\xca\x77\x3c\x74\xb9\xa2\x6f\xa3\xb0\x66\x2a\x2e\x4a\x72\x33\x47\xd5\x86\x8c\x9f\x71\xd8\xb1\x86\xe6\x8f\x99\x53\x6b\xd6\x1d\x56\xea\xc8\x0d\x7e\x26\x12\x2c\x2c\x0b\x91\xb7\xee\xb7\x16\x9b\x1b\x37\x8d\x1c\x20\xda\xc7\x2c\xda\x15\x34\xc9\xc5\x46\xa5\x6e\x90\xcf\x1e\xbf\xcf\xd5\x70\xfe\xde\xdf\x1d\xbc\x13\x3b\xec\xb5\xe4\xf5\xb5\x91\xc2\xc2\xf2\xd6\x29\x53\xc7\xfb\x2c\x82\xd3\x62\x66\xbd\xad\x4d\xc5\x99\x69\x11\x86\xbd\x4e\xaf\x0b\xe0\x71\xa9\xf1\x0f\x07\x12\xba\x51\xb5\x85\xbe\x47\x7d\xe5\xa9\x35\x93\x66\x7b\x37\x37\xf9\x4a\x1f\x1c\x3f\x7a\xe7\xcb\x3c\xe6\xab\x4a\x07\x37\x8f\x89\x0c\x1d\x7f\x7f\xd3\x18\xc5\x34\xfb\x58\xf7\x9d\x2b\x57\xdd\xfe\x01\x7b\x2d\x79\xc6\x01\x3f\x1e\x5c\xdb\xbd\x6a\xac\xae\xcc\x85\x05\x81\xd9\x3d\x8f\x4c\x33\x70\x30\xe7\xc3\x50\xf7\x3f\xc2\x47\x6e\x70\x9b\x9c\xa3\x8b\xc7\xce\xcb\xa4\xc8\xbd\xa5\x2d\xb7\xfc\xe0\xd8\xc3\x80\xcb\x07\xb4\xdb\x6a\x92\x05\x9c\x3f\x98\xf0\x8a\x2c\x8b\x45\x31\xec\x75\x4b\xce\xaa\xbd\x43\x8a\xd6\xfa\x0b\x0b\xb1\xe1\x6d\x2c\x98\x92\xc3\xef\x19\x17\x0c\x64\x0a\x17\x5b\x0b\x83\x1f\x4f\x4b\x2f\xd8\xe2\x1e\xe1\x6f\xde\x6c\x86\xb7\x97\x8c\x5d\x90\x7b\xce\xca\x5b\xb6\x5d\x79\xcb\x82\x61\xf3\x86\x2f\x27\x6d\xe6\xe6\xd9\xb3\x32\x07\x48\xf7\x0b\x57\x96\xd5\x81\xb1\x8f\xef\x4f\xed\xff\xdc\x28\x45\x71\xe2\x11\xc4\xfb\x77\x66\xa1\x7c\xef\xa7\x76\x74\x91\xef\x0c\x49\x45\x12\xea\xe0\x35\xaa\x04\x8a\x05\x13\xd6\xbe\xa0\xec\xc7\xb2\xc4\x06\x8a\xd3\xcd\x38\xdd\x0c\xa2\x35\x60\x65\xac\xef\x98\x1e\xde\xf1\xc0\xa9\x67\x6f\xb8\xed\xa8\xf1\x0c\xd7\x14\xaf\x6b\x31\xb8\x53\xd1\x39\xf8\x97\x6f\x9b\x8e\xf6\xf8\xbf\xc9\x36\xc7\x54\xff\x64\xb4\x26\x0d\x2b\x8a\x2a\x79\xb3\x17\x4f\xce\xdd\x9b\xfb\xde\x24\xce\x65\xe5\x2b\xfd\xfe\x4a\xde\x26\xf3\x15\xb0\x07\x44\x3c\x6f\x0a\xe7\xb4\x72\x55\xfe\xce\xaf\x11\xb6\xdc\xf7\xa3\x3f\xbe\xf6\xf2\xff\x9c\x38\x94\x69\xdb\xb4\x6e\xc0\xb0\xc1\xe1\x7d\x97\x7b\xb4\x3f\xf5\xce\x6b\x4d\xba\x42\x1b\x6e\x69\x61\xcd\x46\x5d\xe3\xab\x3f\x7b\xf7\xd5\x26\x9d\xc9\xc4\x05\x8a\x07\xb2\x26\x93\xbe\xf1\xa7\xcc\x99\x0b\xaa\xd8\xea\xe9\x57\xb8\x0e\x2e\x8b\x7c\xa8\x41\xb3\x78\xcc\x03\xa4\x2b\xfd\x18\x1d\x69\x4b\xa7\x8c\xc3\x26\xe8\xe9\xec\x7b\x98\x1d\x53\x3d\x17\xcc\x39\xca\x2d\x79\x68\x15\xf9\x82\x3a\x6c\x26\x78\x77\xcf\xa7\xbb\x21\xbb\xfb\xd3\x3d\x64\x80\x7a\x7d\xc8\x64\x03\xcb\xaa\x43\xd4\xc1\xdc\x4c\x2c\x34\xce\x17\xab\x0e\x75\x51\x60\x6f\x2e\x63\xb2\xed\xfe\x14\x86\x77\xdf\xbc\xe7\xd3\xdd\x36\x13\xa3\x4d\xe2\xd1\xa1\x55\xcc\x2a\x6d\x0f\x08\xdb\x6f\x0f\x48\x33\xb5\xe0\x41\x97\x5b\xc7\x72\x1a\x56\xb5\xd0\x03\x58\xdd\x00\xb1\x9e\xa0\x6f\xbb\x8a\x24\x7b\x0d\x75\x68\x58\x1e\x6f\xfd\xb2\x11\x4d\x91\xc7\xf9\x86\xd3\xeb\x75\xbe\xe1\xf4\x10\x69\x60\x72\x77\xab\xd7\xdb\xba\x23\x39\xd0\x91\x96\x3c\xae\xd9\x4e\xaf\x23\x25\x79\x9d\x73\x9d\x1e\x29\xed\xc0\xa3\x06\x25\xc9\xd7\xc9\x41\x52\xda\x51\xd4\xf2\x62\x72\xd0\xd6\xbd\x1d\x5d\xef\x76\xec\xdd\xdb\xc1\x0e\xe8\xd8\x8b\x9f\x5a\xa3\x3e\x45\xfd\x21\x17\x92\x03\x13\x89\x81\xc9\x0b\x92\xf4\x07\xd5\xef\x0f\xbd\xe7\xf5\x77\x27\x07\x0e\x4c\x92\x85\x0e\xc7\x93\x65\x03\xf1\xbd\x7d\x77\xef\xed\xcf\x5d\x88\x91\x9e\x5a\x11\x06\x3c\x10\x50\xff\xeb\xbf\xb1\xaf\xf0\x56\xf2\xc1\xad\x9f\x41\x9a\x9c\x26\xc3\xc8\x69\x48\xc3\x36\xbc\xf4\xd8\xfa\xee\xcc\xfa\x63\xc7\xd6\x33\x9d\xeb\x8f\xc1\xcb\x38\xda\x7d\x07\x8b\xba\x11\xd4\xe3\x23\x7d\xfe\xc7\xd4\xea\x20\xf7\xe2\x31\x8e\x42\x93\xd0\x5c\xb4\x18\xad\x40\x6b\xd0\x46\xb4\x0d\xed\x42\xd7\xa1\x5b\xd0\x01\x74\x0f\x3a\x84\x7e\x80\x1e\x42\xc7\xd0\xa3\xe8\x19\xf4\x1c\x7a\x01\xbd\x84\xce\x68\x58\xc7\x0c\xdd\x11\xca\xe4\xb5\xa0\x01\x5e\x3d\x34\xb9\xc6\xd0\x0d\xb7\x8c\x86\x7e\x20\x26\x54\x2f\x31\x2f\xdb\x02\x29\xf5\xd0\x60\x27\x44\x8a\xa3\x2b\xfa\x01\x02\x10\x82\x40\x2a\x06\xd4\x57\x4e\x5b\xa3\xbc\x00\x01\x39\x12\xe0\x83\x90\x4a\x47\x85\x50\x9a\x01\x19\xd2\x62\x00\x52\x5c\x1c\x02\x56\x59\x62\x02\x69\x30\x43\x3c\x29\x48\x56\xbb\x7a\x93\x6c\x4d\x5b\x65\xa8\x06\xc1\x9a\x8e\xf2\x91\x10\x27\x3b\xf4\x38\x12\xb5\x72\x42\x1c\x64\xb1\x1a\x2b\x4d\xc0\x28\x51\x3d\x4e\x32\x62\x48\x04\xa1\x05\x28\x1d\x5d\x01\xc8\x29\x1d\x72\xdb\xdf\x62\x5c\xf6\x97\x98\x80\xd3\x65\x21\xab\xac\x09\x2b\x59\x6d\x75\xcb\x41\xf6\x25\xbb\x8b\x79\xdb\xee\xf2\xd8\x5f\x85\xe0\xcf\xd8\xa0\xec\xb6\xc1\x0d\x96\x94\x05\x6e\xb2\xa9\xa1\xef\xc8\xc5\xc2\x73\xa2\xab\x3b\x0a\xbb\xc9\xb1\xef\x91\x63\xb0\xd8\x56\xd6\x3d\x03\xf0\xbb\xe6\xd3\xcf\x19\x2d\xf8\x28\xd9\xf2\x02\x2e\x23\x7f\xb4\x54\xe0\x47\x81\xcd\x58\xfd\x52\x37\xf9\x55\x0b\x6c\xb0\x0c\x24\x93\x60\x94\xae\x7b\x15\x07\x93\xc9\x3e\xd6\x64\x83\xfd\x19\x72\xe6\xde\x97\x1e\x3c\xca\x82\xee\x11\xff\x5d\x50\xfa\x9b\xdf\xb0\x6f\xbd\xc8\x33\x1b\x2c\xb9\x5b\xdf\x27\xff\x05\x69\x28\xc9\x5d\xbd\x17\xfe\x50\x36\x09\x22\x7f\xd9\xc5\x80\xa4\xfb\x15\xa7\x23\x23\x21\xd5\xdd\xf9\xe0\x83\x0f\x3e\xc8\x36\x0d\xd8\x51\xf2\x0e\x66\x1e\xd9\x3e\x8a\xc3\xdb\x1d\x45\x2c\xb9\x47\xaf\xb7\x17\xb1\xe4\x51\x9d\x4e\x0e\xda\xec\x76\x7b\xc0\xa9\x2b\x84\x31\x6c\x91\x5d\xaf\x87\xf9\x5c\x91\xdd\x51\xc4\xc2\x54\x60\x21\x6c\x86\x65\x06\x9d\x33\xe0\x70\x38\x1c\x01\x27\x5f\x48\xee\x86\x80\x64\x34\x91\xd3\x6c\x51\xf7\x5b\x30\x8f\xdc\x67\x61\xbc\xac\xde\xc0\x91\x3b\xf9\x57\x61\xc6\xcb\x3a\x0c\x9d\xaf\xbd\x66\xe9\x9a\xc8\x73\xad\x63\x96\x80\x81\xbc\x95\x21\x37\x7b\x21\x45\x1e\x66\xcd\x30\x8f\x9c\xe4\x39\xd8\x38\x08\x06\x1e\xf9\xe8\xf9\x93\x3a\x26\x09\x18\x2c\xc6\x93\x60\x2c\x20\xaf\xdf\x0b\xf5\x7f\xfa\x58\x47\xbe\x1e\xf1\x3a\x2e\x3c\xf7\x49\x39\x79\x85\xbc\x04\x71\xf3\x8d\xe4\xd3\x8f\x2a\x60\x6f\x17\x5e\xc5\x81\xc3\x68\xc1\xb0\x11\x58\x52\x43\x4e\xc1\x3f\x7f\x43\xfe\xd0\x7d\x1d\xf9\x3d\x78\x7e\xf7\xbb\x36\x58\x62\x60\xc1\x0c\x25\xb9\x7b\xc6\x33\xda\x7a\x09\xc5\xff\x37\x22\x0f\x42\xb4\xfa\xf7\x36\x86\x48\xb4\xbf\x21\xde\xd3\x3b\xf1\x1f\xa0\xe3\xe9\x9d\xdd\x7f\xdf\xf9\x34\xfb\xee\x63\x99\x2a\xe2\xad\xca\x0c\xac\x64\xa6\xee\x7c\x11\x16\x5e\x18\xb4\xeb\x85\x17\x76\x85\x9f\x84\x87\xab\x06\x0d\xaa\x22\xf6\xaa\xc1\x9a\xbc\xd9\xc9\x23\xee\x1a\x64\xa0\xcc\xde\xa5\x08\x01\x8b\x18\x75\xe0\x12\x8e\xc7\x38\x49\x56\x2f\xa2\x36\x04\x36\x14\xd1\x2e\x38\x25\xca\x0b\x29\x94\xe6\x05\x89\x39\x42\x7e\x4c\x82\x1b\xec\x6f\x41\xc7\xbb\xe3\x61\xfe\xac\xa1\xe4\xea\xdc\x2b\x2b\x67\x35\xaf\xc2\x29\xf2\xe0\x5a\x6c\x85\x2b\x4a\x4c\xe4\x43\x92\xd9\xb0\x88\x79\xe7\xa5\x13\x7b\x0e\xae\x80\x11\x6f\x3a\xc6\x0e\xe4\x96\x6e\x22\x3e\xf2\xd2\xb4\x29\xef\xc2\xdc\xb7\xae\x1f\x38\x7d\x75\xee\x25\x72\xf5\xb0\xe9\xb0\x03\xd7\x77\x35\xc2\x7c\x6c\x5f\x3f\x73\xd1\x46\xd2\x4c\x7e\x6d\xb2\xc7\x06\x4e\x94\xdf\x82\x91\x57\xde\xb9\xeb\xd1\xbc\x6c\xd0\x21\xf6\x5f\xd4\xf6\x57\x95\xe4\xa2\xc6\xf2\x43\x35\x24\xe5\x20\xa6\x02\x31\x39\x15\x2f\x86\x98\x44\x87\x2b\xd4\x9f\x51\x27\xba\x72\x2a\xad\x91\xd3\x09\x94\x1d\x4a\x4e\xc9\xc2\x82\x83\x3b\xb7\xbe\xf6\xd2\x6f\x6f\xbb\xed\xb7\x2f\xbd\x96\xdd\xc2\x1d\x3c\x07\xf8\xb3\xbb\xef\xfe\x0c\x30\xf9\x72\xfb\xdb\xf7\x6e\x79\xe4\x95\x73\x07\x0e\x9c\x7b\xe5\x91\x2d\x4b\x36\x3d\x36\xfd\x8d\xe3\xc7\xbf\x4a\xff\xe2\xb6\x3b\x3f\x7e\xec\xd0\x9a\x2d\x3f\x5b\xf7\xb3\xc3\xc7\xdf\x60\x37\x76\xe9\xea\x66\xdc\x76\xdb\x8c\x3a\xf6\xeb\x6d\x4b\x97\x76\x1d\xa9\x1b\xc8\xe4\x46\xdf\x78\xe3\xe8\x6e\xa6\xbc\x22\xb4\x7c\x79\x90\xd9\xc7\xde\x71\x70\x50\xf7\x84\x78\x6c\xe1\x32\x4e\x1b\x47\x1f\xd6\x21\x6e\x46\xef\x7e\x8b\x99\xff\xfb\x75\xe8\x6f\x5c\xf7\x01\xac\xf6\x43\x5a\xa1\xb2\xc5\x0f\xdc\x87\x7e\xfb\x2c\xbb\x9f\xfe\x90\x4f\xfd\xf6\x05\xaa\x7b\x81\xdd\x4f\x3e\xfc\x76\x37\xb7\xf7\x4f\x47\xba\xc2\x47\xfe\xb4\x75\x89\xe1\xfb\xab\x17\x8e\xae\x84\xb2\xe7\x6f\xef\xbe\xd5\xb4\xe7\xf8\x61\xfc\x91\xc3\xef\x77\xe4\x42\x6a\x44\x2c\xaa\xbf\xb9\x3f\xab\xbf\xf0\x43\xf5\x97\x4c\xa0\xee\xa5\xd4\x7d\xc0\xee\xf7\x1f\x39\xf2\xa7\x3f\x1d\xb9\xea\x95\x58\x30\xba\xfa\xfb\x83\x9f\xfe\xfc\xd6\xee\xdb\x07\xd5\x06\x7e\x8d\x10\x8a\x22\x74\xb1\x99\xd7\xf6\xce\x68\x3c\x6d\x0e\xca\xd4\x16\xa0\x5c\x6d\x95\xa8\x06\x25\x51\x1d\x6a\x42\x03\xd1\x10\x34\x1c\x8d\x42\xe3\xd0\x24\x34\x0d\xcd\x42\x73\xd1\x22\xb4\x0c\xad\x44\x6b\xd1\x06\x74\x35\xda\x86\x76\xa3\xeb\xd0\x8d\xe8\x16\x74\x3b\xba\x0b\x1d\x46\xef\x23\x64\x0d\x58\xf5\x10\xa1\xbf\xc9\x80\x43\x74\x84\x92\xf2\xe5\x47\x5a\x16\xfa\x1f\x2d\x70\xe9\x01\x8e\x50\x32\xf0\x6f\x0e\x35\x3c\xee\x48\x7f\x47\xa8\x9c\x54\x43\x85\x6f\x39\x22\x3d\x23\x2c\x0a\x7e\xe3\xc7\x29\xcd\x1c\x2d\xd4\x6b\x4f\x07\xbc\xa2\x61\xfd\x4b\x72\x3c\x5d\xc5\x87\x82\x26\xcc\xa3\xee\xaf\x73\x3a\xee\x9e\x0b\xaf\xe1\xdb\xf1\x83\x17\x5e\x1b\x17\xe9\xf9\xd7\x62\x5e\x62\x2e\x32\x2f\x31\xfb\xe9\x79\xb1\x79\xcc\x12\xf3\x92\x8d\x4b\xcc\x4b\x36\xe5\xcf\xdd\x03\xd7\x80\x7d\x2d\x38\xd6\x82\x7d\x0d\xfd\xcb\xbb\xbb\x9e\x89\xac\x7d\xe0\x72\xff\x2f\x46\xaf\xed\x7d\x70\x24\xb7\x77\xfb\x33\xcf\x6c\xdf\xf1\xf4\xd3\xe4\x6c\xb4\xb1\xb5\x31\xba\x6a\xae\x9b\x29\x1a\x3c\xc7\x97\xae\x0d\xa5\xc7\x8e\x49\x97\x96\x38\x82\xc3\xcd\x8c\x9f\x09\xeb\xfd\x26\xb7\x54\xe8\x4b\x27\x03\x3c\xba\x70\x33\x39\x01\xe3\x07\x32\xf7\x75\xcf\x23\x1f\x70\x25\xaf\xbf\x4e\x7e\xb9\x76\xed\x6d\xfd\xfe\xbe\x17\xac\x0e\x98\x82\x55\x41\xf5\x30\x06\xaa\x82\xc1\xaa\x40\xf5\xec\xaa\x60\x95\x7a\xcc\xaa\x0e\x56\xb1\x3f\x0b\x5f\xf6\x8f\x1c\x1f\xb3\xf6\x52\x9f\xb5\x63\xc2\x97\x3c\xf3\xb6\xb5\x6b\x43\x4f\xef\xd0\x52\x0b\xd7\x84\x4b\xf5\x1c\x88\x8e\x9a\x78\x4b\x99\x41\xaa\x28\xaa\xaa\x16\xa0\xc0\xee\x70\xf2\x92\x5c\x0f\x66\xa6\x80\xe1\xb1\x41\xae\xec\xe1\x17\x58\xab\x43\xdc\x8d\x14\xef\xa1\xec\xb2\x39\xec\xb7\x6d\xce\xcb\xd3\xc8\xaa\x03\x8d\x39\xf7\x9f\xbb\xef\xbe\x73\x0c\xb9\xef\xdc\xfd\xf7\x9f\x83\x73\x2d\x95\x5f\xff\xaa\xb2\xa5\xa5\x12\x1e\xad\xc8\xe0\xaf\x32\x15\xf0\x68\x65\x0b\xec\x55\xc3\xee\x53\x23\xae\x5a\x7d\x1f\x5b\x7b\xe1\x74\x45\x4b\x4b\x05\xd7\xaa\xfe\x7e\xff\xfb\x15\x2d\x2d\xf9\x71\x68\x89\x0e\xb1\x67\x11\x42\xd3\x11\x02\xae\x07\xee\x48\xe8\xd3\xcf\xd3\x85\x66\x87\x5d\x50\xe7\x91\xea\x28\x02\xf5\x87\x48\xca\x5b\x0e\x24\x35\x25\x47\x8f\x29\xbb\x76\x43\x8a\x3b\x00\xec\x6d\x3f\xff\xe0\xbe\x49\x77\x6f\x5e\xb3\x78\xd1\x9a\x8d\x77\x4e\xb8\xfb\xc7\xef\xde\x3f\xff\x57\x93\xb8\x62\xaf\xce\xe4\x68\x5c\x40\xfe\xb1\x6d\xf7\x27\x7b\xc0\xf3\xf6\xc6\xf7\xef\xbb\x65\xf7\xb5\x87\xa7\x2f\xdc\xbd\x7d\x8e\x7f\x91\xd5\x5e\x64\xfd\xaf\xfb\xeb\x97\x35\xc5\x74\x66\x87\xab\xe1\xb1\xd9\x2f\x12\xb6\x8e\x39\xf5\xe6\x2b\xfb\xef\xfd\x59\x7a\xe6\xc6\x5d\xbb\x37\xce\x4c\x3f\x7d\xd7\xbd\xcf\x8e\x6c\x62\x7d\xa2\xc3\xe4\x4c\x4e\x5d\x7e\xd5\x2f\xaf\x7d\x0b\x2c\x53\xf6\x3d\x74\x74\xdf\x94\xab\x17\xcc\xc9\x46\xfc\x76\xdb\x68\xfb\xfd\xef\x46\x2a\x22\x0e\xb3\xe8\x19\x3c\xbc\xeb\x85\x88\xcf\x9c\x1f\xcb\x66\x39\x44\xf7\x12\x94\xa3\x29\xb4\xd4\xcb\x35\x4e\x4a\x1f\x50\x53\xb1\x06\xa0\x20\x23\x4d\x40\x51\x31\x34\x3e\x8e\xfc\x59\xa4\x0c\x0b\x94\x57\x20\x10\x93\x7a\x44\x5d\x33\xa4\x99\x9e\x35\x15\x3f\xab\x4e\xc3\xd9\x4e\xc5\x9d\x55\x12\x8a\xc6\xe1\x4b\x1d\xb9\x3f\x68\x36\xe4\x9a\x29\xf9\x99\x62\x57\xd7\x9f\x40\xe0\x9c\xcc\x9d\x6a\x94\x6e\xe4\x56\xa4\x08\x3e\xf9\xa6\xb6\x6c\x62\x71\x99\x0b\x58\x01\xd8\x93\x6e\x85\xb9\xf4\x29\xaa\x23\xd7\xdf\xb0\x9c\xe9\x24\xc8\x19\x61\x36\x0b\x3e\xa7\xc1\x32\x40\x49\x28\x8a\xdb\x14\x6f\x65\x99\xb4\x92\x50\x8c\xb6\x22\x29\x22\x28\x7d\xb8\xf6\x6a\xbe\x35\x7b\xfc\x09\x5a\x6d\x33\xf7\x98\xd1\x53\x06\x34\x19\xa4\x58\x1a\xfe\xaf\x79\xe6\x90\x92\x10\x6f\x55\x12\xca\xad\x62\x42\x11\x01\x89\x09\x11\x50\xee\xd6\xff\x73\xae\xc5\xfd\x10\x51\x03\xc8\xaf\xf7\x8b\x4a\x42\xbc\x88\x44\xf5\x79\xc1\xff\x7d\xde\x35\x1e\x0d\x6d\xfc\xce\x21\x3d\x2a\xa4\x7b\xcd\x14\x84\x44\x3d\x13\x88\x8a\x01\x3d\x0e\x44\x02\x0c\x1d\xd0\x47\x34\x95\x39\x65\xf6\x48\x83\x9a\xb7\xf7\xf0\x4a\xf2\x1e\x7c\x06\xb3\x72\x6d\xd7\xbd\x49\x2e\x90\x73\x4c\x0e\xaf\x24\xcf\x77\xbf\x8c\x8f\xbd\x49\xfe\x82\x57\xc2\x74\x72\x8e\x5c\x80\x69\x90\x35\x61\x4b\x77\xc6\x56\x6f\xeb\xce\x58\xb0\x09\xb2\xb6\x00\x9b\x0d\x30\x28\xb7\x08\xdf\xd5\xdd\xcd\xb0\x94\x6f\xa3\xfb\xbf\xf1\x5d\xd4\x01\xd9\x85\x04\xd9\xaa\xad\xdd\xc8\x6e\x67\x91\xb5\xda\x86\x91\x1b\x31\x48\xbc\x88\x84\x3f\xf3\x08\x0d\x47\x77\xa0\x43\x08\x71\xa9\x58\x11\x08\x51\x0a\x45\xfd\xef\x7f\xd2\xda\xe6\xd8\xef\xfc\x89\xf4\x8f\x64\x65\x94\x54\x0b\x58\xe3\xc9\x40\x32\xe0\x08\x38\xe2\x56\xd9\x0f\x02\x63\xed\x8b\xfd\x9f\x5e\x09\x8e\x08\x97\x54\xbb\x19\x41\x14\x13\x62\x76\xfa\x84\x09\xb6\x94\x6d\xc2\x04\x31\x21\x7e\xe7\x8f\x1a\xe9\xdf\x85\x4f\xb8\x50\xd9\x2f\x56\xe6\xe7\x56\xbb\xff\x64\x56\x53\x03\x65\x4f\xfa\xed\xd6\x9f\x8b\xfd\x9f\xf4\x6f\x5f\x07\x19\xc8\x42\x36\x4b\x90\x28\x6a\x0f\x14\xbf\xeb\xf8\x37\xa1\x9b\xd4\xd0\xf1\xe3\x45\x71\x7c\x06\x22\x50\xef\x6e\x32\xd4\x43\x79\x36\x9b\xcd\x92\xf7\xeb\x0d\x4d\x6e\xf2\x53\xf2\x6b\x9b\x28\xaa\x11\xfe\xcd\x43\x58\xb7\x06\xb9\xd9\xd3\xfe\xb8\x1e\x2e\x97\xc1\x68\x3d\x42\x01\xb1\x1a\x40\x34\x03\xe4\x49\x20\x83\x79\x2e\x48\x8d\xc6\x51\x1f\x8f\x35\x33\x0d\x10\xf3\x33\xf1\x58\xb3\x4e\xdb\x18\xdd\xdb\xf6\x98\x74\x34\xae\x0a\x5a\x4d\xd8\xa6\xd5\xce\x3c\x46\x41\x5a\x80\x02\xb9\x4a\x42\x5c\xf0\x33\x38\xd3\xd1\xa1\x16\x44\xb6\x03\x10\xc6\x86\xc9\x6d\x73\x05\xaf\x30\xb7\x6d\xb2\x81\xda\xe9\x16\x60\x5c\xc0\x14\x72\xc6\x02\xab\x4d\x36\x86\xab\x44\x83\xb1\xa0\xb0\xc0\x68\x10\xab\xc2\x46\xd9\x66\x2d\x30\x72\x85\x4c\x01\x8d\x05\x0f\xec\xdf\xd4\x7d\x60\xd3\x7e\xbd\xaf\x6a\x5c\x72\xfa\x2f\x25\xfc\xf2\xcf\xad\x43\xc2\xc5\x15\xfe\xe5\x8d\xcb\xfd\x15\xc5\xe1\x21\xd6\x9f\xbf\x2c\x78\x7e\x39\xbe\x65\x5a\x99\x05\x3a\xb3\x99\x5c\x16\x67\x33\x59\x1c\x63\xb1\x4e\xc4\x58\xd4\x61\xd6\xa6\x67\x04\x81\x0d\xe8\xdc\x3a\xbb\x50\xc8\xb2\xae\x50\xd0\xe5\x0a\x86\x5c\x2c\x5b\x28\xd8\x75\x6e\x5d\x80\x15\x04\x46\xdf\xfd\xe0\xa6\xeb\xaf\xdf\xd4\xb4\xe6\xba\x2b\xe7\xba\x3f\xcc\x64\x0a\xed\x25\xb5\x75\x65\xcd\x37\x97\x45\x9a\x9b\x23\x65\x37\x37\x97\xd5\xd5\x96\x8c\x1b\xf3\x49\x60\xdb\xa1\xef\xe5\xf5\x06\x39\x0e\xa1\x76\x34\x13\xad\x42\x08\x24\x13\x8e\x56\x41\x54\xa1\x8a\x12\xba\x04\x1a\xea\xb7\xf0\xad\xf4\xee\x09\xf7\x63\x39\x10\x8f\x86\x82\x4a\x9a\xea\xda\xd5\xea\x9e\x5f\x94\xe0\xcb\x41\x4e\xc9\x7e\x80\x58\x2a\x1d\xd0\x28\xd2\xe9\x72\x7b\x09\xa4\xbe\xb1\xc6\xae\xcb\x15\xb6\xee\x78\x6e\xd1\xf7\xff\x6c\x29\x1c\x33\x66\x68\xc7\x95\x11\xcf\x45\x34\xa4\x77\x19\xbc\xbd\xdd\x79\xf5\x8f\xe8\x76\xb0\xec\xe8\x6b\xaf\xa8\xf0\x61\xb4\x76\xd2\xc7\x7e\x85\x63\x15\x67\x2e\x60\x6f\x5b\x23\x7a\x16\xa8\x81\x4f\xac\xdd\x79\xf3\xf7\xde\xf8\xfa\xbd\xb5\x8f\xc9\xe4\xa7\x21\xbb\xcd\x7a\x6b\x75\xc5\xae\xd3\xa7\xb9\x2c\xe8\x4e\x5f\xba\xe6\x0e\x7f\x5f\xf4\xe2\xde\x76\xa1\xe0\xd3\x43\x2b\x5f\x1d\xba\x6c\xec\xa7\x3b\x3c\xd1\x9e\x95\x71\x4f\xe5\x95\x4a\x42\xf1\xc4\x7c\x52\xb6\xd2\x2f\xfb\xbd\x4b\xd6\x88\x8a\x3b\xeb\x56\x8e\xb7\x78\xdc\x67\x73\x5d\xb7\xac\x2c\x2a\x2e\x02\x87\xf1\x34\xf9\xfa\xf4\xe9\xcb\x97\xdb\xf3\xfc\x46\x5c\x96\x3b\x87\x92\x68\x8c\xda\x13\x06\xec\x26\x5c\x5c\x85\x35\x3c\x0d\x49\x96\x78\xc1\xc4\x0a\x7e\x36\xd6\xcc\xa4\x29\xb0\x06\xdd\xc2\xc8\x68\x6b\x55\xfd\x2d\x4e\x7a\xed\xf2\xf2\x3d\x06\x97\xbd\xfa\xad\x7f\x90\x0b\xff\x78\xeb\xea\x41\x57\x6d\x1c\xea\xae\x60\xb9\x22\x77\x7d\x47\x5d\x89\x19\x98\x01\xf3\x76\xbc\xf8\xde\x8b\x3b\xe6\x0d\x60\xc0\x5c\x52\xd7\x51\xef\x2e\xe2\xd8\x0a\xf7\xd0\x8d\x57\x0d\x22\x59\xc5\x9d\xd1\xb6\x38\x65\xdc\xca\xc8\x24\x64\x93\x23\x3b\x28\xd7\x55\xcb\x82\xa6\xa2\xa2\xa6\x05\x2d\x35\x63\x52\xa1\x42\xae\xc8\xed\xae\x60\x0d\x1e\xa7\x6c\x61\x0b\x8a\x42\x7e\xbb\xdd\x1f\x2e\x2a\x64\x4d\x4e\xd9\x63\x60\x2b\xdc\xee\x22\xae\x30\x94\x1a\xc3\x8c\x21\x59\xb7\x42\xb2\x9a\x3e\x42\x3d\x92\x23\x47\xc2\x51\x8d\x13\x0b\xf7\x72\xd6\x78\xa8\xf5\x54\xc0\x04\x66\xd0\x30\x2c\xa3\x81\x58\x2a\xed\x01\x8d\xcb\x45\x94\x25\xb0\x0b\x81\x68\x15\x08\xbc\x50\x00\x55\x10\xe4\x05\x26\x90\xc7\x88\xc4\x72\x33\x13\x57\x3b\x3d\xa8\xe1\x0c\x2c\x93\xbb\xc5\x96\xb0\xe5\x6e\xe6\x2c\xb0\x5a\x0a\x71\x6d\x2f\xf0\x41\xc9\x11\xe4\xf7\xd7\xda\x70\x74\x11\xf9\xde\x4a\x5d\x48\xac\x2c\xd8\xfe\x13\x3e\x54\x11\xe4\xae\x22\xd3\x16\x91\x73\xcd\xdb\x57\x8e\x0d\x87\xc7\xae\xdc\xde\x7c\x8e\x60\xc4\xeb\x19\x36\x77\xd4\x66\xc3\xd3\xb1\xcd\xe3\x00\x57\x6e\x81\xdd\xed\xb6\xc3\xef\x57\x85\xe0\xf8\x2d\x07\x3f\xb2\xda\x31\x57\x4a\xc6\xe3\x13\x76\xb7\xc7\x41\x06\x1c\xbc\xe5\xc3\xaf\xcb\x87\x67\xc2\xe1\xcc\xf0\xf2\xaf\xd5\x31\x1c\xbe\x88\xd8\x2c\xd7\x4d\xf7\xd6\x20\xb0\x23\xc1\x1a\xef\xa9\xd5\xbd\x0b\x75\xbd\x78\xbb\xd6\x2a\xc0\x94\x7d\x96\xb5\x85\x2d\x88\xea\x8b\xd8\x2c\x39\x7b\xf6\x5c\x1f\x68\x8c\xe6\x3c\xf0\xb7\xed\x85\x05\xfb\x3e\xd9\x7d\x0c\xca\x4e\x74\x23\xad\xc6\x91\xf3\xe4\x26\xa6\xf3\x23\x72\xca\x49\xba\xfb\x45\xd5\xcc\x89\x58\xcb\x09\xb0\x1d\xbc\xf6\x0f\xfb\xcd\xe2\x7e\xf2\xb9\x4d\xd3\xe6\xa8\x77\xf5\xd7\x83\x46\x51\xf5\x65\x9c\x90\x94\x0d\x19\x07\xab\x30\x55\x00\xcb\x90\x07\xc2\x89\x6b\x69\x43\x16\xae\xd3\xad\xd0\x17\x90\x1d\x5b\x67\x1c\x7c\xff\xf3\xf7\x0f\xce\x98\x71\xf0\xfd\x75\x67\xee\x81\xad\xa4\x8b\x2e\x56\x2e\xea\x49\x1a\x39\xcf\x65\x15\x37\xd1\xcc\x96\x78\xb2\xfd\x9e\x33\xeb\xb4\xd8\xea\x4d\x5b\x61\x2b\x7d\xcc\x85\x6c\x5f\x5e\x7a\x6d\x51\x58\x55\x36\x37\x69\x7b\xe7\x6c\x0e\x3b\x12\x1c\xff\xa6\x08\x93\x0a\xa2\x16\x67\x51\x45\x95\x1f\xb2\x5f\x95\x1a\x54\x92\x08\x7c\x4f\xa2\x99\xe6\x5b\x4e\x92\xb3\x67\x35\xc4\x06\xfa\x5a\xcd\x79\x96\x9c\x3d\x79\xcb\xe1\x16\x5e\xb4\x0e\x71\xe8\x2a\x3a\xff\xd4\x59\xa1\xf3\x35\x59\x45\xbe\x25\xf7\x83\xbe\x4c\xb0\x3f\x19\x46\xfe\xe7\x21\xb5\x94\x77\xf5\xbb\x95\x3a\x77\x39\x61\xe8\x47\x0f\x81\x63\x58\xc7\x49\x8b\xc7\xbe\x74\xc7\x8e\xa5\x76\x8f\xe5\x64\xd7\x87\xfd\xb2\x44\xeb\x03\xed\x6b\x06\xa1\x11\x08\x41\x8f\xc1\x7b\x4f\x36\x04\xe9\x3f\xe6\x4f\xad\x22\x29\xa4\x0a\x81\x88\xda\xbe\x7b\x32\xc5\x22\x9b\x09\x8a\x7b\xbe\xc6\xd6\x6f\xcb\xdf\xed\x7f\xdb\x51\x68\x81\xe2\x33\xeb\x3f\x9c\x8a\x2e\x5e\x6b\xb2\xe5\xf6\xf4\xfb\x36\xe7\x4c\x36\xc5\x4d\x68\x95\xb9\xf6\xe2\x7d\xaf\x7f\x7b\x06\x2d\x27\xc0\x7a\xf0\x4d\x28\x97\x4d\x83\xda\x88\xcd\xd4\xd5\xd1\xff\x6b\xe1\xde\xbd\xa5\xcb\xd0\xda\xff\x5b\xde\xd4\x6f\x97\x8e\x0a\xbd\x90\xc3\x8e\x4b\x56\xdb\x7b\x3a\x83\x74\x2f\x52\x71\xaa\xf8\xd2\x42\xe0\xfe\x73\x21\x9c\x25\x67\xb7\x26\x16\xe8\xdd\x86\x01\x06\xd0\x2f\x59\x49\x43\x14\x37\x14\xab\x81\xbb\x97\x4e\xce\x07\x4c\xaf\xbb\x0f\xf6\xdf\xf7\x7f\x2c\x25\xb5\x1a\xbc\x7e\x5f\x72\xa5\x01\x74\x15\x3a\x8f\x61\xed\xaa\x6b\x69\x9d\xef\x49\xd7\xb2\xd9\xf9\x80\x2b\x6a\xb7\x6e\xfd\x46\x29\x22\xc4\xa9\x75\x84\x27\x5c\x0e\xd5\xa2\x66\x34\x12\x8d\xa7\x9a\x19\x09\xf3\xdf\x26\x3a\x02\xdf\x21\x44\xd4\x1a\x22\xa7\x64\x09\x41\xca\x12\xe5\x2d\x4c\x8c\x0e\x48\x14\xda\xf1\x82\x55\x89\xf2\x82\x15\x62\xc8\x82\x42\x41\x81\x0e\x4b\x78\x52\xb8\xfd\x6f\x07\xfa\x49\x0c\x82\x2e\x13\x37\x56\x88\xbe\xf5\xf6\x23\x8f\xbc\xfd\x16\x44\xbb\x6f\xcd\x66\xb3\x9d\x6b\x17\xdd\x7d\xf7\xa2\xb5\xb4\x67\xc5\xe7\xaf\xdb\xb0\xe1\x3a\x9c\x39\xa5\xe6\xe2\x14\x0d\x60\xfe\x7a\x90\xfc\xe5\x84\xe5\x12\x51\xf4\x4d\x81\xf4\x36\x54\x8a\x8e\xb5\x6b\x1d\x22\xf9\x45\xee\x8d\x9d\xb0\x7c\xe7\x4e\x72\x1b\xf9\x67\xdd\xe1\xdf\x9e\x7b\xa8\x4e\x2b\x72\x92\x05\xd6\x3c\x66\x8c\x99\x74\x43\x5e\x36\xd4\x3d\x74\xee\xb7\x87\xeb\xd4\x71\x1b\x5c\xe4\x05\xb5\xbe\xb5\xa1\xb1\x68\x36\x5a\xfe\x6d\x75\xce\x0f\x02\x8f\x04\x3e\x1c\xad\x62\xd2\x5a\xd7\x19\xe9\xb5\xc3\xbc\xb4\x72\xca\xf9\x06\x05\x09\x3a\x50\x91\x9b\x21\x62\x97\x64\x25\x99\x40\xe9\x2a\x75\xc0\x02\x31\x94\x4c\x28\x51\x5a\x89\xfd\xc0\x5f\x52\xd3\xda\x5b\xa4\x22\xf2\xd5\xd3\x3f\x27\x0f\x0e\x5e\xf7\xee\xad\x63\x75\xfa\xeb\x7f\xbb\x67\xfd\xaf\xa7\xd1\xfa\xd3\x3f\x5e\x43\xf0\xa9\xfd\xd4\x93\x20\xf6\x81\x0f\xd8\x07\x3e\xe8\xce\x7e\x7c\x98\x01\xd3\x99\xe4\x47\x7b\x4e\x91\xf3\x4c\xe7\x29\x10\x3e\x3e\xcc\x90\xaf\xce\x24\x3f\x62\x3b\xfa\xd7\xb5\x39\x7f\xc9\x3e\x45\xba\xdd\xbe\x0f\x5e\xe4\x17\x3d\xf8\xf1\x86\x3d\x9f\xdf\x6e\xd6\xda\x60\xa6\x7f\xac\x11\x73\xf4\x6b\x89\xcd\x44\x0e\xd9\x15\xd7\x85\x87\xe8\xcf\xd1\x6e\xd9\xe7\xff\x39\xb4\x44\x36\xee\x27\xe7\xbb\x05\x10\x4e\x1d\xed\x96\xbd\x45\x3f\x27\x2f\x45\x36\xee\x47\x2c\xe2\xf3\x7a\x8d\x11\x68\x2c\x9a\x89\x16\xff\x9b\x32\x8c\xf2\xff\x7f\x82\x89\xd2\x8d\x68\x45\x49\xeb\x1e\x1d\xea\xa5\x15\x8b\x5a\xfb\x7a\xeb\x9c\x45\x90\xf8\xec\x65\x45\x58\x4c\xfe\xf5\xa3\xdf\x3c\xbb\x6e\xdf\x37\xda\xec\xc1\xf3\xd7\xc8\x2e\x30\x3e\x7b\xee\xd9\xfd\x27\x5e\xcf\xb7\x4a\x94\xcd\x66\x73\x59\x10\x4e\xad\x5b\x70\xf7\xdd\x0b\xd6\x9d\x62\xea\xb4\xca\x47\x2f\x2f\x6d\xa7\x73\xfe\x92\x7d\x92\x74\x7b\x82\x5b\x46\x9b\xbf\xd9\x58\xad\xa7\x20\xf8\xc0\x73\x60\xf6\x05\xb7\xcc\xa5\xad\xf1\xbf\xf3\xd5\x10\x56\xaa\xd5\xaf\xee\x21\xe8\x7c\xa8\xae\xbb\xb7\xea\x91\xcc\x43\x75\x97\xd8\x0e\x35\x50\xe4\xf8\xfe\x7d\xa6\xd0\x6b\x2c\x29\x5c\xda\x7b\xa6\xfb\x2c\x26\xbf\xb3\x1f\x7d\xff\x06\xbd\xbe\x4a\xef\x36\xdc\x30\xfa\xd2\xfe\x74\xf4\x71\xcd\xff\xf8\xfb\xff\xbe\x5f\xfd\xe5\x0d\x06\xb7\xbe\x4a\xaf\xbf\x71\xcc\xa5\xfd\xeb\xe8\xe3\x9a\xff\xf1\xf7\xbf\xa3\x9f\xc5\x17\x59\xda\xcf\xd6\x51\x3e\x47\x09\x39\xec\x98\xa5\x6a\x5d\x5b\x2a\x9d\xec\xfb\xc8\x82\x06\xea\xa4\x65\xa3\x27\x9f\x7d\xd5\x02\xe7\xf3\x83\xb3\x67\x21\x7a\x82\xfc\xf2\xd8\xee\x4f\xf6\x15\xa8\x92\x85\x2a\x3f\x0f\xcd\xd4\x12\xf1\x86\x98\x10\xdf\xd0\xf2\x33\x53\x0b\x38\xdf\x97\x1b\x66\x8b\x93\x9c\xfa\xe8\x21\xf2\xf9\x7e\xd1\xbc\xff\x0f\xd7\x1e\x04\xdb\x09\x8b\xf6\xd9\x0e\xcf\xd4\xee\x79\x5d\x14\x5f\xd7\x1e\x34\xf3\x30\x0d\xe8\xca\x5e\xda\x0f\xb1\x08\x09\x59\x76\x6b\x4f\x5e\x28\x0a\xba\x96\xea\x7e\xe2\x92\x47\xa1\x60\x38\x3f\xda\x92\xe4\x78\xb2\x47\x09\x1a\xe8\x01\xa3\xea\xf9\x36\xc2\x0a\x51\x24\x1f\xe8\x3d\xfa\x4a\x83\xe1\x14\xf9\x20\x2f\xe3\xbf\x23\x8d\xa0\x9c\x32\x18\x2a\xf5\x1e\x7d\x57\xa6\x2f\x4b\x78\x85\x98\x10\xc9\x07\x5a\xc0\x29\x4d\x0a\x9e\x25\x67\x4f\x40\x59\x6f\xf9\x68\x9e\xa7\xb4\xb7\x74\xff\xf9\x1b\xfd\x2a\xfd\x36\x32\x2a\xca\x8f\x21\x7b\x81\xe0\x90\x3a\x23\x88\xf9\x71\xef\x30\x40\x1d\x2e\xd2\x94\x9c\x25\x67\xf3\x1f\x3f\x27\xf4\x2b\x5d\x3a\x40\xcc\xdd\x43\x6d\xc2\xe7\xab\x3d\x55\xbe\x96\xe4\xce\x5c\xf6\x4e\x84\xd8\x2c\x9b\x45\x02\x92\x11\x42\xf9\xc1\x28\xea\xad\xce\x31\x3f\xb0\x88\x9c\xef\x1d\x47\xee\xe9\xab\xad\x9f\xbf\x7f\x10\xfa\xf5\x99\x38\xd9\xe7\x3f\x63\xc6\x41\xd4\x0f\x87\x2d\xdc\x8f\x6b\xd3\x1a\x4f\x87\xd4\xe1\x7b\x9a\x9a\x12\xfa\x20\xe4\x88\x5b\x7b\x81\xe3\x1e\x09\xc5\x62\x21\xb2\xe9\x55\xff\xef\xab\x5b\x37\xb7\xac\xdd\xfb\xe0\x6b\xaf\xe5\x02\xaa\x1f\x97\x8d\x85\x2e\x1c\x0b\xc5\xf0\x84\x3f\xde\x56\x5b\x0b\xef\xe8\x0f\xed\x7f\xe4\x8f\xb9\x1f\xc6\x42\xdc\xe4\x50\x0c\xe5\xdf\xc5\xa9\xf2\xad\x1d\x21\x6b\x42\x9d\x17\xb0\x12\x25\x1d\x0d\x2a\x51\x13\x6f\x06\x6a\xc8\x68\x4b\xf7\x2d\xbb\x6b\xb6\xe0\x2c\x5d\x34\xa5\xc0\xe6\x9a\xd6\xb6\x8a\x19\xb9\xeb\xf8\x4f\x17\xdd\x07\x96\x63\xca\xf8\xf5\xc7\x17\xb5\x5e\xeb\x33\x84\x0b\xfc\x52\x59\x2c\x62\xd2\x9b\xcb\xa7\x0b\xc5\x8b\xc7\x36\xb5\x4e\x9d\x9e\x49\xcf\x6e\xa9\xf1\x18\x7f\xfd\xd8\x6b\xe4\xef\x2e\x9f\xcb\x2f\x61\x73\x7c\x4c\xb9\xc4\x3c\xb2\xfc\xc5\x9b\x16\x27\x76\x93\x43\x1d\xcf\x1c\xdb\x3e\x2a\x53\x1b\xbd\xb5\xfc\x8a\xf2\xf1\xc3\x63\x9c\xe1\xde\xa2\x99\xbf\x87\xe9\xfe\x81\x8b\x27\xec\x1f\xd7\x3c\xe8\x42\x73\xcb\x84\xd8\xe4\xc5\xeb\x96\x54\xff\xf0\x25\x92\x7b\xb5\x62\xfc\x80\x72\xbd\x77\x3a\x63\x1e\xbf\x6c\x45\xcf\xba\xf4\x66\x1e\x71\xd7\xa2\x72\xd4\x8c\xc6\x21\x84\x34\x64\x12\x6a\x7b\x4e\xe7\xd9\x69\x8d\x8e\x4c\xa2\xd6\x88\x40\x33\x44\x71\x86\xa4\x78\x8c\xe9\x8f\x73\x2b\xa4\x25\x5b\x0f\x0c\x59\x28\x18\xe5\x44\x6a\x7c\xc4\xbc\xe9\x7e\x98\xc3\x56\xcb\x95\xd5\x75\xbb\xe7\xdd\xdc\x3e\x0c\x98\xa1\x4e\x2f\xef\x14\x44\xb3\x4e\x17\x1b\xc2\x05\x5b\x6b\xe7\x14\x1a\xcc\xab\xb6\x7d\x76\x74\xfe\xfc\xa3\x9f\x91\xcf\x8e\xce\xdf\x38\xe6\xab\xfb\x82\x10\x03\xf9\x8d\x8d\x1b\xdf\x20\x9f\xdd\xf5\xe3\x63\x64\xce\xde\xe5\x1b\xdf\xc0\xb1\xa9\x7a\xce\x10\x28\x8f\x26\x9b\x2b\xf7\xaf\x5a\x36\x45\x37\x63\xb0\xc4\x18\x1d\xf6\xbd\x82\x63\xb8\x41\xd0\x0d\xcf\x24\x07\x08\x64\x4c\xfe\x21\xf3\x8f\x7e\xb6\xed\xcc\xe1\xcf\x46\x2d\xe6\x16\xaa\x0f\x21\x6f\x93\xcf\xde\xd8\x38\xfb\x5a\xb8\xfd\xf1\x5f\xdc\x05\xf2\x1b\x94\xd7\x25\x8f\x3f\xa6\xe1\x05\x89\x74\x8d\x38\x8a\xca\xd5\x19\x4b\x3a\x90\x0c\x58\x03\xc9\x40\xef\x56\xa5\x7e\x6e\x5b\x2f\xce\x08\xe5\xa3\xa1\x47\x96\x45\xdd\x48\x3d\xf8\xe2\xda\xb1\xb5\xb5\x63\x2f\x38\xfb\x5d\x68\x7f\x77\x9e\x47\x02\xd2\x8e\x2c\x05\xa5\xb9\x93\x06\xb0\xc5\x3d\x2e\xac\xc5\xcc\x15\x93\x2c\x64\x31\xea\xfb\xed\xd5\x3b\x52\x2c\xee\x72\x34\x1a\x21\x54\xac\x58\x52\xc5\x92\x05\xf2\x43\xd8\x7e\x56\x24\x3d\xfd\x40\xa0\xc7\x7a\x84\x12\x9c\x3b\x7a\x16\x93\xb8\x78\xcf\x0c\x26\x1e\x93\x29\x33\xde\x1c\xf2\xf2\x27\x9f\x40\xf3\x27\x38\x03\x1d\x46\x51\x34\x92\x43\xa2\xb1\xd3\x28\x92\x43\xea\x05\x74\xd0\x8b\x5c\x71\x7b\x02\x50\xeb\xa2\xee\x03\x9b\xf6\x0b\x8e\xe2\x54\xdb\x82\x26\xd1\x3e\xe6\x8e\xc7\xef\x18\x63\x17\x77\x4d\xfa\x4d\xa2\x1d\x67\xf3\x00\xff\xe4\xfe\x6f\xde\xad\x3d\x37\xd7\x99\x68\xff\x4b\xec\xfa\x4d\xc9\x05\xeb\xe6\xcf\x19\x5c\x62\x6d\x6a\x6a\x6a\xb2\x76\xb4\x27\x7a\x6c\xa2\x85\x7f\xd1\xfc\xc5\xd1\xe4\x7e\xf9\x53\x6b\xa2\x19\x34\xb4\x0c\x0d\x0b\x30\x99\x68\xa1\x4d\xac\x05\x28\x2d\x9f\x46\xce\xa7\xd6\x57\x4e\xa0\x70\x0b\xfd\x33\x2a\x15\xd3\x6c\xd2\xc1\x57\x5f\x3e\x7f\x74\x5e\xaf\xdf\xab\x37\x9a\xf4\xe7\xcf\xeb\x4d\x46\xfd\x5e\xbd\xea\xb8\xcc\x27\xe7\xf8\x51\x24\x32\xc1\x21\x5f\x92\xe1\xbb\x61\xc4\xdd\x76\xd1\xeb\xf3\xba\x23\xbd\xf9\xcd\xfd\xe6\xbb\x1f\xd2\xe7\xf3\xa3\x48\x2a\x19\x99\xc0\xf4\x65\x7e\xf3\x66\x2b\xef\xa9\x0a\xa4\x22\xfd\xec\x62\x6d\xc8\x4d\xe5\x17\x1d\x2a\x69\x76\xfa\xf9\x4f\xd8\x53\xf5\x02\xbd\x96\x34\x80\xf8\x4e\xb7\x72\x11\x5d\x40\x17\x11\x5d\x04\xc2\x99\x03\xef\x1d\x38\xf0\x1e\x37\xf9\x93\xfb\x73\x19\xb7\x82\x91\xe2\x26\x19\x50\xc5\x3c\xc5\x3a\x23\x92\x1a\x7a\x20\x73\xff\x27\x8a\x9b\x64\xfb\xb0\x74\x55\x39\x26\x51\x2b\x17\x26\xee\x08\x08\x01\x47\x40\xaf\xd6\xf5\x68\x20\x19\x67\xa8\xc9\x8b\x18\xe2\x51\x67\x27\xf9\x4b\x1a\x86\x93\x05\xe4\x20\x39\x48\x16\xc0\xf0\x34\xf9\x4b\x67\x27\x20\x18\x0c\x9b\x61\x30\x41\xcb\x7f\xc5\x23\x92\xe9\xcc\x76\x76\x77\x32\xea\x09\x3a\x73\x88\x41\x5d\x19\xe8\xe3\xd5\x46\xf9\xbe\x26\xa4\xca\x67\x56\x95\xcf\x82\x2c\xd1\x4f\xd5\xa2\xd1\x6a\x87\xe3\xb6\x1e\x66\x51\x6b\xc0\xca\xaa\xe3\xfe\xae\x27\xdf\xb7\x58\xa4\xae\x73\x92\xc5\xf2\xfe\x93\x5d\x20\x9c\xfa\x82\x92\x38\x31\xa8\x2b\xcb\xa3\xe7\x76\x77\x67\x77\x3c\xc3\xbd\x61\x2e\x29\x31\xbf\xc1\x3d\xb3\x83\xc9\xee\x7e\xee\x42\x27\xe5\x6c\x82\x77\x31\x22\xe8\x52\x9e\x29\xed\xdd\xe5\xda\x6a\xc4\xb7\xbf\x1f\xf7\x7b\x3f\xfa\x8f\x69\xf9\xad\xc6\x59\x9a\xc9\x9d\x63\x88\x46\x69\x9a\xc9\x75\x7e\x47\xb2\x34\xaa\x57\x78\x59\x4d\x56\xae\xff\x45\x8f\xae\xe6\x7a\x01\x71\xeb\x29\xff\x8a\x97\x62\xde\x58\x69\x07\x91\xa7\xf3\x8e\xc7\x64\x90\x64\x3d\xb6\xda\xf9\x60\x34\xa2\xf6\xd5\x7a\xd0\x3c\xf1\x24\x97\xd3\x6a\x21\xd5\x0e\x9f\x5d\x34\xf9\xe1\x22\x93\xc1\x52\xee\x73\x76\x99\x77\x80\x4c\x86\x62\x57\xee\x62\x05\xd9\x0c\xad\xd6\x90\xa9\x10\xfb\x58\x76\x46\xd7\x32\x57\x48\xf7\x99\xa1\x5a\x66\xaf\xb2\x7b\xcd\x17\x11\xb3\xa8\xfb\x3e\x30\xe0\xb6\xae\xdf\xba\x8a\x8c\x1f\x32\xbf\x67\xba\x5f\x1c\x8a\x37\x63\xb3\x97\x27\x5f\xe1\x4b\xf0\xd5\xcd\x97\xe3\xab\x07\xac\x97\x63\xaa\x5f\x40\x97\x21\xa9\xb3\xc7\x34\xeb\x37\x27\x9a\x78\x91\xd7\xfd\x80\xbb\x98\xdf\xa7\x5c\x8d\x5a\xd1\x28\xd4\x0d\x3c\xd8\xc0\x03\x11\x88\x41\x23\x0c\x85\x71\x30\x1b\x96\xc3\x06\x78\x02\x5e\x86\xb3\xf0\x19\x10\x6c\x44\x88\x33\x01\xc5\x54\x4b\xa5\x53\x12\xe7\x07\x8d\x89\x39\xaa\xf0\x69\xea\xa6\xa4\x66\xbc\x16\x27\x99\x50\xe3\x40\x3c\x28\xe4\xc1\x75\xa2\x79\x75\x66\x42\x49\x57\x81\xd0\x8c\xfd\x00\x92\x20\x39\x24\xed\x89\x6c\x84\x92\x54\xa7\x53\x69\x45\x9d\x5c\xe4\x7f\x13\xda\xfc\x56\x4e\xe6\xbb\xbd\x54\xba\x19\x4b\x72\x5c\xed\xea\x9a\x21\xad\x44\x95\x68\x22\x5d\x95\xbf\x2f\x25\xc9\x76\x3f\x23\x4b\xea\x23\x04\x8a\xb1\x54\xc5\x46\xc3\x20\xc9\x52\x3a\xde\xcc\xb4\x40\x33\xc8\xda\x92\x2a\x08\x0e\x5e\xe0\x05\x3f\xc8\x6a\xa4\x78\x33\xf8\x69\x08\x45\x41\x0d\xd9\x85\x94\xf6\x4e\x87\xa4\xfe\x0a\x92\x9c\x02\xbb\xfa\xab\xe6\x4c\x9d\x24\x69\x2c\x8a\x51\x5e\x08\x46\x25\x39\x96\x4e\x29\x1c\x35\xb4\x50\x28\x77\x96\xac\xa4\xd2\x35\x4a\xd4\xa4\xce\x34\x53\x69\xde\x0c\x49\x5e\xa6\xe5\xe4\x87\xb4\x9a\x60\x94\xe7\x4f\x48\x26\x18\x45\x48\xf2\x92\xe6\xaf\x70\xcd\xa0\x44\x93\x7c\x48\xa3\x31\x89\xf0\x94\xe1\xba\x19\xd2\xbc\x20\x09\x12\x2b\xa7\xc2\x69\x25\x9d\x68\x86\x26\x70\xd0\x37\x53\xcc\xc0\xa8\x49\x17\xe2\xa3\x26\x46\xe0\x43\x7c\x54\xf3\x51\x27\xfc\x12\x93\x4a\xaa\x45\x65\x02\x59\xfb\x3c\xd4\x60\x57\xbd\xcb\xce\x3b\x24\x0a\x37\x15\xe2\x65\x49\x66\x29\x45\x3d\x4f\xef\x09\x39\x62\x11\x35\x5b\x42\x2a\xa9\xc1\xe5\x29\x49\xfa\x28\x2e\xa5\x61\xc3\xda\xb5\x64\xc2\xc7\x3a\xc5\xe6\x4a\x62\x18\xef\x91\x25\x2e\x21\x28\xa2\x2b\x09\x78\x82\x47\x92\xea\x8c\x53\x82\x95\x23\xf6\x0c\x28\xa9\xbe\xb0\xc6\x38\x59\x73\x56\xe1\xd7\xa1\x34\xe4\x09\xa6\x94\x84\x97\x5b\x35\x66\xec\xaa\x55\xe7\xae\xf8\xdb\x16\xcf\xca\x6b\xd6\x8f\xc3\x5f\xe9\x44\x01\x66\x64\x53\x03\xa6\x4a\xb9\x71\xb9\x9f\xc8\x53\x6a\x26\x3f\x07\x98\x13\x75\xbc\xcb\xe4\x11\xf4\x05\x5e\x9f\xdf\x28\x7b\x43\x6e\x9b\xbd\x40\x48\x4e\x2d\xd0\xeb\xcd\xa3\x71\x50\xf1\x72\xc6\x2a\x13\x83\x0d\xa5\x06\xb3\x59\x6e\x85\xe6\xd5\xde\x62\x87\xce\x32\x42\xae\x67\x18\xcc\x0a\x9c\xa7\x66\x40\xac\x64\x73\x75\xd3\xc2\x5b\xae\xb3\x97\x25\x02\xcd\x85\x78\x02\x24\xe7\x35\x4e\x0a\x03\x27\xb0\x18\x03\x53\x2f\x0f\xb7\x09\x8e\x62\xef\xca\xc6\xa1\x4e\x93\xb5\xa0\x4c\x0f\xac\xa5\xc2\xc8\x79\x95\x20\x1e\x63\xd2\xeb\x0a\xa7\x26\x0d\x02\xd8\x6d\xee\x90\x57\x36\x05\xdc\x9e\x02\x83\xce\x6b\x94\xc9\x3f\xf4\xe3\xfd\xac\xc7\x6b\x2f\x1e\x1d\x72\x19\x07\xfb\x8d\x1c\x53\x1b\x37\x8f\xf0\x9b\xca\x0a\x1c\x92\xc5\x7f\xfe\x05\xff\x78\x7d\x40\xf4\x7a\x4a\x7c\xad\x46\x57\x28\x62\x8e\xa7\x59\xfd\xb3\xa6\x06\x31\x5c\x59\xe5\x76\x31\x67\x75\x56\x86\x31\x5a\x4b\x2a\xc0\x49\xce\xfd\xf1\xc8\x91\x3f\x1e\x49\x2d\x59\x0a\x82\xc1\xb7\xbd\x48\xcf\x72\xe4\x2b\x1d\xc3\xe2\xf7\x30\xcb\xf3\x05\xc1\x6b\xc9\x9d\x96\xd2\x3a\xb3\x8d\x61\x0c\xdc\x90\x97\x99\xc8\x2e\x90\x8f\x1c\x07\xc7\xc1\x00\x03\xd8\x3a\xc8\xec\xae\x8d\x17\x71\xac\x60\xc0\xbc\x5e\x28\xd4\x59\x74\x22\xbb\xb4\x8e\x2d\xf4\x5b\xbc\x3c\xf3\x84\x13\xa7\xaa\x2b\x0a\x75\x56\x7d\xbd\x0f\xc6\x31\xd6\xd6\x68\xe9\xa6\xa9\x5c\x68\x47\x2a\x3e\xd9\x28\xb3\x3f\x7e\x65\xde\xe1\xb9\xbc\x8c\x8b\xf4\x85\x15\x06\x11\x30\x23\x4e\xc2\x76\xbc\x80\x9c\x68\x1f\xab\xd3\x0d\xcc\xbc\xfb\x2e\x00\x7b\x88\x75\x9a\x44\x60\xcc\xe6\x32\x93\xbe\x08\x5b\x0a\xdf\x7c\xe2\xa7\xb8\x83\x9b\xba\xb1\x4c\x19\x62\x65\x0c\x93\xe3\xa9\x1d\xfb\x2c\x11\x41\xef\x12\xa5\x41\x1c\x1b\x77\xf4\x73\x4f\xf5\x0c\xd4\x1b\x43\x81\xaa\x15\x1c\x37\x29\xd8\xcf\xcd\x0e\x32\xeb\x2a\x3d\xa1\x58\xb9\x2c\x8e\x58\xb2\xe4\xb6\x25\x1f\xac\xa8\x1c\xdc\x38\x9c\x2f\x59\x71\xe1\xc3\x82\x22\xd9\x5a\xbb\xba\x0d\xe3\xea\x32\x97\xab\x74\x00\x66\x0e\x4e\x90\x6c\x45\x05\x06\xbd\xe4\xf3\xe9\x0d\x26\xbb\xc9\xa7\x2b\xf4\x72\x02\x6b\x1e\x8e\x0d\x43\x92\x4a\x79\x73\xc0\x1a\x31\xb8\x6c\x9c\x8d\x61\x81\x83\x02\xbe\x84\xe1\x59\x1c\x28\x0a\xaf\xaa\xdd\x9a\xb4\xc8\x3e\x70\x5b\x9c\x26\xc6\x84\xab\xbc\xac\xad\xaa\x3e\x39\xdc\xa8\x33\x1b\x75\x26\x66\x2b\xf9\xd7\xc4\xeb\x0d\x22\x63\x72\x9a\x4d\x26\xaf\xd3\x9a\xd8\x5a\xb7\x2a\x54\x1c\xc0\x06\x5c\xca\x15\x02\x07\x1c\x63\xe3\x6c\x4e\x9d\x62\x2d\x6e\x29\x29\x4d\xb6\xe9\x71\x8d\xd3\xcc\x0a\x9c\xb7\x50\xef\xb5\xd8\x8c\x7a\x83\xd7\xef\xd0\x31\x8f\xfa\x5c\xc5\xf3\x23\x57\xfb\x44\x76\x7d\xd9\xee\x7a\x63\xb1\xc9\x94\x59\x60\x31\x1b\x60\xed\x16\xa6\xf5\xda\x9a\xf9\xc5\x2e\x9f\x8d\x15\x7d\x57\xef\x2b\x32\xd5\xef\x2e\xe3\xcd\x96\xf9\x03\xad\x03\xb7\xac\x64\x4d\x22\x4c\x5b\xc6\x44\x95\x1b\x45\x9b\xa0\xb3\xef\x6c\xc4\x78\xe7\xe1\xab\xd6\x1d\x3e\xbc\xee\x2a\xa2\x60\x0c\x9e\xf5\x82\x09\x0a\x98\x61\x83\x9f\x65\xa7\x4e\x15\x81\xb1\x4f\x1c\xcf\x99\xf1\x6b\x0d\x1b\x5c\x3a\xde\x66\xb9\xcd\x87\x77\xc8\xc6\x1b\x7f\x9a\xae\x79\xf9\x2e\xa3\x03\x33\x0c\x00\x60\x01\xa6\x97\x29\x51\x5e\x67\xac\xe1\x74\x3c\xc7\x60\x0c\xa0\xb7\x5b\xc5\x02\x06\x83\xb5\xae\x45\xaf\xab\x32\x1a\x7d\x61\x9e\xc5\xb9\x5d\x26\xcb\xd0\xf5\x05\x85\xc9\x65\xa9\xe4\x58\x8c\x1b\x3f\x6c\xa9\x5d\xdd\x94\xd8\x3b\x97\xd5\x03\x8f\x6d\xa2\x5c\x60\x2c\x98\x30\x38\xf8\x96\xc3\x71\x6b\x4d\x48\x62\x18\x87\xb7\x31\x0b\xd5\xa9\x41\x4a\x00\x46\xb5\xeb\xac\x7a\xa7\xfd\xff\x31\xf7\xde\xf1\x71\x54\xf7\xfa\xf0\xf9\x9e\x69\x5b\x67\xfb\xae\xb4\x92\x56\x5b\x67\x56\x6d\x25\x6d\x95\x2c\x69\xb5\x96\xbb\x25\xdb\x72\x97\x2d\x4b\x96\x1b\x96\xe5\x26\x37\x6c\x8c\xc1\x8b\x6d\xaa\x6d\x30\xc6\x36\xd5\x58\xc1\x10\x20\xb4\x98\x9b\xd0\x8b\x20\x09\x2d\xe0\x40\x42\x0f\x45\xd4\x40\x12\x08\xe1\x06\x02\x96\x76\xf4\x7e\xe6\xcc\x4a\x96\x65\xdf\x9b\xfc\xee\xbd\x7f\xbc\xfa\x68\xf7\x94\x39\x33\x73\xe6\xec\x99\x53\x9f\xef\xf3\x98\x69\x86\x56\x3d\xd5\x5e\xb3\x2f\xbe\x3a\xa6\xd3\x6e\x9d\x68\xe4\x2b\x6b\x31\x6e\x56\xc6\x0c\xe3\xd4\xc0\x3c\x49\x46\xe6\x35\x44\xcf\xfb\x0c\x94\x02\xb8\x18\x1d\x44\xc2\x2e\x5a\x6e\x92\xb8\x24\x13\xa2\x38\xd6\x1f\xe2\x98\x7f\x74\x5c\xb1\x64\xc9\x15\x99\x4d\x4b\xae\xe8\xe8\xb8\x22\xb3\xb0\x7a\xf5\xe5\x57\xfe\xea\x15\x10\xa1\xfa\xed\xbd\x7f\xb8\x7e\x49\x19\x55\x3c\x69\xcd\x8e\x69\x8f\xae\x28\x58\xdc\xd6\x31\x51\xd0\xcd\xb8\x49\x3a\x71\x97\xf4\xde\x7b\x4f\xee\xda\x34\x7e\xbc\xa7\xbc\x44\x3e\x69\x09\x39\x75\x09\x53\x59\xbb\xa0\x31\x12\x74\xf0\x8c\xc6\xe1\x2e\xaf\x9a\x3c\x73\xc5\x9a\xb1\x47\x17\x46\x36\x2f\x3e\x6f\x66\x73\x6d\xa4\xd0\x48\x61\xa3\x2b\x1a\x99\x5a\x33\x27\x31\x73\x08\x73\x90\xd5\xe5\x2a\x24\xac\xa0\x8d\x68\x25\xda\x4a\x94\xb9\x46\x2a\x15\x09\xfe\x51\x34\xcd\x96\xb0\xcd\x64\x2d\x01\x6f\xcc\x14\x8d\xd0\x64\xb2\xc8\x0d\x2f\x27\x84\x20\x16\xc5\x6e\xda\x3c\x64\xf3\x6c\xb1\x29\x98\x3b\x85\xe4\xba\x00\x86\x43\x82\x9b\x1d\xcd\x85\x48\x17\x49\xf7\x4b\x2f\x7f\xb8\x67\xcf\x87\x10\x85\x59\x10\x95\x7d\x99\xb5\x67\x33\x3d\x6f\x34\x1a\xdd\x46\x23\x5c\xd8\xd5\xe8\x2b\x20\x53\xfc\x02\xdf\x4c\xc5\xb2\x79\xc8\x54\xfa\xf7\x24\x7a\xf7\x63\xbb\x89\x7b\x52\x7a\xef\x24\xd5\x21\x38\x07\xd2\x43\x84\xea\x4c\xef\x9e\x0f\xa5\x97\x47\xdd\xed\xd7\xe7\xe0\x85\xce\x4c\x37\x4a\xf2\xbd\xfa\x8c\xa9\xc6\x98\x6f\x8c\x69\x23\x6f\x36\xf3\x1b\x4d\x63\x7c\x31\xaa\x71\x94\x61\xb6\xf4\xb5\xb2\x9c\xd6\xb6\x7b\x77\x9b\xe2\x3b\x78\xf2\xe4\xc0\xd5\x98\xb0\x22\x12\xaa\xde\x21\x7b\x32\xb5\xc2\x2b\xef\x20\xe3\x3a\x79\x2e\x16\x31\xf9\x46\x15\x45\x8c\x8c\xa6\x6c\xa3\xa1\x55\x61\x3b\x97\xfe\x31\xcd\xa1\x74\xda\xcc\xff\x40\x40\xf0\x1c\xb1\x91\x6f\x8c\xb5\x37\xfc\xd0\xdb\xd0\xde\xde\xc0\xa5\x1a\xda\x63\x8d\x34\x92\xc7\xb2\x99\x5e\x48\x2b\x0b\xfa\x03\x8a\xed\x7b\x8f\x94\x8e\x35\xf6\xc8\xc9\x28\x92\xb8\xa7\x11\x8d\xca\x53\xde\x70\x9e\xb2\xeb\x11\xa3\xb2\x60\xcb\x85\xb3\xb2\x6a\x02\xc4\x20\x4c\xec\x83\x46\xe6\x62\x54\x16\x29\x94\x41\xb8\xb7\x31\x36\x2a\x0b\x99\x8e\x33\xf3\x08\xee\xff\x8b\xfc\x50\x69\x1a\xfd\xff\x29\x3f\x18\x31\xff\x77\xe5\x83\x87\xf3\xe3\x40\x25\xa7\x57\x8e\xfe\x9d\x9c\xa8\xfe\xfb\x5c\x50\xff\xd6\xfd\x01\xa1\x41\x86\xbe\x90\x45\x28\x9f\xb0\x78\xb2\x3e\x8f\x65\x48\x2a\x93\x28\x9a\x08\x59\xe5\x77\x07\xbd\x96\xc8\x7f\xec\x7a\x51\x63\xcd\x39\x91\x5b\xa1\x7d\x5a\x7a\xc1\xe2\xd4\xe9\x82\x41\x9d\x2e\xcf\x0c\x5f\xb9\xc4\xa0\xe4\xcf\xad\xd0\x36\x6a\xac\x39\xf0\x6b\xe9\x05\x0b\x63\x2a\x66\xfa\x8a\x4d\x8c\x45\xe1\xaf\xa6\xd2\x2c\x22\x1a\x05\x6e\x9b\x29\x62\xf3\x99\xac\x9e\x88\xcd\xe7\x16\x59\x8f\x2f\x16\x71\xc7\x4c\xbe\x58\xc4\x14\x25\x7e\x47\xdc\x13\xb1\x51\x29\xa9\x37\x9d\x86\x54\x2a\x25\x7d\xd3\xdd\x2d\x7d\x93\x4a\x41\x2a\x9d\x96\x7a\x53\x29\x30\x76\x77\x83\x31\xc5\xa4\xfb\xa4\x8e\x74\xa6\xaf\x2f\x7d\xf0\x60\xba\x0f\xbb\xd3\xd0\x43\xbc\x4a\x71\x0e\xd9\x35\x0c\xa9\x3d\x94\x10\xd6\x8b\x1a\xb2\x72\xea\x33\x45\x4c\x04\x88\x64\x92\xdf\x54\x8f\xcd\x13\xf3\x30\x36\x22\xc2\x1c\x33\xc5\x7c\xb6\x40\x2c\x62\x22\x88\x56\x53\x44\xd1\xd3\xcd\x1a\xac\xcb\x2e\xb1\x5f\xb7\xa9\x50\x3a\x2d\xa5\xfb\x91\x94\x4e\xa7\x21\xcd\x20\x48\x0f\xa2\xf4\x8f\x28\x9d\x66\x51\x3a\xdd\xaf\xb8\x12\x82\xf4\x40\x5a\x4a\x53\xe9\x0c\xc2\xe9\x4c\x9a\x46\x83\x48\x4a\xd3\xe9\x81\xec\x59\x34\x82\x21\x7d\xdc\x53\x48\xfe\xa6\xb3\x9a\x0f\xb2\x2f\x83\x48\x0d\x4a\x63\xb9\x16\xc9\x27\x64\xb9\x73\x90\x5a\x7e\xa6\xc2\xe1\x35\xa2\x48\x56\xc3\x62\xfe\x99\x4f\x75\xe6\xb3\x99\x7c\x43\x4f\x08\x23\x9f\xd2\x67\x8b\x04\x3c\xa7\x1f\x15\x62\x44\x9d\x5a\xae\x67\x31\x4f\xf6\x52\x11\x9b\x27\xa6\x26\xcf\x2a\x3f\x49\x5a\x4a\x2b\x59\xa7\xd2\x20\x3b\xe4\xa9\x33\x28\x7d\x2a\x9d\x4e\x33\xe9\x74\xba\x3f\x4d\xa5\xd3\xe9\x01\x45\x97\x42\x8e\x18\x3a\x85\x22\x34\xc6\xca\xb9\xf2\x07\x13\x57\xca\x8a\x03\x93\xef\xfe\x6c\x51\x60\xb2\xfd\x91\x51\x8e\x20\x3c\x74\x4f\xb9\x00\x4e\xcf\x05\x4d\x28\x87\xbc\xb5\x23\xde\x0e\x93\xc7\xcb\x3a\x3c\x72\xad\xe5\x68\x34\xd0\x11\xac\xaa\x0a\x32\xa9\x60\x15\x91\x28\x86\x8b\x0c\xe1\x47\xc2\xb3\xc0\x2d\x75\x28\xb1\x55\xc1\x81\x8e\xaa\xc9\xb3\xc2\x8f\x84\x0d\x68\xa4\xad\x0d\x4b\x74\x95\x11\xf8\x6c\xf1\x7a\x88\x07\x86\x56\x3f\xe4\xb6\xdb\x00\xa7\xcd\xa1\x88\xa5\xd0\xb6\x1f\x0a\x74\x8f\xea\xa4\x6f\xc1\xdd\x8f\xa8\x74\x15\xbc\x10\xcc\x7f\x24\xbf\x23\x38\x80\x86\x6e\x0d\xe8\x07\x8d\xee\x51\xdd\x51\x2a\xdd\x8f\xc0\x1d\xac\xa2\x7a\x06\x50\xb0\x23\xff\x91\xfc\x60\x36\x13\x43\x9a\x4e\x43\xfc\x59\x39\x48\x44\x63\xd1\x1c\xb4\x9c\x58\x5d\x0e\x13\x12\xc6\x87\xfd\xf6\x88\x9d\x21\x62\x29\x3e\xaf\x68\x73\x41\x21\xb8\x03\x31\x96\x63\x85\x28\x99\x2f\x86\xa0\x1c\x04\x62\xc9\x9c\x20\xa6\x6b\x31\x45\x71\xdb\x2b\xf8\x3c\x26\xcf\xd9\xa6\x4e\xdc\xb1\x42\x87\x4a\x73\xe3\x8d\x1a\x95\x43\xef\x72\x50\xba\xbd\x7b\x29\x2d\x38\xfa\x57\x7d\xda\x34\x6e\xcd\x05\xb1\x2b\x8a\x8a\x61\x32\x7e\x69\xd9\x8a\x35\xdb\xb7\xaf\x59\xb1\xac\xa2\x33\x3f\x7f\xe7\xc3\x4b\x4b\x4b\x97\x3e\xbc\x73\x05\x35\x65\x5e\x43\x75\x6a\x56\x03\x65\x66\xa4\x6a\xf8\xcb\xd4\xc5\x67\x52\x14\x45\xa3\x01\x06\xef\xc3\xcc\x03\x61\x2f\x0d\x97\x00\xdd\x07\x51\xe9\xe5\x31\x53\x6a\xba\x0d\x46\x00\xcf\x86\x28\xa7\x5a\xfa\xd8\x52\x15\x17\xe9\xd6\x19\x30\x66\x83\xcd\x1d\x9b\x3b\x9a\x83\x2c\x7d\x75\x7c\x02\x43\xa9\xc6\x85\x12\x0d\x14\x48\x78\x0a\x15\x3f\x83\x7f\x88\x19\x2e\x27\x06\x69\x91\x13\x85\x50\x52\xae\x01\x3c\x58\xed\xfe\xa8\x20\x9a\xe2\x88\x28\x9f\x85\x88\x74\xa7\x9b\x06\x62\xc8\x4d\x2c\x54\xcd\x74\xc4\x13\x4e\xe2\xb3\xac\xa6\x16\x76\xed\xd9\x83\x97\xee\xe9\xea\x82\xd6\xa3\xd2\xb7\xc7\xb6\xbe\x73\xb4\xed\x28\xf0\x90\x04\x1e\xe7\xaf\x7f\xe4\x3f\x77\x4b\x7f\xf8\xb9\xf4\xce\x03\xf7\x43\xf1\xfd\x50\x76\xc9\x77\x8f\xac\x87\x96\x91\x4f\x09\x22\xfe\x65\xd1\x93\x7f\x7e\xf2\xc9\x3f\x3f\x59\x94\x99\x5a\x04\xaf\x49\xcf\x4a\xdf\x1e\x6d\x3b\xfa\xce\xd6\x63\xc0\x1f\x3d\x2a\x35\xed\xfd\xee\xa7\x1d\xb7\x49\x6f\x3e\x76\x8f\xf4\xc7\x9f\xad\xb8\xfb\xaf\x14\x7b\x26\x0f\x16\x75\xc6\x58\xad\x06\x21\x66\x54\xdb\x7e\x16\x7f\xb4\xcd\x77\xda\x80\xcd\x4e\x78\xfb\x4e\x73\x53\xa5\x2d\xfa\xfe\x5e\xbd\xc5\xa2\xa7\x53\x7a\x4b\xba\xbd\xa1\x9f\x34\xf5\x74\xaa\xa1\x5d\x4a\x0f\x1f\xeb\xe9\x19\x8a\xec\x90\x93\x65\xa3\xe9\x69\xa7\x13\xb7\x43\xb2\xa7\x67\xe8\x48\x3a\x1b\x97\xd5\x7b\x55\xc9\x6d\x37\x46\x0c\x8a\xa1\x3a\x34\x17\xad\x45\x48\x0d\x1e\x35\x78\x80\x07\xce\x34\xbc\xfe\x3b\xbc\xea\x1b\x02\x71\x38\x40\x58\xc6\x87\x92\xd0\x43\x6b\x5a\xca\x8e\x0b\x01\x16\xc6\xc3\x0e\x17\xcd\x8c\x8e\x60\x7b\xa5\x34\x85\x7e\x94\x5b\x50\x04\xbf\xe4\xeb\x83\x98\x8c\xc2\x4e\x91\xde\x0d\x77\x04\xeb\x79\xc9\x46\x7a\xb0\xbf\xd8\x96\xee\x58\x6a\x83\xbf\x90\xed\xc3\xfa\x86\xf2\xf2\x86\x72\xfa\x40\xdb\xd5\xd7\xed\xb9\xee\xea\xb6\x89\x1b\x97\x77\xd2\xe6\x26\x33\xdd\xb9\x7c\xe3\xc4\x7e\x74\xae\x58\x3a\x95\x49\xe1\xde\x4c\x8a\x4a\x07\xeb\xf9\x53\xdf\x9d\xa6\x27\x62\xb4\x7c\x7d\x90\xf8\xaa\x27\x4d\xaa\x26\x1e\x63\xb9\x7c\xf9\x81\x25\x53\x36\x37\x78\x3c\x0d\x9b\xa7\x68\xf7\xbd\xf6\xd0\x63\x9c\xc7\xc3\x3d\xf6\xd0\x6b\xfb\xb4\xe7\x8c\x1d\xb9\xc6\x59\x86\xa6\x21\x04\x46\xcc\xd9\xcd\x43\x90\x87\xd3\x12\x5c\x46\x73\x42\xc0\xa6\x11\x9b\xf8\xe4\x30\x24\xa9\x98\xc7\xea\xc2\x0e\x17\x58\x59\x8e\xa7\x6c\x9e\x68\x08\x8b\x21\x88\xc6\x99\xf4\x1b\x3d\x3d\x6f\x28\x65\x42\xb2\xdc\x31\x1c\x66\x14\x7b\xca\xab\xa6\x1d\xd8\x34\x71\x00\x4d\xdc\x74\x60\x9a\xc5\xe1\xb0\xc8\x21\x7a\x28\xc4\xa4\xa5\x7e\x69\x7d\x57\x97\xb4\x5e\xea\x1f\xc1\xce\xc4\xc0\xb5\x5d\x5d\x70\x2d\x30\x23\x58\x9a\x6a\x0b\x76\x3e\xf8\xed\x9e\x3d\xdf\x3e\xb8\xb3\x80\xf3\x04\x3d\xdc\x99\xc1\x91\x6b\xab\x65\xa4\x3f\xfa\x7f\x7b\xc2\x12\xf0\x58\x1d\x9e\xb8\x49\x7e\x2c\x1f\x4f\xd9\xfe\xe5\x63\xf5\x0d\x20\x35\xf5\xb5\x7a\xfc\x86\x7d\x4d\x9f\x37\xed\xdb\x30\xfe\xdf\x7f\x92\x86\x64\xdd\xa9\x71\xbb\xfe\x76\x62\x67\x61\xe1\xce\x13\x7f\xdb\x75\xe6\xba\xb0\x9c\xf7\x9a\xff\x59\xde\xa9\x10\x88\x3e\x1e\xb8\x7f\x27\xeb\x73\xa9\x79\x73\xab\xe3\x0f\xaf\xfc\x7c\xe5\xc3\xf1\x7f\x3f\xe7\x27\x1f\x7c\x70\x80\xdf\xff\x62\x71\xf1\x8b\xfb\xcf\xac\x4f\x93\xfe\x77\xf5\x89\xe5\x3c\xc2\xff\xac\x32\x5d\xb9\x1a\x3f\xb1\xfa\xca\xff\x5d\x45\x8a\x5c\x7b\x6d\x44\xa9\x42\x23\x7e\x07\x03\xaa\x46\x53\x10\x62\x46\x35\x29\x89\xa4\x2a\x11\x52\x89\x1e\x5e\xc5\xb9\x54\x0e\xcb\xa8\xa3\x4c\xdf\xe9\x9c\x2f\xa5\x9c\xde\x31\x95\xcd\xd1\x05\xa5\x25\x25\xa5\x0b\xa2\xcd\x95\x63\xbc\x4e\x8a\x1e\x38\x57\xec\xd2\xd3\x67\xa5\xcc\x3c\xb1\x4c\x4e\xf3\xe6\x54\xa2\x73\x5e\x4b\xaa\xb1\x6c\xac\x2b\x3f\xdf\x35\xb6\xac\x31\xd5\x32\xaf\x33\x71\xae\x38\x16\x9d\x3e\x69\x04\x76\x02\xa1\xb1\xa8\x0b\x21\x62\x95\xec\xcb\x4a\xaa\x9b\x44\xc5\x53\x00\x56\x07\xd8\x6d\x4a\x1b\x5f\x07\xd1\x84\x25\x9e\x25\x1c\x53\xd2\x8a\x23\xbd\x62\x98\x68\x81\x93\xaf\x02\xb0\x12\x92\x2e\xa5\x53\x00\xe5\xb1\xc3\x0e\xc5\x8c\x8f\x42\xb1\x46\x77\xaa\x22\xd4\x40\xbe\x7c\x10\x17\x05\x27\x4e\x3b\x05\xcd\x1a\x0d\x89\x0d\x8b\xbc\x3a\xd4\xe0\x1e\x1b\x66\x54\x73\xc6\x56\x37\xd4\x74\x7a\xf3\xdc\xcb\xf7\xe9\xd7\xb2\xdd\xcd\x99\xf4\x9c\x35\xd2\xcb\x4d\xfb\x97\x69\x19\x76\xef\xe2\x68\x68\x32\x9d\x6e\x8c\xa5\xdb\x2a\xc6\x35\x84\xa4\xd9\xae\x7b\x65\xb7\xaf\xdc\x27\xbd\x2d\xd6\xcb\xd3\xde\xdc\x22\x3f\xfc\xc2\x5f\xf4\xbd\x1c\xed\xbe\x28\x38\x56\x85\x1b\x42\xe9\xed\x91\x69\x0c\xa4\xc3\xde\x78\x25\x77\xcd\xf2\xef\x23\xd5\x52\x53\x4e\x79\x73\xf7\x96\x39\x10\x9c\x72\x5e\xdf\xb2\xfd\xb0\x78\x97\x6d\xc2\xe9\xbd\x9e\x0e\x16\xa1\x4a\xd4\x82\x10\x92\x8b\xc5\xa7\xd8\x82\xe4\xc2\x10\x09\x23\x90\x92\x49\x58\xe2\xb1\xac\x95\x88\x6f\x84\x3b\x5c\x16\x71\x79\x8a\xc4\x51\xca\x90\x4c\x84\xac\xd5\x9f\xb2\x4d\x11\xa7\x6e\x5d\xd4\xe0\x6e\x58\xd4\x70\x93\x90\x8a\x35\x3a\x21\x2d\xa4\xf0\xcf\xbd\x71\xae\x89\x69\x50\xe2\xdd\xbf\xb8\x62\x53\xa1\xc5\xb1\x6c\xff\xaa\xeb\x55\x4d\xfc\x45\x33\x33\xcd\xb5\x6b\xfd\x52\x3a\x72\xa4\x6b\x7a\x78\xff\x32\x87\xa5\x90\x49\x37\x84\x32\xdd\xd8\x18\x6a\x68\x08\x65\xbe\x19\x44\xaf\x44\x1a\x63\x25\x5e\x09\x45\x4a\xbd\x70\xd8\x9d\x07\xdf\x12\xbb\xd1\x6f\x86\x12\xe0\x03\xa1\x67\x27\xd5\xd1\xfb\x97\x99\xd8\x7d\xab\x24\x3e\x58\x22\xad\x99\xd1\x99\x28\xc7\x68\xfc\xbc\xae\x23\x5e\x78\x70\xd9\x7e\xba\x6e\x98\x83\x8f\xec\xf5\x0a\x28\x86\xa6\xa2\xa5\x68\x37\x42\x8c\x3c\xbf\x52\x96\x59\x12\x1e\x05\x32\x3e\xcc\x34\xcd\x64\xe1\x4a\x1c\xc3\x52\xf2\xf8\x53\xa1\x2f\x0a\x84\x20\x46\xaa\x0c\xc7\x10\x8e\x5e\x39\x2a\x09\x54\x60\x88\x96\x9a\xb1\x65\x39\x47\x12\xb1\x68\x3d\x50\xe4\xa8\x62\xe3\xcf\x65\xb5\x2b\xea\x20\x42\x4c\x23\x6d\xf2\xa5\xe9\xca\x13\xc7\xeb\x1d\xc9\x29\x8c\xd4\xdf\x75\xe4\x48\xd7\x86\xd2\xa9\xad\x47\xba\x42\x65\x78\x33\x5c\xdb\x75\x64\xcd\x3c\xe9\xbe\x45\xd7\xdc\x7c\xdc\xe5\x6f\x08\x39\xad\x30\xab\xb2\x1e\x52\xb2\x4f\xfa\x20\xdf\x5c\x62\x34\xd6\x87\xad\x66\xe8\x70\xf9\xbf\xc8\x9c\x9f\x63\x8f\x35\x96\x05\x30\x9f\x21\x33\x52\xec\xf8\x32\xb4\x7e\xcd\xac\x29\x30\xbb\x24\xde\x18\x93\x5e\xbe\xc2\x2f\x97\x7b\x75\x74\x42\x48\x90\x5e\x4a\xef\xaf\x8c\x31\xae\x2d\x13\x04\xcd\x91\xd7\x8f\x98\xf2\x77\x37\x77\x1d\x31\xfd\xed\x48\x57\x66\x79\xcb\x5e\xdb\x5c\x07\x7e\x7e\xd2\x54\x3e\xe1\x09\x35\x68\x6e\xd2\x34\x87\x07\x51\xa8\x41\xb3\x47\xaf\x72\xda\x02\xf6\x70\x4a\xdd\xc3\x27\x28\xd3\x0f\xaa\xc6\x58\xb0\x81\x7f\x21\xd5\xd8\xd5\xd8\xf5\x5c\x7d\xc9\x79\x03\xc8\x32\x57\x3b\xa1\x14\xdf\x12\x6b\xbc\xd8\x53\x29\xbd\x1d\x4a\x4e\x0c\xbd\xfa\xea\xc4\x52\xd5\xcc\x58\xf1\x64\xd3\xfe\xe1\xba\x47\xe6\x83\x7e\xc2\x8f\x17\xb6\xcb\xaf\xe1\xb0\x04\x66\x60\x78\xb0\x22\xff\x08\xa2\xe2\x07\x53\x54\x04\x65\xc8\x65\x75\x81\xfc\xaa\x79\x6c\x9e\x2c\x6b\x52\xc4\x43\x50\x15\xd9\x59\x81\xfc\x5a\xcb\xf5\xd6\xc1\xb8\x20\xeb\x8d\xd3\x3b\xeb\xd6\xf9\x71\xed\xf9\xdd\xcd\x52\xba\xb9\x5b\xfa\x38\xf3\x41\x73\xf7\xdd\x5b\xe1\xf6\xe2\xcc\xac\xe5\xd7\xa9\xc6\x76\x37\xb3\xbd\x6d\x99\x5f\x89\xa9\x81\xb1\x4e\x81\x32\x9a\x34\x91\x42\x2a\x35\xd0\xeb\x14\x28\xd5\xe4\x32\x9c\x6e\x0d\x56\x31\x29\x4d\xb8\x50\x9a\xd0\xd0\x2e\x38\x71\xa5\x51\x0f\x75\x39\x05\x82\x13\xd2\x4e\x81\x45\x55\x95\x03\xff\x79\xec\x05\xe9\x68\x73\x77\x77\xf3\x89\x6b\xba\x9b\xdd\x5b\xef\x4e\x5f\xbe\x6c\xc6\x4a\x77\x73\xf7\x8f\xbd\xb0\xec\xe8\x4e\x4a\x1f\x15\x9c\x6e\x5f\xc8\x5a\x28\xb8\x05\x67\x29\x5f\x3a\xa6\x2a\x68\x30\xf4\x16\x04\xda\x1b\xdc\x4e\x81\xbb\x55\x1f\xca\xfb\x0d\x59\xc0\x52\x38\xf1\xe4\xb1\x5d\x18\x6d\x96\xdb\x2c\x41\xa4\x84\x58\x94\x7c\xc5\xb3\x14\x6f\x79\x90\xa5\x7a\x03\x9b\x95\xa3\xb2\x94\x24\x2c\x07\xac\x8f\xf2\xb2\x1c\xe5\xa3\x86\xc8\xa4\x2c\x23\xbc\x2e\x90\x3f\x11\x4f\x38\x01\x8a\xa1\x1e\xc7\xc4\xa2\x4e\x48\x0c\x91\x9d\x50\x3e\x8b\xec\x85\xdf\x4e\xbb\xc0\xb2\x42\xcf\x6c\xe6\x76\xb4\x99\x76\xcf\x9f\xbd\xcb\x3a\x7b\xa5\x75\xd7\xec\x05\x97\xf2\x8b\xb6\x71\x17\x6a\x12\xf6\x0a\x6f\x65\xee\xaa\x23\xd5\x61\x89\x19\x3f\xb7\x52\xa8\x53\xdf\xbe\xf3\x5a\x75\x9d\x50\x91\xa2\xf6\x38\x97\xa9\x93\x42\x79\x03\xb5\x99\xa3\x55\xcb\x55\x51\x0f\x7e\xa8\xd8\x0b\xfd\x55\x8d\xd1\x12\xaf\xf4\x4a\x6a\x32\x45\xa7\xca\xc5\x3a\xf5\x66\xe7\x11\xaa\x7e\x10\x2d\x6e\x84\x6b\xab\x23\x65\x76\x78\x3f\xcf\xd5\x76\x85\x66\xee\x9a\x95\x33\xa5\xdb\xe1\xde\x99\x2b\x37\xcd\xd7\x5c\xd5\x96\xe3\x93\x10\x57\x62\x74\x69\xb5\x87\x56\x25\xbb\x05\x69\x4f\x84\x4d\x57\x08\x99\x79\x78\xa1\x50\xd1\x50\x6e\xd0\x67\xde\x87\x1b\x02\x91\x86\x10\xaf\x93\xbc\xf9\x9b\x5d\xd2\x7a\x77\x91\x13\x2e\x2c\x19\x17\x9d\xe2\xfc\xfc\x13\x1a\x74\x10\xd4\x9b\xb5\xe5\xe3\x2b\x04\xc9\x85\xbb\x79\xbe\x62\x7c\x76\xcf\x57\x2e\xd7\x08\x61\x20\x59\x46\x98\xb8\xce\xdd\xd2\xd5\x29\x22\xe3\xbe\xd8\x88\x7e\x40\xf1\x98\xa2\x82\x48\x9a\xbb\x08\xe9\x09\x4e\x77\x04\x67\x37\x7c\x96\xac\xca\x94\xfc\xc1\xe9\x58\xe3\xf5\x45\x0d\xd1\xa9\x4a\xe3\x77\xd2\xee\x63\x16\xe5\x54\x35\x57\x29\x5d\xc4\xd4\x78\xac\xd1\x3d\x35\xbe\xfa\xb0\x5d\xb3\x6c\x6a\x79\x74\xc3\xa4\xbc\x82\xf6\x5d\xf9\x8b\x8c\x9d\x0d\x99\xb0\xd2\x10\x1e\x5e\x35\xa9\xe6\xc8\x9f\xdd\xe0\x96\xff\x99\x74\x63\x4c\x42\x52\xfa\xa5\x78\x53\x94\x34\x82\x79\x36\xe8\xee\x58\xfa\x4e\x51\x6d\x55\xb0\x4e\xee\x07\x52\x0b\x13\x33\x1a\x63\x1d\x78\x4c\x62\x46\xfa\xe6\xd5\xef\xe1\x09\xb6\xf9\xdc\xe5\xed\xef\x6c\x5e\x2b\x1d\x48\xcd\x54\x9a\xc1\x55\xd7\xfb\xb0\xaf\xeb\xc8\xa9\xac\x1d\x9a\xf2\x19\xb1\x2f\x1e\x20\x2a\xb6\x4b\xd0\x2e\xa2\xb4\x32\xf2\x11\x63\x26\x2a\x0b\x61\x2a\x04\x85\x6b\xd5\x24\x07\x38\x2f\x6b\x20\x54\x84\xa4\x12\x39\xbc\x3c\x95\x65\xb0\x54\xba\x8e\xa8\x00\x56\x87\xc5\x96\x88\xd7\x40\x62\xa8\xfb\x50\xaa\x26\x64\x4b\x9c\x22\xac\x2f\xa2\x32\xaf\x8e\x93\x89\x95\x01\xe4\xa9\x17\xa3\xaa\x2d\xdf\xef\x98\x6b\xdb\xdb\x92\x59\xde\x75\xe4\x6f\xa6\x23\x5d\xcd\xbb\xf3\x4d\x47\x5e\x3f\x92\x67\x9b\xb0\xe5\x31\x4f\x82\x9f\x3a\x29\x11\x6e\xd6\xdc\xa4\x69\x78\xc0\x1e\xb0\x39\x55\xfa\x3d\x9a\x86\x90\x27\xc1\xf7\xa8\x53\xfd\x63\x55\x3f\x9c\x57\x52\xff\x5c\x57\x63\x57\x63\xea\x05\xbe\x21\x18\x6b\xa4\xf3\x4b\x27\x68\xe7\x5a\xf6\x9b\x26\x17\xc7\x66\xaa\x4a\x27\xbe\xfa\x6a\x68\x62\x32\x24\xbd\x5d\xe9\xb9\xb8\x31\x46\x5d\xe0\xa8\x3f\x7e\xa2\x7d\x91\x74\xdf\xbc\x35\x47\xba\xe0\x5a\xbc\xb9\x2c\xd4\x75\xa4\x75\x6a\xe9\x06\xb9\x21\x96\xfa\x99\x29\x09\xbf\xeb\xf8\xcd\xf5\x95\x30\xcb\xea\x0c\x35\x5c\x6e\x34\x96\x98\xf3\xa5\x0f\x64\xbf\xdf\x05\x1d\x66\x6b\xb8\x1e\x56\xda\x73\x32\xe7\x4f\x58\x1f\xfa\x12\x3b\xe4\x76\x37\x93\xc6\x7c\xa0\xac\xf1\xd4\x5f\xe2\x25\x30\x7b\xca\xac\x56\xe9\x25\x21\x34\x21\x5a\x2d\xf7\x7a\xfe\x2b\xa4\x97\x63\x8d\xc3\x3c\x30\xdc\x2f\x68\x84\x72\xc9\xf8\xd1\x76\x6e\xe4\x4e\xd8\xce\x58\xec\x1c\x89\x15\xb5\x20\xbb\xa2\x16\x88\xb0\x8f\x28\xc4\x2c\x0a\x71\xa8\x85\x6c\x4a\x5b\x14\x4e\x98\x05\x16\xbd\xf4\xa6\x59\x7f\xb9\xde\x22\xbd\xa5\xb7\x98\x79\x2a\x57\x6f\xa1\xf9\x69\xa0\xd6\xe8\x2f\xd3\x99\x21\xf4\xa4\xca\xb6\xcd\xaa\x7e\xa2\x0c\xcc\xba\xcb\xf5\x1a\xf5\x74\x30\xeb\xae\xb6\xaa\xdf\xd3\x68\x28\x3d\xfd\xbe\xda\xba\x5f\x6f\xa6\xfa\xb6\xe8\xcd\x03\xaf\x93\x93\x4b\xcd\xfa\x2d\xbc\xd9\xa2\x19\xa8\xd7\x6b\x35\x26\x1d\x6e\x92\xe6\x5b\x2c\x70\x4f\xe6\x41\x9d\x49\xa3\xe1\xa9\x67\x74\x26\x4b\xe6\x87\x9c\x3c\xce\xa7\xc6\x2a\x8b\x69\x08\xc3\xa0\xcc\xa9\xd5\xa8\x18\x8d\x51\xec\x10\x44\x45\xc6\x21\xee\xc8\x3e\x8b\x48\xf9\xce\xa4\xba\x51\xc0\x64\x9c\x1d\x8f\xda\x24\x41\x23\x36\x48\xfc\x6e\xda\x4e\x9b\x6b\x3d\x73\x2e\xbc\xad\x61\x72\xf4\x15\x95\x5a\x65\xb9\xc1\xaa\x7a\xf6\x66\x33\xaf\xe0\xa0\x85\x74\x72\xee\xd2\xb9\x53\xd8\x32\xe9\x75\xe9\x9b\xdf\x6c\xd9\xf2\x1b\x30\x42\x29\x18\x89\xef\xdd\x73\xec\x42\x50\x63\x5b\x3c\x66\xe9\x4f\x53\xdf\x91\xf6\x9a\x78\xa3\x09\xd6\x4a\xb7\xc9\xd7\xa1\x7a\x79\x73\x4e\xe1\x2d\xe7\x2d\xba\xce\xaf\xa1\xe2\x5b\x7e\x23\x7d\x33\xea\x7a\x52\xe3\xa8\x0b\x5d\x7d\xf5\x37\x23\x9f\xbb\x0c\xb5\x2a\x4a\x57\x10\x4e\xc4\xcb\x41\x10\x05\x03\xf0\xcc\x30\xbd\x51\x21\xd8\x13\xf1\x7a\x88\x8b\x21\x5a\x19\x2b\x78\xfe\xbd\x64\x67\x15\xcd\xa8\xfd\x23\xdc\x76\x63\x27\xaf\x2d\x63\xcd\x46\x2d\x4d\x1b\xac\x79\xae\x80\xa5\x69\x69\xc7\xd4\xc0\x04\xa3\x51\x6b\x30\xaa\x62\x7a\x03\x65\x2c\x8d\xcd\x2a\x3b\xf4\xeb\x67\x29\xdd\x8d\x9d\xbc\xa6\x4c\x65\xfa\x17\x49\xaf\xfb\xcd\xb3\xe2\xd9\x85\x99\xb9\xfd\xec\xcd\x23\x28\xef\x34\x9b\x67\xe9\x69\xac\xa7\x68\x9d\x81\xd7\x71\xcb\xa7\x35\x2d\xcb\xe7\x79\x2d\x60\xdd\x74\xab\x85\x36\x16\xe6\x5a\x9f\x39\x70\xf0\x69\x39\x15\x4f\xfd\xab\x54\x74\xe5\x39\x8a\x1d\x6c\xe7\xf8\x0d\xe5\xf7\x28\x35\xd8\xc7\xf5\x32\x6e\x82\x29\x41\x6a\xda\xc1\x89\x6a\x48\xa8\x29\x31\xe1\x50\x03\x07\x1c\xe0\x3e\xb9\xa1\xcb\x74\xe0\x9e\xbb\x3a\x26\x4b\x6e\xe8\x7b\x46\xfa\x10\xf7\xe0\x9e\x4c\xc7\x5d\x1d\x93\xa1\x4f\x72\x3f\x03\x9e\x0e\x29\x8d\xfb\xa4\xb4\x94\x96\x0f\x90\x64\x72\x74\xa1\x9c\x28\x9b\x4c\x3e\xed\xa3\x0e\x48\xa3\x33\xd6\x8d\xe4\x7b\x8a\x08\x05\xd4\xc0\x39\x38\x35\x38\x12\xa2\x9a\x49\x88\x09\x35\x88\xdc\xe8\xaa\x8b\x5f\x01\x83\xf4\x65\x4b\x6f\x87\xf4\x25\x38\x82\xf3\x77\x4a\x63\xa8\x52\x78\x4e\x1a\x23\xfd\x1d\x1c\x2d\xbd\x1d\xe0\x90\xbe\x0c\xce\xa7\x9a\xce\xf1\x90\x0f\x81\x01\x1c\x2d\x4f\x77\x80\x43\x3e\x31\x2d\x8d\x91\x1a\xe0\x39\x78\x4e\xfa\xbb\xf4\x65\xcb\xd3\x1d\xd2\x97\xd2\x97\xc1\x16\xf8\xf1\x1c\x95\x52\x83\xd0\xe0\x7b\x6a\xc4\xf8\x91\x16\x59\x50\x7e\x56\x65\x73\x02\x9a\x8d\x5a\x51\xfa\x4c\x55\x80\xa1\x5d\x55\x26\x0b\x2f\x8b\x13\x11\x61\xa2\x95\x42\x52\xc9\xad\xbe\x3f\xeb\x8b\x28\x30\x7b\x1e\x08\x01\x1b\x08\x1e\x37\x17\x76\x61\x5b\x34\x89\x87\x90\xbc\x16\x0f\x4f\xe0\xe9\x98\x26\xed\x3b\x17\x02\xc2\x63\xe9\xc7\x31\x02\x9b\xf1\x10\xf1\x73\xbc\x37\x21\x88\x89\x84\x28\x24\xe8\x5d\x89\xe9\x89\xc4\xf4\x01\x71\x43\xcf\x86\x0d\x3d\x1b\xe8\x4b\x36\x34\xcf\xd8\xb8\xa1\x67\x60\xc2\xf1\x4d\x9b\x8f\xdf\xfe\xf9\x71\x7a\xd7\xf1\xcd\x9b\x8e\x1f\xdf\xb4\x79\xe0\x43\xe9\xef\x4f\x5f\xf4\xfa\x8e\x1d\xaf\x5f\xf4\x34\x75\x8f\x24\xfd\x5e\x7a\x46\xda\xf2\xfa\x8d\xad\xf3\x0f\x9f\xc4\x33\xa5\x6f\xa5\x5d\xd2\xdf\xc1\x00\x17\xd3\xb0\xb3\x34\xa9\x5e\x77\x93\xf4\xc3\xcd\x97\x7e\xd1\x5c\x3e\x4b\x3b\xd7\xdd\xfc\xe5\xa5\x37\x4b\x3f\xdc\xb4\x4e\x9d\x2c\x85\xb5\x87\xe1\x96\x8f\xfb\xe0\x2a\x9c\xa7\xdc\x3e\x81\xe5\xbb\xc7\xdb\xe5\x7b\x6e\xd8\x00\x24\x0f\xbd\xe4\xc6\xc7\xe1\xf3\xe3\xc7\x3f\x3f\x2e\x05\xe1\x62\x30\xec\x78\xe3\xd4\x1b\x3b\x68\xed\xfa\x75\xad\x37\xbd\xbe\x65\xd3\x6b\x37\xb4\x67\x38\x39\x5a\xfa\xbb\x7c\x5b\x9a\x8e\xec\x8c\x5c\xff\xd8\x2d\xd2\x0f\x37\x76\x2f\xab\xba\xd0\x7e\x41\x60\xd9\x86\x1b\x41\x75\xcb\x63\xd7\x47\x76\x46\x96\x6f\xe8\x46\x14\x3a\x6f\x10\xd1\x37\x91\x76\xd1\x82\x9a\x10\x22\x64\x8d\xc8\x8d\x6c\xd6\xd3\xe0\x1c\x70\x01\x8f\x39\x96\x73\x64\xc1\xef\xa2\x20\x66\xc1\xe5\x09\x48\x08\x62\x88\x52\x70\x48\x2e\x3a\x12\x26\xe2\x62\x2e\xa0\x6a\xa5\x2b\xa4\xef\x41\x03\xdb\x40\x23\x1d\x79\x64\xf7\xee\x47\x76\x43\xa9\x9e\xd6\x07\xcb\xc4\x4d\x2f\x4c\x01\xad\xcb\xa5\x2b\x9c\x57\x38\xee\x05\xe9\xbb\xc2\x79\x2e\x5d\x61\x21\x68\x27\xff\x76\xa3\x58\x16\xd4\xd3\x7a\x8d\xbf\x22\xe5\x61\xac\x0d\x93\xbb\xab\x5b\x7f\x1a\x10\x3c\xa9\x0a\x3f\xde\x02\x9a\xc7\x9f\x00\x8d\xf4\xfd\x13\x8f\xc3\xcd\xbb\xdb\x16\xed\xde\xbd\xa8\x2d\x73\x67\x5e\x99\xbf\xc8\x93\x3b\xc5\x36\x99\x5c\x45\xef\x72\x8d\x7f\x41\xfa\x87\xcb\xa5\x77\xcd\x93\xaf\x67\x9b\x92\xeb\x29\xf2\x97\xe5\x59\x5d\xbc\xd9\x49\xf3\x3e\xa7\x3d\x92\x9b\xeb\x34\xf3\xae\x11\xfc\x61\x1c\x8a\xa3\x24\x41\xab\x0e\xed\xda\x87\x80\xe5\x78\xec\x15\xca\x89\x8f\xb5\x3b\xec\x0e\x8e\xe5\x58\x6b\x21\xd8\xc3\xf5\x60\x77\xc8\xdf\xf1\x68\x39\x96\xc7\xbf\xd8\x28\xb8\x59\xa3\xdd\x7d\xd6\xf2\xf1\xb1\xb6\x3d\x6d\x6d\x7b\x20\xa2\xf1\xd7\x14\x6a\x84\x1d\xbb\xce\xcf\xcb\x2b\xac\xf1\x6b\xec\xc1\x71\xb3\xaf\x89\x5c\x5d\x69\xb7\xab\xed\x75\xf6\xa7\x37\x4e\xb3\xd7\xd9\xd5\x76\xfb\xd3\xd1\xfd\x73\xc6\x05\x27\x3d\x25\xfd\xe3\xa9\xa7\x40\x87\xb7\x8f\xa4\x3a\xa5\x24\xf9\x4a\x6d\x99\xef\xad\x39\x4c\xae\x2a\x27\xe8\x37\x9b\x73\x99\x1c\x6b\x59\x4d\x69\x8c\x8f\x5e\x5d\x91\xbd\xc0\xa6\x26\xe5\x92\x4f\x45\xf9\x58\x69\x0d\x98\x41\xf7\x94\x7c\x35\xf8\xe2\x4c\x7e\x53\x65\x0d\xe2\x11\x26\x8d\xcc\x8a\x6e\x9d\x3c\xc9\x21\x48\x68\xbf\x80\xb3\xe2\xe5\xc3\x23\x72\x35\x0c\x0f\x45\xd9\x82\xb1\x0b\xaf\xf8\x4c\x7a\xe6\x81\x9f\x4b\xcf\x7c\x7e\xc5\xa2\x14\x7e\xa6\xdc\x07\x87\x02\x13\x2a\xcb\x7d\xd2\x93\xd2\x93\xbe\x50\xe5\x04\x3f\x1c\xf6\x30\xe9\xd6\xb1\x99\x1f\x7f\x2e\xf5\x7e\x7e\xf9\xe5\x9f\x43\xea\xe7\x98\x4b\x2d\xea\x7f\xdb\x03\x7b\x7c\xe1\xca\x09\x1e\xe9\x25\x88\x7b\x26\x54\x46\xbc\xd2\x0e\x4f\x16\xa3\x7e\x83\x1a\x31\x2b\xe5\x3a\xc7\x00\x8b\x38\x56\x88\x09\x48\x0c\x61\x5f\x54\x88\x79\x6c\x3c\x76\xd8\x91\x23\x6e\x4e\x08\x58\x14\xc4\x18\x63\x53\x00\x5c\x04\x5e\x17\x8f\xc6\xc2\x49\x88\xd8\x78\xe0\x28\xbb\xd9\x01\x21\x2c\xc6\x18\xf9\x67\x42\x1c\xf3\xa6\xf4\x4e\xae\xf4\xdd\x58\x88\xcd\x92\xee\x98\x67\x6b\xdd\x5c\x0a\x78\x92\x38\x33\x6a\x74\xc2\x45\x65\x85\xef\xda\x2d\x6f\x16\x08\xc7\x31\xd4\x8e\xb3\x79\xd6\xb8\xd7\xd5\xe7\x8c\x5f\x0c\xa9\x37\xae\xb3\x24\x37\x7a\xde\xd0\x7f\xc6\xc1\xa3\xfc\xa4\x1a\x27\xbc\x0c\xb0\x37\x99\xf9\xd6\xb3\x12\x3f\x5c\x99\x19\xbc\x14\x00\x9e\xa1\xac\x2f\x85\x37\xcd\x63\x04\x55\x18\xe7\x8f\xf1\xd5\x0c\x1c\x58\x5e\x07\x37\x17\x8b\xf0\x69\x6c\x02\x0e\x43\x39\x0e\x85\x26\xfe\x6d\xfc\x9b\x87\x13\x95\x98\xf3\xb3\x00\x95\x38\x19\x96\x26\x7a\x32\x92\x89\xfa\x51\xa8\xe4\x21\x4c\xe3\x52\x7a\x7f\x7f\xaa\x71\x04\x9f\xb6\x06\xe5\xa0\x8d\x68\x17\x3a\x38\xa2\xc5\x93\x67\x9e\x3c\xcd\x41\x92\x0e\x58\xb9\x10\xf6\x79\x6d\x56\x07\x0f\x1c\x99\x15\x14\x92\xed\xd6\x24\x8e\x45\x09\x65\x76\x08\x44\x32\x5f\x32\xc8\xe3\xfc\x84\x0b\x13\xe1\x9e\x72\xa2\xec\x27\x8f\x74\xcb\xc9\xbc\x80\x25\xf2\x6d\x2e\x70\x10\x71\x8c\x7a\x70\x81\x82\xf0\x18\xd9\x63\x9f\xd1\x1b\x50\xbf\xf4\xe4\x3a\x05\x6f\x58\x30\x40\xbb\x7a\xcb\x65\x7b\x17\x53\xd2\x71\x6e\xdb\x9e\x7d\xed\xf8\xaa\x4e\x2a\x3f\x97\xd6\xd7\x4c\x7d\x7f\xb7\x11\x78\x86\x05\xe3\xe4\xa9\xcf\xdf\x07\x39\x16\x3d\x6b\x77\xe0\x0d\xb7\x16\x4e\xd0\x68\x99\xf1\xfc\x5a\xec\xc9\xa3\xf5\xb9\x56\xeb\xb4\xbe\x3d\x06\xac\x67\x58\x30\x4c\xaa\x7f\xf9\x01\x51\xa7\x0d\xac\xbf\xb1\xb0\x4a\xa3\xa5\xab\xf9\xb9\x3b\xdf\x94\xde\x96\x1e\x93\xde\x7e\x73\xe7\xce\x37\x21\x08\x13\x21\xf8\xe6\x87\xe7\xe8\x60\xf0\x6e\xa7\x20\x67\xc7\x33\x1b\x4f\x50\xad\xdd\xb1\xab\x95\xcd\x3c\xc1\xad\xbb\x70\x77\x6b\xed\x8b\x3f\xc3\x66\x83\x5e\xe3\xed\x3e\xea\x1e\xa7\xd1\xd2\xe3\x0d\xab\x70\xc0\x45\xeb\x0b\x82\x54\xe3\x47\x7b\x0c\x94\x4e\xbe\xed\xe4\x71\x27\xef\x03\xbb\x51\xc7\x5a\x74\xba\xee\x9b\x5c\xe3\x34\x5a\xa6\x41\xbf\xb6\x4a\xad\x4f\x35\x7e\xb0\x4b\x87\xe5\x47\xd0\x4f\xfe\x13\xb9\xf9\xce\x91\x19\xc2\x97\xfc\x57\xe3\x28\xc8\xf6\xad\x76\xe4\x45\xc5\x08\x41\xdc\x61\x77\x04\x04\x9a\x83\xb8\x5f\x0d\x76\x3a\x41\x09\x7e\x1c\x33\x06\xec\x66\xcc\x72\x6c\x00\xe2\x58\xf4\x87\xed\xa4\x61\xa1\x2e\xfa\xe6\x0f\x5f\x6c\xcb\x38\x7b\xa4\x7f\x44\xa4\xbf\xa6\x61\x5d\xe6\x7d\x98\x39\x19\xec\x37\x7d\xfe\xba\xf4\xd3\xe7\xd9\x5f\x8f\xa1\x96\x9f\xbc\xe6\x73\xe9\x1f\x70\xb8\x45\xbb\x42\xaa\x3a\x75\xe2\xc4\xa9\x13\x2c\xc2\xdb\x2f\xfb\x5a\x54\xdf\x79\x10\xee\x3a\x76\x9f\xb4\x26\xb3\xea\x9a\x43\x05\x52\x9d\xe7\x47\xd8\xf9\x1e\x68\x13\x47\xa4\xa7\xa5\xf7\x33\xb3\x2f\xe5\xf1\xfa\xdd\x50\x7f\x3e\x7b\x42\x3e\x49\x7e\xaf\xb0\x5c\xbf\x98\x17\xc9\x6e\x82\x1b\x89\x02\x76\x42\x82\x4a\x82\x3c\x16\x97\xdf\x21\x8a\x60\x3e\x31\xe7\x10\x59\x17\x4e\x24\xb1\xc3\x05\x1c\x4f\x8b\x3c\x88\x2e\x48\xe2\x44\x3c\x24\x7b\x1c\x71\x2c\xd2\xc8\x62\xc7\x3c\xd0\xd4\xe5\xd2\x67\xd2\x84\x35\x63\xcc\x13\x6f\x58\xa9\xd5\x6e\xd4\x17\x7f\xb5\x39\xbe\x9b\xcb\x6d\x8c\xcc\x55\x19\xb4\xb9\x8c\x63\x61\x95\x61\xaf\xd9\x16\x69\x2e\x8a\xb4\x4f\x09\xd4\x55\xab\x81\xe2\xed\x45\xce\xda\xbb\x2f\x9a\x7a\xa2\xe7\xf0\xea\xbc\x12\xd5\xb8\xb2\xf9\xcb\xf3\x0c\xd7\x5e\x09\x6a\x10\x68\x3c\xf7\xb6\xb7\xa5\x2f\x07\x11\x94\xfd\xb0\x1b\xe6\xc0\x04\x28\x69\x93\xfe\xc4\x53\xa6\x99\x1b\x71\xd9\xef\x6a\x55\x5a\x9a\x06\x66\xa6\x8f\x73\x54\x68\x9e\x1c\x57\x32\xad\x2a\x8f\x53\x47\x44\x4c\x8f\xf1\x63\xce\xac\x57\x51\x8b\x67\x6a\xeb\x4a\x0a\xa7\x9c\x17\x6b\xfd\xed\xfd\x82\x30\x7b\xd2\xcf\x60\xe1\xfa\x69\xd2\x6a\xe9\x37\x3b\x07\xd1\x7b\xf7\x2e\x1b\xc5\xe3\x9f\x50\xf4\x1a\x69\x02\x71\x75\x81\xc3\x4e\x47\xc2\x09\x62\xf8\x21\xc8\x0d\x5e\xd4\x1c\xf7\xd7\x80\x9d\x06\x2b\x26\x54\x0a\x71\x73\x2c\x8a\x45\xa2\xad\x68\x66\xde\xb8\xe3\xd9\x9b\xa5\xbf\x9e\xd7\xb8\x80\xa6\x17\x34\x9e\x07\xd6\x9b\x9f\xbd\xe3\x02\xe9\x95\xbb\x0b\xf8\x07\xa4\x5f\x7f\x7a\x99\x5c\x37\x1e\xa2\xee\x82\x4a\xb8\xfd\xa6\x2b\x3a\xcf\xbf\xf2\xfc\x9b\x9e\x7f\xee\xa6\xad\x97\x6f\x5d\x7d\xf9\xf5\x4c\xfe\xba\x83\x3b\xdb\x4e\xed\x2f\xde\x7f\xaa\x6d\xe7\xc1\x75\x6b\xb6\x81\xea\xd0\xd7\x30\xfe\xc4\x43\x72\x4d\x82\xad\x03\x3f\xf4\x4a\xf7\x5c\x5c\x3f\xa7\x0a\x96\x7e\xfa\x09\x2c\xad\x9e\x3d\xf6\x22\xe9\xde\xec\xfc\xc4\xc8\x21\xe6\x1b\x54\x82\x62\xa8\x1e\x4d\x24\x7a\x37\x1e\x65\xd6\xea\xe1\x41\xce\x35\xeb\xf3\x9a\xa2\x89\x78\xc2\x1c\x60\x29\x33\xf2\x84\x1d\xfe\x48\x98\xd0\xe0\xd8\x29\xd2\x64\xcb\xbf\x1b\x90\x35\xbf\x10\x88\x2c\x78\xc8\xa4\x96\x43\x5c\xff\x25\x7f\x3c\xb4\xec\xbe\x30\xdc\x59\xf5\x99\x74\xf2\xae\xc7\xef\xfe\xf4\xa7\x5f\x95\x99\x16\x3d\x0f\xd6\x47\xfe\xb3\x1e\x1e\x85\x5c\x97\x01\x0d\x3e\x98\xea\x9c\x5b\xd1\xb8\x62\x62\xd7\x9c\x35\x07\x2f\xf8\xed\x84\xc8\x8f\xcf\x2d\x99\xb7\xe9\xfa\xed\x0f\x87\x96\xc2\x0f\xf8\x6d\xe6\xed\x6b\x0e\xbc\x85\xe7\x57\x55\x1c\xfc\x4d\xdb\x9c\x63\xff\xb8\x74\xf6\x66\xe0\x36\xf5\xd4\xde\x0d\x9d\xdf\xcf\x90\xbe\x02\x33\x2c\x86\x2d\xce\xc4\xd2\x86\xcd\x3f\x7b\x08\x7e\x3e\x7b\xe9\xc4\xf2\xbb\xd7\x5f\xde\xbf\x63\x5e\xdb\xec\xc9\x1f\x5c\xf6\x0a\x9e\x7a\xf5\x53\x4f\x0d\xad\xb3\xa5\x39\x45\x67\x24\x82\xd0\x68\x44\x98\xb2\xab\x69\x3b\x6b\xbf\x30\x36\x72\x63\x1a\x59\xf4\x3f\x92\x1d\x4b\x56\xd9\xcd\xcc\xb8\x81\x6c\x44\x0c\x90\x8d\x08\xe8\xc8\xb8\x1b\xda\xdb\x1b\xd8\x54\x43\x3b\xb8\x29\x92\x70\x20\xa5\xb7\x58\xa8\x57\x06\x14\xfc\xcb\xd0\x7e\x43\x3a\x8b\x79\x51\xf2\x65\x1f\x4c\xb3\x7f\x66\xd2\xc8\x81\x92\x08\x59\x22\x2c\xc7\x53\x0a\x08\xda\x61\x77\x64\xef\x5e\x34\x6c\xee\x18\xa7\x18\x9e\xe2\x58\x91\x6c\xb5\x29\xd2\xd7\x2e\xca\x11\x10\xae\xfa\xcd\xc4\x2a\x7f\x88\xa7\x72\xcc\x16\x1a\x47\x5c\xd5\x8b\xa5\x6f\x2a\xc6\x8f\xa7\xbf\x80\x68\xc5\xf8\xf1\x15\x0f\xbe\x6e\x94\x4a\xb0\xb5\x78\x5a\xe2\xc2\x26\x77\x71\x9d\xd7\x67\xd3\x98\xad\x73\x6b\xcb\xa6\x55\x47\x7c\x26\x78\x7d\x3c\x93\x4e\xcd\xad\x3a\xff\xd2\xd5\x47\x17\x2f\xb0\xa8\xbf\x6e\xbd\xa7\x73\x7c\x05\x93\x23\x9f\x78\xea\x8b\x8a\xf1\xbf\x87\x65\x2b\xca\xa6\x4e\xac\xd4\x39\x1b\xf2\xc6\x3f\x75\xfc\xf8\x0b\xd3\x85\xa2\x94\x5e\xa7\x75\x94\x57\xba\x97\x3f\x30\xac\x5d\xc3\x5c\x40\xd6\x4b\x26\xa2\x7b\xd0\x6f\x10\x62\x38\x85\x22\x44\x81\x42\x0b\x09\x05\xc4\x9d\x35\x8b\x22\x93\x38\xd9\x0b\x9c\xc3\xce\x9d\x6d\xbd\x92\xc8\x9a\xae\x38\xec\x8c\x95\x50\x14\x7b\xc9\x45\x62\x3e\x72\x1d\x47\xc4\x94\xb5\xb8\x52\xa0\xec\x42\x22\x5e\x08\x43\xb4\xc7\x8a\x16\x93\x29\xcb\xde\xa6\x04\x0d\x40\x18\x51\xb2\x3f\xa3\xd5\xe7\x31\x45\xb2\x3c\x31\x72\x1e\x28\xbb\x75\x38\xab\x72\x6a\x82\x6c\x27\x2f\x22\x73\x01\xbb\xe1\xe0\x4d\xc7\xef\xb8\xe1\xd0\xfa\x0d\xc9\x62\x1d\x1d\x8d\x30\x60\xce\x0f\x9f\xb7\x34\xbd\xe7\xc0\x35\x97\xa6\x97\xb0\x1a\x83\xce\xe6\x97\x6c\x0d\xf5\xb6\x7c\x93\x41\xa3\x4e\x36\x30\x1a\x83\x11\x9b\x55\x0d\x0d\x46\x97\x59\xcf\x72\x63\xc7\x9a\x5d\x79\xf0\x7c\xa8\x6c\x66\xf3\x9b\xdf\xbe\xd9\x3c\xab\xc4\x00\xea\x68\x58\x13\xa8\x05\x6a\xd9\xaa\x43\xd7\xbd\xfa\xda\xc1\x31\xf1\x7c\x83\x31\x9f\xe7\x05\x6d\xe7\x81\xc9\x93\x3a\x57\x4f\x4a\xad\xdb\xd3\xf1\xe0\x65\x53\xf6\xef\x7b\xfe\x85\x7d\xb1\x1c\xac\xd2\x78\xec\xb6\x42\x9b\x89\x5a\xeb\x72\x0d\xbc\x01\xc1\x1d\xa1\xb5\xdb\x2f\x78\xb3\x79\x66\x59\xa8\x50\xad\xd5\x3a\xf5\x6a\xae\x6b\x45\xfa\xd0\xa5\x97\xe4\x99\xd5\x40\xe9\x77\xdd\x7d\xfb\x0d\x57\x6a\xd9\x0d\xc9\x54\xaa\xbe\xbb\xfb\xe0\xca\x79\xf9\x2a\x55\x3e\x50\x0b\x27\xec\x38\x6f\x69\xbc\xaa\x2a\xb1\x84\xd5\xd0\x94\x25\x80\x67\x91\x1c\x6b\xea\x1a\x18\x23\x36\xf0\x9c\x66\x6c\x83\xb1\xc0\xcc\x34\x8c\x35\xb9\xf2\xa6\x9e\xbf\x6e\xd5\xcc\xe6\x45\x8b\x9a\x67\x75\x7a\xb8\x3c\x93\x31\x7f\xd9\x78\x98\x8d\xaf\xe8\x58\x79\xf2\xe0\x75\xaf\x1a\xb5\xe1\x88\x8a\xa2\xd8\x6b\x56\xae\x98\x38\xa9\x79\x72\x8b\xb4\x6c\xdc\x94\xcb\x7e\xbe\xf8\xb9\xfd\xfb\xf6\xc5\xbc\x58\xab\xd6\xa8\x18\x87\x01\xdf\x65\x70\xac\x93\x0a\x8a\xe7\x58\x42\x8b\x9a\x67\xae\xea\x86\x57\x55\x56\xa3\xde\xc9\xb5\x16\x57\x55\x6a\xca\x73\xf5\x46\xba\x3a\x35\x46\xae\x33\x05\x83\x88\xfd\x88\x45\x28\x0f\x25\xd1\x66\xb4\x0b\xa1\x40\xdc\x6e\xe5\x78\xda\xe7\x0d\x51\x62\x08\x88\x28\xb3\x83\x0e\xc4\x03\x76\x96\x88\xc7\x27\x92\x20\x86\x28\x1e\xfb\x78\xaa\x18\x2b\x04\x37\x71\x3b\x58\x5d\xb8\x50\x1e\x90\x94\x83\x20\xf2\x14\xd9\xa6\x67\x12\xca\x2f\xcf\x53\x5c\x80\x18\x20\xba\x28\x1b\x58\x89\x31\x42\xbc\x0e\x78\x8a\x35\x18\xec\x06\x7d\xf2\x92\x1b\x3f\x3c\x7f\xeb\xd7\xbf\xb8\x63\xb9\x57\x45\xb3\x1a\x3d\xd3\xbb\x06\x2e\x85\x9b\x9e\x82\x1b\xb4\x26\xab\x37\x62\x32\xab\x6d\xe5\x26\xc6\xe6\x71\x96\x5a\x4a\x80\xe5\x55\x6a\x86\xa5\x28\x00\xb6\x2b\x1c\xda\x21\xed\xc9\x0b\x08\xbc\xfe\x93\xe0\x74\x8b\x45\xcb\x0b\x5b\xaf\x38\xb0\xbb\x33\x59\xd5\x72\xd1\xb6\x7d\xcb\xc2\x36\xef\x7c\xd6\x56\x1b\xad\x35\x4b\xef\x96\x2e\xbc\xf8\xc4\x79\xcb\x6f\x5b\x32\x36\x37\xd3\x31\xb1\x61\xca\x1c\x17\x5f\xd3\xb9\x76\x6c\x2d\xcb\x16\x58\x8c\x89\x99\xe3\x2a\x93\xad\x5b\xda\x8a\xd4\x06\x35\x03\xf4\x96\xca\x9f\xcf\x0b\xfe\xde\xb8\xba\x72\x76\x11\xaf\xb1\x94\xdd\x68\xe7\xd4\x14\xc6\x58\x11\x8b\xc5\xd8\x58\xc1\x72\x3a\xb8\xbb\xb0\x21\x5c\xac\xd5\xf6\x05\xa6\x59\xad\x5a\x7b\xcd\xfc\x20\x5b\x31\xfb\x9a\xd6\x39\xfb\xda\xa6\x14\xe5\xab\xf1\xce\xb1\xee\x18\xb6\x07\x66\x25\xf2\x6a\xcf\x5f\x33\xab\x32\x3c\xa5\x6d\x86\x37\x73\xeb\xbc\xf2\x52\x7b\xee\xd2\xb2\xaa\xdb\xb0\xb5\x7c\xf1\xb0\xcd\x4f\x9a\xf4\x51\x11\x82\xd0\x5a\x3d\xc2\x26\x74\x88\x55\xf9\xb4\x6d\xee\xb0\x2f\x90\xe5\xb4\x8c\x65\x39\x2e\x99\x51\x61\x05\x5f\xfa\xdf\x58\xab\x67\x8d\xb5\x88\x44\x77\x56\x18\x3c\xdd\xde\x20\x37\x96\x8a\x33\x38\x52\x80\x69\x84\x9f\x4e\x9f\x4a\x53\xe8\x2c\x42\x16\x05\x09\x81\x9a\xa2\xa7\xf1\x2b\x1d\x72\xf3\xdb\x91\xfd\x56\x6c\xd1\x15\x44\xe1\x08\xff\x29\x33\x8d\x06\x10\x4e\x8d\xbe\x12\xf1\x9e\x51\x3e\x06\xa2\x72\x10\x21\x08\x36\xdb\xc8\x3e\x21\x6c\x07\x8f\xc9\xf3\xaf\xb9\x40\xff\x45\x81\x46\xc2\x76\x3a\x6d\xe6\x33\x0a\x6c\x24\xc5\x9b\x07\x10\x93\x3e\x95\x86\x11\x1d\x05\x35\x52\x9f\x2a\x7d\xce\x52\x4b\x47\x9b\xa0\x67\x28\x8d\x39\xf3\x7b\x1a\xf5\x9e\xf5\xcc\x8a\x7f\xfa\xb9\x0b\xaa\xe9\xcc\x3a\x21\xa2\x84\x52\x27\x02\xa7\x29\xce\x04\xd2\x2a\x0f\x6b\x0f\x65\xed\xd0\x1d\x76\xeb\xff\x59\x39\xcc\x0f\xa9\x9d\x9a\x27\x9e\x50\x6c\xcc\x9f\x7c\x52\xb1\x3a\x1f\x0a\x3f\xf1\x84\x7a\xc0\xfd\x3f\x2b\x9a\xeb\xcf\x7d\xb9\xe1\xb0\xd4\xf7\xbf\x2b\x2f\x2b\xca\x41\x41\x54\x85\x16\x11\x9d\x1a\xaf\x38\x6c\xa8\x9f\xb5\xd6\xff\xbf\x2a\x20\xc6\x21\x21\x8d\x53\x23\xf5\x29\x59\x7f\x0f\x94\x67\xe9\xef\xf8\x9f\x15\x0b\xae\x95\x90\x5a\x0d\x6e\xa5\x40\xde\x03\xa5\x44\x32\x63\xfe\x07\x85\x01\xc3\x63\xde\x82\x6c\x3b\x02\xa4\x6b\x1e\x72\x46\xac\x4e\x40\xaf\x53\xc0\x39\x26\xc7\xd0\xb7\xe0\xfc\x91\xe0\xe4\x59\x24\x38\x07\x2e\x85\xfb\x78\xc1\x29\x29\x4e\xbf\x12\x9f\x76\x0a\xca\xba\x22\xad\xcc\x7d\x88\xea\x08\x0a\x27\x86\xd7\xc9\x87\xc8\x0f\x02\x64\xa7\x64\x78\xc9\x28\x0e\x4f\xed\x49\x12\xb3\xcf\x39\x70\x17\x94\x4a\xaf\x4b\x2d\xd2\xeb\x18\xc9\x0f\x73\xf0\xa4\x39\xdf\x7c\x37\xf4\x1a\x32\x1b\xe4\x5b\xe0\x6b\xe8\x4a\xe5\x30\x94\xc2\x5d\x4d\xe6\x7c\xf3\xc9\x83\x72\xb2\xad\x77\x2b\x6b\x9a\x81\x41\xc4\xfe\x91\xf4\x51\x01\x82\xc1\x21\x4b\x50\xa7\x97\x5b\x4e\xff\x58\x61\x07\x0c\xef\x54\x9c\x6e\x4d\xb3\xc4\x0d\xf2\x30\xd2\xc6\xbe\xa6\xd1\xec\xcf\x0f\x9e\x22\xf6\xa6\x38\xa5\x58\xa5\xa2\x60\xfe\xc0\x13\xa0\x98\xa8\x52\x84\x27\xed\x54\x6f\x30\x7f\x3f\x49\x89\x11\x20\xfa\x2d\x8d\x53\xb3\x3f\x5f\x70\x82\xc2\x04\x26\x38\x53\xf9\xfd\xef\x11\x8c\xbf\x93\xea\x55\x08\xc2\xf2\xf7\x93\x34\xbd\xbd\xca\x7a\xbb\x0a\x31\xfd\x04\x57\x2c\xbf\xcb\x48\xd9\x4b\xe6\x80\x15\x03\xcc\x10\x62\x3a\x9e\x80\xb8\x83\x09\xc4\x19\x13\x63\x0a\x98\x02\x26\x30\x31\x26\xee\xd3\x7c\xbb\x39\x93\xce\xc9\xc9\xdc\x90\xb9\x41\xc3\x5b\x4c\xf9\x76\x33\x4e\xe7\xe4\xe0\x4e\xdc\xe9\xee\xcf\xc1\xa9\xfe\x0e\xec\xa6\xfb\x32\x7d\xcc\x77\x56\xcf\xa9\xb4\xd5\xcd\x0d\x22\xad\xf6\xfb\xef\x19\xad\xd5\xc3\xc8\x41\x20\x41\xfd\x4d\xfd\x9a\xcf\xe9\xef\xf5\xfd\x9a\x77\xe8\xef\x4f\x65\xe8\xef\xdf\xe9\xd7\x8c\x5c\x1b\x36\x21\x1f\x8a\x0d\xf5\x37\x1c\xb0\x0a\x56\x30\x01\x71\xcf\x39\x62\x86\x36\xc2\xe5\xd7\x4a\xce\x36\x46\x7a\x8b\x49\x72\x73\x2a\xbd\xc5\x04\x7d\x1c\xfd\xc5\x19\xc1\xfe\xbb\x54\x2c\x46\x66\x8b\x5e\xc5\x4a\xc8\x6c\x61\x91\x45\x7f\x2a\x65\x55\x0d\x22\xda\xa2\x67\x7a\xad\x2a\x90\x3d\xa3\x63\xa8\x41\xa4\xb1\x9c\x4a\xe9\x2d\x14\x20\x8d\x85\xe9\xd5\x5b\x86\xf6\x6b\xdc\x9c\xfc\x9a\x73\xc8\x80\x1c\xa8\xea\x6c\x45\x95\x21\x57\x41\x77\x8a\x2c\xc3\x12\x53\xcc\x44\x92\x4b\x84\x40\x81\x7a\x62\x45\x38\x05\x7e\x7b\xa6\xf3\x8d\xb4\xfc\x1f\xeb\x56\xdc\x27\x9d\x8a\x7a\x75\x56\x8a\xce\x61\x02\xbc\xc7\xe0\xe4\x0d\xcc\xc1\x3b\xbf\x81\x5b\xe0\x0b\xb8\x05\x37\x8e\xa0\xf5\x54\xfe\x21\x24\xdd\x2e\xbd\x73\x8f\xf9\xbe\x2a\x0d\x05\xbc\xd6\x60\x67\x3c\x7c\xc0\x59\x51\x31\x4e\x5c\x98\xb9\xe6\x7e\x10\xef\xb9\x07\x9d\xd6\x4b\x1b\xce\x77\x88\x30\xba\x8e\xb2\x0d\x1a\x72\xb1\x9b\x96\xdf\x97\x42\xe0\x58\x2e\x5e\x0f\xf2\xb8\xdc\x1f\x37\x0a\x60\x1d\x7e\x20\x9f\x57\x10\x63\x42\x5c\x48\xe2\x44\x92\x49\x10\x4d\x2a\xf0\xbb\x69\x17\x9c\xf3\xc9\xbe\x94\x3a\xa5\xa3\xaf\x5d\xb3\x6b\x7e\x5e\x4e\xe8\x86\x0b\x4b\xaa\x27\xd4\xbd\x0c\xcb\x5e\x7b\x0d\x66\xca\x0f\x3c\xb1\xf1\x39\xe9\x54\xe5\x58\xc6\x90\x43\x53\x0c\x68\xb0\x0e\x73\x15\xb6\xa2\x1c\x97\xf6\xe8\x2f\x4f\x2f\x75\xe0\x5f\x9e\xfd\xdc\xe9\xbd\x7f\xbd\xb2\xfb\xb7\x53\xc3\x1d\xad\x33\xeb\xd7\x08\xac\x6a\xef\x5f\xc1\xfc\x57\x69\xef\xfd\xd2\x3b\xf7\xa8\x1e\x18\xc7\xab\x6c\x26\xa0\x8d\xb4\x81\xe2\xb1\x2a\xe6\xa8\x0a\x4d\x0e\x2e\x00\xf6\xc8\xae\xaf\xee\x5d\xb1\xe2\xde\xaf\xc8\xef\xa8\xa6\x11\xf3\x4f\x44\x21\x16\x69\x90\x5e\x6e\xa5\x4d\x6a\x30\x41\x2e\x10\x17\x23\x8c\x24\x24\x91\x6f\xd9\x0f\x0b\x40\xcc\x9c\x90\xde\xa6\xb6\x66\x4e\x40\x90\xbe\x55\xf6\xe3\x19\xd2\x3b\x72\x2c\x59\x37\x9c\x35\xd8\xcb\xde\xc7\xa4\x88\x1d\x3a\x0b\xc8\xe7\xa5\x04\x0a\xfb\xbc\x9c\x98\xcc\x5a\xbd\x9a\x95\xf9\x4d\x22\xee\xf3\x72\x66\xc6\xce\xde\xa7\x91\x9e\x92\xfe\xe3\xb3\xab\x97\x96\xb6\x4c\x9e\x6b\x5e\x3b\x2d\xe7\xae\xd0\x2d\x73\x17\x6f\x76\x94\xda\x13\x63\x23\x2b\x57\xa8\xf4\xdb\xab\x53\xdb\x60\x76\x3f\x75\xea\xaf\xd2\x12\x69\x26\x70\x3d\xd0\x00\x6c\xd3\x52\xdb\xf5\xc1\xab\x54\xea\x4b\xf6\x4a\x1f\xcd\xfb\xf1\x27\x3f\x99\xbb\xd7\x09\x57\x6a\x55\xe8\x0c\x1e\x1c\x0a\x69\x08\xb3\xb6\x07\x28\x8b\xc7\x42\x01\x8b\x4e\x21\xba\xee\xfd\xf7\x33\x97\xbd\xff\x3e\xd4\x31\xe9\x53\x08\xee\xc0\x5b\xa1\x48\x7a\x2b\x73\xa5\xf4\x2a\x3a\x43\xbb\x82\x42\x66\x34\x16\xcd\xcd\x9e\xcf\x11\xce\xed\x84\x98\x10\x7d\xa2\x8f\x63\xc2\x76\x2e\x11\x0d\xe1\x21\x52\x90\xb0\x8d\xa0\xcc\x6d\x9e\x98\x18\xc2\x49\x88\x99\x22\x09\x9f\x57\x1e\x49\x47\x93\x18\x62\x04\xa4\x17\x33\x79\x38\x87\x3d\x9b\x4e\xce\x07\xb5\x4f\xd7\x58\x98\xbb\x7a\x75\x6e\x61\xa3\x6e\x71\xcc\x1d\x93\x8e\xb8\x73\xe1\x7e\x5f\xc3\xe4\xca\x4b\xf7\x74\x34\x59\x35\xfa\x29\xd0\x7b\x98\x65\x30\xc0\xd3\xc2\x9f\x58\x9a\xa6\x74\x79\xf8\xfc\x38\xc7\x60\xe9\x2b\xc7\x6c\x87\x8e\x9f\x28\x67\x9f\xee\xf5\xcc\xde\x98\x5b\x5d\x9d\xbb\x71\xb6\xa7\xa3\xe3\xb8\xbb\xdc\x96\x68\x0c\xf0\x9b\x2e\x9a\x9c\x56\x49\xbb\x78\x1d\x70\x2d\xf3\x78\x00\x9a\xd6\x30\xb0\x3b\xcd\xb2\x54\x73\x5e\x5e\x81\x76\xe0\x57\xf3\xd4\x40\x51\x3a\x16\xab\x56\xd8\x39\xab\x74\x35\xaf\xc6\xea\x79\xca\xb3\x2f\x27\x6d\x50\x39\xaa\x46\x33\x51\xab\xa2\x14\x41\x36\x64\xdc\xd9\x4d\x98\x2c\x45\x7b\xc0\x92\x04\x07\x43\xa0\x25\xf2\xbb\x12\x0b\x50\x34\x01\x38\x80\xdc\xbb\x90\x7e\x06\xe2\x51\x51\xf0\x66\x27\xa6\x5e\x8e\xb5\x2a\xca\x83\xc2\x10\x0d\xb4\x95\x43\x35\x61\xdd\x1b\xd2\x01\xa9\x59\xba\xf6\x0d\x6d\x24\xb9\x79\xf6\xdc\xda\x77\xa1\x68\x33\x95\xc3\xc3\x06\xf3\xe4\x92\x64\x4b\xcb\x8e\xf9\xd2\x83\x9d\x50\xfa\xc7\x31\x73\x67\x6f\x3e\x75\xdb\xfc\x1d\x2d\x2d\xc9\xba\x16\xaa\x58\xab\xd5\xb8\xb4\x45\x3d\x3d\x3d\x45\x5a\x97\x46\xab\x2d\xb9\xbe\xbd\xa5\xfd\x7a\xfb\x8e\xf9\x2d\x75\xc9\x16\xfc\xe0\x98\xc5\xb9\xa1\xf0\xcd\xd2\x0f\x37\xde\x08\xaa\x9b\xcb\xcb\x73\x97\x8c\x99\xb5\xa5\xfe\x06\x0d\x56\xeb\x8d\xd4\xcc\x40\xd9\xfc\x1d\x2d\xf3\x93\x53\xa5\xa0\xfa\xfa\xba\x2d\xd2\x9f\xc8\x4d\x5a\xa4\x0e\xad\x4b\xab\xd1\x14\x07\x83\xc5\x1a\x8d\xa6\x50\x5b\x12\x56\xab\xc3\x3f\xc8\x37\x9b\xbf\x83\xd4\xe9\x09\x83\x98\x7d\x9c\x45\xa8\x02\x21\x4b\x24\x49\xf9\x23\x61\xda\x21\x77\x69\x2e\x2a\x09\x09\x13\xab\x03\x51\xc0\xa2\x60\x4e\xf0\xc0\x79\xe2\x21\xba\x1c\x78\x6a\x02\x18\xe7\x5e\xfb\x14\xc0\xa1\x3f\xc1\xba\xf5\x9d\xfd\x37\xc3\xaa\xbb\xfe\xf0\xd6\x8b\x53\x16\x49\x5f\x49\xb7\xed\x7f\xf2\x3b\x4c\x7d\xfa\x87\x8a\x5a\x23\xbe\x50\xe5\x4e\xce\x98\x35\xde\x6e\xbf\xfc\xc7\xe7\x6e\xc2\x9f\x5d\xfc\xa7\xdf\x1e\x9e\xf7\x87\xe7\x1e\x1f\x7c\x62\xfd\xf1\x59\x6e\xe7\xb8\x88\x74\x79\x62\x2a\x8e\x4f\x81\x8e\x5f\x7f\x0b\x73\x96\xd6\xee\x6e\x9f\x76\xf1\xb4\x2a\xa7\x01\x80\x99\xb1\xeb\xfa\xa1\xfa\x4a\xb0\xf5\x0a\x1b\x7d\x1e\x42\x31\x93\x27\x3b\xa4\x90\x2b\xa4\xc7\xe6\x89\x0d\x0f\x96\x22\x6a\xd4\xde\xf0\x43\xaa\xa1\x1d\xa7\x21\x9d\x41\x80\xd8\x8e\x86\xf6\x7f\xa2\xf6\x06\x37\xee\xc8\xf4\x34\xb4\xb7\x83\x97\x98\xb0\xa4\xdb\x1b\xfa\xfa\x1a\xda\x87\xb1\x9d\x8f\x13\xbb\x95\x0a\xb9\x7f\x0f\x90\x2d\x39\xb9\x22\x28\x7a\x92\x09\xa2\x26\xa5\x2c\x58\x47\xc2\x7e\x35\xb0\xc8\x33\x42\x70\xd4\x41\xf9\x88\xfc\xbd\x0b\x78\x60\x2b\xde\x9d\xfa\xdd\xfe\xeb\x7e\x38\x30\xf7\xda\xe7\xd7\xed\xfe\xb2\xe9\xad\x75\xd2\xb1\x97\x7e\x22\xbd\xfb\xfa\xc5\x17\xbf\x0e\xc2\x4f\xde\x80\x0d\x52\x0a\xff\x72\xb3\xd4\x28\x7d\xfd\xd0\xd0\x0a\xef\x43\x40\xc3\x1d\x17\x1d\x13\x3b\xae\x70\x97\xe9\x34\x65\xdf\xaf\xdf\x76\xd5\x81\x1f\x0e\xae\x7b\xfe\xda\xb9\x17\xac\xb9\xe8\xee\xde\x8b\x5f\x97\xde\x95\x9e\x92\x2f\xf1\x26\x9e\x28\xf5\x64\xa4\x77\x4f\xb7\x95\xd2\x77\x5f\x4a\x9b\x7b\x80\x98\x93\x20\x1a\xb9\x07\x11\xdb\x97\xe5\xd3\xcd\xf2\x11\x24\x3c\x20\x9a\xa0\x10\x4c\x6a\xec\x01\xe6\xba\xcc\x4d\x8b\xa8\xf9\xa7\x7e\xf9\x08\x7d\xcc\x7a\x5d\xe6\xaf\xb0\x48\xd2\x0d\xdc\x0d\xcb\xa9\x1a\xd8\x75\xfd\xc0\x07\x9b\xa9\x85\x99\xdc\x8e\xc5\x03\x3f\x85\x19\x78\xe7\xc0\x07\xb8\x66\xa8\x6c\xd2\xcc\x37\x64\x3f\xf7\x22\x84\x80\x28\x92\x0f\x4b\xd6\x0c\xfb\x19\x93\x27\x8b\x64\xf1\x98\xa2\x35\x10\x2e\x80\xc8\x90\x1b\x1b\x76\x93\xd8\x1e\x31\x0d\x6b\x12\xdb\x14\xba\x9c\x78\x24\x5c\xa0\xec\x3e\xf8\xbc\x9c\x2d\x1c\x77\xe1\x33\xce\xa9\x81\xb0\xcd\xa4\xb8\x38\x6d\xec\x30\x1a\x3b\x8c\x18\x0d\xb9\x99\x74\x77\x4f\x77\x46\x8e\x1e\xfe\x30\x3a\xce\x08\x6e\x4f\xa9\xc7\x5d\x26\xd8\xa6\x19\x4d\xb5\x9c\x71\x62\x9e\x79\x8a\x25\x18\x06\x23\xa7\x63\x46\xa6\xc5\xc6\x3e\xe3\xe9\xff\x8c\x11\x52\xcd\xdd\xdd\xcd\x52\x2f\xfe\xc6\x68\xec\xc6\xdd\x46\x63\x37\xf9\xb0\x1c\x05\x00\x97\x1b\x7c\x0e\xb7\xdb\xe1\x33\x98\x34\x06\x83\xf1\xf7\x06\xbd\x41\x77\x29\x00\xc5\xb1\xdd\xd9\x84\x99\x03\xdd\x46\x45\xe3\x91\xd4\xd5\x2e\x85\x01\x4b\x19\x6e\xd5\x81\xc7\xee\x70\x31\x64\x5c\x3f\x44\xf2\xa6\xcc\x24\x7d\xde\x10\x23\x86\x28\x9f\x87\x00\x7e\x14\x95\xa7\x48\x58\xee\x6b\xd9\x1a\xc8\x36\x3e\x72\x0f\xec\xf3\xf2\x34\xc7\x72\x72\x0d\x77\xa8\xbe\x31\x1a\xa5\x5e\x95\x4a\xcd\x19\x07\x7e\x1a\x08\x19\x4d\x85\x8e\x42\xb7\xa9\xc3\xcc\x03\x19\xf3\x4b\xbd\xbc\xb9\xc3\x3d\xa6\x34\x94\x2f\x9a\x2d\x8e\xfc\xd2\xb2\x1c\xe9\x06\xfb\x55\x2d\x5d\x47\x8e\x74\xb5\x5c\x65\xef\xcc\x29\x2b\xcd\x77\x58\xcc\x62\x7e\xa8\x74\x8c\x7b\xb5\x6d\x69\x52\x7e\xe8\xe4\x52\xdb\x6a\x93\xbb\xd0\x51\x68\x32\x86\x02\xf4\x42\xb7\x11\xff\x51\x25\xa8\x7a\x19\x5a\x63\x4e\x8f\x59\x1d\xf0\x27\xdd\x7e\x63\xc7\xd0\xc5\xcd\x7c\x87\x35\x2f\x2e\x34\x89\x45\xb1\xea\x29\xde\x39\x6b\x8e\xbc\x7e\x64\xcd\x1c\xef\x94\xea\x58\x91\xd8\x24\xc4\xf3\xac\xd5\x93\xba\x7b\xba\x27\x55\x1b\xfd\xee\xa4\x3f\xb0\x7a\x4c\xda\x6c\xd5\x9e\x89\x0d\xe0\x90\x09\x79\xc8\x98\x84\x80\x5f\x90\x51\xf0\x79\x4c\x11\xe2\x1b\x05\x6a\xb9\x78\x46\x55\x26\x53\x05\xf8\xe1\xdd\xd2\x8c\x5f\x64\x76\xe1\xcb\xcf\x85\x56\x49\x76\x4f\x07\xbd\xf4\x4f\xa0\x1f\x19\x48\x83\x1e\x56\x9d\x63\xf3\x44\x6e\x43\xde\x51\x23\x46\x44\x22\x1a\x83\xa6\xa1\x25\x44\x83\x58\x64\x87\xf8\x9b\x12\xf1\x58\x54\x59\xab\xb6\x3b\xe4\xe6\x5e\x54\xb6\xf8\x09\x02\xee\xb4\x7a\x87\xa2\x11\xe7\x02\x87\x22\x03\x2f\x9f\x66\x14\x05\xb2\x44\xe5\x37\x0e\x47\xc5\xa2\xca\xa2\x94\x83\x5d\x3b\x3e\xc6\x19\xb9\xa2\x1c\x9d\xae\x30\x5f\xe3\xd8\xfe\xfb\x0b\x2f\xfb\x38\xbe\xa6\xd9\x5e\x9a\x72\x34\xae\x92\x7f\x0e\xda\x3e\x63\xfd\x8d\x2f\x5e\xdd\xff\xe7\xbb\xbf\x79\xe1\x70\x12\x92\xbf\xfa\x0b\xb4\x3a\x36\xdf\x78\x6a\x89\xa3\x28\xc7\xe2\xd4\x99\x27\x4d\x32\xeb\xa2\xf5\xe6\x25\x80\x2e\x73\x14\x39\x2c\x4e\xbd\x79\xcd\x1a\xb3\xde\xe9\x4c\x9a\xe1\xa1\x9a\xc5\xb6\xb2\xf2\x9c\x7c\x4a\x53\xed\x9a\x34\xf9\xc2\xd7\xb6\x1f\xbc\x20\x7f\xba\x23\x55\x6a\x6f\x3c\xfc\xfa\xe1\xf5\xd3\xaf\x7e\xe1\x6f\x77\xdf\xf8\xa9\xfd\x91\x4f\xa5\x5f\xfd\x29\xf7\xf1\x0b\x1e\x38\xe0\xd1\x9b\xea\x9d\x9d\x80\x3b\x9d\x49\xbf\xde\x79\xf5\x78\x29\xe7\x79\xaf\xde\x9c\x74\xde\xfe\xec\xaf\x6e\x73\xd6\x9b\xcc\xba\x3c\x84\x91\x7f\x10\x31\xef\x91\x7d\xf8\x75\x08\x31\xa4\xd7\x93\xdf\x55\x85\x97\x91\x95\xab\x6a\x2c\x9a\xa4\xc2\x2e\x8a\xc0\x73\x0b\x81\x68\x92\xd2\xa2\x20\x86\xa8\xd8\xd0\x12\x1b\xe1\xf8\xf2\x15\x43\x88\x26\x16\x5f\x44\xd5\xd4\x45\x39\x5c\x2a\xe6\xbd\x8b\x7f\xb1\x73\xe7\x2f\x2e\xfe\x72\xd3\xcd\x9e\x83\x5f\xae\x7d\xe4\xc2\xa5\x71\x9f\x4e\x9d\x5f\x36\xbb\x6b\x56\x69\x9e\xca\x91\xbf\x46\x0c\x6e\x3a\x62\x2e\x8b\xb7\xb7\x4d\xc9\x37\x6c\xbe\x7a\x65\x51\x51\xeb\x65\xcf\x6f\xdf\xf6\xc2\x25\x0b\x05\x57\x49\xbc\xd4\x84\x59\x8b\x33\xea\x0f\xe5\x5b\x0d\x2d\x81\xc0\xf8\x65\xc5\x1a\x61\xfc\xc5\xf3\x9b\x2e\x6a\x9b\x52\xe1\xb5\x68\xb0\x7e\xc1\xce\x9d\x0b\x16\xee\xdc\xf9\xb4\xe1\x81\xf3\xa7\xa6\xa6\x17\x8f\x9b\x37\x67\x56\x84\xb7\x94\x8f\x8d\xf8\x7d\xe5\x35\x22\xef\x2d\xcf\x73\x61\x38\x6f\x96\xb3\xac\x54\x08\x97\x79\xf5\x5c\x62\xe1\xc6\x2b\xdb\xa7\x1f\xd8\xbd\xa4\x3a\x3a\xab\x6b\x55\x24\x34\xa5\xa4\x40\xa3\x31\x0b\xf1\xf9\x71\xa3\x05\x20\x39\x3d\x90\x23\xc4\x2b\x6a\x0a\x72\xab\xe3\xa9\xc4\xc4\xf8\x94\xc8\x48\x3b\x3c\xc5\x7e\xfd\xac\xdd\x83\xc0\xa8\xf0\x48\x21\x6e\xdc\x6b\xe6\x07\xc9\xdc\x13\x10\x6f\x86\x33\x43\xe9\xd1\x9a\xdb\x1d\x98\xbc\xc9\xa7\x17\x85\xb2\x7e\x18\x1c\xa5\xac\x4d\x8f\xe0\x9f\x71\x90\x55\x1b\x84\x46\x58\xc3\x23\x77\x12\x8c\x21\x70\xf3\x60\xb4\x07\x46\x6a\xa5\x8d\x5c\x6b\xc8\x86\x71\xf9\x99\x36\xed\x70\x2b\x04\x4f\x1d\x3c\x78\x4a\x7a\xfb\xd4\xc1\x83\xf0\xb5\x9c\x87\xde\xd3\x99\x22\x5f\xcc\xe8\x8c\xf7\xdf\x7f\xf0\xd4\xf0\x59\xd3\xcf\xc8\xfa\x08\xff\x19\xe3\x57\x83\xdc\x9f\x8f\x2e\xc9\x33\x24\xcc\x53\x23\xaf\x00\xbd\xff\x5d\x59\x9d\x55\x3e\xd4\xa8\xf2\xf9\x2f\x4b\x27\x31\xd2\x56\xf3\x5f\x95\xc6\xba\xd3\xcf\xf3\xff\x50\x04\xa3\xf1\x51\x01\x54\x87\x50\xc0\x42\x0c\x9a\x09\xbd\x3a\x58\x3c\x16\x82\xe2\x56\x40\xf0\xc3\x6e\xd8\x1e\x30\x91\x97\x31\xdb\xc3\x66\xfd\x71\xb7\x9d\x7d\xdf\x47\x59\x2c\x05\x3f\xa6\x0b\x2c\x16\xca\xc7\xb6\xcd\xfb\x71\xce\x3c\xca\x9f\x0b\x88\x4c\x9a\xe4\x2f\x94\xeb\x97\x76\x0b\x51\xe1\xc8\xeb\x47\x84\xa8\xf0\x11\x24\x3f\x4a\x4b\xcf\xe7\xdb\x6d\x36\x7b\x3e\x54\x53\x93\x06\x7e\xa4\xb8\x1c\xcf\x48\xc5\x4d\xcf\x4f\x06\x91\xa2\x3d\x21\xb7\x50\x43\xfe\x63\x1f\x7d\x94\xb5\xb3\x93\x1d\x1b\x61\x28\xaa\x41\x53\xd0\x5a\x32\x8b\x97\xdb\xf1\x21\xcc\x6f\x56\x01\x03\x92\x20\x52\x21\xe0\x15\x98\x75\x60\x28\xe7\x76\xe5\x2d\x19\xf6\x5b\xe2\x21\x20\x7a\xa4\x8e\x48\x38\x0e\x94\x8f\xe0\x36\xb3\x3f\x03\xc1\xcf\xfa\xa8\x10\x94\x0c\xb1\xfc\xcb\xed\x33\xc9\xa5\x61\x93\x6a\x72\xa8\x1f\x85\x26\xab\x36\x19\xe4\x30\xac\x70\xfa\xb0\x1b\x17\x45\xe5\xef\x40\x2e\xf4\x08\x51\x41\x88\x0a\x90\xce\xba\x1d\x6e\xec\x8b\x16\x61\x37\xf6\x39\x99\xdc\x40\xff\xc5\x6d\x7b\x56\x58\xf6\x2d\xbc\x53\xc1\xab\xdf\xb9\x70\x9f\x65\xc5\x9e\x36\xed\x84\xb2\x3b\x05\xa7\x24\x47\x94\x4d\xa0\xe4\x12\xcc\x74\x85\x6a\x6b\x43\xf8\x48\x63\x57\xe3\x40\x1f\x2e\x72\x42\x8f\xd3\x47\x17\x39\xa5\x8e\x5c\x6f\x0a\x7a\x08\xcd\x42\x07\x29\x9e\xd3\x7e\x1b\xf4\x38\x8b\x68\x9f\x1c\x28\xc2\x5e\xfa\x5d\x69\x39\x3c\xda\xb2\x5e\x3e\xbc\xbe\x45\x9a\x04\xb7\x94\x56\xc9\xfe\x2a\x84\x91\x67\x30\xcd\x7e\x48\xe6\x60\x33\x10\x02\x8b\x8f\x02\xb9\x1e\x50\x9e\xb0\xc3\x4e\x16\x97\x28\x82\x06\x15\x12\x16\xdf\xb0\x4f\xae\x25\x64\x1d\x69\x84\x2f\x9e\xd5\xc7\x8f\x0c\xfb\xe4\x2b\x50\x1f\xa6\xa4\x14\x25\x55\x71\x39\xd2\xa3\x29\x48\x18\x34\x1a\xba\x8a\x71\x4a\x8f\xce\xe4\x72\xfa\x8c\x1a\x35\x35\x5d\x9a\xc9\xe5\x7c\x64\x20\xbe\x17\x65\xa7\x8a\xcb\x81\x49\x29\xd9\x4f\x52\xc2\xa4\x99\x5c\x6e\x9f\x21\x9b\x32\xeb\x93\xaf\xa3\xc6\x08\xd0\x20\x82\x1f\xfa\x72\x06\x91\x8e\xe7\xfb\x72\xa4\x47\x72\x74\x3a\x23\x54\x0d\xb9\x3a\x9d\xb1\x2f\x07\x94\x63\x30\x59\x8e\x93\x5e\x18\x72\x75\x3a\x65\xfe\xb9\x7a\x10\x31\x87\xb3\xf6\x9a\x26\x62\x71\xef\xe0\x4c\x0e\x8e\x52\x53\x26\x8a\x53\x83\x03\x90\x11\x13\x6b\x4b\x6c\x34\x13\x96\x4d\x6a\xca\xa1\xc3\x87\x0f\xed\x86\x57\xa5\x93\x10\x96\x2a\x06\xdb\x20\x25\xf5\xb6\xa1\x41\xfc\xbb\xd4\xfa\x9f\x3d\xf3\xfd\x33\x3f\x5b\x9f\x1a\xf2\xc0\x27\x87\x0e\x53\xfb\x0e\x1f\x1a\x58\x02\xaf\x42\x18\xc2\xf0\x6a\xe6\x28\x1a\x6c\x93\x9e\x96\x9e\x6e\x43\x83\xd0\x2d\xb5\x4b\xcf\xbf\xb8\xa3\xb2\x72\xc7\x8b\x50\x0d\xb7\x41\xb5\xe2\x57\xde\xcd\xe0\x20\xa2\xde\x1e\xce\x17\x0a\x24\x44\x53\x42\xb4\xa8\xc1\x04\xa2\x1a\x12\x60\x02\x3c\xe7\xbe\xfb\xee\xbb\xcf\x0d\xcb\x33\x9f\x49\x6f\xad\x81\xcd\xd2\xbe\x35\x50\x84\xf3\x36\xdc\x7b\x2f\xac\xbb\xf7\xde\xcc\xdf\xa5\x5b\x32\x9f\xe2\xe7\xa5\xb7\xd7\xc0\x16\xd8\xb2\x46\x7a\x1b\x3f\x9f\xf9\x54\xb1\xab\xc9\x62\xbd\x0c\xc8\x81\x8a\x50\x25\x42\xc3\x2b\x47\xc3\x2b\x48\x2c\x61\xf3\xb3\x58\x39\x50\xd6\x0f\xa3\x09\x20\x8d\x33\x9d\x3d\xc2\xa0\xa6\xce\xa6\xa6\xce\x4c\x13\x71\xe8\xa6\x8f\x14\xa6\xbe\x4b\xf4\xfd\x7d\x16\x77\x8f\x53\xd0\xd3\x6e\xe2\x66\x3a\xb2\x47\x5e\x96\xd3\x35\x51\x24\x79\x93\x54\x38\x44\xec\xd7\x6b\x35\x9f\x4a\x3b\x05\xa7\xd5\xcc\xa4\x9d\xc2\xe3\xd9\x68\xb2\x6e\x44\x0d\x4e\x62\x33\xcc\xa3\x64\x95\xc4\x88\x1c\xa8\x00\x21\x8b\x1a\x42\x90\xb0\x14\x01\x54\xca\xcd\x53\x3c\x0c\x16\x3b\xcb\xa9\xa1\x52\xf6\x3b\x3a\xa9\x9c\x81\x5b\xcc\x3c\xb7\x02\x4e\xe2\x43\xd2\x43\x99\x6f\x9e\x93\xc2\xcf\xa9\xc2\x4c\xc5\x0a\x8e\x37\x0f\xdc\x42\xe5\x90\xa0\x8a\x4a\x0e\xa8\xf1\xf9\xfa\x12\x1b\x44\x07\xd4\x6c\x6b\xe6\x16\xbc\xdc\x91\xb9\x54\x7a\xd9\x56\xa2\xcf\x5c\x45\xfd\x13\x2f\x77\x38\x46\xac\xb7\xf5\x21\x8a\xec\xba\x54\x22\x04\x91\x98\x0f\x88\x0d\xb9\xe8\x70\x41\x82\x30\x4c\x32\x56\x79\xba\xae\xc0\x27\xbd\x0a\x78\x52\x91\xfd\x90\x3b\x0b\x33\xa4\x7b\x7a\xa8\x09\x9d\x7b\x2f\xff\xb1\x03\x5a\x7e\x38\x74\x89\x14\x24\xdc\x06\xe9\x65\x0b\xa4\xcc\x23\xdb\x4f\x8e\xb1\x34\x59\xc6\x9c\xdc\xfe\x88\x94\x59\xb0\xec\x1b\x38\x0a\x9f\xc3\xd1\x6f\x70\x6f\x5f\xe6\xf5\x45\x7e\x0c\x8b\x1b\x3b\x9a\x97\x00\x5c\xd4\xd7\xfb\xf8\x1d\xe7\xed\x3c\xfa\xc1\xaa\x16\x80\x96\x55\x1f\x1c\xdd\x79\xde\x1d\x8f\xbf\xa6\x74\x06\x43\xdc\x0d\x43\xeb\x27\xca\x3c\xcb\x82\x82\xa8\x24\x6b\xf3\x6d\xf3\xc5\x2c\x44\x89\xcc\x73\xfa\x43\x96\xfa\x41\xe4\x88\xf1\x49\xb6\x8b\x83\x84\x87\x49\x78\x98\x51\xb8\x3d\x4c\x0d\x0c\x0c\x50\xdf\x4a\xf7\xc0\xdc\x4c\x07\xee\xc9\x74\x50\xa2\x4e\xe5\x96\x2e\xfb\xfd\xef\xa5\xcb\xdc\x2a\x9d\x4e\x45\xbf\xad\xd2\x0d\xdc\xfd\xa8\xd4\x85\xf7\xbe\x2f\x75\xe1\x8f\xe7\x25\xfb\x83\xc9\x79\xf3\x92\xf4\xdb\xc9\x79\x78\x43\x3a\x8d\x06\x77\xee\x94\x20\x9d\x06\xa4\xf8\x07\x6e\x97\xcf\x18\x44\xf7\xdc\x03\x48\xa7\xea\x0f\xaa\x74\x3a\xba\xfd\xc8\x91\x23\xd6\xd3\xa7\xcd\x3b\x03\xb3\x52\x28\xf7\x4a\x90\xdd\xb0\x67\x0b\xc1\x45\x39\xec\x0e\x17\xed\xb0\x27\xe2\x72\x0c\x86\x10\x83\x45\xb7\x0e\x5c\x14\x0f\x1c\x6b\x03\x1f\xf0\x38\x84\xa9\x74\x67\xd5\xde\x57\xbd\xfe\x05\x1a\x51\x4c\xae\x68\x89\x95\xaa\xe9\xd2\xe6\xcd\x9b\xae\x6b\xbc\x11\x20\x1c\xcb\x9f\xf6\xb2\x34\xab\x69\xc3\xec\x9a\x31\xa1\x46\x11\x4c\xf0\x0c\xc4\xbe\xbc\x6a\x96\x8b\xe1\xf5\x7a\x18\xd7\x29\xfd\xc9\xbe\xb7\xf3\xde\xc3\x8f\xe1\x57\x7f\x3d\xeb\xa5\xcd\x16\x53\xd0\xe8\x2a\x2c\x59\xb1\xa7\x7d\x8e\x49\x35\xe7\xaa\x9f\xed\xda\xe2\x6e\x60\x29\xaf\xdf\x36\x06\xc2\xd2\xc5\xb5\xbb\x8e\xde\xf0\xde\x73\x10\xbe\x62\x72\xf7\x89\xbb\x3e\xfb\xd9\x27\x5b\xe7\xcc\x71\x48\x8f\x42\x01\xce\xe1\xb1\x7b\x1e\x1a\x81\x6d\x2b\x27\x3b\x58\x44\x61\x1e\x85\x80\xa3\xdd\x01\x81\x27\x7b\xc9\x3c\x36\x00\x4b\x00\x08\xf5\x10\x4f\x44\xec\x85\x60\x8f\x84\x13\x49\x28\x87\x10\x16\xe5\x31\x7e\xf6\x8d\xa4\x47\xcd\x45\x46\xb3\x14\x8d\x9e\xab\x30\xcb\x75\x65\x4e\xa9\x5f\xfa\x42\xea\x77\x96\xe9\xf2\x9c\xcf\xae\xc5\x79\xce\x7c\xb5\xc6\x9e\xab\xe6\x4b\x8d\xaa\xb8\xa9\xd8\x14\x57\x19\x4b\x79\x75\xae\x5d\xa3\xce\x77\xe6\xe1\xb5\xcf\x3a\xa5\x87\xc9\x02\x27\xde\xbb\xfe\x49\xa9\x5f\xfa\x58\xea\x7f\x72\xfd\xfa\x27\x81\x01\x17\x30\x4f\x4a\x8d\xd2\x0b\xd2\xa7\x27\xb7\x6f\x3f\x09\xf9\x50\x05\xf9\xc4\xf7\xc2\xb9\xe6\x3f\x73\xa3\x79\x6c\x32\xc9\xe6\x45\xcb\xd8\x90\xee\xd6\x0f\x16\x4c\xb2\xe5\x56\x68\xe8\x22\xeb\xde\x6d\xdb\xf6\x5a\x8b\x68\x4d\x45\xae\x6d\xd2\x82\x0f\x6e\xd5\x85\xd8\xe3\x64\x39\x75\xc3\xa8\x3b\xc9\xbe\x35\xdb\x4f\x4a\x9f\x8e\xba\xa1\x54\x71\x2e\x18\x1a\xa2\xd0\xf8\x41\xc4\x3c\x9e\x2d\xe3\xc9\x08\x21\x3b\x31\x87\x21\xb3\x1f\x0b\xa1\xb5\x17\xb3\x08\x4e\x31\x9e\x00\x91\x63\x43\x40\x30\xb9\x0e\xb9\xfc\x0d\x10\xc0\x0a\x68\xda\x0a\xe1\x04\x99\x55\x40\x2c\x9a\x70\xb0\x36\xab\x9d\xd9\x31\x9e\x29\xa5\xeb\x8a\x58\xaa\xb4\x9a\xf2\x5d\x93\x38\x74\x65\xeb\x2b\xd7\x5e\x76\xde\x95\xdb\x6e\x07\xd5\xe1\x5f\x7a\x5a\xc6\x30\xee\xbf\x39\xc7\xbb\xe0\x0b\xbf\xce\x54\xf2\x0a\x6c\x2a\x3a\xd4\xd9\x79\x68\xd5\xc0\xbb\x5d\x0b\xf7\x1e\x7c\xf2\x50\xff\xc1\xcd\x7b\x6b\x5f\xc1\xdf\x4f\x2c\xcf\xbc\x53\x5c\x05\xd4\xb8\x52\xb8\x4f\xb5\x61\xe7\xdb\xb7\x5c\xb9\xe2\xb2\x6b\x4f\x2e\xba\x6a\x63\x1e\x94\xce\xff\x89\x8b\x69\x68\x29\x78\xc3\xc1\x99\xa5\xcf\x6c\xe5\xe3\xc2\x5f\x58\xe1\xee\x4e\xf9\x32\xa7\x9e\xaa\xdb\xbb\xf9\xe0\xa9\x43\x4f\x1c\xda\xdb\xb2\xf6\xda\x57\xce\xd2\xf8\x9d\x4e\xb4\xe0\x46\x69\xfc\x82\x95\xc7\x1c\x8f\x95\xcd\x6e\x12\x9d\xa4\x12\x84\xd7\x82\xc8\x16\x11\x34\x4b\x48\x01\x99\x60\x37\x8f\x8d\x2e\xec\x4e\x62\x63\x08\x46\x8e\x6f\xa9\xee\xac\x44\x71\x0f\x6f\x06\xe4\xaa\x2b\x11\xdc\x05\x0e\x12\xb2\xe5\x45\x0a\x0b\x62\xa5\xf3\xa3\x55\x62\x41\x44\x6d\xd4\xaa\xd6\x68\x68\x6e\xfb\x27\x97\xfc\xf1\xeb\x51\xa2\xfc\x70\xed\xe8\x41\x71\xf3\xd0\x15\xcd\xf0\x71\xb8\x79\x8c\xcb\x66\xb6\xe6\x1b\xc8\x3e\xde\x78\x5f\x8d\xdf\x67\xd4\xe7\xfa\x0b\x8b\x6b\xf2\xac\xf5\x3a\x76\x16\xe7\xd4\xf4\xfe\x07\x8c\x3b\x2d\xc0\x4f\x2e\x2b\x3d\x3c\x6a\x28\x8d\x68\x24\x0e\x52\xcc\x02\x32\x3f\x4c\xa2\x19\xa8\x03\x21\xe4\x1d\x5a\xcd\x01\x2b\x2b\x88\x10\x02\x03\xb0\x85\x60\xa1\x08\x56\x83\xcc\x86\xf3\x80\x73\xd8\xc9\x3b\x17\xa2\x62\x94\x45\xe1\xe4\x2c\x04\xce\xce\xc8\x33\x48\xbb\xc3\x2e\x57\x0f\xd1\x27\x88\x14\xe1\xa7\x95\x03\x02\xd8\xe3\xf5\x10\x8f\xc1\xfd\xe9\x45\x8b\xd2\xad\xb0\xaf\x76\x1c\x2f\x5d\xcb\xf1\x34\xc5\x69\xb7\xc3\x4f\xc6\xe5\x1a\xf4\xe1\x58\x41\x2e\x85\x7f\xc5\xcc\xf5\xd1\x1a\xb3\x95\xe3\x2c\x85\x26\x2d\x1d\xfa\x83\x63\x61\xa3\x1b\xee\xe2\x38\x0a\x38\x69\x6d\x49\x6b\x4e\x8e\x9f\xd5\x96\xfb\x92\x41\x35\xb0\x78\x07\x75\x5d\x21\xa5\xd6\x5a\xd9\x8d\xd2\x6f\x29\x15\x45\x69\xe9\x17\x5b\xc7\xa6\x5a\x5b\x53\x63\x33\xbe\xb0\xcf\xee\x80\x87\x74\x1c\xa6\x54\xfa\xbd\xd2\xad\x52\xa2\xb7\xd8\xc9\x3a\x73\xf5\xb5\x79\x26\xbc\x00\x7a\x6e\xff\x20\xc7\x6f\xd1\x03\xa6\x74\xd6\x1c\x03\x86\x12\xb8\xc8\x1b\xcc\xfc\x93\xd1\x51\xa0\xff\xe9\x86\xbe\xaa\x44\x9b\x7b\x62\x9e\x5d\xe7\xb6\x18\xd5\xb0\x58\xba\xaf\x52\xc5\x60\x46\x5b\xa4\xb9\x17\xbe\x04\x1a\x63\xb5\x8a\x70\x9f\x51\xe8\x13\x35\xa2\xf3\x11\x46\x5a\xe4\x43\x95\xa8\x11\xad\x40\x3b\xe5\x1e\x8e\x62\xa2\x59\x1b\x20\xb0\x0c\xab\x4b\x90\x39\x81\xa0\xc8\xad\xc9\x23\x80\x11\x7d\x04\x58\x79\x8a\xf3\x25\xa9\x7a\x88\x86\x28\x31\xe2\xa2\x0a\xff\x8d\x18\x07\xfc\x70\x0f\x50\x2d\x2b\x3a\xe2\xd1\xd6\x35\x99\x67\xc1\xc2\xbf\xcd\x5b\xa4\xf7\x13\x1a\xb3\xf4\x9d\xcd\xa2\xc7\xa5\x6a\x33\x34\xf1\x56\xaa\xa6\xff\x79\xe9\x5b\xde\x6a\xe5\x41\xf7\x02\xdc\x00\x86\xfc\xba\x92\x88\x50\xed\x34\x02\x00\xef\xac\x12\x4a\x8a\x92\x05\x26\xfc\x28\x18\xf2\x93\xa7\xe3\x73\x87\xe2\x1f\xca\xa6\xaf\x3a\x33\x1e\xb0\x0b\xd4\x3f\x9d\xdf\x25\xed\xd8\x08\x2f\x65\x74\xf2\xd5\x93\x33\x0d\x7e\x13\xfe\x8e\xb7\x3e\x27\x5d\xfc\x9e\x95\xc7\xff\xe0\xad\xd2\x72\xad\x7f\xf5\x92\xad\x25\x65\x5b\x57\xb5\xe6\xe5\xa9\x0a\x5a\x17\xed\xae\x29\xdf\xb6\x72\x81\xd3\xf9\xff\x18\xaf\xec\x7f\x32\x69\xe6\x5b\x34\x15\x2d\x42\x6b\xd1\x2e\x84\x98\x68\x08\x08\xa9\x3e\x11\x67\x14\x43\x94\x28\x44\x13\x49\x2a\x4b\xd8\x4d\xd4\xd2\x71\xd6\xba\x9d\x23\x64\x79\xf2\x94\xd0\x71\x1a\xa9\x96\x04\x8b\x57\x88\x2a\x4b\x3b\xd1\x78\xd8\x61\xb7\x72\xac\xdd\x2b\x5f\x24\x6e\xcc\xc6\x18\x39\x25\x22\x09\x46\x21\x1b\x65\x36\x62\x0e\xaf\x72\xfa\x31\xa8\xd4\x6a\x83\xdf\xd1\x9e\xe3\xd5\xb3\x1a\x46\x05\x81\x00\xa8\x18\x0d\xab\xf7\xe6\xb4\x3b\xfc\x06\xb5\x5a\x05\xd8\xef\x9c\xef\xb6\xe6\x7a\x53\xd5\x33\xea\x0b\x0a\x59\xaa\x52\x10\x2a\xab\xf2\xea\x37\x53\x54\xca\x9b\x6b\x75\xcf\x3f\xe6\x14\x2c\x81\x80\x45\x88\x5a\x1a\x1b\x6d\x8f\xc4\xcd\x16\x4b\x77\xb7\x1c\x3a\x72\xe4\xb8\x1c\x58\xb8\x64\xc9\x42\x39\xb8\x76\xf3\xe6\xb5\x37\x6a\xdb\xb7\xa9\xe9\xb2\x3c\x15\xaf\xd5\x32\x36\x4b\x01\x9d\x96\xd2\x74\x81\xc5\xc6\x68\xb5\xbc\x2a\xaf\x8c\x56\x6f\x6b\xd7\xda\xeb\x74\x2a\xb3\xa9\x7c\x6e\x62\x9c\x8e\x5b\xfd\xae\xf4\xed\xbb\xab\xb7\x8b\xad\x7e\x00\xb3\x4a\x57\x47\xdd\x29\xc4\x2c\x81\x58\x54\xb4\x44\x05\x4b\xe3\xeb\x8d\x96\x5f\x5a\x2c\x51\xcb\x46\xa8\xdd\x28\x47\x1c\x91\x5a\x8e\xbc\x20\x47\xb4\xfe\x19\xd0\x9f\x5b\xe5\xa8\xb5\xd2\x17\xd2\xcb\xd2\x17\x84\x27\xdd\x4a\x78\x9a\xd3\xc3\x63\xdd\x42\xa2\x6d\x94\x40\xf5\x68\x12\xd1\xd3\x5a\x8c\x56\xa2\xf5\x68\x2b\xda\x89\x2e\x47\xd7\xa0\xeb\xd1\x31\x62\x67\x4f\x76\x54\xfc\x59\x17\x67\xdd\xd1\xf1\xff\x65\xba\x51\x3b\x9a\xff\x55\xf8\x5f\xb9\xff\xd5\xf9\x80\x15\xe6\xe2\xdb\x88\xa3\xfc\xe3\xdb\x46\xc6\x65\x6e\x3b\x3b\xc5\x8f\x6e\xc2\xb2\x8c\xbb\x89\x23\x75\x9f\x23\xc4\x28\x4e\xe6\x8c\xd0\x39\x53\x66\x43\xd0\xd1\x7e\xfa\x0e\x58\x71\xa4\xf6\xb3\xe3\xce\x08\x0c\xf0\x3d\xca\xd9\xf2\x3f\x1c\x38\x3b\xd0\xaf\x38\xd4\x19\xa1\x73\x25\x54\xfe\xb3\xdc\x65\xec\x00\x8b\x86\x19\xe1\x9b\xd0\x1c\xb4\x0a\x5d\x88\xf6\x21\x64\xcf\x96\x5a\x7c\x48\x29\x13\x38\x18\xb2\xa0\x52\x7a\x4b\xca\x36\x6c\x2c\x15\x27\xb2\x6a\xf2\xab\x47\xac\x7d\xc8\x7a\x23\x99\xef\x0d\x95\x7d\x40\x89\x53\x40\x1d\xca\x72\xa4\xdb\x1e\x50\x74\xe7\xe4\x01\xaa\xa2\xbf\x66\x67\xec\x43\xd8\xcd\x6c\x84\x32\xef\xff\x9c\x7c\xcf\x06\xb4\x70\x10\xc1\x7d\x24\x80\xbf\x74\x44\xfd\xbe\xc2\x02\xc1\xf0\xd1\x31\x79\x26\xde\x75\xc4\x11\xf1\x7b\x83\xa2\x5f\xd1\x4c\x10\xa2\xc2\x90\x76\x43\x86\xa4\x87\x89\x42\x54\xd8\xdd\xb6\x68\x8f\x10\x15\x4e\x82\xff\x24\x5c\x45\xc6\x73\x16\x0f\x37\xfe\x16\x9b\xca\x68\x8a\xda\x1e\x86\x80\xda\x96\xab\xd5\x95\x1a\x17\xbd\x62\xe7\x8c\xc6\xa8\xed\x2f\x3f\x25\x8b\x0e\x37\x29\x4b\x0f\x65\x83\x68\x21\xa0\xcb\x95\x00\xaa\x59\xd6\x52\x5e\xe4\x13\x92\x0d\x45\xc7\x3e\x12\xa2\xc2\x91\xae\xea\x25\x73\x2b\xc4\x50\x74\x49\x42\x51\x51\x91\xf3\x94\x15\x86\xf8\x23\x39\x85\xa0\x3d\xda\x76\xef\x6e\x93\xdd\x83\x27\x4f\x5e\x23\x0f\xed\xec\x96\x07\xb7\x18\xa3\x36\x9b\xca\x78\xe5\xa5\x64\xa8\xf7\xf5\xcd\xc6\xa8\xcd\xce\x19\xb3\x38\x5c\x6a\x10\xa9\x32\x59\x9c\xc5\x4a\xf4\x73\x32\x9e\xcf\x5a\xbe\x93\xd1\x6e\x3c\x11\x0f\x44\xcb\x89\x75\x4d\x56\x5c\x51\xee\x7d\x78\x62\xfa\xcd\x85\x15\x48\xac\x5c\xa2\x61\x82\xcc\x87\x12\x10\xc4\x80\x22\xf5\x27\xc4\xeb\xc1\x12\x37\x27\xe2\x2e\x90\x4f\x8d\x67\x35\xf1\x58\x4e\x91\x5a\x0c\x10\x62\x3e\x8a\x55\xd0\xec\x42\x3c\x11\x4f\x0c\xfd\x56\xc4\xaf\x8c\x11\x93\x04\x66\x90\xf0\x0e\x1f\x88\x64\xa3\x6b\xb0\xdd\xc1\xc8\x8d\x32\xad\xaa\xc9\x35\x25\x03\xb1\x46\xbf\xc6\x5b\x11\x48\x9a\x72\xf1\xa6\x21\x5f\x4d\xf6\x88\x34\xcf\xd4\xe4\x4b\x4e\x8e\x54\x50\x7a\x6a\xd1\xd1\xa0\x29\xcf\x6f\xb6\xd9\xcc\xfe\x3c\x53\xf0\xe8\x22\xd6\x98\x2f\x7d\xf0\x37\xde\x10\x34\xf5\x68\x79\xfb\x6b\x87\x4c\x87\x2f\x28\x9c\x11\xe6\x0a\x27\x96\x5f\x78\x20\x58\x4f\x33\x15\xc1\x39\x8d\xa1\xd8\xa6\x95\x7e\x27\x75\x62\x38\x85\xd3\x57\x56\x90\xab\xa4\xa1\x55\xfe\xc4\xc8\x54\xe6\xff\xe6\x56\xc0\xe7\x83\x4f\xbe\x17\x4e\xe1\x98\x57\x6c\x8c\x55\x79\x54\x85\xa2\x37\xb6\x2b\xeb\x62\x12\x0b\x66\x9f\xd3\x54\x68\x82\xe5\xb3\xfd\x8d\x26\xb5\xda\xd4\xe8\x9f\xbd\x1c\xe3\xbc\x6d\x9c\x0f\x52\x8e\x4a\xfd\x56\xd0\xde\x0c\xa6\xe5\xb9\x5c\x72\xba\xb3\x66\xc2\x1c\x13\x53\x11\x0c\xd6\xd3\x9a\x32\x4d\xd8\xdc\xb8\x43\xea\x95\x53\x48\xdf\xdd\x2c\xfd\x6d\xb9\xdd\x57\xa8\xa4\x80\x0a\xff\x70\x0a\xff\x7f\x71\xed\x33\x6c\x8e\x2d\x68\x3c\x9a\x8e\x16\x21\x04\x0a\x3a\x4a\x70\x0f\xe3\xa4\xc2\x76\x45\x9b\x82\x84\xc8\x9b\xc8\xc3\xd0\x7b\xca\x12\xf8\xbf\xf2\x9e\x52\xb1\x68\x08\xc0\x31\x6c\x77\xe7\xb0\x5b\x0d\x94\x20\xd6\x43\x3c\x4c\xbb\xe5\x17\x44\x7a\xef\xa4\x10\x15\xf6\x3c\xb2\xa7\x53\x7e\x85\xe4\x0a\x4f\xa4\x4d\xfc\x62\xd0\xeb\x8f\x38\x8e\x74\xc9\x75\xf8\xd8\x47\x06\xa1\xa0\xd0\xe7\x8f\x3a\x5a\x6f\xce\x3c\xfb\x71\xe6\x49\x9d\x57\x77\x97\x4e\xc7\xa6\xee\xd2\xe9\xbe\x74\x4e\x6a\xb8\xa4\xf5\x77\x7a\x2f\xee\xcd\x56\xf7\x83\xd9\xea\x0f\x9f\xb4\xde\xfc\xc6\x16\x39\xa0\xbc\x27\x89\x25\xd1\x90\x58\x31\x77\x49\x75\x17\x59\xd6\x3c\x56\xd4\x90\x14\x7c\x45\xe5\x2d\xcb\x6a\xb6\xbc\x71\x73\x66\x9f\x7c\x59\xdd\x5d\x3a\xaf\x8e\x65\xef\xd2\x79\xf5\x5f\xe6\x4e\xba\x71\x55\xeb\xef\x74\x23\xd7\xf0\xad\xa8\x85\xa8\x2e\x59\x39\x1e\x14\x9e\xf1\xec\x1e\x4f\x24\x6c\x87\xec\x50\x40\x94\x87\xf2\xf2\x90\x00\x13\xdb\x7d\x05\x85\xee\xf3\xc6\xa2\x72\x51\x90\x37\x2a\x4b\x7a\x92\x24\x5c\xe2\x59\xc0\x78\xe4\x6c\x76\x34\x6a\xa9\x5e\x5b\xa4\xc1\x8c\xd6\xaa\x1d\x13\x9d\x38\x3e\xdf\x91\x6f\x82\xcf\xa7\xeb\x6d\xfa\xd6\xcb\x31\x55\xf9\x6d\x4e\x69\xfb\xe1\xa9\x3f\xb9\x2e\x17\x68\x3b\xdf\x58\x56\x6c\x2b\x70\xd9\xb9\x9c\x09\x85\xbe\xea\xdc\x95\xf3\x67\x1d\x5c\x60\x63\x2d\x0c\xa5\x3d\x7f\x6d\xc5\x0c\xa0\x18\xf5\x23\x67\x18\xe7\x65\xf2\xc6\x85\x5f\x08\x6b\x29\xc0\xcb\x52\x2d\xf7\x0a\xbc\x47\xaa\xe6\x2f\x64\x54\xd3\xb0\xfd\xe3\xb1\x5f\xb2\xa6\x6b\x9f\x58\x7c\xf0\x56\x16\x7b\x67\x47\x97\x96\xe7\x94\xbb\x73\x0d\x40\x71\xf6\x82\xf1\xb3\xbc\x2d\x6b\xba\x0e\x36\xdb\x17\xd8\x75\x6c\xad\x19\xd4\xd8\x70\xa6\x99\x1e\xc2\x28\x30\x88\x98\x77\x99\x41\x94\x8b\x56\x20\x44\xf8\xea\xbc\x1c\x8b\x6d\x56\x17\x8e\x84\xed\x49\x9c\x90\x1b\x01\xb0\xb2\x3e\x51\x39\x42\x4a\x91\xf2\x79\x87\x65\xd2\xad\x72\x05\x92\x8b\x86\x4a\xc4\xa2\x42\xb1\x02\xe9\x22\x2a\x9a\x11\xb7\xc9\x8a\x39\x85\x1a\xc8\x05\xf8\x0b\x5a\x5f\xe0\x10\xc5\x55\x6b\x4c\xfe\x09\xe5\x74\xbe\xce\xaa\xc1\xc6\x94\xd1\x82\xbf\x35\xa8\x58\x7b\x73\xaa\xf0\xce\x47\x0c\xac\xa6\x40\xe5\x68\xdf\xfd\x60\xc7\xe5\xc7\xc4\xf9\x71\xe1\x76\xf0\x84\x42\x6e\x8f\xbb\xac\x39\x56\x62\x67\x38\x8d\x46\x03\x9f\x9c\x9a\x70\xe1\x93\xeb\xa2\x71\x38\xbf\x89\xa1\x56\x1c\x9f\x67\x2f\xb4\x6c\xa7\x7f\x97\x53\x50\x68\x70\x8c\x91\xfe\x79\x65\xe9\xec\xe9\xe5\x00\x8c\x4e\x33\x0d\x62\xd3\x5a\x33\x77\x72\x7a\xa0\x8c\xea\x36\x95\xc5\xbf\xb7\xb0\xf5\xc4\x0d\xed\x77\x5e\x11\x4b\xaf\x1a\x97\x0f\x0e\x31\x3c\x59\xf0\x04\xeb\xdb\xce\xef\x28\x56\x63\x0a\xbe\xfb\x78\xcd\xc7\xcf\xee\xb7\xa8\xa5\x1b\x96\x4a\xb7\xf9\xa9\xea\xa4\x9e\x7b\x1a\x51\x08\x06\x11\xbb\x93\xe9\x47\x75\x68\x16\xba\x1c\x21\x08\x17\xca\x53\x1a\x32\x0b\xe6\xf4\x90\xad\x48\x01\x0f\xd1\x54\x8d\x94\x81\xd2\xb6\x01\x13\x20\x9e\x48\xd8\xc1\x38\xc2\x8a\x81\x9c\x3c\x41\xe2\x1c\xe5\x98\x1a\x02\xb2\x17\x82\x5c\x15\xed\x60\xb1\x1b\x80\x35\x40\xbc\x1c\x04\xd2\x4e\x73\x94\xb2\xa5\xa8\x06\xc5\xb5\x64\xc3\x16\x87\x8b\x24\x8a\x27\xc2\x76\xaa\xde\x9d\xf7\x41\x5d\xe5\xc1\xa0\x76\x32\x5b\xee\xce\xfc\x5d\xea\x51\x8b\xd5\x71\x01\x68\x29\x55\x54\x8d\x71\xad\x08\x8f\x65\xfe\x59\x14\x66\xd9\xea\x80\x06\x3e\x92\x7e\x22\x54\xb0\x6c\xdc\xc7\xf2\xd0\xfb\x0e\xd0\xe0\x30\x58\x1f\xf3\xf1\xb9\x79\xb6\xc7\xde\x65\xfc\x5f\x03\x05\x39\x5a\x77\xe1\xd4\xbc\xab\x31\x0b\x6e\x33\x75\x87\x81\x36\x54\xe8\x12\x5d\xb8\xe8\x60\x2c\xf5\x81\xb7\x38\x12\xf8\x4b\x2e\xef\xf5\x4c\xcb\x01\x8d\x74\xca\x66\x0b\xf8\x1a\xad\x7f\xbf\xc2\x60\xf3\x06\xa6\x9b\x9e\x59\xa1\x72\xe5\x80\x0e\x57\x15\x89\x55\xd4\x62\xf3\xa1\x60\xf5\xcf\x42\xb5\xd2\x32\x77\x09\x5d\xe5\xae\x0a\x06\xe2\x8c\xbb\xb6\x48\x8c\x42\x8a\x49\x15\xf9\xca\x6a\xdb\x35\xf5\x01\x7f\x19\xee\x08\x40\x48\x7f\x91\x63\xa6\x47\x78\xe9\xa2\x00\x16\x80\x05\x06\x0a\xa7\xe7\x3a\xb4\xf9\xd7\x01\x83\xcb\xd6\xc0\x9d\xd2\xf7\x53\xa6\xfe\xb1\x26\x3f\x9e\x2c\xff\x59\x5d\xf1\x21\x47\x00\xaa\x3c\x33\x1d\x76\xa3\x5b\xea\x81\xe7\x7d\xcd\x16\x73\x8e\x57\x5a\x04\x33\x7d\xd3\x4d\x16\xa7\x20\x2d\xf9\xb5\x81\xb1\x1a\xfb\x8a\x6a\xa1\x5a\x69\x03\x5d\x1c\x62\x96\xa2\x59\xa8\x0d\xad\x45\xdd\x08\x05\x14\xf1\x82\x58\x34\xc9\x26\xe2\x01\x21\x16\x55\x6c\x4d\xe2\x11\x37\x92\xc7\xf6\x8a\x89\x36\x99\xbe\x63\x42\xf9\xef\x04\x25\x28\x02\xcb\xd9\x91\xcd\xea\xf3\x0a\xe5\x40\x11\xc1\x02\x8b\x35\xe0\xf0\x5b\x70\x80\xd0\x34\x20\xb9\xc6\xdb\xb3\x2d\xa9\xe0\xf3\x06\x44\x07\xcc\xc0\xf4\xbc\x3b\xaa\x6d\x34\xad\xe1\x78\xd6\x8c\x1f\x01\xdd\x3a\xd3\x66\x9d\x59\xb3\x63\xd1\x72\xd0\xc0\xef\xae\xb3\x5a\x5b\x07\xaf\x5f\x67\xda\xac\xb5\x68\x76\xa4\xa4\xf1\xdc\x98\x22\xea\x87\xaf\xd5\xfa\x9a\x6a\x4a\xaa\x12\x4b\x72\x60\x87\x96\xbf\x92\xee\xea\x2b\xf5\x62\x37\xf7\x73\x2a\x5a\x09\xa6\x13\xbf\x90\xbe\x1c\x37\xb9\x5d\x5a\x97\x6f\x9d\xb7\x3d\x3f\x98\xff\xe0\xc5\x56\x98\xa5\xe6\x7e\x81\xab\x7f\xbe\xc8\x25\xaa\xad\x46\xab\xce\xae\x72\x50\xfd\x1b\x9f\xd3\x5b\x34\x29\xe3\x67\x16\xe9\xab\x2f\x0a\x9b\x0a\xaf\xfe\x30\xf5\x9c\xde\xaa\x4e\x19\x3f\xdb\x4a\x45\xb9\x1c\x07\x23\xc5\xa5\xc9\x14\x87\x29\x8e\x9a\x92\x1f\x2c\xc9\x8c\xa3\x35\xa5\xec\x6f\xe0\x68\x2c\x46\x95\xea\xa4\x47\x35\xe7\xb5\xae\x07\x33\xd8\xba\x53\x77\x2f\xea\x7a\x12\xd7\x04\xf3\xb7\xcf\xb3\xe6\xe7\x5b\x2f\x7e\xd0\x44\x73\x43\x38\xb2\xeb\x69\x89\x59\x85\x0a\x51\x39\xd1\xcb\x95\x5b\x53\x05\x5e\x4a\x1a\x01\x07\xcb\x65\xe1\xb8\x6e\x79\xe6\x14\x4f\xd8\x45\x2b\x36\x80\x57\x4c\xd2\xb1\xa8\x68\x17\x6d\x82\xe8\x02\x8b\x57\x94\x87\x06\x3c\x70\x4a\xf3\x2b\x37\xa4\x8a\xb0\x12\xed\xbc\xee\xd0\xe7\x5f\x1c\xbc\xee\x8a\x6f\xaf\xeb\x98\xe7\xe6\x1a\xa6\xdd\xf9\xc9\x47\x30\xab\xcf\xdd\x50\x5d\xf4\xf2\xb1\x63\x7c\x81\x67\xf6\xce\xc9\x65\x06\x2a\x91\x98\x72\x69\xcb\xda\xcc\xec\x69\xef\x4e\xb6\xe0\xe2\x5f\xad\xf6\x79\x9d\xa1\xf5\x35\xed\x79\x53\x73\xdc\x1b\xe0\xfe\xb7\x8e\xfd\xe4\x27\xc7\xde\xba\xee\x9f\x07\x0b\x93\xa9\xfc\xef\xef\xfa\xd9\x57\x5f\xfd\x6c\xc1\x34\xbd\x7f\x69\x63\xaf\x74\x72\x39\x30\xee\xfd\x77\xfd\xfe\x81\xd6\x09\xde\x9e\xdb\xf0\x9b\x1f\xd7\x0c\x4a\x8f\x36\x6e\xdb\x19\xb0\xb4\x5f\x9b\x1b\xaf\x09\xcc\x71\x96\xba\x8c\x73\xc7\xac\x3a\xb4\xb6\x6e\xda\xea\x21\x7e\x2c\xd2\x77\x38\x51\x11\x0a\xa1\xf1\x68\x0e\x61\xf0\x20\xf0\x31\x36\x4b\x17\xe0\x88\x27\x14\x95\x64\x77\x9c\x22\x82\x57\x9c\xbd\x06\xe2\x26\xb9\xb7\x10\xed\x4c\x94\x20\x0e\x88\xc8\xa1\xfc\xc4\xd9\xa1\xd8\xa8\xce\x82\x76\xe6\x17\x95\xda\x6f\xfa\xe2\xe6\x5b\x36\xc5\xca\x68\x47\xed\xd8\x9b\x7e\xf7\x3b\x88\xfe\xee\x41\xac\x29\x0c\xcf\xaf\xb6\xd9\x34\x7f\x14\xe8\xe6\x31\x8b\xe0\x92\x48\xd1\xec\x09\xcd\x39\x53\x2f\x2d\xa0\xf7\x8f\x8f\x8e\x89\x4c\xb7\x99\x60\xca\xc8\xce\x01\xfe\x36\x7d\x42\xae\x3a\x9c\xda\x72\xfc\xf8\x96\x4d\x77\x5b\x4a\x4a\x6d\xef\x48\x2f\xbd\xfe\x06\x64\x72\xca\xeb\xb7\x5d\xbb\x69\x89\x9d\xda\x0b\xc6\xcd\x6b\x9b\x1f\x16\x6f\x29\x3a\x6f\xf2\x3c\x87\x65\xc2\xd8\x60\xc0\xb4\x7c\x6c\x74\xab\x10\x9d\x1a\x2b\xfe\xe6\xac\x3e\x61\xe8\xf9\x67\x10\xdc\x5c\x74\xe8\x1d\xc2\xca\x08\xdd\xe7\x15\xe3\xd9\x6e\x91\x63\x15\xc0\x80\xf2\xf3\x13\x03\x41\x96\xc4\xc9\xbd\x07\x91\x0a\x8e\x84\x09\xb6\x8a\x74\x9d\x67\x6e\xf7\x0e\xda\xc7\x9d\x57\xc0\x89\xe5\x62\xc0\xaa\x0b\x6a\x69\x15\x63\xf2\x5f\x36\xf7\xf9\x26\x13\x43\x6b\x74\x41\x8d\xcd\x27\x96\x8b\x5c\xea\x32\xfb\x95\x58\x65\x30\xea\x22\xbc\x2f\x55\x3a\xa9\xa8\x64\x72\x49\xca\xc7\x47\xf4\x46\x5e\x85\xaf\x04\x18\xbd\x1a\xb6\xc7\xce\x18\x5a\x52\x16\xd6\x60\xd7\x15\xd8\x2d\xb9\x46\xbc\xd8\x32\xc3\x37\x7d\xfe\x1d\xbe\x19\x96\xc5\xd8\x90\x63\xb5\x15\xe8\xec\x06\xd6\x72\x55\x01\x63\x0f\xd9\x99\x62\x8b\xda\xe5\x73\xb9\x7c\x2e\x95\x35\xc8\xd8\xa1\x7f\xf4\x3a\x18\x20\xc3\x60\x9a\xdd\xc0\xa4\x49\x29\xc4\x15\x1d\x30\x05\xc8\x44\x74\x07\x09\x01\x97\x23\x2b\x0f\x86\x15\x5c\x53\xd6\x9e\x49\x29\x26\xa5\xd8\x94\xaa\x1e\x8f\x45\x43\x58\x21\x9a\x88\x84\xb3\xe2\xe5\x54\xf3\x65\x6f\x54\xe7\xa9\x79\xde\xdc\x60\x2e\x88\xd7\x37\xd6\xeb\x02\xbb\x67\xe4\x47\xf3\xff\xc8\xa9\xac\x0e\xeb\x1c\x7b\x20\xd7\x9d\x8c\x27\x17\xc6\xa3\x0b\xea\xe2\xc9\x42\x67\x20\x67\xb6\x29\xd7\xaa\xe2\xfe\x98\x1f\xcd\x9f\x7e\xa9\x5f\x57\xdf\x54\x1f\x2d\x30\x34\x58\xcd\xbc\x3a\x2f\xf5\x36\x93\x86\xbd\x17\x8e\xb9\xa0\xfc\x00\x97\xe7\xcf\x77\x97\x5a\xc4\x7c\x43\xfe\xac\x2b\x3c\x3a\x2d\x5b\x30\xd1\xa3\xad\x0a\xe8\x19\xc6\x57\x14\xcc\xcb\x0b\x16\xf9\x18\xc6\x10\x18\xa3\xf5\x4c\x2c\x60\xb5\x3a\xf7\x55\x33\xf3\x0d\xf9\xa2\xb5\xa4\x30\x2f\xe0\xe4\xae\xae\xd8\x3e\xe6\xca\xed\xa3\xea\xc0\xe2\xff\xd3\x3a\x30\x9a\xc1\x80\x41\x4a\x3d\x08\x89\x01\xab\x36\xa8\x23\xf5\xe0\xd2\x79\xcf\x4d\x33\xb3\x1a\x46\x5b\xa4\xb1\xfa\xc4\x10\xa9\x07\x57\x61\x15\x6f\xd4\x47\xf4\xbe\xb1\x4a\x3d\x18\xeb\xd3\x47\xf5\x06\x83\x0a\xae\x02\x74\xc6\xcb\xb0\xc7\xce\xf0\x2d\x63\x79\xed\x70\x25\xa8\x8f\x4e\xf7\x4f\x9f\x7f\x87\x30\x4d\x68\xc2\xc6\x5c\xa5\x12\x68\x79\xb9\x12\x94\xcb\x95\x40\xa3\x54\x02\xb5\xa5\x84\xb2\x53\xda\x51\xef\x02\x28\x98\x44\x16\x91\x56\x8f\x67\x94\xe1\x0f\xc7\x72\x7e\x86\xe5\x92\x50\x0f\x49\x2a\x11\x67\xc8\xfc\x89\x62\x45\x62\x01\xcc\x86\x70\x39\x44\x63\xd1\x48\x38\x61\x46\x91\xb0\x8b\x71\x24\x92\x74\x22\x49\xa9\xd1\x84\xee\x86\x98\xdd\x4e\x69\x22\x0e\xc3\xc4\xb1\xcd\xaa\xf2\x4e\xe9\x1e\xe9\xc3\x45\x7f\x28\x9f\x6e\x34\x4c\x7a\x64\xf6\xa5\x4d\x8f\x81\x03\xd4\x5a\x96\x7d\xd6\xe0\x4e\x7f\x7c\x50\x42\x57\xcc\xba\xac\xb9\x58\x07\xec\x55\x5f\xf6\xc2\xda\x17\x19\x4b\x75\x6c\x62\x55\x94\x3f\x0f\x0b\x91\x49\x4b\xa2\x0d\x3b\xb6\x36\xb0\x28\xb4\x68\xe2\x94\xe2\x72\xd6\xfc\x55\xa8\xa0\x5e\x28\x65\x0b\x5f\xe0\xef\x8d\x5d\x6c\x74\x71\x5c\x5e\xa3\x3b\xa0\x2f\x14\x28\xd6\xae\x95\xee\x2c\xe0\x72\x16\x60\xc8\x0f\x79\x4d\x00\xc0\x26\x60\x1d\xd4\x82\xda\xe0\x2d\x9b\x12\x3a\x41\x4f\xeb\xb8\xf0\xc0\xd8\x59\x5b\xa7\x7a\x46\xf0\x60\x4d\x44\x2d\xa8\x1d\x2d\x27\xd8\x36\x2b\x27\x3a\xd8\x91\x1f\xaf\x98\xe0\x84\x91\x9f\x58\x34\xe1\x10\xe3\x23\x3f\x91\xb0\x83\x4b\xd8\xcf\xf8\x44\xb1\xdf\x47\x26\x1f\x72\x75\xf0\x9b\x2d\x04\x97\x6d\x52\xe0\xd9\xe4\x8b\x29\x66\xfe\xda\x67\x11\xdf\x3c\x51\x5a\x7f\x74\x65\xdd\x8c\x19\xbc\xd0\x24\xf0\xd3\xa7\x36\xac\x3c\x5a\x53\xf9\xe0\x9b\xa2\xa5\xef\x2b\x86\xf9\xfa\x23\x39\x41\xa8\xee\xd6\x95\xe3\xa6\x4c\xd3\xfb\x45\x41\x49\x71\x6b\x5d\xe8\xc4\x1b\x01\x5b\xdf\x57\x8c\xeb\xa8\xf4\x9f\xb7\x6e\x7d\xfb\xe8\xa2\x45\x47\xdf\xde\x7a\x2b\xe8\x8f\x4e\xc9\xac\xcf\xac\xc7\xd7\xe2\x5f\x67\x6a\x33\xb5\xcc\xaf\x33\x44\xbf\x00\xa7\xcb\x0a\xf9\xe9\x53\xc6\xaf\xbc\xb5\xae\xfc\xc1\xb7\x02\xf6\x4f\xbf\x61\xd9\xaf\x3f\xb6\x04\xdf\x7a\xb0\x64\xec\xad\x9d\x13\x26\xcf\xe0\x8b\xbd\xbe\x62\x7e\xc6\x94\x71\x9d\xc7\xe4\x14\xa2\xa5\xef\xaf\x2c\xfb\xd5\x47\x96\xe0\x9b\x0f\x96\xd7\x1d\xeb\x4c\xce\x98\xce\x17\x86\x7a\xc0\x70\xb4\xed\xe8\xbb\xdb\xb6\xbe\x7b\xb4\xed\x28\x18\xb0\x2b\x83\xa5\x4b\x60\x27\x96\x60\xe7\x8f\xbf\x85\x5b\xa8\x04\xdc\x2c\xad\x18\x78\x91\x6a\x1d\x48\x4b\x29\xe8\xa5\xd2\xd0\x3b\x8c\xb3\x24\xb6\x44\x45\x28\x8e\x10\x78\xb8\x2c\x1e\xc6\x61\x8f\x0c\x91\x29\x07\x22\xc0\xb3\x5c\x2c\x4e\x16\x22\x21\x62\x01\x93\x27\x9e\xf0\x98\xa2\x82\x98\x70\x01\xcc\xc6\xff\xe1\xcc\xac\x5c\x77\xf4\x82\x36\x47\x63\xd9\xbe\xe7\x9f\xa7\x3e\xfc\xa7\xe4\x72\xf8\x12\xb1\xa6\xd9\x6b\x92\xc7\xab\xad\x56\xe9\x93\x4f\x1f\xa7\xe6\x0d\x7c\x16\x50\xe1\x9f\x2e\x6b\xce\x5d\x71\x11\x23\x4c\xbe\x75\xdd\x40\x66\xf1\x61\x0b\x33\xf9\x85\x7d\x14\xb5\xef\x85\x77\x4f\x7d\x5b\x37\x77\x7d\xd3\xcc\x4a\x0f\xfe\x95\xf3\x96\x68\x2c\x1e\xc5\xef\x67\x1e\x86\x6f\xfb\xef\x4e\x98\x69\x7e\xee\xbe\x82\x71\xde\xff\x40\x43\x5c\xef\x59\x2c\x9f\x15\x79\x50\x19\xaa\x46\xad\x68\x1d\xda\x86\x0e\xa0\x3f\x9d\xb6\x36\xa0\x62\x51\x21\xcb\x3e\x18\x8e\x27\xce\x1d\x38\xd3\x0f\x6c\x96\x26\x3b\xc1\xda\xac\x66\xc7\x30\xb3\xdc\x10\xd5\xa8\x59\x94\x27\x64\xac\x3c\x09\x4b\x28\x8c\x6a\x89\xb8\xc2\x4f\x47\xce\xce\x82\xf8\x86\x8e\x90\x16\x99\x4b\x02\x63\xc5\x1c\x4b\x1b\x86\x54\xaf\x88\x1d\xbb\x48\x66\x24\xa4\xc5\x4a\x08\x22\x69\x7d\x49\x4b\x46\x91\x4e\x5c\x9e\xd1\x61\x65\xb4\x4e\x26\x75\x72\xc3\x4e\x28\x29\x39\xbb\x12\x41\xcd\xf1\x56\x79\xbd\x55\xbb\x8a\x6a\x83\x45\x05\xae\xa2\x7b\x83\xb5\x45\x45\xae\x82\xa2\xfb\x8b\x6a\x8b\x8a\x6a\x87\x1c\xd0\xcd\x91\xde\x7e\xe0\xc2\x37\x0e\xcc\xb2\x75\xee\xda\xe6\xaa\xab\x72\xb9\x13\x55\x2e\xf7\x3a\xb7\xab\x2a\xbf\x52\xdf\xbd\xeb\xea\xc9\x26\xd7\xe2\xf8\xc7\xae\xd9\x0f\x1e\x5c\xbf\x4c\x2f\x4d\x4c\x2d\x4d\xd5\x2f\xaf\xc7\x5b\x1a\xaf\x5f\x3a\xed\x40\xa2\xa2\xf5\xbc\xd8\x02\xbf\x29\x12\xa3\x1b\xe7\x82\x63\x5c\xed\x18\xe9\xeb\x56\xba\xa6\x24\x7b\x81\x84\xdb\x55\x55\x5e\xb5\x70\xcd\xf9\x6d\xf1\xe8\x86\x09\x6e\x71\x41\x63\x6f\x45\x8e\xb9\x6c\xec\x9a\x86\x1a\xbb\xc5\x81\xad\x94\xc6\x99\x63\x9c\xff\xe3\x15\xbe\xbc\x9a\xf9\xb3\xab\x19\x9d\xde\x02\x26\xc1\x78\x34\x98\xeb\x2b\x4b\x2c\xa4\xbf\x18\x53\x5e\x3e\xa6\xfc\xd4\x9c\x8d\xae\x92\x12\xd7\x46\x57\x69\xa9\xeb\xbf\xf5\xe1\x97\x7a\x9e\x5f\x79\x4f\xdf\xb6\x96\x79\x0f\xbc\x75\x9b\xf4\xfa\x8a\xea\x30\xf9\x2b\xcc\x6d\x07\xcb\x7f\x34\xb2\x96\xff\x9c\x77\xfe\xce\x43\x47\xde\x9f\x58\x81\x1f\x0c\xcf\x98\x11\x8e\xcc\x98\x21\xf5\x75\xfc\x74\xcd\xc4\x9a\x63\x6b\x3b\xbb\x2c\x6c\x55\xd4\x69\x1d\xff\xab\x8d\xeb\xa5\xbf\x34\xa4\x8e\x3a\x61\x63\x49\x4a\x39\x7f\x5c\xc5\xf8\x66\xb0\x14\x76\x70\xa1\xde\x8d\x55\x9d\xd5\x57\xde\x72\xf1\x9c\x68\x41\x2e\x65\x65\x0d\x21\xc1\xba\x7e\x0f\x9d\xaa\x66\x38\xc6\x64\xb0\x00\x9b\xa3\x63\x2d\x57\x7d\xe3\xaa\x6c\x1e\x39\x87\xcf\x45\x01\x82\x12\x88\x8a\x1e\x5b\x64\x18\x40\xeb\xc8\x8e\xc0\x22\xe1\x78\x20\x12\xf3\xc5\x7c\x36\x9f\x2d\x62\x8b\x9c\xb1\xe7\x76\x98\x95\x8e\xbc\xa3\xbb\xa8\x79\xd9\xbe\x7d\xcb\xda\x6a\x3b\xd7\x1c\xee\xe9\xeb\xeb\xb9\xe3\xb7\xb0\x60\xed\xda\x75\xeb\xd6\xad\x03\xf3\xa8\x21\x04\xde\xea\x29\xdc\xd3\xb4\xe0\x9a\xe7\xae\xa9\x59\xb1\xfc\x23\xe9\xd9\x8f\x7e\xbf\x75\x1d\x49\x78\xfe\xe8\xd1\x81\xdc\x37\x04\xb2\xed\xa5\x48\x54\xea\xe4\xda\xea\xf7\x79\x39\x93\xcf\x14\xca\x92\x04\x5a\x59\x82\x7e\x26\x0b\x6f\x0a\x8b\x25\x8b\x2a\xef\xbf\x7d\x8a\xf4\xc9\xdc\xdb\x4f\xf6\xd4\x37\xa5\x1f\x4a\x37\xd5\x3f\x75\xe3\xb2\x65\xfc\xaf\xa2\xd3\x5a\xb4\x57\x59\x9d\x02\x8d\x06\x1e\xad\xe0\xa3\x35\x15\xd2\xfd\x4c\x4b\x6e\xf7\xf8\xd6\x74\xba\x75\x7c\x77\xee\xf8\x52\x03\x2e\x32\x63\x41\x50\xc6\xa7\x33\x89\x4e\x07\x83\xaa\xd1\x3c\xb4\x08\x1d\x42\xc8\x1c\x8e\x0b\x5e\x96\x09\x31\xa2\x22\x12\x57\x0f\x21\xcc\xfa\xbc\x06\xf0\x99\xc2\x71\x17\xe5\x20\x9b\xdf\xf6\x78\xc2\x9e\x48\x82\x48\xba\x62\xc1\x11\x31\xf9\x44\xa1\x04\xbc\x06\x60\xe5\xa1\x4c\x3d\xc4\x5d\xc0\xb9\x14\xf5\x32\x9a\x5c\x4f\xe9\xac\x95\x85\x13\x1e\x44\x1e\x42\x20\xc2\x70\xe7\x9d\x64\x6b\x20\xec\x88\xd7\x40\xd8\xc5\x3a\x3c\x61\xfb\x0d\xcd\x6e\x77\xb3\x9b\x55\x6b\xaa\x9d\x61\x5f\xc8\x7e\xd1\xec\xfe\xe6\x6a\x18\x73\xc2\x3e\x26\xd0\xa4\x5d\xd4\x70\xeb\xcd\x8c\x5b\x97\xc7\xdb\x54\x50\xb4\xa9\x7b\x7a\x79\xf5\x7a\xd3\xd4\x98\xd5\x8d\x35\x9e\x92\xf1\x85\xdc\x9e\x8e\xb6\xa3\x0d\x2b\xef\x5c\x50\xfd\x5a\x7e\x5e\xc9\x65\xa5\xcf\xe4\x56\x07\x34\xc6\x66\x6b\xc1\x6a\x6d\x14\x10\xb9\x2c\xa8\x04\xa7\x34\x3d\x6f\xdd\x44\xcf\xe2\x44\xf1\x45\x0d\xb5\x7b\x2e\x5c\x5f\x21\x7d\x24\xdd\x44\x80\x59\x77\xf0\x0d\x05\x35\xc5\xb5\x29\xff\x96\x65\xb3\x66\x2d\xbb\xd3\x97\xaa\x8c\xfb\x22\x79\x09\x1e\x96\x39\x05\x48\xa7\x52\x29\x56\x3f\xd5\x9b\x2a\x8e\x3a\xf6\xb5\xd3\x1d\x13\x1e\x1c\x7f\x52\xab\x05\xdc\x70\x6b\xa6\x0f\xe0\xff\xa3\xee\x3d\xc0\xe3\x2a\xae\xc5\xf1\x39\x33\xb7\x6c\xef\x45\x75\xd5\x77\x2d\x59\x5a\x49\x5b\x25\x63\xf5\x62\x70\x95\x2b\xc6\x60\xcb\xab\xdd\xbb\xd2\x5a\xab\xdd\xf5\x16\xcb\x72\x28\x02\xc7\x98\x12\x4c\x27\x74\x4c\xa8\x0e\xe1\xe5\x11\x08\x84\x6e\x48\x02\x84\x84\xc4\xa1\x3f\x48\x78\x40\x48\xf2\xd2\xc0\x09\x24\x2f\x80\x75\xf9\x7f\x73\xef\x95\x2c\x17\x92\xbc\xf7\xfb\x7e\xdf\xf7\xff\x19\x34\x73\x66\xee\x3d\x73\x66\xce\x39\x7b\x66\xee\xbd\x67\xe6\x10\x4e\xab\x12\x7f\x91\x6e\xb6\xb5\xb5\x73\x3e\x4b\xd8\xa9\x69\xe8\x5e\x55\x84\xd1\x43\xcb\xfb\x3e\xae\x5a\x57\xe5\xc7\xbe\xb7\x9c\xc4\x5f\x61\xdd\x58\x54\x7b\xa9\xb1\x77\x69\x77\x77\x37\x46\x33\xd3\x25\xee\x9e\xb5\x9a\x96\x3e\x5d\xb0\x9d\xa9\xd6\x7a\xfa\x9b\xa1\xc4\x5d\x82\xf7\x97\xb8\x0d\xfd\x65\x01\x67\x99\xb6\xad\x4d\x67\xae\x2d\x09\x56\xf4\x98\xdc\xc7\xf8\x5c\xd4\x49\xab\x88\xa3\x0b\xa0\x70\x27\x17\xee\x24\x3e\x17\x76\xba\x38\xa7\x03\x6a\x65\xef\x04\xe0\x39\xde\x40\xaa\xbd\x58\xf2\xcc\x90\x9d\x18\x58\x17\xe3\xeb\x24\x3c\xda\xd2\xfb\x59\x77\xef\x16\xad\xaa\xd3\x3e\x38\xb8\xeb\xae\x14\x3b\xdc\x32\xb4\x68\xc8\x77\x16\x97\xba\x6b\xd7\xe0\xa0\xbd\x53\xa5\x9d\xf9\x09\xf0\x6b\xb4\x44\xe5\x56\x95\x68\x7f\x9b\x61\xb7\xb4\x0e\x2d\x1a\x6a\xdd\xc2\x3e\x76\x8b\xb6\x44\xe5\x56\x11\xed\x1a\xe0\x35\x43\xbe\x95\x2b\x96\xae\x58\xdd\xb2\x86\x64\x8f\x78\xa5\x90\x2c\x2f\x1b\xd5\x7c\xd8\xbc\x28\xb8\x79\x6a\x88\x39\xb5\xaa\xae\xae\x7a\x90\x1d\x9a\xda\x1c\x5c\x64\x0e\xf3\xea\x99\x7b\x9f\xee\x50\x15\x6b\x03\x5a\xa2\x3a\xb0\x9a\xd0\xab\x55\xa7\x92\x0b\xf3\x2a\xa2\x0d\x68\x8b\x55\x1d\x4f\xab\x16\x57\x37\x39\x1c\xcd\x95\x5d\xc7\xfa\x3d\xb6\xa2\x21\xfa\x04\x0e\xca\x19\x30\x06\xb2\x10\xd3\x21\x49\x27\x59\x28\x11\x01\x5d\xe4\x14\xec\xeb\xc4\xe1\xda\x70\xc8\x61\x35\xbb\x3d\xee\x3a\x2f\xbd\x4b\xfa\xd4\xce\x73\xfc\x89\x11\x08\xc2\x21\x14\xee\xa4\x48\x94\x63\xd8\xe9\x60\x9f\xf5\xa8\x88\x66\xe1\x3d\xe7\x32\x9e\x86\x55\x4b\xeb\x00\xea\x96\xae\x6c\x74\xb3\x3b\xef\xf1\x68\x89\xaa\x4e\x55\xaa\xdd\xf2\x2a\xbb\xa2\x71\xa0\x08\xa0\x68\xa0\x71\x05\x0b\x38\xac\x2d\x79\x6e\xd3\xc0\x99\xe2\xeb\x64\xa8\x61\x90\x56\x0f\x36\x0c\x91\x37\x7e\xb4\x28\x68\xe0\xad\x7a\x56\x8e\x36\x40\x19\x5c\xff\x15\x78\x8e\xab\xf5\xae\x58\x46\xdb\x5c\xb6\xc2\x5b\xbb\xf0\xfd\xf7\x37\xd6\xe3\xb4\x5f\x5b\xac\xaa\x3e\x3f\x42\x2a\x2b\x7d\x4e\xa7\xaf\xaa\x82\xd9\x7c\xbe\x4b\xe2\x0d\xa3\x3e\xed\x0e\xa6\xb3\xa2\xba\xba\xa2\x93\x79\xae\x51\x45\x66\xdc\x64\xff\xda\xb6\xa5\xbf\xc1\xbd\xae\x9a\x1a\x57\x2f\xbe\xfb\xb6\x56\x9f\x8e\x3f\xb2\x55\x6f\xb5\x92\xfb\x8f\x48\xbb\x69\xc9\xfe\x36\x77\x16\x22\xac\xab\xa6\xb5\xa8\xa8\xb5\xc6\x55\xfb\xad\x87\xd7\x50\x75\x41\x5a\x64\xff\x02\xb1\x7f\x98\xb7\xbf\xa3\x04\xb9\x50\x35\x72\x23\x2f\xf2\xa1\x1d\x08\xd5\x39\x9b\x01\xea\x3c\x2c\x38\x89\x07\xea\x08\x0b\xce\x66\xb0\x39\x38\x23\x38\x1d\xc0\x92\x3a\x08\xf3\x4e\xa9\x3a\xec\xe1\x25\x3f\x8c\xb0\x11\x7b\x78\x9b\x11\xb8\x66\x70\x4a\x3b\x15\xdc\x41\x8f\x9b\xb8\xbb\xc0\xed\x99\x4d\xc3\x75\x3e\x27\xeb\xb0\x5b\xa5\x8d\xde\x76\x67\x38\x54\x01\xe1\x40\x17\x48\x47\x6d\xd0\x07\x59\x23\x70\xb0\xf4\xc5\xea\x37\xc1\x02\x16\xad\xf8\xaa\xf8\xe1\xaf\x5a\xfe\x0a\x8b\xa1\xc3\x20\xee\x87\xcb\x86\xf1\x28\xc6\xcc\xca\xf5\xfc\x4c\x17\xa0\x7e\xf1\x77\x4c\xdc\xf8\x1b\x3c\xf3\x1e\x14\xac\xe2\x19\xe4\x46\xdb\xfb\xf8\x0a\x0e\xf3\x80\x5d\x0f\xda\xac\x4b\x54\xcc\xef\x79\x7e\x84\x67\xc4\xb7\x19\xac\xfa\x80\x09\x63\xbe\x63\x0b\x9c\x8a\x55\x5b\xf6\xe0\xad\x58\x0d\x0f\xb0\x04\x3a\x38\x1b\xb7\xe3\x5c\x96\x9d\x62\xb9\x75\x84\xfd\x29\xc7\xfe\x95\xc1\x46\x1b\xf3\x34\x07\xaf\xff\xf1\x35\xd1\xff\xd6\x5f\xdf\x80\x0b\x5f\x83\x25\x3f\x99\x79\xff\x75\xe8\x7f\x41\xbc\x63\xe8\xa3\x55\x60\x54\x93\xc0\x20\x87\x6f\x7d\x01\x7e\x7e\xff\xe7\x0f\xfe\xfe\xce\xc3\x78\xfb\xb3\xf0\xe8\x1d\x47\x1e\xff\xdd\xbe\xc4\x30\xc3\x4e\x9e\xf5\xce\xf4\x07\x55\xad\x05\x96\x3c\xce\xb2\x6b\x6f\x67\xc9\xef\x31\x86\xbf\x30\x60\xe6\x99\xba\x0d\x1c\x0c\xf3\x6c\x53\x4c\x05\x2f\x6b\xc8\x5e\xb8\x81\x61\xc5\x56\x9e\x74\xac\xc7\xdc\x57\x96\x32\x4c\x5b\x8a\x23\xe7\x12\xb2\x97\xe1\xb2\x7b\x09\x8b\x6f\x60\xe7\xaf\xe1\xca\x91\x07\xad\x97\xde\x9a\x92\x1a\x03\x43\x1f\xfc\xaa\xe5\xb7\xa1\x55\xbe\x10\x39\xba\x58\xb1\x2b\x47\x24\x1c\x1b\x73\xeb\xe8\xe1\x09\xc7\x40\xcc\x03\xda\x8a\x96\x21\x3f\x17\x76\xf9\x9b\xbd\xcd\x7e\x57\x98\xf3\x0f\xb5\x54\x68\xd7\x75\xe0\xee\x8e\x75\xf7\xdf\xf0\xfa\x0d\x37\xbc\x7e\x03\x3e\xdb\x62\xd8\xba\xa5\xf7\xf3\x6e\x29\x62\xc6\xc1\xde\x2d\x72\x5c\xb0\xb9\x14\x1a\xda\x63\xc2\x92\x26\xa6\xca\x54\xa4\xd1\x14\x99\xaa\x98\xa6\x25\x42\xac\xfd\xb4\x48\x04\xdf\x94\xbc\xfe\xfa\xe4\xf8\xf5\xd7\x8b\xab\x0e\x1a\x2c\xef\x52\x74\x56\x0a\xbb\xf1\xae\xe4\xe9\x3d\xad\xa4\xca\xf7\x04\x69\x8c\x6a\xb4\x10\x9d\x81\x12\xd2\xfe\x39\xc5\x0b\x84\xf8\x5c\xcc\xec\x70\x02\x9d\xe4\x14\x70\xb1\xbe\x4e\xe6\x24\x63\x99\x3b\x1c\xe2\x84\x91\xdb\x4f\x88\xd1\xc6\xc8\x43\x6b\xf1\x9e\xd6\x5c\x69\xe2\x57\xf5\xce\x1c\xec\x5d\xa5\x2e\x6b\x5a\x1d\x64\x79\x9f\xbd\xa9\xbc\xde\x5d\x5f\xde\x64\xf7\xe1\x07\xad\xfa\xad\x52\x00\x65\x25\x3d\x86\x0b\x7a\xeb\x17\xc8\xaa\xff\x5c\x8a\x2a\xc2\x1c\xd4\x5b\xc9\xd9\xe3\xd7\x5f\x3f\x9e\xbc\xfe\x7a\xf1\x7b\xd5\x1d\xa7\x9d\xb1\xbc\xbe\x6f\x74\xb4\xaf\xe5\xcc\x6d\x2b\x02\x4c\x85\xd6\xa9\x56\xab\xd5\x4e\x6d\x05\x30\x7a\xeb\xb4\x14\x99\x59\x4e\xe7\x73\x85\x36\xc6\x4a\x47\xfb\x7c\x46\x1b\x55\xe2\xe4\xa8\xe4\x35\x49\x15\x6a\x45\x3d\x68\x35\x2a\x20\x84\x02\x5e\x3c\xa7\x01\x58\x1a\x11\x9e\x0d\x96\xad\x84\x4b\x99\x3d\x8f\xdb\xfc\x4f\xca\xf2\xf4\x10\x94\x0f\x0d\x90\xb6\xba\xcd\x42\xf3\xde\x1c\x21\x4b\xfd\x50\x3b\xd7\x52\xda\xd8\xd0\xd0\xd0\x58\xda\xc2\xb5\x0f\xd5\x5b\x96\x86\x30\x0a\xad\xdd\xf3\xc4\x9e\x3d\x4f\x30\xd5\xf3\x5d\xe9\xed\xc6\x99\x17\x8c\x76\xbb\x11\xb7\x19\xed\xc7\xb8\xd8\xa3\x2d\xbd\xe2\xfe\xf9\x07\x70\x88\x52\x68\x16\xee\x60\xef\x16\x58\x3f\x3d\x1e\x6d\x67\xca\x8c\x36\xb5\xda\x66\x2c\x63\xda\xa3\xe3\xd3\xeb\x71\x17\x6d\x7c\x8f\xf8\x9b\xb9\x03\x28\xc0\xd2\x46\x5b\xa6\x09\x68\x8f\xd6\xae\xa4\x32\x99\xaf\x93\xb2\x7c\xb6\xc8\xb1\x01\x4f\xe4\xdf\x1e\xe9\x49\x82\x2a\x49\xa0\x13\xfb\xa5\xa9\x2e\xec\x73\x01\x9e\xfd\x9e\x7c\xdc\x79\x1c\xc1\x7f\x52\xb6\x1e\xa3\x5b\x27\x39\x62\xe1\x24\x71\x6d\x18\xb4\x34\x24\xa2\xd0\xd2\x13\x19\x7b\xe9\xff\x80\xa5\xd3\x56\xfd\xa7\xdd\x72\xac\xef\xf9\xe7\x33\xc0\x56\x69\x66\xf9\xb4\x7b\x8e\xbd\xaf\x4d\xaf\x3f\x81\xc3\xf0\xb8\xc4\xde\x99\xad\x73\x8c\xfc\x70\x8e\xbb\x7f\x9d\xab\x3b\xe2\x63\x24\x85\xa4\x5a\x3e\x9f\xc5\x56\xe6\xa5\xa3\xbf\x84\x2d\xe8\xb8\xd8\x3e\x4e\xb4\x00\xa1\x3a\xe9\x10\xd2\x6a\x39\x48\xae\xb4\x46\x96\x0f\x95\x44\xa6\xd9\x93\x19\x67\x5d\x1c\x3f\x76\xec\x9e\xec\x7b\xf4\xa7\x8f\xf6\x4d\xee\x76\x6c\x83\xa5\x70\x2e\x2c\xbd\x58\xf1\x36\xc6\xef\xed\xfb\x48\x7c\xe8\x91\x87\x8f\x71\x18\xfc\xe1\x4d\x2f\x99\x96\xae\x5d\xbb\xd4\xf4\xd2\x4d\xd7\x7d\xfb\xdb\xf8\x3b\x72\x34\xf0\xf7\x20\x24\x5e\x23\x7e\xf7\xcf\xc7\x39\x16\x1e\xed\x97\x09\xd5\xa2\x46\x69\xaf\x86\xc3\x62\xb7\x1d\x75\xb3\x84\x50\x30\xa0\x1c\x1e\x68\xb7\x39\x2d\x7e\x47\x65\xd8\xe7\x56\x3a\x8b\x5f\x94\x5b\xba\xec\xb0\xf8\x90\x78\x95\xf8\xd0\x47\xfb\xf6\x1d\x66\x26\xae\x3d\xea\xd6\x78\x6d\xef\xe1\xdd\x90\xdc\x7d\xf8\x80\xd2\x61\x0e\xed\x3b\x2c\x3e\xf4\xf0\x77\xc5\x87\x0e\x5f\xbe\xef\xcf\xb0\x4c\x42\xff\x7c\xc9\x4b\x9f\xdd\x2c\xfb\x5a\x8a\x1f\xdc\xfc\xd9\x4b\xb0\x64\x7a\xfa\x76\xa5\xd7\xc7\xc6\x63\xa9\x90\x77\xdb\xc0\x31\x26\x2f\x3c\xeb\xc0\x60\xb7\x21\xa9\x57\x21\x93\xd5\x47\x3b\xed\xe1\x2a\x3d\x9c\xf4\x15\x91\x79\xa0\x79\xfd\xe6\xde\xc6\x17\x2e\x3b\xf2\xcd\xcb\x5e\x68\xec\xdd\xbc\xbe\x79\xd5\xea\x4b\x9e\x3c\xf4\xe4\x25\xab\xc5\xdb\x14\x5f\xec\x85\x1b\xcf\xb9\xe5\xea\x2b\xc5\x0b\xae\xbc\xfa\x96\x73\x36\xe2\xc3\x86\x96\x91\x3d\xaf\xec\xbe\xf1\xed\xb7\x6f\xdc\xfd\xca\x9e\x91\x16\xc3\x39\x57\x8f\x3d\x79\xc9\xea\xd5\x97\x3c\x39\x76\x35\xb6\x2a\x83\xf9\xec\xbd\xcb\xe3\x1f\x81\x8d\x3f\xef\x3c\x5e\xfc\xe3\x47\xf1\xcb\xe7\xce\x9b\x66\xe5\xf3\x16\x8a\x51\x0d\xea\x38\xe6\xd7\xe4\xf0\x1d\xf3\x53\x32\x57\x9d\x34\xb0\xd3\x5c\x34\xcd\x63\x7e\x0a\xab\xdb\x86\xde\x1c\x6a\x5b\x5d\x7f\xd1\xde\xa7\xf6\xee\x7d\x0a\x6e\x3f\x82\xac\x7a\x22\xaf\x92\x8e\x48\xba\x46\xd5\xfc\x20\xd5\xef\xde\x2d\xb0\x61\x7a\xc3\x86\xe9\x64\xac\x7d\xd9\xb2\xf6\x18\x3c\x2a\xa9\xf2\xe7\xfb\xd9\xad\x9f\xed\xd7\x5b\xad\xec\x4b\x9f\x75\xcf\x9a\x55\xc5\x22\x20\xa4\x9a\xb3\x05\x56\x54\x8a\x16\xa2\x53\xd0\x32\x74\x26\x12\xa8\x3d\x95\xbe\x43\x72\xd5\x1e\xf9\x73\x35\xed\xee\x97\x99\xd3\xe3\xcb\x75\x73\xf6\x52\x1e\xd1\x09\xe6\x75\x2e\x6a\x7c\xd5\xf1\xdf\x6e\xa7\x8d\xd5\xfd\xcd\xdd\xdf\xeb\x6e\xee\xaf\x36\x76\x35\xc2\x37\x1b\xbb\xa6\x25\x57\x18\x26\x63\x31\xcc\xc8\x81\x2e\x0f\x1a\x2c\xe2\xf4\xec\xe6\x48\x90\x0e\x5d\x51\xb6\x48\xc9\x5b\xa6\xe6\xee\xfa\x74\x9a\x47\x16\xc3\xa7\xdd\x06\x0b\x7f\xec\x0f\xbf\x3f\xb4\xf9\x74\x5f\x77\xb7\xef\xf4\xcd\xa1\xf0\x8a\x15\x70\x87\xe4\x6b\x23\xbe\x7b\xd4\x76\xce\x9d\xe7\x32\x2f\x99\x57\x09\x29\x89\x7f\xf3\x7f\xea\xff\x88\x8f\x73\x2a\xab\x28\x02\xfe\x32\x9b\x5a\x77\x5c\x99\x3d\xce\x03\xf6\x44\x1b\x7b\x72\x45\xa2\x7c\xec\x6a\x14\x37\x34\x76\xcd\xe3\xe6\xff\x9e\x8f\xd3\x9f\x22\xab\x9e\x3b\x78\xbc\xf9\xec\x0f\xaf\x58\x11\x9e\xe3\x24\xbc\x2e\x71\x71\xe6\xe8\xc1\x48\x7f\x39\x09\x13\x8f\xd6\x1d\xf9\x0e\xb3\xf5\x73\xaa\x96\xc7\x9a\x4c\x2c\x9d\x51\xf6\x3e\x87\x50\x89\x14\x9d\xd1\x84\x6b\xaa\xb1\xd9\x64\xf1\xfb\xc2\x5e\x46\x72\x72\x96\xde\x4c\x81\xdf\x61\x20\x35\xf4\x59\x86\x93\x4f\xb3\x0d\x58\x42\xb5\xf2\x96\x48\xcc\x4b\x1e\x36\xcc\x6f\x5f\x7e\xef\x9d\x43\x87\xde\x59\xda\xee\xa8\x0e\x05\x4f\xab\xf7\x56\xb5\x26\xee\xfb\xea\x3d\x7d\x7d\x70\x61\x81\x68\x16\x9e\x76\xd9\x59\x4b\x26\xcf\xea\xad\x8a\x24\xaf\x13\x7f\xf5\xcb\xbd\x7b\xdf\x81\xf2\x6b\xa7\xfe\xf0\xfc\x0d\x1b\x6e\xbf\xa4\x79\xf3\xa2\x8e\x5e\xfc\x27\xe8\x84\x76\xf1\x39\xf1\xfb\xe2\x0f\xc4\x1f\x99\x17\x2e\x1e\x5c\x58\x6e\x8a\x9c\x99\x14\xae\x15\xf7\x94\x0e\xa5\xce\xec\x71\x2f\x5d\x13\x2e\xcd\xff\x08\xea\x0f\x7c\x13\x16\xbe\x98\x3f\xf5\x6b\x4f\x7e\x7a\xf1\x53\xe2\x0f\xc7\x07\x4f\x5b\x36\x6b\x0f\x04\x35\x62\x6f\x42\x95\xc8\x8b\x6e\x40\x4f\x4b\x7b\x3c\x25\xb7\x29\x6c\x36\x59\xa5\xd7\x10\xca\x4b\x7a\x93\xe4\xf3\x5f\x37\xb7\xf3\x55\x92\x9f\xed\xa8\x9b\xc4\xec\xa9\x7a\x76\x9b\x7c\xfa\x5e\x30\x10\x9a\xef\x10\x61\x97\x3e\xfe\xcb\xde\x93\x76\x9b\xe4\xf4\xa3\xf8\x4c\x48\xaf\xd8\xfc\x3e\xa7\x8b\x71\xda\x5c\xac\xe4\x59\xe2\x96\xca\xc0\x9a\x8e\xfa\x0f\x84\x43\x66\x29\xbe\x90\x97\x95\xbf\xa9\x39\x2c\x4e\x07\xfc\xb0\xd2\x0e\xba\xae\xe8\x7b\xaf\x79\x32\x6e\x6b\x65\xd7\x48\xeb\xe4\x57\x7c\x1b\x70\xb1\xc1\xa6\x66\xbb\x6a\xca\x3f\x7f\xbe\xc4\x5d\x53\xce\xb4\x97\xb8\xdf\xe8\x2b\x3e\xc3\x63\xd2\xf2\x26\xb7\xd7\x5d\x53\x6e\x26\xc6\x85\xce\x5e\xa2\xd1\x2f\x72\xb0\x0c\xa9\x74\x87\x82\xee\x86\x72\x9f\x09\xc0\xc2\x95\x4e\x5e\xdf\xba\x64\xb0\xb5\xb8\xbc\xd4\x5a\xef\x5b\x5c\xbf\xd8\x53\x66\x52\x71\x44\xa5\xd1\x99\x35\xce\xb2\x05\x9a\xd2\xde\x53\x3b\xf0\x2b\x97\x58\x17\xad\x5c\x57\x69\x72\x2d\x5a\xa5\x7e\xa4\x3e\xb0\x28\x81\x1d\x5a\xab\x56\x55\x69\x1d\x3c\x77\x64\xab\x0e\x0b\xf6\x2a\x62\x3c\x07\xca\xe0\x22\x58\x0f\x66\x7f\xa2\xd4\x5a\xda\x15\x5f\xf3\xfc\x67\xe2\x6f\x5f\x5e\xbf\x91\x94\x98\x8a\x1d\x67\x97\x7b\xdc\x25\xe5\x1e\x37\x3e\xed\xc2\xa8\x7b\xb5\x4d\xa3\xe3\xd4\x0d\xbe\xf5\xde\xe5\xa1\x06\x56\xd7\xac\x77\x94\x2c\x37\x2e\x32\x16\xdb\x8b\xdb\x81\x61\x70\x8b\xab\xae\xd3\xeb\xed\xac\x1b\xe9\x5c\x68\x63\x59\x4c\x4c\xda\x85\xcf\xec\x0a\x4f\x4d\x24\x27\x03\xc1\xfa\x16\x93\x5a\x67\x2b\xb7\xfa\xfd\x4b\xbb\x5b\xa0\xca\x5c\x65\x77\x68\xcb\x9c\xc5\xeb\x6c\x83\xcb\xf7\xef\x15\x3f\xfc\x75\xe5\xd0\xe6\x8e\x0a\x93\x71\xc9\x5a\xed\x6f\xa0\x69\xf7\xa1\xf1\xc9\x09\x62\xd7\x39\xcd\x36\xb5\xb5\xea\xc0\x6e\xf1\x83\x6f\x35\xcc\x7f\xdf\x50\x24\xcd\xfa\xd6\x90\x9b\x07\x03\x38\x2a\x00\x42\x4e\x07\x0f\xed\xc0\xfb\xba\xc0\xe9\x38\x61\x13\xf6\x5d\x57\xab\x3d\x95\x47\xf6\x97\xdb\x4d\x45\xbf\xc4\x60\xd7\xf2\x5a\x31\x62\x72\x3a\x92\xef\x76\xe3\xe4\x49\xf6\x23\xfc\x1a\x7f\xb7\xd1\xad\x13\x1f\xd4\x96\x15\xf3\x03\xd0\x67\x50\xb1\x1a\xf1\xe2\x0f\x1c\x63\x77\xd5\xe2\x9b\x4e\xb6\xa1\x80\x9b\x3b\xdb\x49\x2f\x7d\x49\xf6\x4b\x71\x50\x91\xe2\xfb\x17\x0a\x9b\xfd\x66\x17\x38\x03\x6e\x8f\xb2\x71\x50\x52\xb1\xca\x50\xd8\x26\x9d\x13\x1e\x96\x36\x42\xda\xcd\x0e\xab\xb2\xf3\x86\xfe\x61\x6a\x59\x06\x17\x4d\x2f\x1a\x9c\xee\x5f\x9c\xd9\x9f\x59\xdc\xff\x38\x68\x1e\x9f\x96\x9d\xfc\xa6\x25\x78\xfa\xa0\xf4\x6f\x28\x93\x19\x5a\x1c\xb3\x93\x4b\x8f\x14\xec\xb1\xc5\x2b\x2e\x6c\x22\x88\x56\xcd\xa0\xa6\x0b\x57\xec\x79\xfc\xf1\x3d\x8f\x8a\x9f\x02\xff\xe8\xc3\xbb\xf1\xf3\xb4\x34\xd3\xbe\x1b\x2e\x91\x37\xd7\x48\x1b\x6c\xfe\x7f\xd1\x77\x7c\xe9\xcc\xff\xb3\x7d\x87\x4b\xc5\xff\x2b\x7d\x0f\xfa\xed\xff\xd7\xfb\x7e\xe9\xa5\xff\x9b\x9e\xcf\xef\xbb\x5a\x9a\x97\xe5\xde\xcf\xf5\xdd\xe7\xf8\x5f\xf4\x3b\xb3\x3f\xf3\xaf\xf4\x7a\xd5\xf6\xed\xab\xfe\xc7\x3d\x36\xcd\xc5\x60\x72\x23\xaf\x74\x5a\xfd\x20\x5a\x89\x36\xa0\x2d\x28\x8e\x52\x68\x07\x3a\x17\x5d\x88\xf6\xa1\xeb\xd0\xad\xf2\x89\x17\x30\x7b\x56\xa0\x17\xc2\x72\x6c\xb9\x2a\xb3\x72\x90\x4a\xc8\xe1\x0c\x87\x7c\x4e\xac\x1c\x49\xcd\x28\xfb\x80\x42\xb3\xe5\xd9\x3c\x20\xd7\xd4\x1e\x5f\x7f\xfc\xfd\x5f\x82\x3f\x8b\xc7\x1d\x97\xb3\x37\x68\x34\x33\xfb\x34\x25\x9a\x35\x1a\x4d\xe3\xa9\xd6\xb6\xa5\xf1\x6d\xd7\x7d\x81\xe8\x42\x7a\xdb\x53\x4b\xb6\xfc\x74\x4d\xa3\xa6\x44\x53\x25\x3b\xea\x6e\x92\x32\xd9\x91\x77\xe6\x6e\xc5\x79\x57\xf6\x08\x46\xc7\x54\xce\xbf\x51\x7c\x6b\x7e\x41\xb9\x41\xde\x81\xbc\x69\x5e\xca\xf2\x9a\x12\xda\x0f\xcd\x1a\x4d\x89\xa6\xf1\xcc\xff\x8a\x2e\xb9\x6e\xdb\xe7\x88\x45\x74\x55\xbf\x66\xa9\xa7\xbc\xa7\x51\xa3\x11\xef\x91\xf0\x36\x9d\x90\x06\xa4\x26\xa6\xbf\xe4\xea\x5b\x27\xd4\xb8\x4f\xa8\x41\xe6\x79\x67\xf5\xd5\xa1\x26\x29\x62\xea\x00\x5a\x81\xce\x41\x7b\xd0\x65\xe8\x5a\x74\x0b\xba\x0b\xdd\x8f\xbe\x8b\x9e\x44\x3f\x94\x76\x3c\x1d\x0d\xb6\x2f\x6d\x54\x9f\x2b\xb9\x3b\x00\x1d\xe7\xed\xed\x56\x72\xc7\x71\x65\xf7\x49\x56\x97\xa7\x80\x12\x0f\xcf\x21\xbd\x56\x74\xf0\xc0\x35\x83\x7b\xbe\xda\xf8\x1c\xe8\x4b\xda\xf9\xb2\xf6\x8f\xaf\x9f\x2d\x73\xd3\xf2\xe1\x88\x5d\x3d\x33\xa8\xa7\xcb\xaa\xef\xd6\x5b\xa7\x71\xb7\xa5\xcc\x62\x29\x5b\x23\xa5\x5e\x29\xbd\x6a\x1e\x2c\xa7\xcc\x1a\x79\xb5\x6e\x31\x6c\xbd\x6e\x5b\x72\xb9\x77\xac\xde\xa1\xd5\x36\x68\xb5\xe2\x73\x52\xe6\xa8\x55\x97\xd5\xf9\x83\xcb\xd8\x77\x0d\x96\x23\xd3\x27\x60\xbf\xfc\x0f\x6b\x64\x6a\x70\xf0\xe0\x81\xc2\xb3\x94\xc2\x0e\x87\x23\x65\x76\x3a\xcd\x8f\x15\x0e\x1c\x84\x7f\xa3\xd7\x2c\xde\x79\xa9\xe5\x84\x9a\x99\xb9\xc7\x03\x3c\xbd\xed\xba\x95\x56\x43\xe5\xb1\x9d\xf3\xe6\x7d\x35\xcb\x82\x33\xd3\x16\x38\x78\x02\xee\x9a\x7f\x58\x23\xff\x2f\xad\x19\x81\x3e\xef\xb2\x22\xd2\xa3\x6e\x74\x2a\xda\x2e\xfb\x78\xf1\x5c\xa5\xbc\x94\xab\x04\x1b\xe2\x39\xe9\xac\x64\xfa\x9f\x25\x18\xc0\xb5\xbc\x81\x48\x2b\x36\xba\x86\x04\xa7\x83\xf3\x78\x01\x87\x43\x96\x50\x6d\x38\xc4\x38\x2c\x73\xdb\x2a\x6c\xf2\x59\x79\x1e\xb7\xb4\x61\xce\x2b\x3b\xe1\x4a\xfb\xc1\x78\x03\x48\xfe\xe0\x38\x1c\x72\x01\x79\xdf\x5c\x51\xe4\x10\x8f\x38\x8a\x2a\xcc\x70\x10\xbb\xc4\x4f\xde\x54\x19\x80\x27\x0c\x06\xd5\x6d\xcf\x3c\x2c\xbe\xf0\xdd\xb3\xdf\xbf\x7d\x18\xe0\x07\xb7\xf1\x98\x10\x50\x61\x30\xaa\xae\x79\x7f\x4a\xc5\xef\x78\x1a\xc8\xe5\x77\x42\xf3\xdb\xbb\x67\xde\xdf\xfd\xd8\xee\xdd\x8f\xc1\x1d\xe3\x9b\x55\x26\xcc\x39\x79\xcd\xa2\xde\xc2\x73\xdb\xf7\x1c\xd4\x6b\xfa\x7a\x34\x7c\x11\x8b\x4d\xaa\xe1\x71\x4c\xbe\xfa\xce\x05\x57\xfc\xfd\x4a\xd8\xb8\x21\xfd\xc6\xc8\xa6\x4d\x23\x6f\xa4\x4e\xbf\x17\xd0\x61\xf1\xec\x0d\x44\xa7\x6e\xb1\x54\x1a\xd5\x64\x35\xf8\xbe\xf7\x10\x34\xdd\xab\xe1\x93\xf7\xff\xf6\x9c\xef\x89\x3f\x5b\x45\xd4\xf6\x22\x75\xb3\x4e\xad\x63\x16\xfd\x27\xb4\xde\x73\x39\xb0\xcf\xec\x52\x6b\xb6\x1f\x12\xdf\xae\xa3\x34\x77\x7f\x81\x76\xbd\xb6\x84\x53\x69\x02\x0b\x34\x9a\xd0\x55\x6b\xd2\x8f\x45\x74\xc6\x1f\xec\x39\xeb\xde\xc5\x1a\x4d\x7d\x40\xad\xe2\x96\xbe\x75\xce\xee\xf7\x2f\xe6\xf8\x0b\xff\xac\x9c\x4d\x2e\xef\x2b\xb6\x22\x54\x27\x45\x73\x3f\x2e\xca\x32\x62\xd1\xe7\x88\x53\x3e\xf7\xc8\xcf\xcd\xd3\x04\xc1\xd6\xf9\xcf\x2b\x20\xb7\x03\xd3\xc8\x88\xd0\xf1\xcf\x6f\xfc\x31\xb8\xef\x4a\xaf\x33\x95\x17\x43\x64\xee\x7c\x07\x82\x74\xc8\x8d\x50\x3d\x98\xeb\xb1\xb9\xca\x2c\xbf\x97\x55\xa2\x70\x1d\xed\xce\x5c\x9f\x08\x9a\x41\x0c\xc2\x68\x06\x6d\xed\xdd\x42\xd0\x96\xde\x99\xfd\xb3\x2f\x02\xf0\x56\xf9\x90\x73\x8c\x08\xfa\x02\x6d\xe9\xc5\x88\xd6\x8b\x73\x01\xff\x61\xab\x4c\xfb\xe8\xd8\x6b\x90\x1f\xa1\xba\x70\x28\xd0\x0c\x52\xe2\xae\x36\x82\xc7\x2d\x7d\x8b\xac\x80\xb9\x28\x28\x4e\x87\xef\x78\xde\x30\x5f\xbf\x4a\xa3\xf9\xdd\xef\x34\x9a\xab\x34\x25\x34\x2f\xd1\x1c\x57\xc6\xb9\xf9\x43\x7f\xe3\xcb\x6e\x53\xca\x8c\x75\x3e\x4f\xc9\xbc\xfe\xc9\xef\x7d\xfe\xe5\x73\x71\x8f\xeb\xe5\xef\x28\x9d\x03\x07\x64\x3a\x07\x0e\xc8\x74\xe7\x95\x8f\xe8\x4f\x14\x31\x1c\x38\xf9\xbd\x73\x65\xf1\x25\x06\x6d\x3d\xf6\x99\x75\xd6\xc6\x4b\xba\xa4\x86\x2a\x38\x61\x59\xef\x05\xdf\x4c\x56\xfc\x29\xbb\xf5\x24\x6b\x78\x88\xe3\xc0\xcc\x4f\xe0\xd0\xc9\xd6\xeb\xbc\xd4\x36\x96\x7c\x3f\xac\xa8\x06\x79\x51\x1f\xfa\x01\x7a\x15\x21\x70\x1b\xc0\xe9\xe8\x04\x96\x93\xb7\xc6\xf9\x9c\x0e\x9b\x73\x8e\x45\x32\x63\x3c\xb3\xd7\x1c\xb6\x3a\xe9\x67\x2e\x45\xed\xe1\x0d\x60\x0d\x49\x9f\x00\xf9\x4e\xa8\x80\x90\xa7\x13\xa4\x38\x22\x21\xb7\xc7\x4d\xcd\x81\x0b\x9c\x5e\xf0\xb8\xc3\x6e\x4f\xb5\xe4\x5d\x45\x9f\x35\x39\x3e\x14\xe6\x5c\xe0\xa4\xd7\x8d\x40\x29\x3b\x39\x9e\xb3\x39\xc2\x9d\x10\xf6\x62\xbe\x93\xf1\x3b\x24\x3f\x19\x87\x7c\x9d\x75\x38\xdd\x1e\x03\xe3\x70\x3a\x42\x16\xc9\xc7\xd4\xe9\x08\x9f\x10\x7b\x84\xd5\x1a\x17\xe8\xb4\x86\x80\x49\xdc\xa4\x72\xf2\x2a\x15\xef\x54\xf1\xb7\xd6\xe8\x6a\xf4\x6e\x9d\x4e\xce\xa6\x68\x15\xaf\x72\x98\xe0\xd2\xea\xab\x43\x6e\x2f\xb3\x74\x45\xb7\x1b\x3b\x78\x2b\x67\x20\x2c\xe1\xbf\x4f\x9c\x95\xd5\xdc\x82\x8d\x03\xd6\x06\x9d\x0e\xd7\x72\x40\xc8\xc2\x36\x4e\xb3\x6d\xdd\xe2\x64\x99\x8b\xaf\xf5\x57\x34\x6d\x30\x94\x2d\x36\xe9\x7d\x1e\xab\x57\xaf\xd7\x6b\x9a\x5a\xf5\x18\xf3\x50\xe7\x2a\x76\xd4\x08\xd5\x55\x9b\x1e\x36\x81\xc6\x68\xb4\x2f\x6c\xa8\x3f\xd5\x8a\xd5\x95\x66\x67\x5b\x51\x85\x5d\x6f\x50\xf1\x0b\xb6\xb1\x50\xa6\xd7\x33\x2e\x47\x85\xd5\x88\xd5\x35\xd8\x51\xdc\x60\x35\xe8\xad\x4d\xcf\x3d\x52\xb1\x61\x47\x69\xf3\xf8\x58\x97\xe7\x6f\xfb\x0e\x8b\x0f\x8a\xd7\x88\x0f\x4a\x12\x5b\x01\x49\x58\x71\x98\xa9\x35\x9b\x17\x58\xcc\x6c\xed\xab\x2a\x95\xca\x41\x87\xe4\x58\x53\xa3\xd7\xbb\xf5\xd5\xfa\x1a\x9d\xce\xa3\xab\xd9\x41\xeb\x55\x2a\x93\x63\x53\xf7\x42\x77\xd9\x8a\x91\x0d\x36\x57\x2d\xb6\x73\x76\x8d\xdd\xe8\xb0\x15\x89\x16\x5b\xb9\xc1\xa6\x59\x12\x36\xe9\xb5\x00\x4d\x4d\xb6\x7a\x8d\xa6\x68\x8d\x6f\xdd\x1e\x0d\xef\x6f\xf5\xc7\x96\x86\x8c\x4c\x77\x5b\x32\x6b\xd7\x5a\x8b\x4a\x00\x7c\x65\x76\xa3\xa3\x9c\x21\x65\xc3\x97\x06\x0d\x0e\xd3\x44\xb3\xb7\xfa\x91\x25\x26\xad\xce\x52\xbc\xc8\x61\xb6\x76\xb8\x30\xa7\x06\xd6\xc8\xf2\xc0\xd7\xd7\x05\xe3\x2d\xa3\xf9\xf2\x06\x8e\xe3\x7d\xf5\x5d\xa7\xf4\xf5\xba\x42\x25\x45\xae\x90\xbb\xb1\x52\x5b\xfc\x1d\x50\x6f\x0d\x9c\xd7\xb6\x79\xfd\x5a\x82\x61\xea\xa4\x7b\xd0\x61\xee\x3d\xec\x12\x84\xc0\xec\x90\xf6\x97\x77\x81\x9f\x58\x6b\x24\x8f\x44\xe5\x25\x54\x27\xd3\x05\x7e\x0e\xf3\x5e\xf0\xd4\x54\xb1\x41\x2a\x77\xab\xc5\xe3\x85\x66\x08\xb2\x55\xbe\x30\x55\x0c\x7a\x7f\x4d\x55\x35\x87\xb9\xd1\x07\xea\xea\xfa\x9b\xcc\x55\xa3\x06\x7e\xb4\xdc\xb8\x38\x74\xba\xf8\xdf\xa7\x6f\x02\xa1\xa6\xb5\xa3\xd9\xd7\x60\xd9\x7c\x06\xe7\x67\xaf\xfa\x43\x53\xe3\xcc\xd7\xc4\x8b\xce\xeb\x6b\x05\x15\xd1\xe2\xe6\xfe\xf3\x60\x27\x7e\xea\xd2\x3f\x70\x26\x86\xdd\x5c\x59\xb1\x61\x70\xe6\x17\x65\x46\xf6\xb4\x99\xed\xc0\x12\x82\x9b\x4e\xdd\x27\x3e\x25\x3e\x73\x5e\xbf\x0f\x54\x33\xaf\xae\x5c\xc6\x68\x8b\x3d\x9d\x0d\x6f\xd6\x89\x6b\x3a\x58\x0e\x74\xf1\x62\x7d\x4b\x18\xef\x86\xab\x3e\xee\xf0\xea\x8b\xe2\xba\xd2\xfe\x99\xcd\x67\x9d\x3d\x55\x30\x2b\xdf\x43\x24\x1f\x17\x33\x6a\x44\x2d\xa8\x13\xad\x55\xde\xdc\xd9\x6d\x0e\x03\x53\x63\xf6\xb9\x48\x19\xb0\xb4\x80\x25\x87\xeb\xc5\x84\x2e\xb1\xa5\x4a\xbf\xb9\x06\xfc\xe6\x1a\xde\xed\xa9\x31\xfb\xcd\x56\xbf\x95\x0d\x78\xbc\x6c\x75\x4d\xf5\x42\x30\xfb\xfc\x8e\x90\xc7\xcd\x06\xe5\xfd\x1c\xc1\x1a\xb3\x3f\x7c\xd2\xfd\x2a\x37\x02\x60\x56\x65\x50\xab\x0d\x2a\x16\xc3\x62\x00\x46\xab\x52\xb3\x0c\x61\x38\x96\x53\xb1\x04\x3e\x7f\x67\xd7\x2e\xf8\xce\xb6\xdb\xca\x6c\xba\x5b\xc7\x9b\x96\x2f\x84\x03\x2c\x31\x59\x2a\xed\xf5\x66\xbb\x8a\x39\xd3\x56\x7b\xa0\x8d\x00\x74\x30\xc6\xea\x72\x6f\x45\x21\xc5\xbb\x9a\x7d\x95\x0f\xcd\xff\x24\x87\x7f\xf5\x30\xe3\x50\x99\x78\x15\x81\x20\x56\x11\x13\xeb\x88\x4e\x81\x53\x65\xe4\xd4\x9a\x9b\xb0\x86\xd7\x72\x2a\x42\x38\x4e\xcb\x1a\x3e\x84\x37\xc5\x05\xf0\xe6\x2f\xaf\x39\x4d\x5c\x00\x6d\xe2\x0b\xd0\x65\xe8\x73\x9a\x8a\x4d\x3a\x96\x88\x0b\xc0\x7f\x53\xe7\x6d\x7b\xca\x2b\x6b\x8c\xd5\x37\x8a\x0b\x5c\xb5\x1d\xc4\x72\xdc\xb7\x0e\x16\xb5\x7c\x81\x55\xcb\xd8\xbf\x23\x1d\xb2\xa3\x12\xb4\x16\x5d\x8e\x10\xeb\xf6\x48\xa7\x96\x39\x10\x35\x2b\xcd\xc0\xf1\x0e\x2b\xb5\x26\x10\xc0\xd2\x49\x8f\x3c\xc7\x77\x92\x0a\x70\x11\xde\x6d\xc0\xbc\x0b\x3b\x1d\x9d\xb8\x4b\x8e\x44\xc0\x73\x2c\xe7\x71\x11\x29\x04\xa1\xc5\xca\xf1\x1c\x96\x36\xba\x73\x35\x95\x88\x54\xbb\x6b\x38\x17\xae\x00\x87\xd3\x4b\x9a\xc1\xcb\x79\x5c\xd8\xa9\x2c\x8c\xa8\x29\xab\x65\x9c\x0e\x0b\x33\xc9\xb1\x7a\xef\xb9\xe3\x85\x0a\xf3\xad\xbd\xb0\x46\xdc\x7c\x6f\x71\x25\x61\xd6\xd5\xb1\xbb\x16\x56\x37\xba\xd8\xfd\x67\xbf\x22\xbe\x73\xdb\xd5\xe2\x27\xdb\x5c\xc6\xc5\x77\x7f\x7d\x6f\xfd\x82\xaa\x05\x6a\x86\x9c\xfb\xe3\x3b\x76\x0d\x32\xc6\xb6\xea\xaf\x7c\xfa\xd0\x95\x75\x75\x8e\x9a\x12\xc6\x10\x3c\x24\xce\xec\x7d\xb8\xfe\x92\x8b\xce\xf1\x78\x2e\xdf\xf9\xfd\x0f\x97\x1a\x4a\x06\xff\xf3\x67\x2d\xd5\xa7\x9e\x59\x5b\x27\xfe\x5a\x1c\x58\x0a\x1c\xe6\xcc\x35\x75\x7a\x83\xca\xbb\x64\xdc\x57\x4e\x30\xdb\xbe\xa0\xb7\xd5\x5f\xad\xb2\x76\xdd\xd1\x8d\xb5\x6b\xeb\xf7\x96\x05\x8d\xd5\x95\xb7\x42\x0d\xb4\x5f\xf7\x8b\xf7\x7f\x08\x44\xe5\x8a\x4d\xdc\x77\x3a\xa9\x7e\x4d\x7c\x1d\x9f\x52\xb6\xfc\x91\x50\x70\xcd\xbe\x1e\xdc\xd2\xbd\xce\xeb\x10\x6f\xbd\x1d\x6a\x5f\x3d\x27\xb1\x75\x51\xdc\xdf\x63\xe7\x18\x02\xe5\x75\x75\x1a\xad\xbd\x77\xc5\xe2\xda\xed\x1f\x2f\xe2\xea\x7b\xfb\x8b\x8b\x4c\x6a\x6b\x71\xa4\x28\x52\x67\x63\xb6\xde\xbe\xb9\x47\xab\x73\xba\xa3\x70\x36\xa8\xf7\xae\x38\x24\xfe\x21\x57\xa5\x2d\xd1\x10\xd8\x04\x7a\xf0\x9d\x93\x38\xb3\xa4\x44\x37\xe8\xbe\xf8\xf2\xdd\x0d\x0d\xd8\x6e\x2c\x29\x2a\x2d\xd5\x69\x2a\x16\xab\x2a\xaf\xbd\xec\xc5\x3b\x72\xd1\xb2\x6a\xe3\xd2\xc5\xee\x95\x39\x71\x10\xb1\xa8\xee\x0b\x1d\xf7\x26\xfb\x09\x72\xa2\x16\xd4\x8d\x4e\x97\x4e\x9c\x0a\xb9\x3d\x4a\x68\x34\x17\x76\xba\xf8\x10\x18\x30\x53\x4b\x57\x99\x9d\x24\xcc\x95\x80\x0e\x6a\xc3\x21\xde\x86\x6d\xd2\x19\x42\xd2\x07\x19\x60\xbd\xd0\x08\x3a\xe0\xb0\xd3\x8d\x3b\x19\x29\xbe\x3c\x09\x21\x4f\xb5\xc7\x1d\x76\x31\x06\xc2\x77\x12\xb6\xa3\x7c\xc9\x86\x45\x7b\x05\x8b\xce\x58\xe3\xac\x58\x54\x5a\xdb\xb5\xb0\xae\xc8\xa6\xd7\x6a\x60\x7b\xe0\x99\x3f\x8a\x7f\x11\x3f\x3b\xfc\xd0\x28\x0b\x46\x8d\x9b\xf1\x8f\xfd\x05\xd6\xc1\x56\xd8\x94\xb7\xe1\x8f\x57\x5f\xf4\xc4\xa1\x27\x2e\x5a\x2d\x67\x90\xe9\xf9\xad\xf8\x27\xf1\xc7\xe2\xdb\xa2\xf8\xf0\x90\xab\x95\x5d\xbe\xef\xc9\xf7\x3e\xfa\xdb\xfb\x3f\x5d\x56\xb5\x68\xb1\x4e\x7c\xe3\xef\x2a\x8c\x4b\xce\x79\xf9\xa2\xad\x76\x67\xec\xca\xf7\x2e\x4a\x3e\x7e\xfb\x08\x3e\xdc\x78\x5f\xbb\xa7\xdc\x56\xea\xd4\xb0\x84\x31\x6a\xf4\x75\x75\x0b\x6a\xab\x8a\xf4\x30\xf3\xe3\xf3\x1e\x8b\x14\xf9\x77\x1f\x04\xe7\x9d\xf5\xa7\xd7\xef\xd4\x1f\x12\x2f\x14\xc5\x1b\x75\xb7\xdf\x59\xaa\x67\x70\xc5\xa1\xa7\x2e\x59\xbd\xfa\x92\xa7\xe4\x8c\xbb\xfa\x50\x54\xb5\xfa\x81\xbf\x89\x77\x3e\x7f\x3b\x34\x7d\xf2\xf2\xd7\x85\x7a\xe7\xfa\x3b\x73\xbe\x7d\xe2\xf9\x9f\xc0\xc6\x7e\x96\x25\xcc\x59\xd7\x3c\xf9\xf3\x9f\x3d\x71\xd5\x19\xd8\x15\xbb\xea\x67\xb2\x3f\x89\x64\x63\xa4\xef\x80\x15\xa8\x19\x75\x49\x3e\xdd\x69\x74\x1e\xba\x1c\xdd\x86\xbe\x8d\x90\xd5\x5e\x53\xdd\x01\xf4\x2f\x70\x0a\x04\x03\xfe\xff\xd3\xf2\xf1\x6b\x21\xb0\xdb\x16\x4a\x7f\x41\xbf\xaf\x1c\xfc\xbe\xe0\xff\x61\xf9\x60\xc6\xd4\x62\x32\xb5\x98\x32\xff\x24\x67\xfe\xbd\x6d\xc1\x91\x83\x0b\xda\xda\x16\x90\xee\x05\x6d\x80\xfe\x05\x14\x29\x07\x34\x6d\x32\x99\x2a\x4d\xa6\x7f\x19\xda\xff\x59\x37\x25\xc3\x52\x62\x9f\xab\x68\xcd\xb4\xc9\x74\xf8\x9f\xe4\xb2\x0f\x61\xf3\x17\x88\x5b\xcd\x21\x74\x05\x5d\x6b\xca\xfb\x70\x9b\xe9\xd3\x94\xdb\x43\xea\xcc\x4e\x17\x18\xc0\xdd\x0c\xd2\xbe\x93\x0e\x7a\x4d\x3a\x62\xc5\xcc\x12\x03\x7d\x84\x9e\x75\xf5\x93\xe2\xa7\x38\xd9\x26\x60\xa5\x5d\x07\xb3\x35\x15\xe0\x71\x87\x1c\x4e\x2b\x6b\x96\x03\xac\x28\xa1\x8b\xcb\x21\xdc\x09\x2e\xe0\x8c\x60\xae\xb3\x76\x82\xc3\x08\xf2\xee\x5e\x23\x48\xe4\x6a\xaa\x3d\x75\x7a\xa8\x0b\xb9\x80\xe3\x5c\xf7\x3c\xe6\xd4\xeb\x0d\x3e\xe7\x63\x61\xbd\x6f\x89\x3e\x2e\xfe\xf9\x90\x09\x17\x55\xd5\x9b\x32\xee\x80\x3b\x63\xaa\xaf\x2a\xc2\xa6\x43\xe2\x9f\xe3\xfa\x25\x3e\x7d\xf8\x31\xa7\xcf\xa0\xd7\x3b\x1f\xbb\xa7\xbc\x44\xdd\x50\x0e\x21\x29\x30\xe4\x8b\x8c\xba\xb4\x9a\x29\x29\xa5\x0d\x95\x04\x1c\x4a\x3b\x60\x3c\x49\x3b\x60\x3c\xae\x9d\xd2\x12\xa6\xba\x54\xcd\x88\x2f\x4a\x31\x2d\x43\xe5\x0d\xea\x12\xb8\xa3\x6a\x5c\xef\x77\x3a\xf5\xfa\x6d\xfb\xdd\x7e\x4d\x1d\x34\xde\x2c\x3e\xff\xa1\xa5\xa1\xc2\xaa\xb2\x4c\xbf\x5e\xe2\x76\x97\xbc\x3e\x6d\x51\x59\x2b\x1a\x2c\x1f\x42\xfb\xcd\xe2\xab\x75\x1a\xbf\x7b\xff\x36\xbd\xde\xe9\xf4\xeb\xc7\xab\x38\x6f\x73\x15\xd7\x79\xcb\x2d\x9d\x50\xdb\xd8\xc0\xd2\x96\xbc\x06\x83\xdc\x90\xf8\xea\xcd\xd0\x7e\xf2\x86\xc4\xe7\x6f\x86\xc6\x63\x1b\x62\x1b\x1a\x6b\x81\x36\xc4\x55\x35\x7b\xd1\x31\x3e\x7e\x16\xfa\x44\x05\x74\x91\x4b\x27\x15\x8e\xce\x2a\xb5\x16\x35\x38\x2c\x3c\x87\x19\x9e\x05\x37\x7d\x46\xae\x0d\x87\x6a\xd9\x67\xf8\xa1\xab\x0e\x15\xf2\x6f\xdf\x95\xe0\xf9\xa1\xab\x7e\x5e\xb8\x09\x6c\xdf\x82\x25\xe2\x1d\x3b\xa7\x34\xda\x87\xc5\x57\x1f\x3e\x52\x0c\x67\x4a\x30\x34\x3d\x7c\x0f\xbe\x11\x0f\xef\xf8\x8f\xdb\x05\x9e\x5f\x79\xf9\xcf\x0a\x12\xa4\xbe\x08\x7d\xc1\x74\x88\x77\x16\xc4\x17\xef\x7e\x44\x7c\xe1\xf9\xe2\xaf\xc2\x99\x79\x08\xdf\xfd\x3d\x68\x7b\xbe\xd8\xb1\x51\x7e\xff\xa8\xc4\xff\x33\x20\x0b\x72\x20\xb7\xe4\x71\x6e\xad\xd1\x42\x8d\xd5\x13\x76\xf2\xc0\x92\x26\x70\xf2\x9e\x3a\x27\xef\x61\xfe\x59\xb8\xbe\x87\xee\xf0\x7f\xfb\xbe\xd6\x07\x57\xda\x0f\xdb\xc5\x01\x68\xb9\x40\x3c\x04\x6f\x1d\x1e\xfd\x08\xce\x7b\x7a\xcd\x53\xb8\x83\x4e\x68\xe2\xb3\xe2\x3b\xaf\x9c\x7d\xf6\x2b\x50\x0d\x9d\x50\xfd\xca\x1f\x4f\xf6\xbc\x71\x44\x7c\x04\xb6\x88\xdf\x80\x1d\x55\xad\x71\x1f\x4e\x5c\x20\x1e\xba\x60\x72\xf4\xa3\xf8\xa6\xd5\x4f\xad\xde\x22\x61\x9d\x3d\xbf\x25\x3c\x79\x92\x55\xa1\x0e\xb9\xbf\x00\x7e\x13\xfb\x05\xda\x88\x46\x50\x12\x4d\xa2\xf3\xd1\x7d\xe8\x11\xf4\x2c\x7a\x09\xbd\x89\x3e\x40\x1f\x22\x04\x5e\xe2\x71\x77\x82\x47\x0e\x29\x4c\xaa\xbd\xe0\xf1\x72\xd2\x23\x06\x91\xcf\xbb\xe2\x0d\xc4\xce\x49\x8f\x10\xd2\x53\x82\xd3\x21\xbf\x95\x08\x49\x2f\x23\x9c\x3e\x69\xbe\xa7\xb3\x4e\x88\x71\xc8\xaf\x2f\x3a\x01\x1c\x06\x90\x00\x07\x52\xde\x5b\x80\xd3\x41\x2b\xbd\x10\x0a\x87\x1c\x56\x07\xe6\x39\x0f\xbd\x45\x79\xdf\xe1\xc5\xa1\x30\xfd\xd9\x49\xf1\x4a\x43\x2e\xc2\xbb\x30\x07\x4a\x6b\x32\x82\xd4\x9e\x14\xd6\x88\x56\xcb\xcd\xc0\x1c\x3d\xc7\xfc\x9b\x3d\xf2\x1d\x9d\xe0\x60\x43\x4c\x73\xa0\x89\xb0\xcb\x97\xb2\x86\xd1\x26\x17\x61\x30\x4f\x78\x96\x27\x44\xc7\x69\x55\x5a\x2d\xe7\xaa\x2d\x05\x93\xda\xae\xd3\x86\x5c\xf5\xdb\x9c\x26\x5f\xdd\x42\xc7\xea\x41\x57\xbd\x85\xbf\x82\xe5\x2a\x0c\xa5\x1c\x1e\x01\xce\x3f\x68\x63\xd6\x0e\x71\x36\x7b\x39\x83\xcf\xe3\x75\xbe\x56\x73\xff\x32\xdf\x91\x1e\xce\x64\x34\x14\x13\x62\x2a\xc3\xa7\xeb\xf8\xea\x7a\x9d\x96\xaf\xae\x9f\xb1\xd7\x76\x95\x94\xe8\x2c\x96\xae\x92\x12\x96\xb1\xea\xda\x7a\xdc\xba\xd2\xb2\x9e\xaf\x0e\x04\x93\x9b\x26\x6c\xe7\xdf\xda\xa1\x83\xd1\x4f\x96\xf8\xc8\xda\xc9\x06\x77\x67\x2d\x13\xdc\xd6\x5f\x79\xe1\x6d\x0f\x2c\x39\xf5\xa2\xa9\x8d\xcd\x5c\x60\xd0\x5e\xf9\x79\xd6\xa0\xb6\x59\x5b\xf5\x52\xfa\x2d\xc6\x52\x5d\xc6\x10\xab\xc9\x5c\xc6\xdc\xc5\xd8\x6d\xd6\x6a\x95\xdd\x66\xab\x9a\x49\x9a\x8c\x65\xa5\x1d\x26\x93\x31\xd4\x89\x3f\x63\x4c\x46\x23\xed\x86\xd1\x50\xfc\x84\x51\xed\x70\x84\x5c\x9a\xc6\x20\x78\x8b\x6c\x50\x54\xd2\xfc\xe8\x03\x1e\x01\x83\x19\x63\x20\x40\x18\x82\xf5\xac\x86\xe5\x08\xb0\x26\x27\x18\x79\x3d\xc6\xa5\x7a\x8b\xb7\xa1\xec\xb2\xb3\xaf\x80\x81\x18\x83\x4b\xaa\xf4\x50\x50\x69\x0d\xbc\xd1\x6d\xf9\x58\xeb\xae\x73\xba\x55\xf7\xde\xa6\x2e\x07\xb7\x49\xfc\xb4\x2c\x18\x2b\x52\xeb\x49\xc5\xbd\x2e\x99\x58\x09\x27\xbe\x65\xae\x2f\x52\x99\x69\x42\x42\x21\x9d\xd5\xd2\x5d\x52\xaa\xb3\x58\x67\xa0\xac\xcf\xad\x6b\xeb\xb5\x59\x75\xb8\x7b\xbb\xf8\xe9\xf2\x2e\x32\xb4\x85\x0d\xab\x61\x49\xd3\xd8\x69\x67\x1a\xb6\x5f\x7e\xfb\xa2\xc5\x17\x65\xd7\xaa\xd7\x9f\xdb\xee\x0c\xdb\xf9\x9e\xe1\xbd\xa7\x99\xd6\x6c\x1d\xc5\x19\x5b\xab\xc1\xa0\xb6\x49\x29\xb0\xa6\x72\x95\xd5\x6c\x2e\x63\x18\xeb\x91\x53\x6c\xd5\x0c\x63\x5f\x50\xcd\x32\x4e\xb2\xad\xb4\xcb\x64\x32\x96\x96\x75\x56\x9b\x66\xd6\x19\x8b\x19\x62\x36\x18\x4b\x08\x31\xbd\xef\x08\x99\x8c\x9a\xc6\x50\xa5\x06\x21\x54\x04\x6e\xf9\xc4\x69\x84\x50\x33\xda\xaa\xc0\x80\xb4\xe8\x5e\x05\xc6\x88\x47\x3f\x50\x60\x82\xcc\xe8\xb0\x02\x33\x48\x0b\x25\x0a\xcc\x22\x0b\x2c\x57\x60\x0e\x69\x61\x52\x81\x79\xb4\x1a\x7b\x14\x58\x85\x74\xf8\x6a\x05\x56\x23\x0d\x7e\x58\x81\xb5\xc8\x8e\xff\xa4\xc0\x06\xe4\x22\x3d\x88\x20\x60\xd4\x08\x21\xf9\x8d\x12\x85\x01\x39\xd0\x15\x0a\x8c\x91\x01\x3d\xa4\xc0\x04\x55\xa3\x9f\x28\x30\x83\x1c\x80\x15\x98\x45\xb5\xe0\x56\x60\x0e\x39\x60\x58\x81\x79\xf4\x0d\xd8\xad\xc0\x2a\x54\x84\xa7\x14\x58\x8d\x6c\x78\xbf\x02\x6b\x51\x03\x7e\x46\x81\x0d\x68\x31\x21\xa8\x0f\xa5\x51\x06\x4d\xa1\x2c\x4a\xa0\x51\x34\x86\xf2\xa8\x12\xf5\xa3\x08\xda\x81\x04\x54\x89\x96\xa0\x08\x4a\xa1\x18\x9a\x42\x95\xc8\x87\x5a\x50\x2b\x0a\x21\x2f\xaa\x44\x3d\x28\x89\x92\xa8\x72\x1e\x56\x4e\x2a\x09\x28\x87\x04\x94\x95\xb0\x63\xc8\x8b\x50\x5f\x3a\x33\x95\x4d\x8c\x8e\xe5\x2b\xfb\x23\x3b\x84\xca\x25\x91\x54\x6c\xaa\xd2\xd7\xd2\x1a\xf2\x56\xf6\x24\x93\x95\xd2\xa5\x5c\x65\x56\xc8\x09\xd9\x1d\x42\xcc\x8b\xd0\x20\x4a\xa3\x14\xca\xa3\x1e\x34\x29\xb5\x96\x46\x13\x48\x40\x68\x30\x9d\xca\xf7\x4c\x0a\xb9\xf4\x84\x80\xd0\x1a\x24\xa0\x51\x54\x40\x49\x14\x41\x59\x84\xd6\x08\xa3\x85\x64\x24\x4b\x71\x57\xa1\x95\x68\x1d\x5a\x8e\x7a\x50\x2f\x5a\x84\x56\xa1\x75\x68\x10\x0d\xa0\x8d\x68\x08\xad\x42\x6b\xd0\x3a\x84\x06\x57\xad\x5c\xb7\xbc\xa7\x77\xd1\xaa\x75\x83\x03\x1b\x87\x56\xad\x59\xf7\xaf\x51\xdc\x20\x8d\x2a\x87\x12\xd2\xbd\x95\x28\x80\xbc\x28\x8c\xbc\xa8\x65\x1e\x5f\xd0\x06\x21\x9b\x4b\xa4\x53\x95\x01\x6f\xd8\xdb\x22\x0d\xf2\x5f\x6b\x7c\x08\x25\x91\x80\x22\x12\xeb\x64\x26\xc6\x25\x72\x95\x28\x8f\xd2\x52\x3a\x26\x5d\x39\x99\xa8\x28\x4e\x14\xe5\xe7\x3a\x16\x47\x69\x05\x53\xc6\x89\x2b\xf4\x69\x4d\x16\x45\x50\x0c\x09\x68\x42\x62\xdb\x38\xaa\x44\x11\x94\x97\xea\x13\x68\x04\x15\xe6\xb5\x92\x42\x69\xa9\x14\x95\xfa\xec\x45\x68\x28\x29\x44\x72\x42\x65\x56\x88\x0b\xd9\xca\x7c\xba\x32\x3f\x26\x54\x1e\x15\x6d\x4e\x88\xe6\xe9\xc0\xe3\xe9\xac\x74\x25\x9e\x4e\xe5\x2b\xf3\xd9\x48\x4c\x98\x88\x64\xc7\x2b\x23\xf9\x7c\x36\x31\x52\x90\x6e\x49\xa5\xf3\x89\xa8\x90\x53\x04\x9d\x95\x7a\x76\x02\x6f\xb2\xf9\xca\x39\xe6\x9c\x4c\x17\xd1\x51\x5d\x42\x12\x1f\xf2\x28\x83\x16\xa1\x66\xd4\x3c\x37\xde\xc8\x31\x6d\x7a\xa5\x91\xa1\xb1\x7c\x3e\xb3\xa8\xb9\x99\x76\x2f\x22\xb7\xef\x4d\xa4\xff\x27\x2d\x34\xa3\xa4\xc2\x95\x94\xc4\xf9\xe6\x2f\x69\xb3\x39\x99\x88\x0a\xa9\x9c\xd0\xac\xac\x71\xfe\xd1\x3f\xfc\x7d\xc9\x26\xd1\x5f\xf7\x3e\x74\x29\xba\x04\x5d\x86\xae\x40\x57\xa2\xaf\xa1\xab\xd0\xe5\x40\xcd\x35\x03\x2c\x70\xc0\x83\x0a\xd4\xa0\x01\x2d\xe8\x40\x0f\x06\x30\x82\x09\xcc\x60\x01\x2b\xd8\xc0\x0e\x0e\x70\x42\x11\x14\x43\x09\x94\x42\x19\x94\x83\x0b\x2a\xa0\x12\xaa\xa0\x1a\x6a\xa0\x16\xea\xc0\x0d\x1e\x58\x00\xf5\xd0\x00\x0b\xa1\x11\x9a\x80\x3e\xd6\xb7\x40\x2b\xf8\xc0\x0f\x01\x08\x42\x08\xc2\xd0\x06\xed\xb0\x08\x4e\x81\xc5\xd0\x21\xbd\x2c\xea\x86\x1e\xe8\x85\x3e\xe8\x87\x01\x18\x84\x25\x70\x2a\x9c\x06\x4b\x61\x19\x2c\x87\x15\xb0\x12\x56\xc1\x10\xac\x86\x35\xb0\x16\xd6\xc1\x7a\xd8\x00\xa7\xc3\x46\x38\x03\x36\xc1\x99\x70\x16\x6c\x86\x2d\x30\x0c\x5b\x21\x02\x23\xc8\x80\x3e\x42\x7a\x88\x42\x0c\x04\x88\xc3\x28\x8c\x41\x02\xb6\xc1\x38\x24\x61\x02\x52\x90\x86\x0c\x6c\x87\x2c\xe4\x20\x0f\x05\xd8\x01\x93\xb0\x13\xa6\x60\x17\x7c\x05\xce\x86\x73\xe0\x5c\x38\x0f\xa6\xe1\x7c\xb8\x00\x76\xc3\x57\x61\x0f\x5c\x08\x7b\xe1\x22\xb8\x18\x2e\x81\x4b\xe1\x6b\x70\x19\xec\x83\xcb\xe1\x0a\xb8\x12\xae\x82\xab\xe1\x1a\xb8\x16\xae\x83\xaf\xc3\xf5\x70\x03\xdc\x08\x37\xc1\xcd\x70\x0b\xdc\x0a\xb7\xc1\x7e\xb8\x1d\xbe\x01\x77\xc0\x9d\x70\x17\xdc\x0d\xf7\xc0\xbd\x70\x00\xbe\x09\xf7\xc1\xb7\xe0\x7e\xf8\x37\xf8\x36\xfc\x3b\x3c\x00\xdf\x81\x07\xe1\x21\xf8\x2e\x3c\x0c\x8f\xc0\xf7\xe0\x51\x78\x0c\x1e\x87\x27\xe0\x49\x78\x0a\x9e\x86\x83\xf0\x0c\x3c\x0b\xdf\x87\x1f\xc0\x0f\xe1\x39\x78\x1e\x5e\x80\x1f\xc1\x8b\xf0\x63\xf8\x09\xbc\x04\x3f\x85\x9f\xc1\x21\xf8\x39\xbc\x0c\xaf\xc0\xab\xf0\x1a\xbc\x0e\x6f\xc0\x9b\xf0\x1f\xf0\x16\xbc\x0d\xbf\x80\x5f\xc2\x3b\xf0\x9f\xf0\x2e\xbc\x07\xef\xc3\xaf\xe0\x03\xf8\x35\xfc\x06\x7e\x0b\xff\x05\xbf\x83\xdf\xc3\x1f\xe0\x8f\xf0\x27\xf8\x10\x3e\x82\xc3\xf0\x67\xf8\x0b\x7c\x0c\x9f\xc0\x5f\xe1\x6f\xf0\xdf\xf0\x77\xf8\x14\x3e\x83\xcf\xe1\x08\xcc\x80\x08\x5f\x60\x84\x01\x63\x4c\x30\x83\x59\xcc\x61\x1e\xab\x50\x35\x56\x63\x0d\xd6\x62\x1d\xd6\x63\x03\x36\x62\x13\x36\x63\x0b\xb6\x62\x1b\xb6\x63\x07\x76\xe2\x22\x5c\x8c\x4b\x70\x29\x2e\xc3\xe5\xd8\x85\x2b\x70\x25\xae\xc2\xd5\xb8\x06\xd7\xe2\x3a\xec\xc6\x1e\xbc\x00\xd7\xe3\x06\xbc\x10\x37\xe2\x26\xec\xc5\xcd\xb8\x05\xb7\x62\x1f\xf6\xe3\x00\x0e\xe2\x10\x0e\xe3\x36\xdc\x8e\x17\xe1\x53\xf0\x62\xdc\x81\x3b\x71\x17\xee\xc6\x3d\xb8\x17\xf7\xe1\x7e\x3c\x80\x07\xf1\x12\x7c\x2a\x3e\x0d\x2f\xc5\xcb\xf0\x72\xbc\x02\xaf\xc4\xab\xf0\x10\x5e\x8d\xd7\xe0\xb5\xe8\x65\xbc\x0e\xaf\xc7\x1b\xf0\xe9\x78\x23\x3e\x03\x6f\xc2\x67\xe2\xb3\xf0\x66\xbc\x05\x0f\xe3\xad\x38\x82\x47\x70\x14\xc7\xb0\x80\xe3\x78\x14\x8f\xe1\x04\xde\x86\xc7\x71\x12\x4f\xe0\x14\x4e\xe3\x0c\xde\x8e\xb3\x38\x87\xf3\xb8\x80\x77\xe0\x49\xbc\x13\x4f\xe1\x5d\xf8\x2b\xf8\x6c\x7c\x0e\x3e\x17\x9f\x87\xa7\xf1\xf9\xf8\x02\xbc\x1b\x7f\x15\xef\xc1\x17\xe2\xbd\xf8\x22\x7c\x31\xbe\x04\x5f\x8a\xbf\x86\x2f\xc3\xfb\xf0\xe5\xf8\x0a\x7c\x25\xbe\x0a\x5f\x8d\xaf\xc1\xd7\xe2\xeb\xf0\xd7\xf1\xf5\xf8\x06\x7c\x23\xbe\x09\xdf\x8c\x6f\xc1\xb7\xe2\xdb\xf0\x7e\x7c\x3b\xfe\x06\xbe\x03\xdf\x89\xef\xc2\x77\xe3\x7b\xf0\xbd\xf8\x00\xfe\x26\xbe\x0f\x7f\x0b\xdf\x8f\xff\x0d\x7f\x1b\xff\x3b\x7e\x00\x7f\x07\x3f\x88\x1f\xc2\xdf\xc5\x0f\xe3\x47\xf0\xf7\xf0\xa3\xf8\x31\xfc\x38\x7e\x02\x3f\x89\x9f\xc2\x4f\xe3\x83\xf8\x19\xfc\x2c\xfe\x3e\xfe\x01\xfe\x21\x7e\x0e\x3f\x8f\x5f\xc0\x3f\xc2\x2f\xe2\x1f\xe3\x9f\xe0\x97\xf0\x4f\xf1\xcf\xf0\x21\xfc\x73\xfc\x32\x7e\x05\xbf\x8a\x5f\xc3\xaf\xe3\x37\xf0\x9b\xf8\x3f\xf0\x5b\xf8\x6d\xfc\x0b\xfc\x4b\xfc\x0e\xfe\x4f\xfc\x2e\x7e\x0f\xbf\x8f\x7f\x85\x3f\xc0\xbf\xc6\xbf\xc1\xbf\xc5\xff\x85\x7f\x87\x7f\x8f\xff\x80\xff\x88\xff\x84\x3f\xc4\x1f\xe1\xc3\xf8\xcf\xf8\x2f\xf8\x63\xfc\x09\xfe\x2b\xfe\x1b\xfe\x6f\xfc\x77\xfc\x29\xfe\x0c\x7f\x8e\x8f\xe0\x19\x2c\xe2\x2f\x08\x22\x40\x30\x21\x84\x21\x2c\xe1\x08\x4f\x54\x44\x4d\x34\x44\x4b\x74\x44\x4f\x0c\xc4\x48\x4c\xc4\x4c\x2c\xc4\x4a\x6c\xc4\x4e\x1c\xc4\x49\x8a\x48\x31\x29\x21\xa5\xa4\x8c\x94\x13\x17\xa9\x20\x95\xa4\x8a\x54\x93\x1a\x52\x4b\xea\x88\x9b\x78\xc8\x02\x52\x4f\x1a\xc8\x42\xd2\x48\x9a\x88\x97\x34\x93\x16\xd2\x4a\x7c\xc4\x4f\x02\x24\x48\x42\x24\x4c\xda\x48\x3b\x59\x44\x4e\x21\x8b\x49\x07\xe9\x24\x5d\xa4\x9b\xf4\x90\x5e\xd2\x47\xfa\xc9\x00\x19\x24\x4b\xc8\xa9\xe4\x34\xb2\x94\x2c\x23\xcb\xc9\x0a\xb2\x92\xac\x22\x43\x64\x35\x59\x43\xd6\x92\x75\x64\x3d\xd9\x40\x4e\x27\x1b\xc9\x19\x64\x13\x39\x93\x9c\x45\x36\x93\x2d\x64\x98\x6c\x25\x11\x32\x42\xa2\x24\x46\x04\x12\x27\xa3\x64\x8c\x24\xc8\x36\x32\x4e\x92\x64\x82\xa4\x48\x9a\x64\xc8\x76\x92\x25\x39\x92\x27\x05\xb2\x83\x4c\x92\x9d\x64\x8a\xec\x22\x5f\x21\x67\x93\x73\xc8\xb9\xe4\x3c\x32\x4d\xce\x27\x17\x90\xdd\xe4\xab\x64\x0f\xb9\x90\xec\x25\x17\x91\x8b\xc9\x25\xe4\x52\xf2\x35\x72\x19\xd9\x47\x2e\x27\x57\x90\x2b\xc9\x55\xe4\x6a\x72\x0d\xb9\x96\x5c\x47\xbe\x4e\xae\x27\x37\x90\x1b\xc9\x4d\xe4\x66\x72\x0b\xb9\x95\xdc\x46\xf6\x93\xdb\xc9\x37\xc8\x1d\xe4\x4e\x72\x17\xb9\x9b\xdc\x43\xee\x25\x07\xc8\x37\xc9\x7d\xe4\x5b\xe4\x7e\xf2\x6f\xe4\xdb\xe4\xdf\xc9\x03\xe8\x1a\x76\x34\x19\xc9\xe5\xd8\x89\x42\x2e\x11\xe5\x72\x42\x24\x1b\x1d\x53\x09\xa9\x1d\x42\x32\x9d\x11\xd8\x31\x21\x92\xcd\x33\xb9\x7c\x24\xab\xa1\xc9\xb0\x30\x91\xc9\x4f\x31\x85\x9c\x90\x65\xe2\x89\xe4\x84\x2a\x3f\x36\x9c\x8c\x64\x47\x05\x9c\x1f\xe3\x29\x9c\xc8\xe5\x71\x7a\x9c\xcb\x0a\x13\xe9\x1d\x02\xbf\x2b\x9d\x9e\x18\x4e\xa4\x54\x52\x9e\x2e\xe4\x49\x3a\x1e\xe7\x72\x89\xd1\x54\x24\x49\xa2\xe9\x51\x36\x9f\x8d\xe4\xc6\x98\xb1\xf4\x84\xa0\x8a\x27\x92\xc2\x70\x24\x99\x67\xf2\x89\x09\x81\xc9\xa6\x23\x31\x5d\x2c\x3d\x99\x4a\xa6\x23\x31\x5a\xad\x9a\x2d\x70\x85\x0c\xcd\xd8\x44\x6a\x24\xbd\x53\x9b\x49\x46\xa6\x86\xa3\x89\x6c\x34\x29\x70\x59\x21\x23\x44\xf2\x7c\x56\x88\x67\x85\xdc\x98\x8a\x76\x45\x6a\x30\x99\x8e\x8e\x33\xf1\x64\x64\x54\x33\x26\x44\x62\x99\xb1\x74\x4a\xc8\x69\x76\xa4\x93\x85\x09\x61\x38\x1d\x8f\x6b\x15\x90\x12\x50\x2b\x70\x21\xc3\x6d\xcf\x46\xd3\x31\x81\x1f\x89\x48\x39\xc9\x47\x46\x99\x7c\x64\x34\xc7\x8c\xa4\xd3\xe3\x2a\x9a\xd0\x19\x9e\xcd\x64\x13\xa9\x3c\x17\x8d\x4c\x08\xd9\x08\x43\xa7\x42\x66\x24\x9d\x8c\x71\x89\x7c\x24\x99\x88\x6a\xf3\xc2\xce\xfc\xf0\x98\x40\x97\x0a\x1a\x09\x9e\x4c\xc4\xf2\x63\x9a\x48\x32\x31\x9a\x1a\x4e\x0a\xf1\xbc\x4e\x06\xa3\x42\x2a\x2f\x64\xb5\x72\x41\x5a\x59\xe8\x65\x78\x5b\x21\x97\x4f\xc4\xa7\x18\x3a\x16\x6d\x22\x15\x13\x52\x79\x19\x4f\x81\xa5\x7b\x0d\xf1\x48\x54\xa0\x5c\x1b\xde\x91\x88\x09\x69\x3e\x93\x88\xe6\x0b\x59\x81\xcb\x08\xa9\x68\x22\xa9\x99\x88\x64\x86\x69\x5f\x85\x2c\x17\x89\xd1\x06\x99\x7c\x22\x95\x67\x84\x58\x22\xcf\xe6\xc6\x22\x59\x81\x8d\x8e\x09\xd1\x71\x86\x0a\x4c\x9f\xcb\x0b\x99\xe1\x91\x48\x74\x7c\x32\x92\x8d\xe9\xe3\x91\x5c\x7e\xae\xa4\x9a\x05\x18\xca\x74\x36\x13\x29\xe4\x04\x26\x97\x4f\x67\xf8\x78\x3a\x4b\xeb\x75\xd2\xed\xb3\x05\xa9\x25\xa5\xc0\x0a\xdb\x84\x68\x5e\x17\x1d\x13\x76\x64\xd3\xf2\xc8\xf5\xb3\x05\x69\x08\xea\x4c\xb2\x90\x1b\xa6\x8a\xa1\x99\x48\xa4\x14\x50\x2b\x2b\x91\x04\xf3\xe9\x71\x29\xd7\x6f\x2f\x08\x39\xba\x9e\x92\x4a\xea\x44\x2a\x9e\x96\xd1\x72\xd1\xac\x20\xa4\x72\x63\xe9\xbc\x5e\x41\x93\xb5\x42\x9d\x1e\x57\x20\xcd\x48\x24\x35\x0b\x46\xb2\xd9\xf4\xa4\xd4\x0f\xad\x0c\x4a\xbd\x50\xc9\x70\x21\xa3\x5c\x97\x34\x42\x62\x11\xd5\x23\x6d\x56\xc8\x25\x76\x09\xc3\xf1\x42\x32\xa9\x53\xe0\xdc\x44\x24\x99\x34\x09\x3b\xa3\xc9\xc8\x44\x64\xae\x5b\xcc\x68\x22\x9e\x67\x92\x42\x24\xce\xc4\x13\x59\x41\x25\x4c\x09\xc3\xe9\x8c\x90\x52\x53\x20\x9a\x4c\xe7\x04\xdd\x64\x24\x9b\x4a\xa4\x46\xa5\xdb\xd9\x4c\x32\x92\x12\x54\xd1\x48\x52\x48\xc5\x22\x59\x2e\x1b\x49\xc5\xd2\x13\x7c\x34\x3d\x31\x21\xa4\xf2\xdc\x44\x64\x34\x25\xe4\x35\xb3\xfc\x2a\x64\xe6\xf8\x48\xfb\xc7\x67\x85\xfc\xa4\x20\xe4\xf5\xb9\xb1\x74\x26\x43\x9b\x8c\x46\xb2\x79\x5d\x3c\x9d\x8c\x09\x59\x99\x98\x56\x29\xd0\x2e\x18\x95\x8e\xef\x10\xb2\xf9\x44\x34\x92\x34\x2b\xe5\xb1\x74\x36\xb1\x8b\xae\xe4\x92\xea\x91\x48\x76\x38\x3a\x46\x1b\xc9\x4f\x26\xf2\x79\x21\x2b\x33\x9e\x2a\x19\x55\x7b\xa9\xa4\x93\x35\x7e\x38\x2b\xe4\xb3\x69\x32\x2e\x4c\x31\xd1\xf4\x68\x4e\xa5\x74\x39\xa7\xcf\x8f\x15\x26\x46\x72\xc3\x85\x0c\x65\x9c\x51\x29\xd1\xee\xd2\xb2\x5a\x32\x24\x63\x91\x64\x5c\x2b\x59\x17\xd9\xa6\xf0\xb4\xdd\x74\x21\xaf\x4f\x26\x52\xe3\x42\x2c\x21\xb3\x92\xcf\x14\x72\x63\x99\x44\x4a\x2f\xec\xcc\x0b\xd9\x54\x24\x39\x4c\x2f\x4b\x26\x24\x91\xe2\xf2\xd9\x74\x66\x6c\x4a\x3b\x9a\xc8\x8f\x15\x46\x64\x3d\x90\xad\x03\x25\xc3\x26\x85\x89\x74\x8a\x95\x7e\xef\x5a\x49\xc5\x65\x42\x86\xd9\x1f\xaf\x5c\xd4\x48\x37\xc8\xc4\x94\x01\xab\x66\xc7\xca\xc9\x2d\x73\x85\x14\xb5\x21\xda\x68\x96\xfe\x68\x28\x83\x63\x24\x9b\xcb\x91\xb1\x58\x4c\x35\x52\x48\x26\xc7\xd2\xd9\x14\x33\x22\x24\x93\xda\x28\x65\x6b\x3c\x11\x8d\xe4\x05\xcd\x58\x24\x15\x53\xb4\x5b\x02\xa9\xb6\xf1\x12\x54\xc8\xc8\x35\x94\x21\x66\x59\x23\x87\x8f\x6a\xa4\xe5\x98\x1a\xa9\x01\xe3\x31\x55\x85\xcc\xb1\x48\xb4\x19\x76\x34\x99\x1e\x11\xb8\xc9\xac\x90\x8a\x8e\xb1\xf9\x48\x6e\x3c\xc7\xc5\x13\xc9\xbc\x90\x55\x8f\x64\x13\x42\x3c\x1a\xc9\x09\x1a\xaa\xb9\xf2\xef\x84\x1d\xcd\xa6\x0b\x19\x86\xf2\x92\x8d\x26\xd3\x85\x18\x37\x22\x44\xc6\x85\x2c\x89\x16\xf2\x4c\x34\x9d\x99\xd2\x64\x22\x19\x49\x7f\x12\x19\x26\x17\xd9\x21\x68\x28\x7f\x86\x47\x92\x91\xd4\x38\x9f\x15\xd2\xd9\x98\x90\xc5\x85\x24\x4e\x27\xf5\xb9\x7c\x36\x31\x2e\xe4\xc7\xb2\xe9\xc2\xe8\x98\xba\x90\x8a\x09\xd9\x64\x22\x25\xb0\xf9\xc8\x48\x52\x60\x27\x22\xa3\x89\x28\x9b\xcf\x16\xa2\xe3\xea\x4c\x82\x5a\x39\x21\x97\x37\xcc\x41\x12\xdb\x4d\xa3\xe9\xf4\x68\x52\x18\x9e\xb3\x01\xda\x79\x15\xec\x44\x3a\x25\x4c\x69\xa2\x91\xac\x90\x97\x46\xaa\x92\xc1\x42\x46\xa9\x93\x7e\xc4\x32\x28\xf1\x8a\x8f\x52\x13\x9e\xca\x31\xb9\x74\x36\xaf\xa6\x89\xfc\x3b\x91\xa0\x42\x46\x37\x3b\xb3\x49\x93\xca\xac\xae\x31\x85\x54\x2c\xcd\x26\x85\xd1\x48\x52\x1d\x8b\xe4\xc6\x46\xd2\x91\x6c\x4c\xab\xa8\x33\xbd\x53\x37\xab\xda\xd2\x8c\x32\x92\x4e\xe6\xf9\x5c\x22\x2f\x4c\x44\x32\xaa\xc2\xc4\x48\x56\x48\x26\x23\x6c\x26\x92\xcb\x0b\x9a\x24\xed\xc4\xf0\x48\x21\x39\xa2\x12\x76\x46\xc7\x22\xa9\x51\xc1\x20\xb1\x78\x78\x76\x06\xd3\xc9\x45\x59\x53\x79\x3a\x95\x0e\x4f\xc4\xb4\xb9\xbc\x90\x1f\x4b\xe7\xa2\xe9\x8c\xa0\xca\x15\x12\x79\x2a\x31\x15\x55\x2a\x4a\x91\x8b\xa6\xe3\x71\x41\x60\xe2\xe9\x74\x4c\x2f\xcd\x94\xd2\x74\x42\x87\x30\x52\x48\x24\x63\x89\xd4\xa8\x6a\x2c\x9d\xcb\xd0\x79\x47\x1d\x99\x18\x29\x24\x23\xa9\xa8\xc0\x4d\x08\xb1\xf1\x44\x5e\x1b\xa7\x5d\x12\xb2\xc3\xdb\x84\x3c\x33\x22\x08\x59\x6e\x4c\x36\x53\xf1\x96\xb8\x60\x8e\xa5\x0b\x23\x54\x95\x52\x94\xe3\x92\xfe\x1d\x53\x23\xeb\xdf\x31\x55\x85\xcc\xb1\x48\x74\x5c\x9a\xa3\xf8\xda\x79\x88\xaa\x59\x0c\xcd\xd1\x5b\xf9\x98\x90\x1b\xcf\xa7\x33\x5c\x32\x92\xa1\x99\xa4\x28\x79\xdd\x44\x7a\x84\x8e\x4b\xfa\x35\xea\x14\xfd\x96\xf4\x4d\xb3\xbd\x90\xce\x2b\x4d\xcb\xa0\x2c\xe7\x5c\x26\x91\x4a\x09\x59\x4e\xbe\x97\xcd\x0a\x99\xe4\x94\x46\x31\x05\x91\x64\xde\x34\xdf\x04\x4a\x66\x68\x9e\x19\xa4\x65\x8d\xb0\x33\x43\x7f\x85\xb2\x74\x93\xc9\x48\x46\xbe\x8f\xcd\x4d\x24\x92\x02\x1b\xcf\xa6\x27\x53\x64\x42\x18\xe3\x47\x23\x13\x42\x26\x12\x53\x8d\x0b\x53\x92\x5e\xa8\xe8\x5a\x82\xde\x69\x90\x00\xc9\xb4\x08\x59\x21\xa6\xca\x0b\xd9\x89\x44\x2a\x92\x64\xe8\x8a\x41\x2d\x75\x68\x38\x92\x4c\x1a\xe7\xec\x9d\x62\x80\x92\xe9\xa8\x3c\x59\x48\xbf\x5f\x26\x9a\x4d\x67\xd4\x14\x85\x4e\x97\xe3\xd4\xd8\x24\x52\xe3\xcc\xb0\x2f\xdc\xae\x9d\x37\xb3\x68\x73\x85\x8c\x90\xcd\x45\xb3\x89\x4c\x5e\x9d\x2b\x8c\xc8\x10\x33\xec\x6b\xf3\xeb\x32\x85\x5d\xbb\x28\xef\x12\x42\x54\xd0\x4c\x24\x68\x83\x94\x8d\x86\xa3\xe0\xb0\xb4\xf0\x1a\x4b\x08\xc9\x98\x61\x76\xa2\x91\x7b\x63\xa6\x53\xd4\xb0\xb0\x33\x9f\x48\x8d\x16\x12\xb9\x31\x21\xcb\x65\xd3\xd1\x71\x81\x4e\x3c\x3b\xa3\xb1\x94\x79\x76\xb6\xc9\xcd\x2e\x5a\x2c\xc7\xd4\x28\x06\x6a\x7e\x15\x35\x50\xf3\xcb\x92\x81\x1a\xcb\x4f\x24\x83\x4c\x34\x97\xf3\x73\x91\x54\x74\x2c\x9d\xd5\xc8\x56\x55\x51\xe2\x64\x32\x27\x4c\x09\x56\x21\x99\x4c\x64\x72\x89\xdc\xbc\x09\xc9\x3c\x57\x37\x3b\x69\x31\xc3\xfe\x16\xbf\x5a\x5a\xfa\xd1\xf6\xb9\x7c\x82\xf6\xd7\x70\x74\xe5\x20\x4d\xd7\xb2\xc9\x97\x2a\x55\x49\x61\x87\x90\xa4\x6a\x28\x03\x92\xc6\xca\xd7\xa5\x65\x84\x64\xd6\xa5\x9f\xc4\xb0\xbf\xd5\xa7\x91\xa7\x7c\x69\x46\x88\xa6\x27\x32\x91\x1c\x9d\xd9\x64\x05\x39\xaa\x29\xf9\x74\x86\xde\x1d\x26\x42\x21\x4b\x46\x47\x32\xa4\x90\x8b\x91\x44\x2a\x4b\xb6\x65\xa6\x48\xb6\x30\x42\xc6\xb3\x93\x64\x24\x1f\xa5\xcb\x64\x41\x3d\xf7\x9b\x35\x49\x76\x68\x84\x2a\x46\x66\x2c\x32\x22\xe4\x99\x61\xbf\xaf\xdd\x32\x57\xab\xbc\x31\x12\x72\x8e\x13\xab\xe8\xb0\xf4\xb3\xd5\x92\x0d\x36\x1f\x53\x92\x6c\xd3\xb0\xdf\x1f\xa0\x49\x50\x37\x95\x2e\xe4\x0b\x23\xca\x40\x94\x02\xb3\x33\x91\x1a\x55\xef\x9c\x5d\x7a\xcc\xdd\x43\x99\xc9\xc7\xb2\xe9\xcc\x48\x7a\xa7\x3e\x97\x8f\x44\xc7\x67\x8d\x97\x3a\x91\xca\xe5\x23\xa3\xd9\xc8\x04\x17\x4f\x26\xa2\xe3\x59\x12\x89\xa5\x98\x78\x6b\xb8\xd5\x30\x92\xc8\x8f\x14\x28\xeb\x15\x31\x14\x26\x46\x92\x59\xad\x9c\x49\x55\xc6\x64\x3a\x35\x3a\x6f\x96\xd2\xcf\x2b\x17\x32\xf3\xaf\x52\xbd\x32\xcd\x2b\xcb\x3f\xf1\xc9\x44\x2a\x96\x9e\xcc\xf1\x91\x54\x2c\x9b\x4e\xc4\xd8\x64\x22\x55\xd8\xc9\xc7\xb2\x89\x11\x3a\xb7\xe4\xc6\xa7\x32\x82\x26\x9e\x2e\x64\x73\xdb\x0b\x91\xac\xc0\xe5\xa9\x1d\x4e\x73\x71\x61\x22\x92\x14\x18\x9a\xd0\x09\x3c\x9f\xc8\x90\x5c\x81\x8a\x36\x14\xe2\xe9\xc3\x4d\x62\x87\x40\x46\x0a\xa3\x78\xc7\x38\x3b\x29\x24\x46\xd2\x5c\x56\x48\x65\x05\x7a\x43\xd8\x67\x90\xc6\x3e\x3c\x3b\x78\x5a\x17\xb0\xcb\x5d\x9a\x9d\x73\x93\xf2\x9c\x43\x2f\x85\x0c\xb1\x74\x7e\xde\x05\x5a\xd7\xa6\xdb\x91\x98\x10\xd2\xc3\x72\x9f\x98\x61\x7f\x5b\x8b\x5e\x9e\xd9\xa4\x8a\xe1\x34\xad\xf2\xd1\xc4\x4f\x13\x2a\xab\xb6\x20\x4d\x42\x34\x09\xd3\xa4\x8d\x26\xed\x7c\x21\x95\x18\x6c\xed\x69\x61\xe2\xad\x91\x56\x66\xd8\xdf\x4e\x91\xda\xfd\xb4\x48\x91\xda\x29\x52\x3b\x45\x6a\xa7\x48\xed\x14\xa9\xbd\x9d\x19\x0e\xb4\x48\x18\x23\x14\xf2\xd1\xc4\x4f\x93\x80\xdc\x5a\x6f\x2b\x2d\x84\x68\x12\xa6\x49\x1b\x4d\x28\x52\x6b\x0b\x4d\xe8\xd5\x56\x8a\xd4\x4a\x91\x5a\x03\x34\x09\xd2\x84\x62\xb4\x52\x8c\x56\x8a\xd1\xaa\xf4\xad\xaf\x45\xc9\x29\x9e\x8f\xe2\xf9\x28\x9e\x8f\xe2\xf9\x28\x9e\x8f\xe2\xf9\x28\x9e\x8f\xe2\xf9\x28\x25\x3f\xa5\xe4\xa7\x18\x7e\x8a\xe1\xa7\x18\x7e\xa5\x7b\xfd\x4a\x83\xfd\xad\x4a\x2e\xdd\x41\x51\xfd\x0a\xc9\xfe\xa0\x92\x87\x94\x9c\x36\x1e\xa0\x6d\x04\x28\xd5\x00\xa5\x1a\xa0\x54\x03\xd2\x05\x8a\x1a\x50\x50\x07\x28\xe1\x20\x25\x1c\xa4\xcd\x06\x29\x52\x90\x22\x05\x29\x52\x90\x22\x05\x29\x52\x90\x22\x05\x69\x57\x43\x14\x23\x44\x31\x42\x14\x23\x44\x31\x42\x4a\x57\x07\xa5\x6b\x14\x29\x14\x66\xe2\xad\x71\xe9\x1a\x45\x0a\xd3\x0b\x61\x8a\x14\xa6\x48\x61\x7a\x21\x4c\xc9\x84\x29\x99\x70\x88\xde\x1c\xa5\x10\x25\x13\xa6\x18\x6d\x14\xa3\x8d\x62\x50\xbd\x08\x50\xbd\x08\x50\xbd\x08\x50\xbd\x08\x50\xbd\x08\x50\xbd\x08\x50\xbd\x08\xb4\x51\x8c\x76\x8a\xd1\x4e\x31\xa8\x52\x04\xda\x29\x46\x7b\x80\x89\xfb\x24\x31\xb6\x87\x28\x24\x5d\xa0\x18\x54\x29\x82\x2d\x2d\x34\x69\xa5\x89\x8f\x26\x7e\x9a\x04\x68\x12\xa4\x49\x88\x26\x61\x9a\xb4\xd1\xa4\x9d\xdd\x21\xa4\x0a\x39\x66\x38\x48\x55\x22\x48\xdb\x0a\x52\x95\x08\x52\x95\x08\x52\x95\x08\x52\x95\x08\x52\x95\x08\x52\x95\x08\xb6\x52\x22\x3e\x4a\xc4\x47\x31\xa8\x32\x04\xa9\x32\x04\xa9\x32\x04\xa9\x32\x04\xa9\x32\x04\xa9\x32\x04\xa9\x32\x04\xa9\x32\x04\xa9\x32\x04\xa9\x32\x04\xa9\x32\x04\xa9\x32\x04\xa9\xf9\x0a\xfa\x29\x86\x9f\x62\xf8\x29\x06\xd5\x81\xa0\x9f\x62\x04\x28\x46\x80\x62\x04\x28\x06\x15\x7d\x90\x8a\x3e\x48\x45\x1f\xa4\xa2\x0f\x52\xd1\x07\xa9\xe8\x83\x01\x8a\x11\xa4\x18\x54\xee\x41\x2a\xf7\x20\x95\x7b\x90\xca\x3d\x48\xe5\x1e\xa4\x72\x0f\x52\xb9\x07\xa9\xdc\x83\x54\xee\x41\x2a\xf7\x20\x95\x7b\x90\xca\x3d\x48\xe5\x1e\x0c\x51\x8c\x10\xc5\xa0\x42\x0f\x86\x28\x46\x88\x62\x84\xda\x99\xb8\x2f\xd4\x42\x13\x8a\x11\xf6\x51\x88\x62\x50\xa1\x07\xa9\xd0\x83\x61\x8a\x11\xa6\x18\x54\xe8\x41\x2a\xf4\x20\x15\x7a\x90\x0a\x3d\x48\x85\x1e\xa4\x42\x0f\x52\xa1\x07\xa9\xd0\x83\x54\xe8\x41\x2a\xf4\x20\x15\x7a\x90\x0a\x3d\x48\x85\x1e\xa4\x42\x0f\x52\xa1\x07\xa9\xd0\x83\xed\x14\x83\x5a\x82\x20\xb5\x04\x41\x6a\x09\x82\xed\x6d\x4c\xdc\x17\x16\x24\x35\xf5\xb5\xb5\x28\x79\x2b\x33\x1c\xa2\xa2\x0f\x51\xd1\x87\x14\x7b\xe0\x6b\x0b\x2a\x79\x88\x56\x86\x69\xd2\x46\x93\x76\x66\x38\x44\x75\x29\x44\xe5\x1f\xa2\xf2\x0f\x51\xf9\x87\xa8\xfc\x43\x54\xfe\x21\x2a\xff\x10\x95\x7f\x88\xca\x3f\x44\xe5\x1f\xa2\xf2\x0f\x51\xf9\x87\xa8\xfc\x43\x54\xfe\x21\x2a\xff\x10\x95\x7f\x88\xca\x3f\x44\xe5\x1f\xa2\xf2\x0f\xf9\xe4\x9f\xa5\xaf\x47\xe9\x61\x4f\xab\x92\xfb\x94\xdc\xaf\xe4\x4a\x57\x7b\x94\xae\xf6\x84\x94\x3c\xac\xe4\x6d\x4a\x3e\xdb\x5e\x8f\x92\xf7\x2a\x79\x9f\x92\xf7\x2b\xf9\x80\x9c\xf7\x2a\x74\x7b\x15\xba\xbd\x0a\xdd\x5e\x85\x6e\xaf\x42\xb7\x57\xa1\xdb\xab\xd0\xed\x55\xe8\xf6\x2a\x74\x7b\x15\xba\xbd\x0a\xdd\x5e\x85\x6e\xaf\x42\xb7\x57\xa1\xdb\xab\xd0\x55\x8c\xa6\xaf\x4f\xa1\xdb\xa7\xd0\xed\x53\xe8\xf6\x29\x74\xfb\x14\xba\x7d\x0a\xdd\x3e\x85\x6e\x9f\x42\xb7\x4f\xa1\xdb\xa7\xd0\xed\x53\xe8\xf6\x29\x74\xfb\x14\xba\x7d\x0a\x5d\xc5\xb6\xfa\x14\xdb\xea\xeb\x57\xe8\xf6\x2b\x74\xfb\x15\xba\x8a\x85\xf5\x29\x16\xd6\xd7\xaf\xd0\xed\x57\xe8\xf6\x2b\x74\xfb\x15\xba\xfd\x0a\xdd\x7e\x85\x6e\xbf\x42\xb7\x5f\xa1\x3b\xa0\xd0\x1d\x50\xe8\x0e\x28\x74\x07\x14\xba\x03\x0a\xdd\x01\x85\xee\x80\x42\x77\x80\x6a\x4a\xbb\x42\x74\x40\x21\x3a\xa0\x10\x1d\x50\x88\x0e\x28\x44\x07\x14\xa2\x03\x03\xf2\xa7\x25\xf8\xe2\x0b\x84\xa5\xaf\xcf\x06\x84\x50\x91\xf2\xc5\x1b\x10\xe0\x67\x11\x20\x66\xee\xdb\x94\xf4\x7d\xfa\x27\x1d\xdf\x90\xdc\xde\x7e\xbc\x6a\x71\x0b\xcd\x5f\x6d\x1d\x7b\xf4\xff\x0b\x00\x00\xff\xff\x4f\x70\x1d\xba\x6e\x87\x02\x00") + +func uiAppLibFontAwesome470FontsFontawesomeWebfontEotBytes() ([]byte, error) { + return bindataRead( + _uiAppLibFontAwesome470FontsFontawesomeWebfontEot, + "ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.eot", + ) +} + +func uiAppLibFontAwesome470FontsFontawesomeWebfontEot() (*asset, error) { + bytes, err := uiAppLibFontAwesome470FontsFontawesomeWebfontEotBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.eot", size: 165742, mode: os.FileMode(420), modTime: time.Unix(1, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _uiAppLibFontAwesome470FontsFontawesomeWebfontSvg = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\xbd\x6d\x73\x1c\x49\x92\x26\xf6\xbd\x7e\x85\x8b\x32\xd3\x17\x5d\xa0\xc3\xe3\x3d\x6e\xa6\xf7\xec\x6e\xe7\x76\x4d\x66\xa2\xf6\xcc\x6e\xef\x64\xfa\xd4\x86\x26\x8b\x2c\xec\x24\x01\x26\x10\xac\x9e\xc1\xaf\x97\xf9\xe3\x91\x59\x55\xc8\xac\x02\xc0\x66\x73\x7a\xa4\xb5\x99\x66\x15\x2a\x23\xe3\x3d\x3c\xfc\xf5\xf1\x3f\xfe\xa7\xbf\x7c\x1a\x68\xbf\xbd\x7f\xb8\xb9\xbb\xfd\xf1\x0d\x5f\xd9\x37\xf4\xd0\xae\x6f\xdf\x5f\x0f\x77\xb7\xdb\x1f\xdf\xdc\xde\xbd\xf9\x4f\xff\xb0\xf9\xe3\xff\xf2\xa7\x7f\xf9\xc7\x7f\xfd\x7f\xfe\xdb\x7f\xa5\x87\xfd\x47\xfa\x6f\xff\xe3\xbf\xfc\x9f\xff\xc7\x3f\xd2\x1b\xf3\xc3\x0f\xff\xb7\xff\xc7\x1f\x7e\xf8\xd3\xbf\xfe\x89\xfe\xfb\xff\xfc\x67\xe2\x2b\xfe\xe1\x87\xff\xfa\x7f\xbd\xa1\x37\xbb\xd6\x3e\xff\xc7\x1f\x7e\xf8\xe5\x97\x5f\xae\x7e\xf1\x57\x77\xf7\x1f\x7f\xf8\xe7\xfb\xeb\xcf\xbb\x9b\x77\x0f\x3f\xfc\xf7\xff\xf9\xcf\x3f\x48\xc1\x3f\xfd\xeb\x9f\x7e\x78\xd8\x7f\x64\xbe\x7a\xdf\xde\xbf\xa1\x7f\xd8\xfc\xf1\x61\xff\xf1\x1f\x36\x7f\xfc\xb4\x6d\xd7\xef\xaf\xdb\xf5\x3f\x6c\xfe\xf1\x7e\x7b\xdd\xb6\xef\xe9\xe7\xbf\xd2\x3f\xdd\xdd\xb6\x7f\xba\xbb\xff\xb8\x25\x67\xd9\xd9\xec\x99\xae\x1b\xbd\xbd\xbb\xa5\x7f\x79\xd7\xc8\x05\xe2\xfc\x1f\x7d\xfe\x8f\xc1\xca\xf3\xb4\xa1\xff\xf2\x57\xfa\x0f\xff\xe1\x3f\x6c\xfe\xf1\xee\xf3\x5f\xef\x6f\x3e\xee\x1a\xfd\xe9\x7a\xbf\xa5\x7f\xbe\xbe\x7d\xff\x57\x94\xb8\xa2\xff\x3c\x0c\x84\x47\x0f\x74\xbf\x7d\xd8\xde\xef\xb7\xef\xaf\x36\x7f\xfc\xe1\xd0\xfa\x1f\xdf\x6f\x3f\x3c\xfc\xc3\xe6\x8f\x1f\xee\x6e\x1b\xdd\xbc\xff\xf1\x8d\xf4\xe1\x3f\xff\xb2\x7d\xb8\xfb\xb4\x7d\x43\xbb\xbb\xfb\x9b\x47\x73\xfd\x7e\x6f\xfe\xf2\xe3\x1b\x8e\x3e\xc9\x08\x88\x50\xda\x7c\xb8\x7e\xb7\xa5\x0d\x11\x51\xff\xf3\xd3\xcd\xf0\xd7\xd3\x0a\x0e\x4f\x7f\xd9\x4a\x2f\x7e\x7c\x13\xac\x3d\xfa\xf5\xa1\xdd\x6f\xdb\xbb\x9d\xcc\xff\xfd\xa7\xeb\x41\x9f\x7c\xb9\xbd\x69\x0f\xe6\xf3\xf6\xde\x6c\x3f\xfd\xf8\x86\x73\x75\xfa\xfb\xe7\xeb\xdb\xbb\x87\xad\xe1\x1f\xdf\x58\x5a\xfc\x4f\x8b\x5c\x3f\xbc\xdb\xde\xb6\xde\x55\xfc\xf2\x7e\xdb\x7f\x32\x2e\xf6\x9f\x7e\xfe\xf9\xee\x2f\x3f\xbe\x31\x7c\x65\x9d\x2d\x9e\xe4\xc1\x55\x4d\x8e\x9c\xb7\xe1\x2a\x11\x47\x9f\xaf\xac\x9b\xfa\xf2\x7e\x7b\x3f\xdc\xdc\x6e\x4d\xdb\xdd\xbc\xfb\xf3\xed\xf6\xe1\xe1\xc7\x37\xf6\xe9\xb3\xcf\x77\x0f\x37\x0d\x1b\x6b\x7e\x74\xf3\xee\xee\xfd\xd6\xdc\x5f\xdf\x7e\xdc\xfe\xf8\xe6\x7f\xfc\xef\xd6\x3a\x6b\xfe\x29\xea\xe0\x7f\x90\xf5\xbf\x79\x78\xb8\xb9\xfd\x68\x3e\x0e\x7f\xfd\xbc\x3b\x9d\xe7\x52\xd3\x1b\xda\xbc\xff\xf1\xcd\x5b\x27\x4b\xce\x6e\x17\x42\xd9\xb3\x67\xb7\x33\xf2\xcd\xc8\xd7\xc7\xb7\xcc\x8e\xec\x5e\x46\xba\x4b\xd9\xed\x0d\xbe\x99\x94\xdd\xe3\x1b\x69\x41\xba\xf1\x47\xad\x1d\xff\x9a\xdb\xeb\x4f\xdb\x1f\xdf\x5c\xdd\xde\xb5\xf7\xdb\x0f\x6f\xbe\x6b\x93\x5f\x86\xe1\x49\x83\xf6\x0d\x6d\x2e\xbc\x72\x7b\x77\xfb\xe9\xfa\xfe\xcf\x37\xb7\x1f\xef\xb7\xed\xcb\xfd\xed\x93\xb7\x63\xcd\x97\xdf\x7f\xf8\x7c\xfd\x6e\xfb\x66\x5a\x86\x1f\xdf\xd0\x93\x0a\x42\x28\x97\x2b\x78\x7f\xb3\xbd\xdf\x3e\xdc\x3c\x1c\xd5\xf1\xbf\xfd\xaf\x7f\xb9\x2e\x7f\x78\x7a\x26\x64\x77\x5e\xac\xe9\xdd\x74\x38\x9f\x54\x55\x5f\x5f\xd5\xfd\xf6\xe3\xcd\x43\xdb\xde\x6f\xdf\x3f\xa9\x6b\xfb\xfa\xba\xae\xdf\x7d\x69\xdb\xd3\x6a\x7e\x0e\xaf\xaf\xe6\x3f\xff\xd7\xd3\x3a\xde\xa5\xd7\xd7\xf1\x2f\x0f\xc3\xf5\xc3\xee\xb4\x9e\xf7\x5f\x31\xd3\xed\xfe\xfa\xfd\x56\xb6\xcd\x69\x55\x8e\x9d\x7b\x7d\x65\x37\xb7\x1f\x6e\x6e\x6f\xda\x5f\x9f\xd4\xe5\xf8\x2b\xe6\xfa\xf6\xae\x6d\xc7\x2f\xd7\xc3\xd3\xba\x92\x7d\x7d\x5d\x1f\x87\xeb\x87\x27\xbb\xf2\x83\xb5\xe7\x2a\x92\x13\xcd\xa9\x56\x62\x1f\xed\x68\xc9\xf8\x48\x26\x78\x32\xb9\x0c\x26\x79\x47\xf2\xcf\xde\xe4\x54\x76\xde\xd9\xd1\x25\xb2\x14\x22\x19\xae\x8d\x2b\x99\x10\x9b\x99\x3e\xf5\xe7\x9d\x29\x35\x8d\x06\x05\xe5\x27\xae\x28\x11\x62\xd3\x7f\xf1\x93\xd4\xb5\xcf\xa9\x37\x91\xbc\x1b\xa5\x4d\x69\x36\x78\xca\x65\xb4\xe4\x3c\x71\x21\x9f\xae\x62\xf3\x85\x38\x5f\xc5\x26\x25\x76\x1c\x6c\x19\x9d\x97\x5e\x48\x69\x79\x68\xf0\x94\x0b\x19\x29\x7e\x91\xd0\x7c\xfa\xf2\x70\xf3\x6e\x31\x37\xfc\x87\x69\x22\xa2\x4f\x24\x84\x6c\x6f\x98\x1d\xa6\x23\xca\x94\x04\x32\xa5\x36\x53\x12\x99\x64\xaf\x64\xc8\xd6\x5f\x45\x32\xde\x35\x53\x93\x7c\x63\xfc\x8c\xef\x7c\x54\x42\x0a\x94\x44\xfa\x92\x0f\x54\x6a\xd3\x7f\xa7\x1f\xe7\x62\xf3\xab\x23\xdb\x48\x96\xb8\x3a\x32\xbe\xee\xa3\xcf\x83\xcc\x3e\x19\xe7\xf3\xde\x64\x5b\x7f\x8b\x5e\x6d\x5e\xdb\xad\x9a\xf2\x68\xc9\x33\x71\xa5\x28\x8b\x14\x2a\xf9\x78\x15\x87\xe2\x1d\xb9\x98\x46\x76\x14\xc8\x15\x0a\x63\x90\xdb\x17\x03\x28\xcd\x15\x32\xa9\x5c\x5c\xa2\x87\xed\xf5\xfd\xbb\xdd\x62\x8d\x96\x07\x34\xa5\x30\x2d\x1b\x47\x47\xd9\x86\xd1\x12\x17\x19\xb6\x67\xe9\x3d\x27\x8c\x8f\x31\x04\xf9\x69\xfa\xc3\xf4\xbf\xb4\x9c\xfe\xd8\x4e\xfe\x38\x29\x77\x5c\xc3\x51\xd5\x8f\x6f\xa5\x0b\x64\xd8\x15\x2c\x89\x4c\x4c\x21\x53\x6d\x33\x55\x96\xa7\x8c\x26\x06\x39\x04\xd5\x92\x2f\x83\xf1\xc1\x93\x0f\x6e\x34\x9c\xab\xbc\x15\x64\x22\xf5\xdb\x68\x38\xc8\x96\x36\x2e\xcb\xbc\xc7\x28\xbd\x73\x2e\x12\x47\xdb\x0c\x47\x4b\xce\xc5\x66\xe4\x77\x42\x91\x4d\x3b\x7c\x6f\xd3\xf3\xe9\x85\xa3\x4a\xf4\xab\xd1\xef\x4e\x46\x14\x2d\xca\x4b\xed\x5a\x87\xb6\x39\xe2\x27\x7b\xe8\xd7\x20\xdd\x95\x3e\x8f\x3e\x93\xf1\x99\xe4\xa3\xda\x8b\x4b\xb7\xbd\xdd\x6f\x87\xbb\xcf\xdb\xc5\xe2\xf9\x8b\xc4\x27\x05\xf2\x4e\xa8\xc1\x68\x84\xde\x78\xd9\xcf\x95\x4c\x02\x15\x91\x7d\x63\x13\x99\xe0\x12\x19\x8f\x49\x65\x25\x50\xc2\x98\xa5\x2c\x3b\x59\x46\x11\x8a\xee\x6f\x87\x21\x85\xab\xb8\x33\xbc\x33\x3c\x9a\x50\x64\x62\xf5\x81\xfc\xde\x5f\xd0\xf2\xc5\x53\xca\xa3\xe1\x58\x88\xa5\x6d\x69\x05\x8d\xc8\x80\x2d\xfa\x91\x12\xa8\x9f\x4c\x10\x7b\xaa\xa8\xde\x61\x3a\xe5\x6b\xbd\x8a\x3b\x0e\xd9\x8d\x2c\xeb\x87\xdf\xea\x55\x6c\x52\x4c\xfe\xe8\x7b\x84\x6d\xf1\x7b\xe6\x3d\xcb\x72\x19\x8b\xdd\xb4\x69\xc6\x13\x4b\x4d\x46\x96\xa1\x36\x53\x29\x63\x0c\x81\x1c\xba\x2f\xd5\x1a\xd6\x7d\x31\x35\xd6\xcc\xdc\x03\xf4\x28\x15\xe2\x90\xe5\x6c\x85\x91\xab\x97\x05\x76\x14\x2c\xcb\x46\xce\x63\x22\x13\x49\x08\xba\x93\x57\x83\xcc\x20\x08\x69\xd0\x9d\x7e\x15\x5b\xb4\xba\x05\x94\xbc\x9a\xba\xe3\x1d\x8f\xce\x2a\x79\xad\xfa\xd8\xcd\xef\xe0\x95\x90\x08\xb5\xf8\x48\x52\xed\xe8\x6c\x21\x4e\x11\xad\x4a\xa3\x31\xc8\xbb\x6c\x31\x4c\x8e\x78\x63\x3a\x3f\x8f\x9b\xb7\xb2\xf4\xc2\x3f\xda\xbd\x61\x5b\x30\xaf\x49\xd6\x37\x93\x61\xf6\x4d\xfe\x91\xbf\xa6\xf1\x27\xdc\x23\xf2\x63\xc8\x4d\x4a\x31\xfb\x7d\x7f\x31\x25\xd2\x1f\x9a\x3e\xd7\x95\xc0\x1b\xbd\x96\xd6\xab\xbd\xb8\x6d\x77\xdb\xeb\xfb\xb6\xd8\xb3\xe7\x58\x1d\xd9\xb3\xa5\x26\x3d\xf7\xd3\x35\x17\x88\xe5\x2e\x73\x81\x92\x95\x45\xb3\x54\x74\x56\xc9\xa5\x7e\x6e\x13\x0e\x75\x2a\x54\xb1\xca\x51\x0e\x26\x3b\x6e\xc6\xe1\x9b\xc7\xa5\xe7\x2c\xb1\xcb\xe4\x43\x68\x3e\x32\x09\x69\x48\x4e\x86\xe3\xb0\xc9\x1d\x48\x90\x1c\xd3\x58\x5a\xc5\xe9\x4d\xb2\x8f\xb3\x1c\x99\x32\xfa\x44\x3e\x51\x4e\x94\xfa\x53\x3c\x94\xf2\xb1\x34\xad\x42\x6a\x18\x85\x83\xb7\x24\x0d\xc8\x71\x6f\xd2\xa2\xf1\x21\x28\x0d\x60\xf9\x07\x37\xba\x95\x11\xc9\x21\xb3\x76\x33\x1a\xb9\x5f\xe5\xbf\x20\x24\xef\x19\x12\xde\xae\xef\x17\xf3\x19\x2f\x11\x70\x39\x24\xa5\x54\xed\x01\xc9\xac\x9a\x20\x24\x33\x09\x0d\x8a\x61\x90\x3b\x2e\x5a\x3b\x32\x99\x4c\xd2\x43\xdc\xcd\xd2\x57\xc6\x06\xf6\x98\x5c\x8f\xef\x1c\xae\xe2\x28\x2c\x87\x2c\x8c\x4c\xdd\x60\x42\xa8\xe4\x7c\xd2\x2f\xc6\x79\xa1\x2c\x4e\x06\x8f\x12\x86\xdd\x28\x75\x59\x3d\x13\xc4\x41\x49\x89\x6c\xf8\x88\x73\x96\xc8\x91\xb3\xd2\x8b\x68\xad\x74\x2b\x90\x8f\x61\x34\x4e\x0e\x87\x88\x87\x14\x64\xf9\x7c\xa6\x98\x28\xa4\x21\x5a\x47\xd9\x0f\x42\x71\x43\x8c\xa3\x30\x3e\x4c\x41\xfe\x95\x7b\xd2\x04\xc6\x23\x13\x62\xdc\xa0\xac\xc9\x7e\x8c\x89\x8c\xdc\xa5\x64\x42\x7a\x76\x76\x7f\xda\x7e\xfa\xfc\x94\xf3\xfc\x60\xed\x92\xb5\x3e\xbe\x24\xa5\x7b\xde\x0d\xde\x26\x72\x35\x0f\x26\x38\x47\xc9\x0d\x86\x4b\x25\x5f\xfa\x17\x83\x6f\xf2\xc8\x24\x2d\x6b\x50\x38\xcb\x79\x72\x3c\xf8\x5c\x88\xe5\x7a\xc8\x72\xb2\x6a\x7d\xfc\xda\xc5\x93\x4b\x28\xb0\x7c\xfe\x96\x8b\xb5\xf9\xa6\xab\xf5\xfa\xc5\xfa\xf2\xb0\x5d\x1e\x85\xbc\x58\x26\x57\xec\xb4\x4c\xae\x58\x62\x9f\x41\xdd\xad\x5c\x83\x20\xfd\x5c\x32\x18\x01\xf9\x9e\xcb\xce\x14\x19\x50\xd1\xab\x0d\xbf\xe6\xd2\xb4\x28\x17\x79\xb7\x44\x2a\xf2\x07\xb8\x39\x9d\xa8\xe8\x5a\x2c\x4a\x88\x5b\x05\xb7\xc7\x1e\x44\x5d\xce\x0b\x7b\x10\x83\x42\x5e\x08\x27\xbb\xd2\xe4\x8b\x90\xb8\x0c\x72\xea\xf5\xca\x90\xc9\xae\xca\x77\xa2\x2e\xe1\x90\xb4\x7a\xb9\x78\x9a\xfe\x24\x6d\x3e\xbe\x65\xeb\xe4\xe2\x73\x20\x2b\x1c\x85\xd1\x61\xbd\x9c\x33\x98\x2f\x7c\xf4\x1f\x37\xd3\x9f\xac\x17\xa2\x96\xd4\x82\xc7\xdf\x8f\x0b\x1d\xbf\xdf\x8e\xab\xbe\xb8\x1e\x1f\x6e\x86\x4f\x8b\xf5\x58\x4a\x92\xd5\x4d\xeb\xe1\x4b\x20\x93\xc2\x5e\xb9\x3c\xd9\xdb\x2a\xc6\xa8\x68\xb3\x3b\xb9\x05\x54\x2c\xea\xf2\xd0\x7e\x62\x0c\x5d\xa2\x2e\x21\x75\x01\x49\x7e\x9f\xe4\x28\x15\xa3\x42\x7c\x44\x43\x22\x15\x7d\x97\x86\xb2\xbd\x38\xa2\xcd\xb7\x69\x49\x64\x35\x4c\x5e\x64\xb7\xda\x14\x78\xbe\xf5\x96\xf4\x95\x65\x4b\xf2\xca\xfa\x98\x84\x29\xf8\x16\xb3\xb7\x79\x66\x50\xc2\xbf\x7c\x97\x1d\x81\xe9\x93\x95\xfa\xcd\xa7\x0f\x63\xea\x9b\x6f\xf3\x1b\x0f\x4a\x9a\x7a\x66\xfb\x7d\xc3\x96\x5e\xb7\x29\x36\x5f\xdd\x56\x05\xe7\xa6\x7a\x50\xe5\xa4\xce\x30\xb5\xc9\xda\x73\x4c\xad\xbe\xb8\x64\x6a\xe5\x95\x57\x33\xb5\x6d\xf7\xd3\x70\x7d\xff\x71\x29\x8b\x2d\xb5\x8a\x07\x1e\x21\xa7\x42\x91\xdd\xde\xf8\x12\xd6\x65\xda\x1d\x76\x96\x3c\x98\x04\xdb\x26\x25\xaa\xdd\xeb\x2b\xd1\x11\xfe\x6c\x78\xb6\x93\xc2\x28\xab\x6f\x37\xad\xec\x11\x0d\xc9\x4d\xf7\xdb\xb7\x04\xee\xe4\xf2\x98\x36\xdf\xb2\xa9\xef\x32\xaa\xcb\x0b\xbf\x58\xf2\xeb\x0b\xa2\x4c\x64\x47\xae\xc8\xbe\xad\xa0\x18\xc2\x62\xa9\x96\x06\xc2\x8a\x71\x65\x67\xbc\xb3\xa3\x81\x1a\x47\x7e\x72\xa5\x49\x89\x54\xf6\xfa\x4a\xb0\x84\x3f\x1b\x9e\x41\x4b\xb8\xa2\xf2\x41\x43\xc5\xda\xdf\xbe\x21\x68\x83\x5e\x30\xa4\xcd\xb7\x19\x53\x57\x17\x7e\x8f\x41\x7d\xcb\xe9\xdb\x9c\x6f\x4a\xe8\xe6\x77\xd9\x12\x18\xd4\x77\x9a\x3f\x19\xd4\x34\x7f\x9b\xdf\xbe\xa9\xef\x32\xaa\xe7\xe8\xff\xcd\xc3\x52\xad\xf1\xf3\xff\xbf\x68\xc1\x4b\xf6\x72\x4d\xaf\xa1\x05\x35\xfd\xcd\x69\xc1\xf1\x5e\xbe\x30\xa8\x57\xd0\x82\x73\x83\x7a\xd9\x5e\x7e\x4d\x5b\xe7\x9a\xba\xb4\x97\xef\xfe\xbc\xd8\xc6\xef\x2e\x6a\x94\x33\x53\xcd\xf6\xb4\xbb\x83\xc9\x2e\x90\xfc\x33\x18\xf6\xc2\x0b\x42\xb3\x50\xa6\xe7\xe8\x8c\xf6\x5f\x0b\xb0\x4f\x83\xf1\xc9\x91\x4f\x0e\x05\x7b\xd9\x84\x3e\xa7\x32\xf4\x42\xa3\x3e\xd2\x91\x6b\x3d\x83\x13\x21\xd9\xd5\x38\xa4\x98\x28\xc5\xbc\x56\x66\xee\x44\xaf\xf7\x05\x13\x71\xbf\xfd\x74\xb7\x5f\xb2\x74\xef\x17\x93\x11\x6c\x99\xf5\x09\xb5\x90\xe3\xf0\x74\x32\x9e\x9d\x02\x19\x82\xab\x41\xbf\xc8\x3f\xcf\x4d\xd6\xea\x1c\x9d\xd4\x32\x55\xf2\xfa\x89\x0c\x53\x45\x2f\x9f\xc8\x4d\x9b\xc7\x7a\x52\x89\xe9\xb5\xbc\x70\xca\x1f\xef\xee\x3e\xfd\x74\x73\xbb\x98\xf3\xa5\x91\xf7\x48\xd5\x66\x5d\xa0\xec\xd3\xde\xa4\xd0\xed\x06\x07\xb5\x7d\x3b\x28\xf3\x77\xc6\xb9\xb0\x97\x7f\x2e\x97\x4a\xe1\xc4\x0e\x30\x9b\x01\xe4\xaf\xbd\x73\x01\xf5\x5c\x28\x82\x5e\x74\xe3\xc5\xc1\x76\x21\x55\x4b\xfb\xda\xfc\xea\xe3\x14\x8e\xec\x1a\x66\x32\x6c\xa0\x09\x74\x5b\xde\xdf\x9c\x2d\xf2\xf8\x3b\x31\xcc\x79\x35\x7b\x08\xe7\x8c\x69\x51\x8d\x71\xbe\x8a\xbf\xca\x40\xb7\xb9\x6c\xa1\xfb\x5d\x1a\xe8\xb0\x99\xef\xbe\x2c\xb8\x02\x5e\x7a\x07\x7c\xcd\x6e\x8e\x39\x7d\xd5\x2e\x94\xf7\x7e\x77\x9b\x68\xf3\x5d\x76\xd1\xef\x74\x13\x6d\x2e\x5e\xc7\x1f\x3e\x2c\x36\xd0\xa9\x0b\x45\x0a\x56\xb5\xbe\x89\x4c\x62\x21\xb9\xa5\x19\x96\xd9\x74\x41\x86\x0c\x5d\x4a\x0a\x4d\x1e\x48\x09\xfd\x82\xcf\x10\x09\x4f\xa4\x34\x0a\x27\x26\x57\x0b\x16\x5f\xb8\x1e\x28\xac\x7d\x73\x6a\xcd\xca\x76\x94\xe9\x76\x04\x73\x97\x8b\xad\xe8\x4c\xd8\x51\xad\xb9\xb0\xf8\x92\xa9\x30\x12\x04\x6c\xaa\x02\xf3\x90\xb4\x9b\x65\x75\xa3\x6a\x91\x0b\x77\x93\x9c\x71\xba\xde\x6c\x03\x05\xb5\x27\x55\x58\xd1\x6c\x55\xe5\x36\xd6\x22\x79\x75\xaf\xa8\x42\x07\x50\x40\x6e\x57\x79\x82\xef\xfa\x15\x85\x50\xa6\xbf\xad\x2f\xa3\x56\x94\x93\x41\x39\x26\x6d\xd8\xc9\x8d\xaa\xdd\xe1\xc2\xa3\x74\x1e\x63\x90\x17\xa5\xcf\x0d\x43\x91\x91\x8c\x9e\x29\x78\x2a\x81\xa2\x6d\x55\xba\x1c\x47\x0e\x49\xed\x05\xae\x5b\x0a\xb3\x6d\x45\xb7\x68\xf0\x8f\x30\x58\x0a\x53\x20\x67\xd8\xae\x6b\x26\xda\xa9\x3a\x42\xcb\x9d\xaa\x23\xda\xcb\xb5\x10\x0f\x37\x1f\x6f\x9f\xba\x33\x7d\xb0\x7c\xce\xcd\x0a\x7e\x85\x31\x51\x4d\x33\xa3\xc9\x81\x0c\xec\x3f\xcd\x38\x58\xa6\xf1\x40\x7e\x96\x4d\xec\xd5\x60\xee\x7c\x67\x32\x39\x90\xfc\xd5\xe4\xc1\x4e\x7e\x42\x39\xbc\xd8\x50\xcb\xe3\xdb\x24\x8c\xa8\xdc\xb7\x5e\x0d\x50\x2f\x6d\x40\x8b\xbf\xa0\x01\x10\xca\x50\xec\x1e\x84\xf0\xe5\x2d\x6c\xf6\x5a\xfe\x25\x4d\x04\x5b\xa8\xa4\xb0\x07\xcf\xfd\x8a\x41\x68\xf1\x97\xb4\xa0\x1c\x7f\x96\x85\x08\xf9\x75\x2b\xa1\xe5\x9f\x6f\xe4\xd2\xc6\x79\x77\xf7\x71\xb1\x6b\xfc\x1f\x8e\xaf\x22\xdd\x99\x6c\x13\x99\x8c\xb3\xd2\xe4\xf8\x52\x8e\xfa\x69\xe4\x4b\xee\x67\x7a\xfa\x9c\x1e\xf4\x82\xfa\xde\xa3\x12\xab\x1c\xaa\x30\x33\x3a\x54\x47\xa6\xf4\xa1\xe2\xaa\x1b\x0c\xee\x1c\x57\x60\xa4\x14\x4a\x6f\x7c\x25\x53\x79\xf4\xa0\x33\xc4\x36\x4b\xb9\x32\xb2\xbe\x2e\x1f\x42\xc4\x31\xd2\xd1\x38\x25\xab\x06\x37\x80\x95\x43\x26\x32\x08\x8f\x52\x54\xd5\xcb\x55\x18\xe8\x42\x6c\xcb\x08\xdb\x3a\x26\x8a\xa1\x97\x1c\x0d\x2b\x67\x2b\x14\x54\x06\x92\x46\x93\x95\x05\xc7\x6f\x65\x87\x7e\x4f\x2b\x21\xf4\x41\xbd\x60\xb8\x5b\xfa\x07\x29\xcb\x25\x8c\x26\x54\x92\xba\xe4\x18\xe7\xc1\x70\x80\xe5\x3c\xc3\x53\x01\x5d\x15\x22\x39\x57\x14\x89\xd1\xc3\x44\x2c\x6b\xcf\x49\x48\x57\x91\xb6\xa5\x78\x26\xe7\x41\xb9\xa8\xc8\x37\x96\xa6\x28\x32\x25\xb9\x5a\x63\xa0\x6c\x85\xc0\xba\x4c\xdd\xc2\x5b\x65\x84\xc5\x93\xcb\x60\x0e\x1c\xec\xf6\x6a\xe7\x93\x0a\xc0\xc2\xba\x43\x85\x8d\x2b\xb1\xdf\x0c\x5c\x12\xb9\x22\x9b\x27\x24\xf2\x95\x64\xcb\x05\x4b\x31\xa3\xe7\x70\x98\x90\xde\xcb\x8a\xb1\x25\xe5\x61\x2d\x76\xde\xe8\xe0\x07\x01\x4a\xcc\x36\xc3\x64\x79\x15\x29\x33\xec\x9c\xd4\x2d\x01\x76\x60\xf8\x0e\xda\x3c\x86\x20\xdb\xb3\x32\xc9\x32\x42\x14\x21\x57\x49\xa6\x3b\x8b\x88\x20\x7f\x96\x9d\x74\x52\x77\x32\xae\x14\xdc\x09\x3c\x39\x65\x0c\x0e\xde\x11\x61\x0c\xb2\x4e\x49\xd5\xb5\x79\xe0\x20\x1b\x22\x8f\x55\xfa\x15\xa8\xf6\xe6\x71\x75\x8c\x8c\x35\x95\xd1\x26\xf9\x21\xdb\x31\xcb\xe6\x93\x05\x56\x0d\xd5\xbc\x19\x47\xc3\x51\xbd\x1d\x22\x93\xc1\x3c\x63\x27\x62\xa6\x1d\xac\xeb\x24\x2b\x5a\xcb\xc0\x70\x57\x2f\xd2\x90\x71\x04\x07\x09\x99\x69\x54\xf3\x8c\x69\xb4\xdd\x2f\x7c\x6c\x3f\x58\x5e\xba\xc1\x1c\x64\xcb\x59\x8d\x73\x96\xde\x41\x72\x79\x4a\x27\x56\xa8\x9d\x08\x1a\x0b\x52\x94\x53\xf9\x2d\xab\x07\x31\xf9\xba\xfa\x37\x2f\x6b\x00\x8c\x6b\xda\xd7\x50\xe0\x14\xbb\x37\x35\x94\xee\x25\x91\x27\x7e\x21\xe8\x6d\xdd\xd4\x8f\xa5\x5c\xc5\x5d\xf1\x6e\x94\x6d\x82\x5f\xca\x54\xc6\xe5\x96\xc1\x57\x3c\xbe\x0d\xc5\x92\xd4\xbd\x0b\xa1\x0c\x26\x14\x62\xce\x72\x38\x65\x3b\x65\x62\xde\xc1\xf7\x0b\x47\xdb\xe1\x27\xc3\xdc\xaf\x0e\xf5\xbb\xea\x7c\xfc\x62\xb8\x47\x5d\x2c\xbe\x5b\xaf\x82\x57\x8a\xe2\xd5\xc9\x74\x67\x8a\x77\x9b\x63\x0b\x56\x04\xc9\x09\x99\x38\xf0\x55\xdc\xd7\xe8\xa4\xa2\x95\x79\x53\xfe\xff\x78\xd6\xbc\xad\x43\xb6\xc4\x29\x0b\x15\xf1\x99\x62\xa0\xe4\x5b\xae\xe4\xd2\x41\xfb\x25\x6c\xb4\x4b\x42\x59\x4c\xf2\x52\xde\x70\xca\xf2\xee\xeb\x2e\x96\x1d\xc2\x55\x9e\xec\xee\x8b\x4e\x49\x32\x61\x31\x84\xbd\x09\xc5\x76\x5b\xe0\xc2\xd7\xd9\x97\xb0\xf7\x45\x24\xf0\x98\x60\xf6\xc1\x4f\x6b\xee\xcf\x7b\xad\x85\x09\x2c\x6c\xc3\xbf\x43\xcc\x91\x42\x0e\xf8\x34\x21\x87\x51\x98\x65\x92\x43\x2e\x42\xac\x67\x4a\x72\x05\x25\x27\xcc\xea\x28\xc4\xa0\x76\xaf\x27\x59\xe4\x59\xd6\x62\xca\x83\x49\xd5\x51\xcc\xfd\x8b\x89\x39\x8f\x33\x01\x11\x52\x71\x4c\x7b\x19\x55\x6a\x8d\x13\x45\x07\x39\xc3\xa5\xb1\x19\x32\x57\x8a\xb5\x0a\x0f\xed\xe0\x4f\xe6\x12\x5c\xcc\x5c\x1a\x1c\xae\x28\x1b\xf6\x5c\xe3\x4b\xee\xfa\xbd\x09\xb6\x0c\x8e\x71\x7d\x39\x5c\x92\xb2\x0b\xbb\x2b\x1b\x6e\xb3\xe7\xe8\xd2\x87\x9b\x61\xfb\xd3\xf5\xb0\x14\x5a\xd3\xcc\x16\x84\x24\x95\xc6\x59\x03\x14\x84\xbb\x4f\x4d\xae\x70\xe8\x7e\x39\x9e\xd5\x5d\xc2\xea\xba\xaa\xbc\x4c\xd6\x2e\xb5\x97\xa5\x26\xdd\x95\x05\x8e\xa9\x98\x96\x50\x26\x6f\x97\x20\xd4\xc4\xe7\xb4\xf3\x90\x84\xad\x5c\x23\x72\xda\x03\x0f\xc6\xb3\x27\xcf\x1e\xab\x02\x5f\x26\x26\xe7\x26\x1f\x09\x76\x65\x2f\x55\xec\x4c\xe0\xb4\xda\x9d\xc0\x09\x06\xff\x1e\x52\xc3\xae\x3c\x23\xa5\xb5\x9b\x95\xfd\x9e\xff\x70\xe4\xc1\x58\xab\xdb\x9b\xa0\xe7\x7d\x49\x0c\xa0\xaa\x7e\xc1\x21\x16\x96\xda\xc7\x05\xe3\xb7\x4e\x11\x3d\xbb\x89\x7f\xc3\x1a\x09\x57\xe0\xe5\x80\x14\x91\x88\x9a\x48\xa9\x24\x3f\xc8\xa7\x99\x9e\x18\x3c\x92\x5f\xa4\xf0\xf4\x39\x3f\x99\xca\xf6\x77\xa7\xba\xb4\xee\xc7\x59\x20\xc5\x95\xea\x2c\xf8\x30\x91\x79\x8b\x4a\xdf\x59\x35\x0d\x19\xba\x0a\xfc\x88\x02\xd3\x77\x7c\xd5\x42\xbd\x8c\xbc\xad\x2f\x1f\xbe\x1d\x17\x38\xbc\x77\x54\xdb\x49\x33\x87\xf6\x2f\x2b\x7b\xef\xae\xdf\x2f\x16\xf0\x92\xab\x12\x33\x33\xc5\x60\xf7\x61\x90\x33\xaf\x0b\x48\xf0\xe7\x62\xea\xca\x1a\xa8\x5f\x76\xca\x4a\x76\xea\xe1\xbb\x63\x31\x4e\xa5\x03\xd3\x28\x5c\xae\x5c\x14\x72\xfd\x81\x0f\xd1\xcd\x2e\x94\xa7\xec\x5c\x08\x23\xb8\x57\xc7\x54\x5a\x21\x67\x1f\xdf\x72\xc9\x96\xb2\xb0\x85\xea\x28\x28\xbc\xb9\xdf\x99\x6c\x67\x05\x22\x94\x41\x85\x7a\x03\x16\x31\x02\xe7\x7a\xe7\x8e\x1c\x9f\x57\x7a\x07\x16\x35\x6d\xb4\x6f\x1e\x7d\x53\x75\x52\x57\x43\x49\xab\xd2\x05\x8b\x8e\xa0\x57\x31\x10\xb8\xd9\x34\x04\xb9\x22\x6d\x08\xa3\xec\x12\x82\xbb\x37\x02\x4c\xc2\xce\xfb\x7a\xa1\x55\x06\xc1\x77\xda\x68\x20\x15\x12\xd0\xe4\x8e\x53\x3a\x8c\x52\xc6\xe8\x51\xbc\x97\x5e\x1b\xa1\x34\x05\x27\x6b\x70\xa0\xa1\xa9\x6f\x3b\xfa\x66\xd0\x39\xf9\x21\x39\x65\x54\xf9\xb2\x87\xe1\xfb\xbb\x5f\x6e\x87\xbb\xeb\xf7\xab\x24\xf2\x92\xb3\x87\x7a\x1a\xd6\x35\xd7\xa2\xf6\xc4\xf5\xa6\x9d\xf8\xc0\xb4\x53\xd7\x17\xc4\xcc\xfc\xfa\x6a\x52\x0a\x14\x38\xcd\xe2\xf9\x2a\xb1\x86\x4b\xf8\x0a\x75\xd4\x77\x9e\xd0\xea\x90\xe2\xc0\x1e\x8a\xbe\xb4\x19\x63\x21\x13\x95\xb9\x37\x31\x35\xf9\x8c\x69\x32\x3d\xec\x42\x5a\x0d\x54\x79\xcb\x5e\x44\x8f\x12\x47\x59\x9a\xa0\x6b\x6f\xb2\x1d\x84\x6e\x12\x88\xa7\x3a\x46\xd7\x83\xb7\x12\x86\xa5\x05\xf0\xdc\x33\xae\x01\x16\xc9\x48\xaa\xf1\x72\xb9\x92\xaf\x3b\x61\x19\x94\xfc\xaa\x97\xd1\x1c\x1c\x25\x67\x63\x19\x68\x05\x5a\x8d\x67\x41\x4e\x5f\xac\x22\x8a\xbe\x68\x6b\x2c\xb6\xc5\xf5\x7c\x73\xb2\xb3\x94\x6c\x99\xc4\x0d\xf0\x8c\x41\x2e\x2b\xa9\x9d\xe5\x40\x70\xbf\x18\x84\x8c\x63\xff\x0e\xb2\x42\x9d\xba\x44\x48\x95\x99\x7c\x1c\x85\x10\x90\xb7\xe4\xac\x30\x02\x6b\x57\xc2\x3a\x7f\xe0\xa3\x3b\xa3\x8a\x80\x93\x10\xa4\x57\xd6\x20\x8e\x6f\x76\x2b\x6c\xda\xb9\xab\xe7\xf1\x44\x81\xf9\xf7\x74\x5d\x7c\xf9\xbc\xba\xd4\x3f\x1f\x96\x9a\x0b\xa5\x64\xc1\x46\x0a\x0d\xf5\x18\x20\x94\x39\x58\x85\x57\xe9\xc4\x84\xcb\x5f\x7d\xa4\x82\x3c\x24\xf2\x41\x76\x91\x6c\x22\x66\xec\x02\xaa\x0d\x95\x0e\x1e\xcd\x3b\x3b\x82\xa8\x26\x11\x86\x7c\xfc\x4d\xd6\x7b\xd3\xa6\x75\xfe\xff\xdc\x7a\xdf\xdc\xfe\x7c\xf7\x97\xc5\x72\xbf\x3b\x52\x95\x79\x8a\xc2\x8a\x32\x2e\x5a\x99\xaf\x49\x3f\x24\x5f\x32\xae\x52\x76\x14\xaa\x30\x96\xb6\xe8\x5f\x26\x40\x76\x23\xd3\xcb\x9b\xf9\x05\x93\xe5\xe2\xe2\x34\x54\xbd\x09\x45\x40\xeb\xb3\x17\x43\x12\x21\xc9\x9d\x13\x92\x10\xb3\xb9\x2e\x12\xc9\x3b\x72\xd1\x45\x62\xe7\x07\xe7\x0b\xc5\x08\x31\xc1\x45\x04\x7f\x52\x70\x2d\xc2\xad\x3d\x43\x30\x46\x25\x51\x5d\xe2\x73\xf3\x1a\xfa\xe5\xf0\xa2\x89\xd1\x6d\x46\x17\x61\x72\x80\x8e\xe5\x19\x89\xf0\xf3\x70\xfd\xd7\x9f\xde\xdd\xdc\xbf\x1b\x96\x8c\xf2\xfb\xc3\xb1\x29\x93\xca\x11\x8a\x3c\x2f\xc2\x55\x1c\x4c\x0c\xca\x24\xa9\x6e\xa6\xea\x83\x0a\x8d\x1d\x36\x37\x69\x34\x1b\xeb\x93\x98\xba\x42\xdd\x67\xc2\x9f\xa3\x47\x7c\x2b\x0c\x4c\xc3\x5c\x97\xd4\xc1\x85\xb4\x8d\x7f\x67\x97\x5f\xc7\x2e\x6f\x3f\x6f\xaf\x97\x1c\xd0\xf6\x34\xb6\x17\xde\x99\x5d\xe6\x59\xdb\xaa\xb8\xb1\x71\xbf\x9a\x58\x29\xc8\xf2\xe2\xc6\xe6\x40\xa9\x42\x63\xa8\x8a\xc7\x20\x5f\x10\x36\x55\x11\xad\x01\x7b\x91\xed\xc6\xa2\xae\xdb\x31\xc7\x66\xa2\x66\x4e\x2c\x48\xe6\xd8\xb6\xf4\x22\x3b\xd3\xb1\x99\x69\x64\x44\xcc\x38\x17\x29\xba\xc6\x59\xfa\x97\x47\xa8\x67\x9d\x27\x76\x42\x58\x55\xcf\x58\x37\x03\xfa\x29\xbd\xae\x22\x7b\xeb\xc4\xa2\x7b\x79\x8e\x24\xd4\x48\x13\x44\x40\xba\xa4\x02\x3e\xd6\xd7\x65\x32\x59\x0b\x44\xec\xeb\xe7\xcc\x74\xad\x7f\x4c\x3f\x4f\xe5\xf4\xbd\x91\x43\x96\x7e\x95\x70\x30\x57\x6a\x2c\x22\xc7\x74\x25\xcc\x9a\x5c\x1e\x75\x74\x72\x6d\x50\x96\x5d\x3f\x7a\xd5\x6a\xc9\x47\xbc\xcc\xed\xdc\x6f\x3f\xdc\x6f\x97\x1a\x4c\x77\x64\x9a\x64\xa6\xae\xcb\x91\x36\xa1\x15\xc1\x70\xc1\xf4\xc9\x3f\xc1\xab\xa5\x30\xcb\x61\x49\x09\x23\x57\x49\xc2\x15\x07\x73\xab\x8c\x1d\x76\xbd\x98\x07\xa3\x2a\x5c\x57\xd5\x38\xb0\x60\x02\x67\x32\xb7\xc6\xe4\xc9\x8f\xe7\xa3\xe9\x07\xd3\x97\x2d\x8f\x19\x3a\x5f\xe2\x04\x9d\xbd\x6b\x5c\x64\xdf\x89\xc8\x01\x8e\x29\x5a\x4a\xb1\x71\x49\xc4\x19\x57\x2d\x67\x8a\x9e\x98\xf3\x46\x78\x32\x0f\x9e\xcc\x2b\x8b\x75\xde\xc6\xfe\xf2\xc3\x71\x2e\xb0\xff\xe2\xe1\xf0\xdd\xb0\x20\x7c\x3b\xec\x34\x52\x7b\xee\xec\xa5\xb0\xd6\x11\x52\x52\x56\xe6\xc4\x77\xe6\xc4\x0b\x8f\x51\x2f\xb8\x14\xe4\x31\x45\x92\x85\x73\xd9\x92\xae\x1d\x94\xa3\xb2\x72\x9b\x51\x57\xce\x95\x30\xef\xb5\xc5\x4e\xe3\xaa\x6b\x42\x2a\x8e\x1c\xd6\xe1\xe2\x4e\x1b\x6e\x1e\xda\x9a\xb8\x75\x16\x45\x62\x0a\x24\xf2\xd1\x3d\xef\x45\x71\xd1\xdb\xe7\xbc\x13\xc5\x05\x5f\x1d\x8d\x8f\x49\x6a\xfe\xfd\xee\x8d\x6f\xd0\x3a\x8c\x96\x7f\x8b\xa1\x63\x6b\xbf\x68\xe2\xe1\xc6\xf8\x15\xcd\xcb\x7b\x17\x46\xaf\x37\xea\x4b\x26\xff\x37\xe9\x80\xb6\xff\xa2\xe9\xff\x76\xed\x6f\x4e\x3a\x80\xb8\x88\x64\xf7\xc2\xc0\xa1\x8a\xb9\xd2\x36\x37\xf4\x7c\xbc\xfb\xde\xe8\xfb\x5f\x17\x86\x0f\xb3\xb6\x06\xe8\xfc\xe6\x51\xe7\x9b\x17\x45\xe8\x0c\x77\xef\x16\x7e\xad\x6e\x89\x94\xc0\x71\xa6\x20\xce\x52\x4e\x08\x0a\x99\xbc\x1e\x5e\x62\x04\x87\x47\x45\xb7\x46\x01\x93\xa9\x9b\xbb\x5e\xe3\xc9\xab\xaf\x2c\xfc\x93\xa7\x6e\x94\x00\xf8\x04\xcf\xa9\x79\x18\x50\x1d\x3e\x85\xa3\x68\xe0\x2a\x3c\xab\x63\xc7\xce\xbb\xd7\x3a\xff\x7e\x18\xae\x17\x1e\x01\xee\x52\x70\xbe\x47\x28\x96\x5e\xf3\x19\xa1\x7a\xb2\x16\x76\x6f\xd8\xa5\xf4\x2b\xe8\x0f\x5e\x97\xda\x3c\x82\x1a\x89\x19\x1e\x32\x1e\x68\x08\x04\xaf\x30\x38\x85\x01\x1c\xe1\xe0\x1e\xd6\x0e\x5e\x63\xf3\x36\x64\x60\x4a\x40\x5d\xaa\x82\x0a\x0a\x43\xd4\xf2\x75\x02\x64\x18\x8d\x83\x7c\x2c\x13\xe9\x13\x6c\xc5\xd2\x3e\x42\x9f\xd9\xa9\xcb\x90\x70\x95\x70\x38\x2a\x1b\xd9\xc3\x11\x5f\x9b\xe1\x80\x98\x59\x39\x4e\xd5\xa9\x1e\x54\x26\x21\x24\xb0\xb3\x90\x56\x3c\xa4\x95\x15\x99\x2c\x07\x59\x52\xac\x26\xc5\x38\x3a\x16\xde\x37\x57\x0a\x7e\x74\x60\x12\x2c\x05\x18\xf0\xed\xc8\x16\xec\x9c\x05\x63\xd8\x60\xe4\x29\x65\xf4\xaa\x0f\x2b\xf8\x18\xe1\x1b\xc7\x0c\x28\x04\x6e\xcc\x56\x4e\x54\x29\xf2\x6f\x84\x5d\x93\x57\xb8\xa0\xe7\xe0\x1a\xde\x7f\xde\xdd\xdd\x6e\x17\x20\x47\xee\x59\x8c\x81\xa4\x18\x47\x9c\x80\x99\x23\xfb\x32\xa8\x42\x39\xd4\xee\xe9\xe1\xbd\x86\x9b\x17\x4f\xdd\xc7\x8f\x01\x42\xa4\x8c\x83\xfa\x6a\xed\x8d\x3f\xa3\x2d\xf9\x15\x06\x69\x54\x9a\x19\xc1\xd6\xb6\x23\x1a\x54\x79\x1c\xaf\xe2\x80\x70\x39\xe1\x8b\x6b\x84\x6b\x42\xf5\x93\x4c\x58\x84\xf9\x81\x66\x0e\x0e\x71\xb6\x36\xe3\xb1\x0f\xb2\x6c\x09\xfd\x6a\x72\x99\x0a\x18\x94\x80\xf1\x2a\x23\x62\xbf\x16\xd5\x4e\x56\x2f\x8d\x18\x76\xa3\x17\x56\x81\xaa\x87\x4f\x5d\x93\xce\x48\x5f\xf6\xfe\x25\x26\x9e\xd7\xda\xd2\xbd\x3b\x44\xb1\x4b\xf7\xa2\x9f\x7d\x2b\x31\xed\xba\x28\xde\x63\x91\x42\x1d\x65\xd1\x30\xec\x64\xc9\xc3\xa9\x9d\x23\x53\xca\xe4\x2a\x43\x0e\x72\x01\xe1\xe4\x0e\x0c\xb3\x54\x26\xd4\x20\x31\x3e\x4c\x62\x3c\x98\x84\x2b\x18\x96\xa5\x7c\x4b\x59\x76\x30\x5f\xdc\x76\xfb\xbb\xe1\xcb\xa7\xed\x4f\x2b\xce\x8f\x6e\x01\xbb\x90\x53\x39\x8a\xa8\x64\x2e\xe1\x70\xed\x2c\x19\xeb\x59\x65\xec\xbd\x27\xef\xfd\xce\x38\x44\x1c\x2c\xcf\xa6\xc6\x08\x3e\xd5\x16\x27\x37\xf4\x37\xbf\x92\x9f\xed\x43\x7b\x7f\xf7\xcb\xc2\xcf\xdd\x2d\xb1\x0a\x0e\x17\xd2\xef\x66\x70\xfd\x72\x53\x2d\x0d\x4c\xb2\xaa\x21\x0a\x7c\x40\x13\x30\xd5\xab\xa4\x0b\xe1\x4f\xc8\x6e\x3c\xee\x86\x3a\x4e\x49\xf5\xf0\xcb\x04\x85\xc3\xc6\x6f\xae\x92\x8b\xcd\x07\xec\xfb\x4a\x3e\x6d\x1a\x3b\x05\xbd\x32\xf3\x17\x3c\x00\x98\x16\xb6\x3c\x5e\x31\xbd\x06\xa9\x2e\x53\xaf\xbb\xf5\xc6\x0e\x22\x7a\x1c\x33\x74\x9d\x34\xf7\xb3\x4d\xdd\xbf\x8c\x9a\xd8\x97\xed\xcb\xe7\xc5\xa2\x2d\xad\x84\xa7\x31\xbe\xff\xbe\x68\xbf\xe9\xa2\xa9\x51\x7f\x76\x82\xf6\x64\xd4\x87\xd0\x4d\xfe\xde\x86\x4b\xc1\xb8\xfc\xc9\xb8\x72\x37\x59\xce\xd3\x2b\x17\x71\x55\x83\xd1\x18\xe1\x94\x96\x13\x85\x30\xe6\x40\x31\x28\xb8\x12\x31\xc6\x1b\xe0\x37\x9c\x55\xb5\x34\x7f\x9f\x99\x02\x14\x1a\x85\x88\x0a\x4b\xa1\x95\x18\x5f\x09\x8a\x78\x54\xff\x74\x11\x0f\x9e\x72\x71\xe4\xa0\xea\xb0\x43\xd7\xdb\x3c\xa0\xce\xde\x4f\x0a\x74\x0f\xe6\x24\xcb\x62\x62\xb4\xde\x83\xd1\xf3\xc7\xa3\x4d\x4f\x56\xf1\x78\xb4\xa9\x8f\x36\x53\x50\x36\x1e\xb8\x75\xf3\xb7\x31\x24\x99\xfe\xe2\x28\xf2\xc8\xea\xb4\x27\x2c\x8e\x73\xb9\xa5\x4a\xae\xd4\x66\xf4\x13\xa1\xfc\x78\x30\x1a\x9f\x30\x10\x7d\xcb\x48\xd5\xe6\x50\xf7\xe1\xab\xce\x88\x7f\xc9\x8c\x38\x98\xc5\x98\x0e\xc3\x6b\x87\x51\x5f\x3c\xb4\xe3\xbd\x1c\xd4\xc5\x89\x5d\x1a\x6a\x0f\x6e\x76\xd0\x1c\xe0\xc0\xc2\x06\xea\x00\x68\xb0\x63\x57\x3a\xee\x05\x8b\x70\xbb\x7c\xa6\xd1\xb5\xe7\x1e\x3a\xe1\x28\xea\x4e\xfd\x97\xbc\x3a\x32\x19\x5f\xbc\x3e\x2a\x35\xed\x66\xd7\xa6\xfe\x28\xa8\x1b\xf9\x99\x47\x29\x58\xd9\x04\x70\x30\x97\xcb\x1e\x1e\xe4\xbb\x14\xec\xd4\x11\x57\x56\xfb\x01\xaf\xb4\xd5\x67\x9b\xf9\x18\x1d\x1c\xab\xf6\x73\x29\xfd\x49\xbe\x49\x3b\xf3\xf4\x9c\x54\x2e\x7d\x9a\xbd\xde\x9f\x76\x0a\x0d\xaf\x3f\xbc\xb4\x7e\x3f\x5f\xaf\x2f\xe0\xa5\x18\xfb\xe4\x49\x5a\xf0\x7b\x69\x6f\x97\xfc\x1e\x16\x11\x99\xe9\x44\xbc\x33\x22\x47\x05\x9b\x45\x9e\x92\x07\xf9\xf1\x2d\x70\xc0\x76\xc6\x73\x7f\xc0\xd3\x03\x9f\xf3\xfa\x83\xe8\x83\x3c\x48\xbd\xaa\x34\x57\x95\xd2\x99\xaa\xb2\xf3\x67\x1e\x94\xb4\xfe\xa0\x06\xbc\xa1\xe3\xc8\xd3\x38\xb2\x2c\xb0\xb5\xab\x4f\x36\x6f\xd9\xe9\x18\x57\x5e\xf2\xb2\x2b\x56\x9f\x84\x70\xee\x9d\xe4\xa3\x3c\xa9\x41\x9f\xd4\x70\x78\x52\xcb\xfa\x5c\x42\xe4\x5a\x9b\xfe\x8b\xce\x53\x2b\x32\xe7\x6c\x49\x0d\x01\xee\xda\x45\xa5\x3f\x73\x10\xff\xcc\x41\xfe\x3b\x8a\x0f\x6a\xc7\x71\x43\x47\x5f\x8f\x4a\x1c\xde\x9b\x2b\x7b\x7c\xcb\x91\x23\x75\x1c\x17\x6d\x47\x5e\x1c\x4c\xa8\x2c\xf2\x8a\x03\xb9\xd2\x5f\x59\x3e\x47\x29\x65\x67\x1f\xef\xcc\x91\xb2\x48\x8c\xbe\x20\xaa\x27\x05\x90\x39\x6e\x06\x11\x22\xcc\x79\x1f\x38\x2d\x21\x27\xe4\x47\x54\xc4\x22\x2a\x3a\x04\x4f\x59\xa7\xef\x6f\x86\x8c\xfb\x83\x83\xc6\x0b\x55\x8d\x17\xba\xcc\x38\xb7\xeb\x8f\x4b\x49\x6d\x19\xbf\x7b\xf0\x63\xfa\xf7\xf9\x5d\xcc\xef\x5b\x2e\xb5\xbe\xae\xb3\x3e\x75\x23\x16\x87\x26\xaf\x84\x38\x84\x2c\xd2\xb7\x1d\x35\xce\xcb\x67\xaa\x3d\xc6\x47\x5e\xac\x3c\x8d\x29\xe8\x98\xe0\x1c\x2f\x0c\x9a\xb2\x63\x99\xa4\xaf\x3b\xe7\xc2\xd9\xee\x7f\xcd\xee\xf8\xf9\x6e\x19\xdd\xed\x96\x01\xcd\xc7\x72\xbc\xaf\xc4\x36\x96\x11\x5c\x49\x26\xf8\xdf\xb8\x3a\x18\x97\xb1\xf4\x49\xad\x31\x29\x08\xa3\xa3\xe6\x33\xc5\xd5\x54\x45\x4f\xf0\x50\x75\x3a\x3f\x9a\x0c\x86\x8b\x43\x39\x48\x9e\x75\x8a\x05\x1c\x8d\x0b\x04\xb9\x90\xd8\xe5\xd1\x52\x20\x4f\x2e\xb7\x40\x3e\x8f\x4c\x85\x8c\x27\xf5\x61\xf5\xc4\x80\xc1\x24\x96\x9f\x1d\x37\x04\x14\xaa\x47\xed\xf4\x6d\x74\x5e\x26\x34\x44\xaa\x88\x39\xb4\xf8\x1c\x3d\xb1\x55\x7f\x60\xab\xb0\xa0\xae\xc8\x6f\xb0\xe1\xb8\xd2\xe4\x5f\xbf\x19\x1d\x0b\x5f\x14\x1c\x55\xd7\x9c\xec\xde\x91\xa9\xaa\x79\xde\xbb\xd6\x5f\x0b\xc4\x9e\x9c\x23\xaf\xfc\x12\x98\xa7\x51\x3d\xdc\xc0\x98\x6a\x08\x19\x76\x7f\x92\x27\x7d\x04\x6a\xd5\xc5\xd2\x8e\x8e\x0a\x55\xe2\xd2\x58\xe3\x30\x32\x39\x1e\x0b\xdc\x39\x12\xfa\x88\x28\x44\xf2\x32\x2e\x61\x9c\x65\xd8\xd2\x03\x37\x8f\xd7\x27\x62\x40\x84\xe2\x14\x46\xc8\xef\x64\xfc\x28\xfb\x9f\x22\x53\xdd\xe5\xc4\xc2\xbd\x5a\x8d\x2c\x89\x09\xb0\xcd\xec\xad\xac\x5e\xc0\xea\x6d\xb0\x75\x11\x18\x61\x3a\xc4\x9b\xae\x0d\xbb\x72\xd5\x31\xe8\x76\xa6\xa4\x3a\x31\xcc\xd8\xa8\xb1\x9b\x92\x12\xec\x7a\xc1\x8f\x70\x7a\x96\xeb\x1f\x9f\x3b\x59\x6f\x57\xc9\x52\x4c\x04\x4c\x52\x1f\x49\xf8\xe4\xc1\x5b\x4b\xb5\xe4\x31\xcb\xe4\x45\x8a\x59\xf5\x57\x11\xfe\x55\xc1\x3f\xbe\x8d\x59\x8e\x75\x4c\xa3\x09\x34\xf9\x50\x43\xf1\x6c\x55\x69\x98\x6c\x99\xc2\x3a\xba\xca\x50\x57\xdd\x5d\xc5\xc1\x31\xa5\xa0\x4b\x63\xdc\xa4\xf0\xb6\xaa\xee\x96\xf7\x26\x65\x63\x9c\xd5\xe6\x46\x43\x53\x55\x69\x1d\x14\xe7\xe1\x7b\xb4\x7c\xd2\xf0\x73\xe7\x75\x89\xa0\xfe\xc1\xba\x65\x40\xfc\x11\xa8\x21\x27\x78\x47\x4f\xc8\xdd\xb2\xd2\xa3\xf7\x18\x95\x3a\x73\x04\xd6\xed\x64\x92\xb2\xab\xd0\x4d\x79\x19\x77\xff\xb5\x99\xa9\xa0\x1e\xef\x8e\x44\x5a\x26\x80\xdf\xe2\xc9\x03\x3c\x92\x29\xb8\xa0\x5f\x4c\x70\x41\x77\x93\xef\x78\xc1\xd0\xee\xf9\x0e\xd9\x5a\x47\xf9\x1d\x52\x89\x54\x1d\xb8\x69\x6b\xc2\x44\x69\x0f\x84\xa9\xd2\x5f\x5a\x2f\x22\x87\xb1\xca\x00\xea\x8e\x6d\xb8\xcc\x44\x7c\xbe\xbf\xb9\x5d\xda\x08\x3f\x5c\xa0\x6d\xc2\xce\xdb\x5d\xa9\x69\xef\x62\xea\x31\x23\x2e\xa6\x6e\xbf\x0b\xfa\x48\x19\xdf\x73\x90\x1b\xa9\xf3\xb2\x46\xb9\x5c\xb8\xe7\x40\x25\xf7\xab\x9d\x33\x63\x4e\x7b\xa3\x57\xda\x73\x88\x06\x9c\xce\xba\x70\x9e\xb1\x30\x6c\xb4\xe7\x97\x71\x0c\xb4\xf1\xac\x88\xe3\x5d\xf0\xc5\xbf\xf8\x61\x97\xc2\x3e\x02\x42\xed\x89\x9d\x22\x65\xb7\xe2\xb3\x3f\x88\x54\x62\x38\xba\x33\x41\x03\xb2\x02\x29\x8c\xb9\x42\x23\x8b\x73\x02\xad\x41\xec\xb1\xe3\xcf\xf9\xa3\xbc\xbb\xfe\xb4\xbd\xbf\x7e\xba\xfc\x7e\x19\x69\x7f\x60\x7c\x6a\xb2\x54\x52\x98\xbc\x3b\x14\xcd\x1d\x84\x5b\x3d\x26\xf0\x4b\x33\x27\x7f\x1c\x97\xea\x7f\xe8\x77\x94\xd2\x42\x47\x5f\x0f\x25\x8e\xf0\xca\x46\xb6\xb0\x5e\x75\xc3\xd1\x6c\x37\x2a\x55\x17\xbb\x5b\x99\xcc\x6c\x66\x32\x39\x4e\x5e\x5d\xfa\xea\x6c\x7c\x52\x63\xd4\x5e\xdf\x94\x67\xdd\x3a\xa5\xcf\x85\x7b\x18\x22\x13\x1c\x72\x65\x6f\x55\x4a\x73\x7c\x73\xc7\x9c\x8f\x57\x51\x61\xcf\x34\x06\x4a\x11\xed\x65\xa5\xd3\x1c\xbe\x3d\x00\xb9\xd8\x27\xa9\xee\x11\xb3\xc6\xae\x8c\x5c\x22\x59\x3a\x13\xce\xdf\xbe\x31\x6c\xc0\x65\x93\xd5\xdd\xf2\xdc\x7b\xbe\xa4\x93\x93\x6b\x3d\xe7\xc1\x70\x86\x4e\xc4\x0a\x71\xb4\xaa\x02\x27\xe3\x1a\x20\x55\xc9\xb8\x11\x1b\x23\x66\x72\xa3\x29\x99\x1c\xbc\x26\x4a\xa0\x10\xdd\xe3\x5b\x68\x5e\xca\xe0\x28\x57\x21\xb3\x40\xb7\x45\xf0\x9f\xf0\x48\x16\x10\xfd\x13\x5e\x2e\x9c\x6e\x5c\x6d\x9e\x29\x5a\xb9\x2d\x7c\xa6\xc4\x69\x70\xc5\x52\x76\x61\x97\xe3\x2e\xfa\x11\xbe\xe9\x3d\x58\x67\x70\x16\x20\xeb\xe8\x99\xc9\x45\x4d\x8f\x2e\x22\xf3\x82\x5c\xe5\x2e\x07\xd5\x8f\x09\xd5\x8e\x78\x55\x5a\xca\x0e\x20\xe5\x80\x09\x87\xb6\x07\x61\xb3\x19\xab\x2f\xb7\x2c\x8e\x24\x42\x03\x82\xba\x25\x8d\x09\x37\x7a\x92\x52\xdd\x51\xa7\x5b\x61\x26\xe8\x74\x98\xcb\x46\x93\xbc\xfa\x5b\x59\x2a\x42\xc2\x98\xca\x68\xb2\xba\xea\x80\x0b\x6d\x86\x73\x91\x0b\x02\x50\xe6\x81\x72\x19\xd8\x33\x42\x4a\x01\xa8\x2d\x33\x00\x86\x46\x76\xc5\x14\x65\x17\x94\xc5\x49\x1a\x0d\x55\x5a\x25\xe6\x06\xfd\x10\x6c\x0d\xd2\x37\x06\x03\xd5\x4c\x76\xc4\x19\x8c\x25\x82\x3c\x85\x17\x8f\x96\x54\x4b\x6a\x62\x99\x99\x4f\x58\x51\x8c\x22\xf7\x72\x72\x57\x71\xd3\x43\x00\x65\xd6\x14\x8e\x5d\x71\x07\xd4\x7b\x65\x1e\x6b\xcc\xea\x7c\x89\x7b\x6c\x64\x10\x6f\x96\x9a\xc7\x1e\xb2\x2b\x73\x3e\x4a\x4b\x32\x0d\x59\xa5\x8f\x36\x7f\x1b\x8d\xba\xd0\xaa\x87\x64\x43\xbc\x95\x54\x64\x4a\xb7\xce\x30\x0c\x74\xe1\x99\xcb\x7e\x58\x78\x14\xfb\xa5\x93\xcb\x51\x44\x68\x8c\xc4\x51\x38\x3c\x38\x3f\x06\xb8\x42\x8e\x1e\xeb\x22\xff\x7a\x8f\xa8\x31\x69\x3f\x30\x71\xb1\x60\xe2\xe4\x22\x4f\xd2\xbf\x1c\x9a\x49\xc2\x3b\x06\x4c\x31\x00\x0c\x1c\x68\x59\xd7\xd5\x21\x90\xd7\x8d\x26\xeb\xe2\x5b\xb8\x44\x4d\x32\x91\x4e\x71\xac\xd3\x36\xd1\xa9\x2a\xe0\x08\x53\x9e\xb7\x0f\x96\x4f\x63\x78\x55\x6f\xa7\x21\xb5\x8f\x6f\x63\x60\x12\xfe\x34\x38\x00\x55\x5b\x61\x40\xc7\x02\xf8\xf5\x20\x7c\x82\x5a\x2f\xb1\xab\x11\x6a\x2d\xdb\x16\x0c\x14\x07\x04\xec\x42\x23\x5c\x89\xf5\x4e\xcc\x95\x8a\xda\x67\xa9\xc7\x50\x22\x42\x6c\x34\x11\x97\x1f\x8c\x7c\xec\x3b\x12\xb6\x22\x51\xb4\xa0\x17\x92\x6a\x96\xb5\xb7\xa5\x4b\x06\x46\xcd\x75\x21\x21\x3a\xb0\x1e\x1d\xf7\x1a\xe4\xd8\x05\x2a\x91\x38\x35\x39\x97\x0e\xbe\x80\xae\x6f\xf2\x0c\x58\x66\x8f\x3d\x05\x86\x5d\x48\x99\x4a\xc3\x8a\xa6\xb1\x57\xfb\x9e\xcc\x63\x2d\x4e\xf7\xa6\x75\x51\xd8\xce\xd2\x77\x2a\xb6\x39\x36\x16\x77\x1c\x8d\xdc\x90\x72\x41\x4e\xcc\xa6\x23\xaf\xfb\x41\xde\xf0\x63\x2d\xe4\xc8\x07\xab\xb2\x80\xcf\x70\xd7\x50\xce\x4f\xb8\x00\x59\xc8\xfe\x39\x66\x7b\x20\x73\x32\xc1\xca\xe2\x07\xd7\x64\xda\x4c\xe6\x06\x8c\x0e\x78\x23\x22\xc2\x1a\x78\x2b\x1d\xbe\x42\xa9\xb1\x1e\x2f\x11\x7e\xb3\x6b\x2a\x84\x1b\x50\x25\x0d\x44\xd2\xcd\x63\x82\x1d\x19\xb1\xfb\xb2\x9f\x7a\x6b\xa1\xcd\xd9\x22\x3a\xe2\x47\xcf\x7e\xc3\xea\xb9\x5a\xd5\xf7\xd2\xab\x2b\xa7\x48\x05\xea\x03\xdb\x9d\x32\x65\xf4\xc2\xaf\x0b\x37\x21\xcb\x1a\xd4\xff\xd3\x3b\xf2\x4d\x3f\xe6\xcb\xd1\x03\x23\x00\x50\xff\x08\xa7\xba\xec\xd7\xdd\xae\x87\x65\x8e\x1a\xbf\x74\x0c\xb1\x6e\xba\x3e\xb0\x15\xd2\xc0\x99\x4a\x1c\x11\x5c\x8c\xd3\x84\x4b\x4b\xc8\x54\x6d\xb1\xce\x82\x68\x21\x88\x3e\xc4\x96\x47\x96\xa2\x0e\x6a\x73\x39\x93\x11\x1b\x35\x3a\x72\x72\x46\xf6\x4e\x85\x60\x30\xc8\x58\x7b\x98\x5b\xf4\xc2\x6e\x42\x78\x44\xc0\x13\xaa\x64\x3d\x6e\x05\x07\xe7\x00\x03\xe2\xa9\x58\x2b\xb9\xb1\xd3\x9b\xeb\x2a\x8e\xe0\xd3\xe1\xc3\x0a\xba\xeb\x98\x72\xc3\x9f\x70\xb3\x8c\x0a\xac\x00\xd6\x5e\x18\x73\xab\xc1\x28\x6c\x35\xc6\xbe\x67\xf7\x50\x09\xd0\x0b\x11\x35\x3d\xec\x06\xb4\x04\x27\x4e\xf8\x57\xdb\xdd\x5a\x83\x66\x5b\xd0\xdd\xa4\x30\x0c\x6a\x2e\xd7\xa7\x8c\x15\xce\x59\x99\x0b\xb5\x8d\x80\xaa\x62\xb0\x45\xd1\x1f\xaa\x90\xd3\xd4\xc9\x84\x49\xba\xaf\x06\x59\xc1\xa2\xe1\x40\x8a\x47\xe4\x79\x34\xbe\xe7\x45\x48\x64\xaa\x7a\x35\x82\xf2\x61\x03\xa9\x27\x6d\xff\x3a\x1a\x48\xa1\x72\x7b\x0b\xb5\x2e\x09\xa4\x5a\x76\x97\xd3\x44\x27\x0e\x09\x4e\x40\xa3\x35\xe4\x86\x35\xde\xf7\xb2\x8a\x6d\xfb\x97\xf6\xd3\x6e\xbb\xcc\x21\xf6\xc1\xfa\x4b\xae\x32\x9c\x03\x38\x40\x65\x37\x02\xbc\xcf\xa7\xb0\x37\x39\xee\x03\x40\x20\xe4\xda\x1a\x35\xec\x4e\x38\x67\x0d\xc7\x96\x4f\x97\xb4\xc0\xf4\x5c\xc3\xd5\x94\x44\xca\xa5\x88\x68\x76\xdb\x03\x5b\x85\xd6\x7b\x15\xbd\xf4\x51\xeb\x45\x87\xa9\x0a\xad\x01\xf5\x36\x6d\x65\x98\x9b\xef\xad\x4f\x1d\xc3\xa5\x8b\xce\x4a\xc5\x7b\x83\x26\x8a\x7d\x7c\x5b\x58\x6e\x9d\x3c\x44\xb0\x24\xa3\x10\xf7\x48\xb0\xd6\xc4\x11\x27\x54\x4e\xa6\xdb\xc0\x2b\xc9\x8d\xd0\x91\x41\x3d\xa4\x64\xe9\xf0\x75\xe7\xaa\x1f\x93\x06\x39\xe2\x11\xf6\xb1\x85\xe6\xa3\xc1\x9b\xa5\x0a\xa3\x20\xdf\x06\x19\xcf\x88\xba\x43\xaf\x46\x3f\x47\x07\x78\x7a\x59\x59\xef\xc1\x49\x97\xee\x79\x6c\xab\xea\xeb\xa4\x20\xbc\x2e\x0a\xb2\x13\xc8\x16\x8a\xba\x20\xc6\x23\x9c\x9f\xbb\x3b\x8f\x10\x5c\x3f\xf9\x6c\xab\x2d\x2f\x51\x51\xc0\x11\x45\xcc\x47\xba\x8f\x06\x35\x01\xfe\x2e\x64\x0f\x52\xbd\xc5\x81\x61\xa8\x4b\xe4\xae\xd3\x67\xb8\xc5\xf0\x0d\x4e\xd0\xcd\xc0\xd3\x78\x94\x63\x20\x3c\x7e\x51\x50\x3d\x39\x08\x01\x63\x28\xa5\x39\xa4\x41\x50\x17\x9a\x1e\x20\x02\x60\x7e\x29\xa4\xb9\x49\x20\xad\x57\xe8\xe6\x60\x8e\x9d\x4e\x27\x48\x03\xc8\x37\x7c\xd8\x49\x51\x9a\x3a\x2f\x22\xc4\xa3\x0e\x2a\xef\x83\x8b\x03\x77\xc3\x85\x70\x12\x33\xce\x48\xbf\x36\x85\xf5\x97\x53\x11\x35\xdc\xc2\x53\x44\xb0\x4a\x74\xfb\x2a\x87\xd2\x75\xda\x17\xbc\xd2\x16\x57\x5b\x2e\xe4\x94\xe1\x0c\x88\xc7\xf0\x05\xce\x33\xc8\x91\x43\x1e\xb1\x0b\xf2\xb1\x67\x16\x86\xd3\x41\x1f\x07\x15\xd1\xc4\x7d\x70\x57\x93\x79\x72\xa1\x19\xf0\x82\xb2\x32\x88\x97\x4b\xb2\x00\xd3\xc6\x46\xfe\x1d\xd7\xb0\xcc\xae\xab\x21\xd9\xab\x1e\x23\xab\x39\xb4\xe7\x2c\x90\x5b\xd4\x4d\xee\x44\x08\x38\x00\xd7\x98\x28\xc0\x1c\xf7\xfc\x61\xff\xe5\xe6\xfd\x12\xe8\xd9\xc7\x39\xbc\xfb\x45\xc7\xa0\x9f\x02\x5c\xc2\x4e\x93\xf4\x34\x6f\xa7\x5d\xe1\x82\xd0\xb8\xab\xa8\x8a\x1a\x91\x26\x3c\xff\xc6\x7b\x5d\xf5\xb4\xf3\x5e\x27\xaf\x51\xf4\x50\x62\x65\xe2\x2a\xd7\x04\xd8\x35\x21\x93\xde\xf6\x39\x67\x8d\x32\xe1\x8d\xa2\xeb\x20\xfb\x19\x7c\xfb\x4f\x36\x32\x08\x77\x74\x7b\xe5\xaf\x84\x4f\x95\xbf\x43\xeb\xf8\x5f\xb6\x75\xa6\xd1\xff\x5d\xee\xee\x2c\xc2\x09\x77\x1e\x3a\x11\xe3\xfe\xd3\xb4\x1f\x53\xc6\xa9\x38\x4b\x50\xd0\x6d\x65\x1d\xa1\xea\xb0\x5d\x57\xb1\xe0\x77\x29\x12\x42\x63\xca\xbe\x59\xca\x2a\x30\x93\x72\xd0\x50\x04\xbb\xc5\xfe\x0f\x7a\x65\x25\x3f\x09\x6a\xe0\x97\xdc\x94\x89\x07\xb1\xa5\x38\x05\x7c\x72\x0a\x94\x90\xe3\x1c\x84\x95\x53\xf0\x96\x3d\x10\x7e\xa2\xc6\x9b\x83\xe4\x57\x88\x46\x7a\x89\x23\x0f\x1a\x18\x8d\x50\x1b\xd4\x7c\x48\x50\x28\x4b\xa3\x37\x55\xeb\x37\x16\x34\xa8\x5e\x51\x93\xbc\x6d\x66\x7e\xc9\x1c\xaa\xea\x57\x4a\xed\x9e\x0a\x56\xc5\xd1\x39\x6f\x1e\xb9\x39\x12\x0e\xac\x34\x94\x09\x5e\xa7\x58\xdd\x97\x7b\xaa\x13\x47\x3a\xba\xda\x0b\x19\xef\x7b\x00\x9d\xf7\xbd\xaa\xce\xce\x28\x6b\xa4\x9e\x07\x0a\x07\x05\x02\x05\x71\x11\x42\x10\x7a\x85\xbe\x4a\x57\x7d\x22\x6f\x21\x5e\x22\x47\x93\xdc\x94\x9b\x86\x8f\x31\x90\x87\xeb\x84\x6d\x53\xe9\x43\x05\xbd\xce\xae\x29\x9e\x9b\x6c\x73\x3f\x8e\xfb\x36\xf5\x77\x1e\xc2\xae\x0f\xcb\x81\x7b\xe9\xbd\xeb\x63\x3f\xcc\x45\x9f\x9d\x79\xc2\x2e\xd2\xaf\xeb\xe1\xe6\xe3\xed\x4f\xc3\xf6\xc3\x92\x57\x39\x97\x1a\x54\x79\x95\x2a\x23\x71\xc7\xa9\x19\x96\x91\x86\x29\xad\x83\xaf\xcc\x29\x20\x8e\xfd\x94\x50\x7a\xc5\xfb\xb4\x43\xbf\x00\x03\xed\x42\x5b\xae\xd8\x57\xb4\x25\xa5\x57\xdb\x4a\x29\x50\x4d\x76\xa5\xad\xcd\x51\x63\xd1\xaf\x26\xd5\x3c\xd3\x98\x94\x5e\x6d\x4c\xb3\x0b\x85\x70\x79\x64\x22\x84\xbe\xbc\x31\xe8\x50\x5f\xe7\xc3\xab\x7b\xe0\xdd\xf6\xb6\x2d\xd3\x23\xf9\xa5\xcb\xe1\xef\x78\x17\x9c\x49\x76\xba\xde\x94\x14\x7e\xe5\x1e\x98\x5a\xda\x5c\x08\xa3\x5d\x1f\x16\xcc\x2d\x5f\xbd\x07\x52\x78\xc5\xe6\x96\xc2\x5f\xb5\x03\x56\xd2\x1e\x7f\xb0\xfe\x5c\x66\xdf\xef\xbe\x01\x32\x30\x95\xbe\x0f\x19\x90\xb6\xbe\x1b\x19\x50\x90\xc7\xdf\x09\x19\xf8\xb7\x2f\x0f\xed\xe6\xc3\x22\x9b\x9d\x3f\x97\xff\xfa\xf7\xb9\x0d\xbe\x61\x5b\xcf\x6f\x83\x6f\xd8\xd8\xf3\xdb\xe0\x9b\x34\xf6\x5c\x3c\xe5\x62\xf5\x2f\x39\xd4\xb9\x98\x14\xca\x75\xc2\x8a\x3d\x6b\x8e\x54\x8c\x8a\xb3\x21\x3d\xd5\x9d\x8b\x69\xbb\x1c\x2f\x2b\x1d\x40\x48\xdf\xf7\xec\xc0\xe6\x69\x0f\x00\xe0\xf5\xb7\x9a\x02\x4d\xad\xf1\xb2\x45\x00\xc6\xda\x57\x75\xc1\x87\x8b\x00\xf3\x0e\x88\x3e\x39\xfd\x8d\xa7\xe1\x85\x5b\xe1\x95\xd3\xb0\x39\x9d\x87\xe7\x3a\xf1\xc2\xdd\xf0\xab\xd6\xe2\xb9\x3e\xbc\x74\x2d\x9e\xed\xc4\xe6\xeb\x7a\x71\x19\x30\xe5\xfd\xf6\xb6\xad\x0b\x1e\x97\xb2\xe2\xf8\x12\x74\x6e\xa7\xd0\xa6\x33\xc3\x3a\x0e\x6f\x1a\x8c\x2b\x85\x5c\x29\xa3\xa9\x54\x09\xc1\x4e\x4d\xfe\x19\xa6\xdf\x6b\x87\xc4\xf9\x46\x27\x2c\xbb\xf2\x95\xab\x9a\x5d\xb9\x18\xbc\xfb\x8a\xfd\x6d\xcb\xd7\x76\x42\xde\xfc\x36\xdb\xfb\x57\xf5\xe1\x62\x2e\x8b\xd7\xec\xef\x6f\xb9\x1c\xaf\xdb\xde\xeb\x1c\xf5\xa5\x74\x39\x7e\x4e\xaf\x70\x88\xda\xd3\xfd\x6b\xfa\x06\x9e\x01\xc0\x2e\x8c\xa9\x07\x39\xae\x8c\xe9\x28\x48\x70\x98\x6b\x45\xa5\xc7\x90\xe3\xff\xbe\xcf\xff\x7d\x9f\xbf\x68\x9f\x7f\xb8\x7e\xb7\x6d\x37\x9f\xb6\x3f\xed\x6f\xde\x6f\xef\x16\x3b\x7d\xe9\x3a\xfc\x54\x68\x38\x89\x7d\x0b\x4e\xed\x8e\xb1\x9e\x89\xc6\xea\x60\x7e\xd6\x53\xb0\x7e\x2f\xcc\x30\xa6\x04\x76\xca\x33\x7e\x58\x1d\x81\x52\xbd\xb8\xce\xf8\x64\xed\x7b\x42\x13\xae\xb4\xea\x9d\xb5\x03\x74\xe6\x25\x3f\x30\xe9\x4b\x1c\xb4\x63\x6e\xe4\x32\x87\xd9\x75\x70\x4e\x19\xc5\xe6\x15\xf0\x39\x9f\x6f\xde\xb5\x2f\xf7\x8b\xc0\x16\xbf\xf4\xeb\x3c\x38\xac\xa5\x60\xa9\x27\x22\x80\xba\x5f\xd1\xea\x9b\x99\x40\x16\x8d\xa2\x2c\xb6\x0e\xbc\xd8\xfa\x47\xff\x75\x2a\xd5\x5f\x3b\x71\x33\x0c\x45\xf5\x1d\xb2\x87\x86\x8e\x37\x38\x70\x82\x92\xd9\x0e\x91\x1d\x45\x76\xb2\x59\xd5\xf9\xcb\x4e\x99\x55\x2f\xc1\x47\xb0\x9b\x9d\x17\x57\xf1\x23\xa4\x82\x75\xfc\x88\xbd\xbc\xba\x39\x8b\x5d\x71\x9a\xff\xb5\xb7\xf2\xfa\xfc\xaf\xfa\xe2\x37\xca\xff\xfa\x79\x7b\xfb\xee\x66\x91\x80\x23\xd8\xc9\x42\xe4\x93\x27\x3b\x54\x86\xdf\xbf\xf3\x91\x9c\x8f\x03\x82\x07\x2a\xcb\xf1\xc8\xbb\x39\x2a\x8b\x6d\x7e\x7c\x5b\x4a\xa2\xaa\x02\x9f\xba\x88\x00\x5d\x40\xad\x16\x99\x4c\x1e\x4c\x94\xb3\x14\x83\x43\x8e\x02\xfd\x3f\x2c\x6a\x5a\x58\x3e\x46\x94\xe7\x4c\x79\x90\xc2\x52\x36\x93\xfc\x8f\xa5\x01\xef\x00\x4f\x3e\x04\x96\x99\xe3\x34\x18\xf9\x49\xfe\x01\x2a\xf2\x3e\x70\xea\x41\x1b\x93\xaa\xfd\x38\x10\x82\x35\xb0\x3b\x0d\x52\x96\xe4\x75\x46\x0c\x78\x1c\x7d\xd2\xf8\x0b\xf2\x65\xa3\x5e\x85\x9a\x5e\x61\x90\x51\x1b\xe7\x5f\x13\xad\xf0\xe9\xfa\xf3\x4f\x9f\xae\xef\xff\xbc\xd4\x5a\x86\xa5\x7f\xdf\xc1\x41\x03\x48\xf6\xb3\x4b\xe4\xaf\x4f\x5b\x01\xe4\xfa\xc9\x39\xb3\xa3\x39\x70\xae\x9a\xeb\xde\xe4\x1c\x34\x73\x84\xc7\x76\x81\x79\xc5\x75\xc7\x2a\x38\xfc\xe2\x1b\x3c\x80\x11\x73\xef\xe4\xbd\x48\x78\xcd\x7b\xb8\x31\x79\x0f\x34\x29\x4b\x8e\x1d\x71\xb4\xe4\x93\x6b\x3e\xe1\x3b\x3e\x0f\x29\x86\x7c\xba\xec\xcf\x72\xfd\xfe\xdf\xbe\x2c\xc5\xfb\xe0\xfe\x70\x34\x37\x35\xed\xfb\x85\xf6\xd5\xc0\x8f\x7f\xbf\x40\x8e\x6d\xc5\x4b\x3c\x5c\x72\xf7\x11\xea\xa7\x71\xd7\xc8\x02\x62\x29\x55\x00\x0d\x93\x7a\x01\x74\xda\x04\x5f\xaf\xd2\xd4\xd6\xda\x8c\x53\x57\xcf\xd1\x04\xb8\x31\x3a\x26\x4e\x4d\xb1\xe4\x7b\x56\x11\xdf\x53\x4c\x68\x50\x6c\x24\x83\xd7\x30\x34\x5f\xba\x87\x41\x87\x8b\x73\xba\x45\xf0\x99\x6a\x3f\x8a\xaf\x09\xbd\x92\x0d\x3c\xa5\x28\x67\xdd\x4d\xd8\x49\xcd\xcc\x9b\xcb\x4c\xdb\xcd\xf4\xfd\xa7\x49\x17\x22\x15\x26\x97\xe3\x98\xa8\x52\x72\x53\x68\x18\x5b\x26\x8e\xdc\x34\x80\x27\x97\x56\x3c\x39\xcb\x57\x71\xac\xe4\xe1\xc8\x1f\x72\x8b\x4c\x2c\xff\x5e\x75\xf4\x48\xf5\xe3\x42\x72\x46\x53\x3d\x21\x75\x86\xbc\xa3\xb5\x18\xa9\x46\x5d\x0c\x23\xb7\xe4\xa6\xd1\x8d\x85\x35\xc6\x59\x3e\x5d\xbe\xbc\xb8\xdb\xf7\x37\xcb\xc5\xbd\xe4\x92\x53\x4a\x21\x1f\xdd\xc0\xac\x78\xd5\xb0\x05\xb3\x9c\x51\x00\xc1\x30\xa7\xbd\x89\x69\x87\x54\x0d\x69\x17\x85\x24\x7a\x57\x88\x2d\xc0\x93\x12\x4d\xe7\x9e\x07\xe3\x31\xa9\x51\x31\x0c\xf5\x3f\x58\xf7\xe4\x70\x0f\xf2\x50\x9e\xb1\x50\x5f\x62\xf2\x53\x76\xa1\x90\xc1\x03\xdb\x17\xb0\x39\x45\x2d\xc1\x97\xd8\x9c\x0e\xf9\x74\x96\xcd\x41\x36\x89\x74\x88\x27\x53\x17\x62\x0d\xea\x72\x7e\xf4\x34\x01\xd6\x38\xe1\xc2\xaa\x1a\x73\xe1\xbe\xaa\x2e\xa6\xa6\x20\xa0\x23\x81\x53\x4b\xbd\x4b\x87\xeb\xd5\xf4\xfb\x55\xfe\x98\xf1\xa3\xf4\x86\x35\xd3\x15\x2b\xf7\xb2\x3c\x99\xaf\x58\xbd\x61\xf5\x4a\x9e\x84\x1a\x72\x6e\x40\x98\xbb\xf4\x0f\x41\x50\x94\x11\x2a\xe0\x6a\xc7\xe9\x94\xeb\x7b\x96\x6f\x06\x93\x00\x3d\x94\xdd\x4e\xfe\xdc\xbb\x82\x64\xaa\xc2\xff\xd8\x12\x06\x53\x1d\x99\xea\x36\xb3\x9a\x60\x10\xc6\xdf\xad\x26\xb7\x7c\x12\xa5\x30\xc5\x53\xbc\x00\x39\xe9\x61\x77\xbd\xe4\xe7\xc2\x0b\x52\x5e\xe4\xbd\x71\x08\x80\xff\x0e\x1b\xc0\xc5\xb8\x3f\x8f\x5e\x36\xb9\xc2\x02\x20\xdd\x21\x62\x4f\x75\xd4\x1e\xf9\x48\x14\x19\xa2\x3b\xde\x85\x9d\x61\xfe\xda\xd5\xdf\xac\x2d\xbf\xa6\x4d\xe5\x2a\xbb\xd1\x55\x59\x01\xf6\x14\x35\x02\x10\x27\xcd\x47\x2a\xa3\x03\x42\x36\x6c\xf2\xb2\x17\x92\x30\xe1\x36\xf8\xc1\xf8\x22\x7b\x14\x78\xc6\x27\x10\xe1\x73\xf2\xa7\x48\x8a\x39\xc0\xb9\x63\x0e\x08\xb7\xdb\x63\x7b\x7c\x0f\x53\x42\x34\x9a\x67\x9d\x66\x05\x85\xcc\x41\x7a\x8d\xc3\xe1\x3a\x11\xf6\x9a\x1d\xc4\xa9\xa7\x85\x9b\x60\x68\x9d\xf0\xdb\xea\x42\x13\x40\xdd\x3d\x77\x84\xa9\xa4\x59\x5b\xe4\x6b\xd5\xc0\x33\x8f\x74\x49\x1c\x9a\x81\x7b\x1b\x23\x27\x53\xa8\x24\x2b\x55\xb9\x71\xa0\x6a\x9b\x2b\x54\x8a\x4c\x4f\x61\x78\xf1\xaa\xbf\x09\xbc\xb2\x93\x7a\xc8\xc0\x8b\x1e\xde\x7d\x70\x45\xd0\xa0\xc1\xaa\x11\xb1\xc2\xca\x4e\x49\x81\x5d\x07\x7a\x90\x19\x25\xcc\xc4\x91\xd1\x60\x98\xa7\xae\xe3\x6a\x9e\x82\x63\x5e\x8e\xbb\xd9\x6d\x97\xb8\x6a\x61\xe9\x59\xf0\x64\xd7\x27\x9b\xf6\xc6\x73\xf9\x6e\x64\xef\xf5\x54\xaf\xbb\xc4\xca\x9a\xb3\xec\x10\xb8\x3f\x21\xe2\xe0\x15\x04\x70\xf3\x3a\x0a\xe8\x62\x58\x52\x40\x3b\x01\xcd\x5a\xb8\x48\xc2\xb9\x07\x1e\x9a\xc0\x80\xef\xc7\x00\x51\xba\x35\x0e\xa6\xc8\xde\x2b\x1c\xe0\x4c\x8c\xff\xa2\x8c\x39\x34\xf9\x44\xa8\x9e\xb7\x14\xe0\xda\x12\xa8\x17\x89\xb9\xe1\xdf\x81\xa5\x31\xb6\xa3\x3e\xc2\x0b\x4d\x5f\x1f\x5c\x92\xcd\x9f\xfc\x90\x42\xa6\x24\xd7\xf8\xb2\x0c\x63\xd2\xd8\x6e\xc6\x5e\xb1\x36\xdf\x7a\x37\x2e\xf3\xfa\x2b\xa9\x96\xc3\xb3\xbe\x09\x13\x03\x3a\x1b\xd2\x06\xe3\x22\x42\x65\xd2\x33\x28\xb1\x80\xb6\x98\x00\x35\x44\xfa\xba\x08\x0f\xfb\x4c\xa5\x5a\x60\x7a\xde\x8b\x4c\x50\xad\x07\x5b\xf4\x11\x8a\xc7\x59\x0b\xe0\xe5\x1a\x37\x1d\xfd\x75\x7a\x78\x16\xef\x47\x65\xc9\x19\x39\x04\x8e\x7f\x67\xb1\x64\xcf\xd7\x36\xcc\x03\x5f\x25\x0d\x27\x76\x79\x9d\xc9\x0e\x1b\xb2\x30\x55\x5e\xae\xf0\xf2\xcd\xda\xb6\x9f\x7f\xfa\xf9\xfa\xdd\x9f\x7f\xb9\xbe\x5f\x04\xc8\x84\xa5\xfb\xc2\x81\x77\xaf\xb9\x12\xfb\x1a\xfb\xc8\x44\xe6\xf5\x0d\x3e\xa2\xee\x90\x70\x51\x6f\x38\xf9\xad\x21\x8c\xc6\x0f\x26\xb3\xa5\x2c\xa7\x1e\x5a\x53\xf6\xc4\x75\x6f\x52\xbe\xe4\x95\xb0\x6e\xb3\x0d\x76\xdd\x2b\x61\x35\xe1\x84\x34\x10\x48\x3d\x30\xf9\xb2\xfa\xe8\xc3\xf5\x43\x3b\x3f\x25\x97\x4d\xf9\x42\x6b\xbe\xd5\x9c\x64\xb6\xbf\xe3\x29\x1c\x7a\x27\x36\xab\x63\x95\xde\xbd\x70\xba\xcf\xce\xf4\xd2\x6c\x7e\x0c\x9d\xc0\xdf\x70\xf7\xbd\x60\xa6\x97\xa4\x67\x9a\x80\x5f\x3b\xfe\xcf\xc3\xf5\xc2\x61\x24\x2c\xad\x78\x47\x79\xf0\x15\x02\x19\xd9\x36\x1d\xb0\xf4\x55\x72\xd0\xbe\x83\xe1\xf4\xdd\x5d\xde\xa7\x29\x95\x29\x02\x13\xf0\x4b\xeb\x45\x86\xc3\xdb\xfd\x65\x00\x46\xb1\xc2\x1c\xfa\xcb\xda\xa3\xcf\xd7\x5f\x1e\x96\x57\xca\xbb\x53\x84\x7a\x75\xc7\xd0\x3d\xb6\xba\x2f\x45\x6e\x7e\xf9\xbe\x94\xd2\x6b\xbe\x1f\xc0\x46\xfa\x3e\x6d\x5d\xa6\xa4\x77\x0b\xf8\xba\xf0\xfe\x95\x33\x72\xde\x31\x6e\xfd\xa8\x9e\xf1\x8c\xbb\x1c\xd2\x7b\xbf\x7a\xdc\x96\xda\xf1\xc3\x71\x43\xed\x1c\x0f\x37\x34\xd2\x3b\x20\x3a\x8c\x80\x53\x34\xef\x31\xf9\xbb\xe9\x53\x1c\x10\x9c\x04\x98\xc8\x90\x3d\xaa\xee\xf5\xac\x9d\x2d\xba\x7a\x15\xea\x39\x34\xd3\x41\x5c\xe9\x01\x1e\x85\x1e\x68\x85\x86\x9e\x27\xf1\x67\x26\x22\x2e\xe3\xda\x0f\x14\xfe\xfb\x4d\xc4\x71\x51\x25\xed\x2f\x24\xd3\x17\xb7\xd7\x99\x8b\x40\x1a\x38\x9d\xbe\xc3\x94\x6f\xbe\xd1\x9c\x83\xd3\x38\x37\xe7\x97\x54\xce\xdf\x70\xce\xff\x06\x13\x79\x59\xa7\xf6\x6f\xdb\x77\x0b\xa5\x5a\x5c\x86\x25\x47\x3f\x13\xff\x40\x31\xe6\x27\x77\xcf\x09\x13\xb8\x38\x4a\x87\x1b\xcd\xb0\x9f\x60\xc1\xdd\x94\xdc\x45\x2f\x2d\x0f\xa8\xc7\x0c\x74\xb7\xb3\x34\x48\x38\xcb\x97\x92\x20\xa0\x4e\xac\xcf\xde\x73\x32\xef\xfe\xfe\x6e\xdd\xa9\x3e\x2e\x55\xc9\xc7\xc0\x2c\x99\x89\x61\xfa\x89\x1e\x99\xe8\x79\x98\xbe\x9c\xa3\x2a\x93\xa5\xe5\xac\xe4\x91\x83\xa3\x1c\xdc\xfa\xf5\xdf\x9f\xad\x2c\xc1\x5c\xef\x57\xc9\xfc\x18\xff\xaa\xf3\x43\x5c\xaa\x5b\x8f\x27\xc0\x66\x4a\xb1\xf7\xda\x4c\xdd\x5e\x1b\x96\xda\x93\x56\x05\x2a\xcc\x99\xcc\x9d\xe9\x5f\x56\x0b\x4d\x15\xac\x6d\xbf\xa9\xf1\xd7\x8f\xfd\xf3\xf0\xe5\xe1\xa7\x87\x9b\x8f\x0b\xe8\xde\x38\x47\x83\xb1\x63\xa0\xc0\x1c\xc4\xa0\x13\x24\x18\x4d\x5e\x3b\xef\xd3\x27\xcf\x4e\x0f\xed\x11\x60\x8c\x42\xa4\xa8\x0c\xba\xfe\xfc\x20\x52\x9e\x60\xcb\x20\xf1\xdd\xd1\x4e\x3f\x7d\x78\x4c\x58\x26\x04\x1a\xc0\xe1\x1c\x67\xc5\x7b\x92\x7e\x70\xdd\xea\xb3\xf9\x5d\x9b\x7d\x3e\xdd\xdc\x9e\x5b\xb8\xf4\xe2\x85\xcb\xe9\xec\xe2\x9c\x9b\x7c\x79\xe5\x55\xd3\xf8\x37\x99\xc5\xcd\xcb\xd3\x3e\x7d\xba\xdb\x6f\xd7\xe7\x31\x1f\x92\x78\x85\x4a\x81\xc3\xf1\x1c\x0e\x30\xbb\x72\xe1\xa1\x7f\xf6\x73\x39\x41\xd1\x22\x64\xbc\x52\x48\x83\xa9\x96\xea\x41\x9a\x01\x40\xef\xe9\xac\x6b\x5d\xf2\xcf\x5c\xeb\xa1\x78\xd4\xe2\x13\xb8\x2f\x8a\x57\x84\x97\x1f\x48\x8d\xd6\x7b\xb2\x5e\xc3\x69\x95\x66\xaa\xf3\x88\x3c\x75\xed\xb8\xbe\x3c\xf4\x3a\x27\xaa\x83\x96\x36\x47\x4b\x3d\x1c\x8f\xd7\xf4\x01\xeb\x5c\x40\x2b\x8d\x1e\x62\x70\x83\x0e\xf8\x30\x1f\xe9\xf7\xb7\x41\x5e\xba\x3f\xee\xfe\xbc\xbe\x37\xca\xe1\x8c\x95\x40\xc5\x82\x1b\x42\x78\xaa\x2e\x39\x9f\x2c\xf9\x31\x60\xd6\x60\x90\xb2\x39\xd8\x3c\x18\xe7\x12\x39\x97\xce\x15\x84\x3b\x85\xed\xfa\xff\xfe\x5f\x5f\x66\x55\xf6\x86\x38\xc0\xe0\xe9\x93\x3b\xbf\x1a\x31\x78\x8a\xc1\xc3\xc7\x07\xff\xff\x16\x07\x76\xf3\xb7\x5a\x90\xf1\xcb\xf6\xa1\xdd\xdc\xdd\xae\x2f\x4b\x3d\x4e\x50\x7d\x30\x17\xa8\x63\x62\xcf\x26\xb0\xc8\x4a\x69\x90\x4e\x00\xe9\x07\x26\x97\xb5\xa0\xce\x85\x9a\x70\xf2\x24\xbf\x68\x85\x1f\x6e\x47\x25\x56\x3d\x7d\x29\x9a\x21\x8a\x38\x81\x41\x56\x4b\x48\x6a\x80\x63\x0a\x3c\x1a\x17\xa0\x6c\xf7\x19\x58\x48\x5e\x73\xfe\x39\xc0\xa3\x04\x37\x20\xc3\x09\x5b\x3b\x66\x32\x7a\x7a\xd3\x08\xfb\x0b\xb2\x1a\x8e\xd1\x53\x2a\x04\xf7\x99\xd1\x43\x03\x5d\x12\xb9\xa0\x78\x18\x3a\x97\x2e\x75\xe0\xd2\x58\xa1\x9f\xf7\x3d\x45\x67\x62\x05\x4e\x0b\x8a\x77\x04\xa3\x9f\x02\x7a\x9b\x82\xb0\xdc\x9e\x09\xd1\x45\x24\xa5\x48\x2f\x1a\xba\x9a\xb4\x80\x07\x14\x10\x4d\x1b\xfa\xb7\x51\x18\xdb\x02\x00\x06\x00\x0f\x25\xf2\x1d\x2a\x2a\x20\x53\x4b\xb2\x53\x0c\x34\x9c\x50\xbe\x25\x41\xd8\x7c\xd7\xc4\x99\x1f\xee\xd6\x37\xdf\xf5\x51\xf2\x4c\xcd\x58\xa4\x40\x76\x4f\x77\x5f\x4d\x7b\x75\x5e\x78\xfa\xe0\x34\x67\xfa\xf1\xb6\x4c\x76\x65\x6d\xaa\x66\x3b\x96\x0a\x5f\xf3\x5a\x08\x65\xb1\x9b\x71\x5c\x6c\x4c\x67\x7a\x7c\xfe\xbc\x9c\xb6\xb0\xb9\x74\x60\xfe\x4e\x6f\x80\x87\x77\xf7\xdb\xed\xed\xc3\xee\x6e\x29\x19\x1c\x25\xc7\xad\x99\x22\xbb\x9d\xe2\x15\xbc\x38\xd8\x09\xe0\x06\x8e\x80\x56\xa4\x99\x00\x14\x1e\x5f\x51\xf2\x35\x39\xc0\x1e\x75\xbe\x56\xc9\x6c\x61\xf1\x2b\x5d\x6e\x2f\x8a\x0b\xd6\xb1\x3e\x14\x87\x00\x3f\xa2\x0b\xab\x72\xf8\x85\x80\x2e\x5b\x37\x9a\x6a\xd4\x16\x3a\xae\xac\x1d\xb7\xb3\xd7\x5e\xbf\x54\xec\xb7\x75\x94\xea\x40\x42\xe6\xa1\xb7\xa3\x39\xe9\x1b\x28\xdb\x67\xa2\xcd\x82\x1f\xe1\xd4\xa7\xf9\x0e\xa3\x5a\x61\xb3\x06\xcc\x67\xed\x9e\xfc\xb8\x47\xc9\x57\xab\xee\xfd\x66\x44\xcd\xd2\x82\x56\x87\xda\x5a\x6f\x09\x3f\xf5\x4e\xbc\x3c\xd0\xd6\x8f\x3e\x23\x3f\xe3\x51\x25\xed\xa8\xf6\xbd\x76\xf5\xc5\x1a\x14\x3f\x62\xf0\x3e\xd3\xf1\x88\xdb\xf1\x64\xa0\xd5\x57\xea\x30\x3b\xab\xbc\x9e\xf1\x36\x1e\x65\x0e\xae\x99\x02\xd2\x5b\x82\x89\x0c\xe9\xa9\xed\x19\x54\x85\xad\xe6\xa8\x64\x9f\x8f\x92\x55\x9e\x2d\x29\xac\x4c\xaf\xa9\x17\x71\x1e\xc0\x01\x7e\x38\xa9\x65\xaa\x64\x51\xa8\x57\x70\x64\x7c\x6e\xda\xc6\x94\xe0\x34\x4f\x15\xad\x96\x99\x86\xd2\xeb\xd5\x2e\x76\x34\x06\xbf\x39\x8c\x60\xae\x6d\xbd\xe4\xdf\x36\x29\xef\xb7\x26\xbd\x9b\xef\xc0\x7d\x9f\xd9\x6e\x47\x09\x96\x33\x53\x76\x7e\x30\xc1\x39\x64\xd0\x38\x6f\xd2\xae\x81\x5c\x0d\xeb\xca\x15\x0b\xd4\xba\x55\xc5\x12\x7c\x1d\x42\x1e\x5c\x8e\x70\x1d\x5c\x2b\x63\x41\x0f\xcf\x29\x60\x7e\x93\x55\xdf\xfc\xad\x96\xfd\xb7\x5e\xf5\x9f\xaf\x6f\xcf\x2d\xfb\x21\x1d\xb3\x4e\x28\xb8\x51\x21\x76\x25\x93\xab\x71\x30\x39\x06\x32\x39\xfa\x11\xe7\xb0\x54\x72\x15\x9f\x23\x03\x54\xcd\xb1\xe2\xdf\x20\x7f\x97\x57\x3e\x1d\xf7\x4c\x22\x20\x5f\xb6\xe0\xc9\xb1\xe6\x3c\x65\x4f\x3e\x84\x21\xc7\x48\x39\x22\xde\x30\xaa\xeb\xb7\xb5\x54\xf9\xac\xb3\x71\x9d\x56\x4c\x43\xa2\x92\xa3\x02\x4f\x9c\x3a\x2f\x88\x42\x04\xc5\x8c\x4c\xe3\x52\xdd\x0c\x0a\xe8\x42\xd2\xe4\xc8\x06\xd9\x91\x9d\xa6\x6c\x46\xc6\x64\x85\xba\xe3\xcd\x49\xf2\x64\x64\xf1\x93\x77\xe4\x4a\xb2\x56\xd3\x27\xd7\x39\xf3\xb3\x0b\x53\xde\xda\x9e\x44\x19\x55\xb4\x43\xb5\x73\x53\x73\xfb\x40\xca\x85\x2f\x5a\x7d\x0e\x87\xe5\xfe\xfe\xee\x97\x55\x95\x71\xb2\x27\x06\x38\xc0\x49\xf7\x2b\x1b\x2e\xf7\xb3\x2b\xec\x84\x45\x2c\xc2\x0b\xa2\x5e\x06\x57\x81\x76\x14\x80\xa2\xae\x9e\xf7\xc0\xd1\xd3\xcf\x01\x1e\xee\x39\xe9\x0d\xaf\xae\xfb\x3d\xb5\x02\x3c\xe2\x2a\x23\xb5\x42\x8a\x4c\x29\x3a\x94\xea\x05\xa7\x4c\x05\x9a\xa8\x40\x0b\xd8\x51\xd3\x14\xc8\x5b\x65\x44\x0d\xa8\xae\x0c\x68\xa5\xf7\x41\x33\x19\x54\xee\x7d\x60\x21\x23\xe8\xa3\x47\x8c\x0d\x5e\x3b\x8c\x62\xd3\x0e\xa3\x7b\xc1\xec\xad\x2a\x9c\xd3\x21\xe3\x74\xc8\xae\xc3\x6f\x1b\xc0\x4f\x66\xed\x81\xf4\x5f\xfe\x59\x49\x31\xc1\xc7\x29\x26\x64\xe3\xce\xc9\x18\x30\xd2\x86\x7f\x31\xcd\x32\x02\x8d\x34\xd2\xc9\xc3\x20\x7a\x42\x8c\xc9\x2f\xba\x73\x2c\xd1\xd3\xfc\x53\x9b\xcb\xc9\xf8\x75\x36\x40\x54\xa5\x19\x05\xdf\xad\x16\xcd\xd8\x41\x3b\xd0\x67\xd9\x62\x96\x8f\xe2\x27\xe6\x51\x60\x8d\xa2\xc6\x4f\x5c\xce\x9e\xa3\xb3\xb6\xcc\x58\x96\x96\xd6\x9b\x13\xb7\x05\xa6\x98\x14\xf8\x93\x0f\x21\x1f\x58\x65\x9d\x9f\xbe\xb6\xf2\x39\x1a\xa4\x9c\xc4\x1c\x96\xe9\xce\xf0\x7b\xd3\x43\x1c\x35\xdb\xc5\x1c\x50\x35\xe5\x11\x71\x60\xfb\x84\x6d\x9c\x92\x7c\x4c\x50\xa9\x5a\x5a\x0a\xef\xfb\x7c\x05\xec\x9e\x0e\x2c\x5f\xfa\x1e\x2e\x6d\x6a\x71\xb9\x6a\x53\x9e\xd0\x72\xd8\xbb\x3c\xea\x84\x61\xa5\x35\x49\xa6\x6e\x81\x79\x56\x37\xaf\x08\x4b\xd1\x69\x5d\xcb\xdf\x97\x96\xd6\x9f\x27\x13\x3b\xcd\xcb\x51\x2c\x4d\xef\xc2\x73\x19\x50\x0e\xc7\xf4\x68\xe7\x1c\x0f\x35\x07\x6c\x9f\xaa\xa7\x16\x03\xf5\xd3\x21\xcd\x43\x9f\xc8\xd0\x43\xe1\x9e\xa4\x49\x91\xb5\x38\x3a\xd2\x4d\x27\x7a\xdf\x89\x8c\xf2\x01\x53\x12\x13\xd4\xec\x0e\x53\xd8\x37\xc6\xcb\xe7\x0f\x9e\xd2\x6b\x19\xbd\xd3\x65\xf4\xcc\xea\xa6\x30\x9c\x63\x7f\xbf\x08\xb8\x3d\x3e\xc7\xc7\x1c\x19\x06\x3b\xe0\x7d\xed\x18\xce\xb8\x74\x13\x64\x11\x32\xae\xa3\x91\xfb\x09\xde\x94\xad\x3e\xc7\x5d\x5e\x14\x1b\xb5\x83\xf0\xaa\xce\xaa\x7b\xee\x42\xb5\xab\x10\x77\xd0\x0d\xe1\xb6\x4a\xa4\x50\xb7\x7e\x02\xfc\x42\xc6\x0f\x5c\x63\x80\x99\x26\xe3\x84\xa7\x50\xc8\x5b\x3b\xfb\x0f\x17\xe2\x3c\x9a\xdc\xbd\x7e\x9c\xdb\x34\xe0\xbb\x21\x5f\x09\x03\x1f\x51\xee\x55\x97\xc9\x95\xa8\x41\x11\x21\x32\x14\x4c\x15\xdb\xc0\x8b\x28\xe3\x28\x58\x4f\x25\x47\xf9\xdc\x39\x17\x56\x6d\xa2\x13\x27\x36\xcf\xde\xcb\xdd\xf1\xee\xb7\x0f\x37\x8f\xdb\x9f\x3e\x7c\x19\x16\x01\x6f\x69\x36\x82\x09\x1b\xd0\x93\xff\xc3\xc6\x6c\x35\xce\xd9\x23\x3d\xb1\x77\x03\x32\x85\x70\x38\xe3\x72\xfc\x6c\x12\xfc\xd5\x24\xff\x07\x0e\x54\xeb\x1e\xa4\x35\xef\xdd\xaa\x84\x82\xa8\x06\x0e\xa7\x72\xc7\xe3\xb1\x0f\xcc\xd9\xd4\xfc\x07\x1b\x65\x08\x24\xed\xcc\xc3\xda\x9c\x97\xc8\x80\xed\x1e\x56\x85\xad\xde\xcd\xb9\xbe\x0b\x4e\xa4\xd2\xa7\x57\xcb\xa1\x58\xae\x87\x4f\xd7\x2b\xeb\x95\x8e\xe3\xc2\xa6\x58\xd0\xd7\x8e\xfa\x6f\x34\xe8\xb7\x1c\xa5\x9d\x09\x4f\xfa\xf5\xbb\x6c\xf3\x37\xdb\x66\xcf\x59\x98\x17\xeb\xb4\x74\x84\x3e\xf2\xb5\x0b\xb6\x50\xb1\x76\x56\xc7\xaf\x25\x02\x09\x7c\x48\x27\xb2\xf6\x1c\x2a\xcb\x95\x0c\x27\x81\x13\x5e\x5e\x4f\x7f\xa2\xc1\x05\xa7\xf9\x3f\x7a\xf0\xe8\xf2\x81\x94\x5e\x66\x23\x47\xaf\x90\xa6\xeb\x95\x99\xca\x61\xd1\x5d\x4c\xd4\xd2\x1b\xf8\x95\x13\x85\xb8\xe0\x17\x0f\x16\xa5\x5f\xd9\xf1\xeb\x87\xb6\xbd\xbf\x79\x58\x44\x4d\xa4\xa5\xdb\xee\x71\xd4\x44\x71\x14\x4a\x1a\x43\xc2\xe1\x54\x4c\xcd\xdc\x53\x6d\x81\x87\xce\x57\x71\x98\xd2\xaf\x6b\x5e\x04\x29\x9b\xbb\xa5\x03\xdc\x97\x86\x9a\x48\x39\xa4\x6c\x8e\x7e\x6f\xbc\xcd\x33\xa3\xd6\xa5\x07\xe5\x01\x26\x06\xcd\xcd\xec\x5d\x53\x9e\x63\xef\x61\x8b\x83\xff\x48\xf4\xa3\xe9\x3d\xd2\xda\x8d\x2a\x4d\xd1\xaa\x34\x3a\x4c\xb9\xdb\x01\xa1\x99\x7a\xf6\x75\x29\xaa\xe0\x99\x52\x70\xd0\xce\x84\xa9\x57\x61\x83\x4a\x81\x4e\x3a\x95\x69\xf3\x7b\x43\xaf\x50\xeb\x9b\x1b\x6a\x87\xe6\x87\xa9\x6f\x7b\x1d\xdc\x0b\x79\x1d\x19\x56\x9f\x96\x51\x9b\x9f\xe7\xab\x1d\x66\x71\x98\x66\xb8\x4f\xf0\x61\xf2\x27\xa0\x53\x0c\x69\x9a\x9f\xcb\x19\x1f\xb6\x7f\x79\x37\x5c\x7f\xba\x3e\x6b\xa0\x4b\xd7\xc7\xf4\x59\xdd\x98\x6c\x25\x4b\xcf\xab\x0c\xda\xf7\x52\x5f\x74\x6b\x48\xe2\xbd\x86\x31\x4e\xc6\x10\x0d\xd9\xa7\x05\x1a\x54\xbf\x22\x94\x12\x1e\x62\x1f\xfd\xa4\xfa\xd3\x02\x3b\xa0\x12\xf5\x40\x35\x45\x07\x40\x9d\xd2\x5a\xa0\x68\xe3\xc0\x85\x92\x03\xf7\xe3\x94\xb4\x22\x3d\x0e\x72\x28\x04\x2a\xc2\xeb\x1d\xac\x43\x9a\xba\x8a\xc1\x99\xe9\x65\x55\x06\xce\x64\xb4\x82\xf9\x7a\xca\x10\xff\xc9\x88\xb4\xc6\x65\x86\x52\x91\x2d\x88\x79\xb8\x52\x08\xf2\x8b\x4b\xfa\xf1\x66\x45\xc2\x9f\x2d\x1f\x55\x78\xbc\x62\xf7\x31\xed\x83\xd2\x14\x98\xb1\x40\x91\xf6\x46\x7e\x32\xdd\x51\x27\xc2\x62\xed\xbb\x69\x10\x7c\x20\x28\xa8\x2b\xdd\x52\x0d\xa5\x8c\x48\x3d\xc8\x5d\x96\xa1\x8f\x0b\x3b\xae\x71\x42\x89\x67\x9c\x39\x8f\x04\x16\xe4\xf9\x88\xa8\x19\x37\x87\x34\x76\x82\xd5\xe3\x1f\x1f\xdf\x32\x27\x0b\x60\x00\xa5\x75\x4a\xfb\x9a\x52\xc2\xd1\xa8\x61\x36\x89\x98\xc2\xd2\x0c\xd4\x21\xbc\xe3\x1a\x66\x22\xa8\x34\x30\x95\xce\x4a\x95\x14\x60\x75\xdb\x8c\xab\x69\xea\xeb\x33\xb7\x12\xc2\xd4\xcf\x5d\x4b\x27\x76\xbc\x43\x8e\x7b\xfb\x34\x73\x7e\x08\x76\x34\x55\x73\x98\x44\x28\x75\x34\x5d\x01\x36\xb0\xfc\xd0\x8e\xbe\x1e\x4a\x8c\x6c\x33\x59\x62\xe9\x4c\xce\x03\xc3\x1c\x9c\x22\xbe\x70\x8a\x63\x62\xca\x19\x8f\x73\x1e\x51\xbd\xbe\x8b\x8a\xb5\x4a\x6d\x6f\xd3\xdb\xd2\xbf\x9a\x39\x2a\x86\xbe\x3d\x4d\xeb\x7f\x19\xbd\x6f\x7b\xbd\x48\x89\x9f\x2e\x01\x0e\x01\x80\x54\x2d\xef\x4f\x3d\x9a\x46\xc3\x19\xe4\xdd\xc3\x3b\xa2\x6a\x28\xba\x46\x63\xfb\x20\x8b\xa4\xf6\xf2\x0e\xd3\x5c\x35\x64\xfd\xc8\x1b\xe6\x89\xb7\xd3\xe8\xc2\xe4\xfe\x32\x8a\x94\x12\x48\x64\x52\x6e\x29\x53\x4a\x50\x31\xb2\x0b\xe4\x10\xc8\xc8\x39\x35\x0f\xe9\xe6\x08\xc8\xf2\xc8\x43\x0a\xe0\x31\x16\x69\x52\x4c\x8d\x6a\xa0\xe7\x3a\x5d\x37\x0e\x29\x75\x54\x8f\x54\x84\x8a\x29\xb2\xb4\x4b\x65\x33\x1a\x07\xa6\x0b\x5e\x23\x9a\x56\xf3\x08\xea\xa0\x24\x0a\x19\x1e\x05\x22\x89\x15\x0a\x8a\x5f\x0e\x33\x88\xba\x9b\x6a\xe4\x81\x53\xde\x30\xdb\xc9\xea\x2f\xdf\x92\x26\xd8\x99\x8e\x81\xef\xf4\xa0\x21\xff\x05\x6e\xa1\xd1\x38\x0a\xf0\x4b\xe0\x66\x62\x4f\x12\xe4\x69\xc6\x71\x96\x01\x8f\x96\x7c\x94\x73\x09\xdc\xf5\x54\x74\x3b\x0a\xff\x2d\x33\x42\xe0\x38\x35\xe4\x1a\x40\x00\x9a\x3d\x1c\x09\x1d\x4d\x25\xee\x40\x36\xaa\x95\x25\xe7\x6c\x63\x84\xcc\x22\x33\x0c\x67\xd0\x28\x5f\x9b\xb3\x81\xaa\x6c\xe2\x08\x42\xc2\x21\x2a\xac\x3e\xb2\xad\x50\x6d\x0c\x53\x57\x9a\x35\x9f\x8d\x75\x2d\x92\x5c\x9f\xa0\xf2\xc8\xb7\x83\x6f\xa5\xc9\x62\xda\x86\xc4\x31\x9c\x34\x83\x12\xa0\xea\xe5\x2a\x42\x93\x26\xa4\x9e\x86\x92\xd9\x81\x86\xb2\x0b\x4d\x2e\xd6\x74\xd9\xc9\xfd\x66\x19\x33\x9d\x96\xa0\x42\x4f\x78\x38\xc3\x09\x29\xf7\x7e\x15\xec\x5d\x0a\x5f\x0b\xbd\x07\x57\x16\x55\x44\xe4\x8e\xbb\x0e\x41\xa0\x75\xee\x0b\x1d\xd1\xd4\x27\xa5\x74\x78\xfc\x7c\xf8\x4d\x33\xe7\x90\x29\x8a\x05\x8f\xb7\x6b\xd7\x0f\xd4\xa4\x59\x50\x11\xa8\x49\x0c\x14\xfd\xcd\x28\xec\x57\x00\x76\x84\x9c\xe4\xd9\x67\x06\x9a\x70\x2c\xdb\x94\x04\x09\xe6\xdf\x0e\x29\x01\xde\x05\xb8\x15\xb9\x10\x5a\x91\x2e\x82\x79\x92\xc2\xe8\x4b\x29\xad\x2a\x0f\xa5\x7f\x67\x27\x05\xd0\x31\xbc\xd1\xbb\x55\x83\x66\x01\x70\x61\x50\xac\x03\x26\x1e\x85\x7b\x0a\x4c\x40\x09\x2a\xbe\x69\x9f\x8c\x74\x4a\xfb\xa4\x19\x60\x5b\x56\x83\x37\x3a\xe5\xba\xc2\xe4\x19\xa6\xe8\xaf\xdb\x9f\xee\x3e\x6f\x97\xcc\xd0\x32\xfa\xe3\x88\xca\x75\x30\xa3\x11\x08\x0e\x4e\x15\x64\x4c\x3e\xfa\x11\x96\x6d\x1b\x08\x7a\x7a\xa7\x6a\x18\xe8\x4f\x8e\xb3\xcd\x3d\x49\x4b\x77\x92\xb1\xee\x28\x97\x1d\xd8\x0d\x96\xaa\x1c\xf2\xf5\x38\xa4\x52\xc8\xda\x98\xf1\x30\xa4\x20\x48\x3c\x92\x57\xc0\x0b\x8f\xa4\xbd\xc1\xeb\x26\x81\x9a\x49\xff\xd0\xef\x5a\x0a\x85\x1e\xdf\xd6\x10\x3a\xc0\x93\xd3\xdb\x52\x88\xb0\xd7\x3c\x56\x72\xd9\x02\xbf\x43\x73\x69\xa9\x17\x4f\xd1\x6d\x29\xbf\xa9\xd5\x4a\xd3\x9c\x85\x86\xec\x07\xf8\xe0\xd0\x50\xd1\x68\xa9\x24\xe9\x38\x87\xdc\x38\x64\x4a\x3c\x3a\xb9\x58\x8f\xca\x1c\xc0\x77\xc7\x9e\x0f\xb4\x43\x8e\x18\xe4\x16\x73\x1e\xaa\x44\xcc\x93\x9f\x42\xda\xeb\x91\x42\x2c\xf4\x84\xbe\xb5\xf5\x62\x1e\x0e\xb3\xa0\x77\x8a\x9c\xd2\x14\x3f\x45\xaa\x93\xb9\x9b\x4b\xb5\xc3\xab\x73\x95\xb5\x1d\xda\x42\xbc\xb3\x8f\xa4\xfd\x79\x76\xfb\xbc\x1b\xee\x96\xa1\x5f\xf9\x52\xd0\x4c\x8c\x52\x39\x0f\x59\x68\x25\x23\xdf\x9f\xa6\x57\x10\x79\xa0\x6a\xfe\x1d\xeb\x5f\xb0\xfc\x38\xbe\x51\x2e\x16\x98\x52\x5e\xbd\xaa\xbf\xc5\xa2\x7a\x9b\xe5\xca\x00\xaf\xab\xb8\x24\x75\xa3\xe9\xb2\x0c\x17\x30\x73\x80\x06\xcb\xb2\xef\x91\x78\x33\x69\x1c\x7c\x99\xe2\xe0\x53\x77\x86\x4b\x13\x98\x02\xfb\x40\x59\x15\x97\xbd\x00\x2c\x1f\xec\x28\x04\x2a\x72\x99\x06\x4f\x09\x37\xb2\xde\x92\xc2\xf2\x21\x9f\x94\x0b\x8a\x68\x23\x7c\xe9\xc9\x96\x88\x9e\x9c\xdc\x8b\xc5\x92\xcf\xdc\x42\x05\x7a\xd9\x58\x90\x11\x14\x0a\x58\x24\x58\xa9\xea\x70\x20\x0d\x12\xa7\x31\xe2\x29\x19\x5c\x9d\x46\x73\x0d\xfb\x9e\x58\xa9\x27\xbe\x00\x57\xa7\x7b\x8a\xaf\xe2\x66\x64\x95\x01\x30\x28\x64\xc6\x0f\x61\x46\x64\x44\x66\x33\xe1\x73\x62\x07\x22\xa8\x30\xf8\xc9\xa5\x58\x2c\x45\xeb\x46\xf8\x07\x8a\x94\x51\x9e\x1e\x97\x78\x38\x2e\xbe\x67\xc4\x06\x5c\x14\xcb\x88\x01\xb9\x23\xdc\x96\xf1\xa1\xb3\x2a\xb9\x69\x66\x2c\xe1\x6f\x86\x1c\x88\xbd\x1b\x01\x00\x55\xc8\x57\x50\x72\x9f\x9b\x47\x46\x2e\x91\x63\x0d\x23\x03\x92\x74\xae\x38\x72\x35\x0c\xc9\x0b\x2d\x1f\x85\x3b\x12\xb2\x5e\x3a\xa5\xf5\x0d\xc9\x20\x41\x68\xf5\xdc\x84\xe9\xdc\x6c\x2e\x1d\x9c\x5f\xae\xef\x6f\x6f\x6e\x3f\xae\x0a\xa2\x79\x19\xfc\x74\x44\x7b\xd5\x7f\xef\x44\x00\x9c\x72\x54\xcf\x37\xef\x12\x12\xf8\x18\x31\x4e\x11\xf6\xea\xec\x1d\x77\xd0\x9e\x1f\x00\xe3\x4e\x80\x81\x67\xbc\x38\xdf\x11\x8e\x1c\x45\x0f\xa1\x30\x00\x4b\x65\x12\x0a\x15\x68\x10\x59\x35\xe5\xe6\x9b\xc4\x42\x9e\xc4\x42\x66\xdd\xe2\xb9\x6b\x0f\x19\x72\x61\xd0\x6c\x98\x93\x5c\x98\xba\x5c\x98\x54\x2e\xdc\x1c\x09\x86\x69\x16\x0c\x93\x76\xc4\x0a\x01\x49\x75\xc8\xc8\xbe\x23\x12\xbb\x6c\x0c\xb8\x93\x22\x6f\x9c\xc2\x03\x39\x38\x91\x77\xc6\x49\x39\x49\xc3\x79\x42\x9c\xf7\xe1\x88\xbf\xec\xb8\x61\x41\xcd\xb8\xa9\x67\x7e\x4b\xc3\xac\x11\xe0\x2c\x87\x29\x64\x0a\xb5\x25\xb9\xf3\xe5\x5f\xc3\x00\x0e\x31\xe1\xd9\xc0\xde\xdb\x25\xa1\xbc\x94\x73\x92\x7d\x56\x10\xe8\x11\x39\x85\x9c\xce\x34\xf2\x66\x81\x33\xcb\x6e\xe8\xce\x64\x89\x15\x42\x30\x55\x39\xa6\x6a\x9d\x81\x5e\x56\x24\x47\xb0\x86\x40\xc2\xea\x8a\x66\x64\xfc\xc6\x42\x30\xd8\x73\xdf\x51\xb3\x06\xe3\x72\xa5\x68\xcb\x20\xa2\x89\x9c\xcc\x3a\x20\x11\x6b\x0d\xa8\x35\x23\xe3\x90\x88\xa3\xc2\x67\xd5\x74\x82\xa0\xba\x03\x38\x0b\xb2\x18\x21\xb5\xde\x00\x7a\xe7\xa2\x93\xca\xe4\xa4\x69\xf6\xb8\xdc\x43\x8b\x81\xeb\x05\xf0\x8d\x38\xd4\x24\xa4\x66\xc2\x0d\xde\x00\x7a\x43\xc6\x37\xb0\x70\x43\xd1\x0f\xd2\x1b\xe9\x8c\x89\xb6\x90\xcb\x0a\x94\x84\x19\x80\x99\xc6\x09\x81\xa9\xe4\x54\x70\x44\xc6\x5c\x24\xf7\xf3\x96\xca\x90\xb0\x42\xb1\x62\x82\x38\xd9\x31\x27\x92\x69\x85\x14\x5f\x1a\x7c\x5e\x9e\x49\x5c\xf8\xee\x7a\xd8\xde\xbe\xbf\x5e\x20\xe3\xe5\x8b\x26\x48\x50\x71\x57\x76\x1d\x25\x49\xe1\x92\x0c\xf0\x92\x42\xd1\x1c\x97\x3b\xef\xac\x3e\x83\x62\x42\xb1\x94\x5c\x11\xee\x0f\xaf\xc1\x85\x16\xaf\x79\x67\xf5\x35\x79\x24\x85\xf1\x08\x6f\xe1\x11\xc3\x8b\x79\xb5\xb1\x02\xea\xb8\xde\x98\xd4\x28\xaf\xad\xf6\x23\x9c\x1f\x80\xd4\xb9\xde\x93\x0d\x40\xdc\xd8\xea\x3b\x67\x81\x25\x77\x22\x52\x5c\xc4\xb4\xd4\xb7\xcf\x41\x5a\xa6\x70\x06\xd0\xb2\x77\xfc\xcc\x0c\x4a\xbf\x2f\x8d\xf7\xcc\x14\x6a\x62\x91\x97\x8c\x69\xf3\x5b\x0d\x0a\x19\xad\x39\x6a\x5a\x08\x7b\x56\x8d\x8c\x58\xcd\x15\x3d\x72\x7f\x69\xa9\x9e\xdd\xd7\x55\x68\xce\x14\x56\x81\x39\x01\xcd\xe6\x4b\x58\x7f\x6b\x73\xf1\xb5\x75\x5d\xf0\x65\x7b\xda\xf5\xed\xfb\xbb\x4f\x8b\x63\x77\xc9\x74\x9d\x12\xdc\xc5\xe3\x08\x0d\x42\x75\x1d\x59\xca\x65\x2f\x3c\x24\xcc\x5a\x3e\x93\xe6\xac\x0b\x72\x99\x24\x5c\x9d\x91\x21\x8f\xcb\xfd\x40\x5e\x18\x43\xee\x19\xa5\xa7\xcc\xed\x4f\x75\x5f\x73\xf4\xc6\x41\xf7\x25\x05\x1d\xd2\x9d\x05\xdc\x6f\x6e\x46\x3a\x8f\xe9\x09\x06\xb5\x07\xaf\xe0\xec\x4b\x31\xa8\x71\x9f\x7b\x75\x86\xe9\x19\x1d\x91\x00\x8e\xe1\xd1\xc5\x1b\x64\x38\xd4\x74\x87\x9a\xd6\x4b\xf8\x15\xc8\x09\xb1\xf4\xfc\x5e\xb1\x52\xb0\x0d\xb6\x73\x1d\x71\x42\x86\xf2\x31\x56\xaa\x5e\xd8\x3f\x92\x39\x82\xa3\xa2\x3a\xbc\x60\x8e\x30\x45\xb8\x1e\x5b\xe4\x9e\x27\x5e\xee\x45\x1f\x5b\x51\x96\x4f\xa1\xce\xd2\xca\x84\x74\xb8\x5e\xf0\x66\x83\x47\xa4\x36\xd7\x25\x3e\x36\xf7\xc4\xc0\x5f\x3f\x3d\x1b\x55\xee\x22\x5e\x53\x75\x4f\x45\xf6\x1d\x52\xba\xaa\x11\x12\x6e\x1f\x9a\x0a\xad\x5b\x0d\x30\x9d\x26\x39\xd5\x2b\x70\x66\xe4\x2f\x55\x6c\xdb\xce\xc0\x72\x83\x6b\x13\xdb\x9e\x47\x12\x4a\x80\x1c\x20\x82\xe3\xc4\xa5\x9e\xbb\xb5\x27\x63\x6d\xa6\xeb\x2d\x5f\xbd\x6b\x34\x60\x26\x13\xc7\x96\xa0\x33\x8c\xac\xa8\x63\x41\x2d\x32\xa3\x77\x94\x1c\x89\xc0\x94\x79\x74\x15\x27\x0f\x42\x1c\xf3\xa6\x45\x59\xf4\x08\x75\x83\xb5\x2d\x07\x2a\x5e\xce\x37\x7a\xa7\x9d\x0b\xae\xa9\x26\xf5\xeb\xd7\xea\xe2\xfd\x78\xf7\xe9\xd3\x76\x09\xf5\x99\x97\x80\x7c\xeb\x90\x52\x8c\x5c\xc8\xba\xe6\x3d\xa9\xac\x08\x0c\xde\x37\x64\x1e\x47\x76\xe2\xd1\x64\x85\xe4\x15\x89\x60\xec\x1e\x8d\x19\x4c\x1d\xd8\x4b\x37\x42\x8c\xea\x36\x60\x60\xf2\x2a\xf7\x47\x9a\xc2\xb9\x76\x1f\x12\x57\xf7\xc8\x6a\xab\xc9\x1d\x89\x5d\x93\xdb\x0a\x59\xb3\x61\x71\xa2\xda\x32\xc9\xcc\x15\xaa\x63\xa6\x22\xfc\x9e\x0f\x22\xe1\x04\x85\x1d\x95\xbf\x61\x94\x91\x6d\x18\xb9\xb9\x4c\xb1\x36\x27\x4c\xc5\x08\xd7\x49\xf8\x54\x42\xf0\x70\xce\x76\x37\x2c\x57\x58\x41\x96\x2d\x65\x26\xa7\x30\x72\x95\xc9\xf5\x04\xd0\x49\x53\x45\x37\x1f\x8a\x82\x99\xba\xa0\xea\xdd\x3e\xfa\x36\xcf\xc8\x61\x9a\x9e\x81\xf3\xfd\x78\xbb\x5d\xae\x48\x3a\x71\x7f\x3c\x89\x58\xb0\x22\xaa\x6a\x16\xe2\xe4\x9a\x71\xb2\x26\x2e\xea\x72\xd4\x78\xf0\x8b\xd4\x3f\x6a\x57\x7c\x05\xea\x65\xf0\xaa\x4f\x6e\x3d\x92\xc0\x97\xb5\xd4\x39\x07\xdf\x4b\xa7\x1c\xbe\xdc\x65\x11\x5f\x62\x6e\x19\x1e\xa8\x0d\x27\xcf\xb7\x80\xfc\x97\x21\x10\xd4\x66\xec\xe5\xb1\xef\xa5\x63\x6e\x78\x5d\xef\xb9\xd5\xd6\x37\xab\x5e\x0d\x60\x55\xe0\x80\xa2\xa8\xb3\xab\x21\x17\xc0\x39\x5c\xf1\x57\xd0\x57\x5e\x34\xd0\x13\x5f\x97\xdf\xb8\xa9\x97\xa0\x09\x2c\xdd\x14\xf3\x45\xf8\xb7\x04\xcc\xd9\x03\x42\x42\x3c\xeb\xc8\x7e\x02\x17\x60\x26\xbc\x80\xf3\xa0\x03\xf1\xd4\x17\xe5\xaa\x7b\xa3\x5c\x4d\x78\x0a\x7c\x01\x53\xe0\x09\x8e\xc3\xd5\xec\x6c\xf2\xcc\xd9\x98\x66\x61\xcd\xab\x30\x5f\xcc\xd0\x26\xf3\x90\x5d\x99\x21\x15\xce\x8f\x6e\xea\xfd\xb9\xd1\x4d\xa3\x5f\x19\xdd\x09\x5c\x45\x47\xab\x38\x83\x28\x11\xbf\x72\x06\xee\xb7\xed\x97\xed\x0a\x79\x58\x7a\x45\x1c\x10\xf1\xc1\x03\xfb\x67\xd2\x26\xd4\x64\x47\xa3\x3e\x7f\xb0\x75\xc8\xb5\x97\xd5\x3a\x23\xac\xa8\xe6\xcd\x17\xc9\x8f\x85\xa9\xf1\x7b\xe6\x3d\x27\xab\x26\x46\xf0\x38\xcb\xcd\x3f\xe2\x5a\xe2\x48\x81\x15\x2e\x5f\xb1\x33\x85\x97\x93\x7f\x35\x9f\xb6\x22\xe9\x2b\xae\xa6\x4a\xaa\x8c\xe4\xa7\x67\xc3\xa8\xaa\x53\x08\xbd\x98\x0f\x11\xad\x86\xbb\x14\x2d\x3d\x51\x25\x85\x5c\x20\xbc\xe9\x28\xf8\x93\xbb\x56\x50\xdf\xc2\xc0\x13\xa3\x82\x53\xdb\xed\xed\xa1\x1b\x5d\x03\x72\xe2\x98\xa9\xc7\x06\x0a\x25\xbc\x88\x5e\x3d\x8d\x98\xaa\x4e\xc1\x03\x55\xad\x9e\x3a\x88\x2a\x43\xc0\xb7\x84\xa9\x81\xaf\x62\x26\xb5\xb9\xae\xd9\x52\x64\xf2\x0b\x32\x20\x63\x6d\x9a\x14\x6f\x1a\x52\xdb\xbc\x6a\xe4\x1a\xeb\xe7\xde\x08\x53\xce\xbc\x57\xf3\x8e\xcc\x3f\x0c\xde\x4b\x72\x72\x51\x8d\xf5\xb0\xbb\xfb\xfc\xf9\xe6\xf6\xe3\x4f\xef\xae\xef\x97\xbb\xe9\x12\x60\x5b\x0a\x96\xce\x48\x31\xed\x44\x72\x69\x47\xf2\x4a\x3b\x95\x1c\x94\xa8\xfe\xfa\x5a\x20\x5a\x89\x70\x67\x26\xe0\xee\x40\x3d\xbd\x78\x38\xc8\x09\x70\x5b\x1d\x0c\x5b\xb8\xa2\x39\x28\xc8\x44\xc6\x90\x8f\xac\x6c\x4c\xd2\x57\x53\xd8\x55\xb7\x96\x0b\x71\xb3\x82\xe5\x68\xdd\x2a\xc9\x87\xe1\x11\xdc\x07\x42\x26\xc8\xa7\xa6\x71\xcd\xb6\x29\x14\x3a\xfc\x7d\x38\x67\x2a\xce\xef\x8c\xb3\xab\xb5\x9c\xb8\xf6\x01\x08\x12\x5b\x5d\x4d\xe2\x07\x55\x2d\x08\x93\x57\xeb\x5a\x2b\x08\xda\x56\x63\xb4\xf0\x39\x1a\x99\x27\xe2\x9b\xe5\xd7\x63\x8b\x0d\xef\xb7\xf7\x67\x4c\x04\x4b\x4c\xbb\x63\xff\xed\x14\xa8\xba\x32\x3b\xb7\x57\x4d\x8e\x6d\x38\x02\xb0\xbd\xc8\x5f\x93\x03\x59\x75\xdd\xdd\x80\x52\x6a\x06\x5e\x45\x22\xd6\xca\x9a\x08\x8f\x89\xbf\x9b\x3e\x16\xc1\x7f\x44\xf9\x5e\x47\xeb\x95\xee\x8d\x77\xbb\x94\xdd\xea\xc3\x97\x8c\x71\xcd\x8a\x96\x97\xbe\x02\x47\xf4\xb4\xe4\x4a\x51\x79\x01\xa1\xf8\x70\x1e\x49\x83\xf1\xb0\xa7\xd5\x04\xd3\x37\x04\x17\xd6\xdc\xc6\x1a\x17\xcf\x41\x4d\x5d\xf1\x90\x2b\xa7\xab\x30\xd5\x1c\xdd\xe0\xff\x4c\x88\xe4\x11\x56\x95\x29\xa5\x41\xea\x94\x2a\x03\xd2\x6e\x6b\x7d\xa8\x4e\x6b\x43\x65\xa8\x0b\x55\x25\x4d\xa5\xec\x9b\xd3\x33\x30\xb9\xea\x62\x3d\x38\xd9\x0e\xc5\x5b\xd1\x2c\xd7\xac\xa9\x18\x9a\x61\x35\xc9\x62\x67\x7a\x75\x51\x4f\x83\x91\xad\xa6\x56\x76\xdb\x3d\xbc\x36\x6d\xfe\xfa\x55\xcb\x14\x43\x78\xfd\x32\x75\xd7\xdc\xfd\xf6\xbe\xdd\xbc\xbb\x5e\x78\xe7\xe6\x85\x21\x3c\xa7\x49\x0d\x9b\x6d\xa0\x29\xf7\xc9\x99\x98\xdc\xbd\x51\x8f\xa0\xef\x03\x6d\x8b\xb6\xbe\x35\xce\xec\x4b\x66\x0f\x13\x74\x77\xdb\x56\xe6\xef\xa2\xc1\xf8\x1b\xc0\x07\xcb\x98\xbf\x1a\xca\xf7\x75\x48\xbe\x68\xea\x1b\xe3\xea\xfe\x7c\x7d\xff\xd3\xbb\xdd\xca\x2d\x59\x16\x96\x52\x67\x43\x39\xba\x25\x11\xa3\x86\x00\x7e\x91\xdc\xe5\x8b\x43\x6e\x04\x18\x82\x54\x21\x88\xed\x00\xb9\x5e\xbe\xe1\xb1\x54\x42\x1a\xdc\x86\xdb\xa1\xec\xe5\x08\xf7\xcc\x37\xc1\xc2\x43\xd8\xf6\xbc\x08\xa5\xa6\xbd\xc9\xa9\x68\x1d\xf2\x45\x5b\x80\x72\xc6\x15\xa9\x85\x63\x6f\x1f\xdf\xe4\xf1\xc5\xbc\x1f\xbf\xdc\xb4\xb6\xbd\x5f\xb5\x6e\x15\xfe\xc3\x31\x43\x59\x5d\x1a\x8d\x4e\x27\x4c\xf6\x00\x7c\x4f\x85\x82\x85\x56\x8a\xf3\x68\x52\xd4\xbb\x9d\x7d\x10\x7a\x38\x9a\x24\x34\x0d\xd6\x37\x4a\x09\xe6\x63\xe8\x05\x7a\xe4\x20\xb4\x5f\x5d\x35\x55\xba\x59\xb7\x92\xd0\xb1\x32\x1a\x76\x15\x3c\x5d\x70\x94\x70\x2e\x1d\x71\x8c\xaa\xfa\x89\x5a\xd2\xb0\xed\x89\xb0\x02\xa2\x6e\x38\xc7\x11\x89\x8c\xa0\x00\x22\x97\xf6\x06\x4c\x42\x8e\x04\x3b\xa3\xe6\x89\x17\xd6\x2f\x6b\x06\x91\x0a\x2b\x89\x10\xee\x39\x83\x98\xaf\x24\x12\x28\xc3\x38\x95\xd5\x60\x68\x43\x83\x5b\x82\x30\x19\xa3\xa6\xc0\xa8\xd8\xda\x1d\x59\x47\x4f\x76\xb4\xe4\x47\xd8\x28\x6a\x20\xef\x9c\x7c\x8e\xac\xca\x1a\xb6\xa0\xdc\x8d\x53\xa1\x2a\x7d\xb0\xdd\x90\x99\x23\x71\x72\xea\x56\xc2\x49\x27\x01\x20\x3d\xe4\xf2\x98\x3c\x76\xbe\x95\xff\xa6\xc0\x4f\x66\x67\xf7\xa6\xe7\xbb\x7a\x06\x23\x1e\x2c\xfe\x65\x8c\x78\xad\xe8\x14\x23\x7e\x73\x0c\x12\x2f\x05\x2e\xa6\x00\x7b\x36\x4f\xda\xcf\x77\x67\xe0\x8f\x8a\x3b\xec\xaf\x30\x59\xed\x2e\x67\x1b\x7b\xd9\xb8\xb9\x94\x7d\xac\x71\xc7\xb5\x0e\xde\x92\xf3\x72\x22\x5c\xdd\x33\xa4\x02\xa1\x2c\x3a\xbc\x56\x19\x0a\x9f\x81\x9d\x23\xde\x3b\x9b\x81\x70\x83\x6c\x65\x85\xa0\xc5\x54\xf6\x5e\x43\x9a\x8a\xed\xca\x66\xe3\x64\x6b\x71\x66\x39\xaf\x76\x6f\xa4\x01\x7c\x91\x46\x4d\x7c\x1e\x99\xbf\x26\x78\x7e\x9e\x87\xe6\xaf\xe9\xb2\xb6\xfd\xdd\xf5\xa7\xed\xfd\xf5\x4f\xf7\xdb\x76\xbf\xc8\x3e\x57\x96\xa6\xae\x03\x7d\xaf\xae\x74\xab\xfe\x29\x3a\xcb\x39\xb8\xfe\x25\xf2\x4b\x3b\xc6\xf0\x39\xf5\xfb\x5f\x87\x37\x8a\x3d\x86\xb9\x27\x9d\x32\x73\xd6\x29\x33\xa5\x9d\xea\x59\xa7\x7a\xd2\xa9\x29\xe7\x54\x4f\x39\x65\x34\xe7\x94\xd1\xa4\x53\xae\x90\x45\x4a\xf1\x7e\xd5\xc8\x37\xa1\x9c\xdd\xf0\xa3\x6d\x71\xac\x13\x12\x8a\xcb\xdc\x31\xf8\x78\xc6\x03\xe9\x7f\x3c\x41\x32\xc1\x8f\xed\xe4\x8f\x93\x72\xc7\x35\x1c\xd5\xdd\xd3\xff\x3a\x4e\x13\xc6\xfb\x01\xca\x5e\xfb\xab\xec\x06\xba\xcc\x65\xcf\xbe\xec\x4c\x71\xa5\xc7\x24\x48\xf1\x14\xe6\xe2\x47\x74\x7c\x32\x1d\xf9\x29\x54\x54\xf5\x78\x87\xac\x46\x93\x59\xfc\x38\x56\x34\xcf\xb1\xa2\x53\xe0\x2d\x36\xda\x94\x18\xe9\x90\x17\x09\x15\xe0\xfd\x1e\x0d\x39\xd5\xda\x0e\x8d\x5d\xdc\x81\x7f\xde\x2e\xa0\xaf\xcb\xc5\x94\x42\xde\x4d\x29\xd3\x7a\x96\xbe\x39\x49\x5f\x3c\x4e\xd6\xd7\xf3\xf0\xf5\xb4\x88\x38\xe7\x7e\x84\x47\x1d\xbe\xc2\x75\xa1\xa8\x7a\xf9\xc9\x2b\x53\x0a\xbf\x39\xa5\x5f\xaf\x5b\x9b\xd2\x74\x1f\xc2\x02\x14\x3f\x06\xee\xdf\xe0\x9e\x8b\xea\x4e\x0a\x3f\xaa\xfe\x48\x9d\xa6\xa1\x9b\x0e\x30\x38\xb4\x6e\x74\x18\x8d\x9e\xee\xa2\x9e\x9f\x06\x2e\xa0\xde\xf7\xfc\x25\xc1\x76\xff\x45\x97\x36\x93\xfd\x7d\x70\xd0\x3a\x88\xac\x79\x9c\x42\xe7\x38\xfb\xa3\x1c\x0b\xf8\x4b\xd5\x13\xdf\xee\xc1\xa4\xcc\x94\x32\x8f\x86\x33\x46\x28\x65\x52\x9c\x32\xb2\x24\xb5\xb4\xa8\xaf\xb6\xed\x41\x9a\xd8\x9e\xf0\xd6\x86\x21\x9d\x6a\x24\x2f\x52\x42\x28\xe4\x42\x69\x9e\x3d\xd5\x38\xea\xbb\xae\x7b\x61\xe3\x5d\x7d\xd5\x4c\xef\xaa\x23\xd4\xd4\xe4\xe0\x23\xe4\x19\x75\x03\x48\xa3\xf1\xf0\x47\x48\xf0\xa3\x14\xd9\x9b\xd4\xe1\xcd\x7b\x92\x19\xd9\x34\xf5\x80\xd2\x5e\x64\x0a\x95\x54\x02\x08\x53\xc2\x61\x4d\x22\x92\xc8\x68\x10\x4c\x00\xbd\x77\x64\x10\x4a\x51\x92\x8a\x52\x80\xac\xc8\xa5\xa9\x2c\x1c\x2e\x07\xd1\xbe\xbb\xfb\xb8\x88\x7e\x2a\x4b\xe3\xc6\x41\xb6\x2b\x75\x42\xb7\xf8\x36\x59\xf1\xa0\xa1\xd0\x78\x77\x37\xc5\xb1\x4f\xfa\x8d\x49\xdd\xa1\xea\x8c\xaf\xc8\x58\x36\x59\x96\x7f\x65\xed\x9b\x33\xd5\x0b\x05\xcd\x9e\xf7\x86\x4b\xec\x8e\x3e\xf0\x00\x52\x3f\x6d\xf8\x87\x41\x95\x11\x01\xf2\x00\x1f\x11\xf8\x77\x79\x07\x3c\x05\x61\xfa\x02\x62\xf4\x01\xfa\x8c\x0b\x04\x2c\x9c\x9e\x22\xd7\x2b\x53\xc4\x7b\x6f\xc9\xa8\x6b\x96\xba\xf7\x29\xc6\x90\x3a\x8b\x77\x3f\x24\xa6\x3c\xc0\xbd\x4b\x78\x2c\xaf\x48\x98\x48\xbe\xa4\x99\x88\xba\x33\x3b\x36\x91\x30\x86\x59\x55\x3a\x1e\x5a\x21\x61\x02\xd2\x5c\x93\x25\x95\x7a\x2d\x1c\xd3\x37\x03\x22\x31\xa3\x87\x3c\xce\xca\x20\x22\x72\x43\x38\xaf\x52\xa7\xdc\x91\x72\x62\xf3\x51\x6f\xe0\x2f\x1f\x08\xae\xac\xf8\xa2\x02\x31\x65\xe4\x3b\xc5\x8d\x1a\x98\xa2\x6f\xea\x71\x28\x8d\x84\x80\x19\x2a\x4e\x53\xa8\xb9\x1e\xf4\x09\x9a\xa2\xc3\x26\x99\xdd\xbd\x4e\x38\xb4\x98\xac\xc8\x1b\x30\x0e\x0f\x32\xd5\x4e\xb8\x48\xf8\xc6\x3b\x18\xae\x7c\xa0\xa0\x01\xff\x80\xd6\xce\x70\xe3\x9a\x94\x8d\x8e\xf0\xcd\x39\x78\xd4\x38\x2a\xb5\x65\x4d\x71\xa4\xc0\x25\x64\xf2\x66\x90\x39\x95\x2d\x22\xa3\x2f\x94\x33\x79\x27\xcf\x65\x3a\x31\x31\x61\x44\x94\x82\xb0\x4e\x61\x27\xf3\xa8\x2f\x5b\x84\x00\xb5\x29\x26\x68\xd0\x99\xf7\x58\x77\xe9\x3a\xbc\x86\x07\x99\xc4\x52\xc7\x82\x8e\x50\x3e\x34\x2c\xec\x41\xd0\xac\x59\xfa\xa5\xe7\x6c\x9d\xb7\x05\x5c\xa6\x92\x12\xc4\x18\x54\x5c\x4c\x16\x29\x0e\x42\x21\x69\xa5\x38\x4d\x45\xe6\x3c\x22\x47\x9d\xea\x69\x65\x73\xf7\x6d\x3a\x25\x41\xad\x2a\x3b\x4d\xaa\x3e\x0e\xb0\x92\x6e\xb4\x0d\xb8\xa0\x42\x13\x39\x42\x67\xc3\x50\xb5\x18\xf6\x4a\x8e\xf1\x7f\x59\x77\x61\xe1\x33\x94\x3a\xf2\x03\x77\x6d\x79\x48\xc8\x97\x1a\x1d\x75\x2f\x5e\xb5\x5b\x92\x71\x4d\x3e\x14\xe2\x4e\x93\x18\x3a\x0d\xdb\x01\x69\xcb\xa3\x51\xdd\x97\x0b\x24\x75\x05\x21\x9d\x81\xf2\x08\x7d\x76\x64\x92\xe6\x0d\x17\x68\xb7\xbd\x9c\xef\x11\xdd\x86\x8e\x3c\x54\xf2\xbc\xd7\x01\xc9\xd6\xc0\xdf\x42\x43\x1d\x12\x0b\x4a\x59\xa9\x81\x55\x0b\xa5\x03\x09\x24\xb5\x07\x72\x04\x07\xe1\x4d\x8b\x95\x7c\x68\x5e\x6a\x18\x7b\xb4\x14\x7c\xe8\x1a\xfa\x99\xaf\xe2\xe8\x2c\x61\xdf\xb8\x86\xf1\xc8\xec\x64\x26\xd8\xfd\xdd\x90\xc8\x8d\x01\x89\x96\x02\xb4\xa8\xb2\xb3\x09\x33\x65\x7b\xba\xe2\x3e\x87\xac\x79\x1c\xfb\x0c\x63\xea\x39\x52\x5f\x82\x39\x4b\xad\x73\x6b\x2b\xf4\xad\x17\x68\xf3\x77\xb4\x42\xdf\x78\x81\x36\x5f\xbb\x42\x2f\x70\x1f\x58\x5e\xb1\xcb\xd4\x66\x47\x3a\xa5\x60\x0b\xe5\x54\x66\x57\x62\x60\x6e\x20\x01\x56\xd4\xe8\x02\xd5\x97\x7a\xb5\x27\x43\x0a\x36\x45\xc5\x91\x9c\x48\xdd\xab\x03\xe2\x92\x8c\xcb\xea\xe9\xa6\xc0\x27\xc2\x35\xc1\xba\xb6\x33\xfe\x40\xec\xd5\x82\x05\x8c\x26\x27\x3b\x4a\xd6\x91\xe1\x92\x6a\xbb\x6b\xaa\xa3\x34\xc0\x27\xa0\xc1\x26\x7d\x15\x5b\x20\x55\x9f\xcb\xb7\x70\x15\xc7\x48\x22\x25\x92\x8b\x4d\xd8\x9b\x3a\xd9\x6e\x5c\x6d\x2e\x2a\x97\x83\x76\x10\x4a\x23\xfb\x05\xac\x65\x24\xce\x19\xfe\x3d\xce\x05\x75\x22\xa8\x54\x03\xc9\x58\x75\xa8\x3a\x52\x1d\x28\x9c\x3e\x8e\xc6\xdc\x4e\x66\xa3\xcf\xd1\xe4\x4c\xad\xd6\x0e\x78\x14\x00\xff\x55\x39\x2e\x69\x52\xe6\x08\x51\x79\x9a\x5a\x4c\xc3\x8e\x42\xc3\x26\x2d\xb3\xcf\x9a\x83\xdf\x83\x9a\x09\x90\xaf\x2f\x8e\xb2\x19\x64\x7b\x84\xc9\x72\x20\x63\x37\x3a\x25\x26\x0a\x7d\xd7\x1f\x65\xf3\x35\x3b\xd9\x21\x0c\xe3\x53\x78\x3f\xf5\xe0\x90\xca\x1c\x62\x5a\x4d\xde\x8c\x26\xc2\x12\x57\xfa\xb2\xc5\xa0\xe1\x92\x59\x7d\x3d\xc1\xa3\xe0\xb8\x83\x93\x4d\xa3\x08\x5a\x38\xb3\xd9\xc1\xd1\x3b\x16\x39\x72\xb2\xd0\x01\xf0\x83\x96\xbc\x85\x52\xcf\x81\xad\xaa\x23\xbb\x88\xfd\x5e\x1d\x39\x76\x2d\x65\xd2\xe4\x70\x59\xb7\xb4\xf0\x46\xec\x2a\x26\xc9\xd9\xa0\xe9\x53\x33\xbc\xa6\x2f\x0b\xd4\x6d\xf7\xe5\xd3\xcf\x0f\x3f\x7d\xf9\xbc\x06\xc0\x52\x66\x0c\x6f\xc8\x7a\x75\x2d\x68\xb0\x3d\xc1\x3e\x6f\x27\x21\x80\xed\x34\x8a\xef\x70\x20\x00\x25\x54\x69\x0a\x71\xc0\xd6\xda\x19\xaf\x2c\x5e\x91\x8b\x1e\x29\x0c\x9b\x7c\x49\x56\xc3\x8e\x14\x8f\x93\xa1\xad\x76\x05\x81\x7b\xae\x07\x9b\x0b\xef\x57\xe4\x28\xa9\x5d\x00\xb1\x6d\x3d\xfe\x9a\xad\x06\xe2\x39\x65\x99\x32\x00\x69\x90\xf1\x22\x52\xe7\xc8\x9a\xd1\xd8\x80\xc0\xcd\x68\x64\x4e\x50\x1b\x80\xac\x61\x08\x5d\xbc\x81\x41\x43\x7f\x73\xb9\x19\x0d\x86\x04\xee\xec\xde\xa4\x60\x77\xbe\x3b\xa4\xf7\x38\x22\x04\x1e\x60\xd7\x03\x9e\xb4\xf9\x1e\x71\xd0\xf4\x45\x95\xad\xab\x5e\xe3\xa3\x03\x2f\xe3\xc9\xc3\x68\xef\x77\xec\x78\x64\x35\x20\xc8\xaa\xa7\xdc\x67\x3e\x52\x4c\x23\x28\x25\xc1\x7d\x27\x42\x76\x41\xac\x96\x57\xe4\x53\x4a\x55\x44\xdb\x08\xe1\x97\xb9\x8e\xdd\x6e\x6c\x29\xc6\x9e\x5b\x38\x74\x77\x2d\x86\x9b\x9d\x5c\x1a\x50\xf2\xcd\xb8\xc2\x39\x29\x10\x72\xa9\x2a\xff\x71\xf2\xa3\xe6\xb9\xae\x53\xc6\x61\x70\xa3\x45\xc1\x34\xd4\x35\x5b\xee\x0c\xd5\x9a\x58\x86\xd1\x51\xb6\x20\xce\x1a\x64\xbc\x29\x6e\x54\x0e\x8c\x9c\x13\x8b\xe5\x4e\x3b\x53\xfd\x28\xa2\xa2\x8a\x5c\x07\x7f\x55\xd8\x36\x21\x8c\x41\xef\x18\x40\x42\x0b\x05\x75\x95\xbd\x28\xfc\xab\x54\x73\x46\xf4\x77\x39\x8c\x3e\xc1\x5c\xef\x33\x14\xab\xb1\x08\x07\xc7\x36\xcb\x49\x45\xaa\x42\xa7\xe6\x26\x52\xaf\x26\xb5\x03\xc1\xa9\x10\x4e\xc3\x13\xa4\x12\x80\x8f\x0a\x2e\x1e\x6c\xe6\x2e\x45\x62\x02\xb0\xca\xa0\x68\x30\x0c\x2a\x23\x67\xb8\xba\x1d\xe7\x34\xb2\x0d\x53\x10\x4b\x4e\x0d\x14\x21\x5f\xf6\xcb\xef\xa7\xf4\xfd\xdd\x2f\xb7\xab\xe7\xb4\x9c\x9c\x53\x5b\xd6\xf2\x15\xbc\xfa\xa0\x2a\xed\xf5\xdd\xac\x4c\x22\x1d\xf6\xfd\x32\xaa\xa7\x40\xdf\x4a\xad\xef\xad\xd1\x52\xaa\x10\xbe\x64\xdb\x31\xdc\xd2\x74\x3f\x5a\x38\x6b\x1e\x6d\xd3\x79\xef\x8e\x11\x5c\x02\xc1\xfb\x54\x36\x89\xf0\x15\xae\xeb\x45\x02\x77\x0b\x92\xc8\xe1\x08\x5c\xc1\xe1\x18\x71\x70\x27\x45\xb8\xa6\x4f\x3d\x1c\x29\x33\x9f\x33\xd3\x0f\x9e\x99\x0e\x62\x3f\xe5\xfe\xf4\xc8\xca\xde\xeb\x67\xb9\xf5\xb3\x7d\x74\xdc\x3b\x05\x38\x50\x85\x36\x93\x0a\xa5\x1d\x63\xc4\x35\x46\x9d\xae\x04\x96\x73\x40\x47\xa4\xa7\x1d\xd3\x24\xa5\x53\x63\xd5\xcc\x9d\x42\xc3\x9a\x92\x34\xd9\xb1\x15\xdb\x04\xe4\xae\x99\x89\x02\xee\x84\x26\xc2\x63\xb7\x53\xc9\xd6\xc9\xe6\xe3\x46\x4f\x6b\xe4\x0e\x5a\x20\xc4\x4d\xf7\x92\xd0\x01\x6c\xae\x9d\x5c\x38\x23\xa4\xa6\x4a\x7d\x0b\xaa\x1e\xb9\xa8\x04\x0b\x61\x11\x11\x29\x98\xcc\x79\xf7\x9a\x79\x4f\x9f\xa0\xe2\x41\x08\x93\xe9\x8c\x81\x8a\xeb\x09\xca\x55\x3f\xc7\x79\x56\xf8\x7a\xa6\x14\xe0\xe6\x0a\xeb\x03\x4e\x16\x70\x65\x85\x01\x64\xf5\x76\xe6\x18\x77\x40\x79\xfc\xda\x93\xbc\xd9\x09\x1d\x70\x20\x91\x20\x0c\x23\xe6\x33\x90\x73\x9e\x52\x6a\xce\x5a\x72\x6e\xc7\xec\x10\x5e\x28\x7f\x80\xcb\xc8\xb5\x75\xd8\x77\x24\xf3\x1e\x93\x52\xb3\x89\x60\x41\x59\x25\xfc\xa3\x50\x33\x59\xad\x94\x69\x22\x74\xc8\x92\x0e\xe6\x2b\xd5\x51\x08\x63\xf6\xd4\xe9\xe3\x33\x69\xa4\xae\xef\x7f\xda\x5d\x0f\x8b\x40\xfd\xb2\x70\x66\x2a\x35\x1d\xeb\x0d\x23\xbc\x1f\xbd\xaf\x83\x09\xea\xb5\x93\xf4\x26\x13\x69\x01\x34\xd1\x8d\x42\x7c\x61\x9f\xef\xde\xe0\x1d\x1b\xcc\xf7\x13\x49\x8e\x9c\x1d\x4a\xa2\x68\xed\x60\x7c\x0a\xe4\x63\x18\xe5\x1a\x40\x6a\xe7\xa8\x01\xe6\x3e\x53\x4c\x14\xd2\x10\xad\xa3\xec\x07\x27\x0f\x22\x7c\xb7\x02\x13\xf2\x77\x5c\x1c\xe2\x6e\x7b\x7d\xdf\x7e\xda\x7e\xfa\xdc\x96\xda\xd1\xa5\x8f\xcd\x93\x38\xdd\x8a\x65\x46\x42\x77\x1d\x84\x87\x0f\x78\x2d\x57\x93\x97\x7b\xc7\xab\x09\x48\xa1\x5c\x8b\xb2\xb9\x42\x02\xd4\x9f\x8c\x95\x4b\x0b\xcd\xa8\xee\x0c\x21\xd5\x56\x2d\x6d\x9a\xff\x01\x3e\xe3\x55\x39\x36\xf8\x64\x69\xbe\xdb\x82\x9b\x4a\x0d\x72\x78\x55\xde\xd4\xea\x00\x11\xca\x4e\xc3\xe4\xa5\x4d\x53\xd0\x03\xa4\x1b\x54\x6b\x88\xf6\x4a\xce\xbf\x76\xd5\x75\x93\x9e\x5e\x83\xa9\x10\x97\xac\x6a\xc3\x58\xe0\x98\x6e\x87\x58\x84\x56\xd6\xcd\xc8\x45\x1e\xeb\x7f\x7e\x36\x65\xd6\x6e\x80\x46\x3e\x6b\x04\x85\x45\x3b\x98\xe4\xe0\xc6\x73\x94\xca\x02\x6a\x04\x91\xdf\x02\x71\x91\x02\x81\x92\x75\x33\xe0\x09\x1c\x7b\x53\xd3\xb4\x0a\x1d\xdd\xa2\x50\x07\xa5\xd1\x00\x71\xee\x78\x73\x2a\x91\x39\x88\xa6\x99\xbc\x90\x3a\xb8\x5f\x84\x31\xe1\x68\xe9\xa1\x71\x9a\x5e\x5a\xe4\xa6\xd2\xd4\xd3\x16\x9c\xbb\xd0\x9b\x54\xe4\x42\x05\xdb\x40\xa9\x3f\x55\xbf\x6e\x27\xac\x5c\xd3\x2a\x1c\x62\x2d\x1d\x10\x21\xbc\x7a\x8c\x84\xc6\x10\x78\xc3\xe5\xf8\xef\x87\x9b\x8f\xb7\x77\x5f\x96\x77\xde\x25\xdf\x9c\x14\x2c\x69\x44\x7e\x20\x04\x96\x2a\x1f\xef\xf4\x16\xe8\xb1\x84\x1a\xcb\xaa\x3c\xc9\xc4\xe6\x4f\x59\x04\x2e\x5a\xb1\xba\x1d\xe9\xac\x11\x4b\xaa\xb8\x94\x53\xfd\xeb\xfa\x74\x2e\xad\x74\xb6\xe1\x5c\x5a\x69\x57\xca\x8e\x79\x87\x5f\xb0\x35\xfb\xa7\x6f\x05\x92\x4e\xcb\xb0\x6b\xa9\x27\xa4\x30\x7f\xa9\xac\xf9\x40\x44\x84\xf6\x75\x4c\xb6\x0b\x90\x8a\xa5\x9c\x47\x4e\x5b\x75\x0f\x0e\x61\x8a\x56\x3a\x83\x46\x38\x35\xfc\x72\x27\x86\xe1\xe6\xf6\xcf\xdb\xf7\x37\xeb\xf8\x49\x65\x86\x59\x77\x00\x1f\x71\x3b\xe7\x79\x9f\x6a\xd8\x19\xf9\x62\x52\x0d\x8f\x6f\x43\xf1\x8a\x34\x62\x58\x95\xcd\x89\x4a\x6a\xc2\xc4\xf9\x20\x14\x00\x13\x18\xba\xed\xc3\x28\x87\x17\xb9\xb3\x10\x60\x19\x11\xad\x0b\x41\x62\xc7\x63\x94\x9d\x54\x63\x77\xd0\x4f\x60\x2a\x1f\xdf\xb2\x15\xf2\xd0\x3b\xe0\x2b\x02\xb6\x80\xbd\xec\x09\x31\x05\x5c\x3d\xe5\x23\x43\xac\xd5\xc8\xf2\x9d\xdb\xb3\x65\xf4\x56\xd8\x6e\xdd\x12\xd2\x7f\x54\x83\x99\xf4\x85\x84\x96\x0b\x8b\xe6\x85\x86\x2b\xed\xcc\x01\xb6\x8a\xcd\xc8\xac\xb1\x4f\x70\x4e\xc8\x7b\xe3\x33\x7f\x3f\x03\xfb\xb7\xb3\xaf\x7f\xfe\xf2\xb0\xfb\x7c\xb3\x5c\xe0\x25\x56\x08\xc7\x39\x11\x66\xb1\x94\xb2\xeb\x20\x7e\xa7\x66\xe0\xf6\x24\x33\x47\xf7\xa3\x3d\x67\x01\xee\x16\xde\x6e\x27\x5b\x73\xb8\x0a\xae\x0e\xd0\x3b\x85\xe2\x47\xd3\x6f\x6c\xbd\xa7\x9c\x3d\x1c\x6f\x4d\x78\x30\x25\xa8\xf2\x8e\x5c\x1e\x84\x8b\x0b\x25\xee\x4c\x58\xf7\x98\x84\xba\xdb\x13\x0c\x07\x4e\x29\x33\xf0\xc8\xe4\x12\x42\x6a\x94\xe3\xe0\xba\xcd\x8a\x77\xe9\x4e\xce\xf8\x32\xcc\xad\x3d\x71\x4f\x55\x5f\xd3\x8a\x80\x7b\x05\x3c\xc3\x35\xa7\x06\x0b\xf7\x6c\x78\xc7\xf6\x2f\x6d\x7b\x7f\x7b\x3d\xfc\x24\x47\x72\xb1\x50\x17\x7d\xb1\x44\xfa\x48\x56\x03\x22\x5f\xb0\x1b\xcb\xf3\x8e\x07\x0a\x78\x74\x7e\x37\x0a\x49\x7f\x8a\xbb\x34\x43\xca\x2c\x60\xaa\x80\xfb\x7c\x21\xcd\xff\x19\x72\x7c\x26\xcb\x7f\x87\xc3\x3a\x89\xb8\x4a\xcb\xee\x4c\x56\xf2\x90\xdd\xc1\x0b\xf8\x02\x2c\x27\x02\x88\xd3\x60\x12\xb4\xa8\xf1\xeb\x60\x39\xe5\xe5\x14\xdd\x5c\xdd\x05\xaf\xbf\xaf\xc9\x3f\x7c\xf3\xf1\x76\x79\x88\xeb\x01\x00\x9d\x4b\xf8\x7b\xb8\x90\xba\xef\x69\x75\xb3\x2f\xf0\x33\x3b\x56\x99\x8c\x73\xa1\x82\x1d\xf0\x89\x9c\x55\x2f\x54\xb0\x08\x5e\x01\x14\x00\x62\x30\x69\x61\x53\x67\x36\x56\x36\x95\xf6\x03\x56\x7b\x0d\x7f\x35\x3d\x6a\xd6\x60\x56\x58\x44\x6b\xdf\x95\xc5\xdc\x3f\x7d\x33\x05\x4a\x61\x93\x41\x11\x27\x78\xaa\xd7\x75\xe6\xeb\x89\x7a\xbb\xbf\xfb\xbc\x5b\xc8\x0f\x75\x89\x35\x71\x9c\xe5\xb9\x50\x8a\x7e\x34\x39\x10\x23\x52\x32\x90\x87\x7f\x52\x4c\x72\x99\x75\x50\x26\xbd\xb5\xe1\x70\xd6\x55\x05\x7c\xec\x31\x5c\x7b\x26\xcd\xe9\xa6\xcd\x40\x8b\xe7\x91\x03\x93\x93\x43\x09\x1f\x03\xf6\xad\xaa\xbb\x9a\x9b\x3d\xf2\x63\x9a\x1d\x3e\xb3\x10\xfb\x49\x02\xe8\xf2\x09\x03\xaa\x39\xfb\x09\x11\xd2\x69\xfa\xb0\x10\x44\x2e\x51\x73\x9f\xc2\x99\xd5\x09\x49\x1d\x20\x0a\x2a\xc3\xa8\x2b\xf5\x64\x29\xee\x28\xf6\xaa\x4c\xa8\xbc\xe9\x00\x97\x3e\x8f\x19\xa0\x27\x0a\x2f\x84\x00\x9b\xd8\xf3\x08\x21\x51\xcf\x39\x1a\xa6\x44\xf3\x69\xf0\x27\x4a\xa7\x4a\x51\xb3\x08\x21\xf1\x0d\x6a\x96\x8a\xc7\x24\xb7\x14\xda\x05\x14\x89\x6c\x5c\xee\xba\x5c\x74\x54\xb5\xb9\xe8\xbf\x3a\x1a\x46\x0f\xa0\xaa\x1a\xa9\x42\x91\xe7\x09\xc2\x44\x84\x05\x41\xb5\x06\xbe\xcb\x25\x8c\x38\x37\xdb\x74\x0e\x39\xf8\xee\xde\xfa\x04\x61\xd5\x15\x59\xae\xcd\x5a\x3c\x78\xcc\xe9\x7c\x64\xb7\x9c\xea\x57\x02\xb3\x7e\xbc\x69\xbb\x2f\x3f\xaf\x32\x92\x75\xf6\xe0\x8b\x5c\xc9\xfb\x34\x06\x4a\x64\x3c\xb1\x1f\x0d\xdc\x37\x39\x90\x83\x92\x39\xc1\x0a\x03\x05\x6a\x06\xd3\xe1\x1e\xdf\x06\xe0\xb1\xe7\xd1\x44\x14\x75\x24\xd7\x09\x29\xe0\x05\x23\xae\xa7\x00\x47\x23\x8e\x89\xa0\x2a\xf4\x8f\x6f\x43\xb4\x14\x38\x8f\x00\x94\x43\x7c\x69\x26\x07\x2b\xb2\x83\x4d\x22\x12\x50\x2d\xe5\x6f\xb9\x47\x1e\xdf\x86\xcc\xe4\x6b\x18\x1d\x31\xb1\x22\xb4\x35\xd3\xcd\x3e\xd2\x9c\x46\x0f\x79\x0d\xb7\x51\x5f\x14\xe0\xa2\x3c\xbe\x8d\x31\x93\xe7\x3a\x3a\x29\x53\x89\x59\xc6\xd4\x93\xf5\x87\x0d\xb8\x19\x05\x25\x67\xa8\x85\x49\xa6\xff\xf1\x6d\xac\x95\x3c\x3c\xd0\x61\xa9\x22\x45\xd8\xec\x57\x4e\x69\x52\x37\xfe\x2d\x8f\x6f\x93\x2f\xe4\x1d\xf8\x22\xc5\xda\x88\x60\xbc\xa4\xc5\x3e\xf2\x04\xda\x62\xbb\x6f\x86\x5e\x01\x0e\x27\x2a\x5a\x42\xf0\xa7\x4f\xd0\x8f\xe8\x17\x83\x6f\x00\xd5\xf1\x49\x35\x5c\x29\xab\xc1\xc0\x02\x69\x2c\x22\x8f\x17\x50\x1c\xe5\x47\x50\x31\x8a\x0d\x2c\x54\x07\x1d\x30\x8c\x4d\x9a\x00\x88\xa4\xe7\xb4\xeb\x13\x35\x54\xc9\x84\x42\x61\xd3\x8c\x02\xed\xc9\xf5\x29\x04\x3b\x40\xc5\xe0\x3c\xb4\x77\x31\x53\x56\xac\x0f\x58\x97\xc8\x5f\xc5\xc1\x40\x5b\xa1\x5e\x0f\x41\x81\x43\xab\x3e\x02\x86\x08\x72\x19\xc2\xaa\x39\x83\x15\x41\x73\xd3\x31\x96\xd4\x8d\x25\x38\x05\xd9\x03\xdc\x53\x91\x77\xe5\x0d\x21\x0a\x59\xce\x80\xf7\x94\x2a\x62\x8b\x93\x5a\xa0\xa0\x8d\xc8\x9e\x7c\xed\x3a\x80\x9c\x1a\xa4\x4a\x42\xe8\xc3\x68\x29\x03\x21\x1e\xe9\x9e\x5c\xa0\xe4\x28\xc2\x57\x8c\xa5\x0a\x4d\x74\x25\x3d\xd5\x28\x0b\xc4\xf1\xe0\xfa\x4d\x9b\x31\x16\x62\x68\xca\x89\x73\xd3\x58\x72\xb8\x3a\x64\x0d\xd9\xe1\xd2\xd0\xa0\x4b\x2d\x66\xaa\xa3\x53\x6a\x1a\xd5\xb7\x2d\xca\x3e\x2d\x04\xbc\x16\xaf\x38\xc3\xb9\x5b\xd3\xac\x3d\xcc\x35\x50\x16\xfd\x44\x28\x9b\x49\xdd\x35\xab\x41\xe9\x80\x23\x02\xef\x1b\x38\x87\x08\xe9\xec\x70\xa1\xca\x51\x57\xbd\xa7\x8c\xe2\x5b\xc9\x46\xd4\xdb\xa7\x87\x8a\xc4\x51\x04\xad\xe8\x48\x11\x5f\x20\xaf\x15\xc2\x36\x79\x2a\x08\x6d\xfe\x1e\x24\xa1\x2f\x9f\x87\xbb\xeb\xf7\x6b\x56\x81\xfa\x0c\xf4\x8b\x9c\xab\x5f\x6b\x27\xd0\x0c\x35\xbf\xb6\x16\xb9\x4b\x27\x00\x94\xb3\xd8\xaf\xc8\x01\xbf\x82\xfd\xea\x27\x70\xda\x13\xd4\x71\x97\xe1\xcb\x1e\x53\x07\xa4\xac\x6e\xd3\xba\x9e\xd0\x6b\x36\x6b\x58\x59\xf5\x27\x9f\x1a\x4a\x55\x87\x17\x57\xee\x89\xb7\xec\x7d\xa5\xea\x3b\x5e\x93\x74\x10\xea\x7a\xdb\x39\x8d\xb3\x30\xf9\x4f\x53\x74\x9f\x60\xc9\x4f\x78\x10\x10\xd7\x00\x7e\x81\xea\x7d\x95\x8b\x22\xd5\x21\x08\xc9\x09\x05\xb9\x67\x9f\x04\xc8\xc8\x23\xb4\x0a\x17\x45\x15\x67\x9f\x41\xc2\x1b\xb6\x9f\xee\x96\x37\x59\x38\xa4\xcb\xb1\x19\x09\xfa\x2d\xbc\xb7\x70\xb5\x76\x93\x22\x70\x1f\xe5\x28\x79\xf5\x0a\x0d\x41\xe8\x35\xd0\x00\x4c\xa0\x1e\xc2\x20\x34\x50\x15\x7f\x91\xe0\xb4\xd1\xad\x3e\x96\xa2\x30\x3b\x70\xfe\xf2\xa4\xe1\xc6\x50\x24\xaa\x05\x5e\xe7\xf1\x4a\xc1\x50\xba\xe7\x83\x0b\x0d\xc0\x09\x2e\x4c\xe0\xaa\x9d\x81\x53\x45\xed\x04\x06\xd6\xa1\xf1\x3c\x50\x7a\xb2\x32\x53\x4e\x6d\x18\x6a\x54\x44\x2a\x29\xee\xb6\x98\x6e\x6a\x86\xe7\x5c\x9a\x80\x36\x01\x73\xb0\xe9\x7b\xae\x27\x63\x74\xb6\x4d\xdf\x34\x38\x17\x81\xa9\x22\xd1\x29\x9f\xd2\x11\x7d\x01\x5e\xa5\x80\x08\xca\xfe\x28\xdc\xad\x82\x6e\x72\xeb\xf9\xb1\xc6\xa8\xa0\xc1\x47\x51\x8c\x87\xef\x23\x17\x38\x89\x95\x40\x42\x7c\x1d\xd6\xb8\x73\x9b\x6a\xd9\x4d\xa9\xa7\xa1\x8a\x0a\xb5\xad\x67\x2e\x52\xee\x7e\x11\x09\xe4\x92\x8c\x77\xca\x44\x55\x5c\x1b\x38\x1b\x48\x33\x6d\x75\xe1\x82\xaa\x8c\x81\xd0\x10\xe4\x0a\x8f\x1a\x90\x92\xed\x64\x32\x48\x15\xdf\x70\x1d\x58\xe5\x3e\x75\x54\x72\x91\x4c\xdf\x47\x99\x50\x10\x55\xf0\x11\x6a\x64\x57\xfb\x68\xdf\x03\x22\x49\xca\x29\x94\x7f\x73\xc7\x8c\xd6\x2c\x94\xaa\xf5\xe8\xdf\x59\x5d\x63\x19\x06\x42\x44\x19\x68\x22\x5c\x67\x15\xb5\x1c\x75\xd6\xd0\xe4\x46\xe7\x98\xc6\x5c\xe4\x7e\x75\xde\x49\x3d\x23\xd7\x40\xb9\x08\xb3\x41\xb9\x8c\xd8\x36\x3d\x7d\x8b\x0b\x3d\x31\x99\x71\x90\xd1\x2c\xc5\x4c\xc2\x10\x53\xdc\x8c\x45\x0f\x7c\x21\xf4\xb9\x69\xa6\xc1\x09\x55\x11\x1c\x14\x08\x4e\x9c\xfc\x93\xd9\x03\x28\xac\x3b\x86\x00\xf5\x2d\xcf\xfa\x1b\xe4\x08\xc6\x2d\x1d\xa6\xc0\xec\x02\x54\x72\x03\x94\x8c\xcb\xca\xab\xdd\xdd\x12\x65\xad\x2e\x9d\x75\x9f\xc0\xdc\xba\x3a\x25\xaf\x56\x07\x55\x55\x23\xf1\xe4\x38\x04\x72\x87\xe9\x76\x1a\x20\x04\x6b\x05\x78\xf3\x92\x34\x2a\x49\xb5\x4c\xd1\x93\xa2\xeb\xcc\x70\xf6\x90\x11\xf5\x30\xe2\xf2\x56\x03\x64\x05\x86\xba\x5c\x8e\x51\x71\x4c\x8a\xd7\x74\x33\x00\x1d\x14\x92\xcd\x09\x96\x7a\x72\xdd\xdc\x97\xb3\xba\xaa\x23\x03\x13\x38\xc4\x42\xa1\x76\x5d\x97\x6e\x17\xc8\x09\x21\xf7\x9d\x10\xf3\xcc\x94\x7a\x8d\xb1\x8c\xb2\x25\x84\xcf\x48\x04\x7b\xa1\x4d\xc4\xce\x8d\x2e\xea\xc6\x82\x25\x41\x89\x35\x4f\x48\xd9\x42\x00\xc1\xd6\x25\x70\x16\x19\x6e\x9b\x42\x65\xe0\xe7\x15\x9a\x9f\xd0\x81\x14\xb4\xe0\x2a\x8e\xf0\x6f\xd3\xd8\x16\x17\xd5\xf9\x41\xad\xbd\x59\x7d\xdb\x3b\xce\xa6\xfa\xb9\x1b\x61\x2d\x85\xc7\x8c\xb1\x7f\x8a\x10\xa5\x3e\xd9\x6a\xde\xa7\x09\x66\xa0\xcc\xdb\x03\x8c\x7e\x98\xd4\xee\x75\x54\x07\xf6\x4c\x80\x91\x71\x3e\x8a\x1c\x0a\x50\x99\x11\x8c\x27\xd4\x09\xdc\x61\x05\x39\x6c\xda\xac\x1d\xec\x6e\x4c\xe0\x5b\xe1\x19\x07\xa4\xa4\xe8\x29\xb9\x16\x23\xfe\xd5\x68\xe9\x3e\x19\xe8\x42\x6e\x13\x52\x37\x78\x5f\x35\xbd\x8f\xf8\xa2\xd0\x4a\xb0\x62\xa5\x1e\xa5\xdb\x90\x1c\xcd\x8e\x59\x51\x2b\xa5\xab\xd1\xcb\x1c\x65\x45\xdd\x7b\x0e\xa8\xe2\xdd\x9f\xd7\x0d\x7f\x75\xe9\x1b\x77\xb4\xa3\x19\x26\xa7\x32\x45\xea\x7e\x33\x6d\x9a\xbe\xb0\x54\x7c\x74\xa7\x06\x65\xee\x7a\xad\xbf\xbd\x5e\xb1\x78\xb7\xf9\x15\xcc\xdd\xcf\x77\x77\x7f\xfe\x74\x7d\x7f\x6e\x82\x97\x80\x28\xae\xcc\xb1\xdb\x1c\x5d\x9f\xe0\x29\x2e\x35\xb8\x21\x38\x4f\xc1\xa6\xa1\x54\x2a\x51\xfe\x35\x25\xe2\x47\x13\x6c\xda\x4b\x11\x60\xfe\x87\x9e\x5c\x42\xa8\xbd\x5c\x1c\x75\xf4\x2a\xff\xa9\x6e\x22\x70\x0f\xcb\x4f\x8a\xf5\x56\x27\x7c\xe0\xe9\xd7\x09\x25\x7d\x42\x1f\xe9\x26\xcb\x32\x63\x5f\x79\xf2\x6e\x30\x21\x30\x05\x60\x5b\xc3\x6d\x42\xae\x7b\x44\x96\x7b\x94\x30\xde\x43\xb2\x82\x07\x06\xd5\x51\x7e\x87\x1f\xa9\x83\xdc\xd5\x25\x1a\x85\xf3\x81\xc3\x92\x0f\xd4\x7f\x6a\xbd\x8c\xf0\x80\x55\x46\x50\x77\x6c\xc3\x65\x71\x1f\x54\x79\x5d\xda\x2f\x27\xf1\xa0\x5e\xf3\x66\x32\xfc\xb0\x13\x18\x24\xc5\x8c\x06\x06\x83\x9b\xdc\x5b\xd4\xb0\x07\x28\x78\x64\xf7\xd2\x84\xc4\x22\xf3\x7b\xd5\x1d\x7a\x38\x63\xb1\x12\x71\x60\xc2\xc2\x06\x90\x0e\x36\x02\x05\x9f\x0f\x71\x72\x40\xc3\x37\x3f\x3d\x1f\x8d\x5e\xe2\x49\xc5\xc9\xa6\x42\xab\x32\x29\xdd\xcb\x9e\x03\xe1\x6e\xa8\x95\x62\xec\xf7\xbd\xf6\x4b\xe8\x38\xe0\xe1\x45\x5c\xf5\x9a\x85\x8c\x83\x2a\x21\x39\x37\x03\xa7\xcd\xa8\xce\x35\x1d\xce\x54\x31\x3d\x40\x99\x10\x50\x1a\xba\x43\xa8\x7c\xce\x5a\x40\xdf\x0b\x0a\xe9\x15\x52\x0d\xb8\x4d\x80\x66\x23\x82\xc9\x13\x0c\x4f\x1d\xef\xcd\xa9\x5e\x69\xc2\x03\xc8\xd3\x6f\xca\x2a\xa8\xdf\xa8\xc6\xd2\x4c\x1b\x07\xce\x65\xce\x75\xd8\x7f\x26\xa4\x62\xab\xaa\xda\x80\x53\xa6\xed\xe1\x3b\x3d\xe5\x9a\x0f\x2d\x2a\xba\x56\x83\x07\x1b\x9c\xf8\xe1\x0c\xaa\x2c\x9e\xfc\x02\x06\x1a\x7e\x20\xac\x97\x1a\x1e\x38\xab\xf9\x28\x3b\xae\x46\x82\xbc\x6e\x3a\x0b\xcc\x8a\x2a\xec\x26\x4c\x7c\xc3\x16\xbf\xd4\xee\xec\xa3\x4c\x21\xfc\x9b\xc0\xfe\xe1\x57\x1f\x54\x7f\x58\x10\xa6\x10\x3d\x39\x27\x77\xdc\xef\xd5\xfc\x76\x11\x55\xa5\x87\x4f\x2f\x4e\xca\xc5\x9c\x45\xc9\x21\x97\x48\x19\x4d\xca\x04\x97\x0a\xa8\x6c\x39\x65\xf8\x09\x42\x44\x08\x1d\xbd\xc7\xaa\x7f\xa1\x53\x1f\x0b\xee\xfa\x98\xd0\xd3\xbb\x6b\x37\x15\x46\xd0\x45\xb8\xe7\xa4\x66\x3c\xb8\x38\xe5\x62\xbb\x7b\x6d\x4d\x70\xae\x92\xcb\x16\x3c\xa3\x09\xa3\x03\xc6\x76\xb0\x93\x5f\xbb\x05\x1e\x2c\x97\x42\x49\x59\x61\xe9\x08\xe2\x71\xe0\xe8\x04\x9c\xf8\x38\x42\x0c\x29\xe0\xe8\xd5\x2d\xc4\x77\x85\x92\x70\xb1\x33\x97\xec\x6c\xbc\x8a\x7b\x44\x87\x4b\xf7\x91\xf7\x3a\xf0\x06\xd7\x5b\x50\x9c\x3e\x62\xc6\xc9\x46\xb8\x89\xa5\x02\x9f\x25\x4e\x7e\x44\x64\x39\x87\x4a\x4e\x85\x1d\xa7\xce\x5e\x1a\x8a\x59\xe1\xc3\xaa\x49\x2d\x0b\x69\xb0\xa7\x0f\xaa\xd7\x76\x4e\xf9\x04\x39\xc2\xf2\xc3\xe4\xef\xe4\x53\x4f\xaa\x6c\xab\x30\x49\xce\x46\x61\x97\x35\xa0\x48\x7d\xf7\x9d\xfa\x3c\x55\x24\xdb\x61\xf8\x08\xbd\x28\xaa\x79\xb1\xec\x4b\x17\x1f\xeb\xa6\x65\xaf\x51\xc6\x2a\x37\x90\x4b\x61\x67\x38\xe6\xd9\xc9\x5d\xd8\x67\x91\xc5\x70\xa6\x6c\xd9\x8b\x90\xb6\x73\xd5\x0f\x88\x0b\x74\xaa\x96\x0f\x7b\x93\x63\xdd\x19\x6f\xd3\x1e\x5f\x5c\x8c\x7b\x79\x86\x4f\x86\x2d\xb7\x08\xb7\x08\x1d\x02\x02\x56\xb3\x06\x04\x8e\x1c\x32\xbc\x30\x9e\x87\xcf\x55\x5d\xef\x62\x5c\x3f\x7f\x75\xbe\x25\x0d\x3d\xc0\x8a\x2a\x42\x49\x87\xa9\xeb\xd6\x53\x85\x77\x14\x56\x3e\x42\x82\xc8\xa0\x90\x48\x6f\xe2\xc9\x42\x63\xd7\xdd\xf6\x27\x11\xa5\x66\x85\x57\x0e\x4e\x68\x4a\xd2\x11\x0a\x7d\xac\x81\x7c\x6d\x85\x09\xf2\x69\xf4\x00\x5a\xd4\x38\xfb\x68\xbb\x9c\xa5\x30\xe6\xce\xa6\x51\x93\x81\x9a\x42\x0a\xc7\x53\x08\x01\x98\xea\x27\x59\x9d\xdc\xb4\x83\x1e\x3c\x91\x12\xab\xef\x7a\x1d\x07\x77\x22\xf9\x34\x4e\xc1\x9f\x98\xd5\x1d\x92\x5c\x6e\xa6\x00\xa1\xa5\x74\xe1\x1c\x56\x23\x55\x7f\xc8\x75\x0d\x49\x29\x8c\xc0\x51\x2f\xb9\xe3\xa9\x2b\x7e\x41\x89\xdd\x6f\x9f\xa3\xd5\x2b\x1b\x48\x96\x45\x3d\x5f\x32\x62\x01\x7c\x9d\x62\x33\x45\x1a\x41\x4a\xd4\xd4\xdd\x92\x45\xca\xc7\xa1\xb1\xdd\x00\x08\xa1\x46\xa8\xaf\x26\xd8\x51\xa0\x46\x75\x82\x72\x3d\x65\x8d\x97\x31\x16\x78\x9f\x36\x45\xd1\x14\xfe\xc3\x59\xf2\x93\x23\x9d\x53\x7d\xc4\x06\x92\x20\xce\x36\x30\x1b\x81\x3e\xc4\x6e\x90\xfa\x47\x15\xb1\xa8\xe3\xdc\x94\xee\x13\x1a\x79\x50\xf3\x2a\x70\x97\x3c\x4e\xb6\xa2\x3d\xa4\xac\x38\x81\x9a\x10\x4c\x55\xa4\x5e\x23\xc9\xd4\xad\xb0\x90\x32\xfc\xa5\xaf\xba\x92\x31\xab\xde\x5e\xdc\x9d\xd4\x83\xc6\xe5\x89\x18\x0c\xff\x6b\xf5\x00\xe8\x49\xdf\x14\x15\x3c\xaa\x64\x2d\xbb\xf4\xd9\x3c\x5d\xae\x32\x79\x2b\xd2\x10\xc2\xfe\xb8\xa7\xab\xec\x8a\x7e\xb5\x2a\x64\x35\x50\x8c\x15\xe6\x01\x4f\xee\xf1\xad\x77\x8e\x5c\xe6\x31\x43\xec\xd1\x70\x07\x0b\x61\x2f\xc9\x24\x62\x4b\x83\xaa\xcf\x49\x0e\xe5\x94\x3f\xbe\xf5\xd1\x91\x73\x69\xac\x84\x2b\xb1\x0a\x39\xc3\x9c\x66\x52\x94\xee\xa8\x4e\xe0\x8d\xa5\x3b\x8f\x6f\x7d\x0d\x48\x58\x52\x08\xb1\x11\x3d\x50\x0e\x5e\x7f\x58\x2d\xb0\x95\xe0\x39\x47\x56\xff\x0a\x00\x9d\x3d\xbe\x0d\x22\x43\xc6\x3a\x2a\xce\xbb\x30\x1e\x88\xc8\xd0\xb2\x32\xfd\x68\x35\x02\x85\x0d\x56\xde\x04\x44\xe8\xd0\x29\x72\xef\x13\x08\xbd\x92\xa9\x04\x53\x47\xcf\x4a\x06\xea\xa9\x5e\xc3\x38\x06\x8f\x6f\x63\x96\x59\x50\xbd\x3f\xa4\x6d\x20\x28\xc0\x1c\xa4\xba\x6d\x24\xe6\x32\x45\x84\x42\xbe\xec\xeb\xf6\xe5\x76\xb8\x7b\xb7\x24\xaf\x4b\x8c\xa6\xa7\x30\x54\xc9\xee\x67\x0b\xe6\x8a\x0e\x32\xad\x63\x36\xea\x1b\x2f\x8a\xff\x45\x4a\xb2\x5d\x5d\xcb\x6e\xb8\x37\x3d\xe5\xc1\x9a\xda\x16\xac\xca\x8a\xd6\x56\x5f\x79\xa2\xb5\x4d\xd9\x4d\xb8\xaf\xa5\xa7\x5b\xd1\x3c\x2b\xed\x28\x01\xcb\xa6\x9d\xe4\x66\x39\x4e\xdb\x72\x59\x52\xbd\xdf\xbe\xbf\x69\x3f\xbd\xbb\xbe\x7f\xbf\x98\xe0\xa5\xdb\xd0\x11\x08\x56\x4e\x56\x69\xff\xba\x71\x71\x82\x5d\xea\x22\xa7\x99\x65\x4e\x11\x52\x0d\xc3\x6f\xf3\x20\xdd\x76\xe1\x56\xde\xec\x2f\x2e\xec\x98\xf2\xca\xe3\x5b\x60\xea\xb9\x62\x9f\x01\xeb\x76\x61\x27\x3b\x60\xef\x5c\xb8\x00\xfa\xdd\xab\x94\x91\xd8\x33\xf8\xdd\xfb\x64\x8b\x14\x4c\x61\x6f\x92\x2d\x9b\x0b\x18\xe0\x5a\x9b\xc2\x3f\x14\x20\x3f\xb8\x6e\x07\x87\x42\xfb\x11\xee\x97\xd3\xa3\x09\x13\x02\xe8\x10\x97\x01\x9c\x1e\x16\xe1\x75\x75\xe9\x26\x74\x50\x21\xf8\x12\x7a\x4c\x92\xe9\xc8\x0a\x66\x86\x56\x30\xf1\x08\x63\xa1\x63\x2e\xf4\x8f\xfe\xeb\x54\xaa\xbf\xa6\x69\x0b\x13\x4c\x90\x6a\xd5\xea\x68\x3c\x45\xe5\x8c\x00\x98\xc5\x9d\x61\x1f\xe1\x3c\x6d\xe1\xe6\xaf\x72\x9f\xb3\x93\x19\xd0\x91\xe6\x80\xd1\x2c\xef\xb5\x23\xd3\xb2\xa6\x5e\xba\xd2\x37\x5d\x77\x13\x70\xb6\xcb\x38\xc1\xef\xa5\x56\x0b\x57\x03\x46\x78\x45\x06\x6c\x80\x50\x9b\x5d\x1c\x15\xef\xf1\xff\x65\xef\xdd\x93\x9c\x48\x92\xed\xe1\xff\xb5\x8a\xd8\x40\x60\xe1\x1e\x6f\x9b\x35\xb0\x06\xac\x80\xa2\xc5\x37\xd9\x14\x09\x89\xee\xbd\xac\xfe\x33\x3f\xee\x91\x92\x2a\x25\x55\x15\xd0\xcd\xcc\xfc\xc6\xac\x1b\x65\x49\xf9\x88\x8c\x87\x87\x3f\xcf\x11\xed\xa0\x68\xe1\xcc\x6e\x01\xf5\x01\x35\x79\xa8\x51\xca\x46\x47\x06\xd1\x92\xbb\x6d\xa0\x31\x14\x73\x7a\x94\x3a\x5b\x75\x29\x92\x87\xab\xbd\x96\xd6\x8c\x7a\x0e\x7b\x24\x2d\x0f\x09\x91\x56\x1e\x33\x58\xd3\x89\xcd\xf9\xcf\x50\x1a\x03\xb9\x14\xd4\x7a\xd3\xf5\x09\x05\x2e\x16\xc7\xca\x8e\x84\x1f\x45\x3b\xc1\xcb\x0e\x2d\xc1\x4a\xe9\xeb\x2b\x25\x2a\x3b\x68\x92\x34\x8b\x1a\xe2\x52\x41\x80\x43\x15\xe1\xb6\x8f\x33\xc3\x2a\x88\x2e\x07\x1a\x0e\xf9\xc4\x86\xf6\x97\x76\x33\xb2\xaa\x45\xe5\x03\x87\x79\x52\x1e\x33\xe4\x26\x87\xa7\x72\xd2\xf6\xef\x37\x6b\xff\xee\x98\x6d\x14\x52\x18\x29\x7d\xd1\x12\x72\x0d\x4e\xdc\x6b\x85\x22\xc7\xf5\xd8\xd8\x4c\x06\x49\xda\x72\x3c\x3a\xfe\x7c\x72\xd1\xf1\x5e\xdf\x5f\x13\xf7\xf2\xb7\x3c\x07\xfe\xae\x12\x06\x07\xe2\x45\xd9\xb0\x1b\x08\x85\xb7\xa4\xcc\x48\xc3\xbb\x22\x0e\xe4\xfa\xab\xa4\x00\x15\x29\xc5\x7b\xa2\x16\x26\x60\x4f\xa7\x86\xc4\x08\x6c\xb3\xc5\x74\x34\x2e\x0e\x99\x90\xb5\x1d\x93\x52\x8a\xfa\x3f\x15\xb2\x92\xd6\xe8\x6c\x6a\x61\x6d\xd0\x15\x91\x8b\xf7\xb9\x28\x72\xf5\x3a\x99\x97\xc5\xd5\xbc\x9b\xa8\x57\x57\x42\x91\x05\x97\xa3\x2b\xd1\xb5\xb2\xc8\x0c\x8f\x71\x2f\x4d\xc9\xc8\xac\x09\x04\x3f\x41\x11\x5d\xb6\xe0\x12\x8f\x6b\x0a\xfc\xed\x84\xcd\xf3\xb6\x17\xef\xdb\x34\xed\x1f\xbe\x6c\xfc\x4a\x77\x37\x59\x74\x64\x5f\x6f\xfd\x16\x4e\xcd\x72\x05\x20\x67\xc5\x6f\xde\x42\x8e\xce\x3e\x51\x75\x51\x3a\xad\x11\xbb\x28\xfb\x0b\xec\xe7\xee\x7c\x27\x85\x7a\x89\x34\xe2\xf1\x09\xa8\x96\xaf\x94\xa1\xc9\xe6\xea\xe0\xb3\x44\x29\x80\x3a\xa3\x32\xca\x34\x7d\x0e\x8b\x82\x9a\xe5\x30\x40\xc6\x70\x6b\x75\x82\x83\xa8\xce\xe2\xf7\x46\xa3\xc6\x5a\x36\xe6\x2b\xac\x69\x38\x52\x5a\x55\x97\x13\x3b\x75\xea\x70\x74\xad\xc3\x89\x44\x81\x10\x88\xe9\x6a\xec\x6a\xe4\x76\x0f\x94\xd3\x2b\xdb\x6b\xe7\x4b\xbb\x6b\x6a\x61\x4e\x31\xa3\x9e\xaa\x00\xf7\xf6\x22\xf9\x2f\xe8\x9c\x64\xbe\x71\xe7\x43\xcf\x49\x4c\x0f\xb8\xc9\x01\xf9\x81\x4c\xad\x78\xf0\x5c\xc3\x1c\x45\x17\x4f\xec\xec\xdb\xdb\xee\xf2\xb7\xf7\x5b\xd6\xf5\xbb\x2d\xbf\xce\x09\x6e\x95\x82\x43\x58\x79\x3d\x2c\xaf\x32\x7b\x24\x95\x6b\xa9\x96\x33\xfc\x57\x48\xd9\x60\x81\xb5\x71\xa6\xa1\x97\x68\x1a\x5c\x74\xd9\xe4\x29\xd2\xba\x34\x00\x0a\x83\x61\xd5\x66\xcb\xf7\xd7\x0c\x12\xe3\xb6\xa7\x18\x80\xf0\x56\x5c\x0c\x58\x8e\xc5\x58\x43\xb3\x91\x27\x05\xe5\x2e\x00\x55\xb0\xa2\xc4\x35\xf3\xdb\x21\xbf\x85\x8e\xc7\xde\xfe\xd0\x40\x8b\x9e\xa5\xf5\x66\x71\x51\x20\xdb\xa0\xe9\x6d\x91\xf5\x41\xbe\x45\xfe\xbe\x7b\x4d\xd5\xa8\x72\xae\x30\x89\x8c\x24\xed\xe7\x00\x6c\x59\x22\xe8\x96\x76\x64\xce\x00\x48\xea\xe4\x5a\x5b\x9a\x65\xc8\x2c\x00\xc0\x53\x7e\xd6\x2c\xe6\x54\x51\x87\x37\xeb\x40\x88\x1d\x4e\xd5\x71\x43\x3d\x60\xa8\x7a\x26\x0c\x1a\x58\x25\xb1\x6f\x74\xdb\xe5\x4c\x65\x1e\x01\xa6\x06\xd4\x23\xea\xaa\x38\xcb\x9d\x06\x45\x2c\x68\xe4\xf0\x80\x81\x1e\xa0\xbe\x75\x2e\x61\x01\x0a\x60\x28\x8b\xa1\xf4\xa1\x95\x60\x30\x44\xd3\x61\xde\xdf\x76\x75\xbf\xbb\xff\xb2\x7c\xfc\xf0\xf1\xdd\xdd\xb2\x09\x43\xde\xc5\x7f\x9c\x32\x3b\x95\x14\x26\x52\x64\xc3\x3c\x47\x6d\x26\x6a\xf1\x83\x22\x56\x24\x03\x93\xc8\x34\xc1\x85\xe6\x53\x53\x3a\xa6\x56\xe6\xf1\x3b\x8c\xae\xa0\x02\x41\x64\x4b\x45\x89\xcb\x84\x2d\x3c\xc7\x49\x4b\x63\x9b\x11\x32\x27\xad\xa6\xf0\xc8\x57\x66\x65\xc9\xea\x6a\x8d\xc2\x3a\xcf\xe4\x98\x27\x69\x8e\xa3\xd8\xf4\x00\xd8\x0e\xd0\xda\x62\xd0\xdb\x73\x50\xe8\x2c\xc2\x05\x99\xf1\x10\x6a\x6d\xb2\x58\xa8\x22\x6b\x29\x34\x8f\xda\xa2\x11\x99\x9e\xf2\xac\x1a\x76\xf2\x0a\xd4\x8a\xbe\x52\x52\xca\x61\xd2\x49\x98\x95\x20\x2c\xc1\xda\xac\xda\x39\x14\xf3\xe4\xed\x60\x06\xd2\x86\x6a\x57\x35\x48\x1f\x24\x94\x91\x64\x9a\xf4\x66\x93\xd7\x9b\xe3\xf5\x14\xde\xab\x86\x99\x3b\x18\x60\xa5\x2d\x93\x35\x71\xd2\x26\x8b\x15\x2d\xb7\x90\xff\x66\x39\x9f\x9d\x75\xa0\xbd\xba\x1e\x50\x44\xb2\x55\x0c\x7a\x13\x45\xfa\xd2\xc5\x9a\x69\xb2\x2e\x9e\xb4\xcb\xcf\x6e\x83\x04\x12\xd6\x54\x66\x79\x75\x6f\xc3\x37\xd9\x70\xce\x49\xad\x78\x1d\x65\xd8\xf4\x89\x0d\x23\xe8\xb6\xb7\x70\x7f\xf7\xe9\xfd\x9b\x2f\x1f\xff\xd8\x6f\x32\x93\xee\x6e\x01\xa6\xfd\x22\xa8\x01\xd9\x3e\x6f\x41\x0d\xa8\x01\xca\xc8\xc0\x83\x5b\x39\x46\x97\xf1\x6f\x69\x0b\xa9\x97\x5c\xf6\x8f\x6a\x1a\xf1\xc8\x52\x85\xeb\x26\x1c\x33\x25\xba\x2e\x4f\xfc\xa9\x49\x16\xa2\x1f\x64\xcc\x99\x41\x00\x6b\xa4\x7f\x95\xcc\xd7\x16\xf0\x4f\xd9\xcd\x10\x83\x9a\x03\x87\x64\xb8\xb3\xca\x64\x70\x31\x83\x40\x32\xf2\x42\x5d\xf1\x32\x92\x51\xf6\xfa\xc8\x33\x19\x19\x62\xff\x2b\x00\x02\xf6\x31\xd2\xba\x35\xea\xce\x08\x24\xf2\xda\x65\xab\xeb\x2a\x78\xb3\x88\xda\x57\x47\xd1\x0b\x15\x04\x65\xc7\x48\x48\x54\xf2\x1a\x75\x38\xf7\x53\x9c\x80\xdd\x8b\x80\x02\x66\x60\x27\x21\xcb\x85\x91\xe9\x48\x25\x21\xdf\x92\x91\x77\xf9\xb3\x88\x00\xba\xc6\x82\xe3\x91\x25\xab\x85\x91\x49\x55\x5c\x6a\x0b\x27\x43\xb1\x0f\xc3\xa9\x48\xdd\x3e\x93\xa3\x3a\x97\xec\x2a\x88\x6d\x14\xa9\x23\x8a\x15\x17\x11\xa1\x07\x8d\xd3\x62\x1c\x4e\x4b\xce\x60\xc4\xd9\xa9\x1f\x10\x31\x79\x25\xfc\x64\xa5\xe7\x29\x75\x10\x16\x69\x44\xb5\x58\xe1\x2a\xcc\xe8\x9a\x7e\x00\x37\x00\x4b\x70\xba\xdf\x52\xd0\xdf\xdd\xe4\xbd\x01\xa7\x1f\xd8\xd8\xa4\xeb\xf6\x20\xb9\x86\xca\x04\x34\x1e\x47\x6c\x39\x99\xb1\x2e\xa2\x02\xa7\x82\x6c\x11\x51\x92\xe0\x4f\x26\x06\x99\x69\x65\xa7\x9e\x65\x2d\x70\x47\x4a\xb4\xee\xe2\xa5\x0d\x74\x9a\xb0\x1a\x24\xa4\xe4\x2c\x8b\xf2\xc3\xae\xe5\xb4\x31\xac\x3f\x12\x6c\x6c\x0d\xec\x58\x40\x48\x7f\x55\x7a\xcb\x5e\xad\xba\x32\x22\xa9\x16\xf1\x2c\x54\xfe\x37\x7c\xe4\xbc\x80\x11\x61\x5d\xfc\x1e\x45\xf5\x00\xb9\x88\xca\xca\x8e\xf9\x37\x52\xed\xc1\x42\xe6\xb5\x64\x4a\xb4\x8d\x18\x95\x88\x50\x19\x7b\xf2\x0a\x28\x2e\xe7\x9a\xbf\xbf\x74\x4d\x6d\x85\xab\x52\xc1\x4a\xf0\x59\xba\xae\x40\xc4\x88\x8c\x17\x1b\xe0\x07\x3e\x29\x74\x5b\x72\x46\xf3\xdf\x54\x16\x81\x19\x72\x21\x4d\xe2\x48\x64\x28\x13\x08\x9a\x2f\xd4\x93\x13\x29\x50\xaa\x8b\x6b\x1d\xc2\xcf\x8a\xcb\xdd\x58\xd7\x0d\xd2\xe7\x29\xfc\x4d\x5d\x6f\x1a\x7e\x44\xcc\x4d\x5e\xb8\x6b\x0f\xf8\x28\x1d\xa4\x24\xc1\xec\x8c\x26\x78\xf0\x5d\x6b\xae\xd7\x84\x70\x77\x21\xa4\x9a\x14\x72\x5a\x77\xcf\xec\xa2\x4b\x11\x61\xfe\x0c\xf7\xb6\x48\x27\x13\x25\x22\x6a\x82\x25\xb4\x21\x9b\x19\x62\x87\x1a\xc1\x7f\x19\x95\x2d\xb1\x2f\xb2\x36\x6a\xc1\x62\x91\x95\x53\xb4\x9a\x9f\x8c\x8c\x96\x9d\x52\xa6\xb5\xbe\xe8\x8a\x2b\x75\x37\xc7\xe6\x82\xb3\x94\x3c\xe4\xa1\x65\xa3\xbe\x1f\xb4\x62\x8b\x12\x8d\xe9\x5c\xd2\xcc\xe3\x0c\xb6\x6d\x19\x25\xf8\x8b\x22\xb2\x2f\xa9\x2e\x4a\x89\x3f\x24\x85\x1d\xa6\x33\x83\x59\xc4\xc9\x48\xe5\x36\x68\x65\x93\x41\x3f\x88\x47\x8a\x25\xbe\x25\xcb\xb9\x2b\x67\x39\x0b\xfe\xe7\x93\x74\x81\xdd\x13\xa0\xff\x02\x1b\xb3\x54\x25\xcc\x34\x10\x68\xd9\x7b\xe0\xf6\x56\x74\xad\x35\x9e\x5f\x8f\xb4\xf8\xd0\xf9\x1b\x16\x9e\xad\x13\x51\x46\xcc\x9b\x96\x2d\xa2\x66\xd9\x13\x9e\xf3\x41\x96\xdc\x16\xf0\x71\x00\x52\x58\xf2\x67\x1f\xc9\x11\xad\xc3\x11\xad\xc8\x67\xc1\xa2\x3c\xa4\x05\xfa\x31\xc2\x23\x2d\x1f\x2d\x59\x1e\x06\x8a\x59\xbc\x56\xd1\x68\x9e\xb9\x01\x75\xd0\x08\xdf\x25\xa7\xa8\x5d\x01\xdc\xa6\x9c\xc0\x60\x1c\xeb\x2c\xbb\xba\x68\x84\x1a\xe2\xe2\x19\x16\x87\xe6\xaa\xc9\xa6\x36\xe7\xaa\xb2\x40\xf7\x75\xa5\x6d\x48\xe1\x00\xeb\xa9\xb2\x8b\x00\xf4\x01\x45\x54\x47\x5a\x1a\x3b\xec\xe9\x03\x7d\x27\x98\xca\x1f\x6d\x3d\x89\x85\x9b\x95\x78\x58\xb3\x8e\x99\xe3\x4a\xd3\x78\xbe\x4c\x77\xe7\xeb\x54\x96\xf2\xad\x7d\xd1\x98\x22\x83\x56\x2b\xa8\x2b\x46\xa4\xf4\xd0\x14\x4e\x5c\x45\x9c\x4c\x20\x5b\xf5\x2a\x16\x12\x08\xcb\x54\xd6\x6b\xe7\x90\x28\x92\xb0\x1b\xc1\x9c\x2a\xdb\xbf\xf4\xb9\xbc\x74\x05\xe1\x5f\xb2\xd4\x42\xe4\x03\x9a\x43\xb0\x74\x23\x52\x97\x05\xa9\x7b\xe1\x22\x53\x0c\xee\xcd\xd2\x0c\x29\xc5\x33\x1f\xa2\x06\xbe\x43\xc2\x7a\x6f\x41\x74\x21\x27\x43\xae\xe2\xc1\x4c\x3f\xc3\x25\x80\xac\x38\x40\x7c\x88\x16\x92\x34\x0c\x1a\x91\x17\x2e\x82\xc6\xc5\x59\x34\x90\x20\xe2\x07\x78\x8b\x30\xb2\x1c\xab\x9d\xd5\x46\x18\x92\xb9\x3e\xbd\xfe\x2e\xd1\x34\xdd\xd5\x7f\x9c\x66\x6f\xaa\xbe\xd9\x92\x62\x58\xb5\xa8\x44\x88\x3d\xc1\xd9\x41\xa5\x1e\x22\x63\xc0\x64\xba\xcc\xc6\x1f\x4d\x86\x7f\xb7\xa8\x52\xa9\x86\x7e\xd1\x8c\xc4\x9c\x06\x20\xaf\x6f\x16\x67\xe2\x19\xea\x65\x55\x7d\x53\xe7\xa6\x2a\x10\x49\x95\x09\x59\x3c\xc0\x84\x33\x3f\x9f\x26\x50\x20\x4f\xa0\x9d\x94\xba\x84\xb1\x14\x6c\x46\xac\xbc\xd9\x56\xe6\x76\xb2\x4e\x96\xe3\xfa\xb1\x14\x09\x5d\x5e\x0b\x56\xdb\x6e\xd1\xb5\x67\x4b\x71\x0d\x14\x65\x05\xcc\x45\xb1\xc6\x58\xc6\x1b\x5d\x13\xcb\x5f\xde\x36\x22\x5e\x29\x9f\x73\x81\xc2\xab\x72\xc3\x76\x57\x15\x2a\xcb\x51\xcc\xac\xb2\x67\xd6\xad\x55\x24\x53\x9a\x5b\x56\x34\x0b\xd5\xf5\xc5\x00\x8a\x79\xc5\x7e\xa5\x98\x7e\x49\x25\x44\x6e\x56\x33\x02\xa0\x22\x15\x63\x31\x2c\x2b\x8e\x7a\x9d\x7c\x76\x34\x7b\xdb\xf7\xbc\xce\x3c\xc2\x20\xa9\xe6\x12\x67\x9f\x0d\xcb\xd5\xa6\xab\xce\xe0\x55\xdb\x1e\x13\x7b\x75\x74\x40\x3d\x0e\x9a\x96\x8d\xd5\xb0\x78\x5d\x1c\x58\x2d\x9a\x13\xaf\x3a\xa4\x11\x0e\x6a\x94\x9b\x5a\x03\xa6\x13\xe4\x32\xd2\xd5\x82\x66\x6e\x89\x19\x3b\x56\xe5\x32\x16\xea\x58\xb9\xba\x90\xb1\xaa\xe7\x0c\x80\x01\x5b\xf1\xbb\x39\x3a\xa0\x92\x8e\x6d\x8d\xfa\x72\x14\x17\x43\x82\x0c\x91\x32\x64\xcc\x90\x3a\x26\x88\xae\x28\xe8\xa8\x56\xbf\xba\x39\x1e\x25\x61\x1f\x36\xc1\x8c\x39\xd1\x15\x8e\x2a\xd2\xed\xf5\xfb\xee\xe3\x97\x77\xd3\xfd\x9b\xbb\x2f\x5f\x1e\xfe\xe7\xb2\xaa\x7c\x9e\xfd\x97\x6b\x39\x12\x6f\x9c\x4d\x97\xbd\xcf\x81\x27\x98\x63\xad\x1b\x81\x87\xfd\xae\xdc\x1e\xbe\x93\xeb\x04\xdd\x90\x94\x37\x1e\x18\x2e\x58\x5c\x93\xd6\xb1\xc5\xc2\x38\xcd\xdb\x79\x47\xc4\x17\x0d\x22\xa7\x3c\xe9\xaf\xd3\x38\x7d\xb6\x33\xf4\x36\x98\x94\x6d\xd2\x07\xe9\x73\xf0\xdb\xa2\xa7\x28\xe1\x35\xb5\xbe\xcf\xe1\x58\xad\xbd\xa9\xe7\xd1\x59\xac\xa0\x13\x6b\x46\xcb\xe2\xcf\x52\x5d\xfc\x49\x0e\x8c\x5f\xb3\x0a\xc6\x49\x76\xce\x31\x07\xe1\x89\x6c\x84\xe5\xe9\x8c\x9a\xe7\x8f\xe2\x65\x9f\x43\x3f\x19\xc6\x3c\x4a\x0a\xab\x1b\x1d\x83\x2e\xd3\x51\x90\x5e\xbd\x32\x48\xb7\x87\x46\x15\xa3\xa6\x33\xe1\x24\xe2\x7e\x22\x43\x4e\xf9\x61\xce\xc4\x89\x8c\xc8\xe4\xc7\x1d\x8e\x95\xed\x67\xa2\xc7\x06\xff\xe2\x98\x5b\xcb\xb7\x63\xff\x9f\x32\xac\x17\x94\xdc\xbb\x93\x31\x15\xb3\x88\xce\xc7\x74\x74\xc9\xed\x85\x67\x0b\x6a\x5d\x80\xb7\x17\xde\xc5\xbe\xb7\x55\x75\xc0\xb8\x5f\x1a\xdc\x53\xd6\xa5\xb1\xdc\x0e\x43\x5c\x78\x93\x17\x2a\x26\x8e\x7b\xcb\x7f\xee\x50\x5e\xd4\x97\xde\x9e\x0f\x26\x9c\xe8\x8f\x17\xe8\xb5\x31\x1c\xdd\x78\xd0\x01\xd8\x8a\xe6\x73\x26\xaa\xb3\x05\xb9\x2e\xbc\xb1\xee\x0c\x50\xe2\xa8\x00\x3c\xb5\xee\x57\xd1\x7d\x63\x8a\xa8\x7c\x19\xe2\xe5\x3f\x63\x4c\xff\x98\x1e\xde\x6e\x23\x08\xef\x7e\x38\x69\x72\xf9\xbb\x5e\xfc\xfb\x6b\x0a\x89\x5d\x6b\x55\xb1\x79\x8c\x2b\x54\x6f\x12\xed\x70\x16\xa5\x4c\xb1\x91\x51\xd1\x27\xdf\xd7\xb9\xb8\x8a\xc4\x6d\x14\xdc\x14\x87\x22\x8b\x39\x26\xd7\x14\x06\x81\x50\x1f\xcf\x08\x94\x53\x5c\x50\xee\x24\x27\x88\x76\xa4\xde\x45\xca\x0e\x20\xf2\x8e\x2d\xc4\x41\x03\x1a\x53\xb3\xee\xad\xe8\xd0\xf9\xe2\xbc\xec\x14\x55\xad\xb3\xb6\x2a\xe2\xa8\x95\xa7\x35\x57\x2f\x2b\xc6\xff\x5a\x84\x00\xe3\x96\x9d\xbe\x83\x43\x5e\xa7\x56\x4b\x79\x42\x3d\x9b\x01\x3f\xfb\xe8\xec\x7c\x2d\xe3\x93\x27\xc3\x5e\x47\xfe\x64\x5d\x8d\x71\x38\xab\xc4\x6c\x40\x8b\x34\xc5\xc3\x9a\xa1\x50\x58\xc8\x93\x8c\xaf\xf2\x0e\xb6\x05\x6b\x29\x81\x7c\xad\x99\xae\x33\x65\x94\x7f\x6b\x42\x9d\x82\x89\x14\x17\xe7\xee\x50\x0d\x0f\x67\xa2\x16\x1f\xec\x45\x93\x05\x8a\x81\xbc\xee\x9a\x2f\xa2\x47\xd1\x95\xd9\x37\x87\x94\x7e\xad\x6d\x88\x48\x94\x05\x18\x68\x71\xd6\x26\x04\xad\xb5\x4c\xfe\x95\x01\x82\xce\x84\xdf\x75\xf2\x44\xed\x62\xaf\xd5\x93\x8a\xc7\xa0\x45\x99\x41\xad\x1d\xbc\x43\xb3\x9c\xbf\x11\x3e\x65\x3c\x44\xbe\x1d\x86\xd0\xa2\x95\xc4\xd2\xe3\x3b\xa4\xd6\x38\x75\xe5\x68\xb1\x84\xd5\xb5\xda\x37\x5a\x4e\x00\xc2\x41\xc4\xb1\x10\x94\x32\xb8\xee\x62\xd3\x8d\x0b\xa2\xe0\x59\xfb\x26\xa0\xec\xa5\x19\xc2\xa9\x3c\x1c\xa9\x0d\x84\xd3\x38\x3b\x0d\xac\xa7\xb9\x38\x98\xaf\xca\x85\x90\xb5\xa8\x44\xa6\x5a\x71\x5a\xdd\xb6\x90\xe6\xe2\xa2\x6c\x06\x39\xeb\x33\x39\x72\xca\x1d\xae\x13\x74\x60\x83\x5b\x86\x7c\x0e\x28\x59\x75\xea\x6c\x45\x89\x3f\x12\x89\xeb\xdc\x5d\x91\xde\x42\x5f\xe9\x9c\x40\x94\xd2\xa6\x07\xfa\x11\xf5\x22\x98\x70\x6a\x4f\x68\x5a\xa6\x8b\x72\xb9\x4f\x40\xc7\x76\x9a\xc4\x99\x34\x19\x09\x11\x53\x9f\x00\x63\x21\x43\x3f\x96\x21\x1d\xeb\x3f\xbc\x25\x22\x15\x14\xc8\xc8\x19\x79\xb4\xdb\x8f\x37\x18\x6c\xbe\xa8\x2c\x99\xd1\x71\x44\x5a\x57\x93\x5c\x83\x22\x0e\x5c\x09\xae\xd2\x51\xc9\xba\x7e\xa4\x37\xf9\x84\xd1\xad\x63\x8a\x10\x0a\x98\x7d\xb3\x21\xc6\x0b\xdb\xe0\xea\xc4\xde\xe9\xdb\x2a\xcc\x45\x1a\xf2\xa3\xd9\x28\x8f\x55\xaa\xc0\x05\xb8\x7b\x1c\xc8\x1e\x69\xc1\xc9\x78\x60\x06\xb2\x86\x7a\xc8\xb4\xba\xa6\x2a\x42\x8b\x4c\xe7\x09\x69\xb3\xb3\x5d\x56\x80\x3e\x61\x89\xd2\x36\x61\x9a\xfc\xd8\x10\x3a\x98\x09\x80\xfa\x6c\xc0\xfd\x44\x56\xfa\x13\xb4\xf4\x27\x69\xc1\x0d\x8a\x41\x13\x70\x3e\x10\xfc\x93\x51\x66\x99\x17\xc5\x00\x7c\x65\x9e\x24\x50\x79\xb0\xab\x53\x76\x36\xa8\x05\xe1\x5e\x96\xd5\x8d\xbe\x8b\x68\x98\x7c\x57\x86\x61\x39\x2b\x86\x89\x65\x68\x5b\x23\x20\x72\xac\xdc\x93\xb4\x0c\x28\xaf\xac\xc1\xac\xf2\x2b\x15\xcd\xdc\x43\x2d\x24\x33\x6e\x54\x75\xb0\x66\x4c\x28\x60\xf2\xaa\xa7\xc2\xa0\x0b\x81\xa3\xd2\xb4\x82\x0a\x93\x19\x9e\xb9\xaa\xda\x53\x45\x2d\x28\x03\x1a\x8f\x2c\x2f\x9c\x9a\xc9\xbd\xae\x18\x37\xc9\xc0\x52\xc2\xe3\xa5\xcc\x6b\x41\x95\xce\xc1\xb2\x78\xad\x10\xd2\x22\x28\xd2\x04\xab\x49\x9b\x1e\xf5\x8d\x5f\x19\xcc\x9f\x79\x72\x49\x49\x5c\x22\x00\x46\x60\xcf\x4b\x77\x23\x7f\x59\xa3\x5f\x78\xb7\xaa\x7b\x80\x48\x57\x4d\x90\x7e\x95\x67\x40\xba\x90\xe5\x5f\x69\xf1\x68\xd4\xd2\x2c\x5f\x2c\xe7\x2a\x58\x43\x39\xca\x0b\x05\x15\xe4\x32\x1f\xf4\x53\xeb\x35\x35\x2a\x42\x69\xb1\x03\x59\xf0\x2a\xba\x29\x28\xbf\x32\x0a\x97\x67\xcd\x95\x06\xf2\xc7\xac\x15\x5a\xda\x7d\xa8\xd0\xca\xb6\xc8\xf4\xc5\x93\xc1\xca\x62\x37\x2c\x90\x81\xcb\x3a\xd9\xd5\xf9\xb3\x88\xf6\x63\xe9\xe2\x6c\x4b\x16\x6b\x1f\xdd\x5b\x15\x0d\x0c\x29\x7d\x06\x33\x63\x95\x82\x8b\x71\x70\xcf\xdd\x58\x56\xb0\xf0\xc9\x28\x4d\xe6\x6c\x7d\xc7\x65\xd1\x82\x6e\xe0\xce\x68\x78\x24\xae\x15\x5c\x1d\x4c\xe5\x58\xb0\xd2\x80\x59\x93\xd2\xdb\x2a\x47\x6c\x68\xc8\xa8\x02\x12\x92\x63\x92\x4a\x2e\x74\x76\x34\x34\x16\xe9\x06\xcd\x01\x90\x8b\x40\xaa\x3d\x47\xd5\x23\x51\x3b\x47\xb6\xd4\x35\xc6\xa9\x25\xe0\xea\x02\xb3\x42\x79\x05\x80\xd4\x86\x17\x25\x33\x54\x0d\x91\x14\xc7\xa7\xa2\x86\x11\xf5\x3b\x3a\x9e\x0d\x2c\x50\x24\x2b\x46\xfe\xd1\x1c\x07\xe5\xed\x46\xed\x35\x08\x73\xd6\xfd\x3a\xe9\x4e\xc8\xb6\x25\x2a\xb5\x8f\xae\x08\xf8\x70\x35\x51\x70\x14\x74\x03\x89\x88\x4c\x16\x22\xd5\x94\xad\xfa\xd0\x6b\xaa\xbe\xd7\xca\x3a\x75\x2d\xd9\xd6\xa6\x2a\xd8\x2b\x85\x1d\xdd\x8d\x9c\x40\xca\x8e\x66\x91\xe3\x3c\x5c\x6c\xd1\xa2\x76\x10\x3d\x59\x37\xf1\x3a\xe0\x87\xd3\x68\xc2\xc0\x35\xc3\x2e\x3e\xea\x2f\xb0\x90\x8a\x66\x68\x60\x6e\xfa\x38\x04\xfe\x9a\x19\xd6\x51\xe6\x50\xf1\x13\xc2\x27\x90\xe4\xba\xb4\x9a\xf9\x2e\xb9\xeb\x06\x00\x18\x19\x0a\x8e\x4f\xa0\xc9\x86\x3a\x93\xb0\xf7\xb1\xeb\xae\x1b\x58\x19\xa0\xf6\x45\x6a\x48\x63\xcd\x01\x15\xa4\xc5\xb8\xb0\xd8\x16\x93\x5c\xdc\x19\xc7\x57\x72\x71\x46\x43\xb4\x7c\x13\xfa\x24\xe6\x93\x4e\x18\x74\x2e\x3b\x3e\x0e\x15\xde\x38\x8c\x9d\x09\xea\x2b\x26\x15\x04\x40\xb4\x05\x6a\x11\x79\x9f\x55\x2a\xe8\xde\xa3\xf3\x07\x13\xc9\x05\x5b\x64\x83\xe0\x82\x92\x16\x3e\x80\x11\x09\xb1\x07\x31\x51\x92\x36\x0d\x95\xa8\xcb\xe8\xee\x80\x32\x4e\xb2\xd2\xfe\x49\xe6\xc0\x01\x16\x12\x00\x99\xb4\xf8\xb4\xe9\x90\x69\x30\x4c\xc5\x11\xdc\xbb\xf2\xf6\x80\x17\xda\x2d\x6b\x2d\x29\x56\x59\x9b\x19\x99\x2a\x00\x15\x9d\x51\xbf\x41\xd8\xcb\x11\xb9\x71\x51\xb7\x7c\x1b\x74\x9e\xbb\xc3\xe6\x52\x66\x79\x5c\x35\x3c\x0c\x55\x42\x35\x3c\x8c\xf5\x85\xca\x0e\xd2\xd3\xaa\x16\x02\xa9\x00\x68\xfa\x2a\xf2\x76\xec\x9a\x63\xd1\x63\x78\x11\x15\x66\x4e\xa2\x9a\x64\xd7\x65\xb1\xe7\x49\xcb\x34\x22\x30\xb2\x12\xac\x2e\x06\xe8\x3c\xd2\x54\x00\xd4\x21\xfb\x63\x54\x68\x2e\x9d\x8b\x0a\x7f\x15\x9d\xf2\xfb\xa3\xa3\x55\xc5\x01\x38\xaa\x0a\xe1\xaa\x15\x23\x28\x70\x49\x10\xf5\xdf\x5f\xb7\xda\xa5\xf9\x1c\x00\x75\x0c\x8c\xe4\xd6\x6d\x92\xa0\x8b\xb4\x76\x90\x4d\x98\x88\xf9\xa7\xbc\x5c\x6d\x56\x2e\x30\x63\xbe\x6e\xb2\x0d\x69\x9f\x02\x4b\xa4\xaa\xb9\xe0\xab\xe8\x82\xd5\xd0\xf7\xc6\xed\x50\xdf\x63\x98\xc0\x50\x1f\x69\xf8\xef\x8f\xf0\x54\xd9\xb4\x6d\xd9\x9b\x17\xdd\x16\x34\xfc\x52\x51\x29\x85\xe0\x11\xb0\x57\xc8\x99\x85\xa5\xa6\x86\xf4\xd0\x51\x5d\x01\x83\x89\x33\x5d\x1a\xaa\x13\xc4\xb5\xb4\xc8\x29\x79\xd8\xa2\x52\x75\x94\xf0\x86\xe3\x2b\x9b\xb2\x63\x69\x9e\xb6\x80\xcb\x68\xbf\x0a\x95\x66\x42\xd3\xb4\x21\x3c\x85\x6d\xc9\x4b\x0f\x24\xd3\x19\xca\x50\xec\x32\x56\xaa\x19\x0c\x11\x2a\x59\x6c\x98\xef\x96\xb7\x05\x58\x47\x0b\xc5\xa3\x64\x2b\x68\x38\xdd\x4a\x84\x34\xe5\xd1\xaa\xcf\xcc\xae\x31\xd8\x11\x99\x15\x22\x02\x6f\x9a\xb6\xff\xf3\xe5\xfe\xd3\xbb\xfd\xc6\xb6\xdd\x16\x8a\x1c\x2b\x71\x22\x5c\x50\x3f\x1b\x47\x08\xdc\x5c\x6a\x69\xf2\xa5\x81\xa4\x89\xb5\x62\x53\xfe\x47\x26\x42\x5d\x93\x18\xc9\xc5\x3a\x21\xfb\x91\x42\x03\x7c\x60\x2c\x16\x2a\x35\x67\x7a\x73\x9d\xa6\xd2\xc8\x95\x46\x33\x42\x99\x4d\x41\xfd\x64\x93\xc6\x16\x6a\xd8\x2e\xf2\x1d\x72\x09\xd8\x75\xd2\x6a\xfe\x3e\x70\x42\xcb\xac\x39\xd6\xa8\xaf\x2e\x56\x79\xab\x69\xba\xac\x48\x83\xcd\x66\xbc\xd6\xaf\x1f\x2b\x75\x16\x7f\x5a\xc2\x73\xa5\x9c\x67\xce\x1a\xe1\xa3\x61\x50\x2d\x14\x54\xad\x28\x06\x83\x26\xca\x3c\x60\x6d\x2c\x17\xbc\x4d\x9e\x3b\xb2\xc7\x3b\x0a\x60\x26\xc2\x5f\xa1\xaa\xb8\xe9\x1a\xe2\xd1\xec\x89\x66\x60\x21\x8a\xa9\x86\x5c\x9b\x68\xa6\xad\x9a\xa7\x4f\x20\x52\xde\x7d\xfd\xe7\xa6\x28\xe5\xee\x26\x76\x2d\x38\xaf\x19\x18\xbb\x07\x63\x39\x0d\xc6\x72\x6a\x54\xd9\x2b\x79\xf7\x09\x63\xf8\x08\x44\x51\xe6\x8b\x74\xaa\xb5\x03\x6d\xf8\x66\x91\x97\x4c\xc5\x1b\x65\x5e\x8f\xa0\x4e\x71\xf6\x05\xbc\x56\x7d\x56\x8b\xfc\xb2\x67\xed\x7e\xe2\x61\x14\x53\xfa\x1b\xde\xec\x66\x65\xf3\xc7\xe9\x42\x39\xfb\xdb\x0d\xf1\xf9\x39\x26\x8f\x6c\x49\x89\x40\x2b\x96\xb4\x82\xdd\xd7\x30\xf9\x04\xc2\x97\x1e\x0f\xbe\x6a\x39\xfb\x60\x3a\x45\x9e\x8c\x22\x0d\xb1\xba\x55\x14\x91\xe7\x16\x2f\xfc\x21\xb5\xa2\xb7\x4c\x3d\x1e\xf3\x54\x13\xb2\x4b\x81\x15\x96\xbb\x8b\xf0\x30\x87\x19\x19\x37\xb9\xcb\xd3\x6e\xa7\xa1\x7f\xf9\x78\xff\xe1\xdd\xdd\xd7\x8d\xf3\xee\xed\xad\x92\x04\x2b\xeb\x0a\xfb\x4c\xac\x33\x54\x0e\x4e\x66\x28\xa6\x7a\x6a\xb7\x6a\x33\x80\xe2\x76\x31\x5f\x3f\xb5\x80\x02\xc0\xc1\x8f\xb8\xf1\xa1\x47\x0e\x5b\x1f\x3a\x15\x5c\x65\x64\xf3\x63\xad\x19\x11\x3c\x9f\xd1\xc4\x03\x60\x21\xb6\xb4\xf7\xf2\xb7\x01\x00\x6f\xea\x03\x62\xe6\x83\xb6\x60\x24\x70\xef\xac\x3a\x31\xd7\xcb\xd5\x8f\xd2\x84\x98\xf9\x62\x79\xe0\xed\x49\xf7\x6d\x9a\xbe\xbe\xfb\x72\x7f\xbf\xf1\x85\xbf\x3d\x61\x08\x6f\xd1\xf5\x9e\x27\xbf\x72\xd0\xae\x07\xe0\xe2\x4c\xe9\x24\x79\x38\x41\xca\xeb\xb4\xf0\xb9\xdf\xc4\xa5\x43\x3e\xfc\x55\xe8\x39\xbb\xb7\x3e\x56\x1e\xe6\xcf\x1e\xab\xc4\x4f\xa7\xd0\x73\x5b\x60\xbc\x6b\xc8\xcb\xda\xa6\xc4\xd2\xc1\xb9\x4b\x8b\xa9\x6a\x18\x3f\xad\xf7\xde\x4d\x67\xcf\xc5\xc1\xfa\xdc\x47\xa8\xcf\x70\x29\xa9\x39\xab\x69\xb7\xd6\x90\xdc\xed\x51\x5b\x90\xe7\xe3\x42\x49\x58\x45\x58\x9d\xfa\x1e\xc7\xe7\x4c\x67\x3d\xbe\x36\x01\x2d\x88\xa4\x40\x20\xd2\x57\x72\x03\x3c\xce\xa5\x80\x9b\x6f\x65\xcf\x3a\x10\x37\x24\xc1\xb1\xa3\x6e\x43\x6f\xfc\xf1\xe5\x61\x1b\x09\x7b\xb7\x95\x54\xc7\x0a\xd6\xdc\x23\xe2\x9d\x0a\xb7\xa1\x2c\xc7\x46\xc1\x4d\x31\xcd\xbe\x29\xfd\x23\x58\x74\xb4\xf0\xcc\x91\xa5\x7b\xc4\x0c\x19\x27\x9f\x80\x2b\xd5\x8a\x77\xa6\x91\xf7\xa1\xa4\xe0\x96\xf6\xa6\xf8\xc0\x14\xa3\x63\x25\x69\x8a\x8a\x6f\x50\xca\xa8\x61\x00\xc7\x0b\x56\x64\x29\x62\x5a\xad\xd4\x7e\x71\x05\xe8\xa3\x8e\x61\x00\xfe\x52\x4d\xc7\x7c\x85\x9e\x34\x25\x41\xce\x25\xcb\xd2\x54\x24\x33\x47\x00\x37\x11\x1b\x29\x74\x45\xf9\xa4\x80\x8c\xce\x64\xe0\xc2\x85\x45\x11\x80\xf3\x3f\xe3\x54\xe5\x48\x0c\x9a\xf7\x9b\xa2\x65\xba\x54\xf0\x74\x89\xfe\xa1\x9f\x71\x65\x3e\x89\x23\xef\x37\x54\x97\x9a\x9c\x98\x9a\xdc\x5d\xdf\x5a\x71\xe5\xc8\xdc\x34\x1a\xa7\xc0\x73\xa4\xbb\x1b\xc9\x89\x8a\xff\xac\x08\xa4\x68\xdc\xa2\x4e\xc4\x6e\x8e\x6a\x20\xae\xac\x02\xf6\xd9\x55\x2d\x97\x69\xe3\x77\x27\xbc\xf1\x31\x69\x15\x19\xec\xf8\x95\x1d\xde\x78\xde\x1f\x11\xc2\x9f\x71\xc5\x9f\x50\xbd\x9f\xd2\xbe\x9f\xd1\xc1\x9f\x5d\x7e\x7a\x67\x63\x3b\x2d\x95\x0c\x80\x5b\xab\x73\xc9\x7c\xf9\xcd\x01\x2b\xc9\xa6\x1f\x61\x1f\x8d\x3a\x2d\x89\xdb\xdc\x08\xe5\x35\x8d\x9c\xed\xef\x00\x07\x28\x40\x77\x06\x68\xbd\x56\xa2\x29\xb5\x06\x8d\x5c\x6c\xcc\x48\xe5\xed\x53\x88\x5e\x9a\x89\x57\x5e\xd0\x98\xe3\x09\xcd\xfc\x4f\x76\xf0\xda\xbf\x4f\x31\x91\x6c\x96\xe9\x2d\x2c\x73\x4a\x79\xd4\x85\x5a\x25\x7d\x11\x55\x37\x34\xc7\x41\xeb\x5b\x74\xc7\x71\xbc\x0a\xee\xca\x28\x04\x50\xd7\x42\x37\x8f\x9b\xaa\xd2\x3a\x5f\x4d\x08\x45\xa3\x4a\xd2\xd5\x3b\x12\xa5\x37\xe5\xfa\x03\x83\x0a\x3e\x0e\xf5\x27\x65\xb3\x5b\x61\xfc\x8f\x14\x40\x3a\xe6\x64\x2b\x2c\x17\xac\x32\xf9\xac\xd1\xee\xac\x37\x9e\xc4\x5e\xf6\x1c\xea\x0c\x53\xad\xea\xd6\x79\x44\x58\xe5\xb2\x9b\x08\xe0\x83\x65\xd6\xf7\x93\xb7\xae\xdf\x5f\x57\xe0\x98\x70\x7e\xdc\x17\x62\xd0\xd7\xc7\x7d\x11\xbb\x1b\xd9\xf2\x62\x10\x61\xeb\x4d\x45\x2b\x82\xc6\xff\x28\x90\x38\x6b\x18\x2c\xc3\xf6\xb8\x61\xec\x34\x47\x93\x86\x6d\xdf\x0d\x4e\xf9\xf4\xcd\x6d\x37\x8b\x46\x0e\x85\xd9\xa6\x9d\x7a\x5e\xf4\x65\x16\x47\x1d\xee\x52\x1e\x51\x28\x8c\x55\xde\x9d\x0d\x95\xba\x2c\x81\xb4\x16\x51\x3f\x50\x65\xc6\x96\xd4\x56\x3a\x7e\x0e\x56\x1f\x11\xe2\xe9\x6b\x36\x83\x4b\xe3\x80\x83\x55\x64\x72\x48\xae\xe5\x93\x5e\x6b\xd1\xd9\xb9\x1c\xa2\xb1\x88\x34\x99\x5d\x7d\xf2\xad\xb9\xd6\x00\xcc\xa3\x10\xa9\xd2\x3d\xa8\xc9\xd2\x64\x5a\xdc\x2b\x9d\xcc\xc6\x96\x90\xcb\xd8\x92\xe3\x90\x16\x00\xb9\xc4\x75\x28\xf5\x41\xd2\x9e\xa6\xb8\x46\x41\x49\x49\x5b\x5e\x27\xc4\x6e\xb6\xa6\x58\xcb\xf5\x05\xe3\x78\x7a\x9f\x9a\x36\xa0\x15\x6d\x22\x9a\xa7\x8d\xd1\x5b\xa5\xe3\x10\x5a\x43\x1a\x42\x3b\xb7\x31\x06\xde\x4d\x0f\xdf\x36\x25\xe0\xef\xb6\x05\x98\x27\xf0\x0f\x22\xc8\xac\x9e\xf6\x09\x09\x2a\xf6\x1c\xfa\xec\xb6\x25\x8c\x5a\x6c\x76\x95\x1c\x27\x1d\xf9\xea\xa8\x98\xbf\x1f\xf3\xd5\x69\x75\x3c\x5c\xb6\x0a\x77\x6e\x68\xe7\x33\xc1\x5a\x66\xa5\x39\x6b\x4d\xae\xb5\x2c\xc3\xb9\x06\x27\x27\x95\xe2\x0a\xcf\x22\xdc\xd6\x84\xd8\x21\xae\x66\x65\x7c\x57\x5b\x25\x36\x25\x8c\x8d\xf2\xa0\x68\x50\xa8\x0b\xfa\x30\xf6\xa7\xe0\xbf\xde\xde\xdf\xfd\x73\x6b\x2e\xbd\xbb\x09\x38\x9d\xb9\xca\x18\xca\x46\xd0\x54\x64\x4b\x87\x1a\xcb\x81\xe5\xda\xa3\x0f\x49\xb9\x4a\xd4\x46\xb0\xda\x99\x21\xd6\x70\xc1\x94\x83\xd8\xf9\xf1\x10\xfb\x55\x6c\x93\x67\x50\x93\x2c\x17\x60\x52\x0e\x3e\xf6\xfe\xfd\x75\x4d\xcd\x35\x8a\x93\x67\x91\xb0\x89\xfb\xbe\x12\xeb\x5f\x20\xf6\x91\x29\x41\x87\x58\xb5\x05\xc4\x0d\xd7\x1d\x7c\x7c\x22\xd7\x70\x4b\x63\xf6\xee\x56\x29\x5c\x2f\x8a\x7d\xff\x74\xdb\x97\xab\x2f\xff\xfd\x35\x71\x41\xda\xe2\x94\x03\x34\xdd\x36\x5b\x7d\x22\x34\xcf\xa2\x9a\x9a\xfd\x8f\x3a\x4e\x88\xc8\xa4\x0a\x6a\x55\xef\x5a\x85\x7a\x8f\x49\xed\xda\xe4\x0b\xf2\x74\x45\xd8\x12\x4c\x3d\x0b\xe4\x7a\x25\x2d\xa0\xa4\x11\x0c\xa4\xd7\xc3\x91\x5f\xab\x69\x00\x56\x34\x83\xdc\x5d\x0d\x71\xe1\x18\xd3\x0e\xe8\xb1\x69\x77\x24\xbd\x62\x06\x60\x59\xd7\xb4\x69\x00\x58\xd5\xb9\xba\x5a\x9c\x68\xa8\xa9\x2e\x14\x95\xaa\x4e\xee\x21\x92\xa8\x36\xd7\x92\x08\x96\xc1\xc9\x4a\x73\x07\x6a\x11\x3b\xe6\x89\x18\xd4\x86\x5e\x3f\xf1\x7a\xc8\x17\x85\x8f\x14\xe9\xd1\x88\xbe\x90\xf1\xb1\x27\x6d\x84\xde\x53\x74\x64\x85\xad\xc7\x13\x55\x47\x4e\x60\x70\x00\xbc\x99\xf1\x83\x00\x52\xb5\xc7\xb9\x65\x27\xcd\x95\x07\xf5\x99\x92\xee\x02\x78\x3d\x88\xbd\x0c\xd2\x67\x74\x81\xe2\x8f\xa4\x06\xd6\x72\x94\x69\x6a\xaf\x25\x8b\xd3\xfa\x3c\x59\x1f\x4f\xd6\xe9\xd2\xbd\xe0\x56\x6d\x5a\xb7\x8d\xe1\x99\xc6\xa0\x45\x8d\x18\xeb\x58\x42\x31\x28\x66\x62\x94\xef\xaf\x73\xed\xae\xc5\x32\xa7\x82\x02\x56\x12\x3d\x79\x51\x0f\x22\xd5\xd9\x77\x86\x49\x44\xf8\x44\x4e\xff\x80\x64\x8d\x45\x03\xc9\xa8\xfc\x44\x64\x55\xd4\x64\xa8\x74\x75\xee\x0c\x9b\x8f\xf4\x73\xc6\x65\x72\x55\x2c\xdf\x5f\xa7\x9e\x5c\x27\xd1\xe8\xb2\x81\xf9\x52\x05\xde\x25\x85\xb6\xc3\xce\x8d\x10\x1b\xce\x96\x45\xaf\x10\xe0\x76\x27\x64\xb3\x67\x32\x55\x4d\xae\xb4\x67\xcf\x06\x03\x36\xda\xa6\xd7\x69\xbb\xbf\xbf\x2e\x95\x5d\x0d\x69\xea\xc0\x28\x38\x00\xba\x29\x16\xd9\x51\x73\x99\xa4\xf3\x26\x99\x4b\xa9\x4e\xc6\x1e\x3d\xaf\x51\x28\x85\x41\x53\x34\x29\x44\xfb\x50\x37\xa0\x61\xfd\x08\xd7\xba\xc2\xc4\xa4\x16\x70\xf7\xc8\x53\x8d\x05\x6b\x0b\xab\xa6\xa4\x49\xc1\x01\x52\xa4\x83\xbc\xd5\xe4\x01\xde\xd2\xcb\xd4\x9d\x6f\x9a\x29\x52\x9d\x2f\x3a\xda\x0a\x17\xc5\x8b\x7e\x4c\xda\x1a\x20\xff\xc8\xb2\x9f\xc6\x1d\x33\x8b\x5e\xd1\x26\x4f\xb5\x8e\x5a\x67\x6d\xb0\xac\xcf\x27\x68\xeb\x3f\x6f\x50\x63\xdf\xdd\x2c\xfd\x2b\xbd\xc0\x0b\x79\xd9\xd3\x61\x50\x47\x2f\x01\x7a\x02\xdd\x10\xb8\x9a\x2e\xfc\x58\x2a\x9b\xd2\x14\x5c\x6b\x4b\x6a\xae\x96\x29\x05\x31\x44\x9b\x29\x84\x20\x43\x5b\xa0\x03\xec\x13\x5d\xf6\xc0\x44\x6e\x73\x91\x8b\x94\x53\x17\x27\x1a\x45\x5b\x8f\x22\xae\x3b\xe0\x04\xfb\x9e\x7b\x3f\xb0\x08\xf8\x0c\xb6\x19\x8e\xc7\xdf\x76\xc7\x1f\x2b\x20\x73\xca\x14\x65\x21\x51\x39\x24\xf0\xec\xb7\x74\xf0\xe9\xfa\xfb\x27\x2a\x5a\xb9\x9b\x89\xcd\x2f\x79\xfe\x5e\x66\xf4\x62\xb7\x80\x9f\xf7\xf9\xb7\x6c\xfd\x76\xb0\xe2\xf3\xdd\xe7\xfb\x2f\x6f\xde\x4d\x1f\xb7\x7e\x81\x9b\x18\xcc\x29\x24\x11\x94\x8a\x38\x6a\xd0\x7c\xd4\x8b\xe1\xc8\x2b\xff\xa0\x1a\x04\xa8\xc1\x08\x93\xaf\xb5\xba\x0a\x1a\x30\x8a\x4e\x51\x24\x45\xbe\xc2\xce\x13\xed\x48\x64\x15\xd7\xb0\x70\x91\x63\x1a\xfa\x0a\xec\x7b\x8a\x53\x09\xd9\xc0\x53\x0c\x1a\x0e\x62\xde\x00\x5b\xad\xe8\x24\x69\x5a\x9a\xa6\x4d\x59\xf5\xaf\xb1\x14\x51\x98\xe4\x6a\x57\x44\x9b\xad\x1d\x28\x78\xb0\xcc\xea\x51\x61\x90\x77\xa8\xea\x26\x18\x3a\x0f\x05\x45\xb5\xa6\x46\xbb\xa9\xca\x51\xad\x75\x2e\x51\x34\x0e\xad\xe2\x2a\x71\x2e\x10\x5b\x41\x24\xe3\x92\x58\x8e\xe6\xe0\x10\x82\xc1\x39\x93\xcf\x22\xc4\x1a\x41\xd9\x10\x8b\xb2\x04\xf0\x13\x70\xd7\x62\xb3\x93\x00\x0f\x3c\x3d\x91\x75\x7f\xed\x53\x42\xde\x01\x85\x2b\x2f\x4d\x47\xc4\x6b\xec\x3b\x6c\x29\x32\xf2\xb2\x09\xc5\xff\x61\x96\x46\x14\xb2\xb6\x74\x6d\x58\xae\x8e\xa2\xd8\x76\xdd\xe5\x3a\x37\x44\x51\x52\x97\x73\x8c\x6e\xb6\x11\x04\x23\x82\x3e\x41\x07\x71\x77\x9b\x8e\xed\xee\xb0\x71\x08\xbf\x5b\xab\x98\x62\x4b\x2e\xec\x6b\x69\x07\xf8\x50\x51\x2b\xaa\x30\x29\xdc\x82\x0b\x7b\x99\xd7\xea\x69\xb0\xfc\x28\x05\x84\x14\x55\x29\xbd\x12\x33\x44\xec\xf9\x46\x2b\xcd\x5c\x4c\xc8\x4b\x88\xa2\x28\xdc\x5c\x06\x28\xd6\xbd\x20\x3c\xb0\x2c\xa1\x7b\xc1\x29\x2d\x47\x7a\x97\x47\xa8\x72\x2d\x5e\x96\x66\x10\x12\x22\xce\x3b\xb7\x27\x31\x92\x3a\xff\x14\x44\x52\xe7\xeb\x08\x49\x39\x16\xd7\x7a\x39\xf8\xae\x95\x01\x17\xd9\x4f\xe2\x15\x09\x6a\xa5\x4b\x8f\x5e\x59\xee\x84\x93\xd5\x9a\x42\x3d\x5c\x6a\x13\x2a\x41\xb9\x85\xd9\xac\x62\x99\xb5\xb5\x2c\xb0\x2b\x6f\x23\x86\x7c\xfd\xf8\xc7\xa7\x37\x6f\xa7\xbb\x0b\x2e\x8d\x63\x79\xcc\xbf\x24\x8c\xf1\x4d\xc4\xb9\xfb\x87\x2f\xef\x2f\xd8\x31\xfd\xfc\x95\x3a\x9f\x56\x6d\x6c\xa3\x53\x29\x5c\x76\x74\xaf\x65\x42\x67\xd1\x29\x6c\x6d\x97\x42\x61\x5a\xfc\x99\xfe\xb6\x67\x11\x18\xd0\x37\x0f\xdb\xfd\xea\xa7\xdd\x04\xbc\xdc\xa0\x21\xbd\xbb\x45\x17\x0e\xc8\x3f\x6d\xf0\xaf\x80\xfc\x8b\x47\x7a\xc9\x5f\x71\x3b\xb8\x17\x19\x11\x5d\xa3\xd9\x37\x71\xe2\x4f\xe4\x89\x57\x40\xc6\xc7\x98\x6b\x67\x0c\x90\x03\x04\x53\x85\x09\x38\x21\x97\x15\xcc\xf1\x11\xdc\xda\x39\xbd\xb4\xbe\x13\x14\xb8\x5f\xf9\x52\x35\x96\xbf\xe0\xa5\x9e\xfb\x4e\xbb\xe1\xb8\x4d\xed\x37\xb6\xe2\xd6\x34\x7e\xd8\x4e\xe3\x2d\x3d\xf9\xe9\x34\x26\xd8\x82\x63\x88\x34\x23\x03\x10\xcb\x86\xf9\x50\x4e\x14\x1a\x76\xa5\x4c\x19\xce\x93\x64\x95\x29\x62\x0f\xa5\x3c\x43\xf7\x50\x02\x9e\x35\x0b\x35\x29\x64\x54\x31\xb4\xf1\x5c\x60\xe6\xe4\x32\x37\x24\x09\xb2\x21\x30\x2e\x00\x0c\xcb\x69\x89\x15\x1b\xf5\x61\x85\xbb\x35\x00\x8a\x65\x1c\x1c\x7c\x8e\x7b\x69\xcd\x01\xc9\x09\x31\x1e\x7c\x6b\x13\x58\x2b\x89\xf2\xac\x5c\xee\x88\xec\xa4\x0e\x22\xbb\xd6\x64\x16\x46\x97\x53\x3c\x78\x02\x74\x77\xe1\xdd\xec\x91\x39\xe5\x8b\x03\xca\x6e\x26\xcd\xc4\xe8\x51\xe1\x0b\x65\xeb\x52\xc8\x1a\xfd\x3b\xad\x68\x86\x20\x3c\x46\x82\x6a\x5a\x51\xa6\xe3\x31\xf7\x5b\xcd\x74\x55\x78\x26\xdf\xc4\x1e\x9f\x39\xc9\xfd\xe1\x99\xb3\x0a\x13\xe4\x03\xb6\x57\x79\x06\x81\x11\x1c\x8d\xf0\xbd\x81\x30\x87\x0c\x65\x2b\x1b\x8b\x85\xe2\x76\x56\xc0\xed\xe8\xd1\x2b\x43\xb5\x1b\x25\xd2\x99\x31\x5d\xea\xa1\x84\x3d\x85\xfc\xd4\xd2\xdf\xfd\xc0\x04\x3d\x65\x03\x7e\xd6\x92\xe7\x78\xf0\x5d\x3a\x3b\xe6\x43\xef\x7b\x0a\xe0\x5f\xd2\x7c\x55\xa4\xd7\x2c\xeb\xd1\x81\x78\xef\x19\x4e\x1b\x51\xfb\x33\xe6\xe0\xe4\x2b\x89\xf9\x45\xd8\x1a\xea\x5e\x46\xdc\xa7\x90\xf6\x14\xda\x8b\xc5\xc0\xee\x97\xbe\xe0\xbf\xfa\xf2\xff\xba\x7c\xf9\xf8\xcf\xfb\x65\xff\xe5\xe1\xdb\x1f\x9b\x9c\xb1\x77\x5b\xf4\xe6\x13\x7b\xbb\x9a\x8b\xef\xf9\xe4\xd3\x54\x11\xa8\xb9\xc8\xdc\x7a\xde\xa9\x95\x9b\xd2\xd9\x57\xc3\x7a\x57\xaf\x90\x6b\x01\x74\x1a\x1d\xf8\x5e\xc0\x18\x53\x57\x31\xc5\xe4\x62\xe8\x33\xc5\x28\x33\xc0\xc5\x8e\xcf\x19\x40\x39\x00\xa2\xa2\x8e\x18\x9c\x18\xcf\x55\x01\x72\x49\xd1\xcb\xe1\x98\xa1\xa6\x35\x03\x6c\x80\x28\x2d\x0e\x04\xf3\xac\xbc\xcd\xa0\x4c\x9b\xbc\xec\xba\xbb\xc9\x28\x52\xb3\x99\x2d\x14\xa2\xe3\x90\x67\xdf\x1a\x10\xea\x99\x82\xd6\xfb\xe9\x9b\x52\x33\x9f\x90\x34\x23\x23\xa0\xa3\xe1\x0f\x8d\x1e\xa3\x55\x29\x2c\x0c\x13\x96\x3b\x4a\xc0\x39\x38\x70\xef\x96\x32\x67\x55\x78\x3b\xd6\xee\xde\xd7\x14\xbf\xbf\xee\x3d\xb8\x94\xda\x3e\x11\xcd\x9a\x02\x50\x9d\xb7\xe9\x85\x34\x5b\xb4\x82\x67\x25\x07\x2b\xca\xf0\x4b\xd2\x95\x48\xc8\x43\xd8\x16\xe8\xf9\x33\xa4\x38\x4c\xc0\x1c\xcd\x1d\x1a\xd4\x51\x86\x98\x0c\x9f\xbc\x46\xcf\x8e\x23\x5e\x3e\x20\xe7\x42\xac\xb8\x82\x40\x9e\x8c\x2a\xf2\xdd\x9b\x63\x3e\x10\x02\x34\x88\x70\x80\x01\xcd\x23\xe1\x40\x6c\x98\x89\x5d\xac\x87\x94\x26\x0a\xec\x50\x5e\xe5\x31\x6e\xd2\xbe\xc1\x16\x55\x96\x11\xa4\x50\xbc\x9a\xea\x94\x27\x65\x4e\xea\x11\x04\x96\x40\xae\xb3\x16\xcc\xab\x33\x92\xd9\x6c\xe0\xd8\x1d\xd7\xb9\x56\xe8\x77\xcc\xae\x95\x39\x55\x31\x3f\x53\x05\xc0\x95\xba\x63\x65\xbe\xe4\x3a\xc3\x8c\xeb\x4a\x6e\x55\x6f\x07\x44\xbf\x7d\x7a\x7f\xff\x65\xfa\xb8\xa5\x3e\x7b\xf7\xfe\x1f\x2b\x45\xbf\xa3\x48\x11\x3d\xcc\xd8\xea\xd2\xe4\x23\x42\x3f\xd1\x11\x1c\x3c\xc6\xf7\x86\x14\x50\x38\x7e\x91\xae\x2b\x5d\x38\x37\x85\xb1\x6c\x2e\xce\x44\x28\x82\x4a\xc5\xe5\x39\xcb\xd7\xad\x38\x9e\x90\xe8\x9e\x26\x31\xea\xd3\xc1\x77\x50\x0e\x22\x1d\x9e\xc1\x71\x64\x0c\x84\x20\x28\xb0\x42\x0e\xcc\x63\xb8\xda\x86\xd8\x51\x0c\x02\x1e\x38\xfd\x9c\x81\x67\xe4\x99\xfb\x84\xba\x8d\x16\x50\x63\xa3\x5b\x90\xe7\x60\x88\x41\xdd\xf5\x82\xd9\x05\x54\xbd\x6a\xeb\xa7\xee\x06\xa8\x57\x17\xe3\x18\xac\x67\xcd\xf5\x0e\xac\x3f\xe4\x73\x96\xec\x4a\x9a\xa1\x9b\x29\x5e\x5b\x9a\x99\x5c\x05\xc6\x18\x63\x30\xa4\xb9\x51\x39\xf8\x90\x51\x4c\x86\xa7\x85\xef\x72\x17\xd3\x3b\xc1\x9f\x0b\x78\x15\xa4\x24\x37\x0c\x9b\xb4\xab\x56\x17\xd3\xe4\xd5\x3f\x80\x25\x19\x27\x19\xf1\x3d\xe2\x6b\x98\xe2\xe0\x2e\x8b\x8e\xba\x4c\x9b\x09\x49\xd6\xb3\xe6\x99\x96\x41\xb2\x5a\xd5\x4d\x4a\xc6\xfa\x60\x0e\x7d\xe4\x0f\x5b\x29\x0e\x96\x65\x35\x00\x2d\xfb\x3f\xd1\xce\xaa\xf0\x74\xaa\x2e\x06\xe4\x3e\x2b\x1e\x2d\xb0\xc2\x7a\x41\x6f\x76\xbb\x24\xca\xea\x23\xc3\xc1\x50\x04\x47\x56\xe2\xec\x92\x07\xd2\x1e\xcb\x63\xb3\xc1\xea\x89\xd4\x40\x55\x6f\xe8\x06\x60\x8b\x9c\x9e\x38\x03\xbf\x08\xd6\x70\x72\xd0\xb6\xc4\x92\xa9\xea\x3f\x52\x4c\x59\x85\xa7\x6a\xf2\xe6\x5a\xb9\xd4\x8c\x57\x28\xd6\x43\x8c\x58\x9e\xad\x59\xd5\x91\xa2\x18\x45\x8d\x70\xb8\xd8\xcd\xc2\xf2\xbd\xac\x72\x19\x52\x1a\x42\xbc\x6b\x1a\xdc\xee\x44\x88\x7b\x48\xf1\x73\xb1\xaf\x52\x5f\x85\x3e\xd2\xe6\xc6\x16\x21\x3b\x04\xdf\xce\x2c\x5b\xee\xde\x4e\xdb\x65\xb6\xcd\x5b\x3d\x86\xe7\xe0\x10\x2d\xe1\xb8\x39\x9f\xb5\x57\xf9\xea\x2f\xb4\x76\x6c\xc7\xe7\xcd\x05\x0d\xfc\x79\x6b\xf1\x80\x9c\xd2\x5f\xf7\x00\xcd\xbc\x7d\xe9\x2b\xec\x5e\xfa\x0e\x9d\xdb\x5f\xfc\x0e\x7f\x6d\x2f\xc1\xf2\xd7\x5e\xda\xfd\x85\x2f\xf1\xd7\x76\x13\xc0\x76\x7e\xa8\x9b\x76\x2f\x79\xc4\x5f\xfb\x12\x40\xee\x53\xa5\x36\x28\x84\xcd\x95\x9c\x59\xf8\xfe\x2e\x63\x5c\xeb\x85\x5b\x0a\x09\xb9\xe4\x52\x3e\xea\x6d\x07\xf0\x9f\x77\x7f\x7c\x7c\xf7\x58\x6c\xbc\xdf\xa6\x16\x9e\x44\xf5\xa9\x07\xd7\x73\x9e\xb8\x47\x07\xe6\x26\x0a\xd5\x51\xa8\x96\xa3\xcf\x1d\x6f\x1a\x2b\xde\x74\xa5\x2f\x6d\x43\x1f\x6c\xd8\x2b\x81\x86\xbb\xa2\x2a\x00\x34\x41\x01\x1e\x26\x4f\xbd\x39\xea\x6d\xc5\x7d\x50\x34\x1b\x85\x84\xc0\xe5\xb8\x7a\x60\x29\x38\x85\x5b\xf0\xd4\x26\x02\xbf\x58\x6f\x03\x8c\x41\xef\xfd\xfd\x35\xae\x49\xb1\x4d\xca\x0e\x3f\xf9\xf1\x19\xe1\x2a\xc7\xa7\x7c\x80\x14\x7c\xd2\x7f\xf1\xd5\xf7\xd7\x45\x2d\xa3\xb2\x9b\x10\x1f\x29\x61\xf2\xeb\x01\x70\x4c\x7b\xc1\x01\x3e\xe5\x97\x12\x26\xfb\xd0\x6f\x65\x5a\x95\xe2\x6a\xff\x91\xa7\x77\xfe\xd1\x86\xdf\xdc\x29\xbe\x7c\xdb\x12\xce\xbc\x7f\x46\x16\xf8\x05\x64\xbe\x81\xcc\xbd\x0c\xa4\xee\x33\x04\xcd\xe5\x0c\x47\x96\x33\x20\x2f\x50\xec\xc0\xb9\xec\x3d\xe5\x76\x34\xdb\x9c\xef\x93\xed\xfa\xb2\xf9\x76\x67\xff\x31\x1f\x7c\x0c\xab\xff\xf2\x67\x1b\x61\x76\x25\xdc\xa0\x81\x2d\xc5\x07\xba\x8c\x91\x24\xc6\x51\x25\xbc\x5b\xeb\xd1\x35\xeb\x47\xc1\x78\x87\xe1\xc9\x96\x28\x17\xec\x8b\x41\x42\xf8\x3c\x60\xf2\x91\x5c\xf4\xbc\xb3\x0b\x2a\x98\xd7\x38\x44\x58\xb3\xf4\xc6\xc3\xd9\x9a\x57\x06\x85\x22\x1d\xd5\xc1\xa6\xb5\xa1\xac\x59\x48\xe7\xfe\x5b\x0b\x81\x34\xe5\xd1\x8f\x79\x91\x9e\xda\xa1\xfc\x1a\xa9\x41\x45\x01\x5f\x45\x45\x5c\x31\xbd\x62\x98\xc6\x02\xd5\x9a\x05\x38\xa3\x22\x2f\x28\x0c\xa2\xb8\x3f\xee\xc7\x8f\x9d\xc5\xd2\xdf\x2f\x74\x16\x7f\xfe\xf8\x69\xb9\xff\x72\xff\x75\x93\x44\xf3\x9e\xcf\x1c\xf6\xe6\xd2\x7d\x36\x92\xca\x0c\x7b\x0f\x16\x5b\x73\x91\xc5\x2a\xea\xd1\xd5\x06\x56\xa7\xee\xa2\x6c\xc9\x8e\x89\x66\xd6\xc2\x28\xd8\x94\x28\x72\x56\x8d\x1f\x38\xbe\x48\x72\xa3\xa2\x0c\xe8\x48\x84\x03\x99\x57\x66\xc7\x55\x63\x18\x40\x6f\x44\x12\x21\xe8\xcd\x51\x11\x58\x40\x02\x9a\x5d\x89\x47\x8c\x53\x70\x78\x83\xf4\x00\x7e\xc1\x8a\x62\x3d\x24\x9e\x29\x72\x3e\xca\xed\xfb\x9a\x93\x28\xfb\x83\xe1\x29\x27\xe5\xdb\x6e\x51\xe1\xe3\x89\x48\xf3\x41\x80\x65\xcb\x61\x66\x57\x91\x3a\xb2\x88\x70\x98\x8b\x33\x66\xf3\x14\x81\xa9\x59\x34\xdb\x42\x03\xc2\x84\x7c\x0d\xc4\x5c\x40\xc1\xc8\x0a\xb0\x17\xf0\xb2\x00\xe0\x54\x9e\x72\xdf\x78\x84\x5b\x48\xcd\xfd\x1a\x94\x91\x5a\x7a\x06\x00\x91\x86\xab\xd0\xa1\x53\x6b\x3c\x32\x19\xab\x89\x3e\x62\x86\x67\x02\xc9\xd1\x0a\x88\x09\x4c\x57\x2d\xf8\xaf\x0a\xc6\x99\x75\xe7\x68\x71\x81\xc9\x12\x77\xb3\x2f\x9a\xb5\xae\x96\xec\xa2\x85\x9a\x5a\x6e\x23\xd6\x11\xec\x10\x9e\x7c\x97\x69\x05\x10\x80\x6a\xc8\xf3\xa0\xf7\xaa\x33\xd2\x22\x3b\xd2\x56\xa3\x63\x2c\x39\xae\x2e\x71\x7c\x1e\x7d\xda\xcf\x42\xe7\xac\x73\xf9\x22\xe3\xec\xfb\x23\x0a\x3f\x27\x03\xd1\xb9\x19\xe6\x7a\x6e\xc8\xad\x72\x9e\x5b\x86\x59\x4f\xa1\x39\x46\x45\xae\x4c\xf0\x28\x2f\x3d\x33\xd9\x04\x7f\xa5\x70\xd4\x23\xd7\xb1\x0d\xa6\xfa\x8e\xd7\x4f\x36\xf9\x21\x11\x22\x06\x08\xc0\x96\x32\xa1\x61\x7c\x76\xcd\x7c\xc4\x24\x86\x7b\x4d\xe6\x70\xaf\xca\x0e\xeb\xd5\xe4\xf5\x64\x3c\x97\x9a\x14\xae\xd4\xdd\x2a\x69\x83\xc1\xcf\x60\x92\x17\x43\x6c\x69\xc7\xf9\x3e\x58\x11\x02\xbb\x68\xe4\xfe\x61\xa1\x21\xa0\xc1\x70\xe5\x95\x1b\xc7\x05\x83\xe0\xe9\xc0\xd1\x4f\x8e\xb2\x2b\x74\x32\xf5\xd5\x03\x85\xba\x88\x80\x0c\x4b\xfc\xab\x25\x05\x8e\x95\x72\xc7\xe8\xc6\x51\x8f\x98\x30\x08\x70\xa3\xfb\x46\x4b\xb3\x7a\x08\xed\xfb\xd2\x0c\x21\xdb\x73\x13\xf1\x3b\xaa\x2b\xdb\x70\x2d\xf4\x7a\x3a\xf5\xa3\x4e\xfd\x64\x53\x5f\xc3\x3c\x0a\xd6\x83\xa4\xa0\xaa\x10\xf4\xa9\xeb\x7e\x64\x68\x8d\x58\x4f\xe8\x02\x5b\x4f\xda\x56\x23\x10\x4a\x0a\x07\x11\x0d\xc6\xba\x32\x72\x15\x88\x49\xf5\x85\x04\xc4\x12\xc4\x06\xd4\x6e\xe7\x9c\xf6\xf0\xd4\xfd\x7c\x20\xf6\x36\x54\xd4\xc3\xc3\x1f\xd3\xfd\x9b\xcf\xd3\xb7\xaf\x97\x67\x7c\xfa\xc7\xca\x78\x52\x5d\x01\xf2\x2f\x23\x5c\x50\x12\x02\x08\x07\x19\xf7\x3d\x53\x9d\x07\x2c\x80\x8e\x77\x0e\x83\x06\x27\xc7\x31\x59\x14\xce\xb7\xaf\x00\x32\x20\x40\xc6\x00\x75\x57\x69\x01\xe7\x43\xa5\xc5\x3e\xf4\xdb\xb9\x03\x6e\x3f\x03\xce\x7a\x92\x29\x4a\x01\xc9\x0a\x23\x7b\x22\x57\x85\xb6\x25\x1d\x4a\x64\x86\x1e\x6b\x25\x46\x42\xf0\xc9\xe1\xf1\x8c\x99\x0a\x52\x00\x8b\xd6\xa6\x88\x90\x40\x36\x79\x0d\xc8\xce\x64\x97\x5b\xde\xed\x29\xf4\x03\x11\xf8\xba\xc7\x01\x85\x83\x3f\x3f\x3a\x3b\x20\x0a\xff\xaa\xec\xc1\xcf\x9c\x0b\x9b\x69\xb0\x49\x4e\xe3\x18\x8e\x05\x12\xb1\xba\x02\x09\x6d\x09\xea\x28\x8c\x56\x15\x28\x81\x2d\x38\x2d\x3e\x96\xae\x21\x9c\xd9\xeb\x6a\xf5\xdc\xb2\xcb\x22\x3e\xa2\xac\x7f\x59\x98\x59\x04\x40\x5a\x7c\x6e\x8e\x5b\x5e\xec\x63\x7c\x3d\xce\xd3\xeb\x66\x86\x5f\x31\x75\x50\x99\xb0\xe8\xa5\x48\x93\x82\x53\xb7\xaa\x81\xc5\xa8\x2f\x44\xea\xbd\xe9\x66\x98\x91\x85\x45\x07\xd3\x7d\x02\x7a\x01\x50\x5f\x21\x3d\x96\xe3\xd1\xd9\x19\xeb\x95\xbb\x91\xc7\x0a\x9d\x2e\x9a\xb8\xcd\x22\x79\xc1\xfb\x59\x81\x63\xdb\x65\x4b\x84\x58\xac\x49\x13\xc6\x38\xf3\xbe\x74\x06\xf8\x52\x01\xec\x93\x6c\x84\xdf\x5f\x4b\x3f\xba\x9a\xf2\x41\xa4\xd5\x5e\x94\xa3\x83\xfc\xb3\x97\x3f\x0f\x7a\x10\xfa\x41\x7e\xc3\x67\xe8\x7b\xf9\x01\xa7\x70\xb8\x5d\x4d\xfa\xe7\xc3\xa7\xfb\x4d\x9a\xe1\xfb\x6d\xe6\xd9\x31\xa9\xbe\x96\xe6\x62\x4b\xd0\xfe\xbb\x65\xf1\xa4\xd4\x64\x9e\xa7\xc9\x13\x5c\xe9\xb1\x4e\x48\x99\x45\x55\x6b\xac\x2e\xcb\xdb\xef\x19\x78\xaf\x96\xf7\x03\x8b\x8a\x5b\x18\x1a\x5f\x35\xaf\x3b\x25\x5e\x54\xd7\x12\xe5\x68\x31\xa2\x24\xf9\xb0\xea\x23\xec\x4c\xb1\x39\x7c\x06\x05\x2b\x22\xbb\x04\x57\x30\x39\xb9\x89\x7d\xac\xdf\x1f\xcf\xb5\xab\xc7\xdd\x4e\x9e\x70\x7c\xae\x35\x65\x94\x6f\xb7\xb4\x3b\x64\x3a\xc9\x6d\x7f\xa4\xd9\x8f\xa8\xfd\x45\x43\xe0\xe0\xe5\xd2\x8b\x69\xfd\x7b\xbb\x50\x7e\x3c\x2b\x57\xb2\x2a\x2c\x33\x70\xec\xee\x17\xb3\x4a\x6a\xe7\xcb\x79\x1e\x7a\xd1\x63\xdd\x5d\x4e\x7f\xa1\xee\xfe\xee\xee\xcb\xfd\x72\x11\xf7\xf1\x7d\xbd\x41\x1e\x0d\x5f\x92\xf2\x4e\x9d\xb4\x7c\xf2\x49\xa6\x08\x0a\x4c\xcf\x6b\x41\x97\x51\x4b\x2d\x27\x8c\xdf\xd7\x5a\xea\xb3\xa2\x80\xd6\xcb\x8f\xbd\xc4\xb6\xfa\xf2\x7d\x7b\xea\x15\x2c\x3d\xec\x52\xe7\x4b\x3b\xae\x16\x30\x4c\xe3\x3d\x06\x96\xb0\x53\xc0\x08\x4f\x7d\x5a\xfb\xc0\xde\xef\xd9\x2f\x70\x09\xe5\xf8\xfd\x86\xb9\xbd\xa4\x70\x6a\xf1\x87\xd6\x0e\xde\x2a\x09\xb7\xaf\xf1\x9c\x7e\xbf\xf1\x2e\xcf\xef\xfc\x8b\xd8\xbe\xef\x37\x39\x43\xc7\xc6\xe7\x7a\x34\x08\x9f\x3f\x81\xc6\x02\xd0\x17\x3e\x9f\xff\x3f\xd3\xff\x0f\xd3\xb7\x3f\x3f\x6d\x77\xbd\x6d\xb2\xc8\x29\xc1\x6f\x70\x61\x5f\xc2\xc8\x1a\xd6\x1a\x77\xba\x95\x6f\x68\x4a\x41\xe4\x83\x9c\xb7\x5e\x22\x3b\x43\x68\xd7\x13\x11\x4f\x1c\x92\xb7\x39\x6d\x6f\x38\x24\xaf\x71\xda\x5e\x73\x48\xde\x8e\xab\x3f\x7c\xd9\x8e\xf5\x36\x9c\xfe\x68\xad\x6d\x6a\xde\xff\x4a\x71\x71\x45\x42\xfd\x9e\xe5\x2d\xfd\x75\x59\xc6\x6e\x71\x6b\x7e\x67\xa7\x3d\xf9\x0e\x17\x44\xec\x36\x78\xf5\xd4\x2e\xf1\x7b\xc6\xe0\xfe\xd3\xe1\x7e\x7a\xf8\x7c\xff\xe6\x6e\xda\xcc\xdd\xfb\xad\x2b\xfd\x34\x15\xa4\xb3\x6b\x5c\x0e\xbe\xf6\xf4\x43\x08\x1a\x72\x5d\x1a\xb5\x57\x24\xea\xf1\x0c\x64\x62\x4e\xc5\xa5\x2e\xba\x72\xca\x20\x27\x49\x0c\x6b\xd3\xa8\x3c\xd5\x0c\x4f\x6d\x41\xa1\x11\x8b\x7e\x4f\x7b\x9a\xb3\x96\xb5\x07\xe0\xa8\xe9\x49\xa9\x2d\xb8\xae\x00\x4d\xa7\x6a\x22\x55\xea\x62\xc3\xe2\xc6\xc8\xe5\x0e\xae\xd5\x13\xc8\x8d\xd9\x22\xea\xc8\xf1\xc8\x70\xb3\x68\x94\x76\x37\xfb\x58\x51\xf2\x42\xce\x27\xd4\x5f\x21\xea\x6e\xf1\x64\x7e\xb5\xf2\x3b\x81\x11\xa1\x2d\xca\x01\xa9\xa0\x57\xd5\x42\xc6\xc8\x5d\x12\x0d\x66\xef\x09\x89\x1a\x9a\xc6\xd5\xed\x14\x9c\xc1\xce\x2e\x4a\x70\x0f\x27\x5e\x19\xdc\x3a\x21\x4f\x4e\x2c\x30\x6a\x9a\x48\x14\xb2\x68\x7c\x30\xae\xd9\x25\x76\xa6\xe3\x2b\x46\xae\x28\x81\xea\x3a\xad\x0d\x94\xcf\x8e\x62\x58\x50\xd6\xee\x32\x6b\x94\x16\x96\x9e\xf9\x4d\x20\xe6\xd4\x05\x70\x5b\xd0\x4d\x1f\x3f\xfd\xf3\xfe\xfd\xc7\xcd\xba\xbd\xa7\x35\xfb\x3e\x75\xd7\x89\x0e\xbe\x77\xda\xfb\x18\xc3\x41\x0e\x62\x0c\xdf\x5f\x47\x0c\x04\xd5\x99\x14\x48\x21\x1b\xa0\x25\x1f\xd3\x09\xbb\xa6\x7b\x19\xce\x03\xbb\xd4\xd1\x73\x84\x32\x84\x9a\x94\x18\x54\x13\x07\x50\x07\x3a\x20\x94\xa2\xa6\x03\x2e\x9a\xe4\xc7\x27\x24\xbc\xed\xe0\x73\x69\x7b\x1f\xb9\x1f\x72\x84\xb5\x18\xb2\x96\xf5\x3b\x2a\x86\x0c\x26\xe6\x6e\x06\x28\x66\x89\xe6\xac\x7b\x35\x20\x33\x51\xed\xe9\x7c\x53\x02\x0b\x1a\x9c\x17\xce\x37\x3a\xf8\x9c\x23\x6e\xbd\x9b\xd9\xc5\xde\x1d\xbb\x22\xf3\x9c\x1c\x23\xb4\xe2\x52\xdb\xcb\x83\x3d\xa5\x24\x6f\xc6\xc1\x45\x25\x5a\x2c\x9a\x3d\x98\x79\x69\xe6\x6a\x51\xbb\x89\x74\xc6\xc2\x87\x55\x75\x40\xe0\xab\x93\x99\x15\x9f\x4a\xef\xfa\xf6\xe9\xfd\xc3\x66\x64\x2e\xba\x9c\xc5\x82\x54\x1b\xaf\x03\xad\x0a\xb4\x41\xb0\x4e\x61\xe0\x89\x61\xd1\x8d\xf2\x83\x40\xef\xe7\x23\x57\x57\x75\xea\x15\xd4\x52\x2b\x0c\x29\x4a\xfe\x46\x86\x5a\x33\x1e\x8d\x89\x62\x75\x28\xdc\x0d\xae\x3b\xce\xae\x03\x1f\x8b\xd5\x99\xc5\xb3\x0c\x7e\xcf\x0e\x25\x30\x94\xea\xc2\x28\x40\xe1\x35\xc5\x44\xee\x03\x84\x0f\x54\x1b\x3b\xf5\xaf\xe1\x5f\xad\x3f\x56\xca\x2b\x9c\xb7\xf8\xd3\xe3\x93\x73\x10\x08\x39\x5e\xed\x8f\x77\x9d\x7d\x6f\xc6\x2c\xa2\xa8\xa9\x8b\x16\xbf\xc1\x34\x42\xd3\x51\xbb\xf6\x57\x80\xc6\x44\xe3\xe2\xd2\xd8\x23\x39\x56\x0e\x73\xf5\xde\xc1\x2b\x91\x15\xff\x4b\xeb\x25\x31\x02\xcb\x3a\x26\xeb\x30\xd9\xc0\xdd\x5e\xa9\xf7\x7f\xdc\x6d\x92\x7d\xef\xb7\x85\xcf\xa7\x72\x5d\xa6\xdd\x91\xab\xc9\xf9\x1e\x34\x4c\xea\x15\xb7\xad\xdb\xb7\x64\xe8\x6e\x71\x50\xd4\xd6\xc9\xc7\x12\x5d\x44\xc8\x67\x83\xee\x96\xa2\x93\xc5\x60\xa0\x51\x93\x2c\x37\x24\x11\xcf\x9a\xb4\x94\x34\x97\x95\xd2\xe2\x81\xeb\x6b\x30\xd5\xea\x1e\x64\xcb\x0f\x13\x05\x2d\x58\x50\x8b\x0c\x8d\x75\x29\xf6\x69\x5e\x09\xf9\x49\x7d\xac\xb3\xe6\xfa\x59\x71\xca\x5a\x36\xa9\x6e\xb6\xa6\xc5\x4f\xac\x2c\x54\x86\x66\xa0\xf4\xf8\x6c\x40\xa9\x1a\xd8\x03\xdb\xb7\xc7\x3c\x3f\xa9\x67\x99\xfc\x28\xfb\x1b\xe0\x0e\xa8\x67\xd1\x5c\x4d\xf8\xa0\xca\xd2\x1d\xb3\x02\x53\xca\x67\x19\x01\x2d\x45\x8e\xec\x0b\x29\x04\xfa\x1c\xad\x16\x06\x00\x0c\x48\x16\x53\xe8\xee\xc5\x1c\x86\x03\xf4\xd5\x17\xfb\xa4\x60\x10\xcf\x72\x60\x78\x8e\x0a\x58\xab\xa8\xa5\xc9\x59\x8f\xc6\x84\xf0\x57\x9a\x62\x92\x3d\x0f\xe9\x8e\xf8\xc2\x51\x5a\xb4\xb7\x0d\xfe\x5d\x21\x1e\x89\x0d\xeb\x11\x3b\x78\x18\xa1\xb8\x60\x00\xd6\xc5\x3e\xe1\x53\x2f\x03\x7b\x15\xfd\x1c\x15\x09\xa3\xcd\xd1\x45\x67\xaf\x0a\xd6\xc9\x15\x20\x13\x17\x00\x88\x5e\x3f\xfb\xc2\xc5\x81\x86\xe9\x58\xea\x84\x52\x4a\x6f\xb5\x94\x47\xd0\x8c\x91\x40\xab\xee\xba\xa2\xb9\x0b\xd2\x54\x45\x95\xe4\x35\xd6\x69\x05\x5c\xaf\x06\x7a\x61\xd3\x21\x05\xc7\xad\xcd\x02\xf9\xdc\x61\xd7\xd6\x54\x4f\x5a\xa1\xbb\xf3\x1a\x76\x1c\x28\xe7\x00\x84\x5e\x91\xa1\xa3\xe1\xc4\x92\xce\xca\xd9\xfa\x58\x27\xee\x62\x13\xf8\x38\xad\x27\x99\xe8\x00\x89\x4b\x36\xf7\x5d\x8a\x46\x1a\x85\x95\x33\xc9\x5a\x91\x05\x33\x47\xcd\xe6\xd4\x45\x75\x73\x35\xbf\xbf\xfb\xba\x7f\xfb\x70\xf7\x65\x03\x09\x71\x7f\xab\x2c\x3f\xb6\x64\x88\x10\x2b\xfb\xda\x09\x47\xa2\x92\xac\x9d\x70\x15\x9d\xd2\x28\x9e\x1c\x9e\x9c\x71\xbc\x6e\xbd\xd9\x77\x18\xae\xc6\xb8\xfd\x17\x3e\x85\x42\x48\x2e\x66\x9a\x40\x7b\xdf\x78\x2e\x70\xbb\xd7\xa1\x03\x28\xb9\x1e\x77\xc5\x82\x6e\x06\xec\x19\x11\x08\x05\xbc\x2c\xd8\xf1\x1b\x6b\x2e\x25\xd6\x90\x48\x74\x9d\xdf\xb2\x1f\xb5\x41\x1f\x5f\xab\x62\x3c\xa7\xa2\xd1\xc9\xd6\x17\x4a\xc5\x71\x58\x5a\x47\xfd\x39\x15\x10\x36\x5a\x8d\x78\x65\xd7\x69\x00\x45\xfd\xe5\x9d\xad\xc9\x63\x9a\x03\x70\xf6\x9c\xdd\xaf\x7e\x50\xaa\xfc\x77\x0c\xab\x79\x1c\xd5\x22\x82\x1f\x52\xb4\x6c\xc4\x79\xba\x42\x3a\x80\x19\x4c\x8b\xbc\x56\x7a\xd7\x9c\x9c\x28\x5d\x38\x9b\xd9\x2e\x4b\x4d\x93\x1d\x01\x59\x12\xc5\x4e\x40\xb2\x6a\x59\x90\x4a\xd3\x69\x11\x69\x58\xf5\x03\x39\xc8\x48\xea\xe9\x84\xf3\x10\x09\xab\x32\x47\xd2\x13\x9c\xe4\x0f\x7f\xfe\x79\xff\x69\xb9\x68\x36\xdd\xaa\x58\x6f\xa3\x60\x1d\x18\x35\xd8\xa1\x14\xc1\x5a\x23\xe4\x0d\x38\xe4\x46\xd5\xaa\x02\x2f\x6b\xf0\x90\x58\x2b\x44\x3c\x93\x46\x37\x74\x0b\xa8\xf9\x55\x9e\x1a\xaa\x22\x26\x24\x2b\xc1\x76\x4c\xba\x3f\x57\x2d\xc8\x99\x29\xb3\x2b\x11\xaa\x24\x55\x9a\x52\x74\xb1\x4d\xa0\x7d\x44\xe2\x79\x73\x50\x49\xda\xac\x4d\xd2\x16\xa1\x41\xd2\x1e\x6d\xce\x08\xae\xaf\x0d\xc3\xe1\xf1\x77\x7f\xbc\xea\x88\xae\xa8\x71\xfe\x9a\x0c\x0c\x28\x2a\x1e\x51\x04\x72\x40\x8c\x62\xf0\x86\xa1\x52\x57\x95\xc8\x09\x5c\x01\x9a\x0c\x05\xec\x17\x70\xa2\x26\x9e\xd5\x20\x03\xee\x2e\x60\x73\xf7\xa0\xef\x34\xf8\x27\x37\x28\x18\x00\x5e\x74\x00\x18\x52\xd2\xc4\x10\xe2\x85\x45\x80\x1b\xde\xf4\x54\x5c\x5f\x94\x51\xa2\xb9\x3e\x6b\x7e\x81\x26\x8c\x44\xad\xd7\x59\xe4\x6f\xc4\xce\x51\x71\x44\x0b\x57\x97\xb1\x5b\xa1\x8e\x3c\x57\xd7\x64\x46\xc2\x50\x62\x0e\x36\xfb\x59\xa9\x5d\x6b\x72\x04\xed\x9e\x64\x29\xca\x8b\xca\x7b\xca\x6b\x22\x34\xbf\xbe\xef\xb2\xf6\xc1\xb1\x63\x9e\x33\xdd\xbe\x5e\x9c\x6f\xdb\xd0\xc5\x71\xbe\xd5\x60\xf5\x75\x08\x59\x63\x1f\x2c\xa2\x65\x2f\x9e\x4d\x89\x48\xb4\xf8\x6a\x68\x4e\x48\x8f\x1e\xd8\x21\xb9\x2d\x5a\xea\x10\x79\xea\x40\x44\x99\x50\x46\xd0\xd2\x8c\x62\x68\x57\xc4\xda\x99\x52\x72\x91\x94\x45\x3f\xcc\x55\xc9\x1d\x11\x97\xa4\x34\xeb\x33\xe5\x91\x99\x17\x7d\xa0\x3c\xaf\x2a\x16\xd7\x78\x30\x8e\x8e\xbf\x7a\x3d\xff\xbb\xb6\x9d\x5b\x98\x65\x65\x02\xdc\x0f\x2b\x05\x4a\x54\xb6\x2d\xbf\xc0\xd8\x47\xbc\x73\xf1\x76\x00\xa8\xdf\x93\xdf\xfd\xc9\x95\xc0\x8c\xc2\xac\x2c\x0a\x9b\x2d\x6b\x05\x65\xc7\x68\x3a\xf0\xb9\x0a\x92\xb7\x20\x16\xca\xde\x23\xd6\xac\xc1\xc7\x13\x5e\x1b\x14\x49\x00\x71\x0b\x20\xd0\xc1\xc0\xa0\xd9\x95\x09\xf3\x06\xd8\x65\x18\x73\xa7\xb8\xed\x72\x94\x80\xb1\x8e\x68\x3e\x67\x99\x52\xc8\x8b\x19\x00\xf1\x6c\xe5\x62\x78\x0e\x70\x23\x39\x39\x04\x65\x61\x25\xc9\x26\x23\x62\x0e\x09\xda\xb1\xbb\x9e\x9c\xbc\xb4\xbe\x29\x5e\x74\xb7\xe8\x8b\xca\x7b\x8a\xe5\xcb\x45\x41\x0d\x14\x6c\x52\x15\xa3\x94\xe4\x39\x5e\x1f\xa4\xd9\x12\x98\xdc\x5e\x9b\x82\x94\x73\xb0\x9b\xcb\x02\x4a\x86\x39\xef\x41\x53\x63\x78\x6c\x22\x70\xb4\x6c\x63\x61\x51\x4a\x15\x0b\x09\xeb\x0f\x9f\x8a\xf9\x6d\x85\x08\xa2\x9d\x89\x1a\x5d\x91\xb7\x50\xd1\xab\xe8\xf6\xac\xc9\x3f\xd2\xeb\xe8\xf4\x3e\x28\x51\x80\x7c\x20\x32\x4c\x99\xb3\x65\xff\xa1\xc8\xa8\x88\x49\xa8\x0f\x4f\x33\x21\x91\x20\x06\x38\xc5\x18\x5e\xe0\xbe\x03\x37\x79\x67\xc0\xaa\x30\xf1\x52\xaa\x63\x94\xee\xd5\xaa\x60\x0c\x62\x59\x02\x7c\x86\x14\x92\x8b\x6a\x43\x48\x8a\xe3\x11\xae\xac\xa2\x34\x42\xdd\x01\x48\xe7\xab\xe5\x89\x85\xf9\xf6\xe1\xc2\x82\xdc\x84\x88\x5a\x2f\x43\xfe\xb7\xec\x7a\x0d\x8a\xfe\xae\x6c\x49\x69\xf2\x39\x29\x49\x78\xd5\x32\x0e\xf0\x75\xb3\x96\x75\x18\x17\x8b\xe3\x01\xf1\xae\x18\x77\x5d\xc1\xeb\x91\xd1\x56\x5d\x0b\xb0\x48\x8c\xd0\x17\xd0\x46\x5a\xd8\xa0\x1c\x60\x0a\x84\x44\x46\x47\x06\x43\x4a\x56\x2e\x07\x72\x8d\xf3\x0c\x2d\x16\xa5\x02\x0b\x37\xd7\xf7\x91\xe1\x41\x84\x97\xc2\xac\x8b\xa8\x13\x04\xe2\x41\xf5\x26\x00\xbc\xc0\x15\x16\xa7\xd8\x8b\xeb\x6d\x6e\x0e\x68\xe6\x6c\x17\x83\xac\xe8\x89\x32\xfd\xe5\xfe\xcf\xbb\x8d\xf3\xf4\x7e\x1b\x9f\x7a\xe4\x77\xe4\xd6\x56\x0c\x83\x4b\xf8\x03\xc8\x77\xbe\x00\x3f\xb0\xc2\x15\x9e\xa1\x0f\x94\x03\x75\x1e\xe8\xc0\x9d\xf7\xfd\x1a\x6c\xcb\xdf\xfe\xbc\xdd\x2f\x7c\xa0\x26\x9f\x6a\xee\x29\xd2\x4a\x15\x17\x59\x5a\xd2\x2f\x23\x56\x5c\xbc\x99\x7c\xf9\xc2\xde\xe9\x5a\x86\x09\x5c\xb3\x41\x9b\xeb\x35\xad\xd5\xf7\x70\xa3\x0f\x6e\xa7\x7f\x7f\xfb\xf3\xed\x97\xfb\x69\xba\xdb\x4c\x9f\x4d\x6c\xf0\x24\x3c\x25\xfa\x57\x0d\xed\xe0\xf3\x80\xd5\x4c\x2b\x4d\xad\x98\x8c\x01\x10\x13\x5e\x99\xd9\x07\x37\xed\xb5\x98\x9a\x05\x08\x06\x47\x70\x37\x86\x60\x84\xd8\x5b\x77\xb1\x2f\xb1\xbb\xd6\x0f\xf2\xac\x08\xe6\x0b\x11\x56\xb4\xa0\xda\x79\x58\x0b\xc5\x50\x5f\xae\x94\x88\xae\xbb\x4f\x04\x29\x5a\xea\x2e\xc9\xfe\x14\x5d\x41\x32\x00\x68\xb2\x7c\x51\x57\x96\xf4\x5a\xac\x46\x4b\xd7\x2b\x48\x90\x14\x27\xca\xb2\xbc\x8c\xe1\xc8\x73\x52\x27\xa6\x18\x36\xdc\xac\xd6\x09\xf7\xe0\x6e\xfc\x57\xc5\x2a\x98\x39\x0d\x4a\x94\x36\xfb\x14\x9d\xfa\xc8\xd6\x2c\x39\xc5\xde\x5c\x8f\xec\xf1\xda\xf8\xfa\xbc\xe7\x8f\x5a\x2b\x2b\x70\x7a\xd6\xf3\xa3\x3d\xbd\x39\xf8\xa0\xf4\xf5\x03\x6b\xe5\x69\x07\x15\xf9\xce\xe8\xea\xc2\x60\x06\xb8\x5e\x66\x2b\x4b\xc3\x91\xab\x33\x52\xf2\xa3\xd3\x6c\xd7\x08\xd2\x1f\xee\x4d\xfd\x9c\x4b\x2c\xd8\xe5\xdb\x4c\x98\xa9\x5c\x35\x10\x11\x16\x4e\x96\xca\x07\x27\xad\xc6\x27\xa8\xd5\x85\xcc\x43\x91\x49\x79\xdd\xd8\x89\x4e\xae\x20\x2e\x94\x64\x12\x76\x85\x46\x45\x85\x9f\x63\x70\x6c\x7b\x3e\xf4\x2d\x5a\xc5\x0b\x02\xcf\x9f\xef\xbe\x2e\x9b\x62\xaa\xfb\x5b\x30\x15\xc0\x00\x23\x6e\xfb\x86\x02\xb0\x80\xcc\x9c\xeb\x18\x36\x8a\xf3\x4f\x79\xa0\x98\x53\x24\xb6\xba\xb1\x8b\x78\x34\x7b\x8f\x82\xde\x5b\x70\x34\x56\x45\x76\x19\x8d\x46\xae\xbe\x1a\x04\xb6\x74\x9a\x3d\x77\x03\xce\xe2\xde\x0f\x1e\xb8\x58\xd8\x29\x20\x64\x15\xb7\xeb\x82\x6c\xda\x5d\x07\x02\xa3\x12\xae\x03\x81\x5d\x86\xb1\x41\x79\xcb\x35\xc0\x2f\x98\xa7\x11\x5e\xd1\x0b\x9e\xae\xe7\x43\xdb\x4c\x1f\xff\xd8\x2f\x6f\xde\x7e\x9b\xde\x6e\xc6\x78\x1b\x96\x3f\xc6\x1c\x6b\x2c\x6e\xe4\xdb\x5d\x91\x34\xcb\xe5\x95\x01\x06\xf7\x84\x44\x44\x0a\xc5\x71\xbe\xbe\x8e\x96\x4d\x95\xba\x16\x63\xf7\xc1\x51\x06\x43\x35\xad\x9e\x01\xc3\x33\x42\xb3\x80\x0d\x9c\x46\x42\x53\x0f\x0e\x8e\xf8\x05\x29\x6a\x48\x4c\x8b\x6b\x80\xc1\x8e\xad\xfd\x40\x47\x90\x33\xfa\xf0\xde\x2f\x7a\xa3\x93\x4c\x73\xc2\x88\x88\x24\x57\xff\xb1\x71\xc2\xc7\xb8\x8c\x83\x19\xc2\x53\xec\x15\xb8\x1e\xb8\xb7\x3d\xb3\xd6\xf1\x26\x98\x25\x8e\x7b\x33\x9e\x1e\x5c\x33\xae\x8d\x71\x2e\xcd\xd5\x2e\x4f\xa0\x16\x46\x3d\x99\x75\x75\xce\x96\xd3\xcf\xa5\x69\xb9\xa9\x58\x54\x2a\x39\x5a\x1d\x59\x5f\x5d\x71\x79\x91\xe7\x5a\x5f\xe5\x39\xa9\x58\x96\x8f\xa6\xec\xfa\xc6\x1c\x53\xd2\xcc\x46\xd2\xa4\x7f\x05\xa0\x33\xe2\xc6\x8d\x90\x48\x0c\xc0\x69\xad\xd5\x95\x29\x0f\xc8\x2e\x79\x06\x12\x49\x55\x0c\x9b\x87\x2b\x29\x2a\x98\xaf\x61\x41\x6a\x22\x17\x7c\xca\x47\x09\xae\x86\x01\x56\x81\xab\x58\x1a\x88\xc4\x3d\xa4\xba\x26\xf8\xb9\x2b\x5e\x89\x35\xd4\x8e\x6d\x2c\xa2\x65\xc0\x38\xcd\xce\xf8\x6e\xd0\x4c\xd1\xf7\xab\x6b\xa0\xfd\x33\xe0\x0a\xbc\xab\x75\x81\xf6\x00\xfa\xa5\x55\xc3\xd8\x86\x6f\x3b\x44\xc7\x70\x01\xf7\xee\x34\x4c\x82\xdc\x4d\x84\x39\x13\x23\x18\xd2\xfa\x02\xf3\x07\x71\xd3\x9d\x1d\x7b\xcb\x55\x4c\xea\xb9\x43\x7d\x41\xe2\x25\x99\x70\x4e\x4f\xa8\xf5\xf7\xff\xfb\x6e\x7f\xf7\xe9\x8f\xad\x1c\xbd\x8d\x8e\xd0\xd9\xc5\xcc\xcf\x81\x7d\x88\xf5\x69\x6c\x8a\x13\xa6\x00\x0a\x93\x8f\xd4\x91\x98\xe5\xbb\x43\x79\x11\x9f\xe0\x52\x4c\x11\x6e\x87\x30\x77\xfc\xe9\xfa\x55\x64\x08\x55\xb7\xe4\xf9\x4f\x21\x58\x0c\x1c\xf6\x01\xe9\x30\x89\x8e\xe7\xbc\x35\xc1\x1b\xe3\x4e\x7f\x02\x3b\x43\xdf\xf5\x07\x21\x2e\xa4\x97\xb6\xf8\x1b\x33\xba\x45\xd3\xc2\x27\xe9\x15\xe9\x9a\x19\x4d\x42\xa3\x9e\x86\x54\x46\xd6\xc9\xf4\x70\xb7\x75\xa4\x6f\x33\x4f\x4e\xb0\x95\xb1\xd9\x84\x76\xa1\xc0\x92\x39\x1d\x62\xe6\x1b\x7b\xe0\xd3\x90\x6c\x99\x71\x9f\x5b\x67\x9d\xd6\x6a\x4e\x11\x09\x06\x99\xf5\xcd\xb5\xae\x53\x5a\x33\xc5\x4c\x2e\x66\x65\x15\x63\xb0\xcd\xa5\xef\x2f\x07\x86\xde\x3d\x0f\x19\x5a\x24\x85\xe3\x14\x16\x6a\xcd\x51\x01\x2a\x34\xe2\x2d\xb7\x50\xa1\x11\xd8\xd4\x8a\x14\xd1\x93\x9a\xd6\xdf\x44\x9a\x2b\x3d\x0b\x15\xba\x9c\xa0\x42\x47\xb5\x6e\xd9\x82\x63\x08\xe5\x5a\x9d\x43\x6c\x4f\xb9\xd5\x30\x19\xbe\x7d\xbe\x38\x15\xb6\x29\x3c\x8f\xa7\x42\x3d\xad\xb5\x9d\x64\x2c\x64\xf9\xcf\x63\x1e\xba\x6e\x28\x28\xf2\x13\xc9\x58\x29\x9c\xe0\x51\x2f\xbd\x54\x3c\x0f\x58\x9e\x98\xf9\x87\xf0\xf9\x64\x12\xca\x1d\xae\x2b\x4c\xff\x9d\x06\x17\x2c\xc9\xaf\xf7\x5f\xde\xfc\xb9\x99\x01\x1f\x6e\xf1\x29\x01\xc5\xa8\x5f\xc9\xe1\xba\x8e\x6f\xbd\x3c\xce\xc7\x13\x4d\x90\xa2\x9a\x80\x6c\x29\x31\xd4\xc3\xca\x2c\x72\x89\x57\x44\x59\x45\x10\x59\x2f\x4d\x19\x2d\x23\x2d\xd8\x94\x9b\xa6\xf0\xa0\xe8\x68\x69\xa4\x95\x69\x2c\x62\x0b\x81\x2d\x56\x7d\x41\x73\x9a\x90\x2f\x1f\x61\x3e\x41\x21\x10\xbb\x49\x94\x01\x60\xc5\x10\x19\xde\xd7\x40\x64\x33\xa8\xb5\xdd\x80\x5e\x53\x20\x36\x69\x02\x69\x02\x85\x23\xb0\x77\xcb\x74\xaa\xe1\xa0\x20\xf9\x05\xb0\xa2\x3d\x2a\xf4\x89\x18\xdb\x0c\xbf\x5a\x48\x8b\x1c\x50\x50\x85\x46\x06\x4e\xe6\xb6\x02\x4a\x9c\x66\x9c\x7b\x4b\x39\x97\x3f\x0e\xc0\xc6\x00\xf8\x4b\x07\x62\xa9\x57\xc2\x8e\x95\x26\x61\x31\xbd\x5b\x75\xf5\x11\x91\x07\x89\x0d\xbb\x4a\x87\xd6\x37\x4e\x90\xe5\x91\x2f\xe2\x89\x27\xec\x9e\xf5\x08\x64\x87\x29\x95\xba\x06\xc8\xa2\xd5\x0a\x2a\xf9\x67\x30\xdc\xb3\x25\xb8\xd4\x94\x22\x35\x69\xad\x14\xd2\xe3\x44\xb3\x0a\x33\x14\xd6\x8c\x70\x82\x2f\x41\x07\x13\xe5\x7b\x96\xa2\x85\x01\xc6\x1e\x18\x9b\xe5\x3e\x44\x12\xed\x53\xd6\xdf\x5a\x1d\xfc\x8b\x29\x54\x76\x37\x38\x54\x6e\x23\x4e\xdd\x2f\xfb\x87\xaf\xef\x1e\x3e\x6f\x34\xaa\x0f\xdb\xe2\xed\x13\xc8\x5f\x11\xb3\x1a\x7e\xfc\x29\x96\x42\x59\x64\x96\x70\x59\xd8\x66\xab\x3f\x4e\x57\x5f\xc3\xc1\xc7\x9e\x8f\x7d\x16\xe9\xa4\xcf\xe2\x28\xd5\xe3\xe3\x5f\xa3\xcf\x22\x8d\x7e\x3a\x50\x94\x1d\x1e\x69\x51\x72\x69\x1a\x10\x37\xc1\x71\x66\x94\x52\x3c\xb6\xea\x67\x45\x00\x02\xed\x7c\x15\x71\x99\xaa\x4b\x32\xc7\x90\x56\x81\xd8\xc9\x49\xe4\xf4\x24\x9e\x7a\x1a\x66\x3d\x09\xbf\x82\xdc\x24\xc0\x99\x40\xed\xe0\x53\x58\x0b\x34\x7a\xd2\xfa\x0c\x46\xb4\x3c\xe3\xb3\x22\x72\x22\xeb\x4a\x43\xaa\xa4\x88\x06\x70\x4e\xb5\x63\x62\xcf\x1a\xe6\x3d\x06\x7f\x8f\x47\xeb\xcf\x33\x22\xb2\x45\x53\x6b\xd2\x0a\xb6\xc5\xf0\x2b\x5f\xa4\x98\xd2\x0e\x31\xfa\x2a\xec\x86\x99\x77\x0b\x3a\xce\x60\x72\xe3\x33\x9b\x2f\x23\xe7\xb3\xd2\x69\x9b\xf8\x59\x56\x89\x34\x07\xa7\x42\xec\x06\x6a\xe4\xcd\xa9\xfb\xed\xe3\x72\x89\x7a\xee\xc3\x96\x85\xe3\x11\xe8\x00\x65\xbe\x44\x3d\xc7\xb2\x40\x29\xb3\xe1\x00\x43\xe0\x75\x4d\x75\xcc\xcd\x15\xb1\xbe\x8a\xa3\xdc\x0e\x3a\x61\x3b\x3b\xfd\x7b\xd1\x9f\xf7\x25\x8d\x5d\xe3\xe4\x26\x83\xa3\x51\x71\x85\xcf\x09\xe1\x9e\xc1\x07\x77\xe4\xc4\xeb\xd2\xf3\xb6\x54\x3a\x6b\x56\xaf\x3c\x1c\x8d\xf3\xa5\x80\x75\x02\x0f\x2a\x69\xd4\x20\xe2\x87\xdd\x62\xa7\xde\x0e\x97\xdc\x4f\xd3\xa5\x18\xe6\x87\x5b\x29\x69\x1d\xfa\x92\xd6\xf8\x21\x3a\x84\x10\x52\xd6\x1a\xc9\x30\x50\x24\x2d\x55\x16\x5f\x9c\x9e\xa9\x34\x9c\x34\xa0\xd7\xb2\xca\x2f\x04\x79\xf0\xaf\xf3\xea\x9f\xb3\xb5\x08\x28\xf6\xca\x6d\x00\xb7\x1a\x60\x83\x37\xc4\x06\x1f\xdb\x7e\xb0\xa3\x3d\x13\x02\x01\x39\x82\x46\x82\xaa\x90\x0f\x9a\x16\x97\xb1\x6f\x74\x72\xad\x2d\x4d\xe6\xaa\x68\x6a\x55\x53\x01\x81\xe1\x90\x83\xe3\x50\x16\xf0\xfe\xb3\xbe\x7e\x66\x70\x4d\x31\xd2\x7f\x63\xa8\x7a\xea\xec\x1b\x72\xbd\x9b\x8b\x7d\x33\xf0\xcb\xd9\x78\x6b\x31\x22\xa2\x38\xb1\xcf\xd4\xd5\x25\x16\x91\xde\x97\x9b\x59\xd6\x1e\xf7\x9f\x8d\x05\x8d\x54\x05\x2d\x01\xf0\x93\xd2\x22\xf5\x5f\xe8\xf9\x4d\xab\xe5\x45\x16\xd0\x93\xce\xab\x77\x0f\x1f\x3e\xdc\x6f\x97\xd2\x36\x7b\xe9\x44\xd3\x2e\x65\x50\x82\x19\x3e\xec\x0a\x0f\x9b\x8b\x71\xa0\xb4\x24\xb3\xb1\x21\x79\xee\x54\x39\xf9\xfe\x1a\xd8\x1f\x5a\x01\x76\x6d\xc0\x50\x9c\x17\xae\x94\xb9\x7d\x7f\x4d\x2d\x97\x67\x52\x92\x59\x6b\x6e\xac\x1d\x38\x42\x2f\x2e\xf6\x1a\x4f\x2b\x77\x76\xa3\x74\x0d\x51\x4b\xcc\xf4\x1f\xdb\x78\x3f\x3c\x3c\x6c\xd5\xda\x6d\x7e\xca\x71\xc7\x85\xe4\x4a\x95\x81\xe4\x8f\xfd\x92\xae\xec\x97\xb5\xf6\x6b\xeb\x03\x11\xdd\xed\x8c\x3f\xc8\x25\x10\xd4\xe1\x82\xa0\x3e\xe8\x03\x6f\xf9\xbd\x57\xdc\xf5\xc7\x64\x9b\xa7\xdb\xbd\xa1\xaa\xbf\xec\x3e\xbb\x1f\xbb\xd1\x90\xc4\xc9\x88\x40\xc3\x4b\x7b\x24\xd3\x05\xa3\xff\xdc\x3f\xd2\x42\x30\x0a\xa6\x9e\x1c\x73\xc1\xe6\xd7\xd3\x9e\xf3\x8b\x8b\x55\x3e\x7c\x9c\xee\xdf\x2c\xf7\xff\x7b\x31\x6d\xe9\x43\x59\x53\xc4\x53\xc1\xee\x52\x2e\x7a\xa7\x8f\xb5\x99\x2f\x43\x7e\xd7\xde\x79\x0c\x76\x3f\xe2\x7e\x67\xc8\xef\x23\xb0\x90\x82\xe8\x65\xb5\xec\xd5\x83\xa4\xe4\x31\xcc\x2e\xd1\xe4\x23\x45\x17\xb5\x86\x19\x55\xc3\x48\x01\xb3\xf1\x50\xd2\x8a\xc0\xe9\x89\x48\x06\x48\x01\x28\xc7\x02\x3a\xda\xef\x3b\x18\x75\xba\x12\xcf\xa0\x49\x11\x81\x78\x36\xe2\xa9\x46\x3b\xb6\x80\xa7\xdf\x5f\x93\x68\xf3\x28\x8c\xfd\xe9\x9b\x5d\x68\xa2\xdd\x5f\xe6\xc5\x8b\xee\xbf\x7b\xf6\x03\x6e\xee\xec\xdf\x3e\x4e\xef\x3f\x7e\xfa\x63\x33\xad\xb6\xf5\xb2\xe7\x46\x34\xfc\x1d\x6b\x00\xe8\x8a\xbf\xb4\xdc\x5a\x21\x23\xf6\xb4\x75\x20\x96\xf4\x04\x0e\x71\x6a\xe1\xb7\x3c\x7c\x07\x41\xfb\xbb\x9e\x3e\xe6\xf9\x6f\x7a\x75\x30\xdd\xfc\xb6\x61\x37\x46\xa4\xdf\x38\xec\xbf\xab\xe7\x31\xec\xbd\xf3\xef\x1c\xf6\xdf\x36\xe5\x91\xf8\xf1\xdb\xa6\xbc\x0c\xfb\xef\xea\x79\xa3\xa1\x48\xed\x77\x8e\xfb\x6f\x9b\xf3\x88\x30\xff\xb6\x39\xaf\xe8\x83\xbf\xa9\xeb\x8d\x52\xec\xb7\xbd\x3c\xf2\x5c\x7e\xef\xcb\xff\xc6\x69\x2f\x6f\x8f\xac\x9a\xd8\xd2\x01\x4a\xa6\x37\x8f\x8d\x1c\x03\x48\x92\xaf\xde\x1a\x08\xac\x57\x23\xb8\xcc\xe9\x91\xe5\x51\xd2\x55\xb0\x14\x18\xb7\x97\xc0\x52\xf4\xa2\xc7\x60\x29\xe0\x5b\x7a\x99\x59\xb1\x7f\xf8\xfa\xf9\xe3\xb2\xad\x33\xfc\xb0\xcd\xe3\xfc\xaf\xea\xf7\x5f\xd5\xef\xbf\xaa\xdf\xef\x92\x86\xbf\xef\xdd\x7f\xa7\xf6\xf5\x7b\x15\x90\xc7\x1b\x01\x40\x71\x38\x97\xe1\x28\xbc\xc8\xa4\x99\xda\x95\x84\x6c\xbb\x14\x77\xf9\xf9\x2d\x04\x1b\x74\xc8\xe5\x26\x9d\xe0\xa6\x57\x36\x99\x2b\x03\x12\x4d\xd9\x14\x4f\x6e\xb2\x7b\xc9\x5d\x6e\x53\x12\x96\x6b\x29\x0d\x87\x0e\xef\x8d\xb4\xe2\x47\x2e\x1f\xfb\x28\xf0\xa2\xb0\xf9\xbd\x78\x1f\xe5\x0b\x09\xe2\xd2\xfb\xbb\x03\x03\xee\xfc\x91\xcb\x4b\x06\xf7\x52\x1c\x86\x9b\x26\xd7\xbf\x70\xf3\xbd\xfb\xf3\xed\xb7\xe9\xee\xd3\xbb\xad\x57\x7d\x9b\x06\x7f\xf4\xaa\x9f\xa0\x62\xff\x85\x65\x9d\x57\x50\xb3\x13\x98\x8a\x37\xb0\xd9\x55\x13\x63\xae\xe0\x66\xff\x92\x66\xee\xae\x94\x9f\x22\xc6\x10\xae\x71\x31\xc8\x7e\x65\x0b\xed\x31\x31\x06\x92\xba\x2e\xe0\xea\x33\xa7\xe1\xd7\x7d\x36\xea\x3e\xb6\x45\xbe\x98\x13\x84\x84\x9f\x33\x40\x7e\x69\x90\x26\xfa\x3c\xc6\xe9\x07\x86\x5e\x4c\x96\xa3\xbd\xbb\x3a\x9f\x6f\x84\x44\x7e\x16\xf4\x1b\xde\xee\xdb\x24\xf7\x27\xce\xf5\xe8\x72\x5b\x22\xbb\x4c\x8f\xd1\xb9\x49\xb1\xb9\x07\x32\xb7\x4a\x88\xc7\x0a\x2b\xe5\x17\xa3\xfb\xfd\x79\xff\xfe\x9f\x1f\xb7\x0e\xf0\x5b\x39\xf2\xc8\x44\x48\x54\xfe\x13\xa6\xc8\xcd\xe8\x74\x2e\x67\x81\xe5\xc8\xbb\x97\x85\xa7\x23\x9c\xf0\xf6\x84\x63\x78\xba\x35\x0b\x4f\x97\xf0\x03\xe1\xe9\x12\x9e\x1d\x9e\x8e\xac\x0f\x8a\x7c\x16\x9e\x7e\x56\x74\xfa\xc3\xc7\x3f\xf6\xcb\xfd\x97\x37\xff\xdf\xfd\x76\x72\x6c\x93\xeb\x4f\x62\x94\xb2\xe6\xc0\xfb\x4b\x9a\x35\xc4\xad\x81\x46\xdd\x6b\x8e\x26\x4f\x32\x68\xce\x97\x24\xdb\xa0\x71\x4d\x44\x20\x9f\x1e\xa7\x2e\x02\xd2\x7d\x40\xf6\x1f\x8f\xec\xb7\xbd\x6e\xb3\x05\x19\x03\xa2\x09\x94\x64\x94\xc2\x4a\xec\x00\x89\x9a\xf6\xfa\x54\x06\x98\x5e\xe7\x7d\x64\x39\x15\x5c\xc7\x7a\x92\xa6\x09\x4c\x76\x68\xc8\xa4\xa2\x57\xe8\x05\x13\x2e\xdd\xf7\x32\xad\x77\x94\x11\xc3\x83\xc6\x63\xe5\x9b\x7d\x2f\xbb\x17\x34\xbd\xf4\xe9\xf8\xce\x69\xb2\xce\xb0\x0c\x56\xd6\xdc\x7b\x6e\x8e\x03\xc2\x67\x4b\x43\x82\xf8\x13\x89\x04\x5b\x22\xdc\x0f\xdb\xe4\xec\x63\xe1\x97\x4c\xfa\x92\x82\xb2\x41\x43\x89\x52\xd6\x73\x9f\xa3\xbb\xb8\x57\x58\x52\x04\x50\x06\xbb\x55\xea\xa9\x05\x2f\xfd\x24\x4d\xd6\x6f\x40\x6f\xa7\xc9\x08\xd7\xd2\xa9\x44\x72\x4d\xbe\x24\x27\xef\xcc\x08\x49\xa7\x16\xc6\x61\x2f\x38\x54\xb4\xde\x92\xa4\x47\x0e\xbe\x85\xdb\x00\xd5\xfb\x8b\xb0\xd4\x1f\xde\xff\xe3\x54\x5e\x49\xbb\x57\x48\xc8\xb3\xec\xa9\xc7\x32\xfa\x24\x91\x0a\x9a\x98\x8a\x84\x55\xe0\x3e\xff\xda\x23\xe4\xe6\x59\x80\x56\x3a\x73\x9d\x2f\x6b\x80\x55\x1e\x04\xd1\x73\xc4\x1b\x7d\xfa\xaa\xc7\x10\xd2\xbb\x7f\x07\x0c\xe9\x0f\xe1\xc3\x56\x41\xbb\x3f\x1b\xac\x5c\xcb\x91\xa8\xf8\x51\x87\x47\x0e\x3f\x32\x18\x18\x48\xe4\xeb\x5f\xfe\xfd\x48\xa6\x7c\xde\xed\xf2\xb8\x17\x8d\x09\x46\xf2\x54\x79\xfd\xb7\x1e\xac\xf7\x0f\xdf\xde\x4e\xf7\x6f\xee\x3e\xfd\x31\xdd\x5f\x42\x9f\xa5\xb0\x4d\x0c\x3e\x56\x5a\x15\xae\x8e\x8e\x95\x56\x5a\x7f\x38\x29\x6b\x69\xb0\xfc\xef\xb5\x26\xd1\xa0\xf5\x27\x9f\x4a\x71\xa9\x94\x95\x6e\x9e\x02\x50\xb4\xe5\xdf\x69\xfc\xa6\x3f\xe1\x82\x45\x2f\x9f\xec\xae\xa7\x54\xfd\x8a\xdd\xa4\xf5\x1a\x90\xb9\x3d\x4e\xe3\xe0\xfc\xc4\xef\xaf\x29\x10\xfd\xaa\xc6\xee\xfe\xea\xd6\x3e\x7b\xc8\x2e\x81\xee\x52\xd8\xe6\x99\x1e\xc7\x2c\xf7\x8c\xfd\xfb\x51\x37\x24\x60\x5a\xda\x8b\x5e\xea\x88\x1c\x9c\x75\xd3\xe3\x31\x93\x77\x90\x77\xf1\x76\x70\xf1\x24\xbd\xfc\x42\x47\xad\x0f\x7e\x34\x5e\xbd\xf6\x5f\xdb\xce\xdd\x5f\xd3\xd0\x67\x0f\xd5\x06\x39\x95\xc2\x36\xaf\x92\xf2\xaa\x85\x87\x9a\xdd\xd0\x7f\x9f\x3f\x5f\xcf\xde\xd1\x8f\x97\x7c\xd9\x80\xde\x98\xd6\xd7\x46\x0b\xad\xd5\x7a\xa1\x9f\x6a\xed\xee\x6f\x69\xee\xb3\xc7\xec\x02\x62\x2f\x85\x6d\xfe\xe6\xa3\x51\xb3\x1a\xdc\x17\x4d\xdb\x5b\x42\xf1\xea\x94\x3c\x13\x23\x26\x45\x9e\x23\x88\x6c\xbc\x28\xe4\x97\xaf\xaf\x9b\x02\xf1\xd7\xb7\xf4\xa6\x3f\xe8\xfa\xae\xb5\x49\xb3\x3c\xc1\x4c\xe7\xea\x7a\xdf\x8c\xd0\x13\x22\x79\xf9\x0d\xbb\xdb\x33\x5e\xfe\xb2\xfc\xdf\x64\x3d\x9e\x80\xae\xff\x7b\x88\xff\xa7\xdf\xfc\x82\x38\xdd\x82\x43\x3d\x5a\x98\xc7\x52\xb3\x7f\x6d\x71\xfa\xf4\xdb\x5f\x14\x4c\xdb\xf4\xb3\x47\xef\xaf\xf9\x95\xff\xca\x82\xe9\xa6\x64\xbe\xff\xfa\xcf\xe5\x61\x3b\xec\xdb\xd0\xeb\x89\xbb\x02\xc0\x08\x29\x99\x0b\xe7\x6a\xc5\x6a\x09\xe1\xb6\xcb\xbe\xc5\x9b\x55\x8a\x72\xfd\xcd\x3a\x44\xab\x82\xbe\x49\x27\x9a\x81\xb4\xe0\xa3\x11\x8f\xc3\x73\x8b\xba\xac\x45\xfe\x4e\x5a\x54\x75\xd1\xc3\x09\xf2\x92\x13\x2f\xe4\xce\xdc\x90\xea\xa4\xa3\xe2\x52\x92\x5b\xd5\x20\x77\xaa\xcd\xd0\x1e\x5e\x46\x5c\x2a\xaf\xf8\x62\x9e\x80\xe9\xee\xf3\xa5\x21\xbb\xe5\xaf\x4f\x04\xd8\xdc\x6b\x48\xea\x21\x5d\x6c\x9d\xb4\xfa\x52\xeb\x0e\x5e\xaf\xb8\x86\xd9\x1e\x5a\xb3\xac\x21\xd8\x6d\x76\xf2\xb5\x61\x0e\xed\x1a\x49\x83\x35\xec\xea\x04\x93\x2b\x6f\x4c\xb0\xef\xbb\xd7\x54\x41\x45\xca\xf0\x42\x59\x88\x27\x05\x6d\x74\x69\xd6\x66\xe4\x1d\x63\xb2\x1e\x7b\x87\x1b\x7a\xa7\x34\xc4\x87\xd4\x87\x08\x70\x86\x14\x5c\x2f\x27\xd5\x1e\x8b\x56\x89\xe0\x0e\xe0\xcd\x0e\x06\x44\x56\x16\xfd\x80\xf7\xf1\x49\xf6\xea\xed\x7e\xb3\xf5\x26\x1f\x05\xcf\x31\xfc\xf2\x53\x65\x6d\x81\x13\xa0\xb0\xcc\x1c\xbe\xd2\xcd\x2d\x3e\x51\x79\x7e\xc4\x05\xb9\x34\xbe\x72\xf9\xd5\x55\x7c\xcc\xb1\xb9\xbd\x8a\x1b\xfc\xc8\x2f\x5a\x5b\xf2\xdc\x17\x2f\xad\x3f\x1f\xde\x7e\x9c\xee\xdf\x7c\xde\x3f\x6c\x78\xfb\x29\x6c\x5c\xb8\xb5\x8c\x6c\x94\x04\x14\x39\x40\x19\x03\x43\xe3\x55\x76\x4a\x50\x07\x74\x3d\x8e\xeb\xa1\x67\x23\xc4\x7b\x35\x38\xec\x4e\x0e\x4f\xce\x38\x5e\xb7\xde\xec\xfb\xeb\x52\x15\xba\xec\xf6\xb2\x50\xd2\xa5\x1b\xe3\x75\x7b\x3d\x22\xbf\xfc\xca\x78\xa5\x86\xee\x2c\xbb\xd3\x02\xa9\xdb\x53\xff\xac\x30\xaa\x96\xb5\xec\xcc\x4a\x4c\x2f\x15\x3b\xe0\x05\x2e\x14\x3b\x0c\xc0\xda\x0d\x0a\xd9\x05\x54\xb0\xdb\x65\x44\x1f\xbf\xbc\x9b\xee\xdf\xbc\x9d\xee\x3e\x3d\x26\x03\xa6\xf0\xee\x1f\x27\xb0\x46\x44\x0d\x01\x16\xc5\xb6\xaa\xd1\xf9\x1a\x17\x3f\xc8\x96\x51\x47\x2d\x5f\x2f\xe3\x73\xfd\x65\x9c\x2b\x9f\xf6\xbd\x7c\x5d\xa3\x93\xd3\xfc\xf8\x1c\xdf\x7b\x3d\xef\xfb\x8f\x31\xba\x8e\x63\x1c\x9e\xf2\x77\xfa\x23\xad\xe7\xf3\x09\x3e\x77\x3f\xc4\xf0\x39\x7f\x7b\x58\xae\xd8\x0d\x5b\x4c\x8c\xa3\x5b\x5d\x3a\x39\xcb\x2e\x6e\x11\x42\xab\xd1\xf2\x6b\x91\x96\xcf\x0a\x19\x35\xfb\xa6\x10\xaf\x5a\xa0\x65\x85\x5c\x63\x29\x80\x0b\x76\x45\xf0\x3f\x05\xf9\x3f\x03\xff\x5f\xd1\xfb\xf7\xe5\x12\x1d\xef\xa9\x47\x73\xa3\x0e\xdc\x2c\x2c\x5f\x73\x31\xce\x0a\xc9\x11\x3d\x5b\xcb\xca\x4e\x2b\x46\x77\x1a\x18\xf8\x7f\xf0\xcd\x9f\x9e\x43\x97\xcd\xaf\x2d\x9a\xc6\xf9\x24\x52\xda\xb7\x21\xda\x42\x32\x72\x0e\x7f\xc6\xe9\xa0\x64\x0e\x83\xd3\xc1\x9f\x91\x3a\xe0\x7c\x7d\xd9\xcb\x59\x1a\xdb\xd8\x71\x49\x27\xe0\x12\x8a\x2d\x81\x7a\x62\xd6\xf0\xa4\x66\xdd\x2c\x9a\x83\x63\xb1\xda\x8b\x43\xa9\x33\xe0\x71\x99\xf1\x5e\xbe\xbe\xd8\x87\x83\xbb\x8a\xca\xee\xff\x95\x57\xbe\x59\x62\xfd\xf9\xe3\xa7\x4f\x9b\x70\x1e\xd1\x2d\xfa\x21\x80\xdb\x2a\x7f\xf2\x9a\x1a\x72\xa1\x1e\xfe\x42\xd9\x2d\x72\x49\x2e\x54\xb0\x2f\x17\x4b\xed\x4d\xcb\x1a\x58\x5b\x57\x1f\xb5\x3c\xbb\x52\xfe\xda\x73\x22\xaf\xc4\x90\xd7\x1f\xb3\xfb\xf9\xe7\x50\x66\x5e\xbb\x6e\xb3\x7b\xbf\xb4\xee\xff\xda\x53\x72\x96\xcd\x37\x5e\x55\x09\x97\x47\x6a\xe0\x72\xa6\xfc\x2d\x8f\x75\xbe\x9d\xd6\x64\x3f\xd9\x3f\xbf\xa0\x7b\x00\xa0\xa1\xf8\x7e\x17\x65\xfa\xf2\x68\x29\x2c\xb7\xb1\x05\x5e\x53\xa1\x63\x57\x00\x9a\xb2\x8c\xda\x69\xcb\x5a\x00\x00\x7a\x8f\x96\x63\x61\x84\x55\x0b\xbe\xb7\x52\x70\x4b\xb4\xb0\x2f\x16\x3b\xab\xbc\x3c\xc3\x41\x35\xa7\xcd\x4a\xa3\x9f\x22\xa4\xff\xb5\xea\xcb\x0f\x69\x2f\x5f\xee\x3f\x4f\x8f\x39\x5d\x89\x6e\x41\x34\xc0\x09\x62\x65\xc0\x84\xae\xe3\x2a\x02\x14\xe0\xf1\x8a\x5b\x8a\x56\x24\x63\x03\xf1\x51\x59\x40\x3c\xb3\x01\x8b\x9e\x62\xa7\x2a\x10\xfd\x60\x0d\x01\x07\x45\x9e\x41\x7b\xf4\x4a\xa9\xe2\x17\x36\x7b\x60\xce\xc0\xec\x71\x04\x62\x60\xf0\x51\x00\xde\x14\x19\x55\x09\x70\xe8\x00\xe7\x96\xb9\xa7\x0c\xb0\x60\xa1\x52\x7e\x00\x8a\xd1\xb0\x0e\x08\x1c\xff\x38\x02\xc3\x76\xd1\x1c\xa4\x91\xd4\x70\x15\x92\x68\x37\x89\x7a\xee\xd4\xc6\xd8\x72\x5e\x8e\xdf\xae\x72\x5e\xe2\x09\xd0\x0e\x2a\x8c\x8c\x06\x94\xfe\x10\x67\x20\xbe\x2b\x35\xbb\x8f\xf1\xb6\x95\xf6\xc7\xc7\x65\xff\xed\xed\x85\x22\x64\xa2\x6d\x1c\xe1\x3c\x85\xe3\x04\x66\x58\x6b\xe0\x1b\x2b\x99\x3e\xd0\x7a\xf1\x4d\x4c\x76\x24\x07\x29\x02\xc7\x17\xe7\x36\xe3\x11\x6a\xbc\xe8\xd7\xe3\xac\xf5\x3a\xbb\xd1\xb8\xb3\xe1\x8b\xfe\xdd\xcf\x4c\xfa\x9e\x30\xd2\x00\xff\xd3\x1d\x07\x99\x87\xad\x3a\x51\x27\x93\x41\x41\x81\x0c\x62\x06\x68\x39\xc0\x74\x33\x84\xe5\x82\x03\x80\x7d\x67\x06\x26\x8a\x9c\x09\xbc\x7a\x32\xc6\xab\xea\x7c\x4b\x8b\xdc\xd7\xb3\x6a\x1f\xad\x29\xd8\x77\x8e\x27\x48\x43\xa0\xbe\x2b\x61\x21\x28\x06\x58\x8d\x40\xaf\xdc\x53\x69\x33\xd8\xd9\xe4\xef\x8a\xdf\xf5\x67\x66\x57\xc2\x80\x9d\x8a\xec\x70\x3f\x53\x77\x92\x65\x86\x84\x6a\xa0\x02\x91\xc0\x13\xe5\x2b\x16\x9b\x41\x18\xc9\x0e\x91\xc8\xf9\x56\x76\x32\xb5\xe1\xea\xd1\x59\xae\x88\x3c\x60\xfb\xa9\x46\xc8\x54\xf5\x7d\x12\x3b\x5c\x86\x65\x64\xab\x03\xbd\x8c\x15\x5b\x01\xf9\xb1\x00\x41\x4b\xd6\x58\x43\x82\x1b\x08\xf3\x0c\x3a\xd4\x45\xe5\x6f\x07\x5d\x59\x71\x11\x14\x1a\xd5\x35\x56\x6e\x89\xaa\xb9\x06\xc5\x65\x72\x4c\x6d\xa6\xd0\xc0\x4f\x66\xa4\x32\x0b\xb5\x0e\x86\x40\x90\x02\x55\x17\x33\xa0\xe9\xa3\xfc\xd5\x00\x70\x16\x34\xc9\x29\xc8\x2c\x70\xd2\xfb\xc4\x84\xab\x62\x9f\x41\x55\x17\x64\xd1\xc9\x60\x36\xe4\x47\x00\x8c\xb3\x82\x62\x7b\xc6\x76\x42\xc5\x14\xaa\xf8\x04\xdd\xd7\x87\x87\xe9\xfd\xfd\x97\x37\xef\xa6\x87\xaf\x97\x18\x1d\x89\xb6\x48\x1b\x27\xcc\xad\x22\xfb\x45\x88\xa8\x46\xba\xd5\x06\x51\x8b\x7e\x21\x2d\xbd\x5c\x3e\xfd\x1c\xa3\xdc\xdb\xf9\x48\xea\x33\x8f\xd3\xc6\xea\x00\x1f\xeb\xc8\x02\x1c\xf8\x5a\x36\x7f\x90\xfa\x67\xca\xf2\xe5\xd4\x3f\x5c\x7d\x39\x59\x51\x1f\x78\x21\x59\x31\xec\x2e\x6e\xa2\x62\x17\xed\x4b\xfd\x91\x1c\x42\x1d\x82\x87\xcf\xf7\x9f\x2e\x8e\xc0\x16\x7c\xe3\xd4\x31\xdf\xc8\x95\x20\x3b\x47\xcc\x9a\x99\xb6\xba\x49\xb5\x23\x75\x97\x54\xc1\xaf\x2b\x42\x66\xfa\xe4\xb9\x27\x25\x93\x02\x84\x13\x60\xc1\x00\x30\x0c\xd7\x79\x56\xa1\x9c\x4f\x00\x8a\x9b\x8c\xf4\x52\xc9\xe5\x38\xc9\xb5\x72\x29\x35\x27\x9a\x61\x73\xb1\x6b\x8e\x68\x2d\x6d\x5f\xcb\x09\x9c\xd0\xa3\x01\x46\xc6\xe3\x2f\x98\x0f\xbb\x83\x6f\xd2\x8e\x5c\x5c\xa4\x3c\x27\x6c\x22\xb2\xe0\x94\x79\x46\xa4\x61\xd2\x98\x41\xe8\xd6\x3d\x80\xf1\x4a\xd8\xb5\x83\xbc\x7d\xb6\xb7\x17\x61\x8a\x9d\x88\x8a\xac\x23\xac\xfb\x14\x14\x8d\x6d\xf4\xe4\x0b\x27\xc8\xf5\xf9\x91\x53\xba\xf2\x23\x1c\xce\x9d\xe7\x9c\x80\x7e\xac\x34\xa5\x8b\xc8\xad\x1a\xc0\xec\x87\x34\x51\x02\x27\xc9\xf7\xdd\x6d\x20\xda\xcf\x77\x9f\xde\x5f\x9c\x49\xd7\x68\x5f\x6e\x13\x3a\x4f\x77\x9f\xaf\xc8\x86\x6d\xa4\xec\xc9\xfb\x7d\xfd\xf3\xe3\x05\x6d\xb2\xad\xda\xa4\x28\x04\xa9\x88\x9c\xaf\x06\x6f\x08\x06\x7a\xea\x70\x78\x8a\xec\x4f\x7a\x50\x93\x32\xdc\xa3\x10\xa0\x39\xce\x2e\x29\xa1\x57\x6c\x2e\xd2\xab\x3c\x73\x76\x0d\xdf\x38\x9f\x16\x45\x67\x8b\x0d\xd8\x81\x2d\x18\x3b\x2c\xe9\x1e\xa4\x00\x4f\xe9\x78\x8c\x43\x9c\x82\x33\xe6\x26\x36\x71\x64\x31\x09\x53\x77\x69\x01\xff\x1a\x81\xaa\x05\x0a\x98\x4e\x7e\x4b\x64\x7c\xa9\xa9\xb1\x7b\x91\xad\x21\x3b\xf4\x0f\x3e\xe8\x45\xcf\x49\x61\xd8\x4e\xc0\xc9\x94\x8d\x4c\xe9\xd2\x0c\x55\x5b\xb4\x0b\x0e\x49\xf9\x62\x17\x8f\x1f\x5d\xa6\x71\xe4\x71\x08\xd2\x14\x3d\x61\x00\x70\xcb\x75\xd8\xb9\x92\x02\x56\x8d\xc3\xe5\xe4\x84\x93\xeb\x8e\x77\x5b\x9f\x70\x7c\xea\xb1\x29\xa3\x79\xff\x12\xde\xd4\x1f\x32\x47\x3e\x7c\xb9\x10\x8a\xa6\x7e\xb6\x2e\x62\xa8\x73\x33\xae\x17\xe3\xad\xf5\xeb\x54\x04\xcf\xc3\x82\x44\xee\x06\x2c\xed\x36\x20\x93\x74\x96\xfb\x93\xa9\xed\x4f\xa7\xbc\x3f\x59\x0b\xb2\x92\x60\x09\x8c\xf5\x62\x06\x86\x57\x7f\x51\x83\xed\x6f\x8f\xc3\xda\x9a\x23\x74\x13\x67\x2b\x71\xb1\x95\x39\x56\xea\x58\xbb\x2f\x5f\x20\xbb\x1f\x9d\xb8\xff\xfe\x0b\x64\x77\xb2\x42\xfe\xbb\x40\x8e\x15\x38\xfb\xcd\xf2\xb8\x3b\x2e\x8f\xcc\x5b\x86\xf7\x53\x7f\xf6\xc5\x4a\xbc\xe5\xdc\xcf\x79\xb1\x92\xee\x67\x44\xfb\x5f\x3a\x71\x7f\x78\x85\xfc\x2d\xa2\xfd\xaf\x9b\xb8\xbb\x7f\xb7\x99\xfb\xc7\xdd\x9f\xf7\x9f\x37\x68\xe1\x44\xb7\xea\x83\x5a\xc4\x7c\x36\x8f\xfc\x85\x0a\xb1\x2b\x55\x65\x5a\x5b\x72\xb9\x3a\xec\x46\x65\x99\x85\x82\xb6\x05\x62\xd7\xca\xca\xe4\x82\x47\xb5\x63\xc8\xb9\xd8\x94\x94\xd9\x7c\x7b\x3e\xc1\xe9\xee\x87\x19\x41\x41\x8d\x94\xc2\x5f\x4d\x3c\xda\x0d\x91\x4d\x3a\x11\x5e\x3d\x90\x53\x14\x5e\xe4\x1f\xfc\x39\xa3\x6e\x4a\xbe\x8d\x00\x05\xdd\x7b\x16\x43\x86\xd4\xfa\x68\xfa\xbd\x55\x61\x28\x5f\x83\x01\x9c\xef\x16\x3f\x20\xcf\x1f\x41\x9f\x03\xf6\x4e\x4f\x1e\x4f\x59\xc6\x83\x6f\x4e\xbe\x7f\xde\xff\xdf\x25\xfe\x5f\xa2\x6d\xe5\xd3\x71\xf6\x81\xff\xb7\x1c\x2b\xa4\xcb\xf8\x5f\x89\xbf\xd6\xb8\x3f\x15\xab\xe0\x2e\xfa\xdf\xfe\x24\x4f\xc6\x53\xf9\xfe\x3a\x13\xbb\xc2\xe9\xd2\x8d\xb4\x8e\xf1\xea\x9d\x50\x85\x78\x7a\x2b\x69\x53\x6b\xe1\xe7\xdb\xa4\xf3\xf1\xd2\xdb\xed\xf6\xbe\x95\x9b\xad\x92\x9f\xcf\x6e\x56\x4b\xbb\xf6\x82\x2f\x6b\x15\x76\x99\x5f\xf2\x7a\x81\xd3\x0f\x35\x69\xb7\xb9\x55\xeb\xe5\x17\xb5\x09\xdc\x07\xbf\xa2\x9b\x94\x2d\xf9\x57\x4c\x4d\xdd\x6f\xf5\xed\x76\xbf\x60\x46\xfd\x9a\x8e\x42\x59\xb9\xdc\x69\xe4\xd8\x3e\x7f\xc5\x10\xf1\x81\x53\xb8\x79\xfb\xda\x51\x40\x78\x68\x5a\x19\x5a\x12\xca\xef\x76\x7b\x39\x1c\x19\x96\x81\xd3\x5a\x94\x77\x5d\x11\xd1\xcb\x6f\xc5\xfe\xac\x8e\xf0\x72\xe8\x14\x4f\xbc\x81\x57\x7e\xdb\x56\x9a\xee\xfe\xb8\xe8\x8f\xd8\xa6\x9d\x9c\x44\x6f\xd4\xa3\x4c\x87\x02\x36\xd1\xd2\x95\xf0\x38\x86\x22\x07\xb3\x6f\xea\xe3\x49\xd9\x21\xf9\x2d\x04\x07\x26\xdb\x96\x5c\x55\x2d\xa7\x36\x70\x05\xcf\x9e\x2a\xde\x39\x05\x30\xe9\xd7\x83\xcf\xbd\xcf\x2c\x4a\x24\x45\x97\xc0\xda\x17\xe7\x9c\xa5\xdf\xb5\x94\x0c\x7b\x09\x0c\xab\xa5\xc2\x5c\x5b\x9a\xba\xf2\xfb\xab\x3c\x21\x20\x94\xe6\x04\x8e\x62\x8d\xee\x30\xcf\xc4\x20\x8c\xeb\xd1\x75\xd6\x40\xef\x40\x9a\x00\xd5\x02\xfa\xa9\xa4\xc5\x2b\x8f\x5c\x2a\xb2\x85\x97\x73\xf2\x1d\x03\xec\xdc\x59\x36\xc7\x63\xbc\x4e\x9c\xaf\xe4\x7d\x4e\x6f\x93\x8a\xf1\xe6\x95\xf4\xf2\x90\xb7\xce\x2c\x24\x64\x94\x88\x76\x76\x6d\x2b\x18\x4a\x8d\x39\xbd\x3a\xdf\x65\xcf\x6b\xe6\x6e\x8b\x05\x85\xbf\x65\xf6\xad\x0d\x0f\x5b\xcc\x13\x28\xfd\xd2\xec\x65\xa9\xcb\x2b\x74\x90\x1e\x74\x72\x2c\x8a\x3b\x28\xf4\x67\xb8\xc0\xf1\x46\xd0\xcd\x92\x7a\x85\x54\x4d\xe3\x1d\xe2\x6b\xd2\x0d\xb8\x7e\xac\x9a\xc8\xae\x81\xab\x81\x94\xaa\x21\x97\x43\x45\x54\x3b\x66\x17\xc9\x65\x40\xd2\x33\x39\x50\x0c\x27\x45\x4d\x4e\x2e\xcb\x66\xcc\xc3\x74\xa6\x0c\x18\x7e\x52\x42\xa1\x00\x26\xa1\x05\x9f\xad\xcc\x6a\xed\x82\xee\x59\xce\x61\x6c\xd7\x60\x00\xe3\x99\x01\x3a\x1b\xc9\x51\x9d\xe5\xdf\xe2\x64\x1f\x67\x39\xf6\x2c\xa7\x39\x9f\x9f\x31\xed\xdf\xed\xef\xdf\xfd\xf3\xfe\xcb\xfd\x76\x43\xdf\xa6\xcb\x9c\x70\x88\xcb\xdb\x46\x85\x22\xd0\x8c\x1e\x74\x7f\x03\x90\x7e\x3d\x78\x6a\x79\xe6\x90\x5d\x2f\x4e\x93\x78\xc3\x77\x5c\xd3\x73\x3a\x50\x07\xd5\x22\x2b\x02\x38\x2e\x61\x99\x6f\xad\xcf\x4c\xc0\x61\xb6\x6b\xda\xf7\xe3\x22\x43\x12\x1d\x2b\x2d\xc8\x78\x52\x25\x00\x1e\xc8\xdb\x22\x30\xe1\x28\xcf\x3e\x3b\x44\xff\x1c\x55\xe3\x60\xc3\x01\x8a\xa2\x07\x2b\x1b\x29\xd7\x19\x5c\x19\xa2\xcf\x17\x0b\xd9\xc4\xec\xd4\x05\x22\x2a\x79\x5d\x8f\x64\x55\x24\x27\x73\x80\x75\x9d\xca\x18\x1d\x3c\xb3\xa8\xa7\xb3\x4e\x1b\x52\x9f\x07\x8b\x95\x57\x35\x8a\x36\x13\x48\x91\x64\xda\x52\x96\xd7\x6b\x73\xd2\x98\x6d\x47\xc0\xf5\xd1\x92\xd4\x00\x03\xb5\x83\xf4\xc3\x05\x71\x92\x10\xdf\xad\xcd\x35\x51\xa1\x0b\x22\x3b\x3e\x81\xb2\xde\xf5\xf0\x73\x4b\xfa\xc6\x8a\xde\xfd\xa7\x2e\xe9\xeb\x2b\x7a\xf7\x6f\xbc\xa4\x97\xfb\x2f\x7f\x7e\xfc\xb4\xc1\xc1\x23\xde\x26\x32\x1d\xa3\x6e\xb9\x65\x97\xf3\xbf\x5e\xb5\xd1\xa8\xed\x1a\x8b\xa3\x5c\xc7\x90\xd6\x82\xed\xa7\x21\xa4\x51\x95\xbd\x22\x53\xef\x96\x67\x90\xb5\x3d\xbc\xdf\x84\x17\x78\x5b\xc8\x7b\x82\x6b\x44\xd5\x51\xac\xff\x92\xe5\xd6\x27\x3d\xca\x41\x4c\xc9\x90\x26\x1f\xc1\xf7\xc4\xdd\x58\xbb\xc1\xbb\xaf\x39\x80\xc7\x34\x73\x44\xf8\xc4\x72\x54\x7a\xf0\xa4\xbf\x9a\x24\x45\x5e\x49\x7a\x95\x77\x93\xdc\x0a\x77\x02\x39\x23\x29\x4d\xf8\x48\x40\x97\x7b\xc0\xd4\xac\x60\x89\x4c\xc6\xea\x80\x7b\xa8\xf4\xd4\x10\x5b\x2b\xff\xe2\xd3\xf1\xc9\x2c\xa0\x37\x77\xd3\x76\x05\x3e\x45\xd6\x92\x72\x3a\xf8\xaa\x41\x69\x56\xd9\x98\xbb\x92\xb1\x67\xf5\xd1\x67\xe4\x04\x0c\x97\xe3\xf3\xb2\x68\xb8\x8b\xd8\xa8\xb2\x0c\x66\x6c\x45\xd5\xe9\x9d\x0f\xbe\x74\xe9\x9e\x8a\x90\xfe\xec\xed\x06\xe7\x35\x1f\xdf\xcf\x72\x94\x72\x53\xf9\x4c\x31\xaa\x4f\x4c\xf3\x25\xe0\xd3\x97\x19\x94\x17\xcb\x1e\x15\x79\x3f\x29\xc1\x67\x40\x04\xe0\x34\x51\x09\x72\xb6\x3b\xda\x69\x50\x01\x83\x1a\xd3\x9c\xa2\x4b\x01\xdd\x5d\x5c\x2e\x19\x92\x1d\x69\x25\x15\xa9\xc9\x04\x73\x81\x8b\xec\x27\x59\xe1\xe3\x32\xfd\x7d\x7d\xc5\x85\xe7\x44\x84\xb7\xc8\x88\xa6\x32\xcd\xd8\xa4\x45\x79\xc7\x41\x0e\xfd\x09\x02\xaa\xbb\x2f\x6f\xf6\x77\xd3\x87\x37\xf7\x7f\x7e\x5e\x36\x99\x62\x7c\x2b\xed\x88\xa8\x15\x97\x6b\x9f\x38\x57\xc7\x39\x4c\x3e\xe6\xe2\x32\x4f\x88\x1d\xcb\x9f\xc1\x01\x83\x27\x77\x17\x99\xc5\x6e\x8c\x53\xc6\xc6\x33\x45\x6c\xa5\xa5\x4d\xbe\xc8\x2e\x96\x27\x4f\xec\x0a\x6c\xc3\xd8\x5c\x03\x91\x41\x41\x70\x3e\x4d\xad\xc8\x7b\x84\x39\xeb\xb6\x58\x94\x98\xc6\x78\x61\x9b\xda\x2a\x6a\xaa\x38\xe2\xc9\xa7\x24\x92\xb5\xe8\x81\xe7\x58\x66\x5d\xa1\x3c\x32\x95\x86\xca\x14\x93\x23\xa8\x56\x05\x99\x30\xf2\x9c\x1c\xa4\xd9\xb2\x7d\xe7\x34\x2b\x5c\x10\xa6\x42\x16\x79\x91\x13\xe2\xed\xbb\x29\x07\x76\x35\x4e\xcc\xd9\xa5\x2c\x2a\xa5\x4b\x24\x76\x54\xa2\x99\x45\x1d\x90\xe7\x26\xc2\xef\x3e\xe5\x8c\xf3\x7d\x8d\x73\x12\x2b\xc9\xe5\xa4\x61\xf7\x05\xe9\x08\x72\xe7\xdb\x45\x71\x0f\xef\xee\x96\x8f\x0f\x9f\xde\xdc\x7d\xf9\xf2\xf0\x3f\x9b\x01\xda\x26\xae\x9c\xb0\x84\xa5\x40\xa2\xb1\xd6\xc9\x17\x7d\x75\xf0\xb9\xd4\xa1\xdf\xc8\xa7\xe8\xa6\x50\x60\x1c\x83\x06\x2f\x1b\xab\x09\x1b\x8d\x97\xa8\x4f\xfd\x55\x3e\xe4\x5a\x2c\xb1\x81\xd5\x97\x07\x49\x1b\xd7\x0a\x1d\xf0\x0a\x26\x97\x78\x91\x09\x1b\xa6\x41\x40\x2d\x52\xb5\x3a\xee\xae\xce\x98\xfa\x1a\x76\x40\xa4\x9f\xb4\xff\x47\x6f\x94\x61\x2c\xde\xde\xf9\xbe\x6c\x2b\x04\x79\x9b\x3b\x72\xa2\x47\x60\x72\x96\x7d\xee\xf9\x90\x7b\x56\x6f\x5d\x0c\x34\xa1\xb8\xb9\xe7\xbd\x97\x5f\x3c\x7e\xc2\x8e\x8e\x74\xc1\xa3\x3f\xf8\xd1\x9e\xfe\x08\x69\xec\xd1\xaf\xe7\xae\xe7\xb1\xe3\x03\x7f\xaa\x5d\xd4\x66\x5b\xd9\x80\x9d\xad\x8a\xee\x86\xdf\x75\x7f\x86\xa6\x76\xfc\xfa\xd4\x1f\x3d\x98\x2d\x76\x0a\xa4\xd6\x32\x4d\x9c\x8a\xe3\x54\x65\xdf\x50\x0e\x5c\xf5\x6e\xcf\x88\x2d\x98\xbf\x7b\x30\xd9\x32\x28\x96\x45\x2d\x6f\x99\xce\x40\xd2\xc6\x8d\x9f\xd4\x4b\xde\x7c\x78\xf8\xb2\xa9\x3e\xe2\x6d\x52\xc6\x11\x65\x84\x5b\x73\x17\x73\x63\x96\x47\x09\x31\xcb\x55\x3a\x43\xa3\x0f\x63\xec\x09\x3f\x73\x9b\xce\x0a\x7a\xf9\x93\xb7\x51\x9e\x16\x2b\xfd\x03\xb3\xa4\x58\x4c\x70\xb1\x54\x64\x2e\xbe\xca\xb2\xd5\xc8\x85\xd2\xe1\x0c\xc6\x4e\xb1\x1c\xaa\x26\x9e\x73\x88\x60\xae\x56\x4f\x3a\x16\x6f\x81\x62\x52\x69\xf1\x49\x19\x8f\x42\x90\x2d\x40\x7d\x2a\xd9\x8d\xdb\x2e\xe3\x49\xcf\xcd\xd3\xd6\xca\x33\x2e\x0e\xcd\xab\x01\x29\xb5\x87\x86\xa4\xa4\x04\xfa\x49\xfb\x4e\x76\x3a\x67\x77\x7e\x8a\x3a\xee\xfa\x6b\x1f\x7c\xea\x75\x37\xe7\x84\x0a\x8c\x9c\x5c\xae\xb3\x98\x26\x15\x59\x4d\x9a\x2f\x89\xdd\x35\xd2\x22\x1b\x87\xfc\x8d\x0d\x3c\x13\x3a\x57\xfe\x16\xa9\xd1\x49\x24\xff\x8f\xb7\xf0\x36\xf1\xe9\xa7\xe9\xe3\xb6\x84\x8e\xb7\x99\x40\x47\x39\x93\x62\x77\x5c\x44\xc3\x90\x07\xa0\x26\x59\xb6\xe6\xbe\x06\xa1\xc0\xd0\x2c\x3a\x46\xb0\x60\x16\xc8\x71\xe5\x6c\x30\xd3\x3c\xb9\x38\xbf\xbf\x2e\xa1\xa9\x74\x1a\x90\xb0\x8f\xe4\xcf\x72\x2a\x3e\x0c\xba\xf6\x44\x4e\x2c\xa7\xab\x58\xa1\xbe\x53\xbb\x2c\xc7\x22\x5f\xb0\x5c\x96\xa3\xc4\x41\x7e\xe0\x46\x32\xbc\xa6\x92\xda\xc8\x0a\x46\x86\x6e\x53\x5c\xa9\xc9\x13\x0a\x16\x92\x18\xcc\x32\xb1\xe3\x98\xe1\x71\x65\x70\xe5\x90\x5c\xcb\x93\x8f\x51\x8c\x67\xd1\x94\x08\x49\xba\x49\xcc\xdd\x89\x63\x77\xd4\x26\xd6\x7a\xc4\x34\xb3\xa6\x82\x62\xe9\x89\x49\x2f\x8b\xaf\xbc\xca\x93\x3c\x47\x1e\xc3\xb2\x18\x81\xa3\x58\x4f\x57\xf2\x04\x1a\x45\xae\x79\xa2\xe6\x38\x76\xb1\x9b\xe5\x41\x32\x64\x89\xa7\x88\x5c\xd2\x58\xe6\x96\xc4\x2c\x76\xf2\xc1\x20\x10\x0a\x62\xf9\x86\x94\x26\xcf\x50\xc2\xda\x6e\x42\x69\xa3\xb4\xc5\xeb\x93\x54\x48\xcc\xa2\xf7\x8d\x4c\xbe\x7a\xfa\xe2\x86\xe5\xa7\xc2\xa3\x9e\xa5\x79\x4e\x20\x77\xe4\x9a\x26\x4b\x53\x0c\xb3\x57\x8b\x5e\xd6\x68\x62\xe9\x95\xe2\xa4\x61\xbe\x25\x27\xfa\x50\x4b\x4e\x33\x94\xa5\x9b\x1b\x90\xbe\xd6\x77\x6f\xd1\xb5\x28\xdf\xb8\x16\x67\xed\x5d\x44\xa4\x5b\x9e\xa4\x73\xbd\xf4\x2e\x23\xad\x16\xfc\xac\xb9\xac\xa6\xec\xc5\x59\xb5\x99\x0d\xbb\x4b\xd3\xe1\xd2\x6c\x90\xb6\x51\x0e\xbf\x68\xc2\x52\x66\xb1\x61\xc5\x06\xfb\xcb\x96\xd8\xed\x22\xbe\xfb\xaf\xa2\x88\x6d\xa4\xc2\x16\x52\xe2\xb8\xb5\xd5\x90\x1c\x37\x11\xd4\x9a\x8b\x82\x18\x05\x1f\x77\x11\xd0\x9c\xa5\xb5\xca\x18\xf4\x8a\x8b\x9c\xc1\xed\x24\xcc\xc1\xb6\xb3\x10\xef\xe5\x4b\x52\x7e\x68\xb9\x7a\xd1\x9b\x61\xc3\x41\x68\x0d\x82\x37\xad\xd6\x72\x20\xa5\x2d\x56\xef\x7e\xce\xaa\x70\x2e\x3e\xc3\x05\x96\xa0\xbf\x0d\x26\x3b\x24\xd0\xa3\x2b\x0b\xd4\xb2\x82\x84\x03\x1c\x61\xba\x92\x01\x11\x47\xad\xcb\x6e\xfa\x90\xd1\x7e\xad\xf4\x80\x71\x8d\x9c\x37\xad\x13\x89\xf5\x55\x3e\x00\x5a\xa2\x45\x57\xc4\x36\x47\xe2\x43\x12\xc3\x56\x54\xf7\xdc\x1d\x57\x59\x67\xb9\x2c\xb2\x89\x15\x23\x0d\x86\x5f\x0f\xc9\x8f\x41\x5a\x10\x79\xf6\x45\x15\xd5\x20\x0b\xa4\x63\x7d\xc0\xa6\x22\x50\x34\x52\x56\x43\x0b\xce\x39\x38\x7e\x51\x8c\x82\x26\xb9\x36\x81\x7e\x96\x58\x4f\x82\xfd\x0c\x1d\x37\x83\x20\x98\xdb\x4c\x25\x38\x86\x7b\x43\xb6\xa5\x62\xa5\x7a\xe8\x18\x5a\x10\xd1\x6e\x62\x9f\x6b\x35\x8c\x6c\x48\x64\x25\x49\x37\x67\xcc\x1b\xae\x7d\x33\x5b\x36\x68\x16\x27\x60\x43\x29\x18\xa4\xe6\xf5\x9a\xd5\xc7\xe0\x1d\x4f\x14\x35\x2a\xac\xe7\x4b\x0a\x21\x63\xbb\x5c\x47\x2b\x06\xc0\xc5\x12\x5b\xd5\xa8\x0d\x59\xf9\x1a\xf1\xf7\x5e\x97\xeb\xa5\x46\x74\x60\x31\x3f\x6a\xc5\x0f\x90\xf8\xdd\xff\xef\xbb\xe9\xee\xcf\xbb\x8b\x4b\x74\x83\x39\x71\x82\x71\x44\x8a\x3d\x30\x94\xfa\x97\xb4\x5d\x2f\x79\x5e\xd3\x5f\xe7\xa4\xbd\x04\x2f\xb1\xaf\xa5\x01\x15\x57\x1e\xc7\xf0\x4f\xe8\x03\x5f\x5d\x7a\xe4\x2b\x7d\x28\xce\x4b\xea\x66\xb6\xeb\xe5\xd9\x15\xdf\x2e\x09\x51\x84\x7e\x02\x37\xa9\x6c\xa4\x7d\x51\xaf\xfb\x13\xdd\xf7\xf5\xdb\xe7\xfb\x2f\x5f\xdf\x7d\xf9\xf8\x79\x13\x71\xe4\xb7\x23\x03\xad\xf5\xea\xa8\xd4\x83\xa7\x52\x65\xe1\x37\xb5\xee\x59\x8c\x7e\x16\xeb\x6f\xf6\xcd\xc1\x35\xee\x98\xf6\x3e\x2a\xf0\x2f\x3c\x75\xce\x43\x04\x29\xea\xe4\x22\x5f\x16\x98\xee\x41\x79\x57\x61\x2b\xcb\xfe\x97\xb1\xae\x83\xf4\x40\x3b\xc8\x63\x14\x96\x57\x6c\x48\x9a\x40\xb9\xcf\x95\xf7\x9e\x62\x3d\x50\x69\x7b\xae\x65\xa2\x08\xdf\x47\x9b\x45\x70\x60\x0f\x4a\x3c\x37\xf8\x73\xb0\xcd\xed\xe3\x1c\x1d\xfe\x60\x9a\xc4\x68\xe7\x09\xa5\x39\xdc\xf6\x9c\xf1\x32\xc0\xfb\xcd\x13\x02\xa1\x9e\x4b\x9d\xb0\x61\x72\x2f\x7b\x0a\xfd\xfb\xee\x35\xe5\x98\x5c\x13\xb3\x88\x83\xd8\xc1\x94\x26\x2f\x9b\xff\x2c\xcf\x13\x05\xdd\x25\x30\xbe\xab\x52\x4b\x75\x29\xd9\xb5\x02\x68\x4d\x57\xf0\x6f\x46\xa2\x7b\x76\x39\x89\x82\x0e\x6b\x07\x7a\xbe\x28\xf5\x85\x55\x41\x36\x8f\xe5\xec\x33\x34\x22\xf5\x82\x29\x2e\xbc\xbc\x08\x94\x13\xe9\xf1\x90\x5d\x07\xb6\x77\xac\xae\x44\x57\xb0\xe5\x83\x1b\xbb\xb9\x92\x67\x22\x48\xaf\xda\x4c\xd8\x2b\x63\x7a\x53\x8b\x00\x3b\x67\x5a\xd3\xc6\x0a\x8f\xbd\xa1\x69\xd5\x84\x96\xd8\x89\x5a\x80\xa4\x6d\x2d\xb6\x1c\x0e\x17\xcc\xd3\x12\xf7\x1c\xf9\x00\x4a\xe5\xa7\x28\xa2\xdf\x5e\x99\x50\xef\xfe\x3b\xa1\x60\x8d\x84\xd3\x09\x95\x30\xa1\x22\xe4\x46\xfc\xdd\x13\x2a\x3c\x77\x42\x95\x62\x9c\xfe\x9e\xd4\x9b\xa6\xba\xf3\xe2\x3b\xec\x55\x6d\x8a\x18\xb9\x25\x2e\x50\x30\x6a\xdc\x3d\x77\x02\xbd\xe1\x16\x37\x73\x67\x9b\xfe\x70\x92\x50\x08\x66\xad\x06\x45\x1e\x3b\x5f\x15\x9d\x5f\xd5\xfa\x96\xf6\x15\xa6\x79\x0f\x5d\xd4\x66\x2b\x37\x49\xce\xec\xea\x93\x19\x9e\x5f\xe5\xc9\x2b\x3d\x49\xe0\xa4\xd5\x78\x62\x66\xcb\x37\x49\xef\x8a\x2f\xcd\xa4\x75\x0c\x3f\x30\xea\xec\x32\xfa\x9b\xb2\x13\x4d\x1b\x21\x5b\x02\x23\xb5\x55\x2f\x4f\x4a\x2d\xc2\x69\x8e\xcd\x25\xd1\xb9\x5d\x42\xbb\x66\xdc\x4e\x6d\x7c\xdc\x0e\x77\xf3\x72\xbb\x9b\x5d\xf4\xf9\xdb\xf7\xef\xd3\xfd\x9b\xcf\x1f\xef\x37\x4c\x17\xc4\xb7\xb0\x25\x34\x88\xad\xd5\xd7\x4d\xec\x2c\x1d\xc3\x88\x8a\x40\x85\xee\x59\x4b\x2a\x2b\x2a\x08\x11\x7c\x16\x93\xbc\x19\xe6\x8f\x1c\x54\xc2\x0f\xb3\xd7\x49\xa2\x8c\xf5\xa4\x5b\xa9\xd8\x6c\x05\xca\xd9\x02\x7f\x1f\x89\x1a\xb1\x3a\x10\x45\x5b\x9b\xe1\xc4\x15\x6d\xbc\xea\x0c\x82\xd3\xd1\x74\x57\x28\xa7\xbd\xc1\x6d\x5e\xb4\xb4\x33\x44\x2d\x1a\x16\xab\xb0\x29\xc4\x59\xac\xba\x03\x56\x5a\x62\x53\x70\x22\xf9\xb4\x5d\x4f\x5a\x3e\x07\x57\x3b\xb4\x62\xbc\x98\xa8\xa6\x31\x63\x77\x84\x39\x05\xbb\x24\xea\x36\x8b\xf7\x53\x1d\x0f\x06\x5a\x44\x2d\x52\x8b\x4b\x8c\x1a\xb8\x96\xbb\x6b\xe7\x44\xbc\x93\x48\xc9\xd9\x10\xa4\xa1\x26\x76\xad\xe9\xd1\x9c\x00\xf3\xb0\x76\xd5\x8d\x93\xac\x46\x31\x4f\x58\x8d\x56\x97\x4c\xbf\x16\x29\x15\x1d\x8b\x6c\x93\x8e\x71\x34\x7b\x55\x5d\x1d\x29\x36\x10\x3b\xaf\xdd\xec\x44\xdc\x2d\xd2\x67\x79\x61\xb2\xbf\x67\xa4\x48\x72\x72\xf2\x04\xbf\xe2\x93\x50\x75\x31\xcf\x49\x26\x98\x4b\xc5\xb5\x0e\x35\x0b\x59\x95\x2e\x63\xc2\xe2\x4d\x72\xb4\x03\xbc\x9c\xfc\xd8\xa2\xa8\xeb\xec\xb2\x2c\x13\xad\x34\x4b\x4e\x7a\x67\x20\x58\x24\x9d\x2d\x0b\xec\x0c\x36\xa4\xb9\x34\x0a\xb6\x15\x8b\x0e\x6b\x26\x77\xfb\xb4\xdc\x22\x5d\x68\xd8\x86\x2a\xd4\xfc\x16\x47\x82\xb1\x0c\xeb\x5c\x12\x00\x38\xc4\x6a\x5c\xa8\x44\x47\xf5\xe0\x59\xd5\x24\xa7\x82\xde\x26\xa1\x16\x16\x6b\x10\x10\x7e\x20\x54\xf6\x59\x37\x48\x4f\x9b\xf3\xcb\x86\x61\x07\x27\x19\x3a\x41\x3e\x66\xcc\xc0\x1c\x34\xfd\x22\x47\x87\xd0\x91\xbc\xbf\x1e\x35\x19\x76\x2b\xe4\x55\x03\x28\xf7\xc5\x54\xb3\xf4\x04\xce\xd6\xc7\x77\x5f\x1e\x2e\xa2\x6c\xc5\x6d\xb0\xfb\x04\x70\x11\x69\x7a\xf1\x44\xf5\x47\x4d\x98\xca\x80\xa8\x30\xdf\xb1\xe8\x0a\x6d\x62\x52\x79\x8a\x7c\x45\xd3\x5c\x7e\xa8\x2e\x80\x73\x39\x90\x98\x59\x4c\xd5\x31\x8a\x26\xa1\x4f\x8e\x5a\x41\x58\x61\xd2\x90\x8b\x56\xc3\xe3\x5a\xf8\x91\x69\xdd\xb2\x23\x2b\xb2\x21\xac\x4c\x2a\xba\xb4\x09\x15\x61\xf8\x0b\x7f\x2c\x7a\x1a\xbe\x79\xc6\x13\x8c\xa2\x09\x69\x1b\x96\xa5\x4c\x91\x9d\xef\xc8\x2f\x2b\x8b\x7a\x54\x7b\xd2\x03\xf9\x54\x8e\xf0\x83\x9e\xbc\x21\x0d\x5f\xc6\xf9\x76\x83\x67\x8e\xf1\x9b\x87\x0f\x1f\x36\xe3\xbc\x0d\xc3\x1f\x23\x32\x5c\xc9\x65\xa8\x1d\xc0\x37\x08\x34\x8b\x24\xc3\x02\x48\xec\x98\xd2\x4b\x7a\x37\xab\x74\x22\x8a\xdf\x5f\x53\x94\xae\x26\x04\x97\x61\xb6\x16\x3a\x8e\xc2\xa5\x9e\x99\x7d\x36\x7b\xba\x23\x14\xd9\xe1\xa8\x9d\x45\x45\xc8\xe4\x38\x40\xe9\x9b\x65\x00\x83\xfb\xf1\x71\x42\x1b\x76\xbf\x77\x42\x13\x67\x40\xca\x71\xcc\xae\xd1\xe4\x39\xc3\x61\x9e\xae\x06\xf0\x1b\xbb\xc6\x17\x63\xf3\xc4\x11\x9b\x48\xba\x14\x9f\x17\xa5\xb9\xf1\x79\x74\x7e\x77\x92\xdb\x10\x82\xb4\x83\x91\xb2\x40\xa2\x18\xd1\xb5\xd9\x38\xd2\xb7\x14\x97\x5f\xb6\x32\x5b\x36\xf9\x76\x16\xfc\xd7\xfd\xc7\xfb\x69\x93\x32\x17\xb7\x31\x7e\x6e\x6b\x65\x75\x68\x8a\x53\x56\x52\x00\xbf\xda\x41\xe6\x53\x05\x49\x40\x89\x8e\x29\x3a\xf9\x53\xfa\x4e\x54\x59\xf9\x8c\x20\x9d\x01\x8d\x06\x6c\x7e\x51\x5e\x02\xdc\xa5\xba\x8f\x68\x70\x7c\x81\x93\x97\x72\x58\x00\xaf\x60\x7e\x13\x4f\x5c\x56\xdb\x03\x75\xaf\xba\x59\xb4\x7e\x2c\xd4\x4b\x9a\x76\x11\x14\x4d\xa4\xa8\x89\x5c\xe0\xda\xd7\x2c\xe3\xea\xf4\x1c\x0e\x76\xa1\x55\xfb\x31\xb9\x7a\xf2\x10\x7d\x06\x35\xdb\xc4\x3c\xa4\x7a\xd8\xd9\x6e\x87\x46\x1e\xb4\xed\xbf\x80\x39\xe9\xdd\xdd\x74\xff\xe9\xfd\xdd\x97\xcb\x61\xf4\x78\x33\x8c\xae\x9e\xbc\xb6\x17\x39\x61\xec\xfc\x38\x84\xf2\x69\xde\x95\xd0\x9a\xb1\xa6\x3d\xae\x85\x29\x57\x88\x92\xf4\xec\xc7\x15\x2d\xe5\x02\x31\x16\x86\xf2\xaf\x7c\x00\x40\xbd\x56\xd6\xa3\xdd\x35\x78\x44\x79\xe9\xcb\xf8\x88\x9a\x41\xf8\x08\x1f\x71\x65\xd6\xdb\x20\x64\x96\x74\x05\xdd\xb5\x2b\xbf\xec\xcb\xaf\x12\x49\xf7\x42\x2c\xc6\x0f\x1f\xbf\xdc\xbf\xb9\xff\xdf\xe5\xe3\xa7\x3f\xbe\x7d\xfc\xba\xdf\xc2\x78\xc5\x5b\xa1\xfb\xe1\x52\xfb\x59\x24\x54\x70\xf8\x01\x4d\x78\xb8\xe0\x87\x03\x5a\xab\x60\xab\x1a\xcb\x70\x64\xc8\xa7\xa3\x49\xa4\x80\xeb\xea\x5b\x67\xe0\x25\x10\x2d\xbe\x3a\x0e\x83\x64\x31\xf0\x4c\xa4\xae\x62\x6a\xba\xe4\x89\x0c\xb8\x85\x43\x04\x49\xcf\x4b\xfd\x97\x2d\x28\xae\x4b\x28\xb0\x5e\x1d\x21\x7d\x93\x8a\x12\x07\x41\xef\x20\xda\x7b\x11\xe8\xca\x29\x44\xb4\x82\x8e\x76\x32\x8d\x1c\xc6\x68\x51\x03\x21\xe8\x77\xaa\xbd\xa8\xcf\x63\x9b\xfb\x60\x5e\xf7\xee\x2a\x92\x42\xe0\xdd\xc6\xfe\x56\x97\x08\xc1\x32\x8b\x1c\x71\x04\x32\x95\xa2\x89\xa3\xb8\x67\x91\xdb\xd7\xb0\xb4\xec\x4a\x5d\xe0\xcb\x46\x06\x10\xd2\x87\x12\xab\xdb\xf9\xd2\x34\x7b\x8c\xe0\x85\xd5\x00\x5b\x48\x79\xb0\x62\xc0\x96\x40\x4e\x3a\x7c\x41\xe7\x4f\x36\x20\xd1\xc9\xb7\x34\x5b\x06\xa7\x8c\x9a\xf2\x02\xea\x78\xde\xce\x00\x7b\x78\xf7\xcf\x2d\x16\x6f\xbc\x95\x38\xa1\x64\x65\xbf\x20\x14\x8e\xe5\x1f\x15\x46\x9e\x01\x94\xa3\x99\xaf\x51\xb3\xa7\xb2\xa2\x48\x49\x8f\xce\xb0\x44\xdb\x00\xf1\xa1\x5a\x34\x61\x2b\xd6\x8e\x60\xf9\xa8\x13\xe1\x32\x69\xb2\x35\x32\x27\x2a\x0a\xc5\x81\x7a\xbd\x3a\xfd\xa3\xeb\x46\x2c\xa5\x2e\xff\xe4\x7c\x73\x91\x27\x78\x7b\xe4\xae\x8d\x1c\x43\x1b\xa8\x62\xb5\x65\x80\x5b\x69\x2c\x89\x76\xa7\xc1\xae\xe3\x5d\x2a\x52\xb4\xb2\x8b\x1d\x3c\x5d\xb1\xa9\x16\xa0\x1e\x9a\x32\xc5\xda\x1d\x87\x59\xd4\x52\x4a\x8e\x6a\x01\x66\x03\xb5\x06\x64\x9b\x98\x9b\xe3\xdc\x96\x14\xc9\x55\x32\x11\xa9\x1e\x82\x85\x0c\xd0\xf6\xb6\xd2\x79\xf7\xbf\xef\xde\x6f\x1c\xdb\xf1\x1a\xd6\x85\xa2\xa6\xa4\xec\x6a\x89\x1a\xfd\xf0\xb5\xc4\xbd\x8f\x31\x4d\x54\x9b\x33\xf0\x62\xc4\xc2\xb3\x6b\x0d\x89\x69\x51\x43\xb3\x31\xee\x3d\x95\x3e\x69\xf9\x6b\xcf\x76\x99\xfc\x85\x3f\xb8\x95\x2b\xbf\x4d\x9e\xc4\x9a\xe2\xba\x27\xae\x65\x16\x25\x57\xd4\x18\xdd\xdc\xb1\x9e\x93\xd9\xf9\x62\x34\x16\x99\xc2\xd1\x69\x9e\x7e\x7b\x95\x17\x8c\xfb\x53\x0e\x8f\x77\xfb\xfb\xc3\x97\x87\x4f\xa0\xf9\xba\x08\xcb\x1a\xeb\x70\x2e\xc2\xd1\x93\x68\x12\x75\x0a\x42\x0b\x59\x76\x26\x4b\x35\xcb\xce\xc7\x50\x5d\x0c\x75\xb2\xcf\x8b\xe7\x8c\xeb\x47\x9a\xde\x99\x18\x9e\x7c\x12\x85\x32\x41\xa1\xbc\x94\xae\x38\xad\xbf\xaf\x29\x7e\x47\x41\xfd\x8b\x2b\xd5\x77\x7f\x63\xc1\xef\xd9\x40\x5c\xc4\x36\x8d\x2b\xe0\x49\x95\xd5\x93\x08\x5d\x61\x3d\xb1\xe9\xe5\xf1\xdb\x95\x5e\x96\x41\xf0\x63\x14\x2e\xf4\xb2\x0c\xa0\x8c\xa6\x0e\xa9\xfc\x73\xed\xcc\xf5\x4e\xff\xc1\xe3\xb1\x25\xbc\x88\x27\x28\x1b\x45\xa4\x58\xbd\xb9\x2e\x9e\x18\x8d\xa7\xe6\xfc\xad\x3e\x9e\x4e\xd7\x9c\xb7\x45\xf7\x9f\x3a\x10\x97\xb8\x37\xe2\x8a\xe8\xd0\x28\x3a\x8e\xf5\xe6\xba\x78\x42\xfa\x9c\xcf\xfb\x31\xed\x7f\x60\x01\xfd\x87\x8a\xa9\xfd\xf2\xe7\x94\x37\x23\xb0\x45\x25\x38\x49\x9b\xa5\x18\x5c\x8f\x7d\xa2\xe2\xa8\xe6\xbd\x6f\x2d\x4d\xa2\xae\xe5\x98\xf6\x85\x40\x5a\x8a\xf0\xd0\xe4\x09\xfe\x12\xd9\xf7\x7a\x71\xf8\x14\x5d\x23\xec\x3d\xd5\x3c\xe1\xac\xda\x26\x2d\x65\x0f\x61\x9f\x0e\x34\xc5\xdc\x5d\xef\xc8\xf2\x4f\x88\xcc\x23\x44\x05\x7a\xe0\x52\xd3\xf7\xd7\xa2\x51\x04\xb5\x05\x27\x4d\xfe\xa3\x14\xdb\xe4\x73\x45\xc2\x34\xcb\x51\x72\xf4\x44\x3d\xfc\xbb\xaf\x5f\x37\x81\x93\xb8\xad\x85\x3f\xea\x0a\x5c\xb3\x3d\x38\x87\x3c\x79\x06\x62\x57\x8c\x71\xf2\x2d\x58\x04\xcb\x97\xde\x9c\x1c\x54\x72\x31\x97\x3d\xf7\x3a\x89\xea\xec\x29\xd5\x29\xc1\xb1\x5c\x68\x4a\x4d\xb4\x21\x9a\x4a\x73\x31\x02\xaa\x21\xb4\x49\x94\x9f\x2e\x4a\x41\xe8\x13\x20\x74\x48\x7f\x78\x82\xbb\xe6\xdd\xfe\x61\x6b\x35\xdd\xaa\x7e\xed\x65\x2d\x37\xfb\x29\xab\xa9\x76\x76\x51\xec\x55\xab\x4f\xc6\x48\x8a\x1e\xaa\x85\x03\x6c\x26\xd4\xb9\xb6\xd9\xa3\x43\x49\x07\x96\x4f\x92\xb9\xa9\xd9\xcd\x3c\x22\x16\x98\xbb\xf0\x78\xdb\x1f\x7a\xac\xa7\xe1\x2c\xdc\xc4\xcb\x5d\xfa\x31\xad\xc9\x4c\x33\x62\x64\x68\x07\x14\x27\x04\x17\xc3\x21\x2a\x8b\xf5\x59\x2a\xb0\x34\x58\xab\xb7\xb0\x4e\x67\xad\xeb\xf2\x30\x77\x26\xd4\xfb\xca\x3f\x73\xa9\x28\xe4\x33\xd5\x4c\xd1\x2d\x95\xa4\xd5\x37\xa5\xf4\xaf\x96\xcc\xfc\xdc\xb4\x11\x80\x75\x94\x38\xfb\xdc\x34\xf4\x15\x81\x3e\x86\xec\x23\x62\x8d\x15\x8a\x71\xa7\xb8\xda\x8b\xa1\x6c\x0f\xd8\x75\x43\x5d\x97\xbe\xae\xa3\x54\x90\x11\x4d\x44\x87\xa0\xb4\x82\x4a\x44\xa6\xf3\x89\x67\x66\xf7\x1c\x94\x77\x64\xd4\x94\x54\x67\x4a\xa2\xa1\x2b\xf3\xac\x6b\xac\x08\x95\x88\x01\xc4\x57\xd6\x39\x14\x34\x95\x09\x94\x3a\x2e\x02\x13\x0d\x7d\xc9\x01\x5d\xfb\xa2\x64\xe8\x6f\x9f\xa6\x87\x77\xff\xbc\x54\xc2\x1d\xb7\x81\xb9\x53\xf2\xa5\x5c\x90\xde\x71\x89\xf5\xd9\xd8\xb8\xcc\x1e\xf3\x65\xb5\xc4\xac\xda\xec\x02\xea\xa0\x5e\xf2\x88\x55\x3a\x0e\x12\xdb\xa3\x8b\xfe\xd4\x43\xaf\xbe\xde\x53\x6f\xfd\x72\xea\xc7\xbf\x05\xa8\xbf\x9d\x30\x36\xf2\xc6\x82\x7e\x64\x45\x7f\x8c\xb9\xbf\x53\x62\xd6\xfa\x44\x6e\xee\xdb\x6f\xd3\xf4\xf5\xfe\xff\x36\x01\x96\x14\x56\x05\x07\xe0\x10\x96\x70\xf7\x1c\x66\xf6\xe5\xe6\xac\x34\x14\x05\x03\x13\x42\x80\xf0\x48\x61\xbc\x9c\x93\x1b\xdb\x22\x3a\xa3\x3a\xd6\x2f\x97\xb3\x3f\xce\xce\x3b\xbd\xc3\xc9\xad\x07\xa2\x84\x6d\xba\x97\x51\x58\x96\xa7\x51\x55\x96\x2d\x96\xca\x7f\xe1\x91\xfe\x6e\x78\xa4\xfb\x69\xfa\xf8\xf9\xeb\xc7\xaf\x6f\xb0\xec\x1f\x3e\x2d\xdb\x72\xd8\x74\x2b\x72\x04\x60\x98\x10\xd6\x14\xbb\x4b\x12\x00\x02\xfb\x82\x04\xd0\x4b\x1e\x49\x00\xf9\x72\x2b\x61\x0c\x0e\xe5\xef\x78\x90\xe2\x89\x3c\xfd\xa4\xdd\x4f\x3f\xea\x59\xe3\x72\xb8\xff\xb2\x7c\x7c\x77\x61\x54\x36\xe1\x93\xd8\xd2\xc9\xa0\x20\x77\xf0\xaf\xee\xab\xbf\x6d\xf4\x81\x71\x10\x89\x7f\xef\xa0\xbc\x89\x61\xa3\xbe\xa6\xf8\x8f\xd3\x8c\xcd\x5c\xfe\x62\x04\xac\x56\xa2\xa8\xd9\x70\x1f\x32\x1c\xb4\x15\x39\x2f\x5a\xcd\x82\x0f\x87\xaf\xe0\x2d\x24\xcd\x3c\xe8\x23\xde\x77\x12\x7c\x75\xa6\x05\x5a\xc2\x06\x85\x99\xb2\x26\x60\x71\x41\x02\x05\x2d\x88\x84\x71\x49\x33\x80\x60\x35\x76\x88\x5d\x82\x9d\x6f\xca\xb8\xbf\x33\xee\x2a\x44\x1c\xbb\xe3\x24\xbb\x43\xaa\xa2\x6b\xcf\x3e\xa3\x90\xc6\xe7\x22\x6a\xb6\x4a\x63\x88\xb0\x12\x44\x48\x8b\x0c\x45\x69\x8c\xc8\x7a\xad\x92\x41\xba\x0d\xf2\xe7\xb5\xe9\x86\x36\x60\xf1\xd0\xed\x2b\x74\x7d\x01\xd8\x31\x33\xe4\x77\x75\x11\x16\x09\xe9\x6e\xa6\xef\x58\x21\xe9\x49\x15\x85\xda\x4e\x5f\x47\xaf\x36\x48\xb5\xf5\x4d\x66\x22\xd7\x9d\x85\x89\xfe\xfd\x08\xd1\x3f\x4f\x77\xff\x07\x33\x7f\x33\x59\xd3\x19\xd9\x56\x0a\x6d\x96\xcd\x2a\xb8\xa7\x77\x91\xe5\xef\xda\xd1\x4c\xad\xc9\x2d\xcf\x51\xe1\xad\xd9\x65\x40\x90\xb8\x9c\x27\x9f\x53\x42\x29\x8f\x8f\x04\x6f\x42\x49\x8e\x50\x12\xeb\x0d\x84\xc2\x67\x40\x1f\x28\xb6\x47\x75\xfa\xcd\x6e\x06\xc0\x34\xfe\x6a\x33\xea\x72\x23\xbb\xdb\x35\xc8\xcb\xc7\x4b\xb1\x89\xb4\x8d\x4d\x9c\xb8\xb6\xad\xbc\x2e\x4d\x51\x33\xfe\x8b\xd8\xc5\xd2\x82\xca\x93\xfc\x29\xda\xec\x77\xb8\x57\x28\xe4\xa9\x50\x73\x85\xda\x65\x07\x70\x61\x51\x96\x00\x10\x0e\x6c\x70\x51\x05\x4d\xa5\x6d\x93\x97\x4b\xe5\x9f\xab\x6e\x47\xd1\xad\xe4\x7a\x04\xb9\x9b\x1a\x26\x0d\x46\x91\xec\x71\x35\xb0\xab\x89\x27\xdf\x83\x98\x5c\xa1\x59\x7a\x58\x75\xab\x88\x5a\xe5\x96\xd8\xfb\xc5\x11\x97\x39\x17\xa7\xff\xa1\x6e\x4f\x3f\x77\xc7\xba\x3d\xab\x64\x9b\x34\xb5\x81\x0b\xee\x69\xb7\x35\x31\x87\xcf\x49\x1e\xda\x43\x99\xf5\x67\x7b\xcc\x2a\xf9\x26\x42\xfd\x04\xe7\x19\x59\xc1\xe3\x7f\xa3\x6e\xf1\xa3\x74\xce\xe7\x51\x42\x37\x11\x94\x7e\x06\x1e\xee\x78\xa6\x8a\xde\x71\xf4\x44\xe2\xcc\xa7\x6f\x5f\xd5\x2d\x76\xc1\x28\x4a\xe5\x1f\xc7\x88\x78\x40\x52\xc2\x65\x2a\xc8\x3d\x70\xbb\x8e\x86\xc6\x89\x55\x7f\x6a\x08\x9e\x19\xf8\x8a\x2c\x68\x96\xe3\x89\xa5\x7f\x26\x73\x7e\xa3\xc8\xd9\x3d\x5b\xe6\x00\x1a\xe9\x0d\xba\x72\xd3\x83\xdb\xfa\xc4\x53\xaf\x56\x66\x57\xe3\x0d\xb8\x12\xe5\xc3\x7c\x1a\xae\x04\xb1\xa3\x6d\xb5\x97\x0c\x9a\x28\x43\x4a\x7e\x6b\xdc\x46\x2b\xb5\x91\x91\x5d\x9e\x72\x5d\x7a\x63\x39\xd2\x28\xbb\x71\xe6\x6a\xbc\xd4\x8f\x80\xa9\x7f\x4c\x78\xa9\x91\x53\xcd\x79\x42\x70\x1b\x83\x37\x08\x77\x1f\x0d\xde\xee\xd1\xe8\xe9\x1b\xde\x1c\x3d\xa3\xfe\xbd\x3a\x7a\x78\xf9\x1f\xde\x30\xa6\xfb\xc3\xfd\x74\xc1\x39\x9f\x6e\xd5\x90\x51\xa0\xe6\x7a\x34\x0e\x03\x59\x69\x19\x9f\xe6\xda\x68\xd7\xc6\x13\xb4\x14\x56\x5c\xd9\x9d\x88\x30\x78\x33\x92\x8b\x79\x22\xa5\x8f\x9d\x35\x89\x5d\x8c\xcf\x7d\xe4\xa0\x59\x40\x27\x8a\x64\x6e\x2e\x02\x17\x0b\xf2\xc3\x95\x36\x45\x0e\x1a\xfa\x04\x29\x42\xea\x8e\x79\x01\xce\x02\xe3\x27\xf0\xfa\x71\xc5\x06\xd1\x9f\xd4\xf3\xb4\x3b\x2e\xb9\xc8\xd3\x96\xf4\xf7\xd8\x21\x11\xf0\x7e\x61\x2f\x2f\x78\x64\xf4\xf4\x83\xd2\x13\x59\x01\xd2\x2f\xf1\xa8\x7b\x6a\x8f\x21\x77\x05\x08\x23\xa3\xa9\x5a\x6f\xc9\x8a\x9f\xc5\x0c\x7c\x71\x66\x3d\x01\xbf\x73\x01\xc2\x51\x77\xa5\xcb\x3b\xc7\xea\xd0\x27\xf0\x77\xa1\xb7\x4e\x8b\x23\xa5\x1f\x27\x3f\xfa\x76\x04\x9e\x93\x8b\x69\xc6\xb6\x23\xc3\x70\x7b\x2f\xd4\xd5\x7d\x51\xa5\x58\x83\x06\xa5\x65\x04\x0d\x0a\x25\x57\xe8\x87\x82\x06\x09\x54\x31\xa5\x4e\x9e\x51\xc4\x40\x3f\x1c\x75\x43\xc7\xe6\x76\x23\x68\xf0\xf3\xe2\x75\xf7\x37\xaa\x74\xf7\xef\x3f\x2e\x97\xfb\x7f\x2d\x82\x4a\x21\xb9\xc4\x6d\x12\x81\xea\x29\xf3\x84\x6c\xa6\xcc\x7b\xd1\x88\x3a\xd0\x30\x0f\x19\xda\x47\x73\x8d\x80\x20\x8c\xda\x44\xf9\x0f\xa4\x1c\xa2\x71\x77\xd2\x6c\x14\x64\xa4\xc8\x64\x54\x5d\x3c\xba\xe8\x62\x98\x18\x98\x61\x24\x0a\x94\xac\xbd\xe0\xe2\xf7\xd7\xa2\x90\x11\xb7\x49\x3e\xb3\x96\x91\x89\x7d\xd5\x54\x55\x93\x7f\x90\x93\xb5\xe7\xd6\xbe\xaf\xd2\x7e\xea\x8c\xd2\x8e\xb5\x1c\x7a\xd8\x6a\x13\x58\x90\x28\xf3\x79\xf9\xf2\x30\xf2\x26\x50\xc9\x00\x02\x6e\x8c\xe1\xee\x77\xef\x91\xcf\x1e\xc3\x37\x91\x78\x33\x7c\xef\xce\xb4\x8b\x12\xda\x21\x5d\x0c\x14\xec\xbd\x7c\xef\x13\x3c\xfb\x40\xab\xe9\x3a\x52\x89\xb0\x9a\x6b\x98\x48\xfa\x9b\x64\x08\x32\x52\xf1\xe3\x8f\x85\x41\x33\x58\xc1\xd2\x7a\x3b\x55\x21\xfb\x0a\x91\x82\x34\x9f\xec\xf2\x1c\x81\x75\x17\xbb\xcb\x3f\xb8\xa6\x76\xbf\x77\x3c\xbe\xee\xef\xbe\xdc\x5f\x5e\x54\xef\x8f\x3e\xdb\x90\x5d\x8a\x22\x51\x10\x7b\xb9\xac\xab\xdb\x6f\xb2\x62\x44\x2a\x97\x0e\x44\xbd\x64\xc5\xc9\x29\x28\x2e\x12\x9d\x4e\x40\xe4\x0c\xa9\x65\x84\xc4\x32\x78\x2e\x09\x23\xd9\x17\xd4\xbe\x39\xdf\x61\x6b\x59\x05\x4c\xe8\x8b\x37\x53\x5d\xeb\x51\x70\x64\x75\x1e\xd4\xc8\x29\xcf\x96\xec\x3d\xa4\x61\x19\x68\xd1\x73\x45\x6d\x84\x8b\x33\xcb\xd6\x47\xdd\xc9\x8e\x9d\x00\x25\xe4\x0a\xbb\x54\xe3\x9c\x8a\x93\x45\x17\x83\xab\x59\xc4\x1a\x73\x72\xba\x59\x51\x19\x18\x5b\xfa\x12\xc8\xec\xca\x48\x11\xca\x27\x7a\xeb\xbf\x90\xc6\xfa\x7c\x85\xf5\xe1\xcf\xcf\x77\x5f\xb7\xca\xea\xfd\x3f\x4e\x71\xc6\x52\x43\x9d\xbe\x08\x38\x6f\x07\xa0\xd4\x5b\xa1\x54\x62\x3f\xf8\x2c\x96\x54\xd6\x74\xb7\x72\xc8\x49\xc4\x53\xa4\xd5\x35\x9f\x9a\xbb\x46\x40\xbd\xfc\x3a\x92\xeb\x9f\x8f\x85\xef\x7e\x97\x13\x7a\xd0\x1c\x3d\x1e\x8b\x7c\x0c\x9d\x50\xca\xae\x15\x82\x2c\x42\xa6\xa4\xa8\xe4\xa6\x30\xa5\x64\x66\xb0\x28\x78\x40\x77\xa9\x8b\x7c\x72\xd5\x13\xf0\x3b\x47\x85\x84\x74\xa5\xcc\x28\x41\x72\x59\xfe\x05\xf1\x84\xaa\x62\x08\x46\x8e\xbc\xe3\x12\x9e\x60\xe9\xd7\xf9\xfb\xc3\x2c\xfd\x98\xbb\xd7\x58\xfa\xff\xfd\xb6\xb6\x95\xa8\x6a\xd9\xc2\x60\x65\x3a\x1b\xc5\x44\xfd\x71\xc2\xab\x55\x4e\x98\x6e\x8f\x00\xa7\x28\xc0\x32\x46\xae\x94\x69\x8c\x21\x01\x94\x01\x03\xbb\xe8\x30\x4f\xeb\xf8\x33\x02\xdb\x0e\xd3\xe2\x5f\x6a\x0c\xff\x7d\xbc\x86\x6f\x22\xd5\xcd\xd8\xf1\x3f\x4e\x2b\x32\x86\x5b\x2d\x8e\xb5\xa6\x59\xd9\x7e\x38\xe4\x14\xa5\xa3\xa0\x34\x32\x02\x3c\x09\x6c\x76\xf5\xa0\x17\xa6\xa0\xeb\x6e\x46\xd9\x06\x6c\xf1\x3c\xad\x37\x00\x85\x22\x86\xd8\x67\xde\x8e\xe1\xa3\xf4\xff\x73\x10\xd3\x93\xfc\xff\x23\x5c\xcc\x69\xfe\xff\x29\x96\xe9\x5a\x00\xf0\xe4\x9e\xf5\xd8\x50\xff\xed\x63\x74\xff\x6d\x93\x79\x92\xb7\x45\x1c\x47\x93\xb4\xd7\xe2\x98\xfb\x84\xcc\x85\xdc\x67\x03\x1c\x8c\x36\x97\x55\xd5\x4f\xaf\xf2\x04\x6d\x02\x98\xa6\x3c\xa8\x74\x8d\xc6\x1c\xdc\x9d\x43\xf5\xd0\xad\x44\x6b\xef\x17\x18\x08\xa3\x5e\xd3\x5b\xed\x14\xae\x5c\xf1\x2e\x45\xee\x26\x05\x41\xec\xa2\x60\x28\x48\xaa\x2c\x6d\x42\x7f\xe6\xb3\xf5\xb7\x2e\x3f\xac\x3e\xa2\xa8\x6b\x77\x5d\xba\xeb\xca\x05\x78\xba\x48\x6c\x72\x14\x44\x7c\xd4\x0b\x40\x40\x07\xa2\x2d\xa4\x6d\x9b\x4b\x75\x4c\xc1\x71\x02\x86\x60\x6c\x4b\x0a\xa8\xb8\xe4\xb6\xc2\x53\x4b\x2f\x44\xa8\x51\x11\x09\xed\x94\x67\xd4\x0b\x3b\xe9\xb7\x34\x81\xb5\x50\x7a\x13\xc9\xd9\x96\x23\x6f\x00\xb0\xc9\xe0\x5f\xe1\x95\x46\x10\x03\x61\x07\x7c\x87\x42\xd3\x13\x68\x42\x03\x06\x93\x29\x0d\xe2\xe1\x45\xab\xe4\x81\xae\xa6\x05\x00\x28\x31\x4a\x1a\x41\xf7\x54\xcb\x3e\x95\x66\x30\x3b\xaa\xdc\x69\x55\xb3\xab\xce\x73\xd9\x4d\x5a\x6e\x2a\xaa\x67\x36\x22\x31\x40\x9d\x89\xe9\xd0\xd0\xd8\x58\xb5\xb6\x2e\xef\x53\x06\xd8\xe1\x7a\x23\x94\x17\xbb\xa2\xe0\x50\x7a\x1b\xd6\xdc\xf6\xc1\x56\xdb\x54\x62\x01\x50\x7f\xef\x63\xab\x33\x80\x4c\x91\x41\xab\xe9\x3a\xaa\x20\x28\x68\x74\x69\xaf\xf2\x0c\xfe\x5a\x59\x63\xa3\x3c\x19\x6b\x01\xa5\x51\x08\xb2\xbf\xca\x2e\x2f\x48\x33\x92\x29\x48\xec\xe2\x94\x9d\x26\x80\xc3\xfe\x61\xa8\x9b\x15\xe5\x84\x4c\xb7\x69\x7e\xde\x6e\xf7\x9d\x6d\x21\xcb\xa9\xf3\x8a\x83\x8b\xbd\x1f\x7c\x34\x14\xa1\x2d\x4c\xb2\x05\xa2\x1e\xc1\x1f\xe6\x70\x6d\x56\xf6\x7a\x88\x2d\xda\xac\x5e\xaf\xc3\x9c\xb6\x19\x0d\xde\xda\xf3\x09\x99\x0f\xac\xcc\xd2\x95\xb4\x0e\xdc\x71\xe3\x25\xa2\xb4\x83\x68\x2d\x75\x8c\xe6\x12\x17\xf9\xa4\x91\x2b\xac\xa5\xaa\x2b\x67\x52\x55\x8f\xb8\x22\x45\x0b\x45\x30\xac\x98\xa2\x28\x31\x44\x4b\xea\x4e\xe6\x45\x36\x27\x34\xe8\x84\x23\x23\x93\x09\x3e\x38\x2d\xbb\x8c\x55\xfd\x9f\xf0\x21\xa0\x9c\x8a\xf2\x3e\x86\x7c\xe6\xd0\x1a\xee\xac\x83\xd7\x37\xf2\x63\x83\xf5\x27\x3b\x2c\xb6\x48\x1f\x43\x3e\xf8\x58\xfb\x3e\x51\x3a\x68\x2a\x15\xe2\x76\xda\x73\xe8\x9e\x3d\x95\x53\xc7\xad\x6c\xa3\xcf\x28\x3c\xf8\xf6\x75\x53\x51\x98\xb7\xa1\x99\x53\x49\x08\xa9\x83\xd6\x66\x80\xa0\xa3\xbd\x45\x57\x61\x36\x78\xde\x02\xa3\xa7\xe6\x2b\x30\x9a\xf1\xa6\xbc\xaa\x19\x6e\xe4\x51\xa9\xef\x22\xd8\xc0\xc1\xfb\x07\xe1\x58\x13\x70\xd7\x81\x21\x15\xeb\x5a\x7a\x8e\x20\x4e\x05\xaa\x1a\x3b\x94\x05\x44\x27\x4f\xaa\xa3\x94\x93\x65\xa5\xb2\xd6\x65\x4c\x48\xf0\x83\x0b\xba\x77\x11\x62\xc7\xc0\x47\x73\x35\x39\xdf\xe6\x86\xea\x06\x94\x22\xa6\xb8\x5b\xb4\x54\x89\x79\x36\x6c\xae\x93\xd2\xfa\xc4\x0b\x90\x55\xac\x35\xa5\x60\x42\x80\x41\xfb\x55\x9e\x07\x4e\x02\x6e\xc0\x00\xe4\x1a\xe4\xe8\x80\xcf\xc0\xfb\x29\xe0\x82\x42\x14\xc4\x81\xf2\x0e\x00\x2f\x97\xfa\xa2\x98\xad\x59\xcc\x1d\x72\x5a\x00\x25\x8f\xab\xa8\xe7\x8b\xcd\xf5\xe6\x38\xf1\xc2\x39\x3b\x8a\x32\x3f\xae\xae\x2d\x02\x3f\xf3\xb9\x73\x5f\x46\xaa\xcc\xa2\x42\x16\xc5\x3c\xc6\x60\xb5\xaa\x05\x9f\xbb\xa5\xc4\x35\x94\x0e\xe0\x94\xae\x70\x0f\x69\xc6\xae\xd7\x80\x29\xdb\x26\xd4\xf6\x28\x04\x20\x7a\x47\xcb\x6e\x75\xe9\x7b\x55\x74\x00\x7f\x12\x75\xa7\x04\x10\x1a\x30\x15\xf1\xce\xe8\x3d\x96\xb1\xd5\x52\x2c\x65\xfc\x25\x14\xff\x77\x83\xb0\x45\x51\xd1\xe2\x0b\x14\x0c\xb2\x30\x90\x12\x3b\x36\x15\x87\x80\xce\x5c\x10\x1c\xf7\x31\x22\xcc\x15\x49\x8b\xb9\xc4\x98\xa9\x41\x91\x19\x40\xda\xce\x01\xa5\x29\x48\x7e\xab\x72\x62\x5e\xac\x70\x49\x3a\xac\x00\x22\x67\xb7\xc8\x99\x98\xdb\x9a\x1e\x57\x35\x71\xc9\xf9\x9e\x6e\xae\xaa\x8f\x9f\xb6\xfa\xc5\xa6\x96\xa7\xf5\xb6\xe2\x9a\x88\x30\x2a\x56\x7c\x77\x79\xcd\x94\x66\x40\xc7\x70\x27\x31\x7e\x05\xc2\x04\xb6\xd4\x30\xc3\x6d\x41\xb5\xb9\x94\xbb\xf3\x39\x16\x75\x4c\x16\x07\x3c\x62\x1d\x15\x00\xc8\xc8\xe7\xde\x83\x71\xd6\xea\xe3\x64\x30\x66\xb0\x3e\x44\xf8\x3e\x7a\x73\xb9\x92\x88\x40\xe4\xa9\x32\x1f\x44\x22\x5e\x9b\x51\xb2\xae\x22\x9c\x59\xa4\x6b\x65\xa1\xa0\x8c\x9d\x79\xef\x13\xd7\x4b\xc2\x3f\x6c\x53\x5b\x13\xc5\xd9\x83\xc1\x1d\x70\x11\x4d\x0e\xf6\x9e\xd2\x4d\x51\x11\xe3\x73\xa2\x57\x37\xba\x95\x63\x9c\x93\x32\xb3\x17\x75\xd3\xed\x69\x2d\xe0\x7a\x66\x22\xe8\xff\xf7\x79\x53\x11\x9c\xb7\xa1\xba\xc0\x75\x38\x44\x42\x74\xc8\x21\xe7\xf3\x57\xb3\x17\x8b\x87\x18\xc3\x1e\xf5\xb7\x97\x7f\xa6\x70\x55\xa1\x43\x80\x2e\xdf\xbe\x38\x5d\xbd\x18\xb0\x57\x4c\x2e\x57\x04\x93\x30\x3b\xc0\xe0\x2e\x87\xdc\xc0\xcf\xd4\x11\x90\x08\x4e\xe7\xd1\xc4\x84\x15\x93\xe1\x01\x05\x40\x8b\x0a\x52\x68\x86\x4e\x71\x71\xda\x02\x31\x5e\x68\x37\x51\x27\x97\x90\xb7\x3c\xc2\x25\x7b\x52\x3f\x78\x70\x4a\xfd\x0e\x0d\x0a\x0a\x5f\xa4\xc9\x47\xa0\xab\xd7\xbe\x67\xca\x97\x63\x41\x9a\x3b\x1c\x8e\x31\x32\x13\x5f\x63\xf3\xdc\x7b\xee\xe1\xe0\x5b\xde\x73\x0f\x37\x6f\x11\x9f\xb8\x45\x8c\xe1\xd6\x1e\x7d\xbb\x3e\xf3\xdb\xdb\xcd\x14\xd9\xc6\x04\x4f\xeb\xf6\x53\x74\x1d\x58\x2a\x48\xea\x2e\xd9\x51\xe1\xff\x9f\xbd\x77\x5b\x92\xdd\x38\xb2\x05\xdf\xf3\x2b\xe2\x07\xb0\x2d\xdc\x3d\xae\x76\x9e\x66\xc6\x6c\xde\xea\x1b\x68\x9b\x6a\x9e\x4e\x5a\xa3\x45\x81\x0d\x65\xf7\xa9\xaf\x1f\xf3\xb5\x1c\xc8\x2c\x66\xed\x2a\x52\x22\x4f\x4b\x76\xc6\x24\xee\xca\xaa\x04\x02\x40\x20\x2e\x7e\x59\xbe\x96\x6f\x74\x92\x9a\x22\x2b\x75\x73\x97\x91\xd4\x9c\x19\xd9\x53\x7c\xb5\xf3\xc8\x70\xfb\xd8\xc2\x22\x13\xdb\x1b\x7d\x0a\x28\xd2\x44\x99\xbe\x7a\x53\x25\xdf\x16\x91\x71\xad\xf9\xdd\xad\x41\xbf\xc1\x21\x5b\xdd\x22\x79\xe4\xd1\x7e\xea\x35\x69\xef\xce\xfd\xa9\xdf\xa4\xc4\x26\x99\xc4\x13\x27\xb6\xdf\xdd\xb7\x4e\x29\xf3\x3d\x53\xc8\xcf\x6a\x3a\x7f\xd9\x58\xb5\xb9\x69\xce\x18\xd6\x47\x0f\xec\xf7\x8e\xf9\x58\x83\xf0\xe7\x27\x76\xf6\xfa\x9c\xc5\xbc\x63\x58\xaa\x94\x64\x45\xd6\x21\x49\xa7\xf7\x46\x9d\x6b\xf7\xeb\xe4\x0c\xe0\x14\x86\xf8\xee\xff\xf8\x5d\xa6\x1c\x66\x7d\xfc\x7c\x7d\x69\x06\x25\xfa\x95\x00\x7b\x1f\x83\xba\x02\x9e\xa3\xe3\xaa\x5a\x5f\x5f\x86\x2a\xa4\xea\xc5\xe6\xba\x1c\x47\x75\x90\x37\x74\x49\x56\xf2\xea\xa6\x5a\xf6\x95\xa6\xa9\xdf\xc6\xa2\x73\xe2\x6d\xa5\xd3\x2f\x3d\x39\x86\xce\x5b\xe0\x0d\x80\x71\x44\x79\x7d\x3b\xae\xdf\x57\x50\xf2\xfb\xf5\x2d\x47\x19\xc5\x7b\x88\x83\xcb\x7d\x75\x95\xa3\x3a\x15\x7a\x65\x9d\x28\x3a\x04\x38\xca\x95\xae\x9f\xe2\x8d\x9a\x24\x77\x08\xa5\xb5\xd4\xa0\x12\x97\xa7\xff\xd6\x3f\x38\x51\x48\x19\x05\x0e\xae\x60\x23\x95\xce\xec\x6c\x34\x31\x7e\x15\xdc\x41\x3a\x58\x89\xf9\x90\x52\x7e\x1d\x46\x42\xfc\xfe\xc6\x4c\x56\x0a\xe1\x79\xee\x69\x8d\x0b\x96\x4a\x90\x6d\x8b\x5e\x41\xac\x81\x25\x14\xb7\xbd\x82\x5b\xa0\xe5\xab\xd5\xb9\xce\x9e\xac\xe5\x0d\x54\x3c\x78\xf6\xab\x68\xdb\xd0\x17\xc7\xd1\x23\x8e\x6e\x75\x9d\x86\xa3\xeb\xc3\xd1\xd6\xc3\x7f\x6d\x77\xff\xd5\xe0\x94\x8c\x95\x1a\x4e\xbe\x93\xc9\xf3\x4e\xf6\x6d\x7c\x88\x20\x05\x13\x6f\x58\xfa\xfc\x6d\x9b\xe0\xf7\xfb\x9f\x9e\xa6\xc7\x13\x2d\xe7\xe3\x0a\xe7\x6f\x77\xcc\x16\xc0\x2a\x45\x1d\x82\xdb\x22\x63\x93\x50\xee\x90\x1e\xb1\x70\xf0\x5e\x09\x4b\xc1\xbb\x90\xa1\x36\xb4\x3f\xc8\x31\x33\xfc\x4d\xf5\x83\xde\x50\x82\x3a\x8b\x84\x57\x41\xec\x04\xf1\x8e\xea\x63\xa7\xdc\xb4\xca\xb6\x0c\xf2\x99\xa9\x26\xf1\xaf\xf4\xf8\x8a\x31\x53\xd2\xec\xe6\x60\xd5\xcd\xe0\xc1\xcd\x79\x35\x49\x32\x0c\x1d\x5b\x03\x77\x50\xe5\x56\xb2\x5e\x7d\x98\xb6\x44\x4d\x32\xb9\xe9\xa0\x66\x4d\x1b\x7e\x73\x09\x7c\x81\x22\x37\x69\xe5\xb2\x12\xe9\x4f\x32\xac\xd9\xfd\xe0\xaa\x57\xbf\xf6\xa2\xa5\x6f\x43\x93\xba\x9b\x91\xf4\xa6\xa5\xc6\xdf\xab\x6e\x1d\x65\x3e\x52\x62\x47\x0f\xf4\x4c\x0d\x11\xbe\x3e\x76\x86\x8c\xc0\xa5\xf0\xfa\x32\x91\x49\xf3\xc5\xdf\x58\x02\xde\x0a\x40\x5c\xa5\x05\x37\x30\x43\x48\xed\xe0\xf3\x85\x53\x15\xbe\xec\xd1\xa9\x12\x94\x77\x8b\xf8\xde\x37\x36\x04\x21\x7a\x5a\xc0\x5e\x37\xf8\xb3\x1a\x82\x12\x30\xdf\xcb\x5e\x3b\xb4\xcc\x2a\x5a\x2d\xa4\xb8\x53\xa1\x3d\x6e\xf9\xc2\x48\x45\xc9\xd8\x76\xab\xbc\xbe\x8c\x21\x69\xc0\xb2\x04\x00\x57\xe1\xe3\x9c\x3c\x7d\xee\x55\x15\x26\xad\xdd\xaf\xa1\xbf\x84\xda\x1e\xf7\x17\x18\xe8\x01\xd2\x36\x24\xd3\xfc\x86\x6e\xa8\x37\x85\xa7\x5f\xe2\x4f\x3b\xfc\xc4\xbc\xd7\x9c\x74\xaf\x35\x55\xd4\x2d\xc0\xb9\xd8\x51\x94\x80\xe7\xb7\x9e\xb4\xef\xda\x93\x0d\x38\xce\xf5\xe3\x30\xc9\xff\xfc\x71\x7d\xce\xb2\x7c\xff\x3f\xde\xc2\x17\xb5\xdc\x4a\x47\xbd\x96\xcf\x36\x7f\x11\x3a\xd6\x92\x41\xf8\x1f\xb0\x01\xd2\x8b\x5a\xbb\x2e\xa5\x2b\xc1\xf9\xf3\x04\x66\xbf\x21\x5d\xb8\x02\x00\x20\xb9\x7e\xb3\x40\x08\x7c\x22\xef\xc2\xb6\x5b\xce\xcf\xb8\x6d\xe0\xcd\x6b\xf9\xd8\x8f\xf1\xe7\xfc\x6e\xff\xe1\xbf\x9e\xd0\x7c\xf5\x9e\x6f\x2f\x0d\xce\x4b\x7e\xe7\x89\x9e\x9f\xff\xf5\x65\x4e\x28\x84\xff\x61\xcf\xf3\x5e\xe7\x05\x60\x42\x5a\x3e\xd7\xf2\x37\x41\x70\x40\xa9\xde\x0b\x82\x9f\x6b\xe5\x63\x0c\xbc\xe7\x72\x79\x0e\x82\x43\xbc\x5d\xda\xef\x74\x81\xf7\xdb\x6f\x5d\xff\xa0\xf6\x3f\xcc\xef\xff\xf4\xf3\xfe\xdd\xf7\xff\xeb\xbb\xaf\xeb\x5f\xae\x5f\xbf\x7f\x86\xf2\xd6\xe7\x9a\xcd\x47\x15\xa1\x29\x49\xb8\xa5\xf4\x75\xe9\x9a\x54\x50\xfa\x9a\x4a\xdf\x16\x45\x64\x44\x41\x3e\x03\xce\xdd\x25\x68\x6c\x0e\x3e\xc0\xb1\x2f\x58\x83\x74\xbe\xbe\x74\x6b\x29\xb4\x69\x35\x50\xec\x7e\x0e\x3c\x0f\x09\x7c\xfb\xbd\xaa\xf2\xb1\x76\x13\x70\x2f\xfd\x76\xed\x1f\xaa\x1b\x49\x61\xf2\xa9\xf2\xca\x6d\xf1\x23\xdf\xfd\xea\xf5\x45\x80\x52\xa6\x3c\x8b\xd9\x75\xa9\xa3\xdc\x66\x5e\xad\xcd\x54\x15\x59\x7f\x19\x49\x25\x69\x5f\x45\xd2\xbc\x59\x50\x41\xb6\x63\xb1\xe2\xd3\x82\x2b\x25\x12\x0c\x40\x0f\xb9\xa3\xaa\x6e\xa6\x57\x54\xd6\xde\x54\xe7\xb5\xb6\x7e\x5b\x86\x3f\x1d\x94\xa0\x2c\xfb\x06\x84\xfa\x55\x21\x85\x0a\x43\xce\xb7\x45\x57\x9f\x95\xdb\x4c\x8a\xc7\xbd\x6a\x19\x37\x71\xcf\x4b\x05\xf4\x2d\x92\x46\xc7\x5c\x6c\x70\x1c\x6f\xfe\xc1\x8d\x22\xe8\x0d\x94\xeb\xa2\xc5\x56\x02\x39\x4b\xb9\xf6\x7a\x1e\xd9\x79\x64\x5e\xd5\x72\x6a\xcd\xf7\x40\xbd\xe0\x97\xc5\x7f\xeb\x1f\x13\x28\x7d\x67\xfa\xc4\x9e\x5e\x3f\x64\x34\xc5\x48\xca\xe5\xff\x8c\x81\xe4\xaf\x65\x91\x9a\x2f\xbf\xd3\x8b\x79\xf3\x5e\x38\x4e\x25\x67\xf9\x87\x19\xa7\xee\x60\xfb\x38\xb5\x6d\x26\xf1\xde\x14\x1f\xa7\x97\x73\xa0\xfe\xaa\x05\x6a\xdf\x7f\xfe\xf1\xfb\xbf\xee\x3f\x3c\xa1\x51\xda\x33\x3b\xe7\xdd\x53\xfb\x67\x18\x0e\xee\x6b\x2d\xa6\x1f\x28\x57\xbd\x0f\xef\x7e\x47\x65\x6a\x98\xbe\x2f\xee\x92\x73\x2a\x23\x7f\x70\x09\xa0\x0b\x7e\xcd\x25\x20\x0c\xf6\x7c\x05\xb7\x7d\xe6\xfc\xe8\x21\x08\x41\xf9\x15\x57\x00\x8e\xe1\x1d\x90\xba\x5b\xdf\x90\x24\xf9\xb6\xc2\x57\x6d\x97\x5f\x29\xc7\x55\xdb\x6f\xf3\x81\x9e\xc7\xe1\x7b\x85\x10\xed\xb9\x0e\xf4\xa1\xf2\x05\x80\xb6\x0f\x5f\xb4\xbe\x9f\x4f\xfb\x95\xf7\xff\x0f\x37\xda\xdf\x1d\x8b\x3e\x52\x3e\x1e\x8b\x7f\xef\x48\xf1\xd1\xfe\xf1\x58\xfc\x7b\x47\x3b\x94\x87\x3f\x1e\x8b\x98\x8a\xbf\x76\xd2\xfe\x6d\x63\xf1\xa7\x9f\xff\xe5\x99\x9b\xb0\xdd\xe1\x28\x56\x5a\x62\xe6\xb4\x19\x58\xd0\x45\x1a\x21\x6b\xd5\x0e\xb6\xc6\x61\x44\xd7\x03\x29\x5f\xc2\xd3\x9c\x75\x97\x0c\x27\xcb\x06\x9d\x61\x90\xaf\xed\x56\x41\x0b\xf7\x8f\x36\xcc\x9e\x15\xf4\x7c\x98\x81\xcd\x84\x3c\xf7\x1a\x18\x04\x54\x66\x92\xee\x5a\x0a\xbd\x11\xe2\x47\x67\xa8\xe6\x30\xc4\x40\x63\x02\xac\x83\x4d\x0f\xe5\x1a\x69\x08\x68\x51\x24\x5b\xea\x6a\x13\x32\xfa\x02\x61\x48\xe8\xd6\x08\x52\x8c\x62\x09\xb1\x0d\xdb\x40\x50\x2e\x70\x56\xe1\xfa\x36\xd4\x9d\x16\x0a\xef\x6c\xdc\x22\x2d\x72\x87\x78\x07\x44\xb8\x50\x68\x9a\xa5\x36\xdd\x48\x42\xbf\xb4\x9e\xa4\x6b\x50\x71\xd4\xe4\x3b\x7c\x1f\x24\x3d\xb0\x4d\x20\x8a\x09\xe2\xdf\xc9\x82\x24\xc0\x2c\x09\xb2\x2a\xb5\xa5\x31\xb0\x71\x97\xeb\x52\xda\xbc\xf9\x07\x69\xfd\x56\x50\x2f\xd3\x11\x1b\x94\xb9\x33\xca\x76\x43\x7c\x6d\x5d\x3a\x53\xe3\x83\x3d\x07\xa0\x84\x40\xb1\x77\xa9\x83\x3c\xbb\x6d\x15\x9f\x05\xa3\x5e\x91\x04\x6f\xd5\x5b\xfd\x04\x4d\xfc\x38\x70\xdf\x5d\x3f\xed\xcd\xe0\x15\x2d\xfd\xff\xa4\xd1\x7b\xb9\x2f\x92\x48\xb6\x94\xff\x7d\xaf\x2d\x26\x8c\x8c\xf9\xdf\x37\x63\x2e\xff\x6d\x53\xe6\x61\xc6\x7c\xec\xd7\x58\x79\x1a\xb2\xcf\x10\x9a\xbb\x5f\x03\x38\x34\x56\xfc\x5f\xd6\x2a\xdc\xe5\x84\xbf\x1c\x65\x90\x4c\x77\x93\xa1\xa5\xa7\xe3\xd7\x2f\xf5\xe0\xaf\x1f\x5f\x1e\xf0\xe4\x28\xd7\x9e\xe0\xf6\x7f\x7d\x29\xd2\x52\xf7\xdd\xe8\x40\x36\xbf\x27\x84\x04\xa6\xc8\x67\x4a\x20\x9e\xf2\x4b\x21\xa4\x31\xde\x15\x42\xc2\xd6\xda\x99\x91\x83\xb6\x2f\x3a\x9f\x9a\xb0\x3e\x43\x91\x46\xbf\x6c\xe6\x3f\x12\x31\x60\xd6\x81\x25\xa8\x51\x3b\xd8\xa9\x93\x5f\x3b\xb5\xce\x66\xd9\x48\xca\xc2\x32\x2e\x19\x02\xa1\x66\x9c\x0e\x86\xae\x3e\xae\x88\x38\xf5\x76\xa5\xda\x33\xdb\xc1\xc5\xee\x01\x61\x88\xf4\x43\x63\xc9\x26\xfd\x16\x4b\x44\xa0\x8d\x54\x58\x0a\x26\xf1\xdc\x5f\xa2\x26\xa1\x80\x2b\x49\x36\xc0\xbb\x64\x24\x08\xaa\x15\x83\x20\xc8\xa6\x25\x69\xea\x0d\x5a\x14\x59\x92\xa8\x6c\x6d\xa4\xd1\x13\x7f\xcb\x1b\x2b\x8e\x4d\x52\x19\x54\xab\x28\x50\x4e\x83\xe8\x2e\xe8\x50\x51\xf4\x81\xb0\x67\x93\x1d\x99\x8c\xaa\xbb\x15\x08\x84\x47\x6d\x84\x8f\x82\xe2\x8f\xc3\x38\x2f\x14\xa9\x1b\xde\xde\x5e\x72\xb0\x6e\x6a\x61\x4d\x0a\x20\x0b\x3b\xa5\xa6\x98\xe1\xc1\x3c\x05\x99\x31\xc1\x0b\xac\xa3\x05\x6d\x00\x75\x0f\x1a\xe0\x6c\x2d\x78\x01\xc6\x1e\x90\xa7\x1d\xee\x59\xb9\x6a\xef\x5b\x1f\x98\x6e\x78\x1f\x7b\xc5\x54\xfc\x74\x02\x3c\x11\xb2\xb5\x8f\x98\x68\x7d\x02\x04\x70\xf4\x79\x50\xbe\x99\x03\xe7\x14\xc0\x0c\x38\x26\xc0\x7d\xfc\xbf\x19\xfe\xcb\x31\xfe\x97\xfb\x04\x28\x65\xdc\x07\xf3\x2f\xea\x82\xde\x0e\xfe\x37\x55\xc7\xf7\x29\xf3\xb6\xea\xf8\x71\x0a\x3c\x56\x1d\x97\x9a\xea\x84\xee\xe9\xd2\x24\x1d\x13\x60\x11\x1f\xaa\x29\xc4\xf9\xc4\x28\x55\x42\x12\xf8\x7e\x5d\xbc\xb3\x19\x41\x45\xe7\xef\xf1\x2a\xf8\x66\xb6\xa8\x0d\x05\xaa\xb7\xe3\xa9\xb0\xf8\xf9\xb7\xfd\xa0\x6c\x2a\xf0\xc8\xfd\xbd\xa3\xaa\x05\x95\x35\x1c\x14\x4b\x8c\x91\xe5\x1c\x34\x4b\x8c\xa2\xe5\x3e\xb0\xde\x4c\x7d\x70\x91\x29\x65\xb4\xc1\xf2\x1e\xc3\x73\x89\xf1\xba\x2d\x13\x44\xc8\xe7\x68\x0e\x14\x16\x59\x86\x30\xe8\xb7\xc5\x8c\x91\xfd\x98\x10\x3e\x7d\x81\xb2\xe0\x74\xb9\xec\x0b\xa6\x0f\x48\x95\x15\x4b\x01\xd1\x78\x31\xd3\x8e\xa9\xc7\x65\xa7\x7c\x89\x85\xe7\x4b\x05\xee\x39\xc5\xbc\xed\x9d\xf9\xb6\x63\x62\xef\xe7\x6c\x3f\x16\x80\xab\xf4\x6b\x6f\x57\x6b\x9b\x00\x71\x9d\x62\xd1\xd8\xea\x40\x8d\xd1\xb1\xa8\xd8\x44\x17\xc7\x92\x23\x44\x85\xc4\x82\x54\x00\xe0\x4a\xc7\x6a\x95\x89\x09\xe5\x5a\xf6\xe1\x6c\xf8\x5f\x3f\xfd\x75\xff\xeb\xf7\xef\x97\x47\xb5\xb3\x24\x7e\x8a\x5b\x02\x76\x93\xea\x6d\x57\x96\xf4\xd6\x7c\x48\x9f\xa3\x13\x1b\x35\xec\x82\x24\x99\x7f\xda\x34\xb0\x18\x65\xbe\xbe\x08\xca\x4b\x6a\xbd\xb6\x76\x33\x5f\x7e\xab\xe0\xd4\x2a\x3b\x5a\xa8\x72\x5b\xac\xbc\xbe\x54\xd3\xd4\x54\x6e\x4b\xcf\xd7\xc5\x9d\xac\xa2\x76\x5d\x7a\xb9\xf1\xe7\xb8\xf5\x7c\x55\x53\xb7\x82\x2c\x95\x59\x81\xed\xbc\x2e\x6e\x56\x64\xa0\xd9\x30\x3f\xb0\x78\x57\xbc\x63\x56\x36\xe9\x40\x06\x0c\x30\xb2\x5a\x6e\x3a\xb3\xdf\xc8\xa2\x3d\xc7\xe0\x44\xb8\x07\xb9\xef\x4a\x65\x8b\x7a\xd9\xd4\x4d\xaf\xa2\xc9\xe4\xa6\x23\x5f\x5b\x7f\x7d\x99\x03\x52\x24\x37\x80\xc9\x82\x4b\xbe\x43\x60\x9d\x22\xef\x0a\x69\x8c\xa5\x28\xb0\xf1\x4c\x0e\x14\x7f\xb4\xc6\x7b\x9c\x76\xa5\xe2\x98\x6c\x86\x7a\x2b\xff\x3e\x6f\x90\x3a\x8a\x13\x3b\x82\x4f\xde\x28\x78\x56\xac\x25\xad\xf5\xb6\x60\xb9\x04\xb2\xca\x07\xe3\x46\x78\x37\xdf\x32\x14\x29\xa2\x06\x6d\x64\xfe\x1e\xe6\xa5\x24\x1b\x94\xb3\x65\xb3\xa3\xdd\x04\xd0\x83\x0a\x3e\xba\x81\x97\x64\x23\x0d\x70\xde\xfb\x02\x60\xe3\x42\x85\xd6\x09\xb4\xe2\x68\x37\x6e\x5d\x06\x5b\x6b\x23\x5f\x17\x4a\x0f\x25\x72\xc2\x3e\x0b\xce\x1c\x7d\xa7\x3d\xd7\xbe\xd4\x9b\x0f\xf5\x2b\x0c\xd6\x51\x93\xe4\x3e\x6f\x8b\x30\xa3\x82\x77\xaf\x2c\x87\x33\x4d\x55\x6e\xfc\xa2\x42\xf4\xde\xf7\x19\x8d\xfa\x00\xf3\x4d\xaa\xa1\xf9\x1e\xa5\x03\x80\xe7\xe7\x04\x55\x1d\x4b\x1d\xd8\xce\xde\x90\x53\xdb\x40\x4f\x81\x2e\x11\xb7\xd8\xbc\x5b\xf0\x16\x0a\xc2\x78\xd4\x6c\x5e\x02\x2a\x77\x24\x61\xa9\xf9\xe0\xed\x5c\xb0\xae\x40\x30\x0c\x2a\x6e\x51\x2f\xd0\x5b\x3a\x7e\x15\x0a\x33\x1d\xa7\x04\x28\xcf\xea\x06\x4c\xad\xd4\x54\xc8\x94\xb6\xc7\xf5\x8b\xa5\x8a\x7a\xbb\x64\x75\xc7\x59\xdd\x7c\x58\x41\x42\xd7\x1f\xe5\xf5\xa5\x36\xf3\x4d\xb9\xaf\xd3\xe7\x8a\x1b\x0a\x75\x45\x07\xc9\xf4\x0f\x96\x64\x56\x1f\xf8\x18\x17\x06\x33\xbb\xcd\xd5\x97\xcc\x46\x09\x61\x9f\x58\x05\x89\xd4\x71\x5b\x34\xcb\xb5\x97\x9b\x66\x79\x7d\x19\x55\xd3\xb4\x76\x13\x60\x83\x2a\x83\x9a\xa3\x6f\x0b\x5f\xb9\x2f\xf7\xfe\xb2\x43\xa0\x8d\xef\x3e\x4c\xd4\xc9\x00\xe8\xf0\xa1\x4a\x64\x51\x1d\x1c\x0e\x9d\x15\xf6\x23\xc5\xf1\xc5\xe7\x38\x5a\xda\x38\xca\x70\x0d\xa8\x16\x5b\x1a\xd2\x7c\xb8\x9b\xcf\x65\x1f\xf6\x3a\x0c\x12\x5c\x70\x77\x0a\x7e\x1e\xea\xad\xd2\x60\x6e\x93\xf6\x3f\x69\xbb\x41\x18\x0f\x27\x4d\x0b\x9a\x17\xd8\x6b\x80\xec\x6b\xc7\x6a\xa7\x7d\x33\xdf\x15\x7a\x77\x43\x70\x29\xf9\x37\xd7\x28\x5e\xfe\x01\xea\x3d\x62\x15\x7e\x5a\x80\xef\x5c\xe2\x5d\x92\x4e\xbd\x2d\x4a\x64\x29\x84\xda\x27\xa4\x71\x17\xb5\xd8\x15\x55\x6f\x96\x65\x53\x05\x37\x82\xff\xbe\x41\x0d\x9a\x07\xfa\x54\xca\x33\xe9\x94\xdb\x52\xda\x75\x99\xf9\x46\x91\x3f\xb0\xc6\x34\x90\xc6\x90\x84\xcb\x87\x6c\x9e\x57\xc9\xfd\x36\xcb\x75\x01\x1f\xd7\x2c\x57\xc9\xf5\xb6\xd4\xe6\x5f\xe4\x5b\x6d\xf3\xf5\xa5\xa1\x0a\x36\x5f\xc7\xbc\x15\x3f\x72\xcc\x1b\x88\x97\x10\x6c\xc7\x42\xd8\xb9\x10\x12\xb1\x00\x49\x6d\x7f\xc1\x20\xbb\xb7\x7a\xb3\x76\x9c\x34\xf1\x54\x65\x26\xd4\x50\x5e\x50\x10\x40\xb2\x83\xc5\x50\x81\xe0\x0e\x90\xa6\x26\xb7\xa5\x42\x10\xbb\xe5\x34\xc6\x4d\xa6\xef\x47\xdd\xfd\xce\x34\x59\x6f\xe6\x4e\x67\x17\xb0\x4b\xc1\x6f\x06\x85\xa7\xaf\xf7\xd2\x79\xad\xd6\x0c\x37\x3c\x36\x7f\xe0\x5a\x13\x0e\xa8\x5b\xf5\x95\xcc\xcf\xac\x1b\xaa\x93\x66\x92\xec\xa3\xc9\xe6\x48\x73\xdc\xc4\xae\x0b\xef\xb2\x52\x10\xcc\x6d\x8c\x4e\x15\xc3\x02\xe8\xcc\xb6\x14\xda\x27\x2d\xb5\x79\x1b\xfd\x2a\x7d\x06\x18\xb2\xb3\x6a\x51\x7c\x7c\xdb\xc4\xc6\xe7\xbe\x5e\x75\x4f\x61\xd0\xd7\x84\xf2\xd1\x85\x3a\xdd\x46\x80\xc9\x22\xbe\xa9\x4a\xc7\xe0\xef\x93\x98\x46\x69\x30\x04\xaa\x24\x68\x11\x57\xd9\x3a\xaa\x59\xf2\x48\xd5\xc0\x8b\x81\x09\x58\xcb\xa6\xee\xbe\xa7\xea\xab\xef\xf4\x03\x44\x6e\x2a\x3e\x8a\xdb\xc4\x12\xd6\xe6\x0e\xf7\xa6\x4d\x1f\x56\x39\xd8\x4f\xfd\x2f\x3d\xbb\x17\xc1\x44\x4c\xe6\x7a\x8b\x00\x42\x09\x77\xbc\x32\xf2\x88\xfa\x74\x7f\x45\x13\xc4\x63\xd0\x4d\xde\x42\x73\x52\xbc\x4f\x81\x8b\xd9\xf1\xc1\x5f\x7c\x1d\x89\x9a\x86\x6e\x87\x1d\x48\x8f\x39\x2f\xf4\x6d\x84\x7a\xfd\x86\xc2\x0b\xbf\x56\xfc\x22\xc5\x77\xaa\x3a\xd2\x9c\x28\x34\x2d\x7d\x13\x08\x8c\xa7\x5a\x7d\x0d\xdd\x79\x9d\x0c\x73\xc9\xbd\x1b\xac\xcc\xc5\x9d\x01\x44\x52\xe6\x06\x5b\x9a\xb8\x27\xbf\xf7\xd7\x97\x2a\x6e\x9e\x59\xbb\x4a\xd6\x95\x42\x40\xa8\x11\xd1\x2e\xd7\xc5\x47\xb7\x76\xc1\x13\x76\x40\xc3\x92\x02\x7f\xdc\xa9\x94\x05\x61\xca\x7e\x95\xdc\xd6\x0e\x93\xc1\x88\x14\x11\x68\x8f\x44\x51\x01\xe0\x6c\x78\x83\x94\x6a\x5c\x8e\x57\xbe\xe0\x9d\x1f\xf5\x39\xe9\x78\xe5\x46\x65\x76\x91\x71\x63\x0b\x60\xb3\x49\x6e\xda\xd9\x48\x78\xd9\x7e\xf0\xd6\x38\x13\xd8\x4e\x0c\x15\x5e\xa7\x1f\xe9\x05\x6b\xbe\x0e\xce\xe9\xc3\xf5\x56\xeb\x06\x6b\x84\x1c\xd0\xf8\x70\x0c\xd3\x3a\x41\xae\x32\x50\x70\x30\x52\xaf\x37\x9b\xe5\x3a\xe5\x2c\x95\x31\x03\x06\xb0\x6e\xb4\x33\xb0\x2b\xe8\x06\x77\xa7\xfa\xe2\x7b\xb3\x21\xd7\xf9\x71\xea\xeb\xbf\x7e\xfc\xf3\xbf\x3e\xad\x6a\xcf\xc8\xd2\x07\xe5\x99\xd9\xd3\x68\x07\x1b\x9c\xf7\x0a\xd6\x10\xc8\x11\x77\x8a\x1c\x36\x88\x1d\x5e\x17\xb5\x79\x10\xcc\x98\x24\xe9\x7b\x4e\xd6\x56\xad\xc6\x2a\xd2\x04\xb5\xc0\xd5\x0d\xad\xa4\x9d\x61\x30\x98\x4b\xfe\xd8\xd3\x4d\x04\xf3\x0d\xfa\xea\xcd\x90\x20\xb0\x45\x80\xa0\x64\x4b\x52\x45\x58\x61\x8f\xce\xb2\xbe\x2e\xd5\x3b\x7a\x9a\x5b\x7e\x94\xea\x6f\x12\x5b\x51\x46\x47\xf5\xb8\xe9\x7a\x18\xdf\x71\x8b\xe4\x72\x68\x8d\x1c\x02\x36\x53\x53\xf0\x75\xb9\x9d\x63\x92\x66\xd1\xcb\xa6\x15\x8b\x70\x49\xa5\x5e\xb5\x48\x90\x28\xc3\x62\xf9\xb4\x7f\xdf\xb7\xdd\xe7\x23\x5f\x4b\x27\x54\x17\x28\xdb\xa4\xca\x30\x14\x2c\x38\x4d\x56\xae\x3e\x67\xcf\x45\x1a\x93\x65\x63\x14\x0e\x36\xf1\x24\x53\x17\xd4\xee\x84\x5c\xe3\x8b\xf9\x4c\x27\x14\x1a\xd0\x98\x8d\xd1\x3a\x54\x94\xd9\x55\x46\xdd\x0c\xf6\xac\xbf\x92\xd8\x78\x44\xdb\xf0\x66\x31\xcf\x4b\x12\xf5\xcb\x76\xec\x15\x5c\xfa\xc1\x11\x0d\x33\xad\xeb\xdc\xb0\xc8\xaa\x8f\xdb\x32\x64\x53\xd2\x32\x43\xb7\xa9\x5e\x85\x0c\x40\x0c\x7b\xe8\x36\x50\xf9\x2b\x09\xc5\xfb\x2d\xa7\xd2\xdb\x4d\x2e\x6b\xc9\x33\x75\xb5\x2d\x90\xe2\x80\xd9\xfc\xd3\xd1\x17\x1c\xfe\xd9\x5f\xd6\xaf\x4f\x28\xfe\xf6\x0c\x60\x7c\xc8\x1a\x8b\xa4\x92\xc7\x5a\xdc\xd0\xac\x79\x5d\xf8\xc1\x6e\x4b\xcd\x76\x08\x18\xf6\xbc\x09\x96\x14\xa3\x28\x33\xea\xf5\x58\xaa\x32\xbf\xd4\xd5\x37\xd6\x82\x99\x84\x52\x1a\xe2\x97\x17\xdb\xf5\xac\x04\x65\x15\x20\x59\x35\xc5\x76\x8c\xd8\x89\xea\xbf\x43\x53\x13\x55\x3b\x67\xf0\x0f\x5f\x20\x32\x70\x28\xb1\x89\x0f\x1d\xc8\xe3\x9f\xa5\x59\x3b\x0f\x17\x50\x53\x00\xfe\x6d\xf4\xcb\x18\x35\xf1\x21\x99\x31\x40\x6b\x88\xf0\x4f\x92\x1d\x28\xa3\xaa\x97\x95\x95\x9a\x3d\xa4\x86\x6b\x58\xb3\x2d\x3c\x7f\x84\x4e\xa8\x7a\x86\xf7\x1d\x8f\xc0\x18\x04\x2b\x57\x51\xdb\x1a\xf4\xd3\x54\x55\x12\x06\x7e\x1a\xab\x97\xdd\x4b\xe8\x09\x83\x11\x82\xc7\x1c\x37\x70\x7e\x50\x15\x3a\x53\x59\xdd\x32\x28\x9b\xff\x1b\x42\xba\x49\x32\xc8\x89\xf5\xa8\xa7\x2a\xbe\x15\x60\x4b\xbc\xe3\x1c\xdd\xaf\xe6\x07\x8a\xc8\x89\xaf\xd0\x24\xea\x04\x31\x36\xcb\x91\x00\x0f\xf4\xee\x29\xf9\x26\x86\x84\x71\x12\x84\x54\x93\xf7\x4d\x4f\xbe\xe3\xfa\xde\xfa\xa5\xba\x23\xe5\xbd\xb2\x42\x16\xc8\x77\x53\xa9\x6e\x49\x28\xe9\xb6\x19\x4d\xf4\xad\xc6\xf8\x32\x07\xdf\x6e\xe1\xcb\xb6\x5d\x7a\xf2\x2e\xf0\x1e\x90\x91\x1a\x82\x5a\x1f\x8e\xd8\x7f\xf9\xf9\xa7\xbf\x7c\xff\xd3\x7f\x3d\x0d\xd6\x67\xcd\x83\xfb\x60\x2d\x59\xd3\xd0\xb9\x96\x59\xd2\x62\x19\x40\x5f\x5f\x26\x06\x3a\xd3\x57\xc2\x09\xc8\xb7\x5b\x37\x80\x02\x0d\xfe\xdd\x3d\x03\x2e\x4a\x58\xe9\xd3\x22\x37\xf1\x91\xee\xb6\x92\xdd\xfc\x30\x29\x3d\x2d\xb3\xad\x86\x08\x40\xb9\xe9\xea\x47\xad\x02\x54\xed\x6a\x70\x21\x46\x79\x7d\x71\x5b\x42\x8a\x8c\xf5\xf1\xc2\xb8\x19\x7f\x93\xe6\x17\xa6\x31\x98\x71\xa3\x86\x0d\xbb\xc7\xc5\x16\x83\x14\x46\xb1\xa4\x03\xd4\x12\x36\xd9\xd8\xc3\x97\x3c\x21\xb3\x59\xcb\x1f\xe3\x1a\xff\x63\xff\xfa\xa7\x7f\xfb\xe1\xbf\xfe\x74\xfd\xfa\xe7\x7f\x7d\xf6\x0a\x1e\xb9\x84\xa6\x3f\x1d\xd0\xbb\x60\x14\xba\x2e\xd2\x32\x02\x82\x57\x29\x36\x82\x51\xcd\xff\x54\x46\x76\xd3\xbe\x83\x3b\xca\xb7\xf6\xda\xd7\x0e\x91\xc4\x46\x80\xb9\x7b\xe6\xaf\x2f\xa5\xba\xed\xa1\x6b\xeb\x49\x4a\x5b\xbb\xa2\x54\x6d\xae\xf0\x38\xc4\xb7\xc7\xe6\x23\x41\xea\xa0\x7e\x8b\x1a\x88\xc0\x96\x0a\x28\x7d\x66\x39\xa9\x1b\xe8\x65\xc0\xc4\x5a\x8b\x3b\xed\xad\x48\xc8\x49\xcc\xb6\x2e\xfe\xa7\x56\xe4\xf5\xc5\x2c\xa7\x56\x6f\x52\x27\xe1\x91\xfe\x61\x19\xf9\x63\x60\xd6\x8f\x7f\xfe\x8f\xfd\xeb\xbf\xfe\xfc\xf5\xdf\x9f\xfa\xe5\x5f\xde\x61\x60\xff\x55\xd4\xef\x07\xd5\xfa\x49\xbd\x1e\x07\xf2\xbc\xd7\x17\x91\xa6\x27\xa3\x3b\x26\xa3\x90\xfb\x04\x4c\x2a\x94\x98\xc6\x27\x7c\xf0\x2f\xfd\xbb\xe3\xe7\xf1\xc5\x79\xe8\x71\x36\x4a\x21\x90\xd9\xc9\x47\x20\xdc\x97\x97\x06\xe4\x33\xe9\x4d\x1a\xb2\x7e\xfe\xe7\xe6\x0d\xf8\xbf\xfc\x53\x1c\xc0\xe3\x5f\xc9\xf3\xaa\x3d\x5f\x7c\x5d\x8c\x98\x2b\xe1\xe1\x92\x2b\xf0\xc5\xcb\x3c\x6a\xf6\x59\x43\x9c\xf7\x25\x48\xe0\x07\x24\xda\x43\xb7\x7e\xb8\xad\x4a\x04\xf3\x82\x22\x2d\x39\x6a\xf2\xbe\x9c\x32\xe5\x24\xe9\x35\x88\xde\x83\x8f\x98\xc6\x6c\x54\x87\x84\xa0\xff\xfd\xe3\xf9\xed\x71\xf8\x71\xfe\xbd\x4d\xec\xef\x95\x11\x8a\x31\x76\xde\xc4\x46\x7f\x27\xdd\x6f\x73\x3f\x6e\xfd\x78\x96\xe3\xe1\x8e\xc7\xbd\xf0\x13\x20\x60\xc7\x77\x38\xd6\x70\xaa\xe4\x9d\x5c\xf7\xfe\xc8\x15\xf1\xe3\x31\x52\x1d\x7b\x1d\x69\x0c\xb7\xe5\xc0\x54\x78\xc8\xa6\x43\x47\xd5\x76\x4b\xf1\x90\x7c\x0a\x3c\x19\x1f\xec\xfc\x70\x7c\x15\x87\x2e\x71\xe6\x72\xb6\x85\xb0\x52\x65\x10\x65\x8c\x7d\xc1\x65\x11\x86\x81\xbd\x23\xe7\xfa\x1f\xb7\xb9\xc4\x5d\xdf\x5f\xdf\xf9\x60\xbf\x20\x00\xc2\x86\xea\x8b\x4c\xbf\xd0\xfe\xd4\x8c\xad\xcd\xd7\x2e\x55\xdf\x15\x95\x8a\xe8\x7c\xb5\x38\x92\x74\x0e\xee\x2c\x6f\x38\x5c\x10\x2f\xf6\xd9\x5c\x76\x9c\x6a\x6e\x22\xd6\xc4\x33\x4c\xfa\x8e\x7f\x51\x35\xe7\x87\xf3\x88\x3d\x4e\xd9\xfc\x61\x12\x9a\xdb\xd9\xf8\xc6\x7b\x70\xb3\x82\x17\xdf\x8f\xfb\xd9\x2a\x86\x18\x6f\xe3\x63\x68\xf7\xfa\xe3\x9f\xfe\xed\x19\x19\xf2\xc3\x7d\xed\x2b\x41\x6d\xfc\xa1\x71\xf5\xbf\xd7\xd0\x7b\x7d\x69\xf3\xa0\x4f\xf1\xce\x0b\x05\x04\x10\x3b\xa0\x3e\xae\x22\x31\xbd\x2f\x87\x24\xc2\x1b\x69\x84\xd0\x4e\x68\xba\xf3\x3c\x5f\x1f\xce\x85\xe7\xde\xdc\xe5\x6f\x6e\xef\x43\xbd\x9b\x67\x79\xbf\x9e\x1f\x69\xa4\xa7\x94\x55\xb3\x3b\x3a\xb9\x5d\x97\x92\xd5\xd7\x45\xb3\x64\xa3\x5c\x67\x59\x97\x52\x67\x6a\x53\xf8\x61\x69\x53\xfc\xaf\x92\x4b\x92\x96\xaf\x55\xf5\x77\x16\x71\xfa\xdf\xc8\x5b\xf5\x3f\xa5\xcb\x53\xdf\x7c\xa4\x96\x30\xa4\xa6\xd6\x3b\x2c\x5b\xa3\x4a\x3f\x4c\xdd\x7d\x09\x76\x72\x86\x81\x30\x57\x2c\x2a\xe7\x33\x54\x61\x76\x50\x62\x6f\xee\xa5\x8c\xd4\x59\xa6\xbc\xfb\x8e\x63\x7c\x3a\x9c\xdc\x51\x42\xa3\x2d\xb5\x49\x90\x19\xa2\x47\x22\x96\x04\x2c\x22\xb3\x27\xb1\x0d\x97\x86\x99\x0b\xc3\x74\x19\xcc\x7c\x11\x6c\xe0\x36\xfe\x56\xa0\xc2\xd3\x99\xee\xab\x75\x97\x56\x23\xeb\x3a\x25\xf9\xf6\xad\x69\x94\xbd\xe6\x24\x10\x4c\x90\xe6\x77\x83\x4c\x03\xab\x61\x6b\x0b\xc6\x83\x3a\x92\xea\xc5\x37\x14\x98\xf1\x1b\x48\x26\x21\x59\xd5\x40\xef\x81\x30\x53\x27\x65\x90\xe8\x4e\xbb\xdd\x7f\x22\x96\xbe\x19\xab\x2b\x98\xb1\xf9\x52\xf7\x4e\x65\x7d\xdd\x47\xc8\x35\xfa\x06\xa1\x2c\x0e\x07\x8d\x90\x6c\xcd\xd2\x48\x94\xcf\x51\x4a\xbf\x02\xe5\xd1\x6b\x2a\x8d\xd2\x25\xaa\x49\x33\x55\x66\xf5\x30\xb1\x63\x6b\x82\x1c\x67\x39\x2c\xff\x9e\xb9\xdb\x55\x90\xe9\x0f\xbf\x09\x94\x7c\xcd\xfb\x86\xa7\x59\x79\xc3\x9a\xcf\xed\x03\x7a\xfe\x69\x19\xfc\xc3\x25\x16\x68\xdf\xac\xbb\x31\x11\xef\xce\x75\x0b\xf7\x21\xb9\xd3\x5c\x7b\xd2\xa9\x2b\xf4\x3a\x65\xa4\xb9\x29\x0b\xe6\x47\xaa\x99\xbe\x46\x19\x7b\xcd\x20\x8b\x28\x08\xa6\x2f\x0d\x2e\xb5\xda\x99\x30\x45\xc8\xe7\x88\x51\x48\x23\x11\x35\x4b\x11\x21\x8a\xdb\x10\xf1\x21\xdc\x99\xef\x28\x68\x1a\x96\xe2\xcf\x49\x48\x91\xf8\x2d\x29\xa3\x01\x4b\x93\xcc\xad\xde\x17\x54\x44\xf6\x67\x49\x02\xda\xc9\x1a\xda\xae\x27\x1f\x04\x18\xd5\xf6\x65\x26\x2b\xfb\xd2\x90\xcf\xbc\xd0\x1d\xb1\xba\x2d\x93\x99\x41\x38\x2e\x48\xea\xba\xe7\xcd\x0e\x84\xe6\x75\xe9\xac\x48\x4e\xe2\x43\x1c\x69\xd1\x33\x25\x1b\xba\xb7\x4c\xa2\x5a\xde\x01\xfb\x63\x25\x17\xba\x5b\xd4\x5f\x6d\x32\xb1\xd4\xca\x66\x7d\x26\xeb\xa9\xf9\x90\xa9\x79\x23\xf7\x42\x4b\xa8\xf6\x16\x55\x24\x21\x35\x27\x7a\x70\x55\x78\x8b\x4b\xfd\xd8\xe8\xfe\xfe\xc7\xfd\xfb\xbf\xfe\xe9\xdf\x7e\x78\x9f\x80\xb5\x9f\x98\xc4\x51\x46\x6a\x48\x48\xf9\xb0\x2e\x92\x5a\xdb\x97\xde\xc1\x04\x44\xe2\x86\x23\xa1\x84\x07\x30\x0e\xb2\x2f\x20\xd2\x74\xdf\x72\x48\x2a\xbb\xb5\xd4\xd5\x67\xf1\x48\x6d\x28\x56\x8a\xc6\x60\xb2\x28\xd6\x09\x5f\xbf\xf1\x61\x26\xbc\xb9\x06\xe0\xd1\x42\xd2\x63\x7f\x9c\x69\x1c\xf8\xad\x6c\x1d\xb1\x22\x29\xa1\xf0\xb0\x8f\xe0\x8f\xc4\xac\x85\xae\x54\x37\x26\xb6\x10\x97\x25\x5f\x46\xd9\x11\x19\x94\xb6\x2f\x64\xd0\xf0\xb5\x84\xa1\x54\xdf\xaa\x4b\xca\xc8\x95\x35\xac\x61\xf1\xa2\xb1\x20\xb5\x18\x47\x60\x0f\xf1\x45\x67\x26\xf3\x37\xb3\x97\x4c\x40\x4b\x41\x9d\xdd\x26\x13\xdc\x6e\xa0\xc9\xde\x90\xe0\x45\xe0\x7b\x10\xa3\xe2\x17\x46\x46\x9b\x52\x43\x52\x34\x19\x6a\xed\x7a\x3a\xc7\x9b\x81\x73\x83\xec\x29\x94\xba\x68\x47\x18\xd5\x1a\x1e\xb5\xed\x8b\xb5\xe6\x56\xfe\x4a\xbd\x76\x32\x5c\x29\x63\xbe\xb5\xa4\xe2\xf6\xab\x64\x90\x28\x0c\x49\x14\xff\xc9\x63\x83\x12\x70\x69\xee\x0d\xa5\x6a\x9b\x15\x24\xf1\x67\xaa\x72\x50\x0e\x70\x67\x41\xc2\x4e\x5e\x2f\x6e\xaa\x83\xd3\x38\x6f\x13\x69\xda\x91\x7a\xc5\x0b\xaf\x5c\x3d\xa9\x62\x2b\x8d\x48\xbf\xd1\x93\xb5\x6d\x11\x3b\xc4\xda\xfc\x7e\x4a\x63\x2c\x18\xe0\x21\x6e\x43\x95\x14\xe4\x60\xca\x98\x1c\xa3\x1b\xc9\x70\x41\xd9\x6a\x03\x01\x13\xe9\xb2\x33\xb4\xd6\x37\x90\x1b\x62\x12\xef\xc8\x3e\x00\x57\xe3\x9e\x00\xdc\xd6\x4d\x72\x45\x06\x58\x47\xa1\xd6\x9a\xfa\x6e\xac\x23\x95\x92\x53\xb3\x4d\xc9\xf2\x4b\xb6\x05\xf7\xff\x75\x12\xda\x53\xf2\x56\x20\xb0\x97\x46\x4e\xa5\xdb\x3f\x25\x3f\xe1\xfe\xd7\x7f\xff\x7e\x7d\x32\x1a\xfb\x87\xd4\x69\xa5\x24\xcd\x7d\x1d\xc8\x70\x30\x9d\x46\x05\x38\x2c\xa7\xcd\xc7\x1f\x08\xc5\xdd\xba\x0e\xde\x34\x48\x18\xa8\x7f\xc5\x84\x6e\xd9\x97\xe9\x96\x86\xcf\x0c\xd8\x1c\x9a\x23\x7c\xe4\x6e\x39\x94\x16\xa5\x8d\x9b\x4a\xdd\x7a\x94\x5f\xbb\xad\xf4\xa5\xee\x53\xd2\xcc\xee\x7e\x48\x06\xb4\x6a\x82\xbc\x66\x60\xfa\x24\x44\x61\x50\xb2\x1a\x8c\x62\x57\x2d\xe5\xb6\x14\x2d\x57\x33\x8b\xaa\x60\xb3\x72\x5b\xaa\x80\x05\xc1\xdd\x69\xee\xe0\x41\x5f\x58\xb1\x02\xdd\xa9\x67\x62\x61\x28\x97\xad\x8f\x04\x89\xf7\xa4\x9f\xa8\x63\xa0\x47\xdf\x5f\x11\xcb\x9d\xf0\xd1\x97\xb3\x0a\x90\xa6\x0c\xf2\xce\x12\x9a\x90\x91\x3b\xd8\xb8\xb0\xd1\x80\xa5\x60\x03\x08\x75\xe4\x0e\xcb\x61\x29\x33\x71\x35\x36\xc7\x55\x6b\xbf\xc9\x2c\xd4\x7c\x37\x6d\xd7\x45\x06\x58\x3f\x88\x6c\x95\x8c\x5d\x0e\x5c\x33\x30\x12\x46\x07\x5d\xcf\x32\x2b\xd6\x62\xfc\x14\x09\x8e\xb2\xdb\x22\xad\x5e\xc5\xf2\x6d\x29\xec\x29\xdf\x8a\x63\x91\x84\x47\x0d\x09\x79\x24\x82\x38\xed\x03\x1d\xe0\xab\x76\x9b\x49\x52\x88\x81\xd5\x1d\x96\x64\xcd\xbe\x20\xfc\xd3\xc5\x92\xd7\x9f\xfe\xfc\xaf\xdf\x7d\xfd\xf9\xe7\x9f\xfe\xf3\x5d\xd2\xfb\xfe\x04\x82\xeb\x6d\x9c\x0e\x00\x48\xdf\x0f\x41\xc7\xca\x60\xbd\xd5\x93\xc7\xfe\xd4\xed\xe1\xbb\x89\xbc\x80\x9b\xa6\x7e\x58\x25\x9b\x3d\x2c\x54\xb8\x94\xf5\x81\x91\x9e\x1c\x1a\x5a\xc6\xaf\xc4\x1c\x6b\x19\x7e\xca\x86\xd4\x0f\x96\xc7\x8f\x87\xf0\xc3\x63\x3f\x4b\x1f\xf4\x27\xda\xa3\xb7\x0f\x2d\xb9\x50\x0f\x13\xc4\xb3\x33\x70\xa8\x5a\x78\x1f\xdf\x60\x2a\x98\xef\x96\x3a\xf9\x7d\x93\x26\xe4\xae\x8a\x30\xdd\xb3\xae\xab\x77\xe4\xa1\xe8\x7e\x6a\x13\x1d\x22\xed\x92\x57\xef\x41\x74\x34\x12\x1d\x88\x28\x7f\x82\x72\x7c\x78\xe8\xf7\x54\xca\xfb\x33\x01\xd0\xa3\x72\xfb\xc1\x9c\xf1\xcd\xca\x10\x7f\x18\xe2\xbd\xc2\xa8\x60\xf7\x40\x6f\xb3\x52\x1d\x9f\x59\x62\x3c\xd0\x82\x87\xe2\xeb\x05\xf3\xce\xca\x03\x80\x16\x13\xff\x94\x1a\x18\x7a\x28\x02\xa0\x13\x4d\x5f\xd1\xc3\xbf\xa9\xaa\xe4\xe1\xa9\xdf\x95\x04\xef\xcf\xa9\xc7\xc7\xc7\x76\x63\xac\x9c\x3c\x3b\x27\xac\x7e\xc0\xff\x2a\xe0\xa3\x22\x5d\x18\x5d\x38\x01\x01\x15\x86\xf1\x4d\x41\xfc\xa1\xbf\xb6\xea\x07\xfd\xc7\xee\x53\xe1\x4c\xd8\x81\x61\x5d\xe3\x6a\x04\x1a\x45\xf7\x7d\xf2\xd4\x5f\xff\xf2\x97\xe7\x72\xff\xfe\x4c\xfe\xf2\xa0\xc6\x62\xd3\x6d\x2b\x21\x5c\x2e\x84\x78\x7c\xa9\xc6\x3b\xe3\x30\x6f\x91\x7b\x95\xd9\x80\x8c\x44\xaf\x80\x70\xc9\x9d\x24\x66\x38\x05\xbf\x06\x0c\x11\x68\x1e\xdb\x90\xfb\x06\x4f\x87\x1f\x03\x72\x7a\x22\xd1\x2c\x4b\x52\x50\xa3\x94\x9e\x14\x96\x5c\xe9\xa9\x02\x20\xa1\x48\x76\x5b\xb2\x5e\xc0\x7a\x27\xbe\x2b\x8f\xe2\x3f\x03\xdf\x80\x4d\xd8\x7b\x05\x41\x79\xd0\xca\xf9\xef\xa5\x82\x05\xcf\x92\x15\xf0\x7a\xba\x21\xd7\xf9\x1b\xd7\x49\x41\xca\xfe\xb2\x21\x75\xe8\x96\x62\xd8\x45\x4b\x9f\x84\xd1\x80\x8c\x1d\x79\xfa\x06\x24\x3d\x13\xcc\x9a\x49\x17\xa9\x05\x70\x09\x55\xdb\xa5\x22\xb0\x06\x4e\x70\xd2\x61\x62\xf4\xb7\x23\x42\xea\x06\x9f\xbb\x5d\xbd\x12\x74\x22\x36\x36\x00\xc4\x2b\x6d\x4e\x77\x08\xa8\xbf\xc4\x8a\x52\xe6\xa8\xfc\x59\x67\xf2\xed\xb8\xf6\xad\xd3\x97\xd7\x0a\x3a\xf1\x8d\xcc\xa4\xdc\xa6\xf6\xf8\x09\x9c\x4c\x8a\x88\xc2\x1e\x3f\x3f\x1c\x1e\xff\xf9\xe3\x9f\xff\xe5\xa7\xff\x7c\xaa\x39\xed\xcf\xd9\xc3\x3b\xe6\xb9\x0d\x4d\xd5\xf7\xcb\x56\x65\x5d\xfc\xb7\x59\x6e\xb5\xf6\x6b\x1b\xfa\x8a\x6f\x45\x3b\xe0\x80\xf3\xea\x5f\xdf\x2a\xea\x2f\x5a\x2b\x3c\xad\x8f\x46\xd1\x29\xd1\x7a\x6b\x4d\xae\x33\xf7\xf8\xde\x87\xe1\x6d\xe9\xbe\xb7\xcf\xdc\x6f\xad\x7d\xbc\x7a\x7f\xfd\xf3\xbf\xfc\xfc\xd3\x8f\x4f\x24\x90\xfd\x23\x09\xed\x32\x21\xbc\x65\xc1\x41\xd3\x83\xaa\x6f\x27\x47\x2b\x29\x19\xef\x1f\xef\xdf\xc3\x63\xe6\x27\x42\xcc\x70\x4e\x7c\x38\xbe\x7b\x7d\x99\xee\x18\x3f\x34\x7f\x34\x7e\x36\x7d\x36\x7c\x36\x7b\xc4\x31\xe2\xc2\x47\xd3\xe7\xc7\xfb\x11\xc0\xcd\x01\x02\x01\xdc\x40\xf7\x61\x9b\x77\x8c\x2b\xbd\x2d\x85\x50\x3c\xf8\x99\x33\x10\x88\xf0\x33\xfd\xa8\x0b\x62\x0f\x96\xc1\xd8\xdb\xed\xc6\x83\x0b\xca\xea\xbb\xee\xf8\x0e\x71\x1c\x4b\xa3\xfa\xbb\x6d\x24\xb7\x08\x06\xd9\x3e\x68\x3a\x99\x5e\x97\x5e\x7d\x09\xee\xc7\xb5\x70\x79\x23\x65\xbd\xb7\xff\xe6\x32\xaa\xfd\xea\x83\xfd\x83\x33\x0e\x10\x44\xd7\xfb\x79\xeb\x22\x09\xa7\xf6\x72\x40\x52\xfa\x80\xc3\x67\x9a\xfa\xb8\xb5\xd6\xae\xd3\x5d\xd8\xe9\xbe\xad\xd6\xba\x11\x24\x55\x41\x25\x16\xaa\xd1\x0d\x58\xa3\x4a\x14\x9f\xa2\x4e\x46\x7a\x6a\x25\xe1\x8f\xbb\xb8\xcf\x46\x7d\xe5\xee\x46\x1c\x70\x0d\xe4\x9d\x05\xd9\x1a\x61\x9d\x6d\xed\x40\x8a\xeb\x36\xab\x77\x97\x66\x49\x45\x77\x04\x3b\x8b\xfa\x97\xfe\x1d\x90\x0b\x9a\x7d\xa7\x02\xe2\x17\x8b\x44\xd4\x82\xf6\xd6\xdf\xbc\x9b\xcf\x9f\xfe\x78\x39\xc6\x97\xe3\x36\xbe\x26\x46\xe5\x2c\x11\xd2\xa6\x08\x62\x66\xc6\x11\x3e\xde\xf6\x7e\xfc\xf3\x5f\x9f\x12\xae\xfd\x4c\x13\xb6\x66\x6e\xa8\x56\x66\x73\xe4\x08\x86\xd1\x12\x1f\x91\xec\x87\x3d\x4d\xe7\x72\x03\x4b\x94\xcc\x24\xf5\x2a\xf9\xf5\xa5\xfb\x72\x24\x42\xde\xe8\x83\xea\xb8\xdd\x6d\x77\x16\x9b\x88\x60\x53\xd0\x8d\x15\x1b\xbe\x63\xbf\xbe\xd8\x9c\xa9\xb9\xe9\x07\x78\x75\x43\xfe\x29\x22\x90\x47\x22\x1b\x10\xfd\x48\x2a\x59\x58\x92\x71\x9b\x8a\x82\x03\x42\x03\x3a\x7d\x71\xf1\x55\xd1\x92\xa6\xbe\x6b\x6a\x20\x08\x2b\x91\x8a\x29\x37\xdb\x7d\x4c\x31\x11\xa3\xf0\xd9\x6b\x49\xc6\x61\x31\x30\x74\x8a\x37\x29\x48\xd3\x73\x92\xc2\x8f\x33\x46\x0f\xf3\xc9\x1d\x1f\x69\x71\x70\x33\x40\x96\x29\x90\xff\x24\x48\x3d\xe2\x13\x04\x21\x0f\x2a\x8d\x65\x4c\xc4\xd4\xd1\x17\xc8\xf6\xf4\xb4\x0c\xdb\x06\x68\x03\x15\xb0\x7d\xed\x91\x51\x2b\x4c\x77\x11\x24\xee\xbf\x27\x7a\x44\xcc\x01\x8d\x90\x66\x47\x3f\x4b\x06\xd9\x2f\xf6\x69\x60\x0d\x66\x14\x3b\x14\xd6\x0e\xe1\x66\x48\x25\x65\x49\x82\xf9\xa0\xb3\x6c\xb7\x11\x67\xcb\xd0\x39\x0a\x24\x5a\xc4\xe2\xcc\xbb\x0a\x4e\xbf\x3f\x9b\xa4\x96\x30\x9d\x40\x80\x34\x4f\x35\x12\x0c\x99\x9a\x50\xba\xf8\x85\xc2\x84\x60\x7a\x15\xb0\xa8\x4a\xa8\x88\xee\x23\x55\xd9\xad\x25\xed\x90\xfa\x23\xae\x3f\xef\x05\x49\x3c\xbe\x4c\x82\xd6\x19\xd4\xc9\x24\x66\x10\x4b\x8c\x45\xb4\x9b\xbb\xdd\x15\x9a\xf1\x28\xd7\x40\xec\x50\xd2\x41\x23\x8e\x70\x22\x56\xd3\xce\x3e\x07\x09\xee\x32\xb0\xe7\x92\x3f\xa6\xc6\xb0\xbe\x04\x29\x28\x09\xb6\xe9\x69\x5a\x30\x42\xa0\xa7\xe0\x56\xe3\x8d\xb8\xdf\xbd\x94\xea\x96\x02\x16\x6a\x7a\xc8\xb1\x1c\x07\xf6\xa3\xb2\x10\x0b\x17\x08\x92\x59\xb0\xab\x22\x4e\x29\xe7\xe0\x75\x53\x0d\x9e\x8d\x94\x0d\x4c\x36\x3d\x8d\xc8\xc3\x12\xd9\x51\x0e\x56\x50\x33\x36\x08\x8d\x16\xeb\xee\xf1\x93\xa7\x36\x07\x3a\x9f\x94\x8f\xe6\xef\x98\x31\xf0\xed\x84\xf8\x83\x7e\x6c\xb2\x2e\x52\x53\xec\x29\x7a\xb0\xd7\x1f\x73\x6a\xbb\x33\x95\xd7\x2f\x41\x2b\xcb\xf4\x29\xf8\x8f\x06\x89\xc0\x91\xfc\x68\x2c\x8b\x0b\x4a\xe4\x1d\x6f\x76\xf1\x61\x5d\x3a\xaa\x50\x32\xf0\xeb\x9a\xc4\xcd\x6f\xbf\xd7\xa3\x4f\xd9\xbb\xb6\xbb\xe5\xea\xaf\x64\xba\x6d\xab\x39\x8d\xcd\x6f\x93\x21\x08\x26\x1b\x18\xee\x67\x67\xce\xc8\x82\x2e\x8d\xb1\xf6\x10\x99\x3d\xab\x07\xbf\x04\x36\xdf\xc7\x0a\x98\x70\x0d\x81\x73\x60\xf5\x67\x42\xf8\x25\x29\xfd\x90\x1d\x70\xa4\x09\xd8\x9c\x1b\xda\x0d\xfc\xd8\x90\xab\x4a\xd6\xfc\x5e\xfd\x5d\x90\x8b\x5c\x3a\xc7\x9c\x74\xf2\x7b\x89\xb2\xd8\xcd\xe7\xf9\xb8\x9b\x54\x00\x06\x12\xfe\x53\x90\x1e\x3d\x08\xf1\xa9\x10\x0e\xc2\xa2\x72\xac\x53\x87\x7a\x04\xea\x0d\x90\x62\x29\x4c\xcb\xf8\x44\xd9\x17\x54\x7c\x82\x0b\x18\xa5\x3b\xf0\xf7\x10\x4c\xb2\xd4\x89\x7e\x27\x95\x5c\xf2\xd7\x0b\x1b\x0f\x63\x8c\x79\xb1\x1a\xf1\xc1\x76\x12\xc5\x23\xa6\xb4\x33\x74\x3b\xc2\x68\x68\x76\x61\xa4\xaa\x25\x92\x34\x2f\x18\xce\x7c\xd5\x45\x48\xe9\x3e\x12\x47\x91\x2f\x19\x0c\x80\x73\xf8\x60\x81\x9a\x10\xfd\x32\xde\x8b\xb5\x34\x7d\x1e\x24\x1d\xa9\xa4\xda\xb6\xc2\xf8\x23\x48\xab\xa3\x6b\xa8\xf6\x40\xfc\x25\x16\xe9\xd6\xb6\x7a\x2a\x10\xe9\xd8\xb9\xee\x21\x95\x0f\x0f\xb6\x1c\x52\xc7\x16\x35\x60\x42\xae\x37\x06\x6c\x6c\x30\x11\x83\x6e\xe2\x50\xb5\x8d\xc1\x51\xbf\xb7\x42\x74\x99\x1b\xcf\x7b\x8f\xf8\x79\x41\x36\xa4\x27\xea\x3f\xa7\x11\x0a\x06\xd2\xf8\x3a\x7c\xa8\x69\x6a\x9b\x6f\xef\x24\x90\xdd\x71\x2f\x3c\x73\x01\xc1\x16\x22\xc7\xa8\xb3\xc2\x8d\xf4\x34\xfa\xa6\x96\x6c\xb8\xe3\xe0\xee\x85\x02\xaf\x86\xb2\x1e\xbc\x9b\x18\x61\x8b\xbb\xf4\x51\x51\xdd\x62\x01\xd0\x98\x64\x1b\x42\xe0\x20\x8d\xee\x9d\xe5\x93\x33\x6f\x04\xcc\x36\xd4\x7b\x1c\x84\x34\xb3\xbb\xf7\x87\x67\x11\x80\xb5\x00\xaa\xf2\x0d\xad\x93\x10\xae\x46\x4c\xff\x5e\x47\x89\x02\xf8\x06\x7c\x74\xd5\x8b\x5f\xaa\xe3\x91\x60\x49\x70\x83\x40\xe6\x85\x33\xa3\x6f\x1a\xe1\xe1\xe6\x8b\x52\x4e\x9d\x35\x2f\xc1\x27\x8d\xf7\xe3\xe6\x85\x25\x62\x74\x6a\x9a\xd5\x87\xb0\x7f\xd5\x4e\x2b\xd8\x0d\xa4\x9d\x2c\xd8\x95\x86\x41\x70\xca\xba\x81\x08\x7a\xbb\x63\xff\x2f\xa9\x60\xbe\x48\xe8\x50\xfb\xba\xda\x13\x12\x4e\x67\x70\x7f\xe3\x40\x42\x28\x73\xc7\x86\x9a\x5f\x5f\x46\x03\x1a\x1e\x21\x1f\x18\x1d\x51\xd4\xca\xcd\x1e\x19\xa6\x6d\x81\x4d\xe8\x37\xbd\xfb\x56\x79\xd9\x7d\xd4\x6c\x94\x34\x44\xb9\x21\x26\xae\xa5\x91\xd4\x7b\x3b\xa9\x3f\xd4\xf4\xb9\x56\x32\x0a\xf3\xd8\x51\x68\xad\x73\x88\xb4\xed\x28\xee\x72\x83\xa5\x32\xb0\x13\x06\xcd\xc2\x85\x1f\x6b\xe1\xf2\xb8\x9e\x62\xec\xb7\xc3\x5e\x6a\x69\x99\xbb\x61\x81\xdb\x0a\x2f\x9f\xdd\xf6\x47\xe0\x76\x6e\x92\x24\xcd\x24\xfe\x8b\xee\x33\xf5\x28\x4a\x6f\x9c\x17\x12\x53\xbf\x7c\x61\x3d\xac\x96\x1d\xf7\x78\xc8\x74\xd4\x48\x7c\x72\xd7\xc3\xa2\x78\xa1\xfe\x86\x44\xdd\x22\xfe\xdc\x0e\xb8\xa3\xd4\xd3\x6b\xb1\xc8\x2d\x4c\x86\x30\x99\xf9\x63\x71\x52\x2b\x21\xf6\xd7\x90\x59\x08\x0d\x8b\xc1\x31\x0b\xdc\xef\xb1\x65\xaa\x9d\x9b\x9f\xd6\x23\x59\x47\x7b\xa0\xa7\x63\x85\x46\x17\xe5\x44\xd1\x46\xc6\x52\x17\x89\x34\x30\x66\x1b\x97\x71\x5f\xb6\x99\x59\xde\x8f\x94\x53\x3e\x72\x91\x3a\x4e\x26\x79\xa6\x77\x11\x0c\x63\xcc\x1d\x74\xfa\xa5\xa5\xe2\x4b\x9c\xcc\x04\x70\x19\x89\xb5\x6b\x4e\x33\xd8\x14\x69\x9e\xd9\xb9\xbb\xfa\xda\x3f\xc3\x24\xf3\x39\x46\x1a\x7a\x9f\x62\x05\xb1\x74\x08\x9c\x20\x93\xe6\x36\x1b\xd9\xeb\x7d\x16\x11\x8f\x04\x6b\x10\xd8\x48\xca\x8d\x14\x9f\x7c\xa2\x9b\xc1\x70\x74\x0f\x0a\xef\xab\x0a\x92\xb2\xb0\xea\x11\xdd\x6e\x94\xa4\xd6\xa0\x71\xc0\x54\x2b\xb0\x97\x8e\x38\xa8\x91\x8a\xdf\x7b\x69\xc3\xda\x82\xdc\x72\xec\x3c\x63\xa7\x2d\xdc\x77\x62\xeb\x0f\x53\x06\x24\xe7\x97\x58\x1f\x07\xd4\x5c\xa8\x76\xac\x6d\xe3\x0e\x1a\x9c\x01\x20\x83\x64\x26\x29\x4a\xbe\x97\x86\xa2\x05\xd5\x60\xde\x54\x23\xdf\xe5\x52\xdc\xb1\x68\x09\xdc\x99\xbe\x58\x1b\x44\x0a\xfa\xc9\x69\x29\x13\xe5\xb3\x9a\xd1\x27\x1b\xaa\x22\x64\x62\x9d\x9f\x49\xdd\x50\x6d\x54\x1e\x80\x0c\x6e\xa6\x5d\x37\xa3\x58\xd2\x57\x18\x12\x9c\x99\x2f\x67\xfe\x32\xb3\x37\xa7\x25\x15\xa4\xa6\x8a\x6e\x24\xec\xc2\x82\xa8\x34\x21\xfa\xf0\x8d\xb9\x89\x2f\x15\xb5\x5c\x36\x11\x86\x72\xc4\x27\xe7\x24\x75\x17\xca\x42\x20\xa8\x9d\x7d\x9d\x9a\x08\x89\x4a\x25\x3c\x0b\xe1\x1c\x26\x56\x15\xdc\x6b\x49\x65\xab\x06\xb9\x98\x16\x8e\x85\x9b\x89\x6e\xd9\x6d\xac\x45\x4a\x93\x53\x88\x02\xf7\x1c\xa0\xa5\x87\xfb\x33\x69\x84\xaa\x94\xcd\xe2\x49\x59\x92\x2b\x03\xc5\xd2\x75\x26\xf6\xb6\x34\xdb\x99\xc1\x93\x09\x00\x73\x99\xe9\x88\xc6\xb3\xa6\x99\xb3\x27\xd3\x84\x93\x1c\xe2\x1c\x5f\xa2\x70\x1b\x69\x76\x68\xf0\xa1\xda\x99\x4a\x06\xfb\xc2\x98\x18\xb5\xc0\xb9\x78\xa6\x83\xc2\x3b\x9c\x24\x1a\xc3\xf7\x00\x46\xe6\x62\xc9\xa1\xef\x86\x05\x95\x22\x8d\xd9\xf7\xa5\x4c\xdf\x3c\x67\xc7\xa8\xe9\xac\x00\x98\x9c\x24\xac\x63\x09\x74\x08\x34\xe8\xcc\xf6\x41\x91\x87\xad\x22\x17\x0a\x08\x04\xe7\x51\x3e\x44\x1f\xd0\xbd\x23\xf5\x1e\x53\x07\x79\x1c\xa2\xa6\x7d\x5c\x61\x96\x4a\xac\x24\x28\xbe\x85\xbb\x03\x7f\x65\xc0\xe5\xf0\xfd\xed\x42\xe3\x19\xfd\x8e\x07\x4d\x81\xbf\xd8\x85\x30\x74\x58\x99\xf9\x5c\x29\x18\x60\xde\x23\x63\x63\xfb\x69\x50\x7e\x02\x44\xfe\xf1\xfb\xef\xdf\x09\x8c\xbe\x85\x89\xa2\x6e\x4b\x93\x82\x1f\xa4\xe4\x54\xe6\x00\x0b\x09\x48\x70\xb9\x64\xc6\x74\x0e\x64\x1f\x9e\x67\xa7\x84\xca\x70\xeb\x96\x34\x20\xe5\x80\x24\x2d\x52\x20\x6f\x9a\xa0\xea\x02\x1b\x21\xa7\x82\xae\xae\xf9\x90\x22\xa8\x2d\x55\x7d\x7d\x19\x36\x11\x71\x76\xe3\xae\x80\x7d\x0e\x62\x30\x8b\x61\x72\xb9\xad\x81\xda\x36\x63\x6d\x3e\x16\x55\x95\x23\x2e\x89\x24\x1b\xdf\x02\x4d\x2f\x21\xaa\xd1\x17\x76\x7a\x4d\x7c\x77\x85\x30\x22\xec\x39\x60\xae\x1d\x72\xe1\xaa\x51\xc6\x6a\xc0\x0a\x15\xa4\xb8\x40\xf0\xed\xb3\xdb\x6d\x8e\x6e\x9a\x06\xd8\x86\x35\xa2\xa8\x5a\x4a\x42\x75\x1f\x62\xaf\x08\x92\x62\x96\x8c\xb6\x13\xdb\xab\xdd\x57\x4c\x7f\xbe\x96\x5b\x1a\x08\x8e\x88\x7b\x96\xcd\x1f\xd0\xff\x4a\x81\x28\x9d\xf0\x8a\x81\x92\xc6\x28\x6d\x73\xf3\x95\x1f\x70\x5b\xff\x0f\x99\xd1\x96\xb4\x02\xee\xd8\x60\x15\xf4\xee\x9d\x10\x96\x3a\xb6\x59\x4d\xf2\xfa\x22\x9a\xdd\xb8\x46\x7a\xd6\xcf\x6d\x30\x29\x81\x84\xda\x96\xde\x4e\x65\x0e\xf7\x16\xf8\xa6\xba\x2f\x21\x6e\xc3\x0d\xdd\x7c\x69\x6b\x50\xc4\x04\x45\x00\x40\x97\x40\xac\x00\x09\x55\xfb\x6e\x47\x72\xd2\x9f\x05\xa0\x62\x88\x84\x28\x96\xff\x32\x53\x91\x4c\xdc\x39\x4d\x09\x0d\x57\x97\x7e\x04\x61\x37\xd4\x84\x41\xa1\x24\x87\x48\x26\xc4\x57\xb8\x99\x37\x84\x4f\x2a\xde\xbd\xbf\xd1\x59\x69\xc3\xb5\xd8\x19\x68\xd2\xa3\xca\xb5\x26\xc8\x8f\x74\x02\xa4\x74\x6f\x93\x1b\x2f\x9e\x79\xa7\x4f\x55\x83\xfd\x18\x9e\x36\xfe\xd2\x2e\xbb\xd2\x57\xf9\xe7\x45\xe0\xfd\xc7\xbf\xfd\xaf\xbf\x3c\x4f\xe4\x3b\x16\x54\xba\x41\xe1\x94\x18\x5b\x84\x47\x26\x9d\xcb\x01\x85\x07\xbc\x02\x83\x54\x0d\xb6\x45\x2b\xfb\x02\x70\x99\x02\xb5\x5e\x92\x16\xc4\xee\x3b\x29\x60\x18\x38\x38\xcc\x61\x37\x02\xda\x61\x15\x09\xf7\x4c\x04\xef\x3a\x78\x2e\x53\xef\x11\xb3\x43\xc9\xd4\x8e\x40\x0f\x20\x4d\x23\xd6\x75\xb0\x07\x4f\xbc\x16\x51\xf7\xae\x73\x14\x84\x2b\x4b\x2e\x3a\x48\x15\x60\xb2\xb1\x64\x03\xb9\x94\x46\x7b\x74\x68\x72\x4f\x38\xca\x44\x0f\xa3\xef\x02\x64\xd0\x17\x16\x3a\x22\x14\x82\x04\x38\x37\x18\x6f\x34\x32\x13\xf0\xe2\x32\x6a\x6a\x80\x83\xf7\x0d\xd1\x67\xe1\x09\xa6\x36\x45\x69\x08\xfd\x22\x54\x54\xc4\x9e\x6b\x6d\x0b\xd3\x06\x75\x35\x44\xa8\x4f\x86\xae\x5a\x2c\x76\x95\xe0\xb0\xa3\x7e\x1c\x5b\x2b\xf0\x44\x95\x3c\xd5\x74\xec\xc0\xeb\xd1\xe2\x2f\xb5\x20\x7a\xc4\xd2\xdc\xa8\x9d\xcf\x87\xd6\x1c\x6b\x27\x27\x09\xc6\x17\xa9\xf0\xb2\xa6\x90\xa3\xe9\xb2\x75\x43\xae\x27\x07\x73\x10\xf6\x45\x84\xad\xc6\x00\x1e\x0a\xf2\x63\x49\x02\x51\x54\x41\x9b\x40\x92\xac\x4a\x82\x1e\x8e\xbb\x08\xc9\x47\xfa\x3f\x62\x26\x39\x45\x85\xeb\xc8\x1b\xa2\xe0\x74\x56\xf3\xa1\x11\x44\xad\x12\x4c\xbc\xd8\xdb\xb5\xde\xb1\xbd\x8a\xb0\x20\x42\x71\x9d\x72\x05\x9d\x01\xa1\x9a\xc1\xe4\x0e\x67\x78\xa0\xac\xd5\x3d\x9e\x3a\x13\xef\x86\x37\xc3\x7b\xe1\xad\xf0\x4e\xb0\xb0\x8e\x7c\xd9\x7c\x88\xa1\x19\xef\x35\xde\x05\x6f\x82\x16\x86\x32\x5c\x10\x78\x5f\xbf\x8b\x1a\x51\x1f\xde\x05\x4c\xd5\x78\x92\x6d\x64\x66\x9d\x88\x74\xf9\x84\x58\xfb\xa7\xbf\xfe\xfc\x1f\xdb\x5f\xbf\xfe\xfc\x34\xeb\xc6\x33\x55\xe9\xa3\x2e\x48\x76\x87\x2e\x2b\xf6\x95\x59\xb6\xca\xd4\x2d\x0c\x6f\x28\x45\x5e\x97\x0e\xc5\x39\xf4\x67\xa8\x07\xf6\xc3\xf3\xb1\x7e\x5b\x44\xe0\xbc\x2d\xa8\xf5\x17\x48\x91\x5b\x55\x77\xd2\xb5\xc1\x4f\x37\xae\x70\xfd\x0b\x4b\x37\x59\x29\xd9\xe9\x06\xa0\xfe\x29\xc2\xd1\xc6\x3f\x4f\xd9\x10\xe1\xa4\xc1\x84\xfb\x80\xa7\x0b\xd9\x94\x02\xc7\x03\x13\xe2\xa4\x93\x1a\xb7\x02\xb2\x2b\x32\x1c\xf5\x3b\x06\xf1\x6a\xa5\x85\xd6\x5d\xd8\x63\xbe\x33\xba\x15\x72\x79\x11\x55\xdf\x48\xa1\x01\x52\xd9\xed\xf4\x6e\x94\x72\x58\x8d\x71\xbd\xca\x6e\x58\x04\xef\xc7\x2d\x0b\xa5\xe3\x6e\x7a\x00\x53\xf9\x89\xe5\x78\x76\x2a\x2c\xa2\x66\x0c\xd6\xda\x75\x61\x71\x72\x88\xe7\xd0\xcd\x18\x68\xa4\x00\x64\x86\x87\x52\x46\x2e\xa8\x77\x46\xb3\x0c\x4b\x21\x67\x6b\x45\x21\x6c\xad\xa8\x6b\x2f\x08\x3c\x01\xa2\xc1\xe2\xe9\xdd\x77\x7c\x7f\xf0\xeb\x18\x63\x83\xba\x95\x00\x4a\x6a\xac\xdc\x80\x0c\xf8\xf1\xbc\x97\x15\x04\x55\x4b\x9f\xd9\xad\x08\x28\xee\xe2\xe9\x76\x3c\xb2\x3f\x31\x3a\x02\xfd\xf0\x31\xd2\xe8\xe7\x1f\xd6\xf5\xa7\xa7\xe1\x76\xaa\xca\xf6\xec\x5e\x81\xde\xdc\x6a\x7b\x87\x62\x1c\xb2\xe9\xef\x51\x8c\xc7\xf1\xbf\x24\x19\xf7\xe3\x9f\x48\xcc\xad\xb7\x54\x7b\xbb\x1d\x8a\xce\xbf\xf2\x12\x47\x69\xd0\xaf\xb8\x02\x40\x43\x06\x6e\xf9\x92\xc7\xb7\x88\xce\xfc\xbb\xcb\xbb\x54\x67\x71\xd6\x2f\xb8\xce\xf0\xd7\x77\xc8\xce\x3e\x9c\xe2\x3f\xfc\xfb\xd7\x67\xeb\x78\xe8\x47\xd3\x5b\x07\x38\x78\xdf\xa7\xc4\x3f\xb6\x01\x3f\xc6\xd6\xc5\x47\x88\x15\xb9\x82\xa1\x4a\x4c\x57\x2d\x70\x4e\x64\xa3\xd7\x38\x81\x16\xf8\x56\x07\x80\xeb\xa2\xeb\x99\x9f\xb4\x10\x4c\xc7\x59\x57\x6a\xac\x47\xd2\x70\x22\x9b\x61\x96\xfa\x24\x65\x08\xf0\x37\xcf\x7d\xc7\x2c\x90\x1f\x8d\x5b\x29\x22\x37\x31\xf5\xfb\xe3\xcd\x2e\x86\xc0\x29\xc9\x11\xc8\xa2\x63\x97\xf7\x18\xfe\x63\x75\x70\xcb\x16\xaa\xe1\x36\x8a\xef\x4d\x92\x7b\x92\xee\x3e\x69\xbf\x12\xcc\x83\xfd\x0a\x34\x70\xb9\xe3\x48\x62\x78\x1a\xc3\x4f\xcd\xa7\xd4\xeb\xcb\x40\xf1\x2b\x3b\x15\x26\x7f\x08\x82\xd0\x2b\xaf\x8f\x1c\x85\xf8\x85\x9f\x29\x8d\x41\x82\xc1\xfb\xc7\x87\x23\x1e\xcf\x7c\x68\xf2\xc3\x21\xf1\xee\x80\xf8\x08\x3c\x09\x0f\x6a\x98\xde\x96\x22\xdf\x10\x4a\xd8\xdf\x8a\x23\x58\xd5\xeb\xd2\xca\x6d\x99\xf2\x8d\x97\xbb\xbf\x7d\xa3\xa5\x15\x9e\x50\xa8\x15\xf0\xe9\x09\x53\xe2\x0a\xbe\x6d\xfc\x9a\x5b\xe2\xad\x8f\x9c\x2a\xd8\x13\x76\x71\x53\xbb\x81\x36\x17\x22\x2c\xfe\xfb\x52\x1b\x2c\x28\xb1\xf6\x7a\x01\xfd\xe6\x3f\xc8\x2b\xfb\xd7\x1f\xf7\xfd\xc7\x27\x54\xdb\x38\xa1\x99\xbd\xbb\xb7\x52\x80\x30\x73\x0b\x59\x9a\xaf\xfd\xd4\x64\x9d\xfb\xd2\xd2\x38\x64\x4b\xfa\xc4\x58\xf7\xd9\x38\x2c\xc2\x7f\x34\x35\x90\x42\x89\xda\x81\x12\x49\x00\xef\xd5\xd9\x82\x68\x0a\x5b\xe8\x64\x3a\x51\xa9\xb0\x81\xa3\xcb\xd1\x04\x5b\x00\x31\x48\x8d\xda\x89\xc5\xc2\x25\xe2\xab\xf4\xab\x86\x56\xec\x82\x0d\xe6\x9f\x55\xe4\xfe\x3f\xfe\xfa\x04\xac\x1c\xcf\xec\x82\x0f\xa8\xb3\xd2\x8f\x12\x2f\x08\x0b\xc1\x64\xd6\x08\xc4\xaa\x25\x19\x65\x07\xa7\x8a\x50\xbc\xcc\xce\xd4\xaf\x46\x19\x3e\x07\x1a\x22\x0d\x7e\x08\x80\x5c\x38\x2b\xd2\x2a\x68\xeb\xf1\xf3\x79\xc4\x79\xd2\x63\x53\x0f\x97\x38\x2e\x7b\xdc\xc7\xfd\xde\x5e\x5f\xa4\x97\x91\xac\x19\x41\x01\x51\x36\xa0\x79\x5d\x74\xba\x49\xd3\x6e\x8b\x65\x1a\xdf\xed\x20\x72\xa5\x6d\x24\x41\x62\xe6\xa6\x83\x1f\x3b\xcb\xba\x08\x6c\x52\x80\xe7\xf2\x9d\xf6\x55\x0c\xc2\xc9\xa8\x2c\x76\xe3\xb9\x8c\xa3\x75\xaa\x89\xc0\x7e\x9a\x29\x80\xa5\x3c\x51\xdb\xcd\x72\x8b\x96\xdb\x16\x60\x49\x70\x05\x42\x09\xab\xa7\x92\x74\xae\x67\x7b\xf1\xc1\xdd\x77\x28\x16\x25\x9d\x44\x08\xe0\x94\x95\xcd\xdc\xf8\x28\x60\x57\x49\xda\x90\xbc\x21\xad\xdd\x1a\xf7\x73\x34\xb8\xcd\x53\x60\x6b\xa7\xf6\xd5\x7a\x3c\x1b\xdb\xa2\x34\x4b\x63\x8e\x8b\x70\x4e\x0a\xd7\x2b\x7b\x2c\x1a\x6c\x1b\x81\xb2\xec\x54\xe4\xd9\x10\xc0\x5e\x74\xde\x7b\xeb\x6c\x3a\x64\x9d\xf1\xf5\x27\xdc\x97\xad\x3d\x8d\xce\x76\x2f\xa9\x6c\xee\x6c\x1a\x51\x6b\x70\x99\x32\x09\x84\x07\x01\x7c\xd6\x91\x35\xd7\x52\x93\xfa\xdc\x9e\x39\x19\xd8\x06\x41\xc7\x9b\x4b\xb2\xda\xb7\x05\xb8\x99\x86\x22\x12\x9a\x9f\x64\x36\x8d\xac\x1f\x6d\x31\x23\xfb\x9f\xd2\x11\x65\xa0\x42\x73\xd9\x59\x9f\x81\xa0\x16\xbe\x03\xcf\x8d\x3b\xd9\x87\xdf\xd3\x58\x9f\x41\xc6\x60\x3a\x7a\xc5\xdd\x4d\xf1\x57\x88\x28\x18\xaa\xde\x98\x6f\x88\x38\x8c\xd8\x19\xf2\xf5\x21\x48\x51\xd1\x39\x52\x93\x0b\x1f\x86\x65\x73\xad\xf0\xa9\x9a\x24\x9d\xc8\x4c\x55\x4b\x20\x11\xd2\x09\xb3\xb8\xb6\xa4\x85\x2c\x18\x44\x41\x20\x47\x39\x33\x02\x0c\x5b\x29\x49\x53\x03\x95\x10\xd8\x30\x8b\x04\x01\x23\x01\x93\x60\x57\x8b\x98\x8f\x8c\x87\xcc\xb7\x4a\xb8\xeb\xe2\x5e\x0d\x28\xcd\x6c\x97\x89\x3c\xcd\xd8\xd5\xff\xe2\xeb\x36\xf9\x4e\x74\xa4\x2a\x5b\x11\x96\x07\x22\xed\x13\xb2\x46\x91\x55\x2d\x81\xaf\xb1\x8f\x49\x1a\xbe\xfe\xfc\xa7\xeb\x8f\xb7\xe7\xcd\xfe\x43\x58\x70\x1e\x23\x88\x73\xdf\x61\x27\xad\xed\x7d\x76\xd2\xfd\x17\x94\xa4\xb5\xbd\x47\x49\xda\x5a\x49\xc3\x17\x8d\x6f\x12\xad\xd2\x28\x7e\xd7\x26\xe6\x39\xbf\xd2\x24\x26\xcc\x97\x26\x78\x84\x07\xde\xbd\x58\x05\xad\xc6\x3b\x57\xe3\x49\xbf\xbc\x5a\xb5\xf6\x5b\x0d\xf0\xef\xff\xfa\x44\x8d\x34\x9e\xf1\xc9\x0f\x02\x33\xcd\xd4\xbd\x93\x6f\xb2\x23\x87\x9f\x83\x58\x63\x07\x4b\xca\x8a\x42\x6c\xcd\x13\xe8\x6a\x92\xf6\x92\x77\x75\x72\x2b\x97\x71\xb4\xc3\x77\x86\xa7\x59\x7d\xe4\x25\x99\x40\xe5\x2c\x01\x48\xf0\xc5\x98\xd4\x18\x5f\x82\x9f\x80\x5c\x24\x60\x9d\x0e\x7d\x3b\xb1\xdb\x00\x1b\x85\x8e\xdb\x32\x7c\xf9\xa5\x47\x40\x75\x6c\xa6\x30\x46\x87\xad\xd6\x5a\xb2\x19\x31\x52\xa3\xb4\x79\x4d\x82\xad\x00\xc9\xea\x7e\xb9\x17\xac\x15\xf0\x16\x1e\x5a\x8c\xc5\x48\x13\x38\x91\xbe\xc0\x4a\x80\x18\x2b\x53\x0a\xed\x4b\x5d\x35\x6b\x52\xed\x20\x1c\x03\xba\xb7\x82\x37\xe4\x00\xdf\x3f\xbd\xd2\xfd\x0d\x6d\xb4\x96\x9b\x62\x4f\x72\x93\x1e\xac\x9e\xec\xb6\xa7\x43\x63\x48\xaf\x82\x20\x4b\xb7\xeb\x28\x65\x3d\xce\x7a\x20\x48\xde\xdf\x0c\x89\xa3\xef\x79\x01\xff\xe7\xb6\xe8\x2c\xac\x68\xb8\x0f\xa0\xcb\x7d\xbc\x42\x1a\x4c\x68\x37\x53\x38\xdb\x10\xec\x4a\x0a\x3c\x15\xfe\x65\xf4\x8b\x1f\x17\x7c\x9e\x51\x44\xfb\x99\xdb\x7d\xfb\xb7\xa7\x41\xf8\x8c\x1c\x9f\x7a\xba\x80\x53\xc0\x20\xdd\x36\x40\x21\x22\xbd\x11\xa1\x94\xc2\xbc\xa8\x0f\x8e\x51\x37\xa2\xdc\x84\x34\x3d\x5d\x43\x36\x6f\x21\xbe\x8c\x54\xa9\x44\x53\x15\xb0\xd4\x04\x66\x06\xac\xda\xb6\xa1\xd2\x0a\x69\x4b\xc1\x42\x0a\xa6\x1a\x64\x49\x65\xb3\x7b\x7c\x1c\xc0\xc9\x83\xdb\x27\x1f\x2b\xa0\x9e\x38\x2e\x04\xfe\x30\xbc\xe0\x7e\xc5\x4d\x32\xd4\xca\x0a\x5d\xd5\x15\xa5\xa2\x50\x98\x46\xa0\xa8\x67\xc8\x11\x36\x86\x66\x23\x2f\x57\xc7\x25\x58\x7b\x00\xf9\x08\xcc\xce\xa0\x4c\x29\xb3\xeb\xcc\x82\x11\xb7\x35\x8f\xbf\x56\xdd\xa9\x4a\xe4\x2d\x1d\x09\x5e\xbb\x03\xcd\xfa\x91\xc7\x5d\x03\x61\x73\xcc\x48\x68\x80\xbb\x33\x2b\x75\x43\xfa\x00\xcb\x7c\x0b\xa1\x41\x6e\x24\x35\xd8\x3c\x50\x80\x9a\x91\xb1\xe0\xa3\x22\x9e\x7d\x14\x0f\xf4\x40\x8b\x20\xca\x38\x21\x56\xdf\x92\x54\xff\xa0\xac\x9c\xf6\x8f\xc6\x24\xb8\x82\x24\x17\x59\x2f\xed\xbb\x4f\xb5\xb5\xa4\x76\x81\xc9\x33\x91\x1b\x9f\xab\xf6\x92\x14\x50\x19\x25\x19\x69\xa0\xc9\xfc\x29\x88\xd1\x68\x84\x06\x62\x3c\x1c\xdc\x1e\x20\x28\x45\x41\x93\xbf\xd0\x01\x4a\x22\x18\x70\xe0\xf9\x68\x99\xda\xcc\xb9\x50\xf5\x10\xdd\xbf\x13\x92\x87\xc8\x31\x52\x4d\x65\xd7\x9e\x88\x49\xab\x09\x29\x79\x55\x22\x6e\x4a\x07\x74\x6e\xc8\xee\xef\x12\x98\x16\xb8\x28\xa9\x1b\xe2\x6a\xa5\xad\xfe\x60\x0a\x4c\x19\xa2\xab\x35\x15\x83\xe5\xe8\xe3\x8c\xc4\xc5\x02\x56\x54\xcb\x5b\x45\xb4\x51\x6d\x26\x2d\x97\x0d\xea\x9f\xe4\x18\x17\xe3\xe3\xa4\x08\xb5\xdb\x3d\x51\x59\x88\x23\x58\x4c\xf7\x47\xbb\xdc\x87\x7f\x80\x3c\x3a\x13\x40\x80\xc7\x69\x8c\x06\x22\x5d\x8b\xc6\xe8\x2d\x23\x4e\xce\x27\x3e\xdc\x66\x14\xf3\x41\x9b\x60\x00\x9a\xe7\x7e\xc2\x0e\x50\xd0\x0e\xe8\xd2\x97\xba\x43\x7e\x6f\x87\xd6\xa1\x8f\xb4\xc6\xa0\x33\xaa\x09\xb4\x6e\xa8\xbb\xf1\xff\x07\xa4\xdd\x6f\x75\x2d\xc9\x56\x02\xe1\xc4\x92\xed\x9a\x93\xff\x55\xc7\x48\x7a\xd9\x6c\x26\x10\xd2\xf9\xad\x93\xd7\xeb\xb3\x95\xe4\x3f\x7f\xf8\xf1\xfb\xe7\xf8\xdd\x47\x1c\x65\xad\xd7\xa4\x55\x37\x92\xd1\x89\x90\x92\xb2\x82\x59\x1a\xd0\x48\x44\x52\x85\x64\xe0\xa5\x05\x71\x6c\xa1\x87\xd0\x8e\x42\xe2\x8a\x04\x36\x6b\xe0\x20\x8d\x1f\xa9\xe5\xd7\x97\xde\x66\xb2\x6e\x24\x88\xb3\x87\x2a\xf6\xb3\x88\x5f\x4a\x8a\x00\x69\xa0\x44\xf5\x81\x13\xc7\xbb\xd9\x84\x7e\x01\xb4\xa7\x17\x60\xd3\x90\x9c\x56\x34\xf0\xfa\x32\x8b\x0f\x95\xb6\x71\x07\x05\xff\x51\x65\xaa\xd7\x1d\x34\xb8\x57\x17\x62\x56\x39\x80\x71\x69\xdc\x06\xd6\x92\xd1\x89\xb7\x9c\x46\x50\x43\x12\x7f\xdd\x84\xb5\x31\x29\x0a\x64\x4c\x0d\xa4\x22\x30\x6d\x04\x11\x30\x27\xa9\xc0\x34\x83\x8b\xcf\xbd\xf1\x31\x93\x74\xbf\x72\x06\x9a\x38\x03\x6a\x00\xc4\x87\x6f\x9f\xa8\xf0\xf1\x05\xb7\x05\xee\x21\xd0\x5e\x1c\x5d\x48\x44\x82\x4e\x2a\x01\x5a\xdb\xf3\xce\x66\x16\x6f\x47\xa3\x83\x05\xa4\x05\x6a\x89\x8d\xb0\x0d\x36\x81\x16\xdc\x73\x6f\x96\x8a\x42\x41\x1f\x01\x17\xea\x63\x84\x17\x0e\xd0\x6e\x77\x6b\x3b\x1e\x29\x38\x01\x10\x75\xf0\xbb\xe5\x1c\x92\x1d\xbc\xcd\x84\x45\x28\x30\x12\xd3\xa0\x2f\x8e\x15\x58\x60\x81\xc8\x9c\x94\xc6\x90\x8a\x6a\x5a\x98\xef\x32\x61\xb1\xd7\xb1\x49\x9b\xc9\xff\xb3\x42\x40\x42\xdb\xb5\x70\x29\xde\x1a\x12\xaf\xe1\x5d\x4d\xba\xb0\xc4\x2c\x69\x26\x67\x3d\x91\x08\x98\x85\xc6\xe2\xdb\xb5\xf9\xa2\xe7\xd3\x62\x22\x81\x5c\xe7\x2e\xa0\xd6\x14\x10\xc9\x36\xa3\x74\x07\xe2\xb6\x1c\xa1\x51\x96\xb9\xdf\x01\xef\xa8\x1c\x40\x5d\x42\x5a\x1a\x10\x29\x32\xc8\x2a\x5a\x3a\x12\x73\x70\x0c\x88\x3d\x21\x8f\x45\xf1\x57\x9a\x4b\xdb\xdc\xf6\x2a\x3d\x31\x0a\x23\x99\x56\xd8\xd9\x85\xc4\x75\x9e\x55\x21\x70\x03\x18\xaf\x41\xae\x65\x60\xda\x70\x57\x2a\x30\x97\x7c\x19\x03\x41\x88\xcf\x3b\xec\x09\x50\x82\x39\xb6\xc7\x02\xb0\x9f\x2f\x95\x30\x02\x21\x81\x02\x2b\xcb\x3a\x42\x43\x58\x5f\x0c\x95\xaa\x0b\x83\x2a\x91\xa5\x7b\xbd\xbc\x48\xeb\xbe\x06\x67\x66\xf9\x67\x4b\x47\xe6\x2d\x40\x6e\xdc\xfd\x80\xc9\x59\xc8\x8b\x8b\x39\x0d\x96\x03\x7f\x48\xa8\x00\x80\x9e\x20\xf9\xda\x30\xd2\x50\x2e\x5d\xba\x23\x97\x56\x07\x14\x5a\x90\xfd\x2e\x23\x51\xcb\xc5\x8d\xa9\x71\xc0\x71\x89\xf6\x9c\x91\xbc\x05\x1a\x91\x9a\xbe\x07\x1f\x03\x92\x44\xc2\x9c\x92\x02\xad\x06\xb7\x0e\xac\x45\xbe\x9a\x7e\x2c\x96\xff\xc3\x9f\x7f\xfe\xe1\x39\xc8\xf3\xfd\x43\x35\xb4\x45\xe1\x5b\x17\x56\x94\x19\x44\x67\xfc\x2f\x93\x74\xa2\xad\xa7\xe9\xee\x3f\x04\x39\xe8\x4e\xfa\x36\xcc\x6d\x5d\xdb\x20\xad\x77\x29\xe9\x9c\x9d\x23\xbc\xce\x45\x45\x5e\x5f\x9a\xf9\x9a\x36\xcb\x6d\x29\x83\xe2\x0a\xc1\xe7\xc1\x9d\x27\xd0\x71\x9c\x4b\x99\x78\xae\x21\xc1\x8f\x31\x24\x95\xc9\x68\x78\x47\xa5\x41\x32\xd8\x64\x24\x7e\xd4\x46\xd2\x40\x5f\x8a\xfa\x11\x87\x33\x66\x2a\x90\x41\x1c\x00\xc0\x90\x29\xbd\xa4\x89\x10\x2c\xc4\x0d\x32\x17\x57\xdc\x03\x6e\xe1\xe6\xf7\x26\x08\xd2\xe6\x64\x48\x55\x5a\x3f\xf8\x25\x79\x9d\x70\xd4\xcb\x67\x58\x9e\xef\xac\xeb\x53\x8f\xff\xe9\xa3\x0a\xc7\x92\x35\x15\x23\xc4\x19\xc1\x7c\xc4\xe1\x6d\xec\x90\x1f\x27\x19\xce\x04\x07\x44\xc0\x7a\xb8\x24\xe2\xcf\x2d\xca\xee\x97\xd1\xa2\x00\x84\xcb\x0b\xd6\xaa\x60\x26\x59\x01\x39\x04\x0e\x0e\x96\x1a\x22\xcb\x91\xe5\x8b\xb0\x24\xa7\xaa\x31\xc3\x8c\x18\xa9\x69\x72\x3f\x4a\x40\x6c\xe1\xff\x0a\x09\x1a\x99\xfa\xf5\xbd\x2e\x19\xe1\x5e\x19\xb9\x6f\x42\xa9\x26\x60\x9a\x16\xc5\xa7\x54\x70\xdd\x09\x38\x34\x3c\x0e\x21\xb3\x06\xfc\xd5\x65\x5f\xa6\x22\xb6\x3b\x08\xd8\x77\xcb\x0f\x9f\x4a\xdb\xdc\x1b\x2a\x3d\xa9\x6f\x7b\x7d\x17\x42\xd6\x3b\x11\x44\x5f\x0e\xd4\xf9\x20\x2d\x4e\x0f\x44\xc9\x50\x60\xbe\x4c\x12\x28\xa8\x83\x1a\x36\x88\x38\xd9\x21\xc7\xd6\xcb\x6e\x62\x59\x91\x04\xe1\x25\x5a\xc3\xfd\x96\xc0\x5d\xf6\x9a\xda\x11\x4f\x9e\x34\x9a\xb1\x5b\x79\xf7\x6e\x9d\xbc\xc7\x30\xaf\x88\x6d\x0a\x62\xd0\x7d\xb2\x12\x2e\xb2\xdf\x19\xe1\xf8\x26\xbb\xaf\x8b\xcd\xf6\x43\x30\xe6\x02\x4b\xd4\x77\x9b\x15\x70\x64\x68\x85\x82\xa7\x8c\x90\x42\x50\x50\xeb\x01\x54\x28\x21\xdc\x41\x06\x14\x22\x03\x6a\xc1\x56\x03\xe8\x5a\xac\xd9\xa2\x7d\xef\xa8\x39\xf5\x3b\x44\x9d\x6c\x8a\x80\x16\xe2\x51\x7c\xd3\x20\x17\x72\x5f\x75\x1c\x36\xe1\x98\x61\xd6\x31\x6c\x2d\x76\x32\x10\x4d\xd2\x76\xc1\x90\x0b\xc9\x2b\x40\xe1\x80\xae\x05\xaa\x00\x81\x23\x4b\x1d\x4b\x1f\x0c\x60\x78\xba\xb6\x83\x4d\xaa\x8e\x1d\x54\xe5\xa0\x90\x08\x0f\xf8\xe2\x7d\x15\x79\xf0\x58\x35\x80\xe9\x47\xe4\x29\xec\x1a\x6e\xf9\x95\x48\x80\x7b\x62\x9a\x4f\x4e\x76\x08\xda\xad\xc1\x29\x50\xb0\xe4\x2e\x18\xd0\x18\x2d\x12\xef\xbb\xc4\x0c\x30\x96\x21\x80\x66\xb3\x33\xf4\xb6\x35\xbf\x6b\xe6\xcc\x49\x3e\x51\x64\x07\xcb\x14\xe8\x28\x88\x3c\xd3\x5d\x58\x86\x91\x77\xd4\x1b\x33\x30\xed\xa6\x82\x1f\xf9\x39\x39\xe6\x77\xdf\x62\xc7\x1c\xcf\x6a\xcf\x8f\x09\x4c\xdf\xbc\x87\xdd\x16\x96\x3e\x8e\x7a\xca\xdd\x94\xa8\xa1\x62\xd0\x71\x7e\xa9\xd7\xa5\x76\xf2\x09\xfb\x5a\x75\xd3\x36\xaf\x4b\x45\x01\x0e\x63\x1a\x38\x92\x53\xbd\x92\xb2\x09\x72\x4c\xed\x2a\x6a\xe3\x95\x97\x6a\x79\x1e\xba\xfe\x6a\xe3\xe6\x9f\x1e\xbe\x9d\xd6\x3f\xf8\x56\x72\xef\xb7\xa5\xf5\xf8\x16\x9c\xdc\xa3\xa4\xb8\x16\xbb\xeb\xb8\x85\xeb\x28\x6d\xc3\x7d\x3d\x3c\xc0\x7e\x3c\x99\xf9\xb6\xfc\xc9\xea\xfa\xa4\x09\x36\x1e\xd0\x55\xf5\xce\x7e\x79\x30\x01\x50\x49\x6e\x81\x94\xdc\x7c\x23\x36\x17\xc0\x84\x03\xa3\x3d\xa3\xa8\xee\x26\x53\xaf\xc8\xc9\x7d\x78\x08\xe2\x1b\xe9\xf8\xcb\x7e\x1c\x74\xb5\xaa\xef\xd4\xd1\x6f\x90\xb6\x3b\x48\x12\x0e\xf9\x3b\xdc\xcf\xa1\x42\x67\x72\xa6\x57\x0a\xc4\x05\x92\xc2\x25\x44\x84\xcb\x6d\x9c\x6e\xf0\x11\x23\xd0\xca\x6f\xfc\x1f\x56\xd3\x22\x1a\xfb\xad\xa8\xec\x1e\x27\x1f\x8d\xb1\xf1\x7f\x5e\x98\x1d\x99\x13\xfe\xf4\xe3\xcf\x7f\x5a\x7f\xf8\xee\xeb\xba\xbf\x4b\x1d\x31\xf3\x9b\x81\xf1\x86\x27\x22\xea\x44\xa2\x9c\x81\x6e\x2b\xa6\x92\xbf\xbe\x6f\xb1\x49\x9c\x02\x85\xc1\x16\xe2\x5e\xb8\xcc\xa8\xe4\xc3\xab\xf6\x7f\xd6\x43\xb9\x70\xe2\xf5\xfb\xbb\x07\x1a\xea\xb8\xc6\x7e\x5e\x18\x17\xf2\x01\xf3\xcd\x23\xfe\xff\x61\xf1\x9b\x86\xc5\x77\xd6\x9f\xb2\x46\x53\xde\xa0\xa8\x67\xb0\x0e\x7f\x53\x24\x2d\x93\x45\x3f\x89\xae\x4b\x29\x83\x1a\x94\xda\xc9\xf7\xd1\x51\x2b\xe0\xff\xae\xc7\x77\x82\x72\x6b\x9c\xf0\x7e\x14\xdf\x8d\x51\x69\xf9\xa0\xcc\x89\x91\xf7\x30\xf0\xe6\x9d\x73\xe7\xbe\xde\x2c\xe7\x82\x13\x43\xe5\xa0\xee\xe1\x9a\xb3\xdc\x17\x1d\x8c\x5b\xf0\xed\x9c\x83\xe8\x18\x43\x18\x42\xff\x8c\x04\x40\xff\xf2\xd3\xfe\x30\xbb\x9f\x5e\xa9\xbe\xc3\x9f\xbc\x1c\x04\xca\xcb\xc9\xa0\xbc\x1c\x14\xca\xc1\xa0\x1c\x04\xca\x07\x7f\x72\xd0\x27\x2f\xe4\x4f\x5e\x40\xa0\x0c\x7a\x62\x8a\x0c\x94\x11\x48\xca\xb7\xd3\xea\x6f\x9d\x55\xfb\xb7\xa6\xee\x6f\x98\x6e\x97\x7f\xbc\xf9\x36\x9e\x5e\xce\x33\x0c\xe7\x21\x33\x94\xd5\xdc\x89\x03\x25\xb7\xbb\x65\x1b\xc1\x82\x90\x9d\x61\xbe\x3d\xef\x90\x9e\x58\x50\x5e\x70\xe4\x40\xc7\x3d\xc4\xed\x87\x29\x48\xa1\x61\x95\x0d\xe6\x24\xfd\x45\x52\x87\xd6\x2c\xef\x47\x28\x49\x56\xc4\xbb\xa1\xdc\x04\x20\x21\xaa\x76\x91\xa3\x0e\xd4\x08\x8a\x05\x22\xc2\x39\x6a\x8a\xb4\xa7\x09\x39\xe7\x19\xb6\x40\x6d\xa0\x60\x6e\x2b\xcc\xd5\x06\x06\xd2\x24\x40\x29\x17\x96\xa3\x31\x08\x52\xbb\x24\x2d\x73\xc5\x43\x49\x89\x60\xbe\xe8\xb8\xb0\xc2\xaa\x13\x51\xd0\x0f\xb0\x56\xed\xc9\xea\x8a\x02\x83\xd2\xfb\x75\x29\x5d\xcf\xec\x91\x06\x99\x60\x84\xfa\x4a\x76\x43\x76\xb6\xd4\xbb\x2f\x53\x49\x7a\x6a\xa9\x80\x77\xaa\xa2\x54\x7c\xc0\x66\xed\x70\xd5\x36\x28\x77\xc2\xe1\x2b\x7d\x2f\x24\x5d\x45\x98\x6b\x52\x07\x2e\xc2\x59\x02\x0e\x48\xf9\x52\x57\x2a\xf9\xcc\x6b\x21\x73\xd5\xb8\x2e\x25\x77\xc4\xbd\xfd\x97\x52\x2b\xa5\x47\x2a\xea\x81\x56\x78\x91\xa5\x7e\x92\xb0\xf9\xf1\xdf\x7f\xf8\xe9\xbb\xf7\xc1\xb9\xf3\x4e\xc9\xa6\x53\xd3\x98\x03\x9c\xcd\xd4\xe4\x93\x50\xfe\x60\xb9\x8d\x51\x6f\x47\xb6\x82\x5a\xdf\xe1\xfe\xd1\x36\x6a\xca\x28\xf2\x02\xe7\x0f\x4b\xfb\x50\xf3\xd5\x7a\xe0\xbd\xc5\x5d\x5e\xa2\xa1\xfd\x94\x46\x8b\xaf\x16\x0a\x50\xd5\x8a\x2c\x8a\x20\x80\xd8\xc0\xda\x03\x78\x10\x1c\x1c\x4a\x2b\xe6\x15\x04\x41\x5d\xcf\x9f\xde\x71\xad\x6f\xbd\xa5\xaa\x69\xf8\x2e\xb0\xd5\x0e\x99\x9b\x8e\x31\x0c\x65\xd6\x5a\xb9\x03\xb4\xd0\x59\xe4\xa7\xad\xc5\x30\x67\xe3\x7d\x5e\x36\xc1\xb9\x36\xcc\xfd\xe6\x4d\xd5\xfd\x49\x4b\xaa\x2d\x95\x52\xfe\x19\x15\x40\xbe\x33\x77\x5f\x7e\xf1\x9e\x9f\x11\x45\x52\xf5\x8d\x59\x46\x81\x5b\xe4\xcc\x26\x11\x01\xd5\x17\xb4\xa8\xbc\x67\x79\xb9\x55\xe3\xb7\x01\xa8\x7c\x62\xae\x6a\x22\xeb\x82\xa8\x51\x6b\x47\xce\x8b\x25\xed\xa8\x2e\xf6\x6d\xbe\xfd\x02\x7d\x23\x0a\x7c\x24\x63\xc4\xb2\xaa\x59\xea\x72\x9b\xf6\xfb\xb4\xa3\x35\x3f\x51\x69\xb5\xfc\xac\xd1\x7f\xf3\x7d\x67\x35\xdf\x96\x04\x78\x9d\x4a\x54\xda\x7e\x40\x6d\xd8\xfc\x72\x86\xc4\x65\x5d\x6c\x52\x2d\xfa\xb6\x4c\xfb\x9b\x4f\x2d\xa3\x6f\x32\x98\x70\x70\x1f\xb8\xca\x0e\x24\xba\x3e\xb3\xdb\xb5\x77\x64\xf9\x3f\x1a\x08\x7f\x59\xff\xfa\x1f\x31\xef\xbf\x7b\xca\xb3\xcc\x27\x1e\xbb\xc7\x60\xd8\x69\xa8\xb7\xf2\x3e\x9f\x1b\xec\xf3\x00\x4c\x3e\x7f\xdb\xca\x3b\x63\x03\x48\x4e\xfa\x73\x4f\xc3\xa6\xfc\xf2\x61\xbd\x7d\x36\xff\xe6\xcf\xad\xbc\xf3\xe6\xbc\x61\x58\xef\xbf\xec\x1c\x1a\x7d\x3a\xc6\x6d\x40\x3f\x1c\x82\x4d\xdd\xd7\xe3\x9d\x55\xa9\xfd\xba\x0c\xd3\xcb\xa9\xb0\x1c\x0b\xf5\x12\x2b\xf5\x6d\xe1\x79\xd0\x62\xe2\x9f\xf6\x38\xe6\xea\xdf\x9c\xab\x3b\x17\x77\x11\x0b\x7a\x1f\xae\x17\x71\xf2\x27\xeb\xc5\x40\x29\xda\x87\xeb\x05\x1b\xfa\xf6\x7a\xe1\xdf\xff\x5d\xeb\xc5\x53\xa8\x74\x3e\xe1\x7a\x54\xdc\xa6\x67\x16\x4e\x73\x2a\x80\x54\xa0\x2c\x14\x22\x6f\xd0\xe4\x21\x90\x83\xf8\xdb\x37\x56\x34\xd1\x89\x24\x94\xc1\x2e\x0f\x5a\x86\x32\x61\x76\x28\x55\x1e\x1e\x89\x3e\x51\xa6\x7a\xff\x74\x7e\xbd\x2d\x1d\xe4\x11\x38\x37\x27\xa3\x11\x5e\xdb\x61\x83\xfb\x75\xae\xad\xf8\x2d\xf8\xa4\x93\x0a\x0c\x54\xdc\x9c\xf8\xde\x5b\x94\x9a\x6f\x34\x29\xc6\x3e\x58\xb8\x5f\xb6\x71\x94\x26\x1f\x82\xc2\x8c\x34\xa3\x9e\x83\xf6\x7d\xc9\x97\xc3\x45\x2d\x79\x5f\x1e\xbe\x5f\xce\xb3\x58\x00\x0a\x34\x38\xdb\xdd\x97\xf3\x5a\x10\x5d\xf1\x11\xd2\x6d\xa6\xd6\xc6\x56\x91\x5a\x03\x39\xf0\x54\x92\x2b\x4f\x5d\xc1\x86\x97\x7d\xa3\x2a\x23\x41\xa5\x43\x81\x3f\x16\xd5\xd7\x97\xa6\x6e\x81\xe4\xab\x64\x28\x95\x0a\x75\x35\x17\x28\xe7\x8f\xbc\x2d\xb5\x9f\xe3\x18\xa1\x38\x50\x0b\xaf\xc8\x71\xa8\x9b\x41\x03\x51\x67\xa2\xa2\xf0\x1f\xd3\x67\x20\x0a\x8f\xf2\xe4\x2b\x24\x57\xa6\xa5\xd2\xca\x55\xcf\x0d\xd2\x8d\xe4\x56\x5e\x5f\xcc\xf7\x5c\x08\xef\xcf\x35\x0e\x9a\x8d\x92\xde\x28\xfe\x9e\x7b\x07\x5a\x66\x3d\xaf\x45\xfe\x05\x09\x3e\x04\xe6\x18\xd4\x22\x6b\xaf\x73\xa7\xb0\xbd\x06\x93\xc5\xc2\x4c\x33\x1f\xe8\xba\xf0\x41\x45\x1a\x53\xcb\xbc\x89\x4f\x46\xb3\x3d\x8d\xe6\x0f\x51\x52\x55\x66\xea\x2d\x6f\x8d\xb2\x88\xf7\x74\xfa\x41\x8f\x2d\x34\x4c\x67\x3f\x68\xfa\xf2\xba\x48\x77\x3b\x76\xae\x95\x64\xea\x77\x05\xde\x02\x46\xb3\x3a\xa9\x67\x29\x59\x8f\x12\x60\xdb\x16\x54\xf2\x91\x6d\x41\x7b\xd0\x19\xb8\x5d\x53\xdd\xc2\xac\xeb\x62\xa4\x70\x6c\x6b\xa5\xbd\xb2\x91\x7b\x65\x7c\xa3\x55\x7d\xdb\x6a\xb4\x79\x6f\xd1\xd6\x05\x09\xc7\x6a\xac\x52\x98\xe4\x90\x9a\x97\x93\x81\x31\x1f\x25\x4e\x48\x98\xb2\x90\xaa\x74\x12\xe0\x8d\x4a\xed\x93\x6a\xab\x9b\xff\x15\x85\x8f\x35\x19\xd0\xb5\xfe\xd8\x95\xd8\xa8\x65\x10\x70\x35\xb6\xa5\xe5\x68\x35\xe8\x79\x8b\x3b\x03\x19\xbd\xf7\x6e\xab\x1d\xad\x56\x4b\x42\xa2\x19\x0a\x0b\xe2\x59\x1b\x78\xe8\xa2\xbc\x28\x2b\x4b\xc9\xf1\xa4\x83\x24\x45\xfe\x60\x6e\x0b\xc2\xd8\xcc\xab\x01\xae\x50\x57\xd6\x0b\xe6\x5f\xb4\x56\x27\xf5\x77\x25\xeb\x65\x8f\xa7\xb6\xa3\xb9\x13\x5b\xc3\x02\x2c\xbf\xbd\x95\x44\xe7\xb2\x82\x88\xab\x6e\x20\xbc\x2a\x96\xda\x86\x47\x0c\xc9\x48\xa4\xa8\xc9\xdc\x3e\x03\x92\x59\x82\x49\x9f\x78\xcd\x0e\x2a\x0a\x62\xd5\xa0\xfd\xbf\xc2\x24\x36\x69\xab\xdb\x9f\xb5\x6d\xcc\x93\xb6\x34\x5e\x5f\xba\x4f\xed\x39\xee\x4f\xc2\xde\xbe\x0f\x8b\x8f\xe5\x4f\xbe\xb3\xf1\x14\x92\x9d\xf3\x1f\x5c\xfc\x04\xfb\xb3\x6f\xf5\x05\x5c\x98\x12\x4c\xa9\x05\xfa\xaa\x48\xf2\xaa\xa6\x03\x70\x30\xb0\xd0\x62\x4e\xce\xb9\x2d\x93\x62\xe7\x74\x13\xda\xbc\xe5\x5b\x3e\xf7\xf1\x56\x52\xf3\x61\x5e\x3a\x79\x47\x8b\xa6\xa9\x47\x9d\xec\x64\x7e\x0d\x1c\x36\x66\x98\x35\x26\x49\x41\xc8\x77\xd4\xa4\x44\xfd\x07\xcb\x3f\xb0\xbf\x52\xf1\x11\x65\x20\xa8\x02\x89\x9b\x27\x87\x60\x09\xce\xc7\xd4\x73\xe0\xc0\x74\xc6\xce\x7e\x56\x03\x2d\x51\x40\xb2\xb4\x11\xda\xc4\x76\x97\x3c\x62\x62\x0d\x1e\x0a\xe8\xdd\x35\x89\xf5\xc8\x08\x09\xf3\x9f\xc3\x36\x3b\xb0\x3c\xcc\x3e\x0b\x01\x4e\x64\xa0\x09\xae\x08\xbb\x04\xeb\xc1\x3c\xf7\xad\x7e\x87\x1c\x1d\x9f\xce\xa0\x15\xbe\x93\x08\x55\x91\x03\x80\x34\x5d\xfc\xb7\x40\xcd\xcd\x47\xb0\xb6\x9e\xa4\x97\xcd\x50\xa0\x09\xc2\xaa\xa6\x87\x0c\x43\xff\x15\x26\x46\x7d\x1a\x9c\x1f\x01\x7d\x44\xfb\x11\x6d\x6d\xa0\xeb\xf2\x65\xc7\xc0\xbe\x9a\x73\x65\x5a\x7c\x62\x2a\xb9\xb1\x7d\xc8\x1e\x88\x80\x41\xa0\xa6\xd6\x27\x9d\x19\x32\xfa\x10\x10\x86\x52\x81\x00\x13\x32\x71\x55\x02\xda\xb3\xd4\x79\x7e\x1a\x2b\x12\xbf\x5a\xdb\xba\x68\x1f\x69\x28\x76\x37\x4b\x63\xa4\xb1\xc9\x4c\x44\xeb\x53\x72\x0f\x9c\xe4\x47\x3a\x12\xac\x91\x0a\x9f\x37\x6f\x88\x73\x25\x08\x81\x20\xe7\x4b\x65\x4c\xbc\x85\xf3\xfa\x72\x80\xbb\x48\xcb\x42\xc4\xd4\x85\xec\xfa\xcb\x00\xc1\xfc\x58\x85\x59\x93\xb1\x2e\xe2\x83\xa8\x66\x6c\xe3\x39\x61\x4c\xfe\x2d\xf7\x15\xa6\x37\xc1\x4b\x2d\x81\x5b\x2a\xfb\x76\xe1\x7b\x3c\x49\xfc\x50\x18\x8d\x21\x39\xc1\x56\x87\x85\x52\x69\xd2\x54\x1f\x6a\x84\xe2\x94\x79\x25\xaf\x3a\xd4\xb8\xa7\xc6\xb6\x09\xfc\xce\xac\x11\xcd\xd1\x44\xda\xa2\x12\xf4\x6d\x80\x9d\xc0\x3e\x17\x32\x1a\xe9\xa1\x9a\xb0\xa8\x5c\x82\xcf\x43\xcb\x2e\x20\xab\xd8\x9a\x51\xeb\x18\xd0\x13\xd1\xd7\x97\x99\x67\xaa\xdd\x56\x35\xc8\xc4\x41\xdf\x00\x25\x1b\x88\x53\xa1\xa0\x15\x55\x43\x78\xbf\x1b\x64\x7c\x81\x0a\xf6\x95\x00\x91\x21\x5f\x5d\xf3\xdc\x10\x7e\xea\x85\xa3\xa8\xcd\x87\x98\x5f\x79\x8c\xf9\x81\x83\xd1\xc7\xbf\xf9\xa8\x1a\x5b\x25\x44\xa8\xce\xa4\x00\x56\x23\x9b\x9c\xfa\x0c\x81\xcc\x6a\x6d\x63\xf1\x83\x21\x4b\x20\xbb\x0e\x44\xb7\x65\x27\x1a\x75\xb4\xbd\x83\xee\x78\x90\xe3\x01\x1f\x8e\xaf\xdc\xbe\x3c\x0e\x5f\x8e\x06\xf0\xa1\x0b\xbf\xc2\x37\x7e\xb8\x37\xe4\x0d\xf8\xf9\xf1\xe3\xf8\xf3\x71\x1c\xcf\xe3\x8d\xb9\x2f\x0d\xbc\x80\x1b\xcd\x60\xe3\x64\x98\x54\x10\xad\xc2\xbf\x08\x8a\xb6\xc1\xef\x61\x71\xc6\xa7\xfb\xb7\xcb\xfd\x94\xe5\x6c\x26\x3e\xa1\x5c\x0e\x91\xd7\x38\x40\x82\x4f\xc8\xcf\x03\xaa\x0b\xad\xdd\x3f\xdd\xbf\xbf\xec\x0f\xe7\x9d\xad\x7d\xb6\xa0\x3c\x67\x18\x3e\x12\x8c\x94\x3c\xf8\x7a\x6e\x40\xea\xfb\xdc\x06\xfe\xc5\x4d\x61\x1d\x89\xf1\xb7\x02\x55\x85\x45\xa7\x25\xcd\xb1\x64\xb8\xdd\x42\xec\x25\x88\x04\x32\x95\x1c\xb0\x99\x75\xdf\xd6\xa0\x53\x47\x22\x83\x3c\x6e\x6e\x17\x3e\xd8\xe5\xc6\xe8\x09\xcb\xfe\x2d\x14\x3c\x02\xd5\xab\x49\x88\xcd\xd2\xd6\x77\x1b\x31\xa5\xea\x4d\x0c\x3b\x63\xaf\x35\xcd\x5a\x10\x10\xb4\x99\xd7\xa5\x6a\x4d\x22\x05\x02\x95\xc3\xb8\xfd\xf6\x00\xd9\xcc\x79\xf3\x0b\x2b\xd8\x78\x2d\x95\x81\x52\x92\x4f\x0d\x86\xfe\xd4\x85\x4f\x08\x19\xcd\xe5\x08\x0a\xcc\x96\xa9\xd0\x38\x1b\x59\xfc\x23\x40\x79\x84\x37\xda\xb1\xc0\x95\xa3\x78\x3c\x0a\x23\xb4\x01\x65\x15\x34\x12\x80\xd1\x13\x85\x5f\xe9\x30\x8a\x8e\xd7\x17\xad\x2d\x8d\xd9\xae\x5a\xdb\x6d\xe9\x6d\xb8\x03\x77\xf3\x9f\xbf\xe1\x0f\x75\x6e\xb8\xce\x71\xf1\xfd\xb8\x9f\x1b\x9d\xd3\x06\xd7\x90\xc5\x18\x71\x07\x7b\xdc\xd2\xb5\x4e\x6f\xeb\xf5\x45\x46\xf5\x15\xa5\x5c\xbe\xd9\x14\x1f\x7a\x6a\x3e\x42\x4e\xcf\x8d\x49\x1f\xfa\x59\xe7\x3f\x47\xec\x9f\x80\x08\x6a\xf9\xf4\x52\x7a\x2f\xa9\xe7\xbc\x92\xc8\xae\x6d\x85\xd6\xcf\xe0\x28\xde\x17\x5f\xa0\x08\xe4\x5f\x4c\x0f\x90\x3c\x3e\x06\xdb\x92\x05\xe6\x1f\x61\x58\x1d\xde\x90\x1b\xa2\x15\xe1\xda\x01\x05\x69\xf7\xab\x7d\xd1\x01\x5d\xc2\xeb\x8b\x5f\x3e\x1d\xd5\xf0\x4a\x51\x6f\x44\xaf\x84\x9b\x52\xd5\x93\xe0\xd7\x47\x34\x55\x0c\xd7\xa5\x55\x4d\x9a\x1b\xc5\x8d\xdc\x86\xeb\x24\x6a\xc3\xfd\x20\xea\xea\xc6\x72\xa3\xf3\xcb\xf5\x7d\x9e\x31\xf1\xc1\xda\x67\xff\x59\xcc\x2e\x9b\x32\xbc\x04\x5d\x6f\x52\xe6\x08\xf9\x28\x45\x0e\xdd\x84\x7a\xe4\x82\x19\x1d\x14\x21\x6b\xa9\xb7\x01\x3c\x57\xa5\x5a\x3a\x34\x53\x42\xfd\xbf\x55\xd0\x26\x89\x24\xcd\x3d\x4d\x5f\xea\xf2\xba\x98\x81\x85\x12\xa8\xe1\x91\x48\xbb\xb9\xe3\xdf\x15\x4f\xec\x0f\x0c\xe2\xa3\x9c\x84\xcc\x06\xeb\xbd\x27\xbc\x6f\x46\x62\x0f\x7d\xf6\xea\xe7\xd3\xab\x3f\xb1\x13\xa3\xfa\xf6\x36\x57\x64\x29\x72\x07\x70\x91\xbe\x33\xf8\xa1\xdc\xa5\x0a\x25\xf8\x45\xc4\x8f\xc2\x41\x85\x1a\xfd\x12\xa6\x67\xd0\x7f\x42\x11\xb2\x13\xa6\x32\x7c\x6f\xe8\x1b\xa1\xc6\x10\xff\x5f\x04\x25\x68\x60\x6a\x4e\xc2\x17\x82\x8f\x16\x85\x20\xe4\x7c\x75\xc7\x16\x26\x6a\x00\x45\x94\xa4\xbd\xcd\xbb\x01\x80\xde\x4e\x84\x38\x50\x26\x33\xef\xb8\xd1\xde\x76\x14\xb7\x8f\xf9\xa5\x6e\x35\xea\xcd\x10\x9d\x2f\x5b\x65\xd0\xac\x24\x29\xb7\x4c\x31\x7b\xf0\xc4\xb4\x7c\xa0\xec\xa8\x3f\xd3\x49\xff\xc2\x02\x15\x42\xaf\x16\x26\x04\x51\x0e\x8f\xd5\x15\x68\xda\x8f\xc9\xec\xff\xfa\xe7\x1f\xff\x5f\xf9\xbf\x9e\x02\xe2\x5f\xdf\x48\x15\xf6\x9a\xaf\x5d\x2b\xd9\x3c\xa9\x38\x7e\xac\x6a\xbe\x94\xfb\xf6\x6c\x83\x69\xaf\xd0\x61\x22\x4b\x87\x8d\xb8\xbd\x6d\x61\x94\x64\xd1\x39\x49\x0d\x15\x75\x82\xc1\x8f\x68\x01\x36\x66\x01\xb3\xce\xb9\x9f\x1f\xee\x5f\xde\xcf\x38\x5a\xd9\x2c\x23\xdb\xc3\x72\x59\x59\x69\xa2\x68\x86\xa9\x13\x68\x5a\xcb\xcd\x3f\x50\x86\x01\x13\x35\x8a\xc2\x77\xb2\x86\xf8\x84\x23\xa5\x88\xdb\x45\x05\xfc\xbf\xe7\xc7\xfd\xcd\x21\xe7\xa9\xdb\x40\x3e\xc5\x4d\xc2\x02\x76\x8f\x96\xf7\xa1\x90\x1b\xf4\x9d\x6e\xf4\xf0\x1e\xc6\xd5\x7d\xa6\x9b\x7e\x12\x93\xf9\x9f\xf2\xf5\x49\x0f\xf1\xeb\xb3\x1e\xe2\xe3\x6e\x3d\x6b\x72\xab\x8c\x89\x28\x2a\xf6\x63\x2e\x50\xb8\x72\x1e\x70\x38\xef\x27\x45\xd0\x0d\xcb\x80\xc9\xd6\x12\x3e\xb7\x1d\xc9\x83\xad\x90\x6b\xcf\x6d\xb6\xa5\xcc\x4d\x80\x2b\xf0\xdf\xca\xfc\xc5\xa1\xaf\x2f\x7d\x8c\x54\x43\x5a\xb7\x73\x43\x6b\x6e\xbc\x20\x8c\x1f\x90\x3f\xff\x00\xc0\x6a\xb3\x2d\xfb\xba\xc2\x5f\xca\x7e\x7c\xcb\xa3\xa1\x57\x9e\x70\xca\xeb\x8b\xc8\xb0\xb7\x0d\xa3\x97\xed\xd0\x51\x63\xe3\x49\x61\xff\xf9\x92\xb8\xe3\x5f\xb7\x96\x8c\x15\x08\xe7\x71\x71\x6a\x71\x3f\xc7\x4a\x6a\x1d\x9c\xf0\x90\xc2\x4f\xa3\xec\x0b\xf8\xf8\x76\x94\x8f\x52\x4e\x8c\x51\x39\x13\x49\xb3\xad\xde\xdc\xb0\x55\x33\x22\x15\x71\x3b\xf1\x98\xf1\x94\xed\xac\x7a\x88\xa7\xfc\x52\xcf\x07\x3e\x71\x8f\xe4\x32\xaf\x25\xc8\x3b\x96\x9a\xd7\x45\xc1\x48\x07\xdc\x6a\x88\xac\x4b\x5b\xb1\xa6\x9b\x80\x6b\x0d\x14\x3d\x8b\xf9\x00\x9e\x7d\xf3\x1b\x06\x21\x5e\x4f\xd6\x2f\x07\xbf\xd3\x40\xda\x89\x94\x37\x2c\xfc\x35\x16\x5e\xf8\x33\x1f\xba\x54\x85\x3c\x38\x3d\x88\xa1\xb7\x90\x12\x11\xf0\x36\x14\xdb\x0d\xf5\x03\x59\xa0\x27\xe7\xf6\xae\x2f\xfc\xb2\xfb\xf7\x0a\xb1\x16\x23\x1d\x7f\x07\x5b\x67\xf5\x2d\x8f\x53\x61\xa4\x78\x5f\x7d\xde\xf1\x6b\xbe\xc1\x3e\x19\xea\xbf\xa7\x9d\x7e\x09\x43\x7d\xff\xd4\x63\xf8\x64\x5b\x99\x4f\x51\xfc\xaf\x27\x40\x63\xda\x4c\x25\x77\xd6\x8f\x33\x2e\xdf\xb6\x85\xc1\xc1\xa8\x00\xad\x2c\x97\x48\x95\x45\x4e\x44\xb1\xb4\xad\x26\x14\xb1\x37\x64\xb3\xa2\xaa\x40\xa1\x1d\x8f\x72\xbc\x02\x8a\xfc\xb7\x07\xbd\xbe\xb4\xde\x52\xc5\x0c\x21\x0b\xb9\x81\x96\x19\x79\x7f\x48\x53\x96\x83\x24\xa7\x16\xbe\x0f\x52\x73\xa1\x2c\xa9\x1c\xa8\x9c\xb0\x8e\xef\x00\x9b\xca\x72\x91\x2c\xe5\xd7\x36\x7e\xf9\xed\xad\xab\xce\x43\xac\x11\xf8\xe1\xd4\x35\xe4\x2b\x4e\x55\x06\xe3\x6a\x24\xbe\xfb\x42\x2d\xb4\xa7\x81\x48\xa4\x16\x5b\xd1\x97\x36\x41\x53\xa9\x89\x51\x99\x5a\x22\xb6\xa8\xba\x81\xce\xf1\x7e\x1b\xf7\x5b\x5b\x1e\x3e\x9e\xdf\x6f\x0b\xe1\x2f\x58\xbe\x40\x6b\x30\xbd\xbf\x17\xa1\x9c\x04\x42\x3f\xeb\x42\xc8\x29\xe4\x18\x83\xe4\x00\x15\x95\x76\xd9\x08\xa4\x47\x4e\xde\xf4\xc8\xc3\x1f\xa2\x1c\x94\x8a\x08\x1d\x38\xd0\x07\x54\xa0\xa3\x21\x43\x93\x0e\x2e\xf5\x10\xad\x02\x24\x9a\x6a\xd1\x20\xda\xf6\xdd\x18\x1c\xdd\x1d\xfc\x63\x33\xa7\xd1\x82\x0a\x0a\x87\xb8\x61\xec\xd3\xd6\x17\x05\xd4\x06\x20\x26\x9c\xee\x4c\xf8\xf5\x4e\x30\xf8\xfb\xa7\xd7\x2f\x7f\x68\x7e\x7d\x3e\x65\x18\xbe\xda\x69\xc0\xb5\x96\xda\xec\xeb\xcc\x49\xfb\xad\x79\xf7\x76\x1a\xb6\x62\xc4\x0b\x43\x54\x01\x94\x98\x24\x86\xab\x47\x11\xc9\x0d\x60\xe8\xd0\x55\x07\xb5\x17\xcd\x79\x3b\x24\x2f\xec\x17\xc4\xae\xfe\xfd\x4d\x34\xbb\x93\x25\x37\x08\x99\x12\x66\x11\x40\x5e\x9b\x7b\x78\x9d\xb5\x3f\xa2\x7d\x91\x30\x23\x2e\xd8\xda\x97\x7a\x23\x33\x8d\xcc\x14\xad\x06\x11\x7e\xd9\xd0\x47\x8c\xbe\x4a\x61\x61\xd3\x62\x76\x5b\xaa\x6f\x40\xbe\xf9\xd6\xac\x37\x41\xd5\x69\xcd\x17\xbf\x83\x76\xde\x7f\x1c\xfc\xa5\x9e\x34\x83\xf6\x58\xd7\x80\x0b\x9c\xcf\x71\x13\xb5\x75\x01\x9d\x60\xc3\x78\x56\xf7\xa5\x21\x01\xe6\x3b\x0c\xbb\xa8\xfb\xd3\xf8\xb3\x1c\x40\xe6\x7e\x3c\xc4\xef\xc0\xff\xf2\xb7\x62\xb7\x2e\x7f\xbf\x58\xf4\xd7\xa7\xc0\xfd\xd7\xf2\x51\x45\x75\x6e\x6e\x8a\x95\x9b\x40\x9a\xf0\x71\x99\xa2\x5e\x4c\x48\x00\x2d\x87\x06\x50\x23\x73\x92\x00\x5d\x07\x37\x7d\x4e\xff\xd6\x42\xe7\x5d\xfa\xa0\xdc\x16\xde\x3a\x89\x7c\xf0\x23\xe1\x4f\x37\x6d\xed\x6a\xfe\x42\xb4\x69\x08\xd6\x1c\x2a\x33\x3b\x8a\x4b\xe6\x5d\x8d\x66\x0f\x75\x9a\x5b\x53\x8c\x29\x28\x3c\x37\x52\x62\xec\xc6\xb2\x7e\x95\x4d\xc0\xb4\x6a\x28\x7f\x54\xdd\xe3\xae\xca\x6d\x11\x6b\x2b\xb1\x61\xd5\x9d\xf1\xea\x3b\x71\x56\xbf\xfc\xc5\xaf\xcf\xdd\x1e\xcc\x18\x1a\x5c\x90\x1c\x61\x39\x28\x3b\x2a\xeb\x30\x7b\x3c\x50\xd0\xd8\xe2\xb1\x2d\x67\x3c\xcc\x58\xc1\xeb\xda\x64\xf5\xeb\x54\x7f\xae\x4e\x86\x32\xe5\x73\xc9\xb7\x9e\x4b\xfc\xfc\xfe\xe9\xea\xf0\x14\xea\xfe\x5a\xff\xc7\x23\x79\x8f\xb4\x7c\x2b\x23\x5f\x97\x9e\xcb\xad\xe7\x12\x44\x71\x93\x05\x81\x8f\x6c\x50\x0f\xa4\x4e\x37\x3f\xe8\xea\x67\xf8\x69\xe0\x8a\xc3\x09\x0f\x74\x50\x77\x92\xa8\x7f\x20\xd8\xd2\xe5\xb7\xac\xab\x4f\x31\xbd\xaf\x4f\x28\x95\x87\x80\x94\xe9\xf0\xe1\x5a\xae\xea\xbd\x32\x87\x5d\x97\x6a\x7a\x6b\xb3\x63\xb8\xea\x68\xaf\x38\xa6\x58\xbd\x59\x83\x08\xa1\xdd\x16\xff\x24\x6a\xaf\x2f\x4d\x4a\x9a\x6d\xdc\x16\x3f\x41\x73\xc5\x89\x8b\xe6\xca\xaf\xbc\xe5\xdb\xa2\xb9\xe0\x3b\xff\xc9\xef\x66\x76\x5b\x7a\x5c\xab\x2f\x84\xb3\xa8\x5f\xd4\x6e\xd2\x0c\x17\x1d\x7a\x5d\xfc\x67\x9b\x3d\x8c\x89\x6f\x5c\x5d\xaa\xb4\x68\x47\xcf\x76\x34\xda\xe9\xd1\x4e\x8f\x76\x46\xb1\x37\xed\x5c\xee\x0d\x7d\xd2\xa3\x4f\x21\xbe\xaf\xfd\x0e\xda\x2d\x2d\x55\xd2\xb0\x41\x31\x7e\xb0\x72\x17\xee\x6e\xa9\xa7\xb5\xe0\x63\xec\xa6\xbd\x6f\xde\xdd\x3d\xf9\xef\x7d\xab\xfe\x1d\x0f\x0c\xe6\x5a\x84\x03\x5e\x5f\x7a\xb6\x34\x4b\xf9\x45\xa3\x80\x7f\xc4\xd1\xbf\xba\xe1\xa3\x59\xef\xc8\x56\x53\x05\x74\x52\x50\x8b\x3f\x12\x48\x82\x54\x2c\xcd\x7a\xa2\xc5\x29\x51\xe2\x06\xa1\xaf\x10\xe4\xcf\x69\xdb\x82\xaa\x52\x16\x42\xc2\x31\xb8\xdc\x96\x66\x6d\xf5\x5f\x8b\xdc\x34\xb7\xad\x52\x72\x48\x28\x13\x03\xed\x70\x72\x58\xcf\xba\xf3\x5a\xaf\x2f\x53\x35\xcd\xe0\xd3\x28\x29\xca\xd4\xe2\x26\xbe\x54\xdc\x46\x2f\xd4\x35\x84\x40\xca\x75\x91\xd1\x6e\xcb\x28\xf9\xcd\x95\x6a\x5c\xa9\xbd\xbd\x12\x5a\xd8\x8f\x46\xff\x59\xed\xa2\xa7\x98\xe6\xd7\x27\xe4\x85\x66\x3b\x51\x66\xaa\xbe\xba\xf7\xad\xd7\x64\x2c\x51\x62\x08\x79\x17\xa8\x6f\x8d\xa3\x4e\x78\xf2\x36\x50\xc6\xbc\x93\x03\x58\xa0\x5f\x00\x91\xf0\x96\xfa\x59\x75\xce\x2f\x07\x40\x43\x93\x2f\x09\x26\x34\x25\x31\x58\x9d\x5e\xfb\x9b\xc2\xad\x9d\x82\x8e\xe4\xf4\x07\x63\x39\xcc\x65\x91\x83\x91\x9b\x10\x52\xd4\xf7\x0d\xc2\x1a\x08\x09\x26\x49\x34\xb9\xd2\xed\xe0\xc6\x28\x60\xe6\x00\x84\x7a\x05\x11\xfc\x86\xfa\x68\x6a\x2c\x5d\x36\x72\x74\x8d\x28\x5f\xd3\x43\xbe\x03\x74\x31\x63\x3f\xf8\x69\x0e\xa1\x3f\x09\x86\x08\xa0\x13\x42\x89\x7f\x2f\x4c\xb3\xad\x02\x3a\x4c\x89\xc0\xfb\xfd\xc1\x98\xc6\xd4\x7d\x61\x52\x2d\x38\x06\x85\xb9\x3b\xf8\xdd\x9c\x05\x47\x69\x43\xa8\xe2\x40\xd9\x93\x9a\x73\x54\x4e\xa0\x3c\x03\xe0\x13\xee\x3d\xa4\xd9\x36\x4d\x51\x82\x9a\x50\x16\x58\x7b\xaa\x93\x71\x82\x4a\x4d\x8e\x92\x34\xb4\x06\xcb\x85\x05\xa8\xd5\x22\xf6\x9b\x96\x60\xaa\x26\x77\x57\x41\x08\x01\xa3\x9f\xac\xce\xcd\x0e\xa8\x54\x94\xfe\x0f\x5f\x9d\x49\x7a\x0b\xe4\x0f\x3d\x30\xc4\xbb\x21\x98\x80\x2e\x15\x06\x7f\xc8\xd8\x88\xb2\x74\x4d\xd0\x14\x14\x14\xe4\x46\x24\x43\x43\xf5\x63\x2d\x03\xd2\xef\x10\x23\x0b\x71\xab\xbd\x1e\x74\x83\xd2\x52\x54\x75\x27\xc8\xee\x94\x43\xae\x00\x59\xf9\x24\x20\x72\x49\xac\xc6\xa7\x9e\xcd\x86\xa0\x13\xf4\x9c\x1a\xa4\x83\xcc\x2e\x9b\x34\x43\x19\x8a\x1b\x63\x3d\xa4\xba\x08\xad\x92\x23\xcf\x39\x0e\x5e\x97\x71\x84\x7f\x22\x7b\x0f\x3a\x23\xe4\x51\x49\x12\xdf\x28\x29\xd4\xd2\x21\xd0\x8f\xab\x03\x5f\x0f\xf2\x6c\x42\x58\x30\xa1\xb3\x5b\x2a\xa2\x80\xc5\xb5\x90\x8e\x70\x97\x1e\x8a\x41\x70\x33\xe4\x10\x97\x64\x05\x77\xf0\xd3\xe5\x64\x65\xa5\x7e\xfc\x56\xc0\x28\x5f\xcc\x17\xc2\x20\xed\x72\x03\x69\x03\x70\x1b\xd4\xe5\xd2\x18\x33\x0e\x32\xec\x2f\x91\xf2\x58\x50\x47\x0c\xd2\x8f\x47\x82\x93\x53\xf4\xcc\x2c\x38\x0c\xca\xa1\x83\xd4\xf2\x5a\x33\xf4\xe2\x2c\x18\x37\xcd\xff\x18\x93\x0b\xf4\xc5\x20\x0e\xff\x72\x6a\xab\x69\x10\x58\x0c\x4d\xc3\x5d\x60\x88\xa4\x3c\xea\x5b\xe8\xa1\xec\x92\xef\xc2\x44\x99\xc4\x25\xcb\x48\x83\xca\x5c\xe4\x95\x4c\xa1\xd3\x55\x08\x29\xb4\x14\xe2\x45\x91\x98\x8a\x9a\xa0\x94\x51\x89\xa6\xf8\x97\x52\x72\xe4\x82\x42\x50\xb8\xe0\x5d\xbb\xc5\x68\x0d\x34\x52\x7b\x0d\xc6\x04\xd8\x61\xd6\xf6\xd2\x58\x91\x5c\x73\xaa\xc1\x23\x50\x91\x6e\x07\x85\x33\xe2\xde\x51\xce\x4d\x6a\x2c\x6c\x77\xb6\xfa\x83\xdc\x96\xde\x56\x60\x5f\x36\x2d\x3d\x4d\x77\x9c\x21\xaf\xe2\x7b\xa5\x4a\xaa\x39\xd9\x24\xf6\x08\x1e\xb5\x19\x72\x15\x93\x54\xf5\x5a\xf0\x1b\xca\x30\x30\x94\x6d\xec\xda\xc9\x4d\x4d\x59\x3f\x5b\x7b\x42\xf9\x02\x26\x28\xd4\x2a\x6c\x52\xe2\x56\xa8\x66\x4b\x86\x8f\x1d\xe1\xe5\x45\x0a\x51\xbb\x78\x59\xa4\xa4\xb8\xb0\x2a\x98\x0e\x15\x98\x15\x20\x3b\x33\x49\x15\xba\x94\x16\x38\x94\x10\xdc\x8b\x75\x0a\x7a\xa2\xb9\x41\xeb\x07\x2a\x2c\x2d\x6a\x3d\x70\x6f\x52\x48\x99\x0f\x5e\x91\xa3\x10\x0f\x6f\x17\x75\x0e\x1a\x51\xd5\x9a\x31\x84\xaa\x04\x5a\xc0\x8c\xea\x33\x40\x5f\x81\x9d\xc1\xad\x97\x80\xb8\x21\x6b\xfa\xfa\x32\x54\x53\x6d\x63\x2d\x6e\x32\xae\xa4\x15\xe9\x7d\x45\x2c\xa4\xb8\xa7\x61\x6a\xa9\x82\x2a\x8a\x02\x86\xb4\x8b\xfa\x21\x17\xcf\xa1\x05\x4a\x22\xbb\x30\xd8\xc4\x4a\x5e\x3b\x20\x36\xe0\x0d\x40\x95\x73\x4f\xc5\x36\x95\xa4\x88\xe1\x53\x8f\xdf\x57\x55\xc6\xfc\xed\x4b\xbd\x4a\x79\x65\xa0\xa0\x4f\xd4\x92\x80\x07\xb3\xb9\xf9\xe3\x23\x96\x1e\x77\x08\xe8\xb5\x70\xc2\xb1\xc1\x45\xe7\x95\x7a\x35\x59\x05\x22\x42\x2b\x79\x03\xf5\x36\x7d\x76\xcc\x8a\x1c\x6d\xbd\xc9\x6d\x91\x87\xdf\xb1\x9c\x54\x88\x94\xe8\x2a\x10\xf3\x3a\xbf\x92\xf4\x59\xc2\x6a\x3e\x25\xac\xbe\xde\x91\x65\x48\x11\x55\x92\x65\x42\xca\x22\xb1\xa6\x03\xd9\xc2\xd1\x43\x9c\x90\x4a\x1a\x67\x92\x42\xa6\x11\xfe\x9b\x48\xce\x03\xa4\x46\x3a\x6a\x01\x15\x94\x01\x2d\x05\xd9\x55\xa3\xa6\x85\x66\x88\xec\x98\xa6\xd1\x63\x88\x05\x10\x4f\x58\x26\xce\x85\x5a\x52\x39\xcc\x1b\xcc\x45\x77\x89\xf5\x80\x12\xb3\xba\x3f\xf5\x04\x1b\x4b\x74\xa4\xc6\x98\x04\x50\x57\x33\x35\x81\xfd\x08\x1a\xc6\x06\x9d\x22\xa2\x2b\x91\xc2\x44\xb6\x2a\x54\x3b\x3a\x04\x68\x02\x47\x5b\xf8\xb7\x52\x36\xb7\x39\x82\x59\xb1\x1c\xe8\x28\x28\xdb\x58\x52\x2c\x45\x69\x1c\xfa\x51\xfc\x90\x3a\x37\xfb\x50\x2b\xf5\x05\x93\x1b\x4f\x3b\x60\x5a\x58\xcd\x36\xf5\xdb\x20\x43\x0b\x66\x71\x2c\x59\x11\x93\x51\xa5\xfa\x77\x4f\xb1\xc3\xe4\x10\x3f\xdd\xfc\x61\x14\x92\xe9\xc8\x19\x0c\x4b\x56\x40\x47\x08\xcd\x90\xa8\x61\x6f\x41\xbd\x6b\x85\x0b\xd6\x52\xb9\x63\x5e\x20\xc8\x13\xd0\xd7\x20\xff\xf1\x0e\x08\xb5\x51\xca\xdd\x6e\x94\x13\x63\xb2\x03\xc9\xfd\xde\x28\x9c\x61\xe4\x1d\x80\x82\x09\x14\x70\xc4\x97\x30\x7f\xd3\x95\x59\x63\x6f\x96\x69\xbe\x71\xe6\x85\x97\xd8\xe0\x59\x45\x54\xc0\xf5\xa5\x39\xb5\xd8\x39\x4f\x6d\x21\xe8\xa9\xb1\xec\xc7\x14\x33\x66\x77\xbb\xbc\x0b\x42\x90\x3d\x74\x04\x4d\x36\x8c\xa8\x04\xfe\x41\x38\xf6\x84\x97\x80\xf9\x0a\x0c\x05\xa1\x80\x60\x0a\x0a\x15\x83\xba\x95\x3f\x3b\xff\xde\xcc\x57\x5c\x1f\x54\xc4\x8f\xc6\x9a\x23\xb9\x85\x8d\x5e\x0f\xd2\xda\xc2\xdc\x94\xe5\xe8\x53\x6c\xc2\xbe\xb5\x97\x88\x9f\x61\xbd\xd0\x99\x23\x22\x0c\x98\x09\x4d\x36\x25\xcb\x53\xed\xfb\x22\x00\x64\x93\x35\xd4\x1d\x28\xcb\xba\x51\xa1\x87\xc9\x56\x45\xa9\x5b\x12\xb8\x5d\x9d\x3b\x1d\x16\x18\x28\x5a\x14\xfe\x04\x53\x0a\x84\xbb\xb0\x2f\xe1\x06\x40\x06\x26\x25\x41\x43\x50\xdb\x19\x0b\x1f\xe4\xa0\xb0\x58\x9d\x4a\xb9\x6c\xd6\x7c\x73\xaa\x83\x32\xc3\x96\x19\x13\xda\x28\xf3\x5e\x6b\x12\x26\x28\x6c\x2b\xd4\x85\x14\x03\xc2\x91\xbc\x0c\xad\x6d\x0c\x4b\x43\x81\x56\x2b\x9b\x25\x6b\x4a\x0f\xc0\x39\xea\x3c\x67\xa5\x1e\x8d\x2a\x0b\xe3\xc8\xec\x4a\x4b\xe9\x53\x4a\x87\xef\x4a\x7e\x4e\xe9\x7e\xbd\x7b\xb6\x3d\xa7\x02\xfc\x73\xcb\xc4\x07\x43\x7b\x7e\x91\xaa\x2b\xd6\x26\xb7\x25\x83\xd3\xe9\xc0\x94\x8e\x7e\xd0\x45\x2d\x34\x2a\x21\x2a\x0a\x94\x90\x1c\x03\xdf\xf7\x15\x94\xbc\x2d\x52\x6a\xe4\x79\x5b\xe6\xdb\xd8\xa0\xbd\x4d\xdd\x5b\x1d\xbb\x08\xd1\xdd\x44\x13\x34\x37\x1f\xbb\xb9\x33\xe9\xf7\x80\x55\x68\xbd\xdf\x12\x1c\x53\xa1\xd6\xfb\xf1\xdf\x98\x3b\x80\x74\x79\x8b\xbf\x8c\x09\x3d\xd9\x31\x93\xf5\xd5\xcd\x8e\x8c\x16\xd0\x5e\x93\x24\x2d\xbf\x5e\x5e\xba\xbf\x0f\x29\x75\x65\x0e\x7b\x05\xd0\x28\x2e\xa2\x24\x2d\xa4\x32\x1c\x9a\xa1\x12\x8c\xff\xe4\x9f\xc8\xd7\x84\x0f\x2b\x26\xde\x5c\xcf\xf3\xdf\xeb\xca\xb8\x2e\xff\x74\x74\x2e\xfa\x76\x40\x63\x75\x42\xbb\x04\xaa\xc9\xd2\x21\x39\x06\xa7\x1f\x5d\x8a\x5c\x59\xa9\x61\xb3\x0e\xef\xce\x18\xd6\x47\xdf\x6e\x08\x12\x06\x1e\xa1\xcc\x3d\x58\xc8\xd4\xb6\x01\x2a\x2e\x09\x91\x0c\x80\x26\x99\x1c\x1c\xfd\x0c\x7e\xf5\x71\x10\x76\x34\xbe\x2f\xe2\x7f\x2b\x49\xc4\x4f\x67\xdd\x24\x95\x8e\x14\x1d\x24\xfd\x7d\x68\x2b\x6b\x04\xb1\x4e\xf8\x4c\x06\x3e\x36\xaf\x14\x9b\xbc\xf7\x39\x3a\xf8\xbd\x97\xb3\xe3\xf7\x9d\x7f\x8e\x2e\x59\x03\xf1\xa5\x1c\x93\xde\x69\xc7\x1f\xce\x8e\x3d\xbb\x1a\x5a\xab\x79\xc3\x92\x52\x62\xb7\x13\xb0\xd6\x71\x29\xf1\x51\x7a\xd9\x3a\x49\x13\x83\xc3\x09\xee\x68\x65\xd5\x89\x1d\xa9\x95\x92\x44\xb1\x80\x40\xa1\x06\xaf\x0d\x49\x08\x24\x4f\x27\x96\xc6\x41\x6b\x87\x10\x81\x79\x04\x20\xd7\xe5\x3e\x7e\xe4\x3e\x64\x37\x0e\x9e\xc7\xe7\xdb\xdf\x8e\xa4\x63\x7a\xbd\x19\x78\x0f\x23\x47\x1f\xc7\xeb\xd9\x05\x3a\x7d\xd4\xb4\xee\x83\x46\x2a\x85\xe4\x76\x84\x79\x81\x3f\x85\xd2\x57\x23\xe7\x4f\xbb\xec\x02\x5e\xab\x2a\xac\x3e\x3d\x5f\xe9\x7e\xbe\xe7\xcf\xe2\xed\xdf\x3f\x2d\x1d\x27\x17\x57\xab\x25\x15\xa8\x50\x53\x66\x57\x0f\x7e\x22\x93\xf0\x2a\xc0\xfe\x39\x11\x2a\x80\x8c\x23\xeb\x98\x90\x8f\x2b\x42\x82\xa6\xc5\x06\x16\xd6\x6d\x21\x62\x19\xe6\x75\xc0\xac\x50\xc4\x0a\xf0\xe9\xbd\x3a\x96\x1a\x65\xcc\x6e\xef\x40\x03\xa7\xbc\xb9\xdb\x3b\x34\x4d\xb0\x1d\x6a\x61\xa1\x82\x2f\x45\x58\xe2\x7d\xb0\x8a\xfb\xc4\xbe\x9c\x4f\xd0\xfd\x34\x54\x66\x9f\x42\xdb\x99\x86\xf1\xa0\x92\x60\xbf\x9b\xa9\xf4\x1e\xbf\x1c\x7c\xa3\xa4\x9f\xe3\xff\x59\x82\x25\x0f\xfa\xee\x91\x64\x45\xb5\x11\x0b\xa7\xdd\x20\x02\xeb\x28\x64\xab\x40\x14\x58\x12\xe3\x1a\xb6\xb5\x74\x68\x05\xd0\xd1\x68\x5b\x1d\x74\x33\x6b\x32\x37\x52\xa8\x85\x93\x35\x19\x54\xb0\x15\xde\x26\xea\x28\xca\x61\xf8\x53\x5c\x3d\x8d\xfd\x10\x94\xdd\x1b\x05\xc0\x35\x04\xd3\x4e\x1d\x90\x78\x3f\x8b\xf6\xc0\x28\xc0\x1c\xe7\x73\x51\x39\x1b\x39\xcc\x18\xfe\x62\xb2\x02\xf8\x32\x2e\x21\xdb\x4b\x8a\x42\xd3\x80\xdf\xeb\x08\xf9\x78\xba\xaf\xf5\x0c\xba\xc0\xf3\x2c\x65\x22\xb0\x49\x0f\x01\x2f\x6d\x6c\x54\xd6\x36\x5e\xc4\x06\x0d\x5f\x34\x9e\x69\xc7\x6a\x83\xba\xa7\x7b\x3a\xf0\xa0\x48\xa8\x96\x8a\xb8\x15\xee\x6d\xf1\xf1\xd3\x12\x80\x8b\xbc\xa3\xc3\x36\x08\x46\xa4\x5a\xef\x72\xdf\x30\xa0\xdd\x68\x2d\x3d\x0d\xa9\x2b\x00\x1b\xda\x57\xf7\xdc\x52\xd1\xd7\x17\x9b\xc9\xff\x3c\x4b\x52\xd3\x9b\x64\xd3\x75\x69\xa0\x38\x37\xa8\xda\x98\x40\x77\x68\xe4\x64\xa6\xac\xfc\x07\x98\x6f\xb8\x75\xe4\xed\xf8\xcb\x41\xf9\x2e\xe2\x36\xed\x3c\xc4\x17\x69\x61\x14\x73\x69\xf5\xf5\xa5\x77\xb7\x33\x67\x59\x2b\x61\xbb\xe5\x66\xd0\xee\xcb\xa8\xf8\xf2\x2d\x83\x8e\xec\x72\x14\xe7\x00\x9f\x16\x70\x14\xd4\xa4\x29\x35\x4e\x46\xd0\x0e\x28\x21\x56\xa2\x57\x20\xbc\x7a\xb8\x08\xf0\x66\xdd\x6e\x84\x25\x39\x30\xb4\x21\xe5\x4e\xfd\x8d\x14\xb9\x50\x31\xa8\x14\x01\xca\x36\x38\xc8\x59\x59\x81\xaa\xfd\x50\x3a\x17\xa8\x81\x81\x50\x84\x08\x2e\xf0\x70\x09\x13\xa5\xb0\x8d\xa8\x5b\xd4\x0e\x61\xa8\xda\xc3\x59\xaf\x29\x2a\x35\xe0\x88\xfa\x92\x3a\xe9\x4f\x04\xe1\x22\x02\xb5\xb9\x66\xef\x62\x77\xe7\x7a\x2f\x49\x4b\x3b\x05\x07\x8c\x69\x37\xce\x3d\x94\x9f\x07\xaf\x3c\xd3\x3d\x23\x31\xac\xed\x03\xcf\x6e\x92\xfb\xd8\x2c\xcd\x54\x92\x64\xc0\x2a\x7c\x9f\x93\x0d\x6c\x8b\x2d\x49\x99\xa9\xe6\x9b\x8d\xb2\xd6\x4a\xb6\x8b\x4d\x89\xd4\x82\xce\xd8\x6e\x98\x6b\xb0\xa4\x9a\x84\xda\xd9\x65\x43\x78\x9c\xe4\xd8\xb7\xa5\xc8\x27\x40\x92\x92\x9f\x81\x24\xcf\xcc\x79\x77\xb0\x96\xba\x51\x23\x55\xdf\x25\x3b\xf0\x5e\x19\x23\x6a\x68\x8f\xba\xda\xfd\xa8\xb4\x25\x78\xf8\xa1\xfa\x36\x8a\x6f\xfd\xc4\x38\x8f\xa5\xb7\x47\xe5\x6d\xe9\x57\xa0\x85\xc1\xff\x3e\xc7\x04\xa0\xd1\x4a\x9a\x50\xbd\xdc\xe1\x25\xeb\x00\x1a\xf8\x9b\x5c\x24\xd7\x65\xb4\xf2\xad\x8b\x56\x94\x00\xb1\x02\x88\x05\x40\x3a\xae\xad\x47\xfd\x0f\x06\x78\x86\x1d\x5b\xc6\xe5\xdc\xb0\x37\x92\xf9\x11\x3c\xcb\x48\xe0\x18\xb7\x45\x1a\xf4\xa5\x47\x3a\x90\xc2\xbf\xd4\x87\xc2\xc3\xbf\x2b\x41\x15\x21\xc2\xb7\xfa\x50\x28\x69\xfd\x85\x3e\x94\x37\xaf\xb5\xfd\xb1\x17\xa8\xa2\xbf\xb8\xc0\xe5\x77\xbc\x82\xc8\x28\x7f\x64\x17\xa1\xfd\xdf\xb3\x8f\x2e\xef\x5f\xe2\xb9\x97\x7e\xcf\x87\x28\x3e\x00\xff\xe0\xf6\x3f\xec\xa4\xcb\xef\x72\x89\x3f\xb6\x93\x7c\x2d\x1e\xb3\xdd\xb4\xb6\x43\xf2\xeb\x49\x8c\xeb\x26\x2d\x83\x19\xff\xb6\x54\xd1\xeb\x98\xed\xb3\xe5\xf0\x19\xed\x73\x57\x04\xb6\x52\xd2\x37\xb4\x1c\x6e\x28\x38\xf8\xa6\x5e\x84\x8e\xfc\xbe\x60\x5b\x3b\x4a\x14\xde\xe8\x45\xa8\x6f\xb1\x15\x56\x78\x19\x0f\xbc\x0c\x8f\x7d\xf2\xc0\x8e\xc0\x2e\x39\x89\x15\xde\xf4\xf4\x1b\x76\x86\xb3\xa3\xd9\xfa\x9c\xfa\x2b\x1a\xbf\xfc\x8d\xad\xbf\xa5\x94\xf8\x9d\x6f\xbd\x8c\xfc\xc7\x34\x6e\x03\x35\xc5\xb7\x06\x3c\xe1\xaf\x3b\xeb\xd7\xde\x09\x5b\x2f\xd2\x7e\xcb\x2d\xfd\xb6\xc6\x5b\xd7\xdf\xa5\xf1\xe7\x65\xcf\x5b\x9f\x60\x7c\xf8\x83\x6e\xdd\xd7\xd5\x3f\xa6\x75\x14\xc5\xcd\x76\xa7\x88\x7c\xd3\x3a\xc8\xe6\x1e\x9a\xbf\xdc\x17\xa3\x93\x92\xf0\xf1\x02\x20\xa0\x7b\xe7\x0a\x7f\xd8\x7b\xf5\xc6\x7f\xaf\xf7\xfa\x6e\xe3\x7c\xad\x7f\xc4\x78\x47\x9d\xe4\x1f\xf6\x5e\x29\x7e\x82\xc9\xfa\x47\x8c\x78\x34\xff\x87\xbd\x55\x12\xa7\xfe\x51\xaf\x15\xad\xff\xda\xe9\x7a\xf9\x1b\x7b\xfe\x8f\x7a\xb1\x9f\x6c\xd1\xcf\x08\xca\x1f\x3e\x62\xf5\x95\x31\xd2\x1c\x87\x3a\x9c\xfa\x9e\x37\xf4\xd7\xa9\x45\xda\x08\x79\xc9\x50\x26\xfb\xf4\x84\x01\xe2\x95\xa9\x49\xa1\x32\x3a\x52\x38\x0b\x2d\x88\x04\x36\x9d\x74\x36\x10\x8d\x3f\x43\x11\xe4\x76\x53\x1d\x57\x6b\xfc\x45\x75\x6c\x3c\x9d\xe6\x4c\x88\xa8\xe2\xb0\x19\x8c\x05\xc8\x26\x44\x62\x23\x94\x42\xa5\x52\x59\xe1\xbf\x59\x77\x12\x75\x58\xff\xf7\x53\x19\xd0\xf7\xcf\xea\xd0\x77\x6a\x96\x0e\x25\x6c\x8e\x90\x16\xf5\xfc\x22\x51\x87\x92\x96\xa0\x74\x00\xa5\xc6\x3c\xc5\xfb\x6d\x44\x56\x65\x6a\x42\xa4\x90\x82\xec\x55\xc8\x2a\x02\xf0\x55\xd4\xd6\x50\xa5\x2d\xd7\x64\x73\xeb\xfd\x81\x0c\xb9\x1f\x34\xd9\x88\x97\x22\xa6\x53\xa1\x1d\x57\xbc\xf5\x21\x01\x4b\x26\x19\x0b\x42\x14\xd0\x35\xb8\xdf\x04\xa8\x63\x08\xef\x66\xc9\xb0\x04\x12\xda\x7b\x53\xa9\x1e\x5a\x34\xa0\x2e\x7e\x72\x9d\x11\xd2\xcd\x94\xc8\x08\x70\x38\x4f\x5e\xc4\x0a\x7d\xdb\x0a\x32\xda\x61\x9a\x1a\xb8\x3c\xc0\x6f\x54\x6b\x5a\x26\x79\x8a\x30\x89\x3a\xa8\xcf\xb5\x06\xa1\x22\x92\xd6\xfd\x60\x12\x27\x5e\x03\xa5\x68\x87\xdc\x04\x08\x0f\x00\xcc\x0b\xd1\x78\x44\x9c\xcb\x59\xc3\x8d\x6c\x3a\x9f\x6b\x92\xfe\x88\xf5\x0a\xbc\x37\xf0\x36\x42\x85\x0b\xa7\x1a\x78\xe3\x73\x1a\x0d\xf2\xa8\x93\x72\x1f\x48\x5e\xb1\xbb\x07\xf9\xa8\xdb\x2e\xd3\x12\x94\x3b\x73\x97\x34\xe4\x91\x96\x86\x71\x9f\xe3\x0d\x2d\xc7\x3b\x0b\x28\x52\xa6\xf4\x09\xdf\x90\xbf\xa0\x03\x0e\xfe\xa5\x6e\x68\x21\x86\xc4\x7e\x0e\x92\x73\xe0\x6c\x67\xf9\x03\x5e\x29\x06\xc9\x12\xa3\x84\x90\xfc\x48\x20\x64\xbf\xb6\xc5\xa8\xe0\xcb\xfd\xc2\xea\x08\x3c\x0c\xda\x29\xa4\x2b\x11\x80\xad\x8e\x17\xc5\x00\xe4\xfd\x15\x42\x1c\x3e\xe0\x7b\x75\x42\x12\x4d\x6c\xc6\x93\x60\x34\x20\x7d\x11\x83\xa4\xec\xf7\xa1\xf3\xd9\x9a\xf7\x04\x96\xfd\xfe\xa9\xa4\xae\xb7\xf1\x28\x86\x9d\x73\x78\x52\x95\x4c\x8d\x2c\x01\x8c\x48\xbd\x77\xc2\x5a\xc0\xdf\x2f\x9b\x86\xd3\xd2\xc2\x69\x29\xa7\xca\xf2\xe9\xb3\x14\xfa\x2c\x2d\x15\x9c\xe6\x67\x2d\x93\x45\x5d\xd8\x09\xd8\xa9\xb5\x27\x5c\xc5\x77\x04\x1d\x29\x52\x91\xf3\x2c\x19\xd5\x9c\x77\x69\x19\x10\x3e\x7c\x60\x42\x98\x5f\xfa\x10\x0b\x82\x1d\xfd\x5c\xf1\xa1\xe4\x27\xb0\xeb\xf7\xcf\xe2\xd4\xf7\xb8\x15\x4d\x40\x5b\x1b\xd4\x43\xe6\xad\x59\x5b\xdd\x2f\x8c\x80\x69\xaf\xca\x99\xd6\xbb\xae\x6d\x8e\xa4\xb5\xac\xcb\x9b\x0f\x3e\xc7\x22\x16\x25\x59\xcb\x19\x76\x32\x06\x79\x51\x83\x59\xdc\xef\xeb\xeb\xd2\xc9\x2b\x51\x58\xf0\x0a\xc1\x2c\x20\xbc\x20\x16\x26\x8d\x07\xe0\x7b\x13\xea\x35\x4d\x04\xa6\x64\xa4\x56\x6f\x6c\xb8\x60\x47\xec\xb6\x37\x49\xa5\xaf\x7e\x06\xe4\x11\x15\x62\x2b\x69\xec\xfe\x9e\x06\xfe\x0e\xa9\x42\x00\x8a\x0a\x34\x26\x0b\x70\x40\x4b\xb7\x4f\x88\xdd\xc1\x01\xf8\x8b\x4e\x7c\x62\x92\x7d\xa8\x4b\x6f\xd4\xf5\x5d\x61\xad\x4f\xbd\x99\x94\xd5\x1f\x13\x19\xf1\xdb\x62\x45\x5f\x5f\x6a\x6f\xc9\xea\x58\x8b\x8f\xc1\x6e\xeb\xf2\xe6\xc3\x22\xe0\xde\xf5\x4e\xfc\xac\x21\x69\xc8\x1f\x7c\xd2\x12\x8c\xa8\x2a\x6c\xa9\xa1\x7c\xe1\xb1\x25\x6d\x3d\x62\xd5\x92\x2d\xaf\x05\xda\x98\x73\x5d\xde\x7c\x58\x64\xcc\xd7\x17\x95\xde\x10\xb1\x38\xd4\xaa\x2d\x1c\xf9\xd6\x2f\xa1\x3d\xd3\xc9\x4e\x1d\x4a\x81\x95\x75\x3b\xd0\xe9\x29\x18\xfc\xfe\x14\x7e\x00\xbe\x07\x3c\xb2\xa7\x72\x64\x5c\xfc\x2d\xff\x96\xf3\xcd\x58\xa6\xa5\x1c\x19\x33\xb5\x1e\x62\xd4\x36\x98\x34\xe9\x99\x22\x1c\x65\xac\xc5\x4a\x92\xd1\x6e\x25\xe7\x6f\x1c\x50\x86\xf7\x34\x20\x22\x39\x55\x5f\x36\x77\x0a\x3d\xe0\x2b\x4c\x76\x8c\xe4\x96\x58\x85\x5d\x46\x60\xba\x7a\xbe\xdc\x96\x92\x33\xae\xb1\xc8\x40\xba\x02\xc7\xf5\x38\xca\x8f\xf9\x6c\xb6\x3e\x81\x8a\xbe\x7f\xaa\x7a\x79\x00\xfb\xcb\xf0\xdb\x95\xd9\xaf\x4b\x15\x14\x3b\x95\xab\x7f\x10\x05\x49\x2b\x08\x79\x7d\x05\x22\x05\x59\x41\x37\xc1\x50\x20\xff\xd3\x97\x7a\x85\x1a\xa8\xf8\x33\x73\x65\xf1\x0f\x3e\xa6\x44\xbd\x9f\x36\xe8\x31\x89\x6a\x32\xdd\x7b\x4b\xa3\x5f\x55\xc1\x28\x80\x7c\x26\x74\x37\x50\xbf\xda\xb7\x45\x69\xc8\x1a\x59\xd3\x4c\x0f\x11\x1b\x03\x5a\x56\xf3\x48\x54\xc7\x33\x82\xe3\x8d\xa8\x56\xdf\x9e\x7c\x8f\xc9\x89\xfa\x54\x80\x4c\xb0\xfc\x72\x46\xe6\x56\xa3\xd8\xae\x63\x78\x94\x7e\x5d\x5a\x1d\x17\x02\xe8\xe4\xa8\xea\x42\x7d\x8a\x34\x66\x7d\x91\x9a\xd2\xde\x93\x5a\xbb\xea\x6c\x9b\x66\x60\x52\xc1\xe8\x03\x20\xec\x60\x2e\xc5\x3f\x5c\x17\xcb\xea\x73\xa9\xf3\x9c\xde\xed\xaa\x43\x36\xd4\xff\x88\x9e\x12\x2a\x85\xa9\xc6\x58\xb6\xb9\xf8\xe3\xc3\x75\xd1\x96\x21\x3f\xf9\xfa\x82\x05\x5d\xaf\x75\x96\xa8\x16\xaf\x51\x25\x16\x9a\x42\xb0\xa1\x32\xb9\x1d\xf7\x90\xb1\xad\x34\xf6\x41\x4f\x82\x0a\x9b\x66\x90\x98\x01\xe1\xd5\x01\xb5\xa8\x08\xb2\xc3\xf7\x44\xec\x5e\x43\x16\x87\x45\xec\xa7\x28\x20\x38\xd7\x58\x79\x4b\xf0\x9f\xbf\x06\x6a\xbd\x5d\x97\x86\x91\xd1\x3e\x1b\x83\xf2\x04\x22\xf9\xbe\xfe\x83\x53\xa6\x95\x09\x7d\x2f\xb9\x2e\xd6\xe5\xb6\xf4\xd1\xaf\x36\x74\x13\x24\x09\x65\x76\x1a\xbf\x6e\x38\x77\x32\xef\x31\x1b\x57\xcc\xb7\x5a\xe4\x91\x7c\x73\xce\x3d\x09\xec\x6a\x2c\x35\x6e\x9d\xcd\x46\x4c\x27\x4a\xbd\x91\x06\x86\x7a\x0f\x3a\xba\x27\xd4\x14\x15\x1f\x32\x6a\xd7\x45\x7a\xbb\xc9\x28\x57\xc1\xeb\x9b\x87\x89\x34\xa9\x6f\x5f\x22\xef\xe2\x83\xa4\x8c\x96\x6c\x8c\xeb\x22\xa3\xde\x54\xfa\x55\xc6\xdc\x04\xcc\xda\x42\x16\x0f\x63\x9e\x06\x10\x3a\x40\xd1\x51\x5a\x68\xbe\x63\xb4\xd3\x20\xc5\xd6\xb8\x2f\xc8\xb4\xf5\x6b\x11\xd9\xc8\xc2\x91\x8c\xf5\x18\xa8\x70\x45\xe9\x44\xbe\x77\x3c\xc1\xff\x42\xe6\x19\xb0\x9a\x8f\x16\xf2\xb3\x5c\xcd\xc5\x6a\x22\xe3\x79\xbf\xec\x2a\x06\xe9\xa2\x98\x3f\xad\xbb\xed\x7a\x75\xa3\x10\xd0\x44\x2a\x8e\xf5\x03\xbb\xc5\x3a\x03\xcd\x00\x11\xb6\xd4\xd5\xdf\x80\x9d\x4f\xa5\x7a\x75\xdb\x60\x2b\x6e\x03\xdb\x4c\x63\xee\x53\x92\xd9\xeb\xcb\x44\xde\x6a\x5c\x4d\xe6\x6d\xe9\xfd\xba\xf8\x87\xfe\x09\x53\x4f\x91\x67\xbf\xe9\x99\xbe\xf7\x81\x3e\xa1\x0e\x4d\x33\x26\x5b\x16\x96\xb4\x61\xca\x31\x3b\x4e\x5a\x38\xb9\xff\xc2\xcf\xd4\xca\x63\x59\xdf\xfd\xe3\xc3\x11\x8f\x67\x3e\x34\xf9\xfa\x32\x44\x93\xa2\xca\x10\x6f\x12\x92\xb6\x80\x53\xf5\xd4\x0d\x00\xc1\x4c\xd6\xf7\xb6\xe2\x80\xa2\x5b\x0f\xad\xc4\x4c\x50\x0f\xb4\xc0\x62\x91\x40\x7a\xd4\x24\xb2\xf6\xa0\x0d\xc9\xf3\x30\x53\x7d\xf5\x4d\x03\x58\x3b\x96\xf6\x35\xc1\x87\xcb\x66\x4c\xbb\x83\xc0\x9a\x84\x25\x99\xc0\xea\xcd\xaf\x09\x6e\xf1\x44\xb9\x00\xe9\x6e\x02\xb4\xe2\x9d\x84\xe4\x2b\x80\x30\x28\xee\x94\xe0\x4e\xf1\xf7\x0b\xf6\x12\x80\x65\x30\x80\x28\x6e\xc5\xda\x04\x96\x79\xca\x49\x72\xd6\xd3\xf1\xa7\xb6\x9f\x47\x1e\x64\xf5\xd1\xd8\x1e\x57\x68\xc1\x30\xc0\x6b\x2f\xe4\x3e\xb7\x10\x20\xd7\x7d\xb1\x90\x5e\x32\x37\x6b\x00\x2f\x22\xbb\x47\x22\x06\x0d\xd8\x65\x95\xb1\x2f\x70\xf7\x86\xfb\x4d\xbe\x00\xe2\x1e\x4b\xea\xcd\xbd\x51\xec\xec\xeb\xa2\x96\xd3\xd4\x5b\xd1\xb9\x1a\x09\x6e\xfb\xd6\x67\xf2\x85\xad\x5b\x2a\x83\x5a\x15\xbe\xc9\xeb\xaa\xa3\x80\x22\x40\x21\xf3\x46\x8c\x8d\xc9\xdc\x4d\x63\x97\x03\x4d\x75\x4e\xf7\xdb\x43\x1f\xc7\x7d\xcb\xa7\xd6\xb9\x3c\x65\x95\xbf\xef\x0f\x6b\xad\xa6\x31\x26\x1d\x63\xd8\x3d\x16\xb2\xb5\x9d\xd5\xca\x47\xdd\x48\xed\x07\x27\x8c\x90\xac\x71\xe4\x74\xfe\x7e\x97\x86\xaf\x2d\xd4\xa1\xa2\xd4\x99\xed\xbd\xbe\x34\xd3\x64\x99\xfe\xbb\x05\xdd\x10\x49\xeb\x40\x1f\x01\x17\x72\xa1\xd8\x81\x64\x4b\x3a\x51\x4d\xdb\xfb\x56\xa1\x93\x90\xdc\xe8\x2f\x79\x6b\xc1\x38\xa4\x39\x81\xd3\xae\xa2\xf8\x7d\xd3\x92\x10\xa6\x00\x50\x29\x87\x1a\xdc\x28\xab\x2f\x3a\x66\x6e\xa7\x57\xf7\xfa\x2b\x14\x62\x49\x28\xc6\x58\xc3\x79\x1f\x7f\x4c\xe1\x97\x54\x5b\xb1\xbd\xb6\x09\x35\x5a\x1f\x7c\x2c\x38\xa9\xba\x87\xb0\x66\xcb\xc7\x34\x19\xe2\x56\xa2\x8f\x81\x6e\xab\x15\x2a\xae\x0a\x08\x3a\xb4\xb2\xea\x99\xa1\x09\xf0\xd8\x46\x94\x41\x68\x39\xf2\x4f\x9c\x43\xf7\x63\x2f\x77\x19\x0f\xd8\x3b\x01\x91\xf5\x99\xad\x95\x62\xcb\xca\xd1\xbf\x2d\x13\x44\x89\x23\x09\x28\x14\xb1\x4a\x77\x02\xcb\x74\x76\xdf\x67\x6e\x05\xbe\xd0\xdf\x53\xc5\xf6\x22\x3a\x66\x1a\xa3\x73\x81\x3c\xf0\xdd\x21\xb7\xdb\xe5\x54\xde\x05\xc0\x96\x9f\x89\xb5\x25\x7a\x95\x1f\x65\x8f\xef\x65\xf3\x45\x16\xc5\xce\x5f\x0e\xd5\x5e\xf2\x2a\xe3\x2f\x9f\x79\x5c\xf2\x94\x5f\xfc\xfe\x99\xaf\xf8\xc1\x6d\xf5\xbd\xb1\xf5\x95\xc2\xd0\x6d\x10\xd4\xaf\xeb\x52\x34\x27\x9d\x28\xbb\x32\xd0\x18\x11\x8b\x56\x3a\x82\x76\xd8\xc5\xb4\x1f\x95\x2e\x75\x2f\xd0\xcf\x50\xff\x88\x19\xdd\xca\x2e\x33\x55\xdb\x58\x5d\x9d\x2a\xd6\x99\x11\xc0\x27\x1f\x41\x03\x84\x31\x73\x85\x78\xdb\xd4\x0d\x41\x38\x5a\x6d\x21\x16\x57\xce\x92\xb8\x45\x14\x85\x21\xc0\x9a\x05\x05\x15\x86\x99\x41\xb7\x5a\x65\x85\x4d\x69\xb5\x83\xcc\x02\xc1\x06\x30\x23\x34\xf7\x6c\x47\x12\x28\x5a\x36\x23\x53\xd4\x18\x97\x15\x33\x74\xf8\xe2\xd9\x46\x4e\x05\x75\xe2\x03\x2c\x50\xb1\x3a\x02\x35\x79\x16\x97\x45\xf1\x1e\x0a\x7a\x56\x78\xe3\x85\xb2\xd8\x60\x6a\x06\xf0\x78\x85\x23\x5e\xb8\x4c\x7a\x97\xaa\x48\xb2\xa6\x2b\xaa\x3e\x0c\xd4\x16\xee\xd5\x28\x96\x0a\x7f\xdb\xd8\xc2\xc7\x04\x6f\x42\x46\x6d\x40\xb0\x03\x41\x8a\x1c\x54\xbd\xdd\x97\xcf\x15\x21\x2b\x5d\x7d\x58\xbb\x1d\xa3\x39\x99\x80\xd3\x98\xa6\x59\xf6\xa5\x62\xd1\x83\x5d\x4e\x11\x58\x52\x39\xe4\xab\x6d\x77\x7f\xca\x50\x3d\x6d\xa1\x4e\xc8\x32\x21\x2c\x10\x70\xd5\xaa\xad\x2a\xa8\x1c\xb2\x4d\x46\x48\x25\x61\xf8\xb5\xfd\x80\xfb\x91\x84\x7d\x61\x65\x5a\xe0\x7c\x83\x88\x36\xd8\xb7\x35\xb8\xee\xdb\xbe\xd4\x78\x87\x51\xe5\xa2\xe0\xdf\xa5\x91\x5e\xd1\xdd\x26\x16\x2e\x53\x71\xf3\x51\xfb\x5c\xc5\x97\x6d\xf3\xe9\x8b\xa1\x81\x62\x94\x99\x94\xc0\xe4\xd1\xd0\x84\xef\x3b\xdd\xbd\x91\x16\x66\x93\x90\x0d\x1e\xe1\xc7\x91\x71\x03\x50\xe1\x47\xf9\x82\xad\x05\xb8\xc8\xcb\x66\x92\x8c\xc4\x0f\xa0\x0d\x9f\x44\xff\xaf\x42\x34\x22\x18\xc3\x24\xa1\x14\x50\xe6\xa7\x76\xfe\x53\x7e\xe0\xfb\x27\xcd\xfa\x07\x5f\xb3\xf8\x00\x2b\xe3\x5d\xc5\x80\xfd\x49\x25\x60\xff\x85\x34\xc0\xfe\x0b\x45\x80\x2a\x2d\x81\xae\x30\x4b\x5b\x81\x96\xf5\x41\x0f\x8a\x39\x1f\xdb\xa1\xa6\x43\xf9\xa9\xde\x86\x2f\x81\x99\xdc\x2e\x04\x69\x16\xd6\x20\xbd\xbe\xc8\x18\xe3\x77\xbc\x2f\x7f\xe0\x54\x0b\x53\x19\x97\xf7\x85\x1c\xe6\x5d\xbe\x02\x1b\x33\xea\x9f\x40\x5f\x02\xee\x25\x7e\xf0\x9f\xb5\xf9\x9c\xb8\x91\x1b\x11\xb1\xb0\xdf\x7c\xda\x6c\xef\x89\x46\x20\xcb\x32\x2d\xbd\x9b\x89\xb8\xea\x00\xa5\x76\x91\xb9\xf9\x49\x85\x1a\xe6\x95\x45\x9a\x13\x7c\x4e\x57\xef\x53\x30\x41\x41\xde\x08\x34\x56\xf4\x37\xfc\xb0\x0b\x29\xb9\x8b\xcc\xab\x8e\x47\x46\x85\xdf\x96\xdd\xf8\xae\xc8\x13\xeb\xc3\xf7\x4f\x04\xc7\x6f\xc2\x19\xa1\x98\xf5\xd1\x25\xcf\x24\xd3\xfb\x2f\x86\x89\x91\x5f\xd5\xc1\xa0\xbf\xc4\x6b\xf9\x8d\x27\xfd\xbe\x2f\xe5\x72\x7f\x2b\xa2\xe3\xa6\xfa\xa4\xfb\xe1\xc3\xfb\x59\xe1\x43\x95\x82\x0e\xdf\x7c\x8d\x8f\x6f\xf1\xf5\xc5\x50\x1c\x90\xdf\xd1\xe7\xd8\x7f\xf3\xac\xe1\xfc\x6d\x25\xff\xdd\xf3\xf7\xf2\x22\xdd\x0d\x9b\xdf\xeb\xc6\x3e\x19\x8f\xcf\xe9\x81\xbb\xe0\x74\xcd\x3e\xf8\xbe\x05\x4d\x2a\x4d\x37\xd8\x43\xa9\xb1\xa2\x62\x3f\x14\xc4\x71\x46\x04\xb7\xa9\xcd\x8b\xd2\xd1\xce\x3a\xd9\x7c\x14\x74\x17\x8b\x6e\x11\x46\xfc\x19\x7f\xac\x81\x4c\x6d\xa8\x68\xe0\x65\xde\x01\x40\xed\xf8\x77\x85\x1c\x73\xb6\xab\x7b\x39\xbf\xe6\x30\x99\xfd\x83\xc3\x6c\x20\xb8\x7e\xd9\x7c\x5f\xf6\xbf\xf8\x11\x7c\x5e\x7c\x87\x89\x06\xab\x00\xdf\xa3\x3b\x9e\x10\x5b\xb3\xe3\x72\x4b\xc9\xf6\xd9\xb1\xaa\xf3\x1b\xc7\x7e\xf6\xda\x9e\x73\x18\x7f\xba\x97\x5a\x6a\x4f\x06\x8a\x25\x23\xe9\x4f\x95\x0d\xa5\x94\xa8\xa8\x2b\x18\x41\x40\x16\x93\xe1\x0d\xc5\x97\x05\xb4\x65\x4b\x28\x47\x50\xb0\xc7\xa7\x47\xe8\x68\xfb\xd6\x5a\x8f\x02\xd7\x0d\x1c\x8a\x3d\xb9\x5f\xa8\x6e\x2c\x6a\xb1\xa4\x7d\x53\xf4\xab\x4d\x16\x33\xf0\x79\x24\x81\x97\x4a\xa2\x3c\xd5\x02\x8b\x5d\x92\x1d\x3c\x6a\x96\x6a\x11\x66\x2d\x16\xb7\xe5\x50\x5a\xd9\x13\xe8\x31\x2a\x62\x6b\x50\x96\xb3\x83\xaa\x07\xb5\x84\x08\x3c\x1b\x15\x25\x88\x3f\x81\x76\x32\x2b\x2a\xf5\xd4\x5b\x80\x84\x7d\x3f\xef\x56\xdd\xbf\x4a\x5a\x05\x6e\x16\xf0\xe3\x65\x0c\xd2\x1b\x29\x2b\x4c\x59\x5c\xbd\x61\x80\xb2\x96\xef\xac\xe4\x2f\xa1\xf0\x69\x92\x3a\x7c\x50\x9f\x69\x25\xa7\x9e\x59\xf1\x0d\x79\x3a\xf4\x32\x2b\x41\x8a\x25\x96\x83\x6b\x66\x1c\xb8\x21\x36\x74\x56\x48\x04\x51\x6a\xe4\xd5\x19\x39\xe7\xdc\x31\x49\xc1\x01\x1f\x4c\x9a\x8b\x82\x85\x16\x9d\xe4\xbd\x0e\xea\x00\xcb\x24\x45\x94\x8a\xae\xcd\x87\x42\xbf\xb2\xd8\x78\x56\x56\xd8\x29\x7a\x56\x74\x43\x49\x2d\x02\xc8\x08\x7f\xc1\x9a\x67\xba\xfa\x9f\x56\x40\xb4\xc8\x73\x1a\xea\x59\xa7\x39\x6b\x79\x14\xa0\x14\x35\x5b\x39\x94\xea\xd0\xd5\x5f\xbc\xc9\x55\xfb\xbc\x2d\x45\xea\x75\xa9\x19\xd9\x9a\x28\x4f\x82\xc9\xdd\xed\x28\x58\xba\x2e\x96\xe5\x66\xd9\x56\x6f\xa0\xc2\xaa\x2d\xc9\xff\xee\x0d\xf8\xf9\x7e\x7a\x29\x28\xbb\x2b\x3e\x3b\x8c\x45\x78\x57\x3f\xcf\xaf\xfa\xd9\x13\x3d\xe7\x3b\x9e\x30\x2a\x0f\x89\xb5\x8e\xec\x55\x59\xdd\xff\x28\xee\x2d\xb5\x54\xd5\x36\x94\xa7\xb0\x30\x5a\x7a\x94\xee\xf6\xd8\x72\x50\xb3\xb8\xb3\x66\x7d\x65\x22\x49\x6d\x05\x91\x7e\x91\x8d\x34\xcd\xfd\x2c\x8c\xe0\xc8\x44\xd8\x22\x34\x91\x81\xe2\xc9\xee\x9f\x4c\x73\x3b\x5b\x45\x50\x07\x56\x47\x23\x59\x04\x94\xd6\xca\xb6\x8c\x14\x69\x21\xe4\x7f\x17\x16\x33\x2c\x31\x73\xb5\xa0\xd8\xbc\x91\x05\xa5\x86\x12\x03\x48\x8c\x15\xf4\xeb\x74\xba\x13\x50\x09\x1b\x97\x12\x94\x33\xcb\x85\x53\x01\xe5\x55\x33\x75\xb7\x0a\xf2\xeb\x8b\xd5\x54\xcd\x56\x70\xca\xe9\x58\x49\x2e\x07\x4a\xf1\x14\x42\xd2\x30\x4b\x26\xfd\x07\x6d\x2b\x7e\x8c\x4d\xd3\xf4\xff\xb9\x09\x01\x06\x21\x49\xcd\x3d\x32\x14\xdb\x43\xa7\x1b\xd1\x80\xa3\x19\xbf\xd7\x19\xfd\x38\x21\x2b\xac\x96\x34\xeb\x8a\x1f\xdd\xcd\x1d\xff\xdf\x06\x03\x24\xa3\xc9\x92\x25\x49\x45\x9a\xd0\x2d\xa1\xbc\x2a\x92\x15\x75\xc5\x16\xa9\xd6\x0f\xe2\x83\xa3\xba\x33\xa4\xeb\x34\x51\x24\x2f\xa9\xb9\xcb\x99\xb4\xd4\xcb\x46\xc1\x79\xd4\xd8\xa1\x13\x70\x8e\xbe\xbe\xf8\x5a\xd0\x6a\x5f\x41\xbf\x5d\x11\xd2\x03\xc7\x01\xeb\xa4\x8d\xa6\xa1\xd8\x59\x4e\xe2\xeb\x30\x1b\x2f\x05\x8d\xd7\x50\xc8\xc6\xff\x29\x7f\xcd\x53\xf8\x00\xcd\xa6\x1f\xb6\xa8\x15\x9c\xb6\xa0\x74\x45\x39\x98\xf8\xdf\xb6\x44\x3c\x8c\x84\x19\xfb\x52\x1e\x2b\xe1\xb4\x34\x7f\x37\x0a\x9e\x87\x96\xca\x21\xe4\x75\x1c\x4e\x6b\x0e\x2d\xd5\xd7\x63\x54\xbf\xbe\x94\x59\x53\x1f\xf5\x82\x8b\xdb\xc8\xf7\x8b\x93\x75\xe1\xa8\xea\x87\x67\x5f\x43\x58\x2b\xea\x65\x06\xfc\x79\xbf\xb0\x8c\x64\x23\x23\x64\xc9\xff\x63\x4f\x88\x53\xf6\x68\xe3\xf5\xa5\x8e\x99\x46\x97\x15\x3b\x70\x1b\x2b\x85\x41\x48\x52\x35\x70\xec\xc1\xb0\xc8\x6d\x91\xd7\x63\xc0\xca\x67\x03\x66\x9f\x77\xa8\xb4\x54\x9a\x0f\x2d\x78\xb9\x10\xc0\x4c\xc7\x5e\x8a\x2b\x1e\x2d\xbd\xbe\xb4\xd1\xd3\x14\x01\x5f\x7b\xcd\x8d\x21\x08\x2d\x1a\xe5\x76\x42\x7e\x04\x64\x18\x0f\x7b\x51\x25\x2e\xa4\x7e\x21\x16\x96\xcf\xd4\x8e\xd2\x23\x04\x6e\x5a\x70\x63\x08\xe7\xee\xde\x49\x90\x01\x14\x0d\x68\x8e\x6f\xd9\xff\xf7\xfa\x32\x86\xa4\x29\x75\x85\x16\xa6\x64\x86\x8b\xd4\x66\xcc\xbe\xa0\x56\xa0\x95\x76\x2f\x0e\x94\x9e\xfa\xbe\x44\x1f\xfb\x8a\xe0\x3e\x7e\xaa\xc2\xc4\x14\x56\x0f\x19\xdc\x35\xfb\x1e\xe7\x91\x9d\x41\xc6\xeb\xcb\x1c\x39\x8d\xd9\xb0\xe4\x94\xa9\x5c\x83\xd4\xda\xe5\x98\x09\xc8\x2a\xd3\x5a\x02\x9b\x6e\x1a\x3e\x75\xd1\xc1\x9a\xd4\xda\xea\x9b\xda\x74\xeb\x53\x14\xd3\x7f\xc7\x31\x0c\x1d\x8d\x7d\xdc\x93\x2e\xd3\x77\xbf\x72\x5c\x41\x6e\x87\x28\x33\xdc\x24\x05\x7b\x8b\xaf\x0b\xaa\xee\xb4\x48\x4e\x0a\x3a\x26\x68\xc1\xfa\x8f\xee\x57\x6a\xd6\x6e\xe6\x2f\xb3\xfa\xe5\xb4\x60\xd1\xd1\x9c\x3a\xdf\xaa\x77\xdc\x46\x9a\x20\x70\x21\xb5\x60\xc4\x2f\xa4\xa5\x04\x59\xd8\xb0\x28\x54\x03\x1c\x2a\x2d\x03\x64\x31\x7d\x34\x0a\xcd\x22\x32\x07\x5e\xa2\x99\x54\x6f\x63\xce\x90\xa8\x1c\x6e\xa8\x8c\x9a\x90\xa3\x97\x64\x6e\x7c\xd6\x20\x2b\xa6\xd2\x2d\xc1\x30\x06\xf2\x88\x6a\x09\xcd\xf8\x63\x44\xa6\x8f\x57\xb3\x1d\xd5\x74\xf9\x63\x02\x0f\x40\xef\xfe\x9f\xa7\x54\xe7\x9f\xde\x52\xa0\xfb\xb8\xfe\xff\xd8\x7b\x93\x1c\xc9\x91\xa4\x69\x74\xef\xa7\xb0\x0b\x30\x61\xaa\x6a\x23\xfe\xed\x7b\x6f\x17\x67\xf8\x80\xbf\xab\x0a\x5c\x70\x43\x80\xf0\x45\x9c\xfe\x41\x45\x94\x74\x8f\xf4\xc8\x8c\x1a\xba\xba\xfb\x03\x1a\xdd\x95\xee\xe1\x9c\x8d\x36\xe8\x24\x22\x46\x96\x09\x4b\xc5\x0e\x73\xbb\x4b\xfb\x7d\x11\xb2\x23\xb6\xd3\x7c\xa0\xdc\xc0\xc8\x97\xdc\xc0\xa8\x97\xdc\x00\x1e\x89\x45\x88\x39\xe4\x06\x04\x2c\x8c\xe3\xee\xa7\x89\x50\x76\x32\x25\x26\xee\xf0\x6b\x2d\xc5\x28\xf8\x9c\xff\xf5\x37\x70\xfb\x78\x07\xee\x05\xfc\x9b\x1b\x81\x60\x92\x8c\x4c\xcb\x75\xce\xc7\x85\xce\x8b\x5f\xf1\x95\x3f\x77\x47\xb7\xa7\x5b\xc2\x79\x9a\x2f\x7a\xf8\xe1\xb8\xee\xfa\x3c\xec\x77\x74\xae\x97\xfc\xe4\x3f\x1e\x72\xef\x05\x5a\xde\xb5\xfd\x08\x25\xc7\x82\x48\x92\x40\x51\x76\x2b\xe4\xb2\xd6\x45\xcc\x57\xba\xcf\x31\x3c\xf9\x15\xa7\x37\x66\xfb\x04\xa7\xf7\x1e\xd6\x61\xc9\xf9\xbe\x58\x6f\xab\xf5\x86\xc5\x18\xd5\x92\x9a\xdc\xba\x32\x10\x9b\x19\x85\x9a\x14\x48\x6e\xd5\x10\xf3\xa4\x46\x49\xd6\xb2\xa2\x0c\xe8\xb3\xdb\x29\xd2\xe0\xfb\x53\x5c\x86\x60\x9d\xdb\xdb\x98\x25\x95\x46\x96\x3a\x6d\xc9\xdd\xcc\xda\xf6\xea\xb3\x8c\x0f\xe2\x1e\xc2\x4a\xd2\x3b\xb9\xe9\x1b\x6e\xe7\xf2\xd2\x00\x09\x5d\x94\xf1\x7d\xb7\x9b\x80\x26\x1d\x41\x47\x3e\x4e\x6a\x68\xf7\xfd\x14\xfa\x32\x19\xdc\xdd\xaa\xa1\x90\x61\x53\xa1\x1a\x46\x11\x40\x6d\xd0\x61\x42\x3c\xf7\xa1\x9a\x31\x52\xdf\x98\xc9\x82\x65\x09\x29\x25\xaa\x68\xf8\x23\x26\x6b\xfb\xf4\x46\xae\x2d\x45\x21\xa7\x92\x94\x2d\x62\x36\x69\x69\x28\x15\x04\xed\xdb\x5e\x35\x8d\xca\xda\x82\xd9\x6f\xbb\xbf\x76\x64\xec\x4b\xc2\x25\x15\x78\xf6\x25\xb0\xb4\xa0\x28\x41\x34\xb8\x13\xe2\x5f\x50\x11\x5b\xf2\xaa\xb2\x82\xb7\x26\x48\x8f\x2a\xc2\xdb\x2a\x69\x42\x3a\x6d\x01\x72\x7b\xf1\x69\x19\x1c\xdb\x7e\xd3\xe3\x0e\x42\x0f\x64\x48\x4f\x93\x68\xea\x1e\x2a\x8a\x89\x8a\x11\x36\xde\xdf\x4c\x46\xaa\xb8\x51\x7f\x66\x80\x81\xc7\x0e\x5e\x84\x92\x19\xea\xf0\x91\x79\x29\x50\x94\xf7\xb7\x2e\x2d\x4d\x04\xd2\x2b\x3d\x68\xea\xd1\xed\x92\x7a\xea\x09\x26\x84\x25\x10\x3e\x49\x2a\xa9\x24\xc0\xe4\x88\xe6\x45\x93\x02\xaf\x0e\xb3\x9d\x4a\x76\x89\x59\xcb\x78\xb7\xf7\x45\xdf\xdf\xea\x54\xf4\x3d\x71\x4b\xb7\x24\x1d\x25\x0d\x01\x03\x1f\x0e\xa0\xe7\xd5\x12\xe9\x93\x7b\x03\xb1\x86\x68\x4f\xe2\xdd\x58\x7d\x11\x6a\xe7\x42\xd4\x09\x40\xaf\x8d\x5c\x58\x03\x12\xb8\x36\x92\x21\x86\x52\x20\x89\x48\x1e\x7c\xb0\x47\x80\x3f\x95\x40\x76\x09\xf8\xb4\x10\x8b\xac\xe9\x2b\x77\x46\x5f\xd2\xb9\xff\xd0\xff\x0e\x79\xa8\x4e\xe3\xc7\xdc\xd7\x9e\x37\xd2\x02\x35\x59\xa5\xce\x0d\x05\xb0\xa3\xee\x30\x32\x24\xa7\x02\x46\x45\x52\x26\xac\x65\x83\x61\xcf\x3e\x1d\x99\x2b\xda\x93\xee\xd2\x80\xff\x6c\x54\x9e\xa6\x95\xe4\xa7\xec\xf9\xee\x57\x59\x2c\x13\x7b\xbe\xce\xbc\x2d\x13\x44\xf1\x41\xe0\x4e\x53\xba\x34\x4e\x21\xb2\x2e\xec\xae\x4b\xa6\x21\x49\xf5\x39\x37\xc4\x60\x56\x2e\x02\x0e\x8b\xa4\x72\x2c\x35\x69\x75\xe3\xaa\xa4\x0a\x95\x26\x30\x13\xba\xeb\x5c\x4b\x3d\x5d\xa6\x72\x42\xe7\x6f\xc7\xc2\x1b\x86\x4f\x50\xe2\x52\x7e\x51\x45\x3f\x86\xce\x6c\xf2\xdb\x98\x33\x15\x1b\xeb\x7c\xdc\xf9\x57\xbd\xec\x25\x37\xfa\x0f\xfb\x6f\x2f\x2b\xea\xab\xb5\xfb\xd2\xb9\xad\x3a\xe4\xee\x9f\x4b\xaf\x1b\x96\xf0\x26\x7b\xf5\x25\x26\x83\xa1\xe0\xe8\x27\x67\xbc\xbf\xa3\xb2\x22\xb4\x5b\x12\xd5\x00\xfd\x86\xd2\x45\x2a\xe6\xd3\xc8\xc1\xda\x15\x44\xd4\x91\x18\x14\xbf\x7e\x5c\x69\xc6\x95\xe8\x42\x31\x06\xe2\x76\xab\x0e\x5d\x5b\xe7\x3b\x45\xb8\x05\xbd\xdf\xbb\x0c\x0c\x93\x3a\xc1\x71\xd2\x43\x27\x8a\x4c\x33\xf4\x93\xd0\x33\x6d\x05\xe3\x52\x22\x53\x6a\xde\x61\xa1\x23\xfe\xac\x10\x9d\x6d\xbe\x5c\xac\xbd\xf9\x05\x6e\xeb\xa2\x33\xfa\x7b\x1b\x1b\x8a\x67\xb4\xbb\xab\x01\xa6\x8b\x61\xeb\x97\xd2\x71\x45\x5f\xb2\x81\xff\x28\xff\xed\x54\x05\xd4\x11\xf1\xaa\x4d\x3b\x5f\xf5\xb4\xbb\xb4\xbe\x8a\xf5\x00\xa7\x40\xa3\x7e\x6f\xfe\x6e\x42\x46\x7b\xf4\x83\xf8\x0e\xe2\x3e\x84\xb9\xe8\x22\x24\x7e\x1b\x1d\x86\x0a\x62\xc6\xe6\x2e\xf3\xba\xd8\x39\x41\x4e\xbd\x2f\xb5\xd6\x75\x99\xea\xc6\xef\x4c\x36\x9a\x4f\x36\xf3\xae\x90\x77\xcb\xbe\x52\xe7\x84\xb5\x6d\xec\x95\x48\x2b\xa4\xad\x04\xe1\xd4\x31\x43\x0f\x48\xf3\x1e\x34\x35\x41\xfb\xfc\x55\x78\x51\x5f\xb2\x75\xff\xa8\xff\xed\x02\x24\x87\x51\xbf\x2a\x44\x25\xb2\x96\xbb\x4c\xdd\x7c\xac\xe3\x53\x79\xf2\x33\x9d\xf2\xfe\x56\x0a\xd8\x21\xf6\x65\x30\xb6\xf5\x21\x81\x78\xc4\x47\xfc\x7a\xa6\x19\xaf\xbc\xe3\xf7\x09\xc8\xaf\xde\xd9\x4b\x46\xeb\x1f\xed\xff\x3c\xc1\x10\xfc\xbd\xdc\x4f\x45\x42\xca\xf4\x81\x2b\x04\x5e\x15\x1e\xe5\x75\x9b\x1f\x37\x66\xfb\xd1\x61\xde\x42\x9f\x6c\xfa\x4f\xea\x21\xb7\xbf\xb5\x8b\x5c\xcf\x7d\x0a\x35\xae\x0b\xf0\x10\x8f\x5e\xf3\xd6\x87\xa4\x3a\x8d\xeb\x85\x95\x09\xd1\xf2\x9e\xc6\xe9\xc6\x0c\x4b\x67\x49\x90\x45\x52\x30\x44\x71\x1e\x7f\xd4\x47\xe1\x10\xeb\xe4\x21\x1e\x33\x52\x05\xf9\x55\x33\x54\xda\x59\xbc\xa7\xeb\x9e\xfa\xbc\x31\x76\x0d\xfe\x59\x62\x47\xad\xf0\xa5\xba\x57\x4b\x2a\xf9\x4c\x56\x4a\x3b\x31\x6d\xd7\x97\x73\x0b\xbf\x20\x30\x45\xcd\xe5\x52\x8f\xeb\xcb\xb9\xed\xab\xbe\xf9\x92\xb6\xfb\x47\xff\xef\x7c\xd2\x34\xa7\x36\x50\xfe\xb4\x50\x63\xd5\xf2\x7d\xa9\x0c\xbc\xaa\x46\x65\x52\x3e\x49\xca\x50\xc4\x85\x3b\x88\x72\x83\x0d\x34\x9a\xbe\xfe\x2c\x02\xc5\xa5\xef\x0b\x11\x2e\xf4\xfe\xa3\x80\x40\x4c\xb6\x38\x6a\xa7\x2c\x9c\xd5\x04\xc4\x0f\xea\x08\x77\x13\x24\xcb\xdc\x05\x12\x37\xa3\xea\x4c\xfe\x69\xe0\x1f\xe7\x17\xc4\x9a\x01\x29\xb0\xa4\x25\x12\xf0\x65\xa7\xdc\x52\x0f\x6e\xed\x85\x9a\x61\xe5\xc4\x3a\xdc\x40\x6e\x46\x59\xbe\x8c\x37\x49\x54\x20\xbe\xed\x3c\x4e\xa2\xfa\x2e\x68\xb0\xed\x4c\x6a\xc2\xc3\x95\xca\x7c\x5e\x7d\x7f\x1b\xda\x92\x94\x1a\xa4\xaf\xee\x2e\xec\xa3\xa7\x69\x69\xf4\xa4\xde\x4f\xf9\x19\x68\x16\xf8\x7a\x9a\xa3\x6e\xab\x1f\x68\xd5\x42\xf6\xf2\x20\x5a\xaf\x8a\xa2\x5a\xe2\xfc\x84\xd0\x25\xb6\xe8\x0c\xb5\x9e\xd8\xf3\x38\x8f\xc5\x3b\x13\xf7\x70\x41\x3b\xf6\x45\xef\x7f\x49\xd6\xfd\x63\xfc\xb7\xf7\x9f\x51\x55\xd8\x30\x50\xe1\x1b\xa0\xf8\x76\xf3\x35\xea\x7a\xaa\x32\xa2\x33\x33\xb9\x17\x6d\xac\xc4\x08\xe2\x18\xff\x09\xb0\x87\x91\x66\x8e\xa2\x9b\xaa\x09\x7f\x1e\xd8\xb6\x62\x11\x16\x6d\x39\xf5\xf6\x32\xce\x7a\xfb\xf9\x38\x2b\x8f\x71\xa6\xad\x26\x6d\xed\x3e\xf3\x16\x5f\xf7\xc9\x08\xcf\x24\xb1\x9a\x1f\xf2\x55\x2f\x78\x49\x70\xfe\x63\xfe\xb7\x17\x94\x91\xd1\x0b\xfc\xf1\x7d\x52\x41\x56\x0b\x0c\xf8\xdf\xea\x56\x19\xc9\x63\x6a\x44\x2e\xe6\x7b\xf2\xdd\x9f\x62\x00\x50\x95\x8b\x2f\xbe\xb8\x0a\xdc\x75\x88\xa4\x9f\xfc\x87\xb2\x2d\x71\xaa\x33\xcd\x12\x57\x40\x65\x92\x44\x89\x75\x43\xe9\x3b\x8a\x96\x50\x58\x30\x82\x4e\xbf\xf8\x54\x89\x98\x19\xaa\x19\x06\xf7\x5d\xb0\xf3\x08\xee\x76\x39\xf3\x71\x5a\x12\x8a\x35\xab\xa4\xb8\xdc\x08\x1a\x46\x15\x38\x8f\x5a\x70\xb7\x5a\xec\xc6\x07\xf0\xdb\x5e\xf0\xf8\x0b\xb7\x1f\xb1\xfb\xc6\x73\xe0\x14\x3c\xed\x71\x5e\xe7\xfd\xad\x35\x4d\xed\x4a\xa2\x10\x82\x70\x20\x55\xe7\x17\xb0\x91\x86\x09\x05\x29\x7c\x97\xcc\x46\xad\xdf\xc8\x8b\x28\x19\x4a\x87\x1a\xd5\x16\x62\x11\x49\xf1\x26\xf5\xf1\xe6\xc7\x5e\x09\x54\x0b\xd1\x0d\xb4\xd9\xd7\x95\x09\xf6\x9a\x48\x79\x10\x0f\x97\xd9\x53\xcf\xee\x01\x4f\x6f\x9c\x1c\xfa\x84\x02\xb0\xb0\x91\x73\x58\x08\x96\xe4\x1d\x75\xf2\xd2\x5d\x70\x92\xe3\x84\x41\x21\x22\x33\x58\xcd\xb4\x48\xd3\x64\x40\x0e\xfb\x3a\x42\xa2\x66\x6a\x39\xd7\x74\x92\x71\x53\x88\xe4\x54\x2d\x47\xa2\xae\x1c\x67\x49\x7e\x29\x07\x04\x23\x92\x91\xc8\x1e\xe5\xe9\x36\xf3\xaa\xc3\x40\x03\xab\x32\xa0\x26\x6e\x73\x3c\x24\x26\x4c\xfa\x21\x84\x7b\xa8\x31\x05\x09\x30\x61\xdd\xa5\x51\x53\x55\x47\x4f\x25\x23\xdb\x55\x94\xd5\xc2\x6a\x49\x01\x7e\x90\x64\xe0\xe9\x84\xf7\x90\x4b\x5c\x5a\x47\x49\x90\x4a\xd9\x29\x3b\x46\xe9\x77\x20\x0a\x80\xcb\x9c\x3d\x30\x35\x35\xe4\xa0\x75\x34\xd0\xc1\xcb\x49\x91\x6a\x5c\xe9\x14\x04\x01\x0d\x08\x4f\xd6\xda\xa0\x04\x06\xe8\x21\x00\x8b\x7c\x30\x7b\x23\xb8\x53\xda\x83\xa8\x5a\x01\x6b\x2b\x15\xda\x97\x41\x0f\x4c\x62\x6e\xd3\x80\x60\x10\x93\x43\xca\xd2\x45\x91\x08\x51\xd2\xb8\x82\x5f\x00\x09\x74\x1f\x54\x3f\x97\xbc\xfd\x9f\x62\xaf\x39\x91\x9f\x09\xd4\xab\xb0\xac\xbf\xa1\x12\x2a\xeb\xdd\xea\xdc\x16\xb3\x92\x94\xd4\x66\x25\x55\x91\x0d\xd5\x5e\xea\x96\x11\xbf\xdc\x17\xad\xe3\xfd\x6d\x82\xd4\xa0\xe2\xe8\x92\xd5\x27\x74\x20\x3e\x79\x06\x7f\x29\xf7\xc5\xea\x0c\x56\xa2\x3a\x36\xed\x9a\x64\x28\x75\xf0\xaf\x2f\x3e\x5e\xdf\xdf\xca\xa8\xa9\x9b\x6d\x71\x71\xde\xc9\x79\x5f\xe0\x71\xab\xa9\x95\x8c\x7b\x71\x9b\xe9\x8e\x5b\x10\xcb\x1d\x87\x5d\x97\x8e\x9b\x89\x2b\x13\xf3\x24\x50\x0f\x64\x46\xb8\x04\xac\xae\x95\x6d\x19\xe0\x58\x40\xed\x81\x44\x05\x18\xc6\x26\x2a\x0c\xc5\xb8\x03\xb6\xfb\x4d\x51\x58\xbc\x95\x7b\x45\xcc\xa1\x48\xc2\x9f\xdb\xb9\x93\xbf\x1f\x03\xb5\xac\x1d\x3c\xcf\x76\x5d\x00\xed\x61\x89\x17\xfe\xea\x1d\xbe\x06\xb9\x7f\xa6\x90\x2f\x23\xfb\x64\x5f\x76\xf1\xc9\xae\xb4\x14\x2c\xd2\x24\x9f\x6e\x51\x72\x2f\xd1\xc7\xc0\x3d\x8e\xdc\x06\x65\x85\x74\x80\xa8\x14\x03\x9f\xdc\xd4\x72\x92\x0f\xa3\x98\x02\x6a\x24\xa2\x79\xae\x8b\xac\x8b\xae\xa8\xbb\xe9\x4c\xd5\x80\x83\x33\x2a\xce\xc4\x17\xa5\xc0\x7e\x4a\x4e\x15\x10\x99\x43\x4a\x4f\x52\xa0\xc0\x40\x7f\x49\xd3\x80\xf1\x2c\x35\x0d\x77\xef\xdb\x21\x73\xa6\x21\x41\x84\xea\xbd\xa1\x8e\xbd\xd7\xe4\x5d\x4f\x95\xc4\x0d\xe3\x30\xc0\x7b\x67\xb9\xed\xd2\xa8\xe1\xd7\x42\x70\x49\x63\xa6\x00\x1f\x3d\xa7\xb4\x80\x5a\x91\xbf\x17\x12\x47\xe7\x97\xf7\x37\xb7\x08\xca\xbc\xc4\x45\x81\xcf\x9f\x76\x68\x46\x86\x6b\x17\xa4\x61\xb5\xe4\x34\x27\x0d\xf2\x1c\x00\xcc\xfa\x40\x77\x80\xa1\x15\x24\xcb\x8d\xf8\x13\x88\x57\x2f\x15\xc9\xad\x79\x4a\x64\x1e\xac\xc8\x1b\x9c\x59\xaa\xa5\xf8\x93\x04\x22\x56\x28\x69\x13\x00\x21\x39\x7c\x28\x55\x28\x47\x2c\x9d\x1c\xf5\x43\x8f\xde\xf1\xd7\xec\xbe\xed\x76\xcd\x8a\xb2\x13\x7a\xa7\x98\x30\x01\x8c\x1c\x94\x41\x88\x17\xe0\xbd\x99\x8c\x06\x6e\x97\xf7\xd4\xb1\x00\xb3\x3e\xd3\xfb\xff\xec\x1b\x46\x51\x1e\x7b\x6b\x09\xc9\x2a\x4d\xad\x84\xd1\xa8\x00\x83\x20\x37\x45\x7b\x31\xb8\xe1\x91\x8c\x03\xd2\xd6\xca\x43\x50\x6d\xc4\x2a\xbc\x74\xa0\x7a\xc8\xe3\xd3\xfd\x8b\xf7\x42\xf7\x47\x7a\x8f\x5f\x66\x23\x08\x68\x81\x7a\x00\xe2\xf4\xa2\xf4\xbb\xdc\x8d\x27\xe4\x09\xfd\x71\x7c\xcd\xbb\x61\xaf\x41\xfa\xd7\x5a\xbd\x8f\xbc\x1b\xc8\x72\x0b\x50\x70\x5f\xca\x1e\x1f\x7f\xaf\xfe\x72\xc8\x2f\x07\x31\x19\x49\x02\xc8\x22\x60\xcd\x5f\x90\xcf\x73\xe8\x9b\x65\x77\x63\x66\x80\x23\x58\x47\x48\xe3\x0f\x6c\xf5\x8d\x00\x8e\xcd\x38\x6c\xe6\xf7\x37\x5f\x52\x01\x92\xe1\x0e\x94\xba\x87\x1d\x87\x73\x1c\xfc\x60\xe4\x1a\x27\x00\xfb\x7a\xc7\x35\x71\x96\x23\x3e\x83\xad\x0e\x8c\x97\xb8\x33\x5e\xe1\xe9\xc8\x38\xeb\x12\xf7\x74\x2c\xbc\xc7\x88\x8a\xfb\x2e\xe7\x79\xe3\x99\x78\x4a\xad\x2d\x8a\x4c\x95\x80\x5f\x98\x78\x42\xf3\x2c\xf0\xc1\xcf\x7f\x3c\xef\x15\x7f\x2c\xf1\x97\x9c\x4c\xdc\x72\x9d\x81\x7f\xdc\x8e\xe7\x1d\x7d\x99\x18\xee\xd3\xda\xa3\x55\x27\x65\x42\x79\x73\x47\xdc\xe4\xd3\xad\xfb\x83\xb1\xe5\xfd\xb1\x8e\xf3\x41\xbf\xea\x94\xaf\x41\xfe\x57\x4a\xb0\x27\xc8\x74\x6f\xf9\xd2\xfc\x76\x97\x81\xb3\xb5\x21\x3c\x39\x20\x40\x16\x45\xb3\xac\xf1\x72\xdb\xca\xac\x9d\x9c\x5b\xfe\x35\xd8\xb7\x88\x71\x82\xed\x35\x4a\x8a\xc3\x70\x36\x43\xee\x17\xb2\x82\x3d\xd1\xd0\x52\xe8\xd3\x80\x25\xa2\x97\x04\x15\x5f\xd5\x11\x49\xfc\x02\x80\x5f\x8b\x55\xe3\xe0\x32\xe2\x8b\x70\xa0\xd7\xc1\xfd\xbe\x28\x85\x33\x2c\x44\xb2\xca\xa1\x40\x45\x00\x0d\xab\x84\x79\x55\x89\x6f\xfe\x25\x17\x82\x61\x6f\x71\x8c\x1f\x52\x25\x69\xd4\x28\xab\x9d\x2c\xfa\x6e\xd8\x1d\x71\x03\xaa\x72\x07\xff\x98\xcf\xf6\x26\xc9\x3a\x85\x33\xf0\x00\x0b\x9f\x60\xf6\x30\x1f\xbf\xae\x17\xf9\x7f\x5e\x6c\xe8\x5f\x5e\x79\xc0\x9e\x5e\xce\x4c\xad\xe9\x3e\x92\x4a\x87\x74\xa2\xdf\x99\x65\xb7\x66\xc7\x5a\x1f\xf9\x74\xd2\xdd\xd3\xc1\x0c\xe9\x61\xf7\xb0\x49\x7c\x05\x64\x2e\x2b\xb8\x4b\x30\x4a\xd4\x0b\x9f\x51\x4f\x8c\x59\x60\x87\xa8\x14\x28\xb5\xec\x15\xfa\xf6\xa0\xac\xc7\x3c\x7a\x46\x04\xbd\x9f\x63\x5e\x05\x9a\xad\x74\x48\xd0\x6c\xd2\x40\xde\x3e\xfd\xcd\x54\x4b\x58\xcd\xa3\xcc\x41\x4f\x6f\x2c\x9f\x6c\xf5\x23\xb3\xc8\x6e\xd2\x11\x0d\xa6\xf9\x44\x7b\xb4\x58\x2a\x72\x8b\x75\x8e\x3c\x0c\x56\x59\x2a\x67\x89\x30\x7a\x09\x1c\x9c\x74\xe8\x90\x57\x3d\xea\x0c\x5d\x5b\xef\xaf\xbb\xc0\xcb\xc6\x04\x1f\x94\x19\xe0\x1d\xf1\x75\x10\xa5\x9b\x88\x94\xb9\x89\x6c\xa1\x41\x31\x04\x1c\x33\xcb\xc9\x9e\x92\xe8\x56\x84\x34\x39\xe2\xa4\xc8\xef\x12\xcb\x6c\x3d\x81\x63\x1c\x2c\x01\xa0\xad\x03\x96\x17\x4e\xca\xc6\xcc\x9f\x50\x52\x11\x6d\x3c\x40\xc5\xcf\xf7\xd0\x6a\xd4\x60\x4e\xe6\x6d\x50\xb0\x30\x2e\xfa\x2c\x54\x30\xe7\xdb\x01\x72\x0a\x5f\xee\x51\x42\x53\x2a\x04\x0e\x42\xec\x61\x44\xc9\x65\x6f\xa1\x66\xd3\x63\xb5\xdf\xbc\x8d\xdb\xde\xb0\xd2\x63\x9d\x13\x09\x99\x3a\xac\xda\x87\xe4\xf8\x82\xf0\x99\xdb\x24\xd6\x13\xac\xfb\x03\xfa\xa4\x69\x1a\x80\x1c\x5d\x43\x2c\xa1\xa0\xc1\xdc\xd3\xec\xf4\x9e\x51\xe6\x2f\x06\x05\x2e\xdb\x11\xb3\x98\xa1\x50\x54\xda\xd1\x14\x0f\xea\xe6\x5d\x1d\xc7\x89\xec\x0a\x99\xa1\xde\xc9\xae\xb2\x8c\x11\xf2\xa6\x16\x81\x40\x71\x67\x2b\xdc\xd5\x76\xdb\x51\xef\x8b\xda\x2e\x84\xe6\xa0\x40\xa1\x40\xda\xfb\xcd\x45\x0e\x6c\x11\xaa\xd1\x58\x95\xd4\x8b\x4f\x8d\x34\x3e\x46\x4c\x3e\xfe\x24\x14\x1d\xab\x3f\xaf\xe7\xe0\xa8\x7c\xf1\x58\x7e\x79\x61\x14\x7b\x5e\xc7\x31\x07\xb8\x7d\xdf\xdc\x6c\xcf\x23\xa1\x3e\xa9\xa6\xd0\x7b\xd5\x61\x9c\xfe\xb6\x3a\xdc\xca\x82\x80\xce\x04\x9a\x62\xce\xad\xd5\x54\xfb\x2e\x78\xeb\x6d\x24\x30\xe3\x2b\x04\x47\x50\xd1\xb2\xc3\xa0\x53\x1a\x50\x40\x2b\xf6\x96\x8a\x2f\x69\xa8\x78\x1c\xde\x01\xbd\x2b\x15\x14\x90\xeb\x46\xd3\xc8\xf6\x65\x0e\x52\xde\xcc\x91\x6c\xd4\x83\x1f\xdb\xb9\xf5\xaa\x8e\x89\xc3\xb8\x70\xee\x64\xec\xca\x41\xdd\xa5\xa1\x97\x9d\x27\xa5\x14\xc5\x9d\x9e\x0a\xa2\x75\xb9\x6d\x64\x9c\xdf\xc9\x71\x42\x16\x1b\x4a\x1a\xd4\xab\xea\x0e\x0d\x70\x6f\x6d\xaf\xd0\xfd\x81\x37\x82\x07\x1b\x6d\x57\xcd\xa9\x14\x3c\xaf\x3f\x6e\xa3\x38\x7b\x29\xa9\x66\x6f\x9a\xe9\x9e\x92\xf5\x9e\x46\xf6\x41\xea\xfd\x7e\x80\x5b\x16\xc4\x71\x18\x46\x47\x0c\xa7\x4d\xdd\x67\x1d\x91\xfa\x74\x5b\x11\x5a\x9e\xcd\xa7\x08\x7f\x0b\x4d\x77\xb4\x0a\x9c\xd7\xd2\x71\x08\xa8\xa6\x8a\xec\x8c\x00\xe7\x38\x24\x43\x06\x54\xb2\x6f\xc6\xd6\x49\x29\x05\x48\x4d\x54\x9e\x6e\x91\xa6\x37\xd8\xda\x6e\x0a\xfb\xee\x6d\xe2\x0e\x06\xa9\x72\x41\x8d\x57\xd2\x00\x06\x68\xc4\xbd\x8f\xec\x23\x77\xfa\x63\x61\xff\xf3\x44\x7b\x9d\xa9\x8d\x84\xf3\xb7\x6d\xc1\x65\xb3\x37\x82\x80\x62\x41\xf2\xc1\xfb\xc2\xa6\xc5\xb7\x01\xcd\xc3\x23\x96\xd1\xb6\xf3\x01\x5b\x83\x50\xdb\x84\x6e\xa1\xbb\xb7\xbe\x8a\x16\x10\x64\x37\x46\x5b\x10\xef\x14\x0a\x2b\xb2\x67\x11\xad\x0c\xd9\x74\x76\x3a\xd9\x7c\xcf\xea\xbe\xe5\x08\x7d\x43\xef\xa3\x03\x9d\x0a\x92\x9e\xb9\xc1\x21\x52\x37\x43\x7a\x8d\xd2\xc8\x10\x3c\x96\x9e\xeb\x03\x63\x53\xd9\xa4\xde\xe7\x78\xf4\xae\x88\xbb\x97\x99\xd0\x4d\x7d\x4c\x0c\xa8\x7b\x64\xf3\xde\x15\xac\x29\x18\xda\x15\x3d\x02\xa6\x0e\x22\xf3\xd1\x51\xfd\x38\x9e\x0a\x8d\x32\xc8\x42\x61\x03\xf8\x1e\xdc\x47\xb3\x47\xff\xb7\x8a\xe3\xbc\x2b\x0d\x3c\x17\x64\xea\x7c\x9c\x49\x9b\x7c\x64\x7f\x62\x76\x46\x24\x6a\x85\x2d\x24\x76\x47\x08\x79\xa2\xf0\xef\xea\xc6\xb7\x43\x31\x48\x3a\xab\xcc\x7b\x19\xf1\xb0\xd2\x8d\x3c\xa3\xc9\xec\x0a\x62\xa9\x4f\x9a\x0c\x29\x50\x08\xc7\x24\xb5\x7e\x7e\xa3\xde\xda\x19\x69\x88\x29\x98\x8e\x94\x1f\x47\xea\x53\x3f\xdb\xe3\xdb\xd3\xf6\xa7\xc3\x1e\x27\xbb\x2e\xf0\xb8\xe8\xe3\x4e\xce\xbb\x8b\xe0\xc3\x69\xde\xf9\xf3\xfc\x1e\x97\xe2\xf6\x57\x7d\x8a\xe3\x4b\xdf\xe6\x77\x4c\xca\x2f\x21\x88\x5f\xae\x3a\xbb\xea\x7d\x45\x2f\x75\x0d\x30\xbc\x22\xaa\x4d\xc6\xc9\xdc\x53\xb3\xdd\xcd\x5a\xef\x31\xad\xec\x6e\xc4\x9c\xa6\x8c\xbc\xbf\xd5\xd2\x52\x9b\xe5\x94\xc9\xea\x98\x55\x4e\xbe\x4a\x9f\x82\x80\xf2\xcd\x3e\xe0\x67\xf6\x3e\x8b\x60\x02\x81\x6d\x12\x18\xdc\xf7\xb7\x2e\x9a\x7a\x9b\x77\x51\x3f\x96\x64\xb4\xa0\x56\xc2\xea\x5e\x19\x61\x47\xed\xfa\x84\xbc\xd6\x83\x80\xf2\x58\xb0\xc0\x15\x94\xd3\xd7\x4b\x26\x37\xeb\xd1\xb1\x22\xb6\x7e\x77\x93\x0e\xcb\x64\x67\xa2\x64\x54\x44\x8e\xaa\x1b\x47\x7e\x8f\xd8\x01\x80\x58\x23\x3a\x96\x42\xa6\x39\x72\x62\xc1\x26\x59\xa9\x16\x8a\xb9\xba\x22\x38\x91\x16\x5f\x41\x80\x33\x56\xf0\x4b\x78\x33\x81\xbc\x2e\xcd\x09\x3a\xb7\x54\x58\x5d\x09\xf3\xf9\x84\xd6\x91\x8b\x2c\x08\x40\x4b\xf1\x51\x5d\x41\x65\x04\x08\x81\xa6\x9e\x41\xd7\x0f\x2c\x0c\x6a\x2d\xb3\x6f\xb7\x9e\x26\x26\x00\x7b\x7f\xeb\xde\x61\x6a\x46\x41\xcd\x02\x8c\xe5\xa2\x69\xe8\xdd\x40\x46\x52\x5a\xd2\x04\x8d\x77\xeb\xb0\x00\x2c\xb9\xad\x21\xf7\xc5\x26\x59\x7c\xa1\x33\x94\x96\x4e\x12\x13\x77\x95\xda\x5d\xdc\x7d\xb7\xc0\x1c\x73\x4a\x3b\xe3\x9b\xd5\xfc\xe4\xaa\x75\xad\x4a\x4d\x55\x72\xe5\x1c\xf1\x79\x17\xe9\xeb\x22\xd9\x9f\x67\x68\x32\xef\x1c\xeb\x22\x3e\x19\x23\x87\xe0\x0d\x57\xef\x64\xa2\xcb\x77\xb7\x51\x76\xd0\x8b\x58\x87\x7a\x11\x71\x4a\x80\xfb\x28\x3e\xef\x8b\xae\x28\x6b\x85\x80\xb0\xbf\x14\x58\x45\xad\x84\xa4\x75\xa5\x57\x72\x62\x22\x29\x8a\xbb\xf8\x88\x27\xe7\x44\x43\xb2\x29\xfb\x7a\xf0\xfe\x36\xfd\xd5\xe4\x8e\x07\x37\xea\x6c\x36\x0b\x53\x9e\x7a\x3a\x2d\xe4\xb1\xe3\xc5\x04\xb8\xdd\xa7\x55\xff\x43\x43\x13\x8c\xf6\x21\x61\x8a\xbc\x78\xd3\xbf\x4d\x61\xfd\xef\x14\x58\x2f\xf6\x92\x68\xfd\xe5\x85\x9c\xf3\xc9\x42\xab\xd3\x3d\x37\xb0\x72\x65\x0a\xfb\x4a\xf6\x67\xa8\x2c\x1c\x27\xb9\xc6\xc5\x12\x46\x02\xbe\x2c\xbb\x54\x20\xd0\xaa\xfb\x2a\xf5\xfd\x0d\x62\x7a\xdd\xdf\x67\x13\xa0\x8e\x7d\x84\x2e\x63\x26\xe0\x77\x95\xa1\x4a\x56\x16\xd7\x93\x56\x8d\x7f\x5b\x7d\xa2\x87\x13\xeb\xef\x6f\x23\x43\x4b\xca\xdd\xdc\xac\x54\x08\x87\x9a\xea\xa4\x86\x69\x23\x76\xbc\x9d\xf1\x2e\x08\xd5\x01\x7e\xcb\xaa\x41\x28\x86\x22\x90\xb0\xb3\x62\x9b\xbc\xbc\xec\x02\xa1\xa3\x45\xbe\x44\x93\x90\x0f\x06\x53\x30\x6c\x36\xa5\x72\xda\xa2\x7a\x40\xe5\xaf\x9e\xb2\x99\x28\xfb\xc0\x3e\xad\x1c\xe1\xea\x9c\x80\x5d\xb0\xb6\x36\x30\x06\x97\x7d\x69\xc4\x59\x42\x12\x93\x51\x8f\x96\x8a\x1c\xac\x1c\x1f\xe0\xee\xba\x4a\xda\x73\x42\x83\x63\x8a\xae\xf7\x02\xd3\xa9\x60\xd9\x4a\x02\x0c\xb7\xdb\x97\xcd\xbc\x5d\x7c\x6b\x57\xce\x18\xd4\xf9\x04\x50\x9e\xe1\x4e\x64\x8a\x80\xe1\x9b\xc9\xdf\x27\xc0\x41\x6a\x15\xdc\xc8\xfb\x44\x51\x9e\x4f\xbb\xa5\xdf\xc8\x8f\xa0\x32\x52\x81\x52\x18\x53\x31\xeb\xa2\xaa\x7b\x49\xa5\x26\xf7\x5d\xca\xbd\x65\x9f\x21\xa7\xdb\x94\x49\x74\xac\xbe\x99\x6e\x1d\xea\xea\x05\x34\x11\x24\xe6\xf3\xb7\x0c\xfa\x69\x5f\x42\x7d\x3e\x28\x7a\x5f\x64\x36\x52\xe9\xd0\xf9\x2c\xa4\xdf\x46\x66\x04\x8b\x0e\x28\xa5\x73\x72\x67\x0f\x85\x81\x7d\x04\xfb\xcf\xd4\xc3\x2f\x99\xed\x6e\x55\x56\xc5\x63\x93\x56\x3a\x09\xbd\x31\x84\xff\x7d\xde\xf2\xe5\xe5\x2e\x33\xaf\xb3\xdd\x91\xc7\x06\x7b\x5c\x1a\x73\x55\xed\x40\x42\xa0\x2d\xd1\xab\x57\xe9\x72\xf3\xdb\xca\x27\xae\x81\x4e\x73\x88\x89\xeb\xba\x8c\x7a\x5f\xac\x45\xef\x14\xa4\x83\xc4\xe4\x24\x8b\x9e\xa0\xf5\x11\xd8\x48\x06\x00\x38\x12\x4f\x78\xba\xcc\x48\x6b\xe3\x39\xa1\x57\x46\xab\xb9\x84\x43\x9d\xb0\x8b\xdf\xe0\x4c\x2c\x83\xcc\x76\x80\x9a\xb2\x94\x1d\x7b\x4f\x72\x12\x01\x6a\x3f\x2e\xa7\xfa\xab\x91\xfe\x92\x4c\xff\xe5\xaa\x51\x1d\x79\xa6\x6a\xba\x69\x6b\xa9\x4c\x5f\x2d\x28\xd4\x08\xaa\x38\x02\x2d\x60\x37\xbb\xe7\x3d\x41\x0c\x95\x00\xc6\xab\x35\x99\x28\x72\x08\x9b\x36\xc8\xd2\xd9\x7d\x31\x2d\xab\x8f\x48\x93\xf1\xbf\x71\x52\xa4\x91\xf4\x52\xce\xf9\x4b\xfd\x09\xff\xff\xf0\x16\x79\x22\x42\xe9\x17\xbd\x68\x54\x22\x22\xab\xc0\x8a\x46\xf1\xf5\x1a\xbd\x9b\x8e\x14\x04\xfc\x60\x1b\x40\x32\xda\x87\x81\xba\x41\x35\xea\xdc\x03\xd4\xc9\xe8\xa7\x31\x30\xc8\x50\xd3\xf0\xb6\x02\x63\x00\xdd\xf5\x24\xa7\x50\x21\x75\x0a\xa5\x90\x84\x10\xfd\xf6\xa1\xd3\xae\xd2\xdd\x78\x91\xd1\x8e\x36\x93\x80\x58\xcd\x3d\x1c\x05\xd1\xf9\x24\xf5\xa5\x34\xa2\x63\x83\xab\x17\x33\xf5\xc9\x8a\xf7\x4c\x8a\x57\x9f\x82\x7e\x5c\x88\x9f\x88\xf3\x82\xb1\xe1\xe4\x24\xf4\xfe\x4f\x5b\xce\xed\xf9\xb3\xca\xc0\xbf\x93\x01\xbe\x8f\x7d\x69\x97\x80\x6a\x14\x47\x81\xc2\xed\x8c\x88\x21\xd7\x0f\x4b\x09\x86\x98\x5b\x32\xc2\x18\x9b\x4f\x8e\x94\x22\xc5\x4a\xbf\x88\xed\x13\x38\x28\x70\x85\x82\x12\xd7\x57\x18\x37\x53\xa5\xda\x61\x03\xcf\xbf\x9c\x9f\xe7\xef\xcb\xb9\xe3\x12\x07\xe2\x73\xc1\x17\xb2\xcc\x29\x77\xf6\x3f\x6f\x64\xbe\x92\xc1\xd0\xa9\x14\xd4\x42\xa9\x0c\xe8\x66\x6b\x26\xe2\xa2\xe4\x03\xcb\x82\xcf\xf6\x27\x79\x99\x1d\x8c\xca\x69\xc3\x13\x03\x60\xd4\x4a\xd2\x56\xa3\x53\x53\xb3\x5e\xfb\x21\x30\x2d\xfc\x1e\x91\x3e\x56\x5f\x4b\x60\x46\x72\xbd\xbd\x5a\xee\x78\xb4\x27\x56\xa0\xc4\x46\xfd\x1d\xbd\xfc\xa5\x00\xf6\x97\x9f\xb1\x80\x6a\xcf\xa9\xb3\xea\x07\x63\x38\xa1\xc4\x06\x7a\x82\xa9\xcc\xc3\x67\xf3\x1a\xc0\x24\x04\xef\x8c\x6b\x1f\xcc\x71\x2c\x36\x78\x97\x03\x61\xea\xe0\x6a\x9f\xa0\x30\x9e\xa9\xb5\x64\x6e\x8d\xb5\x9d\x5c\x23\x3e\x13\x2d\xb5\xee\x65\x12\xa9\x95\x41\x03\xdd\x85\xf5\xbe\xa4\x3a\x86\x5f\x5d\x0e\xf4\x10\x0e\x71\x36\x35\x18\x35\x01\xd7\x1d\x9b\x1f\x00\xd8\xd6\x30\xb8\x1a\x52\xf3\x13\xfd\x91\xbf\x9e\x89\x2a\x17\x32\x0a\x7c\xa3\xf8\xef\xc1\x72\xd2\x43\x29\x05\x0c\x66\x51\xb0\xc6\xb1\xf8\x43\x51\x76\x70\x92\xc1\xc5\xba\x8e\xa4\x70\xb8\x1b\xf9\x58\x18\x9b\xab\x17\x91\x02\x56\xad\x6f\xa1\x3c\x70\x7e\x51\x88\x01\x33\xda\x48\xa0\xb8\xff\xc2\x1d\x02\xf4\x65\x49\xb6\xa5\x82\x6a\x0e\xae\x0d\x04\x30\x8d\x55\x11\xa8\xce\xd2\xcc\x98\x29\x67\x07\x77\xc8\xa1\xf4\x4d\x0a\x96\x46\x68\x4d\xe1\x2a\xdc\x18\x07\xe5\x40\x83\x02\xbb\x79\x67\x9e\xfd\xb4\xed\x11\xcc\x46\x29\xe4\x48\x9a\x81\xe8\x84\x77\xc2\x55\x10\x35\x1b\x89\x01\xcb\x82\x90\x6e\x39\x17\x2c\x58\x4f\x91\x5f\x10\x52\xc5\x35\x60\xcc\x02\x5f\x8d\x20\x02\xa1\xa5\x5c\xfd\x8c\x20\x6a\x09\x27\x08\x54\xbb\xfe\x32\xf0\x2e\x31\x8f\x62\x1d\x4c\xd4\x48\x10\xd0\xda\xed\x22\x49\x53\x30\x64\x1f\x00\xd4\x89\xb2\x96\xac\x24\xdd\x35\xf9\xff\x00\x12\x32\x02\x04\x84\xb1\x4e\x96\x82\x80\x42\xb6\xb2\xd0\x08\x3b\x04\x73\x02\xee\x0e\xc5\x8a\xc2\x0a\x62\x12\xff\xde\x22\xb5\x09\x4b\x6e\x5d\x24\x0e\x88\x67\x86\x88\x2c\xd8\x59\x2a\x73\xff\x82\xba\x31\xed\xa0\xb6\x4c\xa5\xfd\xbc\xf2\x9c\x63\xef\xa5\xc0\xf7\x97\xfe\x93\x4a\x80\x0a\x96\xbf\x5e\x59\x9c\xb0\x68\x4d\xad\x81\xbc\x5a\xaf\x6c\x6d\x3f\x6d\x50\xd8\x5d\x61\xe4\xb9\xd1\x81\x3f\x4b\xc8\xa5\x43\x79\xbd\xb8\x9d\xe2\x07\x73\xd4\x80\x65\xeb\xfd\x4d\xcc\x9f\x08\x64\x98\x28\xaa\x83\x28\x72\x8e\xb4\xaf\xea\x49\xbb\x4b\x2c\xa3\x3e\xc5\xf1\x4b\x08\x58\x40\x53\x06\x1d\x3f\x43\x55\xfe\xdc\x8f\xe5\x73\x71\x1a\x8e\xd2\x2a\xa0\x06\xe9\x1f\x1e\x0a\x9e\x54\x3b\x2f\x58\x6f\x7f\xfa\xc9\x6a\xe8\xd3\x87\x73\x16\x91\x26\xd5\xe7\xa7\x6b\xf1\x6c\x7f\xed\xc9\x6c\xe2\x7a\x78\xae\xc6\xa7\x2a\xb5\xa5\xd9\xc8\x38\x5c\x20\xfa\x5e\x7c\x39\x65\x2d\x9c\x20\xca\xe0\xa7\x7f\xcc\x1f\xc7\x12\x31\xa9\x81\xb2\x5f\x04\x19\xc8\x60\x52\x95\x91\x64\xa3\x1b\x6e\x27\x21\x55\x25\x4d\xec\x52\x03\x76\x87\xfc\x53\x3f\xd8\x81\x99\x92\x42\x8a\x09\x79\x19\xac\x5d\xda\x37\x77\x08\x7c\xf4\xeb\x84\x61\x94\xf0\xa5\x80\x63\xdb\xef\x6e\x22\xb6\x25\xee\xc9\xa3\x4a\x07\x0a\xd0\xb0\xa9\x04\xb5\x55\xa8\xcd\xe0\x64\xdb\xda\x01\xf4\x2f\xd4\x5c\xae\x4c\x61\x50\xc7\xe7\x32\x52\x09\x27\x10\xc5\x65\xe1\x23\xd1\x3e\x09\x1a\x9f\x69\xdf\xea\x56\xa9\xa3\xba\x91\x4d\x3e\x83\x77\xb8\xd2\xc9\x47\xf9\xd8\x62\xfd\x43\xc3\xb1\x88\x80\x2d\x47\x1d\x18\x36\x9c\xb6\x72\x5c\x5f\x9e\x37\x9f\x07\xed\x02\xc3\x1c\x44\x3e\x9d\x95\x25\xa4\x98\x98\x7a\x8c\x80\x44\x7e\xed\x2b\x97\x97\xaa\x84\x5f\x7e\x46\xab\x2a\xdd\x57\xf7\xaa\x01\xd7\x2e\x08\xcd\x80\x1c\x14\xc9\x96\x6a\x8d\x98\xca\x09\xb2\xfa\xa5\xd0\x68\x73\x0f\xd4\x10\x4d\x5a\x84\x14\xcc\x25\xd5\x6d\x29\x6e\x9a\x20\x08\x0e\xc8\xf0\x24\x9d\x08\x4a\x01\xb1\x44\x5e\x7c\x2d\xaa\xe8\x6d\x33\xf5\x48\xfe\x45\xbb\x4b\x50\xf1\xdf\xad\xcc\x0d\x32\x4e\xb9\x4e\x60\xe1\xa6\xdb\xf4\x75\x5b\x6c\x46\x88\x1f\x60\x2b\x54\xce\x56\xac\x1f\x05\xec\x60\xc0\x89\xb6\x92\x60\x5c\xd7\x34\xfd\xb7\x49\x21\x60\x38\xdd\x3f\x67\x8c\xf8\x9f\x52\x5e\xd2\xe7\xbf\xbc\x30\x66\xfe\x5d\xad\x57\xb5\x27\x15\x6f\x3d\x04\xba\xdd\xdf\x0b\x08\x38\x4a\xf1\xf5\x19\x09\xf0\xd4\x7a\x57\xdb\xb1\xe5\x4a\x75\xd7\xa7\x6b\x92\x69\xdf\xb7\x92\x25\x9b\xdf\xb7\x12\xc2\xef\x09\xe1\x33\x9f\x15\x54\x93\xb6\x4d\x11\x18\x07\x0c\x11\x5a\x17\x43\xfb\x86\xb4\xbf\x58\xbf\x6d\xa3\x19\x08\x74\x96\xe2\x56\x5c\x9f\x5f\xd5\x24\x94\x57\x37\xe5\x51\x3a\xfa\x44\xd5\x25\x35\xe4\x61\x14\x99\x3c\x88\x96\x17\x44\x1f\x89\x68\x3f\xd8\x32\xcd\x1b\xa2\xc3\xed\x36\xed\xcc\xc3\x2e\x98\x0e\x32\xaa\x82\x3a\x51\xfc\x98\xc6\xdd\xa3\x8a\x28\xe6\x06\xe0\xbb\xc1\xf4\x9d\x49\x6b\x0a\xea\x01\xce\x61\x0a\x9d\x6c\xef\x5c\x1d\xc1\xd9\x7e\x80\x9b\xb9\xea\x49\x0f\x4d\xdf\x16\x31\x3f\xcc\x37\xcc\xf6\x91\xc7\x1d\xbf\x1c\x5c\xf4\xe7\xb8\x32\xce\xf1\xfd\x69\x1f\xb7\x56\x9e\x8e\x5e\x1e\x67\x45\x06\x0f\x51\x7a\x70\xfb\x12\xfc\x9e\xc3\x13\xc7\xad\x83\x93\xdf\x22\x14\x55\x40\x6a\x8d\xf8\x70\x89\xb8\x41\xc9\xeb\x52\xca\xf8\x54\x5c\x95\xec\xa9\xe0\x19\x48\x75\xfa\x72\x20\x3d\x81\x42\xa3\x6c\x42\xed\xf6\x09\x91\x04\x58\x3b\x98\xa7\x85\x31\xcb\x51\x42\x96\x69\x17\xf0\x83\xc7\x1b\x38\xae\x77\x72\xbd\xa6\x78\x71\x0f\x1d\xc5\xa5\x94\xf1\x81\xc5\xf3\x76\xd1\x78\x7e\x14\x9a\x3c\x61\x2d\xed\x85\x16\x53\xb5\xdc\xad\xbe\x80\x5d\x9e\x74\xf2\x4e\xb2\xcc\xaf\xba\xe0\xab\x0f\xf1\x7f\x9f\x69\x60\x28\x4b\xeb\x4d\x91\xa3\xb4\x04\xa1\xf3\xe5\xa9\xa8\x64\x79\xaa\x35\x59\x1e\x15\x28\x7f\xa5\x16\xe5\x93\x52\x14\x9c\x3a\xbe\x3d\xb6\x2e\x8f\x43\x96\xf3\x34\x7f\x9d\xe6\xee\xf6\xef\xe3\xb9\x2b\xaf\x76\xe5\xcf\xb4\xd6\xa5\x0d\x65\x25\xd8\x52\xc2\xfd\xf6\x25\x3e\xb8\xab\x8c\x5f\x9f\xb6\xd1\x41\xba\xbe\x21\x36\x14\x71\x79\x16\x96\x5a\x2a\xb4\xcf\xa8\x3a\x55\xda\x81\x31\xe1\xaf\xa1\x23\x97\x81\x19\x5d\xc1\xf6\x28\x25\x6f\x8b\x24\x9b\x82\x32\x26\x30\x5b\x08\x56\xb2\x02\x1b\xa7\xac\x4b\xeb\x15\x09\x1b\x1f\x8a\x02\x3f\x48\x02\xf5\xed\x33\x3d\x88\xe1\xac\x93\x01\xae\x28\xb5\xc2\xbc\x0f\x43\xd4\x85\xd5\x2a\x86\xaa\x0f\x4c\x23\x70\x00\x6f\x84\x24\x85\x11\x09\xba\x52\x9a\x7a\xd0\x03\xa1\xad\x02\x26\xee\x1c\xd2\x6c\x67\x63\x8c\xab\x31\xe8\x2d\xa1\x26\x88\x05\xf6\xfd\x6c\x0c\x72\x4f\xd6\x28\x9b\x94\x10\xbb\xcb\x94\x98\x23\x4c\xd0\x1a\x3d\x40\xc4\x62\x3b\x35\xe0\xa2\x51\x8c\x8d\xe2\x8b\x43\xaa\xfd\x3e\x10\x32\xb5\xc4\x68\xc1\x91\x93\x5d\x1c\x0b\x11\x0b\x02\xd7\x64\x44\x46\xda\xb9\x56\xc9\xc9\xef\x31\xe0\xb7\x49\x4c\x59\x7a\xb8\x9b\xa7\xb7\xc3\x5d\x1d\x29\xe4\x52\xad\x21\x0c\xad\xa9\x0c\xbf\x33\xd5\xbd\xb4\x87\x6e\x21\x15\x19\xce\xaf\x7b\x61\xad\x7a\x8b\x36\xb9\xbe\x91\x04\x93\x10\x47\xd5\xe3\x6c\x4f\xc6\xbb\x99\x6b\x2b\x8f\xb2\xd9\x85\x88\x01\x1a\xd1\x25\x18\x5f\x99\x68\xc6\x92\xcc\xb0\x53\x76\xdf\xdd\x67\x33\xa6\xa1\xf0\x07\x30\x18\x58\x6a\x17\x5b\xdb\x9c\x71\xdd\x91\x6c\x07\x1f\xa0\x24\xd3\xcd\xff\xc9\x11\x71\x40\x60\xac\xe5\x1b\x81\x6d\xee\xe1\xb1\x6a\xe7\x1b\x85\x7f\xc4\x22\x3c\x13\x66\x3e\x5a\x02\x5a\x56\xc4\x6b\x7a\x6b\x60\x89\x3a\xfb\xfd\xd5\xed\x0b\xa5\x59\x66\xb4\xc3\xfc\x5d\xad\xc0\xa8\x2d\x5c\xe6\x68\x03\x52\x76\x5a\xe8\xe1\x21\x0b\x61\xf4\xb3\xa3\x15\xc4\x5b\x61\x16\x3b\x03\xa7\x46\xbe\x95\xab\x83\xb7\xe0\x99\x23\x91\x27\xe2\x12\xa1\x79\x72\xa2\xf5\x4a\xb8\x14\x1a\x99\x11\x76\x73\xbf\xc3\xaf\x26\x92\xd7\xd4\xd0\x6b\x11\xee\x93\x04\xaa\xf6\x91\xc4\x4a\xbf\x2f\x1d\xb7\x8b\x2c\x2d\x6b\x95\x24\x02\xe7\xfe\x0a\x17\xe8\x3e\x40\xbb\x45\xb0\xa2\x82\x84\xc8\x9b\x55\xdc\x8c\xa2\x34\x4e\x82\x20\xea\x89\xe1\xba\x08\x82\x2d\x3a\x0b\x28\xc1\xc7\x33\x39\xf0\x60\x77\xb6\xbb\x28\xb6\x16\xc8\xbc\xcb\xb8\x0e\x67\xe3\xdb\x49\xe2\xff\x38\x45\xbb\xc2\xfb\x38\x09\xb0\xbc\x76\x2f\xa4\xa9\xee\xc4\xa9\x95\x9a\xa8\x09\xd0\xc8\x1f\x3f\xd5\x8d\x99\x1b\xe3\x77\xf0\x71\x4a\xd2\x3a\xe1\x48\xb5\x34\x46\xd2\xd1\xf6\x81\x5a\xb0\xe4\xcb\x87\xd4\x89\x0a\x7e\xeb\xa9\x48\x4f\xd6\xd7\xd2\xa3\xf3\xf2\x79\xf8\xaa\xbe\x5c\x6a\x5f\x43\xf8\xbf\x9e\x4b\xad\x55\x4d\x0f\x6c\xb5\x05\x70\xdd\xaa\xbe\xbf\x5d\xaa\x7e\x9f\x08\xca\xfb\xef\x3f\x20\x6d\xf6\x4d\x9f\x59\x3c\x3c\xe4\x3b\x35\x79\xad\x8d\xea\xb0\x90\xc1\xc7\x3d\x8c\x46\x80\xfc\x68\xe5\xfd\x0d\x49\x71\xa9\x1a\xdb\x34\xc0\xf3\x4a\xad\x35\x9f\x12\xaf\x7b\xef\x41\xdf\xde\xad\x51\xe9\x0f\x16\xc4\x0f\x6e\xfe\xf6\xcf\xbb\x7b\x51\xd2\xea\xff\xfd\xed\x74\x5a\x17\x3f\x6e\x8c\x47\x4b\x3d\xb7\xe2\x97\x31\xa5\xff\xf7\xa5\x0a\xf6\xd7\xfc\x50\xc4\x11\x48\x0f\x9e\x01\x56\xe6\xeb\x81\x46\xa2\x74\x8b\x32\x0e\xf9\xe1\x8f\xe7\xbd\xe2\x0f\x7e\xc7\x5e\xf8\x01\x98\x84\xa4\xc9\xca\xb6\x58\x83\x3c\xdc\x8e\xda\xb1\x11\x20\x30\x54\x48\x9d\x0c\xd2\x9f\x9e\xe2\x78\xfa\xfa\xd8\xe3\x12\x3b\xc2\x29\xb6\xeb\xdc\x0a\xe2\x2b\xbf\x20\x26\x79\x4b\x9f\x1e\x7d\x3b\xfe\xf0\x13\x72\x80\x67\xde\xf5\x68\x7c\x9c\x45\x40\x07\x1a\x3c\x6a\xe6\x06\xa3\x7f\x6c\xd7\xb6\xa9\x69\xb4\xc4\x43\xbe\x18\xbf\xf5\xa5\x1c\xf2\xd7\x07\xa9\x1d\x6a\x2f\x40\x6f\x3d\x06\x4b\x0d\x12\xf4\x64\x51\x49\x9c\x9a\xed\xcb\x28\x8f\x52\x97\xb1\x01\xed\x21\x9a\x2f\xc6\x27\x5f\xcb\x92\xda\x76\xfe\xde\xb0\xdc\xa5\xd8\x7f\x1f\xa4\xa0\xe4\xc9\x8e\xc7\xf9\xe3\x1b\x8d\x37\x6e\x66\x26\xda\xcd\x2d\x7e\x05\x00\xb2\x06\x92\xad\x03\x3e\x69\xbc\x3e\x89\x52\x9a\x52\xf5\xad\xa0\x02\x73\x19\x51\x0c\x40\x49\xc2\xd0\x4c\xe4\xa2\xe4\x57\x79\xfa\x7e\x3b\x9e\xf6\xda\x21\xf8\xcb\x93\x6c\x8f\x93\x07\x73\x2c\x2e\x8a\xfc\xda\x48\xd7\xfd\x1c\x8f\x9b\x7c\xba\xf5\xc7\x13\xfd\x6f\x4c\x3f\xfe\x4f\xa9\x2f\x05\x5a\xbf\xfe\x4c\x75\xb6\x76\x49\x13\x38\xac\x28\xf9\x2e\xc9\x28\x13\xeb\x4f\x92\x23\x6d\x8b\x3a\x31\x41\x55\x03\x34\x7b\x26\xe9\x83\xcf\x25\x74\x42\x0d\xda\x0a\x2c\xac\x8a\xc2\x81\x30\xf7\x5a\x4e\x25\xef\x56\xd2\x28\x09\x3e\xb5\xd0\x25\x83\xaf\x84\xaa\x06\xad\x09\x39\x4d\xbf\x6c\x4e\x65\x7a\xab\x03\x45\x9b\x6d\x73\x03\x05\x74\x61\xa5\x10\x77\xdc\x80\xc5\xfe\xc8\x60\xff\xed\xe2\xbb\xff\x56\x37\x24\x27\x5a\xd9\xa1\x2e\xd6\x04\x6a\x2f\x16\x06\x50\xb1\x14\x99\x15\xed\xe1\xf3\x57\xcc\x2a\x18\xc8\xec\x55\x07\xb7\x85\xdc\x75\xfc\x11\xdf\x15\xfd\x82\x47\xe1\x20\x9c\x0c\xbb\x1c\x4f\x5f\xcf\xcd\xe7\xfe\x8f\x73\x5c\x08\x23\x4b\xcb\x98\x1b\xd6\xbb\x4b\x01\xe0\x5b\x68\x00\x30\xb2\x18\x4f\x8a\x42\x5f\x49\x42\x51\xa1\xa0\xca\x45\x4e\x37\x5f\x21\x3b\x03\x3d\xf4\x94\x34\x33\xe4\xaa\x72\x08\xdd\xfb\x3f\x11\x53\x71\x57\x1e\x3e\xf9\x06\x05\x4c\xb9\xed\x12\xbc\xd2\x67\xbc\xfa\xfc\xf6\xfe\x26\xbd\x42\xc7\x66\x12\xbb\x3d\x2f\x81\x7c\x22\xf3\x67\x4e\xf1\xf2\xc9\x52\xad\xd4\x2c\xc7\xe7\x8e\x33\x22\xd2\x2d\x39\x2a\x57\x24\x6f\x50\xc0\xcb\x3b\xf7\x0f\xd9\x10\xc6\x06\x58\x07\x29\x16\x05\xce\x9f\xa8\x8a\xbc\x46\x23\x8e\x47\xb8\x61\xb6\xd7\x70\x03\x45\x79\xa5\xe6\xe2\x63\xf6\xb3\xd3\x32\xda\x71\xc6\x36\xb0\xcf\x73\x10\xe3\xf8\x78\x36\xb4\x46\x29\x13\x2d\xbc\xa0\xa4\xe3\xc7\xaf\xe1\x07\xed\xb2\xb1\xd1\xbe\x7b\x17\x9f\x35\xc8\x17\x43\xfb\x25\x84\xfc\xeb\xcf\xca\xad\x5a\x9e\xa9\x6b\xde\x74\xb8\x7b\x3d\xf0\xb9\xf8\x17\x6a\xf6\x99\x35\x37\xf5\xea\xfb\x7f\x2c\x02\x4e\xaa\x20\x81\xbd\x4b\x99\xc8\x39\xf8\x67\xa9\xe5\x0e\x1a\x36\xc5\x20\x5a\xb4\xa0\x68\x72\x6b\x96\x4c\xed\xb6\x51\x73\x55\x99\x0c\x20\x3e\x68\xcc\xa4\x43\x37\x66\x32\xca\x46\x25\x0a\xa9\x93\xdf\xfc\x4b\xb5\x24\x50\x3c\x76\xaf\xaf\xc7\x31\x8b\x1f\xc4\xea\xb1\xad\x01\xeb\x60\xbc\x9c\xdb\x5c\xbc\x83\x31\xef\x0b\xdd\x15\x74\x13\xcc\x42\x65\x33\xf8\x7c\x9b\xb9\xbd\x57\xf2\x06\x57\x52\xa7\xb7\x3b\x74\xb6\x27\x38\x93\x17\x9b\x80\x93\x2e\x36\x0f\xff\xb4\xc9\xed\x6d\xe2\x00\xdf\xdf\x4f\x50\xbe\xa2\x24\xac\x2f\x91\xf1\x5f\x5f\x74\x8b\x9f\x3a\x45\x88\x37\xdf\x17\x72\xd5\x7c\x32\xe8\x20\xaa\xfe\xbb\xa8\x6d\xa6\x7e\x32\xfe\xb4\xb6\xd4\xf2\xf8\xfb\x2e\x30\x4c\xff\xcc\x13\xdc\x7e\xff\x15\x5a\xc9\x7f\xef\x23\x34\xba\x0a\x0b\xb5\x60\xdd\x4f\x0c\xbb\xdf\x7d\x97\xb9\x56\x81\x5e\x15\x2a\xbf\xb8\xdc\x02\xc8\x43\x42\x9d\xb9\x2e\x46\x22\x55\x37\xdc\xbe\x6a\x87\xdb\x5f\xb9\x4d\x50\x94\xfc\xad\x0d\x81\xc9\xfa\x6f\xec\x8e\xb7\xa0\x4b\xf9\x7b\x1f\x02\x8b\x58\x96\x76\x87\xd6\xb3\xbf\x3d\x12\xd4\x53\x62\xdf\xb7\xe9\x8e\x2f\x88\x37\xe2\x33\xbb\x87\x96\x63\x67\x54\xb8\x40\xd4\x18\x1c\xdf\x6e\x16\x1c\x01\x96\x06\x7a\x15\xaa\x8e\x0d\x0c\xec\xc4\x16\x68\x49\x51\x94\xc5\xc8\x03\xbf\x32\x60\x82\xad\xa4\x80\xf2\x23\x58\xb8\x7e\x9d\x66\xe9\x2d\x14\xbd\x88\x1b\x81\xb5\x44\x22\xfb\x72\x3e\xca\xdf\xdf\x58\xb3\xe9\x17\x1d\xbc\x5c\x49\xf5\xf6\x3a\x38\xbe\x9a\x11\x5f\xd2\x5a\xbf\xbe\x56\xdf\x3d\x66\xc4\x9e\x4b\xf2\xc1\x74\x87\x5a\xd6\xa7\x6e\xfa\x83\xbc\xe8\x13\x0f\x1e\x7c\x83\x9f\x78\xf0\x55\x74\xd3\x32\xd3\xe8\xb6\x77\x16\x9c\x25\xb5\xb5\xc0\x4f\xa7\x3e\x0c\x2e\x9a\x0b\xa2\x00\x77\xff\x42\x07\xdf\x9b\x08\xb4\x87\x95\x86\xd1\x1f\xba\x6a\xff\x3c\x9e\xd0\xdb\xf0\x4b\xef\x08\xb8\x1b\x78\x60\xde\x6f\x6f\xdd\xfd\x1b\xd8\x4a\xaa\x85\x81\x9f\x4f\x44\xd0\x74\xbc\x8a\xa0\xc5\xc0\xfa\x93\x07\x7f\xf1\x02\x5f\x92\x42\xbf\xfe\x54\x5e\xba\x57\x94\x28\xdb\x6e\x84\x65\x80\x92\x80\xda\x48\xfd\x82\x89\x66\xb0\x6a\xe7\x8d\xca\xb0\x35\x6f\x91\xc7\x83\xc7\x06\x9f\x10\x65\xd5\xd4\x4d\x96\xc1\xc2\x08\x24\xbe\x25\xe3\x0c\x06\x1b\xa0\xe9\xba\xc8\x90\xbb\x0c\xd9\xfc\x17\x03\x7b\x39\x40\x1b\xac\xde\xf2\x41\x2c\xc4\xfd\x20\xbe\xed\x27\x04\x9e\x15\x41\xe9\xf3\xe2\x25\xbb\x63\x24\x3b\xef\x76\x4a\xb2\x4e\x78\x7d\x3f\x3e\xbf\x7b\x90\x51\xc9\xa6\xa4\x0b\x29\xb7\xcd\x1f\xa8\xe4\xfc\xc9\x19\xbe\x6a\xdd\x97\x14\xcf\xaf\x2f\xa5\x43\x1f\x60\x95\x96\x3a\x2d\xe9\x61\x04\xd9\x20\x5b\x42\x2f\x9f\x55\x2d\xf3\xf1\x07\xbf\x33\x97\x1a\x5a\x6b\x83\x38\x89\x24\xc5\x8e\x73\xa7\xe3\x3a\xf4\x38\xcf\x68\x40\x1a\xd6\x8f\x17\x7b\xba\x94\xf1\x42\xfb\x32\x58\x14\xf7\x47\x2e\xb7\x83\xa7\x20\xce\x71\xf0\xb4\xe7\xf2\xd3\xa4\xdd\x5b\xeb\x41\xcb\x63\x4a\x41\x50\xf7\x0e\x23\x75\xbf\xfa\x37\xdd\x97\x11\x65\x6e\x8c\x45\x23\xeb\x8d\x3b\xd7\x76\x5f\x5a\xb7\xbd\x10\x21\x33\x46\xd4\x6e\x0e\x98\xc6\xf8\xc0\xc4\x0c\x51\x5f\x39\xba\xbf\xca\xc0\xe1\xe6\xb3\xea\x55\x0f\x24\x77\x15\x2c\xf5\x09\xcc\x43\x7d\x47\x74\x9b\x4a\x40\xe0\x44\xaa\x40\x3c\x54\xd9\xf1\xbe\x45\x46\x1a\x9d\x1a\x69\x2c\x9c\x45\x5d\x61\x5a\xf4\xf4\x22\x0f\x37\x6b\x0f\x54\xf5\x94\x6f\x48\x04\xa3\xca\x4f\x59\xed\x0b\x49\xf9\x13\x2a\xad\xfd\xe8\x4a\x75\x85\xdb\x9b\xf4\x66\xa9\x91\x84\x03\x1c\x81\xee\x2d\x10\xad\xa4\x3b\xc8\x07\x46\xa4\x19\x4a\xab\x3b\xb0\x5e\x84\x3a\x81\x19\xb7\x80\x69\xaa\x30\x2c\xef\x1e\x85\x54\x00\xad\xaa\x80\x37\x01\x0a\xb7\x92\x4c\xdb\x1d\x7c\x5e\x7a\x56\x6e\x1d\x24\x32\xac\xcc\xca\xd9\xd8\x0b\xeb\x26\xc9\x25\xdf\xca\x0e\x58\x06\xc8\x0f\xf1\x0b\x24\x84\x3b\xcb\x47\x70\x15\xb8\x5f\x95\x70\x5b\xd5\x54\x9a\xed\xb4\xcb\x91\xfc\xec\x0a\xf1\x21\x6f\x45\x1f\x57\x05\x71\x2c\x7f\x9f\x80\x16\x25\xe2\x81\xfa\x2d\x30\xcf\xe3\x4e\x24\x5a\xd7\x84\x30\xbe\x1d\x28\xd2\x95\x55\xb4\xf6\xbd\xa1\x3e\x58\x08\xe3\xc2\x1d\xa9\xdd\x97\x36\x21\x71\x44\x14\xbc\xf6\xe4\x63\xfe\x58\x7c\x85\xfd\x72\xc2\x7b\x49\x96\xfc\xfa\x53\xc9\x65\xf7\xd7\x60\x42\x14\x2b\xeb\x22\xa5\xde\xfd\x8b\x14\x94\x4d\xcf\xf2\xf3\x8d\x56\x74\xd3\x6a\x49\x6b\xb9\xf7\x89\xde\x3d\xdd\x00\xcb\x65\xae\xfe\x56\x16\x95\xbe\xa9\xf4\xa4\xd2\x57\x9b\xc3\x87\xc9\x44\x8d\x33\xc8\x98\x05\x32\xf0\x6e\x62\xf8\xe9\x4d\xdb\xe6\x07\x24\xff\x67\xf5\x7f\xee\xf8\x62\x73\xdc\x45\xea\xd8\xdc\xd5\xd4\x31\x57\x29\xe3\xcb\x56\x78\x49\x50\xfc\x7a\x11\xf6\xf5\x6e\x7e\x3f\x6e\x35\x74\x24\x71\x75\x52\x78\xc1\x72\xa5\xdc\xb2\xf7\x36\x2a\x27\xec\x48\x0f\xcd\x00\x67\xb2\x14\x1b\x51\xbd\x31\xe1\xad\xa3\x64\xde\x3b\x0e\xaa\x64\x35\x95\xa4\x6d\x07\xd6\xd7\xdc\xae\x3a\x64\x48\x52\x69\xbb\x30\x7e\xd5\x51\xb1\x24\x01\xa7\x40\x5d\x20\x93\x8f\x46\x89\x75\x77\xe2\x23\x6d\x37\xcf\xb4\x9d\xbe\xbf\x35\x37\xd2\xdc\xc8\x47\xd4\x89\xdc\x8a\xdd\x57\x1d\x90\x1f\x4e\xb7\x6f\x00\xbb\x8f\x47\x19\x44\x7d\x2b\x72\x5b\x06\x06\x33\x4d\xcc\x3d\xa5\xee\x03\x28\x75\x80\xb7\x9b\x2f\x4c\x00\xfc\x14\xcc\x1d\x89\x79\x4d\x77\x75\xfd\x02\x7d\x07\x02\x60\x86\x04\x63\xdf\x20\x26\x59\x76\x2c\xbe\xc9\xa2\x98\x1c\xe6\xe0\x09\x7a\x43\xcd\x21\x38\x4f\xc0\x6b\x86\xb6\x63\x16\xb0\xb9\xcb\x1e\x72\x8c\xde\xec\xc8\x8f\xa3\x3f\x47\x21\x2f\x42\x21\xa3\x24\x1d\x7d\xf3\x91\xd9\xf9\x33\x26\x0d\x3f\x45\x69\x07\x6a\x97\x4b\xdb\xcd\x6d\xdb\x34\xcc\xdb\x5a\x28\xc0\x86\xda\x98\x1d\xb5\x84\x28\x26\x05\xf0\xca\x67\x5e\x54\x55\x65\x6f\xdd\xc1\xd0\x79\x00\x44\x7b\x1f\x69\x64\xdb\x89\x59\x89\x2c\xa0\xea\x4e\xdd\xfc\x28\xb3\xee\xb2\x2d\xd6\x47\xaa\x73\x78\xab\x81\xa4\x22\x35\xdd\x8b\xf8\x0d\x28\xa8\xe8\xa2\xc6\x1b\xe5\xc9\xc2\x02\x53\xe4\x43\x61\x63\xed\x98\xc9\x70\x51\x12\x89\x40\xbc\xa4\x13\x5c\x5d\xdc\x35\x9c\xd8\x07\x5e\x7d\xf3\x05\x85\x6a\x1c\x60\x5f\xd0\xc9\x8c\x05\xb0\x19\x35\x21\x68\xa4\xb6\x41\x7d\x03\xa5\xfa\x2c\x7d\xc6\xda\x6e\x0a\x98\x24\x6a\x05\x46\xbf\xed\x92\x24\xf5\x0a\x6f\x41\x20\x32\x29\x89\x31\x8c\xe2\x76\xba\x4d\x6f\x0e\x7f\x16\x5f\x26\x0a\xcb\xf7\xa8\x2f\x02\x96\x0a\x2c\x33\x3e\x97\xdf\x97\xaf\x06\x5a\x7b\x4d\xf4\xfc\x54\x1b\x18\xc6\x2a\xb8\x26\x6d\x50\x9e\x79\xf5\x2f\x24\xfb\x14\x50\x80\x96\x48\x38\xb5\x92\x91\x70\x6a\x25\xc7\x36\x66\xa3\x5a\xc9\xdc\xe8\x5f\xb8\x11\x56\xee\x75\x60\x15\xe6\x1c\x2b\xd8\x0d\x02\x1e\xfd\xc3\x6d\x23\x84\xa0\x3f\xdb\xf6\x94\xfe\xfa\xb0\x51\xab\xbb\x12\x7a\x9f\x2d\x07\x91\x74\xc4\xf4\x99\x64\x5b\x4a\x94\x78\x4c\x26\xdb\x6e\x94\x6a\x7d\x7f\x93\x09\x69\x35\xbd\x4b\x1e\x63\x5d\xce\x79\x70\x30\x35\x1f\x39\xe7\x56\x30\xc3\x5d\xd9\x3f\x26\xff\xca\x59\xd1\xea\xb6\x32\x52\xca\xed\x47\x6a\xc7\xeb\x22\xcd\xd7\xb8\xcf\x88\xcb\x79\x65\xf7\x11\xc0\x37\xdd\xe7\x57\xc9\xf7\xf6\x9a\x2a\x7a\xe1\xfa\x7b\x79\xc1\x76\xc2\x81\xa6\xa5\x6e\x51\xf4\x8e\xcc\x16\x2a\x38\x31\x83\xd6\x72\x80\xba\x25\xa9\xc6\x97\x45\x35\x72\x32\xb5\x84\x96\x2b\xe9\x0a\x22\x4b\xe7\x7f\x7d\x3b\x97\x1e\x85\x5f\x97\x48\xac\xaa\x08\x3b\x4b\x54\x89\x83\x2a\x92\xbf\x69\xe8\x95\xb2\xc6\x1f\x24\x2d\x85\xd0\x89\x4b\x06\x0f\x7e\x6f\xaf\xa1\xe0\x3e\x2d\x34\x05\xdd\xc9\xd8\xfb\x48\xdd\x4d\x9b\xe6\x0e\xd6\xa1\x66\xa9\x14\x7c\x2c\xa5\x1c\x42\xe6\xaa\x88\x80\x87\xb0\x50\x08\xa8\x0d\x3a\xc5\x7e\xf6\x33\xcd\x07\x5c\x73\x6d\x3d\x55\xb0\x16\x48\x78\xbd\x6e\xe1\xd8\x49\xc9\xe8\x7d\x9c\x84\xe1\x0a\x0a\x39\x98\xa8\xc8\x8b\x48\xcf\xd1\x42\xb4\xa1\x2a\xe5\x94\x99\xb2\x02\xf3\x23\x7e\x82\x37\x46\x4e\xe6\x0c\xe2\x0c\x3e\x58\x3c\x96\xa6\xd0\x59\x73\xcb\xd4\xe0\x18\x26\xcd\xf5\xb0\x91\x53\x37\x7c\x2c\xfe\x49\x38\x47\xfd\xf0\x5c\xfa\x78\xae\x78\x2a\xc5\x33\xdd\xde\x64\xd8\x48\x03\x6b\xa9\x44\xe1\x2f\xca\x16\x67\x22\x6e\x0f\x1c\x59\xca\xaa\xa0\x02\xe0\x0a\x4b\xd1\xf8\x7d\x89\xe2\xb5\x1e\x5c\x9c\x94\x6b\x89\x6c\x81\x42\xb9\xf2\x7c\x98\x1f\xbf\x27\x19\x1d\x18\xab\x52\x00\xeb\x39\xaa\x76\xe0\xa7\x2a\x22\x02\xd9\x2d\x62\x54\xb5\x8f\x2f\x5f\x95\xc6\xab\xfa\x62\x50\xbc\x26\xc6\x7e\x56\xda\x66\xa3\xa4\x4c\x7e\x3e\xf2\xb0\xd3\x27\x03\xdd\x12\x89\xe3\xc9\xbc\xc4\xef\x34\x00\xb0\xcb\xd3\xd7\xa7\x3d\x1e\xc7\x5d\x27\x3b\x55\xe6\xfe\xde\x6b\x84\x36\xc2\xef\xbc\xca\xed\xcf\x5e\x06\x73\xfd\xbf\xa2\xbd\x7e\xff\xb3\xfc\x91\xab\xdc\xbe\x6f\x32\xc6\x82\xfe\xce\x87\x39\x57\xce\x7f\x41\x9b\xfd\xfc\x61\x6e\xff\x94\xa7\xa9\xd6\xd2\x13\x2b\x38\x59\xc2\x8f\x93\x33\x3c\xf8\xc6\x97\x57\xc2\xf1\xe0\x1b\x8f\x1d\xb8\x3b\x8e\x8d\x16\xfa\xdb\x5f\xc4\x2d\xd2\xfc\x79\x8c\x47\xd5\x4d\xa8\xb5\x33\x86\x06\x73\x21\x3f\x85\xd5\x2e\xd5\xd0\x8f\xc5\x3d\x1f\xac\x88\xf5\x43\xe1\xd1\xc3\x1e\xc0\xc5\xfe\x05\xbd\xab\x81\xbc\x33\x07\xfd\xf7\xe7\xec\xee\x37\x70\x6b\x8c\x4f\xf9\xdd\xe3\xa8\xef\x08\xde\xb1\xfb\x2b\x83\xfc\x57\x53\xef\x6b\xe2\xf2\x97\x07\xd0\x40\x66\x1a\x33\x43\x74\x60\x10\x6c\xa8\xd9\x2d\x21\xf7\xd2\xa1\xf1\xd5\x50\xf9\x58\xd6\x05\x3a\xc3\x2c\x39\x28\xa7\x72\x13\xa2\xdd\x1a\x4c\x70\x32\x37\x38\x5b\x16\x22\x63\x52\x89\xf3\x68\x11\x64\xa0\x66\xfb\x49\xb8\x87\xd8\x8e\xd6\x0b\xe5\x6f\xee\x1b\x1e\xee\x27\xb5\x1d\x74\x47\xa8\xee\x91\x36\x8e\xc7\x97\x9e\x24\xf8\x7d\xf8\x65\x47\x38\x01\x12\xec\xab\x98\xa0\x3e\x0a\x95\x34\x2d\xa9\xec\xd2\x6b\x32\xd2\x52\x4b\x21\xe1\xcd\xac\x49\xaa\xfb\x91\xed\xe6\xde\x63\x87\xac\xa0\x98\xed\x92\x1a\xd8\x49\x7a\x40\x48\xe5\x20\x00\x7b\x87\x9d\x30\x13\xd9\xb4\xdc\xca\x35\x28\xeb\xf7\x60\x05\xeb\x24\xc8\x53\xf7\x67\x11\xfa\x30\x0b\x6c\xa6\x31\x46\x62\xc1\x63\xef\xef\xbf\x9c\x52\x8e\x20\xf7\x44\x3a\x1f\xd9\xfc\x00\x97\xfb\xcb\xa4\xde\xf2\x08\x86\x3c\xc0\x37\xa3\x66\x1a\x89\x8b\x95\xf8\x21\xb2\xb3\x1a\xdb\xe5\x81\x11\x1a\xdf\xc8\x03\x26\xa5\xcb\x5e\x93\x4e\x30\xa3\xa4\x32\xa8\x2f\x2f\x73\xad\x73\xdc\x76\x2b\xde\x83\x88\xa2\xb2\x43\xe8\x8c\xba\x27\x8b\xa7\x11\x82\x32\x10\x56\x39\x41\xe1\xf3\xab\xf2\xa8\xf6\x9a\x07\xfd\x19\xc1\x66\x29\x92\x46\x2b\x3b\x2a\xcb\x00\xbe\x6e\x3b\x60\xc3\xd6\xdc\xff\x86\x2f\x8d\x1e\xe7\x76\x9f\xf6\x54\xc0\x0e\xdd\x7a\xea\x65\x92\x91\xbf\xa1\x98\x18\xd5\x3b\x04\xdd\xae\xd6\x91\x34\xcb\x39\xd5\xdc\x77\x92\xba\x81\x0a\x0c\x85\x35\xd3\x10\xc1\x32\xd6\xcd\xb4\x54\x67\xd9\x91\xbb\x16\x50\xf7\x94\xb9\x2b\xaa\x57\x4b\x4e\x66\xa0\x10\xf6\x29\x30\xcf\x89\x44\xc1\xae\x28\xb1\x51\x2c\xe6\xb0\x20\xc9\x8c\xce\x3f\xba\x1b\xd9\xeb\x52\xbc\x2f\x17\x49\x0d\x3c\x5b\xd5\xfc\x35\xe8\x5a\xac\x3e\x5c\x2a\x32\x5d\x33\x6c\x21\x69\x19\xa2\x70\x56\x2b\xd4\x7d\xeb\x64\x1c\x1d\x41\xb2\x8c\xd7\xde\x52\x75\xa3\xbd\xf8\xf3\xa2\xc6\x65\x9c\x48\x69\x51\x7f\xe4\xea\xb7\x8d\x32\xea\x78\x99\x2c\xfb\xf0\xfe\x8c\x08\x44\x8e\x50\xc4\xa8\x3f\x9f\x24\x50\x81\xf8\xff\xbd\x38\xa6\xbf\xbd\xf0\x70\x3e\x69\xd2\xcb\xec\xee\x92\xb8\xef\x64\x48\x32\x58\x4f\x0d\x2c\xd7\x1b\x85\x22\x68\x34\x6a\x3b\x66\x82\x6a\xa1\x37\xca\xfb\x5b\x35\x49\x4d\x64\x5b\xea\x48\xc4\xc2\x09\x90\xb8\x38\xd9\xea\x56\x3c\xe7\x0e\xdb\x89\xb7\x9c\xa9\x20\x82\x68\xed\xfd\xad\x4b\x4e\xb3\x21\x79\xa0\x50\x36\x24\x8f\xde\xc4\xe2\xd0\xc9\x5c\x25\xa4\xc7\x04\xb3\x07\x94\xeb\x8c\x9a\xd7\xab\xf4\xba\x69\x93\xd4\x8a\xac\x8b\xf4\xf6\xfe\x36\xca\x04\x69\xa8\x34\x52\x68\xb6\xa2\x70\x04\x7d\xfe\x96\x9e\x66\x21\xc9\x0b\x2c\xe2\xe2\x9f\x88\x0b\xb1\xe0\x04\xbe\xd1\xa4\x1b\x21\xd5\x62\x98\x2a\x4b\xf6\xa4\x97\x33\x46\x00\x1e\x29\x41\x2d\x2a\xa9\xa8\x2c\xfe\x2b\xed\xa0\x5c\x6f\xbb\x88\xb0\x6a\x4b\x66\x1b\x45\xa2\xa9\xed\xee\xd3\x16\x28\x55\x22\xc3\x81\x22\x2f\x4c\x21\x00\x9f\xa6\x3a\x8f\x01\x4c\x15\xcb\xda\x40\x42\x58\x72\xf2\xeb\xfb\x00\xf0\x9e\xdf\x05\x30\x03\xf5\x95\xc4\x57\x57\x4d\x8c\xbc\x20\x26\x9e\x63\x02\xd9\x7b\x06\x37\x21\x0a\xbd\xa0\x12\x3e\xe0\x3b\x6b\x3a\xfd\xf5\x1b\x08\xf4\xa0\x8b\xea\xce\xe6\xb6\x28\x78\x41\x87\x7b\xc4\x65\xb3\x9a\x66\x5b\x55\x74\xaf\x8c\x19\xf9\x7a\xd6\x56\xa9\x25\x64\xb2\x7d\x39\xbe\x73\x21\xff\x81\xd2\x89\x7b\xc4\x9f\x2f\x85\x3c\xe8\xbb\xa5\x10\xbb\xff\xf1\xa5\xf0\x25\xb7\xf5\xdb\x0b\xa9\xe5\x73\x17\x07\x55\x91\xa0\x97\xea\x48\x88\xbb\x0f\x49\x03\xaa\xb8\xcc\x47\x70\x1a\x2d\x2c\xc1\x8c\xf2\xc8\x1c\x00\x37\x0e\x4a\x77\x36\x4b\x08\x47\x75\x2e\x1a\x25\x9d\x3f\x8c\xe3\x69\x37\xf4\x6a\x1e\x0d\x8d\x08\x20\xe0\x04\xf8\xfe\xeb\xb2\x10\x33\x00\x25\xea\x48\xda\xea\xb7\x7a\xc0\xfe\xc0\x2a\x20\x80\xbd\x6b\xab\x57\xf0\x07\x04\xe3\xbe\xfe\x62\x22\x44\x12\x81\x84\xb2\xb4\x5f\x32\x62\x91\xd4\xe3\xd2\x32\x6f\xbb\xcf\xb5\x3e\xe5\x75\x12\xbc\x4f\xee\xc8\xfd\x70\x3c\x0e\xf7\xd3\xfb\x48\x83\xf6\x83\xc5\x32\xc8\x8b\x2f\x8f\x7b\x82\x60\x04\xee\x73\xd1\x06\xed\x7f\xe5\xb2\xa6\x60\x5c\xab\x0f\x08\xe1\x09\x20\xd4\xa0\x3a\x62\x93\x78\x8b\x9c\x80\x41\x74\x6e\x4b\x27\x80\xb0\x9f\xad\x8b\xc6\x65\xb3\x9f\xad\x8e\x17\x42\xec\x20\x9b\x6e\x89\xeb\x21\x96\xd4\x52\xe9\xb6\xf6\xbb\xf9\x14\x70\x5f\xfc\xeb\x22\x7d\xb5\xbb\x74\x37\x45\x67\xad\xa9\xd4\xb6\x96\xbb\xe6\x75\xa9\x1b\x38\x85\x0c\x2a\xf1\xb6\x2e\x6e\x6e\x66\xdf\xb7\x6e\xf8\x7d\x2d\x9b\x1b\x0f\x77\xc8\x34\xc9\x74\xbb\xa0\x91\xf3\x6c\x5d\xec\x6e\xab\xad\x7a\x5f\x24\x36\xf5\xd5\xdc\x48\xaa\xab\x6e\x92\x04\xe1\x46\x49\x76\x2c\x92\x00\x19\x92\x75\xb1\x75\x61\x11\x83\xdd\xeb\x2a\xef\x6f\x6d\xb8\xf7\x0e\xcd\x0c\x14\x69\x0a\x23\xcf\xbb\x90\x40\x24\x34\x58\xb0\x6a\x9d\x4a\x15\x33\x30\x18\x72\x10\xc2\xa1\xfb\xa9\xe3\x92\x01\x22\xc2\x69\xd0\x3b\x86\xbf\xbe\x1d\xc8\x3e\x2e\x6d\xb7\x75\xe9\xd9\xed\x29\x45\x39\x28\x38\xd1\xa4\x7c\x77\x03\xbe\xd6\xea\x71\x66\xde\xae\x40\xf6\x67\xd7\x27\x7e\xf2\x0c\x19\xf1\xc0\xeb\xfa\x7d\xb4\x38\xf3\x60\xee\x07\x51\x71\x9d\x27\xc0\xe7\x8b\x2b\xb0\x77\x3d\x52\x80\xf1\xed\xa4\xe1\x8a\xf3\xa1\xe1\x0b\xa4\x52\x60\xb4\xc2\xd6\x42\x63\x24\x3f\x22\x84\x98\x7d\x32\x2d\x20\x95\x4b\x92\x40\xd5\x07\x2a\x0a\x7f\x47\x7e\x98\xe2\x53\x92\x1f\xed\xbd\xc9\x97\xee\xcd\xa7\xc9\xcd\x57\xa0\xfb\x22\xe0\xf9\x01\xc4\x09\xa9\x33\xb9\x2f\x78\xa9\x0b\xf1\x6d\x0a\x73\x8e\x3c\x1e\xba\x07\x33\xb5\x9f\xe3\xfd\xad\xce\xe9\x9d\x22\xdf\x47\x3d\x09\x02\xcb\x03\x1d\x86\xe7\x01\x53\x85\x69\x94\x29\x2d\x5a\x18\xe0\x2f\x24\x34\x2c\x17\x80\x0f\xba\x5d\x77\x69\x2b\xa4\x9e\xc4\xaa\x9f\x16\xed\x6b\xbe\xa4\xb8\x45\xcd\x37\x0d\xa3\xf1\xbe\xf4\xba\xea\xbc\xf7\x7a\xfb\xc9\x1e\xee\xbb\xd6\xd4\x7d\xc7\x36\xee\xad\xbb\xe5\x79\xc7\x6a\x25\x9d\xf2\x0b\x96\x50\xe3\x8d\xfe\x55\x28\xaf\x84\xf7\x53\xb9\xdc\x55\x39\xf8\xeb\x8e\x42\x2b\xec\xee\x83\xed\xfd\x6d\x16\x4b\xc0\x56\x21\x91\xd5\x53\x09\xea\x6b\x04\xe9\x83\x94\x03\x95\x0c\x35\xa1\x8a\x97\xfa\xdf\x40\xdb\x88\xdb\x11\x78\x72\x12\xe0\xd6\x4a\xbe\x21\xfa\x86\xc2\xce\x20\x34\x67\xe9\x53\x80\x98\x69\x6e\x10\xf6\x41\xc2\xe8\x14\xbe\xbe\xed\x01\x6f\x83\x56\x68\xbf\x7c\x1b\x3f\xe3\x46\x21\x20\xdb\x23\x07\xc4\x14\xc7\x8e\x67\x65\xb1\xb0\xcf\xd6\xdf\x62\x9c\xe4\x6e\x38\x66\x80\xd0\x83\x84\xd0\xf0\x7a\xfa\x39\xfc\x64\x26\xd5\x7b\x93\xb5\x8c\xbb\xf6\x75\x29\xe3\xee\x56\x88\xbf\x2d\xff\xd4\x71\x5f\xb4\xaf\xfe\xd1\x24\x88\x1d\xfd\xbe\x6b\x0e\xf3\xce\x1d\x64\x0c\xdb\x99\x48\x37\xf5\x49\xa3\xe3\x79\x35\x05\xf1\x9d\x5c\x89\x32\xff\x21\x0c\xed\xa0\x0c\x2f\x49\x95\xb0\x3a\x36\xd5\xa4\xab\x06\xb7\xc0\x1b\xd1\x0c\x1c\x60\x28\x7f\x61\x1a\x19\x42\x3a\x07\xcb\x81\xc8\x36\x02\xfa\xdd\xf6\x40\x4d\x7e\xda\x03\xdd\x85\x35\xf8\x21\x86\xd0\x28\x89\x84\xcb\x36\x41\x6a\x0b\x36\x39\xb7\xbf\xe1\x54\x0d\x4e\x08\xfe\x36\xce\x47\x38\x58\xa5\xe0\x3d\x08\x0d\x3f\x92\x34\xde\x7e\x89\xbb\x3f\xb1\x76\x4f\xf3\x0c\x5f\x4e\xcc\x02\x72\x9c\x9f\xb1\xe1\xb6\x53\xed\x0a\x07\x6d\x71\x2a\xcd\xf0\x27\x70\x7e\x70\x9e\xe7\x93\xf1\x9c\xad\xcb\xbb\xf1\x09\x71\x1a\x87\x6c\x8c\x08\x3c\x6b\x43\x02\x2a\x58\x84\x9f\x47\xc4\xf7\x27\x38\xae\x2f\xe7\xb6\x18\x19\x7a\x8d\x0c\xe9\x10\xfb\xfb\xac\x5d\x31\xfa\x8c\x03\xf7\xe7\xed\x3a\x9e\xda\x75\xb4\x76\x8d\x61\x51\xbd\xf1\x3c\x30\x0b\xea\x63\x14\x07\xb9\x60\x28\x5f\xc5\x6d\x62\x4d\x7e\x7c\x7d\xec\x11\x6f\xe3\x31\x9e\x31\xcd\x6a\xa7\xdd\xbe\x82\xe9\xe4\x9c\xe7\x8c\xb8\x40\xc0\x02\x89\xff\xe5\x26\x84\x44\x20\xd7\x4f\x24\x6f\xc2\x76\x4c\x95\x7e\xd4\x51\x59\x1a\x90\x53\x0b\x11\x7a\x4d\x3e\xe3\x72\xdd\xb4\x54\x76\xff\x45\x12\xd8\x67\xfc\x84\xed\xe2\x5c\x2a\xa7\x66\xbd\xfa\xfd\x3c\xa6\xfc\xcc\xf0\x6a\x22\xd1\xc9\x7f\x92\x4d\xfa\x52\x11\xf4\xdb\x0b\x64\xe4\xc9\x26\x35\xb1\xd4\x2b\x79\x09\xe1\x14\x83\x1e\x13\xcb\xbd\x4f\x39\xa8\x9c\x6e\xb0\x6e\x54\xdd\xe9\x21\xaf\x21\x95\xb1\x77\x0b\xc1\x06\xdf\xd1\xdc\xc2\x1f\x33\x0d\xbd\xd4\x07\xc1\x52\xef\x3e\xd0\xbc\x4b\x96\x55\xf3\xde\xbc\x1b\x92\x1d\xf0\xfd\x0d\x49\x0f\x5c\xba\x13\xe3\x2d\xd1\x61\x94\xc4\x67\xeb\x32\xeb\x7d\x31\xb3\x75\x56\x77\x5b\x08\xb4\xb1\x01\xfa\x7d\x41\x45\x86\x8e\xf7\xb7\x02\x72\x28\x5b\x5b\xbd\xfb\xbe\x4b\xe3\x41\xef\x6f\xdd\x72\x50\x10\x23\x62\x42\x50\x50\x64\x2f\x8a\xcf\x58\x4a\xd0\x04\x17\xc7\x19\x4a\x48\x48\x4a\x48\x4b\x41\xc2\x85\xba\xca\x60\xd2\x61\x4f\xad\x20\x64\xdf\xcc\xdd\x7c\x38\xe8\x46\xce\x72\xeb\x27\x36\xbe\x43\xd2\x03\xeb\x6e\x66\xc1\xe6\x1e\xc4\x7c\x23\xb0\x28\xad\x30\xdc\xb2\x93\x72\x22\x20\x86\x84\xc2\x28\x42\x8f\x76\x25\xe0\xa4\x9c\x7a\x13\x16\x10\x5f\x70\x5a\x65\xfa\x62\x05\x14\x8c\x0b\x19\xce\x09\x42\x25\x57\x2d\x78\x56\x87\xd1\x14\x32\x4d\x91\xf3\xce\x28\xa0\x2d\xb7\x7b\x8f\x1a\x00\xff\xaf\x07\xc1\x4e\xc1\x54\x03\x17\xd0\x60\xfc\x18\x44\xfc\x59\x8a\x55\x46\xe2\x9f\x3e\x77\xf7\x53\x11\x81\xf0\x67\x08\x73\x0f\x9c\xb3\x80\x06\x6e\x19\x19\x93\x57\x0f\x72\xad\x7a\x0d\xfc\x00\x3a\xa3\x2e\x0b\xbc\x0e\xfc\x86\xb0\x0a\x80\x65\x80\x1a\x0d\x9f\xb6\x81\x15\xcd\x29\xdf\x2b\x68\x39\x6b\x0a\xb8\x74\x21\x92\xea\x58\x94\x31\x54\x71\xcf\xc0\xc2\x7a\x63\x9c\xb5\x48\xc4\xa3\x88\xad\xce\x94\xc3\x5a\xa5\xb6\x79\xfb\x2c\x8e\x6b\x63\xa6\x5e\xdd\x9f\xea\x08\x94\x79\xd7\xa2\x5c\x1e\xf2\x7c\xee\x6a\xf8\x17\xa2\x0e\xc6\x71\x7e\x9e\x1b\x62\x47\x1e\x07\x41\x35\x49\x75\x94\x4d\x0a\x4a\x74\xd6\xa5\x33\x3c\x47\xb0\xc1\xf0\xe5\xbb\xe0\x47\x01\x55\x7c\xd1\x95\x61\x1d\x29\xe8\xca\x32\xca\xbd\x86\x5a\xf9\xcc\xab\x48\x8d\x3f\xeb\xbd\x97\xd5\x7f\xad\x7d\x5d\x04\xf9\x7b\xef\xe9\x2a\xb9\xe2\x40\xa8\x7e\x64\x37\x39\xf2\xde\x5b\x02\x8a\x35\x71\x08\xd0\x32\xe9\x76\xa3\xc2\x6b\x5b\x97\xd9\x39\xba\x5a\xbd\x8b\x0f\xb2\x6b\x1e\xeb\xc8\xe3\xb3\x7e\x16\xc2\xe8\x58\x5f\xe6\x85\x97\xb4\x89\xb9\x2c\x7f\x14\xc3\x9a\x81\xe9\x9f\xf5\x1e\x07\xd7\x96\xe2\x97\x23\x76\x59\x71\x18\x8e\x3a\x4f\x75\x9c\x67\xff\xe9\xbc\xf6\x9b\xfc\xf6\x12\x76\xfe\xed\x05\x2f\xf3\xc1\xd7\x9e\x69\xd4\xb2\x8e\xb9\xc1\x06\xcb\xe3\xfd\xad\x83\xbe\x68\x6c\xbd\xa4\x3e\xb7\xa5\xe7\xd4\xe7\xba\x48\xb3\xfb\x52\xe6\x2a\x05\x8a\xf1\xeb\xc2\x2f\x65\x15\x6a\xda\xb9\x3f\xd9\xb6\x49\xa2\xf1\xbb\x62\x85\x42\xaa\x13\x74\x96\xc6\x80\xac\x4f\x3c\xfe\x3a\xda\x5c\x87\x91\x79\xcc\x67\x86\xf6\xfe\x26\xa5\xbb\x13\xe8\x5d\x0b\x22\x15\x9a\x74\xae\xcb\x50\xb7\xcd\xd6\x21\x1c\x3f\xc5\x68\xfa\xc9\xec\x69\x62\x06\xfa\x7e\xdf\xfc\x61\x5f\xb7\x1e\x5a\x6d\x8f\x27\x2c\x78\xc2\xdb\x5b\x03\x7d\x56\x9e\x6e\x00\xca\xba\xb4\x76\x87\xee\xc5\xc4\x12\xae\xeb\x52\x3b\xfe\x50\x01\x8f\xb6\xcf\xcd\xe6\x0b\x5b\x4d\x88\xcb\x18\x38\xc2\x92\x5f\x6d\xe9\x79\x13\x69\xc9\x4f\x33\xdb\x26\x0c\x74\xf6\xbb\xd6\xbe\x4a\x6e\x1b\xf5\xbb\xca\xd6\x7b\x92\x51\x56\xb4\xaf\x28\xfc\x5d\x3b\x67\x2e\x16\x28\x85\xa6\x84\x5e\x44\x6a\x11\xea\x6f\x14\x87\x30\xd6\x2e\x5d\xb3\xcd\x22\xc1\xfd\x47\x86\xaf\xc9\x6f\xf7\x65\xca\xea\x9d\x72\xf3\x99\x65\x66\x4a\x75\xcc\xcc\x6a\x6b\xbf\x49\x6d\xf9\xb6\x0d\xd0\x0a\x6f\x43\x41\xe6\x9b\xfb\x2e\x79\x06\x0d\xef\x32\xe6\xfb\xdb\x6c\xfe\xea\xcb\x1d\x35\x1a\xa8\x6f\xf3\x23\xdd\x75\xc7\x80\xaa\x1a\x3d\x61\x9c\x3d\x61\x44\x4f\xd0\x18\x1c\x6a\xee\xb5\xb3\xd8\xbd\xd6\x6b\x68\x94\x6f\x4f\x83\x03\x89\x88\xd7\xe1\x71\x91\x5e\xf8\xde\xf7\xd6\xc7\x2a\x22\x1b\xea\x40\xd7\x5a\x37\xb4\xbb\xdf\xcc\xb8\x97\xb6\xb1\x88\x7e\x15\xb1\x4d\x7d\xf0\x82\x26\xbd\x16\xb9\xcf\xb9\x49\x4e\x12\x66\x1a\xa6\xc3\xfb\x32\xda\xaa\x7d\xde\xee\xee\x61\x60\x66\x22\xc1\xe5\x08\x8b\x17\x3a\x41\x30\x55\x22\x70\x7f\x5e\xb5\x5d\x57\xd5\x7e\xaf\xc3\xd7\xb4\xa5\x8e\x55\x86\xde\xad\x0f\x9f\x61\xdc\xa3\x00\xd3\x56\x2a\xc5\xff\xae\xf1\xb7\xe1\x6f\x2d\xf3\xe2\xad\xce\x28\x17\xb8\xab\xf7\xa9\xee\xbd\x8b\x64\xc1\x4a\xc5\x0b\xff\xb9\xe9\xd8\x40\xda\x30\x3b\x3e\xa7\x37\xf9\x1c\x71\x46\xe5\x15\x9a\x0f\x4c\xb8\x47\xf3\x4e\x32\x98\x5a\xd3\xd5\x6c\xc7\xd5\x96\x98\x49\x6e\x1f\xa7\x92\x8b\x04\x19\x2d\xbc\x34\x3c\x82\xaf\x42\x58\x0b\x17\x94\xf0\x9e\x77\xd8\xcf\xb7\x83\x80\x12\x7f\x35\xc4\x5b\x74\x27\xc1\x37\x62\x93\xfe\xb3\x62\x38\xd1\x9d\x44\x41\x84\xf0\x67\x2b\x1b\xaa\xd6\xea\xd8\xdc\x7a\xa9\x63\x5d\xac\xcc\xfb\xe2\x4d\x67\xc5\xb6\xea\x73\xf2\x06\x79\xec\xb9\xaa\xc8\xdd\xfb\xa4\xec\xd0\x44\x03\xbd\xee\x7d\x91\xac\xab\xf4\x72\x9f\x73\x1d\xfb\x88\x37\xaa\x07\xe2\x76\xf7\x65\xf4\xb5\xea\xdc\x6b\xa7\xe0\xb0\x96\xfb\xa2\x65\x95\x36\x6e\x3b\x08\x84\x41\xa4\x85\xd5\xa6\xa5\xd2\x08\xc0\xb0\xa0\xf6\xb0\x03\xf2\x97\x0a\x6e\x89\x85\x6c\x21\x88\x9d\x2f\xa5\xa1\x4f\xbb\x9d\x44\x3e\x1a\x1e\x12\x9c\xd3\x0d\x96\xce\xba\xb4\x79\x5f\xe6\xc4\x5e\x3e\x46\xa4\x22\x04\x0d\xbd\x86\x45\x90\x25\x59\x20\xcc\xa9\x6d\xa6\xc9\x94\xa4\x96\x8b\x3f\x07\x02\x66\xac\xa2\x44\xb5\xf3\x4c\xe4\x2a\xa6\x42\x02\x76\x69\xfe\x8a\x2a\xec\xb5\x3d\xa7\x19\xcc\x36\xdf\xea\xc1\x62\x22\x23\x12\x66\x61\x58\x2e\xd8\x38\x06\x8c\x6e\x0d\x22\x1e\x9f\xa3\xee\xcb\x44\xa1\x9a\xdf\xe4\x46\x6a\xde\x1d\x56\x0c\xfa\x50\xf9\x16\x77\xda\x09\x86\x75\x2b\x4d\xfb\x39\xfa\x63\xde\xf0\x97\x8e\xd5\xb5\xca\xa7\xa3\x1f\x95\xec\xfa\xfd\xac\xda\x65\x6d\xcd\x4d\xde\x56\x93\x61\x76\x07\xcb\x01\x91\x8c\x0d\x53\xd5\xdd\x87\x92\x36\xe6\xc7\xac\xb8\x37\x4f\xcf\x10\xe5\xb8\x07\xd8\x59\xd3\xc9\x7e\xc3\xd6\xd7\x14\x08\xde\x9e\x2a\xde\xcd\x4c\xda\x52\xcb\x47\x6b\x49\xe5\xb6\x0a\xb5\xb7\x61\x19\x80\xe1\x9e\x8a\x04\x8b\x86\xea\x67\x92\x87\xe3\x05\xb3\xf0\x00\x25\x60\xfc\x45\x85\xaa\xce\xfa\xae\xcb\x6f\x29\xb9\xa3\x14\x98\xdc\xde\x16\x75\xac\x06\x3d\xd0\xca\x67\x08\x87\xdf\x2c\x9e\xc1\xe2\x45\xbb\xd1\x6c\x92\x2a\xc9\xd8\x40\x8a\x9e\xd3\xc0\x6f\x97\x80\x74\x48\xbf\xe1\x49\xdc\x02\xf7\x67\x01\x27\xd2\x0a\x85\x59\x3e\xcc\x78\x7d\x18\x3d\xe5\xb3\x43\xdb\xb4\xde\x22\x7b\xa8\xde\xec\x62\x58\xe7\x10\xe8\xc8\x2b\x98\xc8\x05\x89\x02\xbb\x2f\x9a\xed\x5c\xd7\x5a\xac\x6b\xe5\x69\x5d\x43\xf4\x9d\x73\x16\x64\x7b\x59\xc7\x34\xc0\x1f\x21\x36\x56\x37\x07\xea\x0c\xf6\x78\x1d\x09\x98\xd7\x6b\x3d\x42\x49\xfe\x42\x85\x4e\xa6\x4a\x43\xef\xed\x8a\x15\x02\x5f\x65\xb4\xd9\x61\xf7\x0f\xfa\x12\x4b\x1d\x27\x5b\x68\x5e\x75\x6e\x53\x93\x8a\xad\xb3\x6f\x9c\x3b\x7d\x1d\xab\x6d\xf5\x09\x1e\xb2\x71\x63\xdc\x65\x8c\xf5\x0b\x02\xd9\xff\x29\xed\xa5\xd2\xfa\xb7\x17\xcc\xe8\x93\x61\xd4\x4b\x4d\xcd\xf2\x7e\x92\x6b\x92\x1d\x58\x1e\xd4\x0c\x0a\x7e\xbf\x88\x3a\xb4\xe7\xe1\x57\xdc\x90\xb4\x9e\xf4\x62\x57\x80\x38\x72\x84\x1d\xda\xb5\xb6\x93\xea\xa7\xd4\x28\x25\xf1\x49\x83\xb2\x29\x24\xcf\x80\x3a\x0b\x70\x06\x75\x23\xae\x60\x13\x90\xbf\xee\x0a\xe6\x26\x4b\x22\xab\x40\x85\x8b\xa1\x15\x3d\xf4\x0a\xdf\x2a\x83\xb7\xef\x6f\x32\x86\x5c\x0f\xd2\x1e\x0f\x72\x2c\x24\x41\xd6\xc7\x43\xf4\x24\xed\x46\x56\xa0\x3f\xf1\x04\x55\x2c\x0d\x68\xcd\xd6\x19\x0b\x3e\xc9\xdf\x88\x0f\x52\x82\x4a\x80\x3c\x22\x55\x84\xb0\x74\x81\xfe\xca\x40\x94\xa2\x25\x44\x1b\x0f\x9f\xde\xeb\xda\x1b\xc9\x32\xd5\x5d\xbd\x0d\x31\xeb\xbc\x4b\x1a\xa9\x27\xb1\x43\x48\xe4\xea\x4d\x12\x5a\x38\x72\xa0\x43\xec\x83\x74\x5c\x1c\x53\x07\x44\x5f\x30\x8c\x87\x2f\x9e\x63\x6e\x45\x92\x36\x41\xed\x81\xcf\x9f\x02\x26\x00\x9f\x26\xdb\x85\x1c\x95\x50\x72\xd2\x0e\xa7\x78\xd6\xe4\x76\x0a\x79\x1e\x25\x68\x6d\x4b\xa8\x5d\xa3\x4e\x9c\xbc\x87\x9c\xbd\x67\x39\x58\x9e\x67\xd1\x62\x75\x24\xd1\xc3\x1d\x43\x8a\x3c\x48\x44\xa6\xe5\x9c\x8d\x00\xf6\x58\xdb\x64\x98\x0c\xcf\x1b\x6b\x46\x07\x9f\x93\x37\x51\x82\x65\x34\x13\x38\x37\xfa\x55\xc4\x28\x21\xd2\xc5\x2c\x64\x6d\x34\x72\xab\xaf\xe6\x98\x44\xfd\x64\x8d\xc3\x99\x56\x56\x18\x91\x25\x2d\x27\x51\xef\x19\xf9\x9b\x37\x4c\x7f\xa2\xa7\x1c\x5e\xcf\x94\x35\x85\x34\x16\x49\xef\x48\x08\x62\xbc\x65\x5b\x7b\xdf\x71\x1b\x02\xe9\x32\xb7\x6b\xad\x8d\x20\x96\xf6\x25\xb7\x95\xf9\x3b\x3a\x85\x4f\x23\x2c\xc3\x05\xbf\xc0\x4f\x3b\xc5\xd0\x5d\xc0\xa9\xd6\xa0\xfe\xe7\x9d\xa2\xfd\x95\x4e\x21\xb3\x0e\xef\x15\xb7\x9f\x74\x8b\x97\x5e\xd1\xfe\x6a\xaf\x40\x80\x04\xc9\x19\xa8\x56\x46\x7d\x8a\x92\x73\x02\x91\xd5\x9f\xf5\x0c\x95\xde\xd2\x98\xe3\x2e\x04\x1e\xe2\x85\xb8\xa3\x5c\xae\x5e\xc1\xa8\x3d\xdb\x11\xe1\xdb\xb4\xe0\x9c\x35\xf1\xc5\xa3\x35\xbd\x2b\xb5\x16\xc1\x59\x65\x28\xc1\xa6\x42\x3e\x7b\xa9\x11\x07\x6d\x91\x34\xcf\x3c\x23\xcc\xa0\xcf\x26\xa2\x49\xca\x6a\xc4\xec\x25\xa6\x20\x42\x2d\xfe\x93\xc2\x7e\xfd\xb5\xda\xe2\x05\x27\xfb\xec\x1e\xd7\xd9\x53\xc3\xda\x87\xb2\x01\x65\x7d\x08\xe6\x30\x34\x0f\x1e\xe4\xa2\x31\x2c\x92\x26\xf0\xa0\x3a\x93\xe5\x54\x7b\xb2\x4c\xbb\x14\x6c\x3f\xea\xee\x51\xb6\x9a\x1a\xf4\xa5\x24\xef\x2d\xcd\xe1\xfe\xff\x1c\x0c\x44\x01\x88\x32\xde\xdf\x4a\x6f\xa9\x22\xb6\x85\x71\x63\x89\xdc\xcd\x92\x25\x55\x50\xdd\x1b\xfb\x46\x55\x5a\x10\x8d\x16\x87\x36\x6f\x22\x6d\x14\x3d\x41\x61\x81\xc5\x20\x61\xc9\x0b\x15\xf6\x27\x26\x22\x6a\x8c\x01\x4d\x61\x03\xb1\x32\xe4\x24\xc0\x00\x99\xe7\x2d\x24\x58\x4c\x1f\xe5\x77\x9c\x26\xda\xb7\x90\x3c\x2d\xa9\x3e\xac\x55\x09\x92\x99\x6f\x67\x3a\x81\x27\x94\x73\x75\xe9\xa7\x5e\x4f\x57\xc4\xda\x36\xce\x5c\x62\x7b\xd7\x28\x7f\x02\xa5\xfc\x3e\xe4\xe4\x09\xec\xde\x26\x45\x12\xb8\x59\x3a\x75\xbb\x7a\x99\x1b\xf2\xa2\xb2\x2e\xb3\xdd\xe1\x8a\x0b\x0c\x20\x39\xcf\x58\x36\xd4\x86\xb1\x4a\x65\x91\x6c\x6b\x83\x17\x8f\xb5\x75\x94\x44\xe2\x40\x80\x48\x91\xa0\x65\x2a\x77\x47\xc2\xaf\xfb\xa9\xef\x22\xe3\x86\x0c\xe0\xd2\x59\x75\xd7\xf7\xa5\x30\x1f\xa8\xa9\xe6\xbb\xcc\xbe\xf6\x1e\x6c\xec\x5d\xcb\x5d\x8c\x78\x18\xc8\x62\x26\x3b\xb3\x87\x24\xde\x71\xbb\x80\x56\x7e\xf1\x81\x98\x13\xac\x68\x73\x2b\x1a\x1e\x43\xbe\x5b\x06\xd5\x9c\x09\xf4\xbf\x64\x17\xb0\x78\x35\xb2\x20\x0b\xca\x9f\x26\x76\xf4\x03\x16\xff\xe2\x87\x42\x09\xb0\xa5\x86\x02\x13\xb7\xea\x10\xc0\xe9\x13\xb1\x45\x68\x4b\x8a\xa4\xaa\x97\x48\x88\xb7\x86\xaf\x0f\x23\x95\x0e\xc3\xef\xbe\xb4\x52\x01\xcf\xd5\x7a\x97\x2a\xb7\x9d\xb4\xd4\x20\x60\x16\x09\x76\x29\x2b\xa9\xb6\xbd\x49\x6a\x80\x62\x6a\xf6\x9b\xd2\x3e\xd2\x84\x90\x87\x11\x00\x1a\xc0\x0d\xb7\xe9\x6a\x7b\x60\xe7\x6b\x3b\xf8\x41\xdc\xd6\xc2\x68\x66\x23\x4d\x34\x0e\xc3\x04\xe1\xf3\x59\x43\xb4\x80\x95\x7b\x23\x89\xcf\xba\x15\xba\x79\xd0\x94\xf7\x19\x69\x46\xbd\x0e\x8d\xca\x76\x4a\x46\x08\xa7\x14\xd1\xa0\xb9\x1a\x03\xf2\x15\xd5\xd7\x3f\x81\x24\x86\x0f\x1b\x60\x91\x99\xf3\x84\xf0\x23\x75\x39\x91\x84\x04\x2b\xa9\x5c\xd4\xf9\xcd\x92\x7b\x0d\x6a\x08\x30\xfb\x59\xdb\xaa\xc5\x57\x35\x29\x49\xd3\x15\xe3\xf8\x4f\x99\xd1\x5e\x70\x2f\xbf\xbd\x00\xc7\x9f\x71\x2f\xb5\x8e\xd4\x46\x01\xd9\x99\xf9\xab\x98\x88\xb6\xff\xa0\x5a\x76\xbd\x88\x93\xdd\xbe\xe8\xa4\x9f\x87\x64\x24\xb4\xf8\xbd\xf1\xbf\xd5\xd4\x61\x52\x84\xea\x36\xcd\xce\x0c\x37\xb7\x37\x76\x66\x68\x32\x93\x62\xb5\x41\x97\xe3\x64\x93\x4e\x51\x9c\xca\x5a\x12\xf9\x76\xf9\x7e\xd7\x01\x0b\xf1\x43\xdd\xd2\x19\x11\x2f\x58\x5d\xca\x99\x70\xf5\x39\x15\xf9\x3b\x2d\x3b\xe6\xae\x44\xe7\x8e\xae\x46\xa0\x51\xbe\xd5\x9b\xcf\x0f\x90\x57\x6b\x00\x9e\x50\xba\x2c\x0c\x9d\x70\x55\x7c\x81\x1b\x25\xcd\x06\xc1\x16\xbf\xea\x49\x07\xcf\x9c\x07\xe8\xaf\x87\xdf\x9a\x60\x09\xc0\x74\x3a\x53\x6b\x7b\x45\x42\x71\x4a\x1a\xe3\x60\x91\x0e\x64\x82\x50\x4e\x00\x66\x66\xf0\xf2\x30\xb3\xa7\x2c\x1b\x63\xa9\x50\x52\x28\x02\x58\xee\xdc\xf3\x21\x15\x83\xc2\xb5\x02\xe9\x85\x36\x8e\x36\x92\xe2\xdf\x45\xc7\xa1\xa4\x04\x8b\xf8\x21\x26\xee\x9d\x72\x6f\x23\x29\x8e\x56\x12\x8e\x85\x98\xb6\x1b\x37\x23\x59\x03\x37\xd6\xc0\x13\xa5\x7e\x68\x68\xc2\x7f\xd5\xc1\x5e\x30\x24\xbf\xfd\x4c\x76\x43\x72\x09\x8a\x81\xa7\x37\xf9\xcf\x7e\xe7\x4f\xbd\xea\xfd\xad\x66\x4b\x26\x75\x1b\xbd\xa7\xee\x0e\x46\x51\x30\x02\x92\x97\x59\x4a\xb0\x16\x02\x68\x8d\x16\x9e\x2c\x22\x6b\x44\xb4\x72\x65\x65\x63\x0c\x78\xaf\x6d\x06\x3b\x35\x4b\x46\xc3\x3d\x85\x9d\x05\xe6\x52\xb8\x55\x15\x34\x9b\xb7\x7f\xe6\xb0\xd9\x7c\x69\x16\x9d\x6b\xaf\x90\x71\x68\x49\x40\x5f\xe5\x5e\x48\x75\x7f\x57\xd2\xec\x2f\x03\x17\x99\x60\xf5\xfe\x94\x81\x7c\x9d\xed\x67\xc3\xe0\x9f\x3b\x0a\x6e\xff\xab\x86\xc1\x5f\x1a\x05\xaf\x79\x95\x57\xb8\x7a\xc9\x97\xf8\x0c\xaa\xa5\xf3\xbd\xe7\x20\x07\x21\x8f\x1b\xe8\x63\xd6\xa5\x95\x27\x3a\x99\x65\x06\x13\x1a\x78\x51\x82\x80\x86\xfc\x33\xa4\x9f\x79\x62\x98\x9f\x60\x82\x23\xc0\xe5\x6f\x3c\x3d\xc1\x91\x7f\xe6\xfc\xb7\xdf\x77\x81\x32\x32\x30\xab\x6b\x29\x63\xa3\xf4\x50\xdf\x97\x9e\xa8\xa4\xef\xc6\x9d\x49\x0f\xba\xc5\x13\xe6\x7c\xb2\xaf\x80\x9a\xb2\x95\x1f\xb1\xe7\xdd\x97\xc9\xa1\x37\x2c\x98\x13\x4a\x04\x9d\x8c\xb2\xf5\xeb\x32\xdc\xfc\x6d\xb4\x26\xc4\x30\x29\x1c\x08\x7f\x14\xf9\x56\xef\xb3\xea\xe7\x2c\x7c\x9f\x68\x02\x58\x9e\x9b\x5b\xb6\xad\xdf\x76\x01\x2a\xa2\x82\x64\xa1\xcf\xa4\x6d\x35\xcd\x74\x8a\xa0\xad\xd9\xa0\x81\xdb\xcc\x0f\x58\xa4\x75\x3f\xf8\x8f\xb2\xc4\xf4\x97\x82\xff\xdf\x2e\xba\x00\x71\x4b\xae\x80\x65\x28\xcf\xfd\xd4\xa9\x45\xb0\x66\xf8\x13\x94\x50\xed\x27\xe4\xc1\xa2\x6a\x2f\x32\xc3\x3b\x74\xb3\x33\x92\xac\x90\x8b\x9a\x07\x73\xc4\xc9\x0a\xe0\x41\xd9\x7d\xfe\x96\xcc\xe6\x61\xe6\xde\x73\x04\x6c\x09\x49\x64\xce\x01\xb9\x94\x79\x52\x85\xf8\x2c\x1a\xba\x0d\x69\x19\x72\xdd\x56\x4c\xf5\xee\xd7\x32\xa4\x29\x7c\x13\x3e\xa1\xdc\xbb\xcf\x09\x25\x24\x8b\x42\xb6\x9a\xf7\xc1\x78\x9b\x94\x88\x13\x30\x81\x21\x88\x74\x93\x7d\x04\x59\x6e\x4a\x77\x48\x22\x9a\x9f\x65\xb7\x4a\xeb\x1b\xcc\x9b\x6d\x90\xaa\xdd\xdd\xa6\x9e\x53\x8b\x2b\xf6\x84\x39\x4a\xce\x39\xce\x3d\x63\x91\xb9\xb7\x90\xd7\x05\xef\x00\x1d\xdb\xf7\xff\x2c\x8d\x86\xdb\xbf\x52\xa4\xe1\xdf\xa7\xd1\xd0\x5f\xf8\xad\x7e\xbb\x64\x5b\x66\xd7\xd4\x51\xc1\x07\xee\x56\x10\xbb\x4b\xf3\x0e\x8c\xea\x29\xb7\xd5\x5a\xe8\x0f\x94\x60\x82\x80\x18\x36\x59\x66\x97\x7e\x16\x44\x84\xca\xe0\xe5\x50\x88\x26\x92\xc4\x4b\xb7\x8b\x76\x57\x4e\xb9\xd7\x96\x40\x4b\xc1\xb8\x8f\xb4\x76\x50\xe8\x34\xdb\x85\x0c\x3c\x95\x64\xe0\x60\x82\xf1\xab\x1f\xe8\x85\x90\xe5\x05\x58\xe2\x5b\x88\xa7\x1d\x24\x29\x86\xfb\xbc\x84\x9b\xf3\x2d\xb8\x72\x10\x6a\xc5\xd7\x7d\x99\xc4\x58\xbb\x1b\x6a\x37\x70\xe9\x01\xf8\x64\x69\xd8\xce\x5a\x22\xd4\xbe\xc4\x92\x96\x0f\xbf\x75\x66\x9a\xf6\x85\x8a\x4e\x1c\x13\x69\xe2\x95\x63\xe0\x68\x63\x20\x50\x2a\x90\x24\x3a\xf3\x21\x3e\x7f\x41\x14\x4b\x4b\x4b\xdd\xef\x6a\x80\xfe\x05\xb9\x5c\xbe\x70\x94\xb7\x7f\xab\x1b\x83\xb3\xe2\x4e\xa2\x24\xe2\x65\x44\x0f\xbf\x46\x5b\x7d\x78\xd7\x14\x99\x10\xd9\xbd\x5b\x23\x98\xd7\x82\x12\xa4\x09\x03\x4d\x20\xcf\xbd\x98\xff\x27\x25\x05\x96\x1a\x04\x41\x8b\x18\x68\x20\x52\xed\xc8\xa1\x74\x4b\x5a\x6e\x47\xef\xa9\xe6\xa3\xf6\x60\xb6\xf0\xee\xce\xea\x01\xa5\x22\x6e\x69\x60\x57\x6b\xc4\x65\xfc\xad\x43\x75\x57\x46\xc6\x51\x52\x52\x76\xb7\xd3\x92\x96\x34\x0e\xc4\x8b\x74\x83\xd2\xdf\x84\x59\xa6\x29\x4a\x8a\x35\xa2\x74\x1a\x40\x78\x64\xc4\x0c\xd6\x1e\x4d\xde\x71\x2c\x5a\x23\xc0\xbe\x2f\x54\xbc\x81\xe8\x50\x93\x1b\x75\x88\x20\x43\x24\xad\x24\x28\x13\xb9\x73\x3e\xc7\x11\x1f\xe7\xcf\xe7\x7e\x3c\x70\x37\x94\x5e\x55\xf8\xe2\xa2\x87\x12\x1f\xf4\x55\xee\xa4\xbf\x02\x38\x5e\xb8\x15\x3e\x28\xa4\xcc\xe1\x0d\xa1\xbb\x2f\x3a\xb3\x40\xe7\xf8\xa4\x12\xc7\x57\xd0\x16\x83\x7f\x58\xd5\x80\x02\x82\x0a\xf6\x07\xd0\x7b\x10\xf4\xda\xb6\x28\xbe\xc8\x33\x0f\xad\xb1\x2a\x22\x88\x80\x51\xcb\x93\xeb\xb6\x34\x10\xab\x64\x7b\xd4\x6c\x91\x1e\xcc\x7d\x71\x3b\x95\xb0\x74\x80\x32\xb9\x95\xcd\x5d\x7f\x24\x94\xb2\x11\x9a\x6a\x3d\xcd\xbc\xf9\x59\x5a\xb6\xeb\xbc\xfb\x79\x53\x00\xf1\x83\xe1\xd6\x36\xbf\x29\xbf\xa7\xc0\x5b\xf9\x8d\xdc\x0e\xde\xd7\xf5\x40\x9b\x22\x17\x5e\xf7\x69\xde\x06\x78\xee\x34\xcb\x45\xb4\x5e\xde\x61\x28\xb6\xb2\xd5\xde\x52\xed\x3e\x2e\xa6\x0f\x28\xdd\x16\xff\xc5\xff\x01\x2d\xe1\x2a\x5f\xf0\x5f\xfc\x26\xbf\xfd\xe3\xe5\x1d\xfd\x5c\xc5\x46\x2a\x09\x70\x3b\x4a\x24\x42\xbc\x0f\x81\x1a\x96\x9f\x08\xa9\xea\x41\x48\x46\x1d\x18\xd9\x17\x73\x5b\xbf\xa1\xea\xa6\x81\x80\x40\x77\xe8\x62\x82\xf3\x05\x50\x4a\x79\x22\x85\x07\xb5\xbc\x5e\xe0\x5e\x95\x98\x69\x74\x24\xa4\xf5\x74\x6b\x36\x52\xed\x73\xaf\xd3\x2d\x27\x1f\xa4\xb5\xbc\xbf\xf5\xdc\x52\xcd\xba\x07\x33\xad\xe4\x10\xc9\xcd\xe7\x34\xdc\xdb\xe6\x9e\x14\x79\xac\x38\x8c\xe8\xcc\x95\x0e\x0a\xde\x28\x6a\x7b\x00\xc7\x64\x20\x6f\x75\x3b\x29\xdb\x84\x85\x87\xa0\xab\x93\x61\x00\x6e\xa8\xe6\xbd\x23\x44\x8e\x88\xe0\x01\xb4\x1b\x56\xfe\x49\x43\xea\x00\x57\x63\x67\xdd\x52\x75\x73\x6f\x87\xaa\x24\x62\xb2\x09\x24\x69\x07\x9c\xca\xde\x8e\x31\x48\x57\xe9\x2b\x1c\x03\xa4\xca\xea\xc8\xaf\x86\xda\x0b\x2d\xd6\x6f\xaf\x1a\x22\xcf\x3c\x80\x33\x54\x2c\x6c\x94\x75\xf1\x3f\x81\x47\x2f\x3e\xed\xba\x07\x56\xfc\xee\x95\xea\x39\x00\x4c\xef\x96\x93\x76\x3a\xd6\x36\x98\x2c\x16\x21\x47\x22\x62\x9d\x07\x82\x62\xf5\x40\x64\x0f\xd5\xf7\xa8\x6b\x01\xcd\x20\x14\xda\xb5\x43\xbc\x5d\x9e\xaf\x42\xf1\x76\xed\xc8\x72\xf9\x55\x90\x4e\x60\xf4\x58\x71\x4a\x09\x01\xd8\xbe\x43\xd9\x34\x20\xae\x72\x84\xa0\xcb\x20\xf1\x51\xe1\x85\x7a\xb4\x3a\x6e\x1c\x35\x54\xe5\xf8\xf0\x34\xb7\x2f\x1e\xc7\x38\xcd\xfd\xc1\x6b\x04\x64\xb4\x94\x20\x03\x0d\xa4\x47\x29\xa9\x23\x5b\x2f\xd4\xd3\xd4\x8e\xa8\xb6\x82\x6d\x0a\x61\x3d\x3e\x3b\x80\x90\x65\x5f\xa0\x07\xc4\x3a\x87\x82\x6d\xd0\xc6\x67\x0b\xee\x91\xe3\x22\x8d\x8e\xf2\xbc\xde\xdc\x67\xa0\x99\xba\xaf\xf1\x1c\x51\x06\x8a\xc3\x9e\x2e\x78\x7b\x5c\xb1\xf1\x8a\x04\x09\x5e\x4a\x41\xd7\x35\x07\x1f\x74\x8f\x74\x6b\xa8\x43\x7f\xbc\x2e\x9d\xff\x9f\x5c\x79\x10\xfc\xd2\x03\xa8\x7f\x76\xa8\xdf\xf7\xb8\x16\x7c\xa7\xe7\x3b\x38\x96\xf3\xd5\x07\x81\x2a\x74\xb2\xdd\x56\x3d\xc8\x00\xb4\xb6\x72\x2f\x85\xdc\x3f\xcb\xf9\xe5\xf9\x87\xdb\xcb\x2f\xee\x62\x82\x44\x28\x88\x85\x8e\x60\x1a\xe2\xf4\x7a\x72\xad\xf7\xce\x14\xb8\xb0\x64\x66\x2a\x95\x7f\x4f\x2d\xdf\x27\x2a\x82\x8b\x53\x80\x15\x86\x33\xcc\x70\x14\x55\x15\xef\xcc\x3a\xfc\x5f\x84\x8e\xf0\x2b\xa6\x09\xd8\x3c\x7d\x87\xf4\x96\xaf\xe4\xbd\x84\x7e\x56\x3e\x3d\xea\x3f\x7f\x23\xb7\x7f\xde\x9d\x80\xf8\xe1\xdf\xdf\x24\x5f\x4c\x83\xaf\xd5\x1a\x2f\xc8\xf6\xa7\xa0\x23\x08\xa7\x2e\x75\x98\x5c\x06\xa8\x1c\x56\x4a\xe4\x94\x3c\x7c\xfd\xcc\x27\x41\x44\xd6\xb2\xc1\x12\x18\x33\x28\xa8\xee\xbe\xf4\x96\x32\xb0\x04\x9f\x0b\xef\x17\x77\x38\xbe\xcf\x24\x6a\x7e\xc1\x6d\x3f\x33\xee\xb6\x91\x5a\x69\x5b\x05\x80\x17\x08\x7b\x64\xec\x33\x66\x24\x9a\x7c\x6d\x40\x55\x12\x7e\x46\xde\xe1\xa1\xe5\xf4\xd7\xbd\xaf\xfb\xd2\x9b\xbe\xbf\xcd\x5a\xdd\x25\x59\x7b\x0f\x7d\xf9\x9e\x90\xd5\xd5\x50\x86\x6c\xe7\x9d\x44\x3b\xf5\x36\xd6\xa5\xb7\x71\x87\xc2\x0f\xee\xe5\x2f\xbb\x71\xe3\xfb\x64\x85\xe6\x57\x24\xf0\x1f\x7f\xad\x60\x2b\x53\x9f\xb5\x8b\xd5\xfd\x2a\x2e\x61\x65\x1d\x7a\x6f\x25\xc9\xc4\x06\x76\x4f\x51\xd9\x96\x06\x25\x64\xb3\x1f\x1a\x95\x0a\x7d\x39\xdb\x96\x02\x98\x92\x3c\x19\x67\x75\xd4\x54\x81\xa5\xbd\x6c\xbf\xd3\xf4\x53\x26\xc4\x6c\x2b\xcd\x5d\x90\x72\x5d\x71\x67\x84\x83\xd1\x54\xf8\x50\x04\x47\xcd\x6f\x75\xf5\xbb\x7e\x44\x82\x6e\xbf\x2b\x14\x34\xbe\x0f\xcb\x6b\xfe\x99\xe6\x89\xb8\x5f\x34\x58\x6a\x40\x82\xd5\x22\x14\xde\x8f\x75\x25\x74\xc3\x17\x2b\x07\x94\x47\x32\x44\xe3\x61\x04\x9a\x92\xd5\x0f\x9f\x16\xe5\x0a\xb0\x85\x32\xb3\xbe\x0c\xe8\x2b\xd3\xc1\x13\xcc\x58\x11\xef\x27\x99\x30\x27\x17\x84\xfe\xa9\x2c\xde\x23\xf6\xdd\x2c\x0d\xae\x29\x14\x22\x65\x79\x9f\x9d\xfd\x9d\x90\x93\xdc\xae\x57\x38\x89\xcc\x1c\xc2\x5a\xac\x44\x1a\x40\xd0\xad\xa5\x49\x4f\x0e\x8c\x02\x07\x7c\x64\xcd\xb7\x2b\x6b\x38\xec\xd4\x37\x11\x1b\x81\x8e\xa0\xaf\x27\x23\xaa\x02\xf3\x69\x68\xb2\x53\x6b\xf0\x71\xc0\x68\x15\x64\xcb\xb5\x0e\xbf\x85\xda\x52\x03\xaf\xa3\x48\x43\xc8\x1d\xaa\xd3\x42\x25\x19\xae\xe3\xd0\xe2\x13\x22\xc7\x7d\xb3\x0f\x8f\x71\xee\x48\xa5\x44\xa5\xa9\x08\x56\x1d\x58\xc7\x19\x2d\xd1\x7c\x61\x2f\xb4\x93\x73\x45\xbd\x29\x63\xe6\x28\x5b\x64\x75\x8b\x9b\x7c\x98\x68\xa1\x36\x5f\xda\xe9\x9d\x4f\x2a\x70\x31\x9c\x5f\xf3\xed\x98\xc8\x69\x1c\xc4\x9a\xcf\x19\x0c\xbc\x22\xfd\x38\x8b\x54\x0a\xa3\xf2\x6e\x5c\x43\xd2\x85\x85\x2b\xd3\xfd\xc3\xec\xfd\xd1\xf0\x25\xb2\xf2\x28\xe0\xa1\x6b\x0c\x8b\x57\x59\xb4\x58\x68\xd1\x74\x8d\xda\x97\xd2\x8e\x05\x97\x64\x6e\x85\x9a\x3f\x6e\xac\x30\x9e\x78\x2c\x43\x52\x55\x28\x89\x0f\x3d\xe8\xf0\x53\xc9\xef\x62\x18\x41\x2a\x38\xa3\x73\xf8\x88\x3b\x28\x4e\xdb\xc7\x0e\x0c\x0e\x21\x50\x61\xec\x90\x15\xa8\xa2\xd2\x55\x6e\x3b\x18\x5b\x04\x23\x89\x7a\xe6\xe0\x37\x41\x2d\x90\xc6\x0c\x30\xbd\x2d\x58\xc6\x33\xc1\xa8\xd9\xf3\x5d\x58\xb7\x2c\x90\xf9\xf7\xd1\x1a\x20\x1f\x94\x50\x1c\xac\xf7\xfc\x72\x48\x7e\x9f\x23\xd0\x6c\x57\x74\xb6\x98\xa6\x02\x06\x28\xe9\x98\x22\x4a\x52\x9b\xb0\xba\x50\xd9\x64\xc1\x29\x63\x03\x85\xbd\x01\xee\x02\x32\x7a\xd1\x44\x78\x32\x31\x96\x89\x71\x4e\xa3\x18\x3d\xe9\xa0\xdb\x29\x5c\xbd\x57\x44\x65\xd1\xeb\xd6\x45\x76\x40\xa3\x40\xc8\xb3\x54\xd9\xa6\xa5\xee\x5e\x1c\xbc\x2d\x7f\xc4\x56\x00\xbd\xf4\x26\x01\x27\xb2\x4d\x37\xeb\x30\xea\x2e\x5e\xc6\xa2\x2c\x0d\x3e\x16\x30\x25\x9c\x61\xd6\x90\xb5\x82\xb0\xe2\x6c\xa9\x31\x54\x53\x72\x08\x1d\x2d\xdd\x6e\x70\x1e\x06\x5a\x19\xf2\x8a\x88\x71\xc9\x55\x7f\x0e\xd4\x91\xd8\x53\x9d\xf3\x4e\x05\xae\x60\x6e\x98\x76\x16\x8a\xa1\xc6\x66\xb2\x60\xa5\x91\x57\x08\xc5\xf5\xa7\x5d\xc9\xe1\x80\x44\x02\x55\xef\x2b\x08\x81\x31\x37\x94\x08\x76\x91\xbb\x31\x42\xe0\xa5\x9f\x01\xe5\xcc\x82\x29\x37\x7d\x6a\x3b\x50\x6c\xb0\x48\x19\x90\x83\xf7\x9f\xef\x64\x4b\xf6\x85\x3a\xc6\xcc\x9c\x07\x75\x5e\x19\x60\x24\xbf\x22\xca\x62\x04\x55\x66\x8a\x2a\x92\x7c\xf3\xb6\xd7\x9e\x4c\x52\xf5\xf5\x06\xf8\x0a\x24\x27\x41\x59\x44\xa4\x0c\xae\x88\x1e\xba\x2f\x22\x8c\xee\x4d\x49\xa3\x1f\xee\xf8\x2a\xd3\x2f\xd9\xc7\x49\x92\x31\x0f\xbf\xc0\x28\xbb\xb0\x04\xae\x67\xf6\xfb\x83\xf1\x86\x0e\x49\x30\x2c\x7e\x51\xe5\x09\xde\x1a\xbe\x0c\x20\xf4\x1e\xf1\x46\xbe\x00\x98\x63\xdf\x4e\xcd\x31\xba\x4b\x38\x21\x48\x81\xec\x18\x39\x90\x74\x92\x31\xc1\x0c\x4b\x0d\x19\x3d\x04\xd5\x5e\xd5\xc2\x6e\xff\x3b\xe4\xc2\xc6\xf7\x59\x14\xcd\xaf\xa5\xc0\x4f\x19\x6d\x9f\xbf\x19\xcc\x45\x43\xff\x40\x4f\xfb\x87\x72\xda\xe7\xf7\x8b\xaf\x84\x7d\x27\x76\xcb\x0c\x3f\xf3\x0c\x17\x41\xc9\x29\xe1\x1d\xdf\x3f\xec\xf5\xe1\x04\xcf\xa7\xfe\x43\xba\xe0\x61\x36\x7d\xfa\x5c\xb7\xdf\xf7\x60\xeb\x62\xa3\xe1\x4d\x80\x53\x2b\xd2\x30\x5a\x18\x04\x59\x74\x8c\x63\x79\xfa\xfa\xd8\x61\xc5\x71\x7f\x5c\xcb\x3c\x98\x65\xcf\xc0\xba\x05\x1a\xf7\x43\xf6\x63\xb9\xd2\x1f\xcb\x87\xfc\xc7\x52\x05\xe6\xec\x77\xa1\xe0\x33\x12\x8c\x7d\x6f\x1f\x52\x28\x57\x5e\xe5\xfa\xf2\xd8\xf8\x48\xaf\x9c\xa7\x59\xfd\xdc\x3c\xf5\x53\x0a\xe7\x71\x1b\x4f\x77\x77\xdd\xf3\x57\xfd\xf4\xfb\xa4\x87\xe6\xd7\x62\xc5\x47\x3f\xbd\x5e\xa6\x01\xf8\xfb\xf7\xdc\xf2\xf1\xcf\x6d\xf1\x4f\x1b\xfc\xcc\xf4\xea\xf8\x69\x27\xb9\xfd\x51\xc5\xfb\x7f\xfb\x08\xfd\xea\x7d\x7f\x1f\x66\xd7\xfc\x5a\xca\xf5\x04\x51\x68\xe0\xd2\x5c\x17\x43\x14\x86\x22\xc1\xf4\x2e\x0e\x60\x48\xfa\x26\xc3\xad\x09\x01\x2a\x18\x96\xa8\xf5\xd0\x0b\x57\xa6\x51\x1b\x0a\x93\x23\x2a\xdf\x8e\xf3\x33\x36\xec\x5c\x92\x34\x5b\xea\x64\x85\x11\x5f\x04\x50\xee\xdf\xa1\x8d\xba\x0a\xb4\x4a\xc9\xd2\xd4\x21\x75\xf8\xfe\x26\xb9\x62\xe3\xa6\x63\xf0\x0e\xcb\xc8\x1b\x57\x3c\x10\xde\xd1\x87\x4c\x42\x85\x07\x5d\xa5\x9d\x55\x80\x2c\x9b\x81\x68\x34\x02\xe6\x0d\x7a\xa3\x69\x96\xdb\xbe\x34\x9a\x23\x2a\xa4\xcb\x02\x7c\xbc\x81\xa8\x9e\x2e\x1b\x44\x19\x11\x6b\x2a\x39\xe8\xc9\xe5\x0c\x6f\x5c\xd1\x2d\xb7\x75\x36\xe4\x87\xfc\x58\x90\x35\x4f\x98\x1a\x48\x4b\xec\x21\xd9\xfe\x5d\x3b\x1c\xbc\x87\x83\xb7\x74\x02\x82\xa2\xc2\x07\x51\x37\x0b\x76\x1c\x9a\x70\x12\xf1\x6a\x79\xfc\x15\x7f\x70\x47\x8b\xd8\xfa\xec\x24\xd8\x47\x9b\x9e\xbd\xd9\x3d\x31\x54\x6e\xcf\xb1\x2d\x56\xa1\x38\x31\x83\x38\x04\xdc\xeb\x12\x5c\x03\xb3\x93\x5f\x5d\x58\x24\x09\x03\x17\x0a\x1d\x40\x71\x7b\x13\x90\x92\xf9\x47\x37\x70\x3c\x7f\x7f\xda\x69\x17\xfa\xa2\x82\x2a\xca\xcd\xfb\x8c\x0c\x83\xea\xee\x67\x32\x3b\xc7\xb3\x5a\xef\x45\x6e\x5e\xac\x6e\x24\x86\x83\x5e\xef\xa7\xc2\x3d\xc7\x77\x3a\xbf\xc1\x97\x82\x2a\xda\x4d\xc1\xe1\x96\xf3\x6d\x9f\x20\x0b\x14\x04\x66\x77\x3e\xd3\x87\x16\x7e\x6e\xfc\xaf\x46\xd8\xf7\xac\x0f\x9a\xfb\xff\x79\x22\x3f\xa6\x0e\xfa\xdf\xca\x51\xea\x33\xdb\xbf\xe0\x32\xd6\x34\x75\x69\x1b\xea\xad\x07\xd2\xac\x70\x89\xf4\xba\x08\x27\xc9\xf2\xad\xde\xd6\x65\xca\xb8\x6a\xd8\x1f\x9e\x55\x00\x91\x0d\x6e\x53\x87\x0f\x1b\xc0\x00\xd6\x04\x55\x23\x6e\xce\x56\xc9\x4d\x49\x65\x54\x50\x1c\x23\x25\x55\x7b\x7f\x13\x30\x86\x9b\x82\x02\x8f\xf5\x3a\xee\xfe\x59\x01\x5c\xc1\x57\xab\xc0\x7d\x50\xa4\x9d\x08\x68\x2b\x47\x7c\xf0\xd7\xb5\x41\x31\x81\xe0\x40\xc1\x46\x3b\x65\x9f\x5b\xb6\xfb\xd2\x00\x64\x0b\x35\xec\x9d\x83\xfc\xb9\xd9\x3e\x34\xe7\x33\x03\xf0\xd5\x5e\x77\xca\x68\xb7\x3f\x78\x8a\x97\x33\xf8\x4d\xb4\x4c\xe7\x15\x4a\x16\xcc\x6e\x5a\x2a\xb5\xec\x33\xf5\x41\xfe\x4f\xb1\x7e\xa8\xe5\x34\xe6\x61\x48\x75\x5b\x8e\x2f\x8b\x65\x6c\x59\xc6\x3c\x4e\xaa\xd0\xbe\x61\xc2\xf4\x53\x30\xc6\xa4\xf1\x26\xbf\x74\x47\xbf\x4f\x25\x69\x7e\x29\x59\x7b\x36\x73\x4b\xb3\x14\x25\x62\x40\x7e\xd4\xb3\x60\xa8\x09\x8b\xfc\xd7\xa5\x43\xd5\x0d\x03\xb9\xd1\xcb\x38\x88\x8a\x07\x41\x26\x3f\x63\xc3\xea\xfb\x62\xd7\xf3\xf0\xe3\x3c\xe3\xfb\x9b\xb4\xde\xe3\x5a\x10\xbd\x36\x77\x66\xd6\x65\x8e\x8f\xa7\x8f\x93\x87\xb3\x5b\x53\x13\x9e\x7d\x9d\x79\x40\x35\x59\xa8\x3f\xe4\x0d\x0d\x6e\x8b\xec\xde\xd1\xc2\x60\xcd\x62\xcc\xa4\x33\xc0\xa4\x36\xa2\x44\x28\xe2\x10\xbe\xf9\x16\x78\x54\xb4\x6b\xcf\xab\x5f\xff\xe9\x96\xe3\x86\x1f\xd0\xb9\x13\x38\xe7\xdf\xd7\xc5\x6f\x02\x41\x9d\x62\x49\x29\x19\xe2\xb7\x61\x8c\x4d\xb8\x9b\x86\x55\x56\x2b\xcb\x58\x0f\x75\x9b\xc6\xdc\x79\x9c\x49\xf3\x38\xaa\x77\x11\xbb\xac\xda\x49\x7a\x99\x47\xd3\x3f\xae\x04\x92\xdd\x4e\xa2\x4d\xb0\x10\xd2\xfe\x6d\x3d\xea\xa4\x16\x13\x9a\x2a\xac\xc6\xd2\x66\xc7\xa2\x41\x8b\xd8\xdb\xc1\xcd\xdc\xf7\xb6\x83\x43\x12\x59\xad\xc1\x08\xda\xb1\x18\xca\x72\xad\xe6\x75\x91\x31\x3f\x79\x05\x12\xd4\x47\x04\xa6\xe2\x15\xf8\x4a\x0e\x1e\x50\x72\x75\xf1\x9e\xfc\x96\x70\x47\xbc\x21\xde\x8f\xdf\x0e\xef\xc6\x6f\x86\xcd\xd3\x00\x27\x44\xda\xaa\x44\xf4\xdb\xec\xe0\x7d\x2c\x7e\x23\x32\xc6\xeb\xab\xf8\xaa\x48\x73\x7c\x9f\x35\xd0\x3c\x5f\x62\xa2\x3a\xf2\x59\x38\x54\x2d\x41\xb0\x87\x9a\x4b\xa6\x63\x13\xca\xfa\xec\xd2\x6a\x2a\x55\x92\x7f\x56\x09\x96\x8e\xc5\x46\xaa\x0d\xc8\x81\xd3\xfd\x50\xad\xef\x6f\xad\x96\x54\xba\x6c\x66\xd0\xb4\xb1\x9e\x8a\x4f\xbe\x6e\x80\x2d\x66\xc4\xfd\xc2\xe1\xee\xc1\xd9\x00\x1b\xd7\x20\x4a\x05\x11\xae\x65\x0e\x46\xef\x2a\xf8\x93\x13\x75\x59\x04\xb6\x4d\x50\xad\x30\x8e\x6c\x6e\xcb\x75\xef\xee\x01\xdd\x51\x7d\x00\x2a\x51\x3c\xf9\x2d\x84\x8d\x0d\x81\x7c\x75\x8f\x3d\x8f\xe8\xc1\x51\x4c\x0d\x9d\x8f\x28\xfc\xab\x76\x48\x06\x3c\x27\x02\xd0\x88\xfd\x18\x09\xbc\x80\x60\x53\xaa\x5a\x41\xcf\x51\x0c\xb5\xbe\xa6\x88\xf5\x15\xca\xca\x04\x92\x74\x40\x19\x1d\xc8\x22\xce\xe9\xa5\x9e\x99\x46\x46\x23\x4a\x07\xf5\x45\x52\xe6\x1f\x8a\x50\xea\x27\x97\x1d\x71\xcb\x12\x66\x10\x07\x91\x0e\xd6\x63\xeb\xae\xd0\x44\x84\xa4\x24\x54\x89\x34\x49\x9b\x28\x1b\x2e\xb8\x3f\x10\xd4\xa5\xd6\x03\x56\xdc\x34\xca\xb8\xf0\xa2\x18\xe1\x53\x6c\xf1\xbe\x78\x73\xfb\xf0\x44\x1e\xa2\x48\x04\x56\x23\x2d\x44\xd4\xc2\xb0\x22\x87\x59\x04\x2b\x29\x10\xcc\x39\x82\x23\x25\x1f\xfd\x51\x56\x3d\xa2\x78\x32\xf2\xc7\xa8\x28\xcc\xab\x5a\x24\xd3\x33\xc9\x8a\xea\xa5\xdb\x5d\x2b\x92\xa9\xf8\x0f\x31\xa3\xb2\x73\x88\x2b\x0d\xd0\xd2\x00\xd6\xa1\x24\x64\x10\x94\xfa\xaa\x78\x56\x41\xf5\x93\xa9\x0d\x9b\xc6\xb8\x10\xb8\x03\x2b\xb4\x91\x92\xed\x01\x30\x15\xb7\x9a\x61\xbe\x45\xc0\x5e\x41\x7b\x4b\x66\x44\x20\x02\xf5\x0c\xe3\xc9\xb9\xe8\x71\xf9\x1f\x04\x9b\xe2\xba\x54\xba\x18\x44\x39\x02\x94\xde\x47\x84\x6b\x04\x53\x96\x95\x64\x96\x5a\xdf\x83\xcc\xaa\x79\x7f\x6a\x3b\x28\x10\xe0\xe7\x59\x54\xf7\x60\x36\x6c\xec\xff\x87\x30\xb4\xc3\x50\x66\xe1\x33\x24\x29\xa8\xcd\x63\x0a\x5a\x4e\x44\x0e\xd4\xe3\x68\x90\x84\x3a\xa0\x9b\x16\x49\x59\x8f\x9b\x25\xb1\x66\xb5\x59\x78\xac\x63\xb0\x36\x0e\x1e\xc2\x48\x82\x75\xa6\xa9\x4f\x25\x50\x35\x53\xff\x4a\x10\x26\x6a\x71\x2b\xd5\x10\x0b\xc2\x9b\xcd\x52\xa5\x32\x1e\xb8\x69\x24\x94\xa3\x26\xa2\x7f\xbb\x18\x98\x01\xc1\xc2\x34\x64\x27\x4b\x01\x56\x96\x1d\xd9\x1d\x9d\x14\x0d\x61\x0e\x03\x89\x8f\x5a\xa2\xda\x04\x11\x52\xbf\x01\xf4\x40\xa8\x2d\x76\xb0\x19\xb6\xbd\x23\xbc\x8e\xd7\x36\x0f\x12\x2a\x06\xd3\x39\x92\x06\xe8\x3b\x19\x95\xff\x12\xda\x8c\x40\x65\x32\x9c\xdf\x07\x82\xdc\x13\x0a\x7e\x28\x95\x3e\x69\x3b\xeb\x49\x61\x39\xf2\x01\xbf\x26\x84\xdf\x45\x2e\xe1\xf7\xc1\x6e\x29\xa7\x24\x8a\xa5\x82\x14\xc5\x04\x64\x51\xeb\x48\x72\x62\x0f\x67\xd2\xf1\xb5\x89\x3d\x5f\xf3\xa2\x3f\x13\x5a\xea\xa3\xa6\xaa\x03\x2c\x34\x30\xff\xa4\x8e\x14\x55\x92\x11\x65\x50\x72\x07\x4c\xb2\xcb\x36\x7a\xae\x95\x05\xbb\x2d\xa4\x50\x0c\x88\x11\x99\x25\x4d\x4b\x26\xcc\x42\xfb\xec\xde\xfd\xa5\x81\x92\x43\x0d\x5c\x25\xc7\x44\x01\x1e\x4b\xc2\xdc\x9a\x05\xc9\x18\x92\x4b\xf3\x58\xa8\x9e\x56\xcf\x39\x7e\x44\x32\xf6\xdb\x83\x76\xa7\x47\xf8\xbb\x8c\x44\x7a\x2d\xf7\xcb\x10\x15\x2d\x39\x18\x20\x51\x84\x39\x76\x14\x6b\x7a\xb3\x89\x4d\x37\xfc\x67\x8f\x27\x0d\x9c\xf9\xf9\xa8\xcf\x0f\xfa\xb7\x3c\x26\xb8\xcc\xf9\x98\xf1\x90\x7f\xf6\x11\xed\x41\x73\xd9\x02\x7c\x17\x3c\x22\xd4\xfd\x3c\x8c\xf1\x15\x09\x84\x4c\x2b\x58\x42\x40\x9d\x0c\xb3\x20\xf7\xdb\x81\x8b\x11\x43\xd5\xd2\x60\x84\xd9\x0d\xfb\x40\x9f\x54\xe2\xc4\x04\x04\xdd\xcd\xfc\xca\x3d\x35\xdb\x97\x46\xaa\xd0\x2e\x28\x4a\x83\x23\x52\xb8\xe4\xc5\x24\xcc\xb4\x6f\xb9\xc8\x26\x10\xe0\x2f\x95\x69\x6e\x00\x98\x4f\xd5\x4e\x37\xb4\x47\xc0\xdf\xa1\xe8\xea\x3f\x60\x8c\x32\x13\xf8\xad\xfa\xd0\xe6\x06\x71\xcb\x8d\xe7\x0b\x56\x10\x51\xb0\xc8\x21\x3f\x8c\x06\xf1\x41\x4b\xdd\x23\x69\x7b\x03\xe7\x10\x6e\xba\xee\x35\x95\x04\x44\x03\xcf\x21\xe5\xc6\x84\x87\xb4\xbd\xb8\xfb\x82\x39\x09\xd2\xa0\xc9\xf2\xfc\xa8\x9c\x55\xad\x3d\x67\xbd\xfd\xdb\x57\x63\xef\x35\xbd\xfe\x7f\xaf\x2a\xe9\xa9\x69\x0a\x98\x9b\xda\x0f\x54\x8e\x11\x99\xff\x1e\xf4\xc0\xdd\x49\x01\x00\x4d\xb0\x03\xc9\x92\x91\xd7\x45\xbb\xde\x17\x91\xfa\x23\xd5\xe4\x4f\xcf\x27\x56\x5e\x60\x14\xa5\xb9\xb1\x8c\x50\x93\x2f\xc6\x2c\xac\x1e\x67\x31\x36\x46\x14\xe7\x83\x09\x96\x19\xf7\x29\x7b\xbb\x2f\x23\x0a\xb5\xad\xf2\x18\xec\x71\x82\xab\xf8\x81\x4a\xd9\x38\xe5\xba\x94\x0f\xc8\x95\xf3\x8e\x22\xdd\xf0\x41\xc7\xb9\xe5\x17\x68\x06\xb4\x92\x57\xed\x7a\xa6\x5f\xd0\x0a\x07\x1b\xe5\xce\x7b\xf9\xf2\x24\x5f\xbd\xc0\xd7\xa4\xfe\x3f\xae\x0c\xa2\x89\xa4\x06\xd9\x4a\x29\x17\x91\x10\x39\x9d\xc6\x19\x27\x70\xbf\x5a\xf3\x55\xb9\x66\x23\x85\x5b\x6d\xe3\xce\xc3\xd4\x9d\xe8\x10\x9c\x91\xb2\xfa\xce\xd4\x47\xee\x67\x1f\x8f\x53\xbe\xbf\x0d\x95\x54\x5a\xb9\x6b\xbd\xc2\x15\x7a\x31\x38\x20\x4b\xe8\x7f\xbb\x7b\xe2\xa3\x93\x22\x65\x6e\xd6\x28\x56\x5f\xb7\x06\x66\x4b\x60\xb6\xb4\x7c\x96\x14\xb1\x82\x24\x68\x13\xe1\xa1\xf8\x2f\xf7\x85\xd7\x00\x8b\x3d\x2c\xa2\xb5\xd6\x1b\xa9\x4d\x20\x86\x78\x57\x50\x98\xa0\x88\x2a\x66\x1a\x78\x2f\x65\x9d\xa7\xbe\xf3\xe0\xdd\x43\x7f\xfc\xbe\x70\xff\xe7\xf3\x95\xcf\x4f\xf7\xd4\x16\xb3\xff\xa0\x29\x3e\x9c\x4e\xe3\xf6\x48\x12\xac\x92\x54\x7d\x76\x07\xb0\x3b\xdf\xa5\x5e\xe2\x46\x76\xb6\x54\x8b\x76\x52\xf0\x2a\xd8\x59\x2d\x17\x8d\x60\x67\x13\x14\x61\x02\x4d\x49\xab\xa5\xf2\xe1\x22\x72\x97\x91\x77\x00\xeb\x19\x9f\x2c\xba\xca\x94\x1d\xe7\x8b\x4b\x1c\x71\xcd\x2b\x2f\x87\xf2\xe1\x4c\xd5\x14\x7f\x35\x40\x76\x9f\x55\xe3\x4b\x1b\x2b\xb7\x9e\x45\x12\x6e\xbc\x0d\x94\x20\x48\x2b\xf7\x38\x70\xb6\xc4\x1f\x0e\x6e\x5f\xf1\x3b\x51\x10\x3c\xcb\x11\xa7\xfd\xaa\x73\xbf\xa6\xc7\x2f\x45\x9c\x29\xee\x6f\x41\x68\xa5\x6c\x52\x7a\xaa\xc0\xab\xe4\x2c\x88\x20\x1a\xa8\x27\x2e\x49\xc6\x52\x32\xff\x5c\xf0\xb7\x6f\xb5\xe1\x0b\x62\xf9\x3e\x23\xb9\x9f\x12\x2f\x83\xb9\x41\x24\x23\xfd\xaf\x2b\x11\x39\x22\x11\x99\x06\x2b\x1a\x35\x5f\x33\x02\xc3\xda\x7e\x14\xb7\x47\xe2\x71\x44\x48\x7c\x19\xb4\xfb\x35\x7f\x39\xac\x5f\x13\x8e\x5f\x56\xb3\xb5\x22\x57\x25\x93\x45\xfd\x31\xd9\x37\x10\x1f\xd6\x0c\x47\xb9\xed\x14\x39\xc5\x4a\x7c\x32\xa1\x06\xcd\xc8\x63\x88\xf1\x10\x99\xe8\x95\xdd\x0f\x19\xc4\x61\x5c\x5c\x68\x2d\xbc\x9b\x33\xfc\xf7\x20\xe6\x76\x77\x63\x5d\x4a\xce\xf0\xf6\x97\x60\x2f\x06\xc5\x32\xc8\x88\xd7\xc5\xe6\xfc\x7e\xdb\x23\x98\x78\x2a\xe5\x74\xaa\x03\xe4\x34\x52\x49\x9a\x79\x37\x66\x88\x47\x80\x4d\x98\x60\x5d\xae\xcf\x1a\x25\x52\x60\x3c\xb3\x24\xc3\x9f\xb7\x25\x7f\x5c\xdf\x3b\x26\x90\x74\xf2\xe0\x3e\xf6\x56\x89\xf9\x01\x21\x6d\x8b\x33\x6e\x32\x67\x8a\x65\x27\x51\x5b\x21\x24\x16\x82\x89\xbd\xa4\x2a\x9b\xe6\x09\x70\xe8\x42\x8d\xd7\x92\xd0\xa2\x8a\xf5\x1b\x79\xa1\x78\x98\xe0\x45\x45\xe5\xf9\x6a\x13\x08\x77\xa5\xd0\xaa\x50\x8b\xda\x7f\x1e\x3b\x40\xa8\xbe\x9f\x4a\x50\xa9\xe7\x93\x36\xa9\xd3\xcf\xba\xb1\x18\x0b\x56\xcc\xd8\x60\x25\x59\x1d\x8c\xf2\xa1\x62\x03\xee\xbc\x04\xb5\x68\x30\xef\x80\xe5\xbc\x6f\x42\xe1\xee\x02\x32\xdc\x92\xc2\x72\x43\xd0\xe5\x7a\xfd\x3e\x80\x40\x89\x50\xc7\x6a\x63\x6e\x8b\x15\x4d\x56\xa1\x90\x6c\xfc\x6b\xf1\x3f\xad\x41\x89\x4a\x9a\x5f\x54\xda\x81\x4b\x37\x70\x4f\xa4\x56\xcb\x0e\x52\x69\xf4\xc3\xfd\x2c\x95\x03\x2b\x95\x9b\x4e\x8b\x41\xe2\x3d\x2d\x0d\xc9\x26\x99\xf3\x6e\xa5\x03\x65\xec\x76\x2a\x89\xd9\x47\x44\x27\xf2\xfb\xdb\x44\xc5\x32\x64\xb8\x6c\x8c\x4d\xc0\xf6\x9a\xf3\x56\xab\x77\x0b\x9f\x00\x00\xac\x0b\x8c\x20\x26\xf5\x86\xa2\x18\xdc\x50\x03\x27\x6c\x20\x8d\x00\x54\xc6\x94\x44\xaa\x8f\x3e\xd7\xee\x3b\xd5\x61\xbe\xd3\xa6\x4a\x50\x88\x56\x4d\xda\xda\xb6\xe8\x84\x78\x72\xdf\x60\x55\x96\xb5\x34\x48\xfa\x4f\x4c\xf6\xba\xf9\x7b\x1c\x1b\x32\x65\x79\x5d\x8a\xf6\xcd\x80\xae\x2a\xb6\x7b\xa7\x15\x4b\xc8\x7b\x0d\x36\x68\xdd\xae\xd6\xb4\x6e\xf7\xc5\xac\x6e\x3e\x1b\xee\x88\x8c\x63\x06\x17\x7b\x7f\xab\x7e\x71\x6d\x6b\xc9\xba\xf9\xbd\xb6\xdb\xb6\x98\xf7\x34\x10\x96\x80\x16\xa6\x81\x4e\x51\xde\xdf\xac\xe2\xe9\x56\x69\x76\x17\x7f\x5f\xa8\xc9\x94\xde\x77\xf7\x8f\x13\x2c\x4f\xdf\xcb\x5d\x5a\x32\xcf\x4b\x22\xb0\x9b\xd2\x1f\x27\x6b\x10\xdb\x7b\x13\x54\x01\xf5\x7e\xd7\x36\x79\x23\x22\x2a\xf7\xc5\xa7\x4b\x72\x00\xd6\xbe\xe9\xec\x3e\x6f\x6e\x70\xfd\x14\x25\xd3\x15\x64\x0a\x14\x17\xf3\xa5\xaf\x95\xcd\x67\x9b\x5e\x36\xd4\xa6\x68\x86\xe1\x8e\x3e\xe0\x26\x06\x14\x82\x3b\x5e\xea\x0a\x68\x57\xe3\x8a\x5b\x36\x20\x33\x10\x21\x93\xec\x16\x51\xf1\x87\xf7\x0b\x2e\x26\x75\x33\x6a\x56\xcc\xcd\x5f\x8b\xe5\xfe\xfe\xd6\xc6\x48\xcd\x20\x03\xe0\xb7\x20\xf7\x45\x21\xb7\x9b\x6d\x24\xed\x39\x28\x9c\xcb\x0a\x55\x11\xeb\x25\x35\x1f\x36\x08\xec\x56\xd9\x04\x82\xad\x65\x5b\x8c\x7a\xea\x20\x48\x01\x31\x95\x80\x9e\x9d\x1d\x51\xe7\x5d\xb7\x45\xbd\xaf\x83\x62\x84\xfd\xda\x8f\x28\x90\x48\x6f\xb6\x19\x55\x8d\xfb\xfb\x5b\x85\x28\x50\xd1\xbb\xaa\x6d\x08\x0d\x2c\x3a\x34\x7e\x67\xf1\xb0\x6d\xf1\xb3\xdd\x75\x50\x5e\x1f\x42\xac\x1b\x75\x02\x7c\xa4\x9a\x1b\x1d\x7d\x5d\x86\xde\xc0\x35\x3f\xd1\x1b\x7d\xb8\x9b\xfb\x40\x4a\xbc\x53\x88\x2f\xf8\x74\xd7\xbc\x3f\x4b\xd2\xd9\xa2\x5a\xad\x89\x6e\xbd\x23\x1c\x56\x13\xc4\xbc\xfb\xcf\xd1\x40\x2a\x2f\x5e\xb8\xe4\xff\x73\xd5\x09\x0c\xd0\x7d\x88\x05\x4e\x96\xd0\x2c\x45\xb6\x67\x22\x74\x5f\x74\xb3\xea\xbd\x1b\x85\xb6\x11\x6e\x46\x52\x56\xce\x08\xdd\xc2\xfd\x97\x59\xd7\xa5\x13\x0c\x1b\x21\x04\x9e\x26\x0a\x3e\x55\xfb\xbd\x43\xd8\x50\x19\x45\xf4\x67\x6b\x49\x46\xbe\x17\xe4\x5b\x51\xfd\xa4\xa8\x83\xec\x03\x04\xc1\x65\x5c\xa0\x02\x54\xfb\xd9\x41\x2e\x9e\xe9\xbe\x0b\xfa\x78\x69\xc1\x4b\x84\x58\x0b\x23\x72\x3e\xdb\xaf\xbd\x7f\x55\x58\x3e\x5f\x72\xec\x22\x97\x11\x62\x3e\xca\x47\xdb\x17\x43\x98\x5d\x41\x1f\x83\xea\x2c\x9a\x6a\xee\xaf\x57\x78\x87\xbe\x0c\x81\xdd\x1d\x50\x50\xf8\xb8\xde\xd3\xb0\x14\xa1\x1a\x49\xfb\x60\x25\xf6\x61\xa3\x70\xcb\x3e\x48\x5c\x86\x2a\x4d\x6f\x10\xa6\xc0\xfb\x3e\x81\x77\xa6\x35\x25\xb5\xee\x8b\x8d\x99\x02\xb0\xde\x29\xe1\x47\x2d\x20\x9b\x58\xa7\x5b\x6f\x41\x63\x01\x26\x07\x30\xdd\xd0\x2b\x31\x37\x04\x67\x4d\xad\xcb\xd1\x5a\x4f\x36\xe7\xfb\x5b\xe9\xa0\x57\x47\x32\xdf\xaa\x77\x7c\x94\xe5\xab\x1e\x0d\x79\x01\x1b\xe5\x06\x39\xf0\xa9\x28\x0b\x84\xf2\x12\x61\x94\xa0\x27\xc6\x44\x5c\xfc\xf2\xbe\xba\x55\x40\xb6\xfd\xd6\xb1\x6b\x01\x21\x0e\x8c\xae\x45\x20\xc4\x31\x2d\x11\x79\xee\x6e\x2f\x94\x39\x2a\xeb\x28\x75\x52\xb4\x08\x6c\xc3\x3e\xa3\x68\x2f\xc9\x3a\x32\x9b\x10\xfc\xaa\x17\x50\x05\xf4\x45\xd9\xa7\x91\x51\xf6\x06\x83\xa4\x92\xb2\xdd\xbe\x78\xc3\xbf\xa9\xbc\xf8\x50\xf2\xca\xec\xff\x94\xf6\x1a\xd3\x7c\x90\x97\x4d\xa2\xfa\x55\x1f\x7d\xb9\xf6\x54\xdd\x14\xca\x39\x4d\x81\x9e\x5d\x9a\x3e\x64\x99\xcb\xf6\x29\x68\x91\xe2\xed\x01\xaf\x7d\xf0\x27\xfe\x42\x92\x11\x43\x81\x81\xec\xc1\x8d\xde\x43\x92\xb0\xf6\x75\xa9\xb8\x20\xae\xa7\x8a\x18\x61\x2a\x43\xfd\x73\x57\xf2\x88\x8e\x4e\xb6\x31\xa9\x05\x2a\x63\xfe\x83\xff\xad\xa0\xf7\x2a\x64\xe4\xeb\x3e\x17\x22\x7f\xd0\x77\x12\x76\x22\x02\x44\xcd\xba\x16\xbc\xca\x1b\xb0\xcf\x92\x15\x8c\x1d\x5d\xc0\xfb\x6a\x6d\xa4\x0e\x40\x52\x79\x7a\x1a\x88\x54\xb8\x27\x2b\xe7\xd3\x80\xeb\x86\x19\x35\x5f\x8f\xfa\xe0\xd9\xdc\xf6\x96\x9d\x35\xca\x49\x88\xd7\xaf\x51\xfc\x69\xcc\xfe\x0c\x10\xad\xee\x9a\x41\x51\xd9\x59\x46\xb9\xa3\x7e\x39\x0f\xfc\x40\x42\xec\x62\x08\x33\x42\xc7\x72\x66\x6f\x70\x09\x21\x0b\xa4\x06\x10\xa0\x84\xe4\x74\x8d\x7b\xc2\x2f\x9d\x2f\xc1\x7b\x9e\xaf\xee\xc8\xe1\xcc\x22\xa0\x00\xa9\xee\x43\x0d\x42\xf1\x14\x71\x25\x75\x7f\x92\x28\x06\xde\x88\xc6\x8d\xf4\xb8\x91\xaf\x04\xc6\xe7\x4b\x3a\x55\x5e\x99\xd5\x9f\x89\x96\xb2\x0f\xf6\x7a\xef\xa8\x66\x66\xb7\x4e\xd6\x50\x4b\x2c\xee\x7f\x5c\xe2\xe3\xc6\x28\x13\xe3\x52\xed\xbe\xf0\x08\xcc\x2d\x64\x06\xe7\x0e\xeb\xb4\xc8\x83\x23\x4a\x86\xd1\xec\xd3\x08\x70\x05\xf5\x5e\x4d\xce\x34\x3b\x4a\x80\xce\xeb\x90\xb3\xf6\xf5\x42\xe0\x15\x96\x4f\x2f\xe4\x87\xbc\x5e\x69\x82\x14\xa4\xde\x0b\x98\xba\x3e\xbd\xd0\xed\x47\x57\xe2\x31\xbf\xf7\x4a\xcd\x97\x8a\x56\xef\xd6\xf4\x8f\x3e\x12\x0f\xf9\xbd\x17\x82\xa7\x65\x12\x44\x9c\x2d\x7c\x45\x85\x68\xc2\x08\x31\x04\xef\xec\x85\x74\x3c\x60\xba\x2d\xee\x18\x92\x45\x43\x07\x08\x4f\x44\x10\xa8\x44\x9c\xfa\x70\x9b\x0d\x83\x00\xc0\x12\x94\x30\xe4\xd4\x2d\xb8\xcd\xa8\x1b\x08\xa1\x78\xfc\x8b\x1f\xa0\x91\x9a\x7d\x4d\xc4\x3c\xcd\x4c\x18\xa2\xbc\x96\xf3\x61\x46\x7a\x14\x41\xa0\x55\x7b\xa5\xbc\xfc\x21\x33\x84\x86\xb0\x06\x32\x73\x46\x31\x1f\x3c\x48\x61\x12\x01\xb3\xaf\x19\x24\x37\xdd\xca\xfd\x56\x01\xde\x24\xd0\xe7\x8b\x0e\xff\x92\x4d\x95\xf2\xb0\x21\x88\xc4\xa9\x06\xf1\xb4\xa9\xdb\xd2\x3b\x8a\x86\xc7\xb6\xf4\x96\x93\xd9\xb8\xfb\xef\x18\xdd\x2d\x69\x9e\xf7\x89\xaa\x25\xf3\x23\xa6\xb6\xad\x21\xf5\x35\x4b\xec\x21\x6a\xf5\xae\x59\xce\x5d\xfc\xab\x40\x7f\x52\x86\xa4\x69\x1d\xa1\x46\x37\xb6\xef\xfe\x69\x9d\x1b\xfa\x98\x9f\x6f\x68\x6e\x3f\x7e\xb6\xa1\x4c\xfb\x7c\x83\x95\xfa\xba\xc1\xcd\x34\xcd\xea\x2e\x8e\x95\x5b\x94\x62\xb8\x7f\x83\x66\x7d\x7f\xf3\x35\x11\xce\x83\x6f\x8f\xcd\x2d\x36\x17\x5f\x7b\x47\x1a\x3f\xdc\xda\xa4\x24\x35\x6c\x0d\x14\xfc\xf3\xd6\x3e\x7d\xba\xc7\x51\xa5\x6d\xbc\x20\x31\xe9\xc8\xa5\x4e\xb7\x9a\x3e\x6e\x2e\xe7\xe6\x06\xd7\xcf\x6d\xde\x9f\xec\x00\xfb\x63\x4c\xee\xd0\x5f\x77\xd0\x3a\xdd\x1c\x9a\x3e\xa8\x56\x9f\x5e\x6f\x77\x7f\xe5\xe2\x8f\x05\x47\xfb\xb1\xa9\x72\x8b\xfb\x47\xc3\x7e\xb0\xa5\x97\xf2\xf1\x74\xd7\xd9\x66\x6e\x3f\xd8\x12\x0f\xf1\xd9\xe9\x44\x2d\xff\x68\x93\x4d\xf9\xd1\x09\x87\x24\xc9\x65\xde\xdd\x5b\x3c\xdf\xb3\x1f\x8b\x3d\xfb\x88\x47\xcb\xa3\xbe\x9c\xf6\xc6\x67\xfb\x6c\x13\x9f\xed\x69\xcb\x77\xcf\xf6\xe9\x16\x3e\xdb\xa7\xa7\xe3\xb3\x7d\xbe\xc9\x7c\x8d\xec\xf9\xee\xf7\xdf\x47\xfc\x7e\xf5\xdb\xd8\x61\xa8\x46\x0f\xfe\x7e\x4b\xeb\xe5\x07\x5b\xaa\xb6\x1f\x6c\xb1\x3e\x6e\x3f\xd8\xa4\x96\x5f\xb7\xf8\xf8\xd7\xf6\x20\x10\xf7\xb9\x87\x49\xc4\xe9\xce\x70\x30\xbe\xe9\x4c\xfc\xf3\xc0\x76\x3d\x2b\x91\x99\x72\x9f\x7a\x9c\xbe\x86\x5c\xc5\xde\xd7\x2f\x2c\x4e\xe3\x8e\xe0\xe4\xa9\x6e\xf4\x96\x16\x85\x0e\x72\x31\x95\x9e\x54\xe2\xd4\x12\xea\xf8\x57\xe3\xc7\x19\x42\x5b\xa7\xca\x21\xeb\x00\x90\x83\xbd\xc0\x26\x6a\xa9\xca\x6d\x5d\x6c\x03\x5e\xba\xd9\x8e\xb2\x44\x5f\x9e\xa8\x2c\x4d\x2a\xdf\x06\x8a\x7a\xd4\x08\x48\x23\xa6\xc2\x8c\xd9\x22\xe8\x7c\x40\xac\x1a\x64\x34\x08\x70\x01\x6a\xe3\x3e\x14\x2c\x71\x3b\xa0\x46\x7c\x70\x0f\xbd\x22\x59\xc8\x18\x99\x45\x65\x33\xd0\x79\x16\xa4\x4b\x0c\xd2\x5d\xc0\xf6\xb2\xda\x66\x39\xd5\xb1\x53\xdd\x4b\x85\x80\x21\xba\x62\xa1\x2d\x06\x97\x0d\xff\xe6\xc4\x64\x7a\x49\x85\x68\xc7\x93\xa4\x95\xc8\x6c\xc2\x67\x10\xaa\xba\x21\xc8\xb7\x58\x39\x59\x68\xea\x97\xe8\x8a\x9a\x5f\x5d\xcf\x9f\x55\xad\x8f\xe6\xfe\x42\x39\x73\x4c\x9d\xa0\x48\xa6\x9c\xf1\xbe\x03\xed\x3a\x25\xdc\x3d\x8a\xff\x62\x8f\xf8\x76\xc4\xc6\xe3\x3c\xe0\x38\xcf\x12\xda\x6e\x15\x1c\x7e\x71\x7e\xff\x9d\xe7\x23\xf6\x8e\xa0\x98\x79\x11\x01\x4d\xf6\x37\xb1\x74\xfe\xa0\xc7\x63\x2f\x1e\xc7\x6b\xcb\x94\xab\x7a\x4b\x4c\x8a\xaf\x84\x2c\x0a\x46\x7a\x90\x87\x10\xf0\xd8\xbe\x05\xd5\xe0\xba\xc8\x30\xbd\x9d\x90\x7d\xe6\x4d\xe5\x4a\xbe\xfa\xee\xf7\x38\x4b\x89\xb0\x1e\x4e\x71\xed\xb8\x16\x93\x1d\x2c\x2e\x58\x6f\x85\xb2\x55\xb8\xce\x7d\x91\x26\x6b\xaf\xe5\x2e\xa8\xd8\xf2\x13\xe8\x79\xf8\xd3\xc1\xf5\x4c\xd8\xc6\xe1\xd7\x8d\x7e\xf5\x66\x5f\xd2\x8b\xf2\x53\xaa\xd1\x62\x39\x4d\xd4\x81\xb6\x99\x21\x22\x1e\x29\xea\x6a\x4c\xf1\x1f\x58\x6b\xb4\x94\xb3\x5e\xa1\x9f\x0a\x29\x64\xda\x47\x0d\xb0\x64\xe4\x71\x59\xcb\xec\xc3\x4e\xfb\x09\xe3\xec\xc1\xec\xe6\xf3\x68\x63\x89\x82\x68\x3b\xa1\x5e\x12\x1c\x67\xd4\xac\xd5\x50\x6c\xef\xb1\xaf\xb5\xf3\xf0\xe0\x33\x70\x1f\x83\xa9\xc1\x7a\x4d\x2c\xc7\xc2\x2a\xcc\x0f\xb7\x88\x85\x5a\x6b\x3e\xb4\xf9\x73\xd8\x4e\x29\x79\xcd\x23\x0a\x4b\xdd\xf7\x03\xdb\x58\x4d\x05\x21\xe9\x01\x6a\xc3\xa4\xe5\x50\x4d\x80\x93\x22\x2d\xc8\x2c\x75\x3e\x49\xc7\x28\x29\x10\x89\x3d\x14\xd1\xf4\x3d\x14\xcb\x51\x61\x12\x49\x6d\xf5\x76\x21\xe6\x11\xe1\x55\x12\x9c\x60\xce\xa9\x40\xd9\xc0\xed\x38\x27\x99\x42\xa7\xa0\x92\xdc\x2e\x59\x91\xc3\x0a\x8b\x50\xdb\x2e\xc1\xaf\xcf\xe8\x3f\x8c\xca\x40\x78\x83\x4b\x5d\xae\x12\x31\x46\x84\x11\x8d\x0e\xe4\x1b\x71\x67\xa1\x75\x29\x76\x3b\x05\x8d\x8b\x3d\xec\x59\x28\x52\x34\x39\xf3\xb7\x50\x0c\xde\xa1\xc7\xb2\xb4\x28\x1f\x3a\x98\x93\x27\x0e\x31\x53\x7e\x86\xc9\x5b\x62\x61\xcf\xef\x0f\x73\xff\x2c\x11\xa8\x2c\xd4\x00\xf7\x3c\x60\x25\xfd\xa0\x36\xf7\x7e\x22\x61\x73\x8f\xe2\xc3\x45\x79\xfd\x5c\xf6\x05\xae\x73\xe0\x92\xe3\x2a\xa3\x9c\xc0\x8f\xb3\xc8\xeb\x4a\xb5\xd0\x8c\xaf\xec\x15\x21\x6f\x77\x0a\xe0\x55\x06\xf0\x05\xf8\xe9\xd2\xf6\x3a\x13\xa0\x89\x3d\x70\xcc\x32\x14\x79\x88\xdd\xa7\x8c\x9c\x0c\xec\xd4\x41\x05\xc3\x10\x68\x70\x65\x77\xb8\xba\xad\xed\xde\xb7\x18\xe6\x90\x2f\x87\xe2\x6b\x90\xe3\x85\x94\x55\x5a\xbb\x78\xcc\xdd\x49\x24\xfa\x1b\x82\x52\xa8\xbb\x67\x2d\x3e\xab\x96\x59\xf6\xfc\xfd\xb6\x83\xc4\x3f\xac\xd7\x5f\x60\x1e\x47\x99\xf3\x53\x39\xff\xd3\xf6\x23\x3e\xf8\xeb\xfa\x5c\x93\xad\x2d\x7d\xd8\x78\x3c\x09\xcb\xa1\x78\xda\xf7\x7b\x55\x9c\x6b\x25\xa7\xfc\x67\x0a\xb2\x6f\x8f\x6a\xf8\xa7\x0a\xf9\xa7\xa3\x1e\x27\x8b\xf0\xd5\x9f\xba\xcc\x1f\xba\x0a\xd9\x27\xc6\xb8\x2f\x95\xf4\x1b\x88\xa2\xb4\xb4\x04\x21\xae\x10\x1d\xeb\x26\x78\x39\xdd\xb7\xb4\x90\x9b\x90\xb8\x59\x37\x23\x10\xab\xa5\x1d\x74\xc6\xfb\x31\x61\x94\x75\x6a\x7e\xa8\xf6\x2d\x6c\xc4\x05\x15\x75\xf1\x19\xef\x05\x59\xd3\xcf\x00\x19\xac\x60\x10\x61\xfc\x06\xfc\x04\xa8\x98\xa1\x25\x82\x34\x4b\x4f\x43\x2d\x8a\x8a\x7e\x07\xa2\x83\x54\xe6\x2c\x31\xc2\x89\x02\x09\x2c\x27\x3c\x3b\xe4\xcb\xbf\xd5\x83\xe5\xa2\x28\xa4\xfa\x16\xac\xf2\xab\xa8\xbb\xed\x2f\x4f\xf4\xd5\xe0\x78\x49\x34\xcb\x2b\x57\xeb\xf3\xe0\x18\xf9\x07\x83\xe3\x6c\xb2\x0d\x88\xe1\x45\x4a\xbb\xeb\xb4\xdf\x35\x52\x74\x1a\x8f\x82\xb0\x6c\x54\x80\x7e\xba\x6f\x3c\x14\x39\x49\xd0\x68\x33\x4e\xfe\x18\x28\xd8\x18\xdb\xf8\xff\xff\x8e\x8e\xff\x8e\x8e\x3f\x37\x3a\x5e\x8a\x11\xe4\xa5\x48\xfe\xb9\x18\x41\x34\xf5\x36\xb6\xa6\xe6\x8b\x54\xdd\x16\xcb\x39\xb5\xe6\xbe\xde\xc5\x15\xbc\x94\xcd\xca\x4c\xbd\xeb\xba\xb4\x39\xde\xdf\xaa\x8d\x34\x66\xdb\x34\x17\x22\x00\xb5\xe9\xb6\x28\x24\xb3\x46\x59\x8d\x01\x08\x71\x7f\xda\x70\xea\xc7\x09\xdb\x30\x3f\x74\x6d\xc3\x8f\xb8\x8e\xef\xa8\xed\x90\x8c\x6d\x56\x1a\xcf\x76\x9e\x1b\x42\x8f\x70\xfa\x75\x03\x55\xb7\xf7\x21\xea\x43\x21\xf1\x57\x24\xaa\x10\xb0\xba\x6f\xcb\x44\xa1\x5f\x3e\x25\xad\xf5\x2c\x94\x85\x28\x73\xd2\x7c\xe3\x2e\xb1\x47\x0b\xd8\x45\x40\x50\x2d\xf9\xe9\x70\x1d\x5c\x66\xf8\x74\x50\x25\x29\x7c\x71\x0d\x18\x1b\x60\x7a\x5f\xbd\x8b\x17\x84\xaf\xfc\xac\x58\x56\x06\x2a\x77\xe7\x7e\x4e\x01\x89\xf3\x83\xcf\x50\x48\x30\x80\xdb\x70\x82\xb9\x09\xd2\x8f\xc3\xa8\x00\x39\x2c\xa4\xbb\xe7\x63\xc9\xe6\xbc\xf2\xb2\xd7\xfc\x4f\xdc\xeb\xf6\x17\x4f\xe6\x8d\xe3\x6d\x33\x21\x8a\xc9\x9d\x37\x1c\xfa\x59\x53\xfe\x27\x6d\xbf\xfd\x78\x87\xf7\x37\xb5\x0e\xad\x8a\xdf\xff\xd4\x8a\xb3\xea\x0f\x4f\xca\x22\x85\x72\xc7\xea\xa5\xe2\x66\x2b\x00\x55\x58\xf0\x7a\x62\x48\x25\x63\x1c\x6c\x3e\xdd\xd5\x71\xd7\x49\x4b\xcf\x8d\x38\xad\xed\xfa\x5c\x3e\x7c\x81\x2d\xa8\x73\xe2\xa8\xa5\x8e\xdd\x58\x4a\x52\xf2\x69\x70\x77\xc6\x1f\x82\xee\xd3\xa4\xdc\xb8\x88\xfa\xad\x8e\x9f\xdc\xf0\x0f\x1f\xe8\x7f\xe9\x88\xf8\xab\x7d\x1d\x7b\xd1\x36\x10\x48\xb5\x7a\x13\x20\x09\x1d\x9f\xa7\xc1\xbf\x3e\xbe\x54\xd1\x87\x6d\xff\xd5\x9c\xf5\x9a\x41\xbf\x8a\x8c\x6b\x6f\x29\x6f\x13\x38\x6e\x9f\x41\x71\x4d\x4a\xb3\x94\xf7\xb7\x61\x9a\xf2\xc6\xbf\x32\x7f\x5e\x5a\xc1\x7e\xb8\x2e\x6a\x94\x25\x4b\xde\x29\x48\x5f\x20\x30\x9f\x13\xe1\x32\x63\x5f\x7a\x3e\x19\x60\x7c\x12\x44\x25\x14\x2b\xe4\xa0\x35\x98\xc8\x45\x2a\x33\x48\x62\x26\x2a\xc8\xa3\xf2\x71\x80\x71\x97\xb8\x98\xb6\x2b\x16\x86\x42\x82\xcb\xb4\x18\xb5\x12\xda\xb9\xe2\x52\xc5\xdc\xf7\x7d\xe8\x44\xf6\xf3\x93\xf5\x71\x94\xe7\x94\x7e\x00\xbb\x74\x83\xdc\x95\xd0\x27\x0e\x81\x2d\x82\x0f\xa3\x76\xbc\x1c\xf4\xf6\x03\x5f\x58\xc9\x71\x7c\x58\xa0\x3f\x51\xb0\x4e\x3a\x1c\xe4\x2a\xaf\x13\xf8\x5e\xab\xaf\x31\x00\x88\x44\xf5\xf9\xb9\x1b\xed\x01\x16\xbb\xe3\x60\x3b\x31\xa4\xf0\x7f\x15\x78\x95\x33\xd0\xa0\xbc\x93\xa8\x61\x1f\x7e\x9f\xac\x16\x43\xc5\xdc\x31\x93\x14\x3c\x93\x74\x3c\xa2\x7f\xa4\xeb\x81\x95\x0d\xd2\xd1\x1e\x72\xfe\xda\xdc\x03\xd6\x34\x53\x49\x48\x43\x83\xb4\x81\x29\x45\xd4\x4e\x74\x54\x2b\xe6\x03\x65\x02\x4b\x9b\xeb\x32\x40\xc5\xac\x41\xb9\x53\x52\x9b\x87\xef\x25\xd3\xcd\xcb\x26\xc1\xc2\x3e\xdc\x90\xa1\xab\x6c\x6c\x04\x70\xd2\x3c\x28\xc2\x90\x39\xeb\x05\x0b\x79\x4e\xaa\x79\x55\x9f\xa6\x54\x81\x72\x50\x30\xa2\x22\xc4\x9c\x08\x48\xf3\x4b\x95\xb8\x24\xca\xd9\x6b\x4f\x3e\xcb\xcc\xb9\x4b\x4f\x4d\x89\x8c\x13\x2b\x84\xe6\x88\x94\xdd\x34\x59\x4f\xbd\x25\xeb\x04\x36\x83\x09\x4a\x8e\xc7\x87\xc9\x8d\x1f\x4f\xd1\x38\x6a\xfd\x17\xbd\x22\xb4\x25\x42\xb4\x62\x65\xc7\xbc\x56\x14\x57\x5e\xe6\x3c\x65\xc3\xd1\x38\xb3\xed\x3d\xa4\x77\x89\x40\xf0\x27\xda\x20\xba\xa7\x5a\xf7\xc6\x7a\x62\x86\x34\xc0\xb0\x76\xe2\x2f\x10\xb5\x41\x71\x1d\x50\x19\x28\x82\xfe\x92\x59\xa4\xe6\x17\x1c\xbc\xbc\x90\x05\x3f\x31\x4d\xa8\x65\x49\x35\x67\x92\x6b\x65\x3b\x85\xfa\xc8\xeb\x36\x2f\x72\x0c\x09\x7e\x31\x04\xd8\x66\x44\x18\xc9\x3c\xee\x86\x0b\x39\x03\x45\x11\xbd\x23\x29\x18\xba\x03\x34\xb8\x18\xfc\x66\x34\x4c\xd8\x11\x61\xa9\x75\x81\xd4\x1c\x07\x71\xb0\xfb\x7b\x9b\x1d\x10\x96\xd6\xc2\x52\xf8\xce\x60\x4d\x30\x18\x07\xf6\x50\xa8\x31\x5d\x9b\x1b\xa5\x7f\x98\x2b\xe1\xf6\xfb\xc8\x12\x50\x85\x80\x82\x15\xed\x9b\x96\x04\xb2\x6e\x35\xd0\x97\x2d\xd0\x89\x92\x4c\xc9\x8c\x2f\x1c\x02\xef\xb3\x1d\xf2\x04\x98\xd0\x31\x97\x30\xe8\x6e\xde\xce\x9d\xa1\xfe\x19\xbc\xe4\xd6\xbe\xd5\x15\x04\x1c\xf2\x3d\xd1\x02\xe3\x68\x65\x9e\x22\xb9\x25\x55\x9f\x0a\x4a\x42\x85\x5f\xb2\x71\x14\x4b\x52\x57\xad\xf6\x81\x71\x01\x58\xb8\x5c\x6f\x10\x56\xf5\x31\x10\x6b\x6a\xc3\xdd\x7d\xea\x6a\x3c\x87\x77\x5e\xfd\xa8\x3e\x37\xd4\xec\x48\x57\x00\xe7\x9a\x21\x7d\x6d\x6d\x27\x6e\xbb\x25\x85\x27\x17\x13\x1f\xea\xf8\x80\x87\x2e\x25\xd8\x5f\x7e\x40\x3f\x12\x94\x27\x41\xe9\x51\x49\x69\x32\xa8\x43\x93\x9a\xa1\x80\x5c\x7b\xdf\x21\xea\x81\x02\x9c\x24\xf6\x25\xeb\xc9\xed\xa4\xfb\x78\xc8\xfb\x9c\x10\xee\x67\xfa\x8f\xe3\x3b\x66\x92\x7f\x27\x31\xc9\x57\xc3\xfc\xb5\x64\xe5\x97\x07\x21\x5d\x1e\xf4\xea\x51\x0d\x1b\xd0\xe0\x60\xc9\x29\x3e\x17\x1d\x64\x68\x2f\xfe\xa4\x21\x84\x10\x80\x7f\xcc\xc4\xfc\xae\xa4\xfb\xf3\x43\xc6\x29\x2a\x8b\xd3\xec\xc0\x30\x9b\x25\xe0\x54\xa7\x84\x5c\x02\xd4\x65\x39\x9c\xb0\xcc\x79\xa7\xaa\x89\xa2\x83\xc1\xd6\x07\x06\xda\x90\x9e\x64\x60\xbc\x8c\x90\x81\x5e\xb4\x21\x84\x1b\x9c\x9d\xa7\xa2\x5c\xe4\x57\xc8\x47\x50\x42\x0d\xe4\xdb\x99\x51\x63\x59\xf4\xc2\xa9\x49\x6f\xbb\x91\x20\xb0\x87\x67\xdd\x31\xb7\x1e\x01\x01\x47\x05\x47\x8e\x9c\xa1\x12\x8f\x2e\x39\xbe\x49\x8e\x8d\x5a\xb1\xbf\x99\x1f\xfd\xff\xb3\xf7\x6e\x3b\x92\x2b\xcb\x92\xd8\x7b\x7e\x45\xfc\x40\x34\xc2\x3d\xee\xd0\xbb\xde\xfa\x1b\x84\x91\x74\x06\x29\x80\x18\x80\x10\x27\x1f\xea\xeb\x05\x37\x73\x32\x59\xcd\xaa\xca\xea\xb5\x7b\xed\xb3\xcf\x68\x03\x6b\x75\xb1\x8a\xf7\x60\x5c\xfc\x66\x66\xe0\xa0\xd4\xbe\x27\x11\xcc\xac\x18\xce\xa1\xac\xdd\xe5\x9f\xf1\x50\xa7\x67\xc5\x1c\x98\x28\x84\x47\x26\x42\xbe\x77\x60\xfa\x02\x34\x8b\x36\x62\x9b\xfd\x07\xe7\xd5\x86\x84\xad\xc2\x28\xea\x05\xa9\xf1\xbe\xfe\xdb\xc0\x21\xdb\xae\x38\x76\x8a\x40\xf4\x43\x87\x6d\xcc\x06\x7e\xf0\xdb\x67\x23\xb5\x15\xec\xff\x6c\xb7\xa2\xee\xfe\x32\x7b\x3d\xe0\x7c\x7f\x3c\xb3\x3d\x78\x39\x50\xea\x5f\x42\x40\x77\xdb\x09\xdc\xca\x27\xb1\xa0\xa9\xae\xb0\x92\x38\x00\x7c\xad\xa3\x50\x8f\x2f\x32\xad\x3e\x7f\xe1\x76\xab\x87\xce\xd4\x69\xf3\x79\xc4\x6d\x3b\x9f\x7a\xba\xe6\xab\x51\x74\xad\x83\xb9\xa0\x37\xde\x31\xad\x8e\x04\x6a\xa4\x9c\x20\xba\x1b\xdb\xde\x5d\xb1\x5a\x82\x00\x16\x60\xed\xb2\x44\x06\x55\x80\xad\x18\xd4\xf2\xc5\x84\x38\xc0\x06\x2e\xc3\x0e\x28\xa1\x25\x05\x7d\x0b\x91\x41\xe9\x9e\xdb\x74\xd1\x67\x2c\xa7\xe8\x7d\xea\xf6\xa3\x4d\xe2\x3a\x84\x75\xf5\xad\xf5\xb5\x51\x22\x9c\x7d\x1c\x69\x9c\x4c\x4c\x11\xf4\xb6\x37\x5b\x0f\x6c\xbe\x6c\xa1\x8c\xba\xc0\x1c\x61\x44\xc3\xa6\x25\x28\x24\x56\x27\x45\x9f\x4e\xba\x56\xea\x2e\x1b\x93\xd2\x3d\xe6\x66\x93\x96\x0d\x27\x94\x16\x0e\x04\x4a\x90\x2a\x01\x21\x07\xd0\xd8\xc4\x60\x56\x5a\x3b\x65\xaf\x69\x2e\x19\x20\x90\x16\xda\x68\x6b\x6c\xa8\xf2\x22\x9d\xf4\x41\xfc\x8a\x8d\x5d\x34\xdc\x2c\x0e\xbc\x61\x14\x04\x05\x5b\xb9\xc7\xa2\xd9\x6b\x51\xab\x3f\x55\x4e\xc0\x75\x81\x0f\xb8\x87\x5c\xca\x96\xab\x04\xd1\xb2\x02\x50\x2b\x4c\x75\x51\xe1\x1d\xc5\xad\x63\x9b\x4f\xae\xc4\x0e\x88\x94\xd9\x70\xb9\x99\x41\xd7\x7c\x2f\x76\xda\xf1\x75\x6c\xbc\x04\x8a\x18\x58\x38\x99\x61\x90\x28\x7c\x00\x6b\xb0\xf2\xf5\xac\xfc\xf8\x8f\xff\xf1\x3f\xff\xdf\x5f\x3b\x94\x5e\x58\x90\x4f\x34\x15\xe0\x1f\x74\x2c\x93\x97\x71\xb1\xe2\x99\xc4\x89\xd9\x99\x37\x47\x07\x8e\xce\x4c\x47\x2d\x1f\xa0\x17\x3f\x93\xcc\x52\x2d\x0f\x70\x3b\x7d\xb8\xf7\x43\xc4\xa4\x6a\x71\x3a\xa8\x6f\x68\x64\xd9\xf5\xb1\xa4\xa1\xac\x14\x85\x10\xb2\x13\xfc\xca\x68\x41\xd5\x6c\x39\xe0\x79\xa6\xde\x56\x28\x0a\x17\x16\xca\x69\x99\x48\xa3\xc9\x18\x1b\x33\x9c\x63\xac\xd2\x91\x74\xcb\x60\x54\x28\x9b\x66\xd7\x32\x01\x20\x26\x21\xae\x38\xf6\xe6\x32\xab\xee\x1d\x37\xd7\x3b\xe2\xa8\x33\x31\xd6\xd9\xbc\x7b\x67\xf7\xbd\xa7\xcf\x7a\x4f\xed\xf5\x7d\xe6\xa9\x2a\x97\xdc\xb9\xea\x73\x29\xee\x0a\xd0\xef\x87\x16\x56\x91\x4f\xf0\xba\x1f\x7f\x9a\xa6\x4b\xcc\x03\x64\x4d\x79\x05\xc3\x9a\xc0\x96\x69\xa8\xa6\x5d\x77\x25\x58\x67\xe7\x70\x79\x40\x98\xc6\xa3\xd8\x07\x29\x54\x00\x77\xc1\xc4\x58\x7c\x99\xcf\x07\x79\xb3\x20\x94\x90\x79\x16\x4e\xc2\xb5\x78\xa9\xd3\xe6\xbe\x7b\x3f\xfe\x79\x8d\xdb\x6a\x26\x9d\x8d\x1c\xb8\xa9\x6d\xb1\xe7\xcd\x43\xef\x51\x21\xac\xf9\xba\x4f\x15\xe8\x3e\x9a\xe9\xfd\x8e\x10\xec\x0f\x7d\xca\xed\xd3\x2e\xf3\xea\x23\x5f\xb2\xb2\x7a\x29\x11\x3e\x0d\xec\x91\x21\xbc\x92\x56\x4c\xaa\x5d\x83\x2b\x95\xd1\x0b\x22\x30\x3f\x27\x4f\x13\xbf\x1c\xf9\x92\xf5\x3e\xdb\x6f\x0c\x7c\x68\xe5\xfd\x4e\xdf\x9a\xed\xdb\xc2\x78\xd0\x66\xd6\x35\xaa\x74\x32\xc8\x30\xe1\x3f\x48\xbc\xc5\xd7\xc0\x5b\x38\x69\x10\x5e\x16\xef\xea\x72\x6d\x68\x03\x73\x1d\x6b\x00\x19\xb5\x0e\x10\xc7\x44\xb0\x6c\xe4\x3d\x46\xa2\xcd\x57\xc0\xbb\xad\x89\x80\xca\x02\x94\x01\x7c\xbe\xd9\x57\x02\xb7\xbf\xcb\x06\x6e\x85\x56\xf1\x13\x65\xea\x29\x48\x97\x75\xd8\xba\x93\xbb\x2d\xab\x0d\xd4\x3b\xce\x50\xc2\x45\x27\xef\x41\x16\x28\x88\x21\xbf\x83\x27\x89\xda\x33\xfb\x1f\xb2\x38\xdf\xee\x81\xb7\x7f\x42\x17\xbc\xe4\x3e\xf5\x28\xda\xa5\x08\x45\x4d\xd7\x29\x7a\x7c\x3c\xf5\xd8\xdf\xbf\xdf\x3d\x24\x97\x25\x6a\x45\x71\x4c\xdd\xa7\x9e\xf1\x6e\xea\xf9\x67\x77\xe2\xdb\x9f\xe9\xc5\xd0\x65\xc5\xca\x95\x4e\x2b\xd7\x31\xd3\xd1\x79\x73\x59\x5a\x50\x9b\x36\x9b\xdc\xd0\x83\xcc\x03\x05\x31\x33\xaa\x94\xcc\x71\x1c\xde\xc4\xf0\x62\xf2\xa2\xd5\xbc\x81\x72\x77\xbd\xa2\xeb\x43\xfd\xab\x76\xb4\x4b\x1a\x51\x2f\x65\x7e\xbf\x5a\xc5\xff\xee\x7b\x7f\x64\x06\xfd\x75\x02\x55\xa0\xe4\x9b\xad\xa7\x4b\xac\x1a\x2a\xca\xc4\x05\x65\x4e\x6b\x9c\x0e\xd9\xd5\xdd\x05\xd1\x4c\x29\x8c\x62\xae\xf8\x1e\x60\x3f\xa4\x7d\xb7\xdd\x53\x45\x5d\x38\xa2\x4b\x88\xbb\x20\x43\x90\xbf\x65\x25\xde\x76\x5b\x64\x78\x51\xd1\xbb\xbc\xb7\x99\x70\xdf\x6e\x62\x41\x61\x3c\x3c\xa8\xbe\x0c\x84\x5b\x26\x34\x37\x94\x61\x68\x3b\x0c\xca\xbe\x70\x9d\x56\xea\x19\x7b\x35\x9d\x1c\x5e\x3f\x5e\x87\x59\xa0\xb9\x54\x24\x9a\xd6\xbd\x7b\xe4\xca\xa2\xc1\xc3\x18\xf9\xc6\x80\x1c\x59\x3f\x1e\x90\xb7\xff\x4c\xe3\xe3\x92\x4b\xd6\x4b\x75\xe6\x7b\xe5\xb0\x14\x24\xa5\xce\xa0\x2e\x24\xf3\x59\x38\x01\x8a\x17\x80\x44\xcc\x32\xa7\xb5\x1e\xa1\x23\xf3\xcf\x73\x2e\x90\x90\xfa\x5b\x9c\x92\xdb\x5f\xf0\x4a\xcc\x30\x50\xb3\x26\x30\x06\x33\xb2\xa0\x99\x3a\x72\x10\xcf\xb4\x7d\x2a\x21\x9b\x7d\x30\xcb\x2a\x5d\x50\xc5\x67\xbf\xcf\xb2\x82\xaa\xc1\x3c\x16\x17\xd6\x43\x0d\x38\x2f\x15\x71\xad\xb7\x9f\x63\x92\x2b\x09\x19\xdb\x0c\xce\x8b\x90\x05\x36\x36\x36\x1c\x3f\x48\x35\x11\xdb\xb2\x9d\xfb\xc6\x41\xc6\xbc\xc7\x4b\x65\x00\xb5\x08\xd8\x20\xc0\x93\xb5\x84\x3c\x05\x1a\x52\xb0\x00\xf0\x2b\x3d\x67\x40\x12\xf7\x13\xce\x31\xf0\xdf\xec\x9b\xf4\x52\x45\x87\xb7\x6a\x46\x2d\x23\x14\x17\xc1\x02\x60\xd3\x3a\x64\x90\x2b\x02\x97\xec\x4b\x55\xd4\x01\x6c\xac\xa3\xf8\x4b\x96\xfc\x21\x9c\x00\xfd\xc1\xda\x01\x97\x64\x06\xd0\x36\xfc\xc5\x19\xf5\xdd\xff\xb2\x22\x82\x81\x2c\x10\xce\x79\x35\xb4\x2e\x29\x4f\xbd\x56\x5b\x4e\x3d\x1c\xf6\x9d\x82\xe4\x9f\xb1\xd6\xf5\x86\x40\xb1\xa7\x86\x54\xca\x46\xc4\x43\xe9\x2b\x25\xde\x00\x13\x85\xa0\x83\xa8\x35\x1c\xf8\x0b\xda\xea\xaa\x9a\xd3\x17\xc3\x30\xd2\x16\x95\x35\xc2\x88\x47\x49\x0f\x8d\x8b\x26\xb5\x3f\xc0\x0a\x46\xba\x50\x21\x85\xd5\x74\x12\x9f\xa0\x39\xdd\x6c\x5a\xce\x35\xf4\x11\xb4\x2a\x9d\x76\x14\x50\x6b\x19\x10\x68\x7d\xda\x3f\x1e\x92\xdd\x79\xd1\xbf\x65\x03\xfd\x33\x1a\xd2\xe6\xff\x0e\x62\x35\x1b\xa2\x2b\xda\x6d\x86\xcc\x22\x82\xf2\xe9\x33\xde\x4e\xeb\x02\x0c\x6c\xd2\xda\xa2\xa2\x08\x88\x0c\x20\x45\x20\x75\xda\x77\xda\x3d\xd6\xb8\xcf\x1d\xa9\x58\x50\x10\x81\xd2\xf6\x1a\xec\x28\x3b\x08\x20\x69\xe0\xe7\x74\xec\xb4\xbc\xc0\x16\x0a\x61\x73\x9b\x76\xc0\xfc\xe6\x1a\xa9\xdf\x92\x59\xfb\x6c\x9f\xd5\xbe\x44\x26\x61\x1b\x90\xb5\xcd\x25\xdd\x84\xc9\x45\x7e\xbd\xbc\x79\xd5\x78\xcf\xdf\x18\xfa\xf6\x72\x83\xf5\x14\xb7\xaf\x47\x2a\x3c\xba\x41\xdd\x63\x7b\xce\x68\x0f\x6a\xcf\x89\x2c\x53\xb0\x71\x47\x7b\x4c\x76\xee\x2e\x3e\x6a\xcc\x60\xfb\xc0\xc3\x82\x9d\x42\x53\xd8\x89\xf4\x67\xf6\xf8\x4f\xec\x2f\xb8\x76\xaa\x5c\x52\x9b\xfa\x25\xeb\x31\xca\x0e\xff\x49\x76\xe9\x97\x63\x15\x35\x09\x64\x61\x62\xab\x27\x1b\xad\x9e\x77\xe9\x2b\x08\x3a\x28\x30\x95\x66\x98\x3e\x44\xc1\x90\xc0\x39\x35\x7f\xdf\x82\xbd\xfd\x53\x63\x00\x80\xb9\xf7\x23\xfd\xeb\xaa\x0a\xa3\x07\xa7\x63\x46\xb0\x37\x27\x88\xa9\x82\x36\x06\x88\x80\xac\x2c\x90\x20\x57\x60\xf1\x70\x6b\x2e\xa1\x20\x7d\x9e\x56\x29\x0d\x04\xfa\x9a\xc2\xec\xab\x42\xc7\xe7\xa5\x11\x77\x1e\xad\xb6\xe8\x62\x2d\xf8\x6b\x8b\xee\x79\x5c\x7e\x15\x66\x5c\x85\x61\x85\x77\xab\x72\x3f\x56\xe5\xed\xb4\x1c\xcb\xef\x2d\xc7\xbe\x76\xbe\x74\x0d\x6f\x5f\x2f\x9e\xfd\xcb\xc5\x73\x3b\x2f\x9a\xf2\x3b\x8b\xe6\x25\xf9\xa8\xf3\x6f\x8b\x78\x92\x6a\x46\xca\xc2\x80\x4f\x49\x2b\xdd\x1e\x3f\xdf\x7e\xe8\x02\x62\xdd\xd2\xe0\x12\x4d\xa7\xdd\xc5\xb5\x51\xdf\x0d\xce\x83\x05\x03\xaa\xcf\xbf\x21\x72\x7a\xfb\x13\xa1\xd3\x5f\x23\xa7\x7d\x04\xf0\x31\x58\x73\x82\xc8\x0d\xe9\x66\x8c\xc1\x19\x54\x97\xd2\x42\x69\xeb\xb4\x51\xa9\x61\xc2\x5d\x9a\x8b\x80\x36\xa4\x2b\x08\x7a\x54\xf2\xdf\x1c\x77\xfd\x67\x04\x23\x2e\x29\x3a\xbd\xd4\xd1\x9e\x02\xaf\xad\xa4\x30\xa6\xae\x8a\x69\xa9\x84\x73\x1c\x60\x3b\x87\x08\x0e\x9a\x75\x4f\x2e\x58\x6f\xf1\x74\x43\xf4\x04\x04\x21\x58\xb0\x75\x3d\x43\xb1\xc5\x3d\x67\x11\xf7\x2c\x06\xab\x5c\x00\xb2\xa5\x47\xb1\xed\x3e\xc6\xe1\x76\xd8\x5c\xf9\x19\x67\xe6\xf5\x43\x48\x4b\x0f\x69\xe6\xd4\x5a\x27\x56\x8a\x58\x4e\x92\xb9\x4d\x24\xcb\x26\xba\x3b\x7b\x3b\xfa\xbb\xea\xcd\xfa\x44\x5e\x34\x29\x48\x9c\x3e\x28\x99\xb4\x5d\xd1\xf6\xfd\xe6\xe8\x99\x1a\xa0\x94\xd6\xea\x27\xd4\x99\x9f\xfa\xf7\x2d\x61\xd9\x62\xaf\x42\x35\xc9\xdf\x10\xd0\xbf\xfd\xe5\x8e\xa5\x17\x30\xab\x5e\x94\xef\xcf\xd6\xc4\x4c\x12\x9a\xca\x0e\xe1\x78\x0f\x31\x58\x58\x6f\xa4\xe6\x10\x1d\x51\x19\x2f\x30\xe0\x96\xa4\x25\x96\xca\x1a\x22\x34\x3f\x42\x1d\x00\x08\xe2\xe7\x82\x95\x66\x54\xf0\x24\xfe\x25\x07\x99\x31\x25\x90\xd7\x75\xef\xf1\x1e\x5b\xda\xdc\x11\x60\x70\x69\x45\xbf\x47\x09\x53\x83\x1c\x9d\x8a\x19\xfa\x0d\xd8\xe0\x4c\x5e\x73\x41\x75\x47\x50\xce\x6e\xa0\x7f\x1b\xba\x69\x99\xce\x6a\x01\x7a\x9b\x00\x26\x21\xeb\xf7\x9b\x02\xd1\x31\x1a\xf5\x62\xd1\xf3\xef\x92\xf5\xc1\xd7\x78\xd7\xbf\xdb\x47\x41\x06\x7b\x01\x9d\x65\x89\xde\x0a\x9f\x35\x12\x5b\xd0\xe3\x44\x2c\xdb\xd8\xdb\x99\xfd\xec\x8f\x75\xb3\xdb\x1f\x9a\xbf\xf4\x9a\x1d\xbc\x8a\xf7\xff\xc5\x8c\x70\x93\x4f\xf8\x79\x3f\xec\x24\x76\xf4\x77\x62\x8e\xb6\x14\x7e\x6b\xc5\xda\xce\xcb\xe1\xb1\x48\x1e\xeb\xe6\x69\x35\x3d\xc5\x31\xfe\x95\xe2\x6a\x7a\x4d\xea\x5d\x15\xf9\x4f\xdf\xc6\x7c\xc0\x0a\x4e\xb0\x93\x34\xd4\x9f\x7a\xd6\xcf\x72\xd6\x1e\x7f\xe1\x7d\xff\x93\x32\xbc\xb7\xbf\xf6\xd5\x5f\xb4\xfe\x35\x9f\xf5\x59\xf1\xcd\xd7\xd7\xb9\xa6\x2b\xfe\xfb\x5f\xba\xce\x25\xca\x9a\xd3\xd3\xaa\xad\x42\xab\x16\x35\x7d\x10\xd7\xde\x45\x64\x6c\x95\x6b\xed\x22\xf0\x92\x28\xf0\x92\xa7\x3c\xea\xac\x77\x99\x73\xc9\x60\xf0\xba\x47\xd5\xf9\x90\xe2\xd2\x23\x4a\xf1\x4b\x72\x62\xe8\x58\x44\x35\xc8\x03\xa4\xf9\x2d\x63\x0e\xec\x23\x98\x99\x41\xe9\x16\xf5\xea\xf3\xe4\x8c\xf6\x51\xb5\x3d\xa2\x74\xb9\x47\x4d\xe9\x11\xed\x06\xd8\xa8\xa0\xef\xcb\x75\x2f\x43\x6c\xe9\x29\xbb\xf3\xf0\x27\x7e\x0a\xbf\x24\x0a\xbf\xb4\x57\xb0\x26\xbd\xc4\xcb\xf2\x57\x05\x2e\x29\xcc\x0c\xd8\xb6\x23\xe8\x5d\xf1\xd3\x51\xfc\xac\x1b\x44\x70\x31\x6f\x36\xa4\xfa\xd8\x60\xc2\x30\x86\x9f\x02\x16\xd5\x46\x0a\x43\xd4\x06\x67\x17\xe4\xd0\xd1\x77\xe2\x63\xac\xc7\xd0\xa3\x44\x3e\xb8\x43\x58\x16\xe1\x13\x4e\x6d\x0c\x44\x59\xd7\x9f\xce\xb6\xea\x84\xd6\x08\xa5\xe8\x06\x00\xc2\xa0\x99\x95\x27\x25\x3c\x44\x28\x7b\x8d\x8e\x3e\xa1\x73\x8a\x08\x85\x6c\xa8\xa2\xb3\x9f\xe6\xd4\x93\x3b\xd0\x8c\xa7\x7e\x88\xe8\x0e\x33\x4a\x16\xcc\xc9\x66\xc3\x41\x6d\x17\xb0\xef\x4e\x85\x07\xc4\x18\xa6\x52\x7e\x44\x21\x80\x0d\x08\xbb\x62\x2a\xae\x66\xbf\x65\x84\x0c\x5a\xa5\x3a\x4b\xb3\xf6\x1b\x39\x80\x25\xad\x6d\x92\x35\xf4\xbc\x36\xf3\x89\xe7\x0e\x69\x27\x17\x15\x31\xf8\xe0\x88\x42\x92\xdc\x3c\x3c\x16\x9d\x75\x2f\x06\x65\x63\x14\x2a\xd2\xed\xe5\x98\xd4\x32\x50\xeb\x1d\x60\x36\x6c\x63\xab\x2d\xcc\x0a\xea\x6c\xa6\x62\x6c\x51\x10\x28\x0f\xce\xc9\x35\x02\x00\x00\xa8\xda\x29\x43\x3c\x0a\x7a\x81\xd9\xa8\x43\x94\x08\xe9\xc7\x73\x51\xa7\x5d\x32\x75\x78\x9c\x90\xa5\x04\x71\x8a\xf0\x4d\x3b\xd3\xf7\x7d\x9f\x53\x1c\xea\xe0\xc5\x11\x08\x6a\x86\xd8\xf3\x46\x3c\x7d\x5d\x23\x05\x4b\x7a\xc8\x6b\xb4\x61\xe9\xc5\x85\xa1\x36\xe8\x2a\x4d\xae\x94\x34\x0f\x40\xe7\x45\xf5\xef\x57\x3d\xfb\x12\x5d\xca\x47\x19\xcf\x1c\x76\x75\x25\xe6\x82\xbc\x11\xa5\x6c\x83\x5c\x34\x79\x85\xba\x0c\x52\x2d\x98\x05\x50\x4f\x00\xa1\x14\x32\xdd\x4e\xeb\x31\x47\x59\x23\xec\x70\x86\xed\x48\x44\x33\x53\x68\xe6\xdf\x0d\x7e\x9e\x9e\x9c\x85\xac\x0c\x5a\x42\x4e\x65\x87\x72\xf9\x59\x1e\x63\xcd\x61\x4a\x00\x57\xde\x58\xb5\x98\xfb\x07\x26\xda\x15\xe5\xea\xd6\x5c\x3f\x08\x3c\x46\x84\x62\x1e\x75\x0f\x1c\x6c\x98\x32\xba\xcb\x09\xa7\xc0\x7a\x52\xcc\x64\xfd\xd0\xd7\x27\x1f\x45\x75\x29\x35\xd2\x54\xb6\x5d\x1a\x1a\x41\xab\xd5\xbe\x66\xcf\xe8\x37\x90\xaf\xa9\x8d\x42\xd7\xa8\x98\x33\x0f\x84\xfa\x33\xf6\x2f\xa5\x8e\x6a\x71\x79\x71\x0d\x14\x02\xed\x03\x08\x0e\x81\x08\x90\x42\x55\xa5\xa6\x4d\xa1\x80\x22\xb9\x6c\xd6\x61\xf0\xdb\x56\x7d\x3f\x84\x9b\x7d\xeb\xb9\x37\x3e\x4f\x89\xc7\x65\x7c\x2b\x62\x93\xa2\x2a\x38\x00\xbd\xd0\xcf\xab\x00\x22\xe7\x5d\x2b\xc2\x63\xa8\xb9\x8d\x85\xe9\x8c\x9c\x6f\x8b\x16\x0d\xbd\x63\x36\x82\xe2\x4d\xf6\x11\xc4\xc7\x97\x22\x65\x15\x94\xbb\x2a\x44\x3c\x6c\xe6\x57\xe7\xd9\x6e\xb2\x09\x78\xd0\x30\x42\xb1\x1c\x30\xac\x7e\xda\x3c\x1d\x10\x4f\xe7\xc5\xe3\x6a\x6b\x94\xc9\x50\x51\xab\xc1\xec\xe3\x02\xdb\x3e\x97\xc5\x96\x83\x92\x60\x28\x8f\x20\xa0\x2e\xb6\x39\x76\x90\x24\x23\xdb\x12\xc5\x9b\xd8\x3d\x78\x0b\xde\xc1\x6e\xc0\xeb\xb7\x17\x8c\xaa\x55\x2f\x71\x9e\x7c\x2d\x7a\x7a\x57\x08\x00\xac\x82\xd9\x49\x8e\x42\xb3\x2d\x02\xc0\x1c\x1b\xf6\xc9\xce\x36\x5b\x10\x44\xcd\x0b\xc7\xbc\x93\xd5\x2b\x7f\x44\xfb\x09\x4c\xd9\xd8\xfc\x87\xff\x95\xc7\xe0\x04\xde\xc3\x8c\xa5\x2f\x6e\xc2\xb0\xde\x3f\x74\x13\x3c\xab\x4a\xbb\xfd\xa3\x17\xea\x13\x02\x8e\x28\xd0\x06\xa6\x42\x51\x77\x6d\x1b\xbe\x77\x2f\xef\xfe\x78\x2f\xc5\x44\x3e\xd8\xfd\xe2\xab\x5e\x22\x2a\xf9\x2b\x8d\xec\x9e\x0a\xd4\x87\xc1\xa6\x93\x8e\x6c\x2a\x57\x48\xfc\x08\xf8\xd3\x76\xde\x3e\x1f\xb4\xa7\x99\x1d\xdd\xc6\x4c\x74\x97\xe7\xe9\xfb\x6f\xe7\x03\x9d\x35\x00\xc5\xd6\xd5\x27\x5e\x67\x25\xfe\x51\x3d\xb6\xae\x28\xed\x60\xae\x05\x58\x90\xfd\xaf\xbb\xbc\x25\x40\x42\xb9\xea\xc3\xfe\xf9\xfa\x28\x99\x14\x41\xdb\x1d\x77\x88\x10\xe3\x58\xdc\x26\x57\xc5\x95\x7e\x3d\xe6\x74\x08\x1f\x44\x72\xd8\xff\xb2\xed\x07\xd9\x1b\x3c\xf8\x04\x1f\xee\x96\xf9\xd5\x0b\xe6\xaa\x2c\x9b\xf7\xf4\x44\x55\x08\x62\xcc\xb4\x4d\xc8\x80\x10\x88\xab\x79\xc0\xae\xa1\xb6\xbd\x2d\x37\x35\xbd\x00\xe5\xd5\x1c\x9e\xb8\x3b\x29\x41\xd2\xf4\xaa\xbb\x04\xa1\xf0\x92\xb1\xd4\x6d\x4d\xc3\x90\x0d\xcb\x3b\xa9\x81\x08\x64\x4c\x5c\x5b\x48\x66\xbf\x76\x70\x59\x07\xa9\x14\x74\x92\x53\x1e\x3c\x1d\xdb\xdc\xc4\x21\xa8\xa9\x02\xc5\x32\x98\xe9\xfb\x0e\xc7\xb1\xe9\x6d\x36\x33\x91\x6d\x71\xc7\x42\xcf\xd7\x04\x53\x7c\x9c\x09\x5f\xfc\x45\x0f\xcf\x97\xd0\x4e\xfe\x8a\xa7\xec\x3f\xad\x87\xf7\x21\x21\x6b\x5a\xa0\x63\xa3\x65\xae\x88\xbf\x61\xed\x39\x7a\x2b\x03\x74\x02\x48\x51\x7e\x1f\xa2\x3b\xfb\xf8\x0b\xc4\x70\xb4\xf8\x06\xae\xb6\x1f\x9b\x79\xac\x77\x5c\x84\xc4\x21\xde\xda\x6e\xa7\x08\xe2\x33\x4c\xb3\xbc\xbb\x92\x5f\x88\x47\x65\xef\xc2\x41\x75\xf1\x6b\x1c\x11\xe8\x53\x54\xe7\x78\xa1\xfd\x52\x3c\x28\xdb\x41\xec\xe7\x88\x55\xef\xef\x74\xbc\xf5\xfb\x68\x06\xe6\xf3\x8c\x06\x8a\x32\x90\xef\x16\x08\xfb\x1d\xff\xcf\x5d\xdb\x0e\xbf\xec\xe8\x7f\x12\x4d\x67\xa7\x6a\xfb\x68\x10\xdc\xbe\x3d\x0a\x7e\x6f\x10\x30\xc3\xa2\xca\x0a\x76\x51\xdd\x32\xe0\xae\xfa\xae\xa7\xab\x79\x1f\xe6\x0e\x34\xd7\x0c\xec\xd4\xec\x43\xfa\x38\xa3\x82\xc9\xde\xaa\xf0\xad\x5e\x08\x63\xd6\x7c\x89\x2f\xe5\xaf\x98\xdb\xb4\xba\xb8\x77\xd7\x4f\x32\x34\x65\x00\x16\xf4\x00\xb8\x92\x2c\xb0\xd8\x24\x01\x00\xf2\x37\xbf\xd4\x7d\xc9\x27\x97\xea\xc9\x0b\xaa\xc8\xc0\x83\x62\xaf\x6e\x2e\x90\x6c\xf8\xa0\xbd\xf2\x67\xb4\x8d\x8e\xb0\x96\x6c\xfb\xcf\x7d\x87\x1f\xc8\xf3\x9c\x91\xaf\xf6\xe6\x81\xf3\x3a\xc3\xbb\x11\x7a\x1e\xbb\x77\x7b\x80\xdb\xc7\x74\x56\x5c\x36\xcd\x56\x78\xd5\xbc\x97\x10\x51\x3e\x64\xa5\x59\x0c\x52\x73\x5b\xa0\x9b\x85\xa6\x13\x04\xcb\xa7\x82\xd6\x04\xac\xd7\x00\xdf\x67\x9d\xfe\xe7\x02\xbd\x1b\xfb\xfc\x23\x2b\xb7\x46\xe6\xdf\x6d\x09\xb1\x23\x71\x1a\x41\x9f\xbd\xe0\x8f\x32\x95\xf7\xb0\x5b\x68\x6d\x4b\x46\x75\x5c\x1b\xf7\xdc\x07\x7e\x81\x80\x55\x6d\x6f\x3f\x7b\x83\x08\xf5\x62\xd6\x20\xbf\x9b\xbc\xf2\xe9\xf3\x25\x10\x93\xc7\xb3\xb0\x78\x0c\xbc\xe3\x7b\x79\x6e\xd2\x1c\xe7\x3d\x00\x61\xeb\xd4\xf0\x64\x33\xd8\x1f\xd4\xa3\x40\x90\xec\xc4\xf6\xec\x2e\x1a\x91\x74\x85\x06\x48\x0d\x80\x22\xd9\x01\xf6\x57\x33\xd5\x50\xbb\xa2\x0c\x4d\x07\x4d\xdb\x08\xb9\x32\x93\x05\x89\xd2\x41\x7d\x18\x5c\x6f\x9a\x9f\x4f\x34\x92\xea\x83\xf7\x46\xb6\x26\x3f\x65\x0f\xf8\xac\x13\x35\xe4\x25\xb1\x69\x6c\xad\x1d\xe6\x9c\xda\xec\x53\x9b\x79\xba\x82\xd0\xb7\xff\xe4\x9f\x6f\xdc\x88\x95\x7b\xec\x97\x6d\xff\xe9\x3b\xde\x7e\x4a\x2e\xc5\xda\xfd\x61\xe3\x29\x92\x90\xc1\x61\xbb\x2f\x7b\xd5\x25\x64\x95\xe7\xff\x8a\x2d\xae\x63\x04\xd5\xb2\x82\x60\x5b\x24\x87\xd2\xb7\xd2\x6d\x0b\x64\x3c\xf8\xc9\x3f\xdf\xb8\x11\x4b\xc7\x1e\xd0\x14\xee\x3f\x7d\xc7\x1b\x16\xea\xa3\xc1\x6b\x29\x6c\xef\x5a\x8a\x2d\x15\xe5\xbb\xb7\xfa\xce\x9d\x00\xa1\x7d\xde\xaa\x37\xbf\x55\x7f\x39\x96\xae\x41\xc4\x6b\xba\xf2\xe9\x32\xd5\x69\x8f\x46\x96\x5f\x8a\xe7\x6a\xdd\x65\x9e\x48\x8e\x95\x19\x21\x66\xde\x86\x69\x9b\x1c\xc6\x12\x4b\xab\x41\x33\x17\x3b\xd9\xe9\x13\x33\x7d\x63\x33\xb0\xcc\x61\x7f\x88\x00\xda\x67\xab\x4f\x0a\xb9\x6c\x3a\x83\x78\xfa\x05\x81\xa1\xba\x54\xd4\x1c\x51\x6c\x2a\xa3\x82\xe7\xed\x67\x33\x43\x2e\x49\x59\x2a\xd4\x5b\x5b\x5b\xa2\x6d\x69\x6b\x8f\x96\xd2\x0e\x1a\x9c\x10\x20\xab\xe5\x78\xe8\x83\x6b\x11\xc5\x3e\x04\xec\xf6\x20\x79\x89\xa5\x48\x50\xc5\x99\x63\xda\xfb\xc2\x77\xb2\x25\x5a\xc9\x4b\x5b\x88\xe3\xcd\x2e\x7f\xea\xa2\xb7\x33\x41\x33\x26\x6b\x09\x55\x3b\x2a\x35\xa1\x3d\xa7\x7b\x99\x71\x0b\xb1\x2d\x15\xf4\x61\x3d\xad\xe6\xd9\x87\x12\xe2\xcb\x4f\x74\x0d\x61\x1e\x2c\x27\x23\xcd\x50\xb3\x2e\xda\x5a\x28\x73\xda\xb0\x56\x17\xf3\xc9\xe2\xe9\xb5\xe2\x58\x4e\x9b\x93\x8b\x06\x4c\xcd\x40\xaa\xdb\x2c\x60\xd6\x5c\xb3\x4e\x34\xf3\x23\x66\x2d\x77\x49\xf2\xc8\x32\x76\xf5\xb2\x93\xfe\x23\xd6\xd6\x83\x6b\xfd\xd5\x43\x5f\xa3\x53\x57\x5a\x07\x9d\xcd\xdf\xa3\x20\x20\x90\x27\x34\x81\x59\x03\xeb\x44\x22\x30\x9c\x94\x7a\x1c\x15\x96\x16\x68\x2c\x08\xc4\x1c\xce\x44\xbb\x46\x08\xd5\x95\x14\x6a\x35\xa7\x35\x43\xba\x0a\x35\x3a\x2c\xbe\x56\x46\x84\xc0\xba\x3d\x79\x27\xe8\x1d\xe1\x9b\x90\xb0\x64\xf8\x6d\x78\x97\xe3\x26\x28\x12\xc4\x3d\x28\xb8\x87\x12\xa1\xba\x33\x82\x66\x88\x56\x04\x4a\x70\x7a\x9d\xf7\xe9\x5e\x0d\xb9\xfa\x15\xb3\x1a\x29\x8b\x42\xac\x4f\xa1\x98\x22\x3f\xea\x6d\x25\xc7\x42\x18\x0a\x2e\xe4\xdc\x29\xef\x4b\xa6\xe6\x46\x96\x13\x72\x7d\x22\x18\x56\x81\x01\x2a\x98\xe8\x58\x92\xc6\xd2\x25\x5c\xbb\xe3\xbe\x05\x85\x41\x89\x82\x57\xda\x89\x76\xa5\xde\x68\xef\x1e\x45\x8d\x7e\xd7\xe8\xb7\x8d\xef\xee\x7b\xba\xed\xe9\xae\xb8\x69\x73\xe2\xbd\xad\xed\xb7\x13\xd4\xaf\xa7\x59\xee\xb2\x9a\x61\x08\x2e\x61\x04\xdd\xec\xde\x03\x23\x97\x9e\x94\xdd\x7c\xba\xd8\x18\x72\x0f\xdd\x73\x0f\xc8\x43\xec\xfe\xd3\x48\xa1\x50\x53\xd5\x8c\x06\x4c\x2c\x88\xe4\x15\x08\x9f\x93\x3d\x17\xc5\x7a\xe0\x92\x78\x2e\x8e\x36\xfd\xb0\x4a\x06\xd1\xb2\x63\x6b\xdf\x69\xb3\x24\x84\xce\x6d\x60\xcc\x19\x58\xfa\xc8\xaa\x2e\x26\xbe\xbc\xb0\x0f\x0c\xbb\xda\x43\x4b\x61\xa8\x07\x89\x81\x6d\xa7\x96\x88\xba\x34\xed\x46\xd5\x83\x6e\xcd\xb7\xeb\x62\x93\x85\x19\x44\x75\x79\x1d\x64\x57\x80\x80\x88\xde\xac\xc3\x99\xe1\x03\xea\x05\x71\x08\x72\x79\xfa\x61\x1e\x9e\x76\xb2\x5f\x40\xe9\x73\x5f\xa9\xdd\x04\x41\x1c\xf6\xae\xd6\xa8\x58\x1f\xdb\xe8\xfb\xec\x6b\x6e\x20\x49\x45\x8a\xec\xfa\xa3\xad\xba\x50\xaf\xb9\x29\x10\x7e\xb4\x67\x9e\xae\xf3\xe0\xfb\xa8\x2f\x8b\x8e\xdd\x43\xa1\x7e\x7b\xe6\x23\x17\x5d\x1b\x66\x61\x09\xb2\xa2\x5a\x36\x14\x09\x10\x7d\x0f\x3a\x83\x39\xf5\x00\xc8\xd2\x99\x28\xab\xfd\x0d\x6c\x42\x00\x66\xd8\xc4\x6d\x6e\xce\xcd\xc6\xa1\x28\x28\xe8\xa4\xad\xb9\x5a\x0f\x82\xde\x37\x10\xe6\x94\xca\x9c\x0f\xd4\x7d\xd2\xe1\x19\x41\x59\x20\x6a\x9e\x74\x27\x43\x83\xd9\x97\x03\x2b\xca\xb4\x33\x52\x18\xb2\x4a\x0d\x4d\xc3\xcc\x61\xda\x0b\x08\xc8\x96\x20\x34\x98\x99\xa2\x02\xf3\x40\xf7\xc8\xb2\x75\xbf\xbb\xe4\xd5\x86\x54\x65\x36\x2c\x73\x05\xa9\x08\xf8\x42\xed\x2a\xf9\x88\xdf\x37\x98\x07\x11\x98\x1a\x50\x21\xcc\x08\x9f\x4d\xb1\xee\x99\x42\x0b\x82\x64\x49\x53\x84\xd2\x49\x14\xe3\x2c\xbe\xb6\x9e\x75\x64\x16\xb2\x86\xec\xc4\x91\x61\xea\x16\x95\xd6\xbe\x19\x38\xa2\x2d\x4c\xbb\xf4\x44\x23\x59\x27\xe5\x0c\xa0\x5c\x98\xa8\xaa\xc6\xce\x56\x9c\x49\x52\x36\x0a\x1e\x3a\xa9\x8c\x53\x3f\x25\x8c\x34\x29\x81\x85\x2b\x6b\x19\x36\x88\xe7\x08\xe6\x49\x16\x54\xf5\xa2\xf4\x57\xca\x52\x7a\x28\x6d\x6d\x12\x6c\xcc\xb6\x0c\x6d\x73\x29\x35\xf4\x1c\x74\x68\x18\x94\x35\x1c\x54\x5b\x3c\xd6\xc4\xb2\xf1\x0d\x88\xda\x21\x69\xb3\x80\x90\x5d\xd2\x5a\x67\xf5\x77\x01\x83\xca\xbc\xad\x73\x40\x66\x09\x51\x68\x55\x5d\x91\x7c\x4e\xc1\x7c\xda\x79\x17\x08\x87\x0d\x16\x43\x54\x92\x52\x64\xca\x2d\x66\xf4\xf1\x45\x6c\xd1\xb7\xe7\x09\xd9\xe6\xf4\x0d\x32\x45\x6b\xcf\x88\x25\x4d\x28\xc9\x0d\x1b\x4d\x58\xe5\x38\x80\xb2\x3f\x20\x04\x8e\x30\xfd\xa9\x39\x2c\x5c\x9d\x9f\x93\x27\x98\x79\xcc\x0c\x58\x91\xe1\x50\x12\x9b\xd8\x6c\x43\xa9\x3c\x96\xa9\xf7\x15\xc3\x16\x24\x2e\xec\x10\xf8\xb9\x4a\xb0\xee\x3b\xf0\xed\x06\x02\xd6\xd9\x3a\x95\x7d\x76\xf4\xbe\x04\xd1\xd3\xdb\x86\xba\xac\xcc\x8e\xd7\x10\x69\xca\xe8\xa9\x71\xd6\x75\x52\x89\x32\xc4\xb1\xcb\xfc\x67\x4e\x05\x63\x6c\xd6\xdf\xa3\xe3\xa0\xa0\x69\xd7\x5d\x48\x0f\x72\x00\x21\x76\x88\xee\x48\x05\x61\xc2\x34\x17\xb6\xdb\x60\xd2\x15\xc1\x36\x1b\x63\x42\xcd\xbf\x09\x45\xac\xdc\x57\xa4\x76\x9a\x8d\xca\x98\x8b\x75\x12\x1b\x94\x23\x10\x9d\x24\x29\x00\x9b\xbd\x72\xb9\x08\xf0\xe9\x21\x10\x39\x38\x09\xbc\xfd\x94\x09\xc9\x7e\x92\xbe\x28\xc3\x33\xb5\xac\xc0\x74\x2b\x59\xec\x25\xeb\x6d\x75\xdf\xdf\xfa\x38\x5a\x1b\xc5\xfb\x73\x57\x27\x63\x43\x04\xe9\x1b\x97\xf6\x04\x56\x9b\x19\xa6\x56\x9b\x11\xcc\x28\x29\x4e\x76\x86\xb3\x99\x57\x00\x05\x79\xc3\x23\xdb\x3c\x00\x02\x31\x29\x01\x5a\x37\x6b\xcc\x54\x11\x97\x20\x90\xba\x89\x7d\x82\xd5\xc5\x39\x6d\xb0\x38\xd8\x70\xb1\x3b\xa9\xd9\x3c\x72\x90\x11\x95\x20\x6b\xc1\x88\xad\xa4\x1b\xca\x8e\xd7\x2d\x39\x64\xfb\xb6\xe6\x75\x05\xc9\x04\x53\x8a\x19\x90\x5a\x47\x18\x79\xae\x90\xc2\x20\x7b\x3f\x5e\x3b\x82\x70\xdb\xac\x85\xb2\x7a\x2a\x0b\xa9\xd1\xb4\xd1\xbc\xa5\x78\xa9\x4b\x4e\x92\x35\xc6\xd9\x6a\xb1\x89\xb4\x92\xce\x12\x7a\xee\x2b\xea\xe6\x25\x4c\x4f\x19\x4a\xb6\x11\x8a\xa6\x40\x4b\x6c\x1c\x74\xd6\x40\x8f\x84\xa8\x12\xe4\x8d\x83\xbd\x18\x27\xd7\x10\x3b\x29\x45\xda\xa1\x9e\x2e\xe8\x6f\x36\x37\x22\x9c\xff\xf6\xb3\x74\x09\x6d\x64\xeb\x24\xa2\x05\x83\x3e\x57\xd2\xf7\x95\x40\xe7\x7f\x2c\x1e\x7a\x78\x08\xa4\xef\xa2\x6b\xcb\x45\x99\x0d\xb6\x91\xb9\x24\x21\xe6\xb7\xdb\x4f\x29\xb9\x84\x56\xca\x3a\x28\xef\xdc\x9e\xdf\x90\xa4\x70\x40\x5b\xa0\xce\x22\x30\x40\x4c\x95\x78\x9b\x1d\x69\x4e\x68\xb2\x49\x7c\x10\x6b\x4d\x9e\x35\xd8\xac\x98\xab\x5a\x28\x4f\x2c\x0f\xca\x83\x29\x0d\x3c\xa7\x59\x2d\x98\x68\xb3\x53\x7f\xed\x95\x26\xfc\xc3\xa4\x24\x91\x1f\x65\x5b\xd8\x80\x90\x91\xa7\x83\x21\x4d\x69\xbf\x73\x72\xf0\x43\xcc\x47\x1e\x09\xea\x1d\xd0\x9e\x41\x17\x92\x90\xac\x29\x60\xb4\x07\xe6\x80\x9b\x4b\xa7\xc7\xd6\xf0\xdd\xa4\xc0\x87\xa4\xce\x3b\x79\x3a\x80\x19\x87\x62\xac\x84\x3c\xd9\xa7\x99\x78\xde\x9d\x1d\x7b\x37\xd1\x50\x4a\x87\xa6\xe7\x04\xd1\x0e\x0f\xb4\xb9\xa0\x84\x96\xed\xbe\x66\x4b\x44\x56\x14\x87\x08\x49\x58\x7c\x0d\xb3\x9c\x74\x33\x6b\x29\x83\xe7\xaf\x34\xa4\x38\x05\x92\xf7\x50\x2a\xb5\x9f\x92\xde\x7e\x76\x9b\xab\xb2\xe7\x76\xeb\x0c\x6e\x72\x8c\xc3\x0a\x45\x19\x95\x0d\x99\x81\x4a\x2b\x10\xf1\xa9\xac\x58\x92\x46\x98\x69\xb3\xa9\x3b\xe5\xdb\x1a\xdb\xe4\xbc\x04\x9d\xb3\xb7\x9f\x75\x9a\x41\x90\x80\xa6\x70\x40\x40\x6e\x08\x8c\x47\x31\x0f\x8a\xc1\x63\x2d\x69\x73\x0f\x5f\x6a\x81\xd2\x59\x31\x2b\x83\x22\xf4\x6d\x53\x34\x9d\x56\xeb\xd5\x19\x1c\x59\x39\xb9\x11\x11\xf6\x25\x19\xc6\xf8\x26\x01\x79\x8b\x47\x14\xf2\x80\x22\x79\xe0\x44\x4b\xe8\x51\x28\x76\x98\x09\x46\x2d\xcb\x0b\xc1\x4f\x36\xf0\x07\x1b\x28\x36\x68\xe0\x52\x46\xb2\x71\x81\x72\x0f\x74\x8c\xa4\x85\x99\x5b\x44\x93\xf4\xcd\xfc\x90\x7a\x0c\xd5\x72\x5b\x38\x29\xb3\x80\x29\x44\xf3\xa1\x94\x99\x6b\x17\x3e\x97\x7d\x83\x64\x01\x09\x77\x8a\x5c\x62\xf1\xd5\x90\x08\x4d\xce\xf4\xe4\xda\x82\x2c\x80\x03\x3d\x0d\x97\x18\x30\xf4\xf0\x4c\x7b\xc7\xe9\x8b\x40\xca\xb0\xce\x94\x0c\x59\x30\xe7\x0b\x28\xc5\x06\xec\x91\xea\xdc\x75\x99\x0c\x3b\x8d\xcd\x03\xf1\x8a\xd0\x2a\x69\xaa\x1a\x2b\x87\x05\xb6\x27\x3c\x16\x94\x20\x26\x44\x12\xc6\x8a\xb9\x35\x87\x4c\x6d\x65\xe4\x63\x6c\x12\x4c\x0c\x3d\xf7\x04\xcb\x9e\x9c\x7b\x72\xf4\x74\xd6\x66\xb0\xb8\x27\xef\x3a\x07\x98\xd2\x39\x73\x86\x38\xf3\x06\xbc\x5d\xd1\x15\x2c\xc4\x61\x96\xa0\x63\xab\x39\xf4\xf9\xf6\xb3\x4a\x0a\x35\x43\x65\x18\x84\x6c\xf6\x28\x73\x95\x09\xde\xae\x90\xa7\xd9\x75\x05\x95\x06\x55\x5d\x45\x3f\x88\xcd\xae\x34\x64\xa5\xb1\xc1\x8a\x6b\xfa\x32\x09\x81\xff\xca\x66\xff\xd6\x95\xb0\x33\x3a\x6e\x9d\x0b\xae\x7a\x0b\x66\x5f\x68\xd1\x6a\x08\xff\xdf\x23\x34\x50\x31\x31\x00\x1e\x05\xc6\x5b\xeb\xd7\x99\x70\x9f\x9f\xb5\x53\x0d\x73\xad\x99\x1c\x48\x62\xb6\x93\x7d\x99\x5a\xa0\xb7\x10\xcd\xf7\xb2\x99\x12\x2e\x10\x05\xdf\x1a\xd0\x0c\xd6\xa1\xb8\x1a\x9b\xcd\x58\xa9\xc2\xa7\x33\x94\x69\x6b\xe4\xa0\xcc\x46\x41\xdc\x6b\x8c\x7b\x44\x2f\x07\xd3\x26\xd5\x63\xc1\x8c\xd6\xd7\x12\xaa\x35\xa0\xb5\xc2\x0a\xbd\xf8\x90\x73\xe8\xb2\xe0\xb5\xd7\x1c\x7a\x87\x28\x6b\x5e\xf7\xe8\x59\x0a\xe6\x58\x99\xdb\x8f\xb7\xce\x19\x8b\x16\x52\x1a\xf0\x5d\xc1\x3c\x8a\x72\x2d\x10\x7f\xe1\xd2\x28\x88\x29\xac\xf4\x88\x79\x64\x6a\x5f\x82\x26\xc0\xe6\x0f\x70\x59\xf7\xf6\xf6\x53\x01\xd5\x9d\x69\xad\x81\xb8\x0c\xc2\x89\xd0\x2d\x00\xe2\x93\xa4\x41\x30\x30\xb3\xfb\x42\x54\xe6\xe8\xac\x67\x60\x47\xd2\xb9\x17\xb7\x87\x4c\x6f\x99\x16\x8f\xad\xcd\x7d\x92\x11\x6f\xac\xf6\xda\xc1\xba\x52\xd1\xcd\x7a\xd6\x7c\x05\xbe\xca\xd7\x5a\x80\x4b\xad\xe4\x89\x57\x52\x2a\x2a\x91\x59\x90\x34\x18\x34\x11\x69\x9b\x53\x3c\xa1\x2c\xa7\xf9\x14\x5d\xc8\xa9\xd6\xb6\x7d\xe3\xe0\x47\x2c\x5c\xfb\x9a\x5b\x9d\x7e\x11\x54\x8f\xf4\xfa\xfe\xf2\x9c\x85\xdb\x7e\xdd\xfd\x16\x7e\x03\xbf\xfc\xf3\xe2\xc7\xa5\x0f\x93\xf6\xb8\x84\x5d\x3e\xd9\x54\x3a\x57\x64\x69\x12\xab\xa0\x8e\xca\x29\xeb\x69\x43\x19\x07\x6e\x79\x03\x00\x93\x75\xd2\x9a\x92\x0b\xef\x28\xd2\xb0\x14\x87\x71\xd6\xd8\xcc\x6f\x45\xea\x56\x54\xe5\xd0\x5b\x65\x8a\xc3\xe5\xc3\xd1\x68\x1d\x9c\x90\xce\x08\x89\x25\xc4\x35\x93\xb0\x44\x96\xcd\xc5\x9c\x3a\x26\xbe\xe1\x4e\xae\xb7\x2c\x9f\x31\x52\xd6\x05\x04\xd2\xa3\xba\xfc\x8e\xba\x3a\xa0\x2d\xb1\x55\x28\x13\x24\x09\x3d\x42\x40\xcf\x32\xcb\x6e\x70\x8e\x4c\x55\xaf\x4a\xb6\xa6\x4d\x6c\xca\xf2\x5a\xd1\xca\x32\x26\x7e\x1f\xd9\xd0\xb5\xcd\x06\xb9\x6d\xe0\xc4\x44\x79\x39\x7d\xec\x2c\x25\x80\x61\xd0\x3c\x48\x1c\xe8\xa7\x10\x06\xe6\x6f\x85\xa4\x37\x2b\xe9\x50\x02\x89\x72\x3f\xfb\xa8\x4c\xe8\xd4\xd3\x4a\x9f\x50\x68\x81\x88\xa8\x5d\xe1\x55\x8f\xbd\xd6\x39\x7c\x45\xee\x36\x66\xb3\x29\x47\xed\xf9\x91\x06\xce\xa4\xc5\xdf\xa2\x3a\xa1\x5c\x3f\xa1\x65\xf9\x47\x84\x0f\xec\xc0\x6d\xff\xf9\x6e\xef\xbb\x13\xf7\xcb\x65\x50\xe2\xfb\x3e\xee\xe2\x49\x3c\xa7\xb5\x60\xd7\x89\xfb\xcf\xf3\xbe\x78\x3e\x29\xf2\x42\x04\xbb\x79\xbe\x00\xd4\x71\x36\x4a\xba\x6c\xf8\xdc\x87\x84\x96\x8e\xc6\x3e\x65\xe3\xc1\x37\x6e\xae\xbd\x65\xfb\xe2\x71\x78\xdc\x2f\x80\x0d\x94\x3c\x8e\xf6\x54\xd6\xc2\xc1\x5d\xec\x36\x9b\xff\xd8\xff\xbc\x1f\xc7\xf3\xde\x7e\x16\xaf\xb7\x81\x9d\x49\xdd\xf7\x47\x2c\xe4\xfe\xdb\x65\xe0\xa5\xdd\x23\x90\x84\xb4\x45\x5b\x90\xf6\xe0\x21\xd8\x0e\xd2\xee\x59\x77\x14\x7d\xfa\x82\x5a\x70\x8f\x81\xb1\x3c\xd6\x46\x49\xe1\xd8\x6e\x8f\x28\xf2\x19\x48\xf2\x63\x64\x27\x18\x87\x27\x90\x8d\xb8\x08\x68\x30\x3b\xb5\x8c\x3e\x63\x3e\xf4\xef\x00\xe0\x1b\xb5\x68\x5d\x6f\x29\xe5\x8d\xf0\x48\xa2\x24\x89\x90\xc0\xce\x2d\x9e\xb7\xdf\x1d\x14\x4f\x67\xfb\x36\x36\x79\x90\x1f\x03\x56\x3c\x9c\xfc\xdc\x3a\x1f\x70\x9c\xf7\xf6\xb3\x96\x12\xa6\x8e\x47\x9c\x0c\xbd\x23\xd5\x1f\x09\xc9\x88\xef\x30\x19\x73\x73\x30\xe8\x6a\x8b\x42\xf8\x90\x6e\xf1\x33\xb6\xc5\x13\xe0\xf4\x1b\x57\x37\x8f\x04\xef\xa0\xe0\x50\x2d\xd3\x5f\x11\xde\x39\x2a\x76\x81\x25\x29\x73\xe7\x9f\x9e\xfa\xa0\x7e\xc8\x55\xe8\x68\xcc\xf6\x59\xa2\xb7\xda\x02\xfc\x81\x4c\xd1\xdd\xce\xb9\xc8\x12\x7d\x3d\xa5\x94\x4b\x61\x49\x49\x5f\x2d\x82\x53\x29\x34\xf1\x40\xae\x36\x4a\x6b\xe5\x61\x5b\xb6\xe1\xb9\x6c\x24\x8d\x75\x90\x71\x13\x24\x0b\x28\xf3\x61\x5f\x75\x48\xc7\xbc\xdb\x34\x7e\x86\xe6\xc6\x49\xec\x56\xb6\x26\x4f\x1f\xb4\x39\x8e\xff\xa5\xd5\x75\x8c\xb7\x9f\xf6\x78\x61\x64\x3d\x68\x41\x3f\x57\x7e\x79\x00\xb3\xb6\x57\x14\x7b\x8a\x6c\x4f\x9e\xed\x8f\x44\xed\xdc\x3d\xb3\xc6\x4c\xdb\xed\xc1\x87\x6a\x2d\x78\xea\x8d\xfb\xf9\x54\x47\x86\x2e\x32\x45\x67\x27\xf3\x56\x5f\x10\x87\xbe\xf8\x2e\x97\x22\x88\x72\xa9\x4a\x3f\x93\x5e\x53\x71\x87\x9f\x42\x47\xda\x3f\x8f\x8e\x64\x56\x58\x6f\x40\xe0\x7c\xfe\x34\x7f\x67\xdb\xfd\xb5\xa6\xf3\xc7\x2e\xe5\x45\x47\xba\xfd\xb1\x9e\x74\x7f\x2d\x27\x50\x2e\xb5\x13\xe5\x2a\xd7\xfe\xf1\x57\x41\xe1\x23\x3e\xca\x98\xed\xdf\xdf\xe4\x0f\x7e\x93\x4b\xad\x47\xb9\x4a\x9d\x7f\xfc\x4d\x40\xdc\x83\x6f\x02\x72\x97\x7f\x7f\x93\x3f\xf6\x4d\x2e\xd5\x20\xe5\x5a\x90\x7b\xfa\x26\xff\x2b\x37\xfc\xe7\xed\x7e\xfb\x1b\x1a\xfe\x52\xac\x51\xae\x44\x77\x67\x6c\x66\xce\xa1\xcc\x8c\x28\x48\xe6\x93\xb7\xb9\xba\xf6\x14\x9c\xf9\x58\xd2\x3d\xe6\xa1\x8b\x26\xb1\x36\x68\xf0\xbe\xb5\x06\x67\x8a\x47\x4c\xaf\x52\x4f\x2c\x76\xcf\xc1\xbb\x83\x8e\x28\x77\x80\x4e\xf7\x94\x50\xaa\x2e\x31\x23\x58\x29\xfa\xab\x22\x0c\x22\x2f\xd4\x51\x63\xf2\xda\x1f\xa1\xce\x87\x13\x9e\x14\x66\xef\xe7\x2a\x1a\x6a\xc0\x71\x00\x5a\xf0\xfc\x57\xed\x72\xa9\x90\x28\x57\xbe\xb1\xa4\xe5\x20\x3b\x75\xc6\x87\x98\x5d\xca\x13\x8c\xcf\x66\xf6\x14\x69\x87\x56\x24\x3f\x7a\xac\xae\xeb\xa0\x25\xec\xc7\xdd\x5b\xf1\x23\x40\x39\xde\x59\x90\x34\x8a\x0b\xec\x89\x87\xaf\x23\x25\x6e\x4a\x03\xad\xb9\x1d\xdf\xca\xca\x5b\x66\x84\x60\xca\xa3\x96\xf2\xd4\xbe\xb1\x9f\x24\x9c\x00\x3c\xd9\x8f\x39\x9f\xcc\x5b\xed\x97\x5d\x91\x88\x28\x2d\xf8\xad\xcf\x8f\xf5\xaa\xc5\x2e\xe5\x19\xe5\x42\x23\x75\xae\xc2\x84\xae\xb0\x54\xf5\x36\xb1\xc6\x64\x3b\x61\x70\xe4\x51\x0e\x15\x9f\xe4\x8f\x60\x7f\x43\xcd\xa2\xbd\x5c\x52\x7f\x4d\x28\xae\x8d\x72\x08\x31\x25\x9c\xb7\x83\x0a\xde\xe1\x04\xf6\x16\x39\xb4\x80\x08\x97\xf8\x64\x9f\xb2\x36\xe0\xa4\x26\xb4\x1f\xe4\x95\xf9\xe9\x68\xe2\xe7\xd3\xfc\xfa\xcc\xbf\xbc\x9b\xe8\xb8\xdd\x69\x64\xc1\x32\xfe\xf4\xfa\x50\x6d\x9c\x8d\xef\xb1\x5b\x01\x2c\x48\xb5\x3f\x1d\x06\x02\x0a\x1e\x2b\xd2\xe1\x7a\x6f\x25\xb1\x5a\xcb\x36\xb8\x44\xa1\xe4\xc6\x96\x2f\xfc\x1d\x75\xf2\x47\xfb\x46\x76\x81\x57\x10\x98\x72\x09\x7b\x95\x2b\xe7\xd0\x3b\x39\x15\x94\xa8\xf9\x2b\x01\xf0\x72\xfd\xac\x78\xf8\xeb\x57\xdd\xff\x70\xdd\x65\xd7\xb9\x7e\x6f\xbb\xcc\xf9\x73\x9f\xda\x71\xbf\xd5\xb3\x27\xb0\xcb\xed\x68\x98\x5f\x7b\x02\xfc\xab\xbf\xd8\x4d\xb4\xb6\xdb\x87\x9f\xd1\x5a\xff\xfd\x63\xf9\xc9\x6f\x3f\x6d\x84\xd9\xae\xfd\x15\xde\xbd\xe4\x2f\x6d\xf4\xbe\x25\x71\xfa\x98\x9f\xf7\x4e\xac\x33\x9f\xee\x4c\xd4\x1f\xf9\xe5\x66\x47\x0b\x7e\xf0\xb1\xce\xc3\xeb\x7d\xbb\x7f\x63\x81\xb9\x84\xa0\xca\x7c\x47\xd9\xab\x63\x70\x92\x8c\x53\x07\x66\x72\x06\x34\x1d\x41\xd4\xc6\x43\x72\x71\xc4\x12\x71\x46\xd8\x79\xc7\x5f\x71\xb4\x23\x8b\x88\x33\x7a\xd8\x65\xee\x60\xd9\x79\x5e\xeb\x04\x47\xf2\xfc\x9f\x8d\xa4\x8c\x84\x79\x65\x6e\x07\x54\x82\x59\x17\x87\x90\x8f\xb2\x02\x47\x52\x5d\x9a\x24\xb6\xfa\xc8\xe3\x55\x25\x7a\xbd\x3a\xc7\xff\xed\x24\x49\x92\xbc\x1c\xb9\x8c\x87\xfd\xb3\x2a\x58\x1c\x50\x19\xb8\x73\x5f\xd8\x62\x25\xca\xd2\x18\x7b\x54\xc5\xdc\x7c\xb7\x46\xb2\xe9\xe0\x39\xb5\x24\x7c\x03\xda\x0f\xef\x5b\x66\xaf\xb3\xcb\x20\x35\x4d\x64\xd1\x28\x24\x63\x43\x4d\x00\x82\x5b\xed\xfc\xa6\x48\x28\x0f\x16\x59\x95\xb1\x51\x92\x3b\xed\x62\xa1\xff\xe8\x27\xb9\xbd\x6a\xb5\xab\xeb\x7a\xa5\x21\x39\x87\x14\xaa\x84\x9a\x9f\xca\x3c\x47\x85\xd5\x06\x70\x33\x19\x51\x91\x1d\xa1\x12\x5a\x54\x54\x1a\x3e\xc4\x06\x50\xcd\x66\x8f\x30\xb5\xae\x2b\xcb\xc1\x9e\x67\x6d\xcf\x8b\xa1\x54\x21\x87\x5e\xe5\x28\xef\x44\x61\x01\x8b\x3b\x91\xfd\x67\x6a\xc8\xf6\xdc\xa3\xe4\xf9\x10\x9d\x77\xc9\x73\x35\xa3\x74\x78\xe2\x0e\x90\x61\x64\xf0\x50\x4c\x15\x78\x32\xee\xc4\x1a\x9e\xb7\x9f\x5d\x47\xa8\xa3\x3f\x72\x82\xc8\x91\x0d\xbf\x44\x9c\x13\xb3\xe0\x71\x16\x92\x71\xa4\x4a\x69\x24\x22\x1e\x61\x38\x4c\x33\x78\x20\x6b\x01\x56\xb9\x1a\x28\xd4\x93\x89\x6e\x9e\x0b\xca\x12\xd6\x0c\xc0\x85\xfd\xab\x82\xd2\x5e\xd8\x46\xf9\x21\x92\x51\xb7\xc6\xd2\x86\x04\x03\x8e\x17\x67\xd1\xe4\x44\xac\xba\x49\x90\xa2\x9b\xff\xe0\x5f\x49\x97\xd5\x03\x4f\x1a\x0f\x7b\x02\x24\x19\x90\xcf\x4b\xc1\x55\x69\x52\x98\x10\x3d\x44\x09\x96\x28\x59\x17\xa9\x65\x25\x65\x8b\x42\xc0\x67\x4b\x0c\xc8\x5a\xe7\x24\x93\x6f\xdb\xf6\x9f\xfc\xfb\x6d\x7b\x1e\x7a\x9c\x8f\x67\x28\x94\xa6\x17\x9f\xf5\xaa\x80\x53\xa0\x84\x58\x5c\x9c\x07\x7c\x84\x79\xfe\xa8\x8f\xbc\xd6\x1e\x46\x18\x93\x9a\x33\x59\x43\x67\xa2\xa8\xa2\x70\x92\xe4\x46\xa9\x87\xdc\xec\xdb\x62\x71\x0e\x2c\x93\x2c\xf6\xf3\x1e\x4b\x45\x30\x2d\xdd\xcb\x94\xb5\x17\x48\x6e\x20\x8f\xdc\xf6\x6a\x8a\x89\xd4\x09\x96\xc0\xe7\x48\x75\xc8\x9a\xa3\xb7\x36\x47\x73\x41\x48\x77\x9c\x10\x5e\x0e\xf0\x9a\x30\x2b\x80\xcb\x01\xcc\x6d\xa6\xdb\x86\xbd\x77\x1c\x8f\xc3\x1d\x0f\xc6\x0b\xbe\x1a\x5d\xd7\x10\xc4\x57\x6a\x68\xa3\x8e\xa0\xb3\x3e\xda\xcc\x9e\x73\x2e\x28\x60\x42\xfa\xfb\x88\xf7\xab\x50\xf8\x7e\xdf\xf2\xfd\x1c\x36\xb9\x69\x68\x90\xe6\x07\x55\x47\x6b\x81\x07\x91\xc8\xcb\x2e\xf2\x88\x6d\xda\xe7\x6b\x36\xf9\x1d\x7f\xdd\xf6\x23\x6d\x06\xeb\xdd\xaf\x01\x48\x9a\x17\xa2\x90\x71\x51\x5c\x47\x80\x05\xbb\xb3\x70\x2f\x69\x58\x31\x28\xba\xd7\x43\x90\x88\x8f\x92\x6c\xa4\xdf\xf3\x90\x38\x0e\x71\xf0\x0c\xae\xac\xb3\xdc\x36\x5e\x98\xd7\x45\x0d\xcd\xf0\x8d\xc8\xad\xf3\x7d\x8f\xe7\xb1\x69\xa2\xa1\x4a\x1b\x60\x00\x1b\x4b\x00\x08\x34\x79\xd2\xca\x68\x62\x78\x9b\xcc\xa2\x59\xb6\xa8\xa0\xca\x2a\xb6\xb6\x26\xa4\xe5\x9b\xa7\x5b\x90\xfb\xb6\x03\x50\xcc\x9a\xd3\x16\x9d\xc4\x28\x33\xa3\xd9\x25\x80\xad\x4b\x3a\x0a\x5c\x50\x16\x26\x7b\x6a\x65\xd4\x7b\x06\xf0\x1c\xb9\x35\x24\x43\x2b\x50\xcf\x28\x87\x97\xbc\xd3\x7f\x69\x42\x61\x2b\x9e\xb3\xb4\xb7\xdb\x9f\xee\xb0\xff\x58\x7f\xbd\x86\x67\xae\x8c\x34\x27\xc4\xb5\x59\xe2\xd1\xcc\x91\x44\x5f\xda\xf1\xad\x27\x78\x2b\xd1\xad\x09\x0c\x17\x4f\xe8\x6a\x3c\xb0\xab\x3b\x8c\x36\x39\xf9\x65\x0e\x4f\x80\xec\x13\x1f\x8b\xdd\x4f\x8c\xea\x0e\x51\x55\xc7\x31\x02\x0f\xa0\xcf\xab\x7c\x12\x53\xc0\x53\x7c\x18\x53\xf0\x13\xaf\x41\x05\xfb\xfb\x47\x41\x85\xdb\x21\x4a\xd9\x1b\x02\x0c\x6e\xcd\x21\x42\xf0\xf7\x35\x43\x3b\x5c\x9b\x96\xfe\xd4\xab\xbc\xea\x12\xd7\xe8\xd0\x25\x8d\x79\x36\x10\x6c\x41\xb5\x7b\x2d\x74\x97\x7b\x2a\xf7\x6e\x96\x1f\x94\xf7\x3e\xf8\xbb\x68\x9b\x94\xe4\x72\x08\xc7\xce\x2f\xc4\xfc\x2b\x8b\x8e\x0a\xe6\x2d\xd1\x29\xf7\x96\x7e\x8f\xe5\xbd\x7c\x8f\xf7\xb7\x25\xb3\xc5\xa7\x30\x9c\x51\x78\x7b\x67\x2d\x22\x97\xad\x60\x15\x9a\x1f\xd3\x19\xde\x2e\x7c\x86\x53\x56\x30\x1c\x87\x9e\xc2\xdc\x35\x06\x31\xd3\x82\x67\x17\x5b\xdd\xc6\xb2\xfe\xa8\x38\xfa\xfb\x2f\x55\xa6\x38\x69\xae\x68\x2b\xae\xb4\xd8\x76\x19\x38\xcc\x63\xb5\x1d\x04\x32\xd5\xeb\xe7\x0f\x99\x38\xa6\xef\x5d\xc6\x8e\x34\x15\x6d\x3f\x8f\x9b\xcf\x23\x7c\x65\xf7\x70\x5e\xcf\x9e\x91\x8c\x98\x48\x85\xc9\xce\x29\x10\x5e\x21\x4f\x87\x93\xad\xa0\xf7\xee\x94\x5a\x2c\xee\xe1\x94\x8c\x1c\x3c\x0f\xc2\xd9\x20\x89\x71\xe2\x29\x2c\x5a\x21\xd7\x30\x64\x63\xb1\x10\x72\x8b\x3d\xc8\x64\x96\x51\x41\x0a\x55\x5b\x90\x94\x56\x41\xb1\x0c\x8a\x60\x00\x8e\xcb\x79\x2d\x54\x92\x86\x15\xb4\x91\x1b\x64\x14\x5c\x21\xf2\x12\x13\x65\xb8\xa8\xca\xc6\x5c\xef\x54\xad\x5f\xbf\xdd\xe7\x2f\x77\xfb\x17\x7f\xbb\x17\x23\xfb\x12\x7e\xac\xe9\x9d\x86\x23\x82\x6a\x30\xf4\xc1\xaa\xe2\xf9\x6c\x42\x2b\x88\x4a\xc8\xf6\xc7\x55\x9a\x6b\x26\x9e\xff\xba\x9d\x4f\xf8\x3d\xf5\x0b\x2f\x83\xf8\x0e\x0f\x30\xb2\xb1\x4e\xb0\x13\xf8\x6c\x7c\x08\x3e\x99\xcd\x93\x04\xfe\x9e\xfe\xba\xc5\xd3\xe1\xbf\x72\x0e\xdf\x3e\x27\xc6\xb4\xa7\xfa\x1d\x09\x8f\xb7\x9f\xa3\x97\xd0\x53\x5a\x3b\xca\xf7\xa4\x4c\x9f\x09\x14\x7d\x06\x08\x17\xe0\x36\x54\xd2\x06\x2e\xac\x7c\x3f\x9c\x46\x73\x7c\x49\xe8\x95\x37\x07\x7e\x48\xf2\x53\x23\xcf\x85\xda\xec\x54\xd2\xec\xc4\x4e\xc8\x83\xbb\x52\x64\x79\xe3\xdb\x9e\xb6\x9f\x87\xac\x00\x0f\xb1\xdc\xd5\x2f\x63\xdd\xf9\x7c\xfd\xf8\xbc\xaf\x73\x8b\xe5\xbb\x3f\x1e\xdc\x72\x3e\xb2\x1f\x86\xa3\xce\x6f\x16\xf7\xf7\x45\xf4\xb8\x13\xb5\xe1\x53\x90\x1c\x96\xfb\x73\xeb\xd8\xfd\xaa\xdb\x5e\xa2\xc3\x55\xfe\xdd\x6d\xff\x64\xb7\xa5\xa2\x4e\x49\xe3\xd9\x1b\x5b\x03\x15\x1c\xd8\x75\x52\x5b\x67\x68\x12\xb0\x6c\xfb\xd1\xae\xd6\x0b\x2c\x70\x2e\x41\x39\x09\x22\xdd\xa3\x20\xc1\x22\xa7\x41\xd5\x0d\xa1\x74\x73\xaa\xef\x66\x62\x7b\x61\xa5\x78\x84\x9d\xdc\x59\xae\xa5\x88\xa3\x99\x31\xc2\x35\x80\xfe\x2b\x34\x07\xf5\x55\x44\xbc\x5e\x22\xe2\x55\xff\xdd\x4b\xfe\xe6\x5e\xa2\xa9\x85\x41\xb6\xd0\xfb\xa8\x65\x1d\x15\xd4\x50\x03\xe4\x9e\x76\x86\x66\x20\xe0\x23\xca\x6b\xf1\xd1\xe9\x07\x79\x81\x21\x3c\xa5\xa2\x47\xdf\x40\x05\x0e\xa2\x28\xd3\xf9\x63\x7d\x62\x21\xd8\xbc\xa0\xf1\xe5\xa5\x53\x73\x89\xa1\xd7\xfc\xef\xae\xf0\xff\x9f\x75\x4e\x72\x47\xf9\x7b\xa4\x26\xf8\x6c\xb7\x7b\x87\x10\x89\xd9\x5e\x85\x52\xef\x2c\xf2\xfe\xb3\xeb\xd4\x25\xf8\x5e\x9f\x7a\x79\x35\x95\x10\x3f\xa4\x22\x76\xd9\xf3\x6f\xf7\x16\x9f\x78\x7f\xfd\x82\x6f\x3f\x6d\x2e\x4e\x6b\x0e\xb5\xa2\x90\x31\xf5\x2d\xa7\x30\xeb\x56\xc0\xba\x0c\xa5\xed\xde\x36\x10\x23\xa1\xbe\xb5\xb5\xd0\xd2\x06\x1d\xba\xea\xa4\x90\x05\xc0\xe0\x0a\xfc\x6e\x01\x82\x2f\xe2\xb7\x2d\x3e\x77\xc7\xfd\x8c\xc8\x0b\xc4\xe7\x15\xe3\x7e\x93\x88\x7b\xa2\x42\xd7\x9e\x20\xf2\x79\xee\xa2\x1d\xd1\x3e\x22\x95\x28\xc5\x45\x76\x88\xe9\xbc\x96\xa3\xfb\x45\xa2\x5d\x85\x84\x4e\xbc\xb4\xb9\xf8\x08\x5d\xe2\x43\xf3\xf6\x18\x86\x44\x4f\x13\x06\x58\x28\x0c\xc2\xdf\xb6\xd3\x01\xc7\x59\x7e\x99\xd3\x95\x8f\xdb\xf9\xfd\xfd\x71\xfc\xf1\xcc\xcd\xef\x36\xf9\xd9\x07\x64\xd5\xeb\x77\xbf\xe0\xed\xb7\x3f\xe1\xd7\xfd\xab\x5d\xf2\x1d\xb5\xee\xfd\x0b\x54\x23\x52\x09\xbd\x4d\xe1\x54\x77\xb1\xc5\x73\x99\x06\x33\x4c\xfa\x98\x79\x4d\x90\x4a\xcf\x1a\x86\x78\xf4\x38\x63\xf4\x14\x04\x19\x80\x7a\xcc\x1b\x60\xf1\x7d\x3e\x62\xd1\xb9\x00\x0c\x9b\x1e\xd2\xf5\x37\x4f\x76\x72\xf1\xd2\x31\xf0\x87\x2e\x99\x82\x41\x6d\xcd\x13\xb8\x03\x82\x4f\xf4\xc3\xb2\xc9\x56\xd2\xa5\x6c\xf2\xa1\x00\xa1\x17\xe0\x97\x7b\x07\xf9\x4c\xc9\x28\x7e\xc8\x8d\x7f\x7b\x68\x69\xbf\xf9\x98\x59\xd1\x36\x82\x32\xff\xc2\x3c\x44\x27\x85\x62\x09\x85\xb8\x20\x60\xdb\x34\x07\xfd\xec\x22\x7b\x0b\x0b\xd8\xa5\x80\x5f\xb2\x49\x6e\x30\x44\x8f\x40\x24\x1e\xa1\x02\xa3\x92\x83\x38\x4f\x8c\x8e\xb4\x0e\x44\xb9\x6d\xf2\xab\x69\xad\x3d\x64\x90\x21\x87\x5c\x56\x10\x85\x51\xaf\xa7\xdf\xb6\x01\xec\xfe\xaa\x3d\xf4\x50\x67\xe8\xab\x80\xff\x54\x7a\xf2\x28\x4a\x67\xf4\x12\x2a\xce\x85\xf4\x4e\xbc\x5b\x94\x34\x16\x8a\x06\x59\x7b\x45\x54\xe8\x03\x5c\xd4\x11\xfe\x35\xcb\x6e\x27\x9e\xd9\x29\x69\x90\xe1\x5e\x23\x1e\x2e\x4a\x1e\x81\xe2\xe9\x58\xd2\x15\xc4\x19\x69\x04\x75\xcc\x4c\x07\x4f\x50\x90\x5e\x9d\x8b\x7d\xce\x40\xa9\x4b\xd7\x2a\xb3\x69\xbe\x83\xd3\x5d\xf6\x2a\xed\xb5\x85\x59\x43\xaf\x04\xb4\x3b\x77\x5b\xab\x1e\xcd\x44\x0a\xe7\xb6\x76\x0d\x6d\x9a\x13\x1d\xda\xab\x72\x92\x76\x49\x71\xd5\xaf\xe4\xeb\x86\x9b\x35\x9f\x7d\xd1\x86\x3a\x00\x7d\x54\x8c\x5a\xd4\x85\xe4\xd0\x27\x30\xab\x76\xdc\xaf\xc7\x57\x1d\x28\x15\x58\x20\x77\xa2\x89\xf0\x19\x12\x95\x2a\x10\xf8\x5f\x8d\x51\x0c\x94\x8c\x92\xe3\xde\x17\x84\xce\xaa\xe8\x9a\x07\x11\x5d\x49\xed\xe7\xbd\x8d\xb1\x66\xfb\x20\x4d\x82\xea\x96\x4b\xa8\x6d\xe9\x64\xe8\xac\x21\x6b\xa8\xa1\xce\x47\x99\x5f\x3d\xf1\xed\x34\x40\xbb\xfe\xee\x2b\xe2\xf8\x06\xee\xb0\x5f\x8f\x7f\x63\x93\xda\x64\x09\xe6\x63\xe7\x0a\x42\x04\x8c\x52\xc4\x50\x66\xb2\x91\x8c\xba\xa1\x75\xa2\x77\x37\xd2\x31\xa4\x63\xba\xc6\x5f\x1e\xc0\x73\xa7\x1a\x5a\x20\x80\x2c\xb6\xb2\x75\xc7\x39\xd4\x47\xe4\x3b\x22\x8c\x38\x42\x1c\x79\x61\x5e\x35\x31\x0a\x88\x27\xef\xa7\x18\x8f\xd3\xb4\xea\xed\x1e\x1b\xa2\xc3\x89\x21\xd5\x82\x2a\xf6\xc3\x87\xe9\x90\x87\xb7\xd6\xb7\xc6\xb7\x96\x6f\xfe\x01\x08\x15\x4e\x2d\x38\xb3\x18\xf9\xc2\xd6\xce\x17\xb5\xd9\xa6\x3c\x4a\xfe\xb2\xe7\xab\x7d\x7e\xb3\x72\xcb\x9a\xc5\xbe\x20\x1a\x85\x2c\x15\x68\x2a\x6b\xa9\x57\x7d\xfc\x92\x68\xaa\x57\x1d\xb9\x53\xe0\x3e\x81\x40\x19\x91\xe4\xde\x57\xe0\x1a\x5d\xc9\x4e\x8a\x90\x1b\x81\xd4\x7d\x92\xf4\x51\xc1\x8a\x80\x85\x70\x00\xce\x7a\x10\x03\x89\xe7\x72\xac\x43\x23\xa3\x42\xb9\x97\xc4\xc0\xb4\x73\xac\x79\xcb\xbc\x6b\xa0\xbb\x90\x98\x07\x4c\x0c\x1d\x18\xb8\x28\x40\x18\x81\x68\x8a\x21\x57\xd8\xf9\x1f\x36\x2f\x46\x26\xa9\x03\x96\x86\x04\x7a\x9e\xf7\x92\x64\xe5\xad\x77\xf2\x36\x27\x73\x7b\xc4\xd6\x06\x8a\xf0\xc7\x00\xb3\x5d\x14\x57\x9e\x2b\x3e\xee\x96\x98\x6d\xcd\x19\x75\x85\xec\x09\xc9\xe4\x9b\xb3\x00\x82\x76\xdf\x7a\x12\xf0\x71\x40\xe7\x35\xeb\xf8\x05\x18\x74\x46\xad\x07\x01\xe1\x1b\x52\xde\x6d\x1f\xb7\x2d\x70\x84\x6c\x1c\x30\xbe\x6e\xd9\x8a\xb4\x40\x3e\x0d\xa8\x4f\x0a\xeb\xa0\x2f\xd7\xe4\x58\xef\x99\x1e\xb5\x3a\xc5\x97\x72\x7d\xfd\x65\x50\x1d\x70\x03\xd8\x25\x4b\xd4\x99\x1c\x23\x4b\x65\x29\x32\x14\x0a\x8d\x2e\x8e\x8e\x2d\xd2\xa8\x76\xd3\xd6\x5e\x6f\x02\x18\xbb\xb3\x53\xd4\x14\x88\x34\x1f\xba\x91\xdc\x3d\x83\x3a\x10\xdf\x77\x2e\xb9\xaa\x4d\xc8\x2b\x4b\x0f\xcb\x60\x26\x17\xd4\x09\x07\xfc\xd9\x1a\x6b\x89\x0d\x44\xc9\x03\xd8\xef\x81\x67\x1c\xdf\x98\xe5\x76\x02\xd2\x9e\xb7\x4a\x98\x6e\x5f\xaa\x82\x61\x20\x99\xff\xe1\x0b\xcf\x57\xd7\x39\xd5\xa0\xde\xb6\xe7\x21\xf7\x9a\xeb\xa2\xd9\x7a\x73\x7b\x08\x66\x88\x96\xf9\x21\xda\x02\x0d\xda\xa4\xf7\xd8\xe6\x1b\x07\x46\x5a\x81\x64\x82\xca\xc8\x5c\xac\x67\x8c\x6a\xb6\xa4\x48\xe8\xc9\x45\x08\x3a\x32\x94\x8f\xd6\x06\x21\x39\xf1\x89\xc9\x89\x07\x28\xe7\x6e\x6b\xe1\xce\x9e\xa9\x66\xeb\xf2\x2b\xe2\xe7\xd0\x07\x6c\x9e\x53\x47\xe9\xec\x28\x62\x3f\x32\x28\x4f\x86\x3c\x34\x8d\x7b\xb6\x63\xe9\xa4\xda\x5a\x0e\x32\x77\x29\xb6\x22\xc6\x11\xc6\x13\x44\x48\xb2\x6c\x1b\x42\xe8\xee\xc5\xfb\x72\x1f\x28\x24\x88\x35\x2f\x11\xb6\x96\x14\xb9\xbf\xa4\x76\x6c\x97\x64\x60\xfd\x52\xef\x4e\x30\x1f\xe6\x46\x72\x78\xc0\x01\x75\x6c\x36\x4a\x7b\x5f\x6a\x57\x7b\x0e\x81\x5a\x23\xd2\xca\xa4\xc4\xa9\x66\x68\xd5\xfa\xb9\xb1\x91\x47\x59\xe3\xe0\xb4\x4c\xce\x3c\x27\xcb\x7b\x48\xef\x0b\xc1\x61\x25\xdf\x63\x2d\xed\x93\xe3\xc8\xfe\x28\x33\x80\xc8\x85\x0a\x00\xf8\x17\x7f\xb8\x17\x4d\x4b\x51\x12\x1e\xb6\x01\xaa\x00\x5e\xa5\xdb\x21\x0d\x3d\x0c\xa3\x41\xc8\x48\xd1\x6a\x00\xdb\xac\x4d\x48\xfa\xc8\x40\xf7\x0c\x48\x29\xec\xf4\x7c\xb5\xdd\x67\x9d\x7b\x95\x61\x2b\x0f\xbe\x20\x50\x90\xd3\xdc\xa8\xb2\xc4\xda\x73\xe8\x20\x14\x9d\x44\x43\xa7\x1c\xaa\xde\xe3\xac\xf3\x63\x24\x11\x00\x66\x4a\xfe\x98\x72\x70\xf4\x92\x58\x9b\xde\x0e\xd9\x7d\xc0\x54\x51\x13\x73\x38\x32\xef\xc4\xda\xe8\x3d\x0e\x4c\x0e\x9f\x5c\xb9\x14\x90\xaf\x8d\x95\xe4\x62\x05\xf4\xea\xdb\x80\x20\xa4\x99\xdc\xf7\x29\x1f\x15\x17\xb1\x44\x80\x54\x2b\x69\x31\xbb\xd8\x99\x8c\x77\x01\xd0\xc3\x23\xc3\x87\x1d\x48\xa1\x99\x37\xf9\x4c\x5d\x9e\x89\xf0\xec\x41\x3f\x34\xfa\x6b\x13\xc2\xf8\xec\xa2\x7d\xc9\x00\xdf\x93\x7e\x3e\x82\x03\x85\x9e\xff\x26\x84\xb4\x82\xa5\xb7\x7f\x78\x25\xeb\x4e\xbf\x89\xba\x6a\x97\x0c\x68\x9d\x5f\x8c\x83\x52\x29\x46\x8b\x00\x3b\x7a\x63\x7f\xfa\xca\x08\x88\x40\x4a\x08\xa2\x7c\x05\x05\x08\xd4\xca\x35\xe3\x1f\x43\xbc\xa0\x41\x5b\x5f\x08\x20\xb6\xf5\xb9\x03\x4d\xdf\x43\xed\x0e\x8b\x53\xf0\xa8\xdb\x0c\xd5\xc7\x2a\x3d\x8c\x4a\x6e\x2b\xc9\x73\x43\xd0\x24\xd4\xb2\x8e\x0c\xff\x61\x38\x82\x97\x9a\x31\x76\xef\x01\x7a\x87\xb1\x58\xa7\x2b\x3a\x6c\x8e\x1f\x12\x20\x35\xc8\x78\xcb\x00\x3a\x76\x1d\x93\xd3\xe0\x0f\xa7\xe3\xdf\x68\x71\x21\xcf\xb5\x22\xdb\x64\xbb\x6d\x60\xcf\x1b\x28\xe6\xa5\xf1\xfb\x21\x55\x15\xeb\x5c\x28\x0f\x03\xe5\x9d\x14\xba\x6b\x70\x60\xa6\x62\xe5\x07\x73\x55\x9a\xb7\x22\x41\xad\x2f\x17\xf2\xa7\x6e\x05\x10\x5d\x33\x0b\x13\x04\x22\x06\x28\xc3\xb8\xa2\x77\x48\xe6\x41\xfc\xd4\x41\xd3\x63\xf3\x22\x95\x69\x43\x2b\xf5\x10\xf3\x48\x4e\x48\x8d\x32\x31\x3c\x84\x4d\xf1\xe0\x20\x31\xdf\x9d\x05\xe3\x83\xd5\x75\x0c\x27\xba\x60\x64\x6c\x6a\x4b\xbc\xf9\x41\x03\x15\xd2\xf6\x25\x4a\x0d\x2d\xa9\x33\x56\xf1\xb8\xa6\xce\x1a\xa7\xe5\x86\xfa\x2b\x9f\xc3\x60\x19\xdb\xcc\x9c\x7c\x78\x20\x0a\xb1\x20\x65\x52\x4b\x37\x23\x69\x89\x73\x06\x3c\xc1\x04\xd5\x4e\x49\x0e\x41\x6e\x33\x90\x35\xa5\xf4\x77\x97\x83\x19\xe1\x51\x05\xbb\x9c\x2d\x5b\x28\x72\x00\x73\x92\x8e\x60\xd6\x4b\xdb\x60\x49\xd8\x77\xc5\x7a\x2a\x2b\xbd\xdd\x5c\x5c\x26\x0b\x3d\x33\xfd\xa8\xf7\x36\xcb\x5a\x6c\x8d\xeb\x2d\x68\x5b\xac\xc5\x72\x9f\x6b\x6d\xa1\x20\xe9\x28\xe2\x25\x25\x5c\xd6\x68\xf1\x01\xea\xcd\x12\xb8\x82\x35\x18\x09\xa4\x76\x33\x8f\x0f\x64\x68\xe9\xa1\x6a\x1d\xb4\x98\xc7\x21\xd9\x2b\x13\x75\xcb\xd3\x7a\xeb\x0a\xb2\x9f\x12\xd4\xde\x03\x9c\x33\xe0\x34\x86\x39\x53\x30\x0f\x26\x86\x60\x2e\x9f\x82\x00\x7c\x45\xc3\x49\xb5\xa6\x2a\x3b\xc1\x05\x1d\x94\x41\xd8\x7b\x18\xea\x43\x2c\xbf\x4a\x0f\xb4\x6b\xee\xf3\x2b\x9e\xcc\x56\x76\x9f\xf0\xeb\x78\x0a\x30\x4a\xd9\xe6\x77\x5b\x0c\x41\x62\x5a\x04\x15\x71\x92\x3a\x78\x3d\x9c\x13\x6f\x3a\xa7\x38\x88\xa3\xbf\xe7\xe3\x75\x19\x2b\xb8\x52\x99\x71\xce\x7b\x65\x88\xad\xf9\xcb\xd4\x90\x1b\xe6\xc3\xd9\x82\x16\x28\x75\xa8\x74\x06\x45\xac\x7f\x74\x01\xa8\x3d\xa7\x5f\x25\x02\xe8\xb8\xc9\x27\xb1\x91\xdb\xa7\x5e\x70\x61\xe0\x28\x79\x09\x5f\xee\x2e\x7c\x32\x05\x0f\xf8\xaa\xa5\xa6\x3b\xd1\xfd\xb3\x0b\xbc\xb1\xd1\x11\x62\x4b\x9d\x46\x3d\xac\x43\xc4\xef\x5c\x86\xac\x20\xa4\xa1\xc9\x1a\x46\xad\xd7\xa9\x3b\x8f\xe6\xde\xb4\xb9\x96\x1e\x54\xcc\xf3\x52\x33\x3c\x30\x1d\x5a\xeb\x8e\xee\xc1\x92\x16\xfa\x3a\x11\x65\xb1\xa1\xd1\x3c\xdc\x19\xa5\xc9\x8f\x7a\x7b\x44\xb6\x60\x74\x53\xc6\xfc\x23\xd7\x45\xb4\xb6\x86\x05\xcd\x59\xe2\xc9\x7b\x20\x6e\x4e\xdf\xa3\x7d\xae\xbf\xec\x4e\xf2\x10\x7a\xb8\x1b\xd9\x51\xcc\xc7\x5d\x3b\x2c\x2b\x24\xd9\xea\xa3\x96\xfe\x91\x73\x74\x04\x90\x88\x74\x72\xa8\x2d\x60\xec\x70\x65\x3e\xde\x83\x64\xce\x73\xcf\xed\xd8\xf5\x62\x1c\x5d\x93\xb1\x07\x99\xa9\xe8\x18\x61\x8c\xb9\xa2\x15\x84\x73\xc4\x8a\xbc\x4f\xcb\xcc\xff\xb8\x78\x14\xc5\x94\xca\xe1\x78\x2d\x11\x59\xa4\x3c\xc9\xa5\x3e\xda\xde\x8f\xa4\xa4\x8d\xce\x9b\x4d\xa5\x77\xf3\xeb\x3e\x71\x37\x1f\x25\xc9\x62\x6e\x61\x68\x3a\x80\x91\xa2\xba\x4d\x00\x69\xfb\xd5\xa3\x24\xef\xa4\x13\x46\xa2\x98\xc2\xa9\xe8\xe6\x8f\xba\x00\xde\x54\x50\xb1\xfb\xc1\xb9\xdb\x2f\xee\xa6\x75\x9c\x26\xd6\xc3\xcc\x27\x0e\x75\x05\x9f\x83\x68\x3f\xd2\x13\x1e\xf5\x18\x14\xbf\xee\x10\xda\x00\x5d\x52\xa2\xf3\x68\x97\x71\xd6\xb5\x58\xc6\x62\x0e\xb2\xf9\x9c\x4b\xa4\xce\x77\xbd\xd7\xba\xd6\xb4\xd7\xf6\x09\x35\x6a\xe0\x42\x2e\xd0\xfc\xcd\xc3\x96\x5b\xd2\xee\x96\x8f\x43\x32\xa2\x33\x87\x6e\xde\x3a\xf9\x97\x59\xe1\x6b\xb3\x02\x68\x8e\xf6\xca\x20\x17\x4f\xf2\xac\x88\x6f\xd9\x7a\x08\xc2\x1c\x68\x45\x7b\x71\x3b\x50\x64\x44\xf7\x5f\xfc\x5e\xbc\x19\x5e\x4c\x06\x57\x78\x33\x3e\x5a\x0a\xb9\xea\x3a\x6d\x59\xb0\x65\xd5\x26\x82\x74\x9e\x82\x34\x90\x80\x93\xba\x2a\xea\xa2\x84\xf4\x28\x17\x2d\xc8\x46\x98\x67\x38\x17\x14\xcf\x88\x98\x93\x46\xaf\x2e\x94\x76\x97\x69\x2b\x61\x0b\x9a\xf3\xa3\xa2\x84\xf3\x33\x3f\x6d\xfb\x74\x9a\x02\x4e\xa3\x95\x05\x05\xda\x55\x99\x42\xc3\x8a\xdd\x83\x53\xb0\x66\xb8\xad\xb7\xaf\x27\x3c\xb3\x3a\xf6\x34\x79\xb1\x09\x87\x95\xaf\x9d\x7a\x75\x3d\x2d\xa3\x06\xeb\xef\x32\x03\xa4\x01\xcc\xea\x7a\x4c\x59\xc0\xbc\x65\x3e\x1b\x61\x7e\x58\x12\x6c\x6a\xb3\x75\x13\x61\x8f\xe3\xb6\xd9\x97\x02\xe7\xb3\x19\x5c\xa7\xcb\xe1\x2c\xda\xc6\xdd\x9c\xc8\x07\x14\xda\x06\x63\x28\x43\x42\xce\x66\x82\x59\xd7\xc8\xc2\x1e\xd2\x43\xce\x77\xf8\xa6\xc0\x05\x12\xa3\x01\x9a\x79\xa5\x7b\x86\x22\xf9\xdb\x21\x7e\x70\x78\xdf\x27\x8f\xbb\xb5\x57\xe0\x94\x76\xcd\xd0\x5f\x95\x29\x67\xcf\x47\x6d\x74\xf7\x22\x4f\x9f\x94\x9f\x5a\x2a\x87\x92\x8a\x3d\xf4\x78\xc4\x21\xfa\x4e\xbf\x82\x55\x98\xbb\xd2\x4a\xae\xef\x55\x54\x5c\x43\x25\x3f\x06\x50\x5a\xb3\x7f\xb8\x5b\x1f\xbc\xef\xbb\x2c\x4d\x9f\xf9\x53\xe5\x94\xb7\x9f\x32\x66\x0d\x73\xd6\xa5\x43\x54\x44\x56\x8f\xb9\xdb\x77\xdb\xc9\xaa\x1c\x64\x2a\x69\xd7\x13\x27\xae\x52\xc2\x70\xd4\x01\xac\x62\x28\xe4\xd6\x31\x16\xaa\xc8\x15\x25\xc2\x42\xa6\x17\xf0\x4c\x30\x3f\x83\x9c\x91\x8e\x97\x98\xe5\x3d\x46\x28\x66\xbb\xc2\x9f\xc0\x50\x0d\x64\x39\x4b\xb4\x02\xc9\x5a\x36\x7e\x6d\x14\x90\x80\x3e\xe5\x9e\xcb\xd2\x47\xe0\xd3\x23\xbe\x43\x33\x9d\x4f\x78\x97\xe2\x01\x22\x3e\xc6\xa2\x8a\xea\x65\x92\x3e\x69\x09\xf8\x15\x44\x56\xd4\x9d\x61\xc9\x1b\x4a\xb4\x7f\xd4\x45\x55\x82\x1d\x0c\x35\x5b\x3c\xf5\x5d\x8a\xdc\x9e\x22\x1d\x83\xd2\xab\x78\xda\x57\xbd\xe9\x9a\xe4\xff\xb2\x72\x39\x15\x0d\x23\xdb\x7c\x3e\x48\xd6\x25\x40\x95\x64\xd2\x3e\x82\x63\xd1\x1a\x35\x3f\xa2\x0e\xb9\x9b\x5f\xc3\xda\xd9\xa4\x21\xf7\x0d\x59\x25\x4c\xde\xb3\x84\x5a\xc6\xa2\x80\x87\x38\x49\x70\x07\x36\x25\xcb\x3b\xf6\x6b\x01\xe5\xb6\x1e\x1f\x69\x04\xb1\x79\x74\x96\x90\x9b\x7d\x81\x0a\xad\x9d\xf4\x69\x19\xeb\x87\x8a\xf9\xe9\xd7\x1e\xa9\xb3\x40\x75\x3e\x05\xb0\x7d\x29\x6a\x30\xc0\xab\x49\x8d\xbe\x79\xdb\xc0\x6f\x42\xdf\x04\xaa\x11\xd4\xaf\x75\x75\x38\xa7\x55\x4d\x66\xc1\xb5\x5d\xa9\x59\x76\x96\x9f\x0c\x4d\xb9\xea\x2f\xd0\x42\x64\xea\x47\x19\x76\x92\xda\x37\xa7\x7a\xe2\x44\x44\x96\x16\x1d\x6d\x7b\x6e\x9d\xf6\x9f\x4e\x7b\x5e\xcc\xb6\xb8\x81\xbd\xb6\xd3\x4e\xe1\x19\xb8\x0c\x18\x80\x9e\x5b\xcf\xbd\xf1\x79\x4a\xdc\x2f\xe3\xd5\xe1\xad\x24\xc6\x2a\x6c\x26\x3b\x78\x88\xfe\x46\xf6\xa1\xed\x25\x0d\xd2\xab\xfe\x7c\xad\x1e\xf8\x8a\x3d\xaa\xa5\x1a\x72\xca\xbb\x1a\x5c\xed\x41\x12\xaa\x0b\x64\x84\x1c\x6c\xee\x2e\xe6\x1e\xad\xb1\x91\x56\x90\x81\x77\x69\x48\x5f\x62\x81\x58\xe2\x41\x48\x69\x3d\x85\x64\x6e\xc9\x89\x87\xa2\x9c\xaa\x85\xc9\x15\xe8\xae\x37\x5c\x82\x7d\xf2\xf3\x05\x8f\xd5\x85\x34\xca\x94\x51\xed\x32\xcd\x00\x5a\xe1\x70\x02\xa9\x44\xa5\x45\x45\xb5\xec\x9a\xcd\xbe\xef\x3b\x35\x72\x65\xed\x86\x59\x08\x44\x1a\x91\xc1\x1a\x6b\x4f\x5a\xf1\xcc\xf6\xfc\x65\xa9\x39\xf4\x81\xe9\x02\x40\xee\x60\xf6\x62\x06\x15\xa2\xcd\x55\xa8\x24\x60\xac\xbb\xb0\xb7\x6c\xe4\x5f\xe7\x82\x60\x9f\x0b\x35\xe7\x04\x73\xa1\xfa\x0c\xa5\x23\xc8\x30\x1e\x84\xcd\xa5\x81\xc3\x95\x25\x4a\x6a\x6e\xeb\xac\xb4\x49\xf2\xe7\x2d\x5e\xce\x2d\x3e\x50\x4e\xae\xf5\xef\x68\xf1\xdb\x7f\x4a\x93\xff\xa3\x2d\xde\xd9\xe2\x75\x4f\xfd\x6d\xcc\x2b\x7d\xa3\xd5\xf7\x59\xe8\xf6\x5f\x6e\x1a\xfa\xcb\x2c\x69\x1f\x4d\x53\xb7\x3f\xc7\x92\xf6\xd5\x2c\xf4\xdf\xf5\x5a\x63\xd2\xae\x84\x53\x27\x25\xb3\xdc\x42\xcf\x8d\x21\x0c\x84\x41\x9e\x5b\xad\x6b\x68\x5d\x97\xfd\x27\x58\xfa\xa4\x8d\x05\x2a\xba\xb3\x2d\xb1\x6b\xe8\xba\xc4\x62\x76\x72\x19\x69\x39\x36\x64\x9a\x49\x9c\x97\xa8\x63\x06\x1d\xfd\xed\xa7\x64\x21\xf3\x3f\x2e\x67\xd7\xe6\x0d\xb8\x65\x97\xb6\x2b\xcf\x16\x66\x5b\x90\x78\x50\x5c\xcd\x2e\x16\x8f\x0d\xbb\xac\xfd\xb3\x28\x38\x91\x47\x7f\x3e\x8a\xe3\xc3\x5f\xb5\xce\xa5\xb0\xa0\x5d\xc5\x88\x9f\x73\x74\x87\x55\xa1\x8b\x76\x90\xe9\x2e\x51\xfb\x0c\xda\xe7\x82\xb4\xe4\x18\x0b\x54\x9c\xc4\xac\xfe\xfd\x39\xf6\x23\xf6\x9f\x40\xc7\xa4\x65\xf4\x60\x4f\x2b\xda\xcd\x67\xb7\x99\xc6\xe6\x90\x5a\xe0\x4d\x56\x5b\xfa\x17\xfb\x53\xa9\x85\xfb\xb0\xa1\xa0\x48\xef\x82\x8b\xd9\x95\x17\xb8\xe7\x14\x76\xb2\xbb\xb2\xb9\x8e\xbd\xf1\xb9\x55\x52\x28\x69\x01\xe1\xec\x18\xcf\x25\xf5\x3b\x2b\xea\x9f\xeb\xaa\xff\xf0\x92\xda\x2f\x39\xf2\xf6\x15\x1f\x54\x03\xd2\x19\x41\x57\xe8\x32\x93\xd8\x8f\xec\x90\x4f\x19\xdb\x3d\x6e\xd9\x8e\x08\x0f\x0e\x6c\x6d\xcf\x8b\xf3\xd7\x7a\xe8\x2c\x83\x52\xd7\xd6\x9c\xe7\x45\x36\xbf\x36\x17\x96\x91\x6a\xa8\x6c\xdc\xcb\x7d\xdb\x71\xca\x87\x77\xdc\x7c\x6b\xbf\xd5\xb6\x9f\xb0\xdf\x01\x02\x5d\xd5\x5f\xab\x4f\xc2\x7d\x0e\xe5\xa9\x1f\x35\xd4\x7e\xdb\x37\xe3\x09\x38\xc4\x3f\x6d\xe7\xed\xf3\x41\x7e\xee\x71\x08\x7e\x7f\xfb\x29\x53\x86\xbf\x0a\x73\x7b\xfb\xae\xe3\x6e\x70\x52\xfb\xdc\x93\x76\xfb\x2d\xfb\x5f\xbc\xe1\xa8\x69\xff\x64\xa4\x04\xe7\xfa\x36\x99\xec\x9f\x38\x7f\x50\x5f\x66\x27\x1f\xef\x1e\x36\x66\x86\x6f\xf6\xdb\x36\x6c\x34\xe0\x26\xb3\x33\x12\x71\x3a\x73\xdb\x2f\x49\xac\x71\x4a\x65\xff\x56\x22\xf5\x79\x43\xbe\x23\x95\x9a\xf7\x1b\x56\xde\xd0\x2e\xe5\xf1\x0d\xde\xb2\xed\x57\xdd\xef\xba\x1f\xb1\xf2\x21\x4f\x97\x79\x7f\x77\x49\xc5\x5e\x17\x5e\x29\x6a\x21\xa8\xc1\x44\x42\xea\xcc\x82\xfb\x8c\x64\x82\x90\x01\x48\xb3\x80\x66\x3c\xee\x73\xef\x0f\x17\x0d\x07\x8c\xf5\xb6\x1d\x9b\xdb\xe9\x00\x3f\x69\xb5\x5b\xa4\x70\xba\xec\x76\xba\x9f\xcd\x09\x69\x04\x11\xd9\xc9\x93\xcd\x82\xa8\xc8\x24\x98\x5b\x45\x70\x70\x45\xd1\x89\x19\x14\x50\x92\x52\x80\xf2\x29\xe3\x4f\x27\x44\xd5\x4d\x94\x28\x23\x3f\xa5\xfc\x91\xbe\x65\xa1\x5c\x50\x80\xdb\x45\xc6\x11\x1c\x05\x91\xbe\xf9\x3f\xd2\x43\x05\xd1\xd3\xe8\xbf\x34\xcb\xa9\x51\xfc\xd9\xbd\x7d\xd8\x66\xe8\xf2\xac\x49\xda\xd5\x68\x9e\xbf\x9c\x0f\xdc\x9e\x17\x38\xae\x8a\x34\xaf\x04\x91\x94\xef\x79\x64\x8f\xb9\x20\x20\xe8\x91\x5f\x30\xc7\x72\x73\x15\x78\xfd\x15\xc7\x87\x98\x33\x43\x19\xb5\x79\x32\x05\x20\x7c\xe8\xd8\x50\x3a\x41\x47\x67\xbd\x92\x79\xe7\x74\xcf\xcb\x44\x6e\x5b\x60\x4f\x30\x51\xc4\xe4\x2a\x5c\xf0\x3e\xa1\xbc\xa2\x50\xa2\xf8\xc1\xa4\xe0\x06\x4d\x1b\xe8\x48\xde\x90\x22\x07\xeb\x80\x77\x6a\x21\x9f\x2e\x70\x15\x1c\x5c\x2b\xea\x5c\x60\x5a\xf5\x40\x92\x5f\x7b\x24\x7f\xa2\xde\x5d\x08\x56\x06\xd2\x44\xc1\xde\x01\x02\x4b\x54\xc2\x70\xf9\x86\xca\xad\x7b\x6e\x75\x15\x94\xb8\xa4\x90\xab\x59\x45\x80\xeb\x67\xe5\xd8\x57\x85\x16\x98\x42\x3f\x87\x13\xbc\xd4\xfe\x6a\xd9\xbd\xd4\x25\xb4\xab\x2c\xf4\x93\x36\xab\x21\xb9\x06\x2a\xe2\x41\xa0\xb7\x79\xc3\x79\x43\x8b\x66\x44\x15\x6d\x0f\x7f\x93\x6d\xdf\x9d\xc1\xe8\x9d\xf3\x26\x28\xd8\x50\xc2\xe1\xc1\xb9\xce\x3f\xa4\x2d\xee\xc7\x78\xae\x22\xa7\x86\xfa\xa1\x14\xf6\x18\xb5\x93\xf4\x3e\x29\x4a\xdd\xeb\xde\xff\x02\xf6\xdd\xd3\xa1\xdc\x7e\xf2\x9a\xe2\x77\xa6\x7c\xe3\x89\x0a\x35\x3e\x8f\x7b\xfb\x29\xd2\x72\xa8\xbd\xec\xb2\x54\xe2\x05\x02\x37\x6a\x13\xb8\x28\x1a\x7b\x71\xa6\x9c\x07\x15\xee\xfb\x16\x1b\x43\xcc\xc7\x0c\x05\x0c\x64\x16\x26\x52\x51\xbb\xa9\x8b\x36\xa4\xf9\xfa\x8a\xb4\x83\xa0\x0e\xac\x17\xd6\x69\xf7\xec\xc4\xf9\x79\x8d\xce\x4a\x86\x60\x75\x4e\xd6\xe9\x40\x3f\xdf\x3a\x6b\x06\x5a\x0f\x6a\xd6\x9e\x5f\x6e\x7c\x70\x42\x0e\x39\x2d\x64\xbe\x5f\xf7\x3b\x65\x09\x3d\x6f\xf6\x6f\x59\x78\x8d\xbe\xc0\x50\x5c\x41\xa3\x0f\xa9\x55\xe9\x61\x96\x1b\x96\x62\xb5\x96\x44\x80\x59\x8e\x37\xb5\x17\xc5\xeb\xfb\xdb\xdb\x5e\x2a\x01\xd3\x15\x62\xa8\x5c\x47\xc8\x75\x2b\x1a\x54\x01\xb8\x54\x64\x82\x72\x5d\xad\x81\xd0\xa8\x22\x1b\x0a\xca\xad\x87\x37\x57\x21\x02\xe6\x52\x0b\x95\xfb\x44\x56\x4c\x92\xd2\x4b\x70\x6f\x2b\x81\x04\x60\x31\x3b\xa0\xae\x19\x39\xbe\x56\xed\x46\xb5\x05\xdd\x50\x9f\xa3\x28\xa6\xc8\xaf\x02\x5c\xfd\x52\x85\xd0\x0e\x38\xc1\xd4\x1e\x26\x75\x5b\x01\x7d\xe7\xc8\x3e\x0b\x08\x47\xa7\x64\xc0\x2f\xdc\x26\x2e\x15\x07\x9d\x36\x4f\x47\x9c\xcf\x3c\x5d\xd2\x7a\x5c\x91\x50\xc9\x51\x41\x47\x70\x84\xac\x2e\x24\xc4\xea\xfc\xf4\x34\x90\x84\xa5\x98\xe0\xe4\x4f\xb6\xea\xd9\xe0\xd9\x60\xbc\xe2\x0f\x62\x9e\xe5\x80\x7b\x98\x61\xf2\x06\x61\xe7\xc0\xb7\x4c\x87\x95\x43\x4d\x99\xc9\x69\xd1\xae\x71\x43\xee\x02\xe1\x4d\x75\xdd\x2e\x4c\x97\xe6\x0b\x8f\x8c\xd8\xb4\x42\xa3\xaf\x2f\x98\x90\x21\x9f\x0d\x34\x11\x21\x45\x02\x4a\x7c\x5e\x64\xff\xbf\x12\x70\xcf\x8d\x65\x86\x38\x57\xdf\x55\x5d\x7c\x6b\xc3\x86\xea\x62\x17\x90\x29\x2b\x62\xeb\x36\x78\xfc\x8a\xf2\xe9\x19\x33\xe0\x6a\xfc\xaf\xee\x61\xe9\xca\x6a\x10\x5c\x2d\x2d\xb1\xda\x5f\x90\x25\x83\x4a\x57\x0d\xad\xaf\xad\x87\x52\x82\x4d\xc7\x0c\x0a\x20\x3b\x78\x43\xf8\x51\xfd\xc3\x23\xbe\x37\xed\x36\x73\x03\x35\xcd\xac\xfc\x09\x2c\xc5\xc4\x83\xcc\x6d\xff\xb9\xef\xf0\x03\x79\xde\xce\x5d\x24\x9a\x9e\x5c\x87\x32\xa9\x28\x02\xd5\x0a\xae\x05\xe4\xc9\x28\xc4\x14\xa5\x27\xf5\xc7\x51\x52\xe5\x92\x59\xf8\xc3\x1e\xa4\xfc\xb4\xfc\xca\xf6\xf3\x0a\xa7\x2b\x6f\xa7\x5b\xbe\x1a\x17\x97\x4c\x7e\xbb\x92\x28\x76\x3d\x48\x14\x6b\xab\x4c\xe5\x37\xd4\x95\x88\xf3\x0d\xb0\x3e\x48\x3c\x8b\x4f\x13\xb2\x37\x26\x77\x33\xec\xe3\xe1\x4a\xda\x30\xb8\x41\xde\x44\x81\x4c\x86\x0f\x9a\x2b\x64\x92\x4b\x04\x06\x44\x73\xe3\x9c\x99\x5c\x0e\xc6\x91\x03\xae\xd0\x46\xc8\xb9\x3d\x78\xa7\x56\x90\xb5\x92\xb4\x09\x12\x76\x77\x29\x69\xbe\xfd\x1c\xcd\xdc\xa1\xb2\x22\x5e\x32\x34\xe4\xbc\x94\x64\x7e\xe9\x58\x33\xa0\x13\xb9\x87\x01\x6c\xc2\xa4\xe8\x61\x18\xf8\x42\x63\x4f\x05\x1d\x55\x24\x8a\xfa\xee\x85\x94\xf2\x59\x12\xb7\x90\x55\xb2\xcb\x64\xb3\x2e\x51\x53\xea\xe9\x1e\xea\x10\x92\xd4\x89\x8a\x20\xd9\x2b\x44\x05\xf2\x67\xa3\x2e\x05\x01\x6f\x7b\x94\x4c\x49\x50\x1b\xd6\xaf\xb8\x24\xfa\x25\x5b\xdc\xae\x62\xd1\x27\x2e\x89\x32\x11\xb4\x36\xcf\x7f\xd6\xd0\xa6\x13\x56\x22\x82\xcd\x58\x4e\x26\xbb\x8b\x30\x80\x94\xa1\x50\xe4\x9a\x21\x74\x79\x9e\x8b\x1f\x16\x39\x18\xf7\x10\xfe\x44\x99\xdc\xb0\xa5\x81\x6a\x00\x60\xf0\x16\x64\x20\x1b\xa5\x09\x5c\xfb\x22\x9f\x24\x1b\x93\x52\x2c\x8e\x17\x0e\x5a\x28\xf0\xa3\xfd\x5e\x47\x7e\x44\x88\xde\x50\x54\xa7\x3b\x49\xc0\x81\x4b\x02\xa1\x38\x30\x5f\x4a\xe1\x1e\x75\xf1\x87\x39\x37\xa5\xc1\x59\x4b\xba\x79\x09\xb8\x94\x44\x94\xe1\x26\x36\x13\x96\xee\x30\x6a\x20\x63\xb4\x05\x85\x88\x75\x6e\x41\x27\xf1\x04\xd0\xf2\x49\x12\xba\x3c\x6a\x5a\x2a\x96\xa3\x47\x2c\x1d\x35\x08\x50\x46\x63\x3e\x17\xf0\x5a\x74\xd8\x89\x4f\xd7\x13\x38\x6d\x04\x80\x14\x38\xd6\x50\xe6\xb3\x8e\xa8\x52\x50\x48\x91\x5b\x5e\xb5\xa0\x48\x43\x52\x70\xee\x77\x9d\xc8\xe1\xac\x12\x7a\xb0\xa9\xfa\xa1\x65\x6d\x85\xa8\x93\x1f\x15\xd4\x4d\x32\x52\x10\x62\xfa\x30\xac\xca\x5c\xe9\x6d\xf8\xb4\x62\x36\x18\xd4\x7d\xe4\xb6\x44\x48\x05\x97\xa2\xb0\x62\x72\xde\xd3\xe5\x3a\xd3\xae\xd0\xa8\xbd\x2c\x05\x10\x1f\x04\x52\xc9\xe6\x55\xe6\xa1\xde\xd0\xa8\xeb\xb9\x91\x03\x68\x58\x33\x14\x88\xb0\x2c\x42\x81\x1f\x17\x63\xcb\x54\xc7\x02\x43\xaa\x14\xc8\x54\xc2\x7c\x86\x9e\x12\x04\xbd\x75\xca\x3d\x96\x57\xb0\x92\x7e\xc9\x5f\xb6\xaf\x4a\xee\x67\x99\xa1\x95\x7c\x10\xa7\xf1\xe3\xef\xe2\x6a\x20\x55\x3d\x8a\x33\x9d\x4e\x82\x5c\x59\x2e\x78\xde\x21\x78\x6e\xdd\x77\x03\x8c\xb1\xb9\x16\x62\x41\x8a\x7c\xb6\x12\xea\xa8\x4b\x36\x0f\x78\x08\xb4\xf7\x87\xeb\x8d\xc6\xe6\x3a\x47\x34\x3a\xe5\xe4\x80\xdb\x2a\x0c\xae\x0a\x9f\xfb\x5c\xef\x02\xf5\x82\x4b\xcc\x80\x1e\x8d\xb4\xf6\xd0\x83\xd9\x71\xba\x59\xdf\x73\x11\x13\x5b\x2a\xb4\x6f\xc8\x95\x89\x6c\x95\xa6\xce\xdb\x4f\x69\x22\x47\xc2\x85\xad\x9c\x20\x5f\x07\xd6\x36\xea\xe0\x89\xec\x83\x92\x0f\x63\x9b\xec\xe2\xe4\xfe\xca\x87\xfc\x0f\x34\x28\xf1\xe1\x30\xe7\x8a\x7a\xd9\x0f\xd6\x6e\x7a\x2e\x2e\x8e\x86\x3c\xa9\x34\x5b\x2f\x23\x35\x89\xa1\x9e\xb5\x46\x38\x33\xbb\xfe\x13\xd3\xc0\x88\x73\x9b\x0d\x0a\xea\xac\xea\xe8\x73\xc1\x18\xa3\xf8\x46\xd7\x20\xc9\xba\x37\x74\x98\x3c\xe7\xb9\x4b\x1c\xa3\x00\x6b\x3a\xd3\x8f\x64\xd8\xab\x8c\x27\x74\x06\xeb\x6f\x7b\x4a\x3a\xbb\x1c\x0a\x3a\x30\x54\x31\x73\x80\x63\x38\x35\x60\xa4\x59\xeb\xbb\x16\xcb\xd2\x66\x10\x98\xa3\x90\xcb\x94\xca\x89\x06\xbd\xd9\x26\x0f\x9b\x68\x16\x56\x1b\x11\x7a\x86\x87\x2f\x41\x10\xf1\xd0\xd4\x20\x81\x9a\xfb\x5c\x15\x4a\x93\x4c\x17\x28\x10\x8c\x32\x37\xa6\x15\x9c\x46\xc9\x1e\x5a\xa1\x7a\xc9\xe9\x40\xdc\x29\x86\x87\x0d\xd6\xb8\x64\x07\xf4\x4e\x75\xbc\x31\xed\xff\x0d\x40\xd9\xd4\x17\xc1\x82\xb7\xee\x05\xa0\x48\x12\x58\x2b\x8f\x40\x1d\x9a\xe0\x1f\xa3\x86\xd6\xd6\x2e\xb8\x5b\xb6\x07\x5d\x35\xd9\x1c\x91\xa1\xbb\x94\x26\x67\x4b\xd0\x9b\xa0\xa2\xda\xb3\xf6\xee\x51\x00\x11\x56\x46\x68\x65\x45\x38\x01\x45\x37\xcc\x8d\xa0\xd4\x91\x13\x44\x91\xc5\xfd\xdf\xa7\xd0\x22\x2a\x51\xb1\x5e\x85\xca\xb2\x16\xa6\xe5\x97\xda\xed\x21\x00\x04\x52\xa4\x65\xa4\x24\xeb\xb1\x2e\xef\x91\xa0\xa1\x49\x1d\xde\x6c\x7d\x94\x93\x99\x56\xeb\x38\xe6\xbd\x52\xe9\x28\x5b\x07\xcf\xfb\x16\x0e\xbf\xf1\x80\xe8\x47\xf0\xbc\x88\x13\x5d\xd5\x57\x64\x7b\x6e\x9d\xf6\x9f\x4e\x3b\xae\xb6\x1d\x77\x78\xde\xf5\xf9\x28\xfb\xe3\xfd\x5e\x20\xf6\xef\x8b\xc3\xde\x7e\x3b\x10\x7b\xc9\xd5\xb7\x0b\xb0\xe0\x9d\x32\x4e\x66\xea\x44\x6d\x51\x0c\x05\x15\xbd\x9a\x56\xcd\xe4\xbd\x0b\x99\x85\xaa\xba\xc4\x5e\x98\x93\x92\x86\xc4\x35\xf9\xe3\x38\x04\x07\x4d\x5f\xf4\xed\xde\x42\x51\x26\xca\xa5\x4e\x6b\xcb\x80\x74\xd4\x96\x47\x86\x32\x2d\xb4\x85\x83\x48\x96\x25\x67\xd0\xe8\xe5\x95\xa3\xcd\x5c\x4e\x7b\x59\xe9\x9b\x4e\xc4\xaf\x96\xa8\x19\xd3\xb6\xab\xfb\x65\x6a\xaa\x04\xc7\x18\x29\x74\x97\xb2\x59\x02\x10\x18\x2e\xb2\xcf\xe9\x1d\x64\xcf\x24\x73\xea\x59\xc3\x6c\x7a\x5b\x2b\x86\x77\x0a\x44\xc0\x64\x57\x68\x75\x5b\x07\x79\x26\x78\xf9\xba\x31\x65\xa9\xc8\xd4\xf3\x09\x10\x97\x28\x93\x48\x2a\x18\x68\x4d\xf3\x8a\xd0\x86\xb0\x3a\x5c\xa7\x9b\x31\x0c\x0f\x1f\xb2\x31\xd3\xd6\x5d\xc4\x08\x9d\x67\x0f\x05\xbf\xac\x52\x73\xaa\xbf\x77\xbf\x9c\x8f\xf2\x5f\xbc\x44\x78\x1c\x24\x7e\xa7\xcd\xe7\x11\xaf\x3a\xc6\x25\xe9\xdd\x2e\x95\xf6\xe7\x25\x35\x65\xaf\xb4\x57\x94\xba\xc7\x9a\x98\x79\xe3\x28\x05\xda\x29\x43\x4f\x32\x56\xb6\x42\x6c\x3d\xe4\x24\x9b\xb6\x90\xf3\x41\xca\x25\xba\x49\x9f\x41\x09\x5f\xc5\xe7\x05\x50\xc5\x66\x88\x36\x38\x37\x02\x42\x5b\x7f\xd4\xb5\xa8\xd9\xba\xc2\x6a\xb6\x3c\x3c\x41\x58\x27\x48\x2d\x88\xac\xa0\x52\x96\x50\xa9\x96\x76\xaa\xd8\xa0\x85\xde\xe6\x80\xb9\xe2\xf9\xdd\xe6\xa2\xc6\xd0\x10\xf3\x2c\x6c\x5e\x89\xa8\x20\xbe\x83\xf3\x32\x76\xf4\xca\x32\x33\xd4\xd6\xbb\x3a\xe7\x78\x86\xe8\xb3\x4b\xfa\x60\x08\x62\x8a\x96\x31\x17\xd8\x3b\x58\x12\x07\x8a\x8c\xe3\x33\x98\x0c\x01\xb1\x76\x48\xe8\x14\x06\x98\x43\x34\xb3\xae\x4a\x98\x61\x0e\x56\x94\xc1\x1f\x28\x75\x03\x20\xc6\x96\x91\xb5\x99\x31\x15\xa8\xfd\x95\xf3\xe6\xd2\x60\x34\xbd\x15\x22\x63\xbe\xdc\xfa\x1a\xb4\x23\xe3\x7c\x99\xf1\x54\xf7\x11\x85\x88\x42\x33\x75\xee\xe0\x82\x83\xef\x52\x29\xa2\xad\x90\x19\x37\x0b\xc0\x6c\x63\x36\x20\xd5\x40\x59\xbb\xdf\x36\xa9\xf8\x0c\x66\xa1\x0c\x0c\x61\x62\x15\x24\x95\xb5\xe4\x80\x9a\xe2\x20\x53\x8f\x22\x05\x61\x87\x45\x19\x9e\x68\x5d\x07\xab\xeb\xc0\x15\xd1\x29\xe9\xee\xf1\x0e\xfb\x1c\x42\xd4\x15\xfc\xaa\xbc\x3f\x95\x02\x4a\x82\x92\xe4\x50\x20\x45\x48\x81\x25\xc4\x1a\xd0\x4c\x1a\x18\xe6\x28\xcf\xd5\x40\xbc\xae\x32\xdb\x24\x3d\x18\x87\xb5\xb1\xdc\xcf\x2f\xcd\xc1\x56\x5e\x6b\x8c\x8d\x6b\x7e\xf6\xab\x32\x76\x29\x36\x95\xe6\x84\xe2\xe5\xea\x31\x68\x40\xb1\xd2\x33\xea\x6b\xb3\x5a\x87\x10\x12\xec\xb7\xb4\x22\x92\x8d\x5c\xa9\xb8\xec\xeb\x2e\x9a\x17\xb5\xb5\x47\x2c\xba\x16\x4a\x84\x1e\x7f\xdc\x9e\x87\xae\x64\x2a\xd3\x1e\xf6\x0b\x6e\x7e\x8b\x55\x50\x7a\xfd\x7c\x00\x44\x53\xd3\x08\xee\x33\x47\x81\xdc\x1a\x0d\xa9\x96\xa0\x89\xc5\x4a\x79\xb0\x76\x52\x10\xd1\x5c\x4f\xc5\x2c\x6b\x8e\xdd\x86\x2a\x60\x38\x47\x36\xd2\xf3\x04\x2f\xdf\xd0\xf0\xe5\x8a\x76\xcf\x2b\x13\x1e\x21\xab\x13\xdd\x22\x97\xc6\xda\x8b\xd6\xcf\x65\x44\x58\x6a\xa7\x32\x5e\x9f\x69\x59\x2b\x35\x27\x9d\x1c\xb8\x50\xd5\x53\x15\xf2\x9e\xa4\x1f\x01\x79\x40\x0d\xa3\xac\x52\xa1\x7b\xaf\x88\xce\x6b\xce\x54\x9d\x2f\x09\x4b\x82\xf5\x15\x00\x43\x8a\x99\x13\x39\x68\x2e\x88\x8d\x8c\x1c\xb4\x96\x30\xf2\x1e\x29\x41\x58\xab\xae\x90\xcd\xb7\x89\x5b\xa9\x10\xa8\xb3\x3a\x16\x3a\x37\x79\xbb\xbd\xe8\x3b\xd7\xec\xf5\x85\xf9\xf9\xdc\x77\xac\x01\xea\x44\x64\x04\xf9\x0a\xd8\xf5\xf7\x28\x42\x92\x66\x2c\x98\x3e\x5a\xc1\x07\xad\x8c\x6b\x63\xfe\x65\x51\x3e\xf4\xc0\xca\x33\x7f\x27\xd0\x71\x2f\x28\x62\x6d\xce\x35\xbb\x5b\x46\xe0\x61\x6d\x6e\xed\x11\x70\xac\x2e\x86\xbf\x22\x0c\x8f\xae\xdb\xac\x4d\xa2\x12\x3d\x0c\x33\x12\x4e\x82\xad\x08\xde\xea\xb9\x07\x6d\x47\x06\xc9\x56\xbd\xba\x4a\x0f\xa0\xcb\x99\x41\x75\xae\x66\xf1\xe7\x96\x42\xe9\x35\xb4\x84\xd2\x92\xe1\x48\xf1\x62\x1f\x24\xd7\xb2\x42\xce\xb4\x04\xe5\x4c\x08\xf8\x5d\x85\x70\xaa\xa0\x2c\x1f\x52\xd4\x98\xfa\x57\x18\x6c\xe6\xac\x99\x0f\x2b\xdd\x7d\x62\x94\xd5\x64\x2a\x1c\x32\x20\xdf\x9e\x1a\x8a\xca\xf8\xe1\x91\xb5\xec\xac\x51\x21\xcb\xb3\x75\x5e\xce\xe9\xd3\x2c\xd5\xae\x1a\x44\x61\xf0\x7b\x88\x53\x10\x4c\xcd\x1d\xca\xa3\x3b\x35\x75\x05\xc3\xe6\x8a\x11\x55\x7a\x50\xf5\x25\x47\x0e\x43\x92\x94\x81\x2b\x54\x61\x6b\xa8\x12\x54\xda\xdb\x0d\xa5\xd6\x28\x9e\x1d\xcd\x47\xb3\x43\xc2\x18\x07\x2a\x70\xf9\x91\xca\xd4\xc6\xc6\x17\x55\x38\x22\x4e\xb0\x3b\x90\x58\x41\xd1\x8f\xf9\xd6\x28\xa6\x4a\xe8\x06\x36\x58\xf5\xed\x67\xcb\x36\x1a\xeb\xbd\xeb\x00\xeb\x05\xb5\xbb\xad\xaf\x23\x16\x23\x61\xc2\xb9\x61\xad\x23\x35\x45\xe7\x33\x8c\xad\xf9\xeb\xec\xd0\xff\x51\xc7\x35\xcb\x7f\xa5\x5c\x3e\xa1\x56\xad\x5b\xeb\x18\x7b\x9c\xf2\x33\xea\xd6\x06\xc6\xa0\x2f\xa8\x5b\xf7\x80\xe9\xa7\xcc\xad\xe9\x73\x02\x5b\xe8\xb4\x81\x99\x7e\x7e\x25\x8a\xd3\xb3\x6b\x12\xe4\xfa\x3b\x0c\x4d\x00\x7e\xfe\x5a\x3c\x7a\xfb\x80\xf9\x29\x57\xa5\xe6\x40\xcf\xbf\x2b\xbe\x63\xaf\xf7\x17\xc8\x65\xc7\x35\x95\xf7\x65\xd5\x6e\x26\x59\xd7\x5d\x66\x5f\x81\x84\x06\xe2\x14\xf1\x14\xeb\xfe\x2c\x21\xa0\x12\x8e\x48\x65\x8e\x8a\x85\x6f\xbb\x25\x92\x36\x17\x53\xcd\xba\x51\xb3\xb7\x6d\x44\xcc\x5b\xd7\x06\x7e\x15\x3c\xe9\x83\x02\xc7\x79\x30\xb2\xa9\x14\x63\x15\x73\x66\xc1\xd7\xde\xeb\xdd\x16\x9d\x03\xf7\xa7\x21\x17\x50\xd4\x0d\x7d\x48\xa6\x06\x8e\x99\x4f\xb6\x3a\x61\x27\xd0\xfc\x54\x68\xbc\xdb\x0a\x8c\xf3\x10\x99\x2d\x5b\x2e\x84\x83\xfb\x89\xa0\x13\xe0\xdf\x36\x06\x6f\xcb\xed\x1e\xa5\x8f\x55\xa1\xe5\x9d\x82\xcc\x16\x6a\x43\x5d\x38\x3c\x69\x0a\x1d\x63\x06\x52\x9e\x96\xa1\xce\xbb\x45\xfa\x11\x84\x2a\x30\x04\xe8\x24\xf6\x9a\x3d\x10\x85\x05\x67\x8d\x59\x81\x31\xad\x39\x34\x71\x31\x5f\xd1\xe9\xa4\x4b\x5a\x07\x42\xc5\x70\x8f\xc9\xd9\xd6\xf2\x86\xd0\x84\xe4\x69\xbd\xa7\xf7\x55\x01\x36\x83\x71\xd6\xf3\x26\x09\x89\xa4\xba\x16\xbb\x10\x42\xd3\x01\xc6\x26\x9a\x71\x83\xc2\x70\x45\x42\xad\x0c\xc7\xad\x9b\x1d\xbb\x14\xb3\xb8\x53\xba\x01\xbd\x29\x84\xd4\x24\x54\x7d\xbd\xe8\x4a\xd7\xfc\xd8\x7f\x9c\x58\xde\x84\x15\x97\xb6\x6e\x32\x0a\xc3\x7f\x94\x6b\x0e\x92\xde\x85\xdd\x09\xe0\x62\x08\x73\x22\x43\x80\xdf\xa9\xd3\x39\x42\xf3\x53\x78\x86\xe4\xc0\x80\x54\xf7\x16\x2a\x36\x57\x67\x50\x4c\xc8\x98\x6b\x04\xaf\x85\x75\x83\x66\xbd\x69\x80\xbc\x55\xa1\xd8\x2d\xc1\x66\xe6\x55\x40\xca\x1d\x18\x7c\x9a\x2b\x04\x2f\xb4\x78\x17\xd3\xb6\xda\xac\x39\x07\xd7\x7b\xb1\x41\x0f\x0c\x69\x0b\xe6\xc1\x46\xc8\x4e\x61\x4a\xe9\xd6\x1b\xe0\xce\xd6\x8a\x9c\x91\x54\x5d\x5a\x68\xb7\x15\x5a\xef\x41\x6b\xb0\xdd\x21\x66\x78\xa7\xaa\x2b\x88\x08\x3a\x74\x9b\xea\x78\xfb\x39\x75\x86\x96\xca\x42\x5a\xad\xb6\x30\x0a\xb2\x42\xce\x00\x52\x03\x08\xde\x22\xba\x45\xe0\x66\x44\x0c\x96\xe8\xb6\x19\x24\x2d\xb1\x69\x68\xb2\x5f\x60\x75\x01\x76\x78\x32\xd0\xf9\x60\x2a\x57\xda\x12\x15\x72\x04\x83\x71\xa3\x41\x38\x68\x0f\x28\x87\x6f\x2d\x58\xa7\xb6\x1f\x14\xb8\xb7\xff\x8a\x75\x22\xd4\x7b\x04\xbb\xc2\x58\x1b\xe3\x57\xb1\x2e\xad\xf2\x69\x41\x0f\x64\x87\x74\x80\x18\x25\xdf\x56\x64\x17\x6d\x8e\x0a\xb1\x94\x37\x0a\x80\x10\x30\xe7\x20\x3d\xfb\x14\xd0\x3c\x81\x2b\x52\xf7\x69\x64\x90\x45\x00\xff\x33\xdb\xaf\x66\x9f\x2b\x4e\xe1\x06\xe4\x58\xc1\x6d\xdf\x90\x50\x80\x3a\x3d\x28\xee\x51\x1d\x8f\x26\x36\x63\x23\x41\x80\x7c\xda\xb0\x2a\x39\x94\x62\x9f\x57\x5a\x00\x4e\x5a\xd7\x4c\x5b\x6f\xc2\x97\xeb\x77\x79\xe4\x3c\x1f\xba\xda\x82\xde\x00\x33\xd0\xac\x00\x3f\x43\xa2\x14\x02\xec\x79\x65\xed\xac\x92\x3c\xc8\xc6\x18\x29\x31\x5d\x53\xb5\x87\x5d\xc1\x5d\x2b\x78\xee\x77\xd9\x68\xf8\xbf\x89\xe1\x53\x18\x47\x03\x0d\x23\x36\xd6\x57\x69\xb6\xfc\x97\x12\x4a\x5e\x04\x15\xc9\xf8\x17\xaf\xd1\x10\x3c\xcc\xab\x24\x86\xf6\x1b\x55\x91\xbb\xd3\x17\x03\x0d\x27\x0c\xa6\x75\x59\x63\x17\x48\xcd\xdb\x78\xe8\x42\x82\x3d\x04\x45\x07\xc0\xd0\x18\x5d\x28\xd2\x44\xfc\x3a\x3d\x62\x41\x94\x2f\xc1\x2d\xd7\x82\xf2\xcd\x75\x92\xc0\x65\xa7\xdd\x03\x1d\x72\xa6\xc6\x2c\x7c\x7b\xf3\x5b\x69\x68\xc0\xb6\x47\xb8\xa3\x08\xc0\x53\xe0\x73\x01\xa7\x4b\x36\x6f\x0f\x12\xfb\xe4\x72\xc8\xa8\xc0\x71\xf6\x10\xfc\x6f\xe6\xfb\xe8\x0b\xbc\x55\xe2\x34\x76\x46\x2c\x97\x0b\x38\xd6\x78\x20\xd5\x33\x93\x43\xc1\x69\x6f\x18\xb5\xae\x0e\x64\x79\x34\x2a\x06\xd7\x70\x60\x5b\x58\x70\x27\xf2\xa3\xde\x47\xef\x34\x10\xad\x29\xab\x2f\x4a\xb5\xde\xe3\x10\x79\xc4\x32\xf2\x1d\xd4\x0a\x98\x3b\x34\x80\xd1\x79\xe0\xbb\xa4\x69\x13\x83\x66\x09\xa5\xc1\x94\x33\xe3\x01\xfd\xf0\xb6\xed\x5d\x73\xb5\xd5\x69\x48\x38\x3a\x2f\xa6\x12\xd1\xc0\xfe\x3d\xa1\x08\x61\xfe\x95\x8e\x15\x29\x81\x49\x6c\x21\x53\x01\xc3\x43\xef\x50\x54\x01\xd3\x8a\x87\x62\xad\x67\xb3\x2a\xaf\x85\x4e\x84\x25\x42\x7c\xa9\x07\xc9\x30\xfa\x7c\x32\xe3\xcc\x73\x14\x27\x35\xe5\x4c\x81\x02\x77\xe6\x32\x58\x1e\xc4\xc8\x47\x1e\xd6\xbf\x31\xac\x6d\x1a\xcc\x29\xd4\x1e\x74\xce\x50\xfb\x2a\xb0\x94\x33\x41\xb5\x2b\x39\x1b\x47\x50\x6a\xee\xbf\x82\xa1\x8e\x4b\x12\xb8\x5f\xea\x94\xcf\x76\x44\xad\x12\x5a\x32\xcf\xbe\x05\x6d\xc1\xec\x18\x4a\x37\x6f\x98\xb2\xb2\xf3\x46\x12\xbd\x53\x20\x68\x82\x05\x14\xcd\x66\x5e\x29\x60\x79\xbd\x6c\x28\x2a\x8a\x15\xda\x29\xee\xfb\x9c\xd5\x30\xb2\xcd\x59\xac\x9f\x62\x25\x95\x20\x1a\x28\xe6\xe0\xc1\xb0\x0e\x92\x90\x2e\x47\xc8\x62\xf5\xef\x93\xd8\xc1\x50\x52\x3f\x42\x27\xf7\xa4\x3a\xd7\x25\xaa\xc8\x50\x28\x2c\x3d\xe4\x84\x6f\xd4\xd6\x8c\x50\x82\x8d\xcf\x39\x01\x29\x97\x09\xce\xba\x3c\x61\xe0\x9b\x65\xdf\x2b\xd6\x53\xd6\xf6\xb7\xe0\x49\xc0\x13\xb0\x20\x81\xab\x19\x76\x07\xf4\x2c\xb0\x16\xf9\xac\x5f\xd8\x37\xe6\x96\x82\x16\x5b\x17\x8a\xf9\x41\xb0\x11\xc4\x75\x76\x3c\xd0\x16\xba\xab\x02\x51\x76\x44\x3b\x34\xd8\x61\xec\x62\x34\xd5\xb0\x93\x1c\x45\x37\x53\xf2\x9e\x2c\x01\x3c\x25\xee\xe3\x90\xb9\x91\x10\x65\xb7\xdd\x36\x5b\x87\x80\xad\xae\xe0\x11\xc1\xe5\x28\x12\x03\x5e\x94\x25\x0a\x47\x2a\x3a\x58\xe9\xa1\x24\x2a\x53\xa7\x9b\x0d\x8b\x1e\x6c\x60\xc9\xd6\x41\x72\x87\x81\x51\x42\x83\x64\x0d\x01\x52\x3f\x48\x26\x86\x25\x76\x38\x93\x50\x69\x1b\xab\xbd\x16\x9a\x0c\x4b\x84\x93\xae\x2e\xcd\xc4\x68\x11\xb0\xd9\x9b\x75\xd7\x3a\x58\xcb\x61\xdd\x1b\x98\x08\x01\xf2\xc3\x86\x0c\xa0\x9b\xf6\x6d\xfa\xd1\xd8\x28\x82\xc1\x5d\xc9\xc8\x84\xf8\xc8\xd3\x7f\x3a\x38\xe8\x59\x45\x36\x32\x2c\x6e\x2e\xa3\x8a\xc9\x77\xc0\xc0\x90\x5a\x30\x23\xcb\x93\x8d\x76\xe4\x8d\xc2\xf6\xb5\xdf\x36\x1b\x67\x88\xe3\x31\x28\x83\x98\x21\xa2\x0e\x36\x75\x11\x22\xd2\x30\x07\x04\xb3\xaa\x73\x01\x4c\xd6\xe6\x9b\x7a\xa4\xb5\x9a\x7f\x00\x06\xb2\x44\xc9\xe7\x42\x70\x30\x0d\x6e\x86\xa9\xbd\x6a\x7d\x96\xc0\xcb\x02\xc6\x27\x32\xcd\xea\x83\xbb\x90\x46\x98\x08\x91\x1d\x52\xde\xe4\x88\x46\xaf\x26\x6b\x21\x48\x67\x76\xf2\x58\x14\x73\x21\x2a\x89\x82\x50\x92\x5c\x38\x4b\x14\x4a\x35\xc6\x7c\xfb\xd9\x10\x99\xe8\xee\xb6\x76\x86\xc2\x6f\x6b\xe3\xd8\x45\xc2\x57\x75\xb5\xc6\x42\x59\xa2\x39\xd0\x2b\xcc\x0a\x33\x2e\x24\xc9\x43\x9a\xae\xf8\x38\x18\x56\xc2\x37\x74\x5e\xdf\xcc\xf0\x77\xf7\xd4\x09\x1d\x69\x29\xaf\x43\x73\x97\x5a\x87\xfe\x15\x38\x80\xa5\x37\x3a\xd2\x07\xa2\x2d\x5f\x0b\xc3\x38\x2f\xc5\x77\x85\x61\x44\x07\xf5\xcf\x2f\x4e\x5c\x2b\x9f\xe8\xa7\xba\x14\xe2\xef\x9f\x45\x7e\x70\xb3\x66\xa9\x93\xa2\x63\x5c\x05\x54\x6f\x1f\x08\xb4\x7f\x2c\xcd\xfa\x4e\x2d\xff\x10\x66\xa5\x9a\xdf\x17\x37\xf8\x87\xaf\x8f\x6f\x13\x4f\x5a\x93\x54\x23\x84\xb0\x64\x49\xae\x07\x58\xca\xb8\xdb\xb4\xf0\x7d\xbf\x5c\xb5\xdc\x0e\x32\xd4\xeb\xee\xf6\x11\xe4\x13\x02\xa2\x98\x7d\xbe\x41\x1b\xad\x5a\x9c\x75\xf3\xbd\xd4\xc9\x47\x0f\xa9\x2f\x19\xd5\xc7\xa5\xde\xa1\x5f\xe0\x13\xe7\x0e\x6d\x9f\xbd\x48\xfb\xfc\xfd\x6b\x6f\xdf\x7a\x0d\x3b\xee\xd7\x07\x26\x29\x00\x09\xe9\xed\x6b\xfc\xfa\x61\xa8\xcb\x29\x69\x7c\x26\xf3\xfb\xf1\xb7\xfe\x76\x0f\xda\x19\x33\xae\x37\xb8\xfd\xb9\x3b\xb4\x56\xc0\xe2\xfb\x5f\x69\xfc\xdf\x7e\x9d\x00\x7e\x5f\x84\x6a\x5c\xd2\xc3\xfd\x5a\xdf\x7d\xee\x68\xb6\xd0\x56\x01\x48\x3e\x16\x58\xae\xc4\xfd\xa3\xd5\xad\x41\x09\x86\x67\x3a\xcc\xec\x35\x38\xe7\xc4\xb7\xef\x1f\x47\xd5\x0e\x2b\x2d\xf0\x02\xb8\x84\x2a\xbe\xc4\xc2\xf2\x07\x47\xdf\xcb\x18\x27\x74\x7c\xb6\x23\x74\xe1\x79\x76\x9a\x5d\x87\x9f\x74\xf1\x5b\x8d\x85\x37\x07\x27\xc7\xe4\x07\xc6\xb3\x2d\xfe\xbc\xb8\xd7\x24\x91\x01\x1e\xe8\x78\xca\x71\x5c\x63\x9d\x3b\x18\xdb\xba\x30\x0e\xf6\x68\xed\xbf\xe2\x18\xf8\xbb\x86\xc0\xed\xbf\xc6\x18\xf8\x03\x43\xe0\x92\x08\xef\x17\x49\xf6\x77\x71\xd1\x94\x43\xed\xba\x44\xfb\xe2\x20\x8f\xfa\xb5\x7b\x63\x14\xe8\x18\x40\x6f\x7c\xaf\xff\x2a\xe5\xb1\xd3\x52\xc0\x08\x58\xbe\xdd\x7f\xff\x59\x93\xf3\xed\x5f\xa7\x67\xfe\xb3\x3b\xe6\xed\x3f\xab\x67\xce\x4b\xc6\xb9\x7f\x50\x6e\x7d\xf4\x4c\xa8\xbe\xa1\x76\xa7\x1d\xea\xef\x2c\x5b\xac\x8f\x38\xa6\x2c\x66\x5a\x15\x9d\xab\x74\x44\xfa\xec\x4b\x7d\x78\x6c\xee\xf3\xdb\xc7\x82\xf9\x7e\xaf\xb3\x9c\x5e\x65\x59\x9d\x27\xa5\x41\xe3\xfd\xa8\xb4\x24\x0b\x66\xa9\x0f\xec\x60\xa9\xe5\x0c\xe4\x8b\x24\x5d\xe4\xab\x06\xb9\xa4\x51\xfb\x57\x62\xf5\xd6\xf3\x4b\xd9\x95\xf8\xe0\xbd\x3d\x62\x23\x01\xea\x87\xcf\xab\xe3\xc3\xc7\xb5\x53\x9a\xba\xea\x2c\x2a\x2b\x7c\x54\xa1\xb1\x41\x23\x93\xb9\x3f\x6d\x02\x5a\x25\x00\xff\x8e\xad\x63\x27\xb6\xb0\x61\x3b\x6d\xdf\xfe\xd3\x77\xf8\x75\xb3\xe8\x2f\x83\x60\x3b\x8d\xa8\x15\xf9\x5f\xc7\xa7\x21\x36\x49\xf1\x96\x67\x70\xf2\x3c\xa0\xb6\xe3\x1a\x5f\x41\x03\x5e\x35\xfc\x25\xd1\xd7\xbf\xa4\xbc\xee\x48\x44\xe4\xb9\x3a\xf1\x8e\xec\xde\x76\xf2\x35\x97\x82\x34\xf2\x54\x64\x26\x51\xde\x2e\x22\xf8\xc1\x47\xd0\xda\xae\x5d\xa6\xf6\xf6\xf8\xa8\x2b\xd9\x97\xfc\xa8\xb7\xb6\x72\xb7\x09\xfb\xc4\xae\x4a\x06\xb7\xac\xe9\x0e\xcd\xf8\x2a\x9f\xf7\xe6\x4f\x7a\x07\xe5\xe7\x5b\x4a\xa1\xb7\x71\xfb\xf0\xb6\x7c\xf6\x8f\xaf\x8a\xf7\x3d\x29\x4f\xb3\x71\xd0\x36\xde\x70\x62\xfd\x60\xc3\xbf\xcb\xbe\x4f\x07\x05\xa9\x83\x0e\x7b\xa3\x87\x4c\xe5\x0b\xd8\x46\xed\xed\xd5\xf7\xbc\xe4\x02\xfb\x57\x74\xc3\x9a\x14\xe4\xa3\x75\xc5\xe7\x02\x80\x2b\xd6\xfc\x88\x87\x9a\x4f\x62\x50\x37\x37\x92\x9a\xd9\x37\x6e\x94\x71\x68\x60\xa6\xc6\xde\x32\x42\x5a\x62\x93\x16\xb4\x34\x6e\x40\x23\x01\xdd\xa2\x92\xca\x94\xa5\xf7\x18\x39\x41\xd8\x3f\x1c\xf5\x44\x61\xeb\xb1\x92\x6c\x4d\x42\x6e\x9b\xc2\x64\xb4\x1b\xd9\x7d\xd4\x16\x89\x80\x9b\xec\x97\x5e\xfc\x66\x2b\x48\x32\x91\x0e\x68\x6f\xa0\x4e\x90\x4c\x5f\xbf\xa7\xa5\x22\x4a\x95\x6d\x9d\xe8\x69\x67\x40\xeb\xf9\xb6\xef\x2e\x25\xa8\xf4\x7d\x2f\xf2\xc7\x89\xbf\x2e\xd1\x76\x46\xdb\x8b\x63\x5f\xb5\xfa\x25\x6d\xd6\xbf\x2a\xb9\x3b\xa6\x98\xcf\x68\xaf\x1e\x14\x39\xd9\xdb\x1f\xa0\x56\xe7\x74\x20\x27\x2e\xc9\x4e\x6a\x88\xe5\x3d\xcf\xd6\x9e\x4e\xc7\x45\xfc\x1a\xf6\x5a\xdd\xfa\x9f\x9d\x6f\xa7\xf7\x00\x28\x5e\x79\xfb\x29\xbd\xa5\x7f\xd6\x93\xdc\xbe\x7e\x94\x83\xa7\x12\xb4\x4b\x25\xc4\xbc\xc0\x0c\xb3\xa3\x50\xf4\xe6\x82\xe7\xf3\xf9\x44\x27\xf2\xb2\xa3\xce\x20\x4e\x46\x80\x9d\xe4\x95\xb6\x1c\x9e\x54\x06\xc7\xdc\x08\x3a\xf7\xa6\xf1\x3a\x83\x67\x99\xc1\xeb\x62\xb1\x79\x0d\x92\xbf\xe2\x3c\x65\xc1\xd3\xef\xd2\xe6\x6d\x1f\x52\xc2\x6d\xcf\xf3\x8e\x8b\x39\x25\xe5\x3f\xe1\x36\x25\x8d\x17\xb7\xb9\xfd\x91\xfb\x9c\xcb\xc4\x80\x58\x50\x42\x8e\x77\xf8\x79\xd4\x9c\x6d\xa6\x4d\x21\x0e\x62\xf3\x99\x45\x55\x41\x6e\x33\x82\xb9\x14\xff\x94\xcc\x8a\x65\x98\x8f\x44\x51\x36\x22\x6d\x91\x73\x86\x83\x0b\xde\x06\x9c\x87\xce\xa8\x29\xe4\xbe\xd6\x40\x7d\x2a\x54\xf2\x6f\x40\x7d\x3c\x85\x61\x51\x0c\xa1\x85\x50\x19\xe5\x2b\xdc\x36\x4d\xa1\x0c\xb2\x67\x13\x93\x8c\x24\x3e\xb5\x1b\x4b\x83\x81\xc8\xfc\x86\x32\xf5\x85\x6c\xbe\x36\x2a\xb8\xdb\x7b\xda\x6b\xf2\x2d\xed\x25\xed\x1d\xed\x15\x07\x81\x75\xfe\xae\xdb\xf1\xfe\xcf\x46\x79\xd5\x65\xaf\x41\xd4\xaf\x6a\xd4\x9e\x5d\x36\x1e\x5f\x39\x9e\x3e\x73\x3c\x75\xa7\xd3\x57\x7e\x7e\xe4\xe7\x37\x7e\x7e\xe2\xf8\xfc\xc6\xf1\xd2\x67\xff\xde\xfb\x3c\x3b\xed\x17\xf7\xb9\xfd\xe3\x37\x02\x39\x91\x93\xd3\xc1\x29\xca\x24\x9a\xd8\xd3\x43\xea\xb0\xb0\xed\x99\x5f\xf6\x72\x35\x75\x0e\x29\x2f\xf4\x4e\xac\xec\xed\xf5\x47\x5d\x46\x0f\xb1\x26\x00\x7a\xa1\x3d\x67\x2b\x29\xc4\x00\x30\x34\x74\x95\xaa\x01\x75\x75\x35\x48\x97\xa5\xe4\x90\xc7\x52\x7b\x88\x6d\x6d\x48\x55\x82\xe7\x76\xec\x90\x11\x3c\x11\x1e\xc8\x9e\x07\x8f\x73\xdb\xf8\x38\x2c\xac\x7d\x6e\x1e\x07\x6c\xf1\x79\xda\x5f\x19\x9b\x9d\x05\x0e\xa5\x06\x1b\x99\x48\x35\x77\x24\x85\x60\xe8\xea\x4a\x24\x62\x71\x7e\x4d\xd5\xfb\xb3\xd8\x41\x7b\x60\x81\xb3\x2d\xf6\xdd\x16\x12\x67\xca\x42\x55\xb2\x02\x23\xb3\x15\xce\xdb\x4b\x0b\x73\xeb\x01\x35\xf7\x61\xae\x3d\xa0\xd2\x01\x29\x1b\x14\xc6\x98\x6f\x46\x52\xe4\x0d\xf9\x87\x2a\xb7\x4d\x7b\xa8\x73\xd3\x16\x48\xc9\xd7\x03\x38\x8c\xa8\x30\xaf\x69\x97\xde\x1c\xe2\xa2\x9c\x5d\x82\xa2\x1e\x1d\x15\xb0\x20\x2b\x46\x0d\x2c\x15\xed\xca\xa0\x56\x3d\x90\x1d\x54\xad\xe7\x5c\xd3\xfc\x8c\xc8\x53\xc0\x20\x54\x5e\xd7\xf1\xcf\x6b\xa8\xf8\x4a\xed\xf9\xde\x27\xca\xa5\x62\xd5\xd4\x59\x1f\xb1\x4e\xf1\x50\x86\xce\xf6\xa8\x53\xdf\x7e\x62\x60\x73\x0f\x0f\x6b\xbb\xbf\xa3\xfd\x7a\x82\x70\xe7\xcc\xed\xdd\x45\x5f\x3d\xf6\x35\xf0\xf8\x65\x35\x5a\x4f\x33\x48\xc2\xac\x0d\x1f\x02\x24\xbb\x1a\x62\xab\xa0\x92\xc4\x1c\x0e\x66\x0b\xc5\x16\xd1\xe7\xe8\x3a\x09\x45\xa9\xc8\x4e\x35\xd7\x40\x2c\x43\x01\x47\x53\x3a\x66\xdd\x36\xb0\xf4\x27\x2f\x22\xef\x6d\x89\xbd\x87\x09\x96\x6f\x15\x64\x33\xc9\x18\x93\x51\xdd\x8a\x4a\x75\xfb\xa4\x23\x28\x2c\xf2\xb6\xce\x1a\x66\x20\xf9\x7d\xf5\x34\x1a\xdc\xab\x15\x16\xe2\xe8\xa1\x35\xb2\x56\xd6\x4a\xcf\x0d\x23\x42\xcb\x5c\x2b\x78\x0c\x6a\x01\x71\xbb\x24\xb1\x9f\xac\x98\x2d\x0d\x8c\x7b\x42\x8d\xb6\x09\xf4\x59\xac\x2c\xf4\x40\xbd\x50\x5b\xb1\x18\xcc\x1c\x4a\x9d\x21\x0f\x5d\x51\xaf\x32\x02\x1b\x48\xbf\xf6\x03\xfe\xbb\xf6\xff\xb8\x7c\x85\xa3\x90\xcb\x05\x47\xcd\xda\x7a\x44\xfb\xf7\x8e\x7f\x1f\xf6\x0f\x24\xd1\x6b\x50\x10\x85\xa9\x84\x96\x05\x0c\xa3\x3a\xfb\x3d\xb6\x5c\xf0\x4b\xd4\xd9\xb9\x3b\xda\xfe\x4c\x66\xe3\xaf\x7d\xfc\xff\xf9\x3f\xfe\x9f\xff\x5d\xaf\x95\xf6\x23\x7d\xef\xa9\x66\xda\x85\xef\x51\x81\x95\x97\x5e\x29\x4c\x05\xd5\x5b\x29\x8b\x62\x42\x5d\xc0\x10\xdf\xf1\x23\xd6\x6e\x7f\xd5\x8a\x83\xec\x98\x5e\xc3\x20\xd7\x46\xce\xf7\x38\xeb\x62\x0b\x02\x39\xd4\xb1\x09\x3e\xf5\x09\xd2\x74\x09\x53\xab\x39\x17\x29\x38\x94\xa2\x79\xe9\x40\xcb\x0b\xa8\x29\xc4\x29\xd7\x29\x51\xae\x07\xec\xb3\xb6\x43\x80\x60\x8b\xa3\xa2\xf2\x83\x85\x1d\x32\xa7\x2b\x40\xa0\xc0\x0b\x68\xf6\x47\xec\x7a\xbb\xc7\xe9\x35\xa9\xbd\x39\x13\xac\xcd\x9e\x8f\x68\xdf\xdd\xb3\x3e\xd5\x79\x1e\x46\x88\x7d\x01\xc3\x48\x7f\xc4\x31\xee\xa5\x8c\xc7\x68\x0b\x74\xa2\xa5\x20\x6d\x0f\xca\xd7\xc0\x09\x79\xaf\x18\xb0\x27\x2b\x9b\x84\xbe\x11\xd0\xf1\xc8\xa3\xdf\x65\xca\x92\x07\x45\x5b\xd4\x86\x16\x83\x0f\xa1\x6d\x25\xcc\x07\x42\x6b\x36\x03\xef\x54\x1f\x94\x9d\x20\x4e\x45\x13\x2b\x88\x9c\xc6\xb1\xd8\x28\xc2\x73\xd4\x12\xa6\xb9\x05\xe2\x25\xc0\x58\xfb\x6c\xfa\xb5\x9b\x7b\x3d\xc6\xa3\x6a\xba\x47\xed\xf5\xb6\x38\x71\xaf\x40\x4d\x43\x75\x85\xd0\x0e\x72\x54\x36\x23\xe5\x7e\x50\xb9\xb6\x1d\xa7\x03\x35\x98\x1f\x75\xc1\x12\x38\x1f\x71\xb4\x7b\x7e\x51\xda\xc2\xbe\x77\x09\x31\x8d\x2f\x53\xc9\x58\xe7\x28\x2b\x50\x47\x70\xd5\x27\x21\x52\x9e\xb8\x74\x98\x76\xd6\x1d\x4b\x03\xda\x92\x32\x44\x42\x88\x37\x2b\x82\x00\x8d\x3f\xd4\x97\xc9\x62\x94\xbc\x62\x3d\x66\xd4\x0f\x38\x39\xd0\x4c\x3b\x39\x90\x03\xcb\x46\xa7\xc2\x83\x48\x98\x05\xf4\xf6\x28\xff\x51\xa7\xaf\xc8\xae\x63\xbb\xa2\xfe\xb5\xa2\xa4\x17\xaa\x23\x82\xfa\x89\x75\x54\x52\xb1\x7b\x09\xe2\x40\x39\x64\x95\x1a\xa4\x29\x64\x2f\xaa\x0a\xea\xe4\x60\xf2\x02\xcc\x55\x6f\x4b\x86\xd1\x20\x10\xce\xef\xa1\x16\xd2\x73\xf7\x09\x17\x69\x6d\x10\x74\x4a\xcd\x2b\x79\x80\xa0\x66\x83\x70\xb3\xe1\xe1\x43\x2c\x65\xe3\x8e\xc0\x8a\x9f\x42\xf4\x7f\xa5\x44\x58\x09\xbd\x2c\x84\x78\x98\x17\x86\xea\x9b\x19\xaa\x80\x23\x37\xad\x75\x10\xba\x8f\xb2\x3a\x17\x5f\x11\x27\x94\x04\xae\xaf\xc0\xda\x2a\x32\x42\x01\x0d\x7d\x6c\x4a\x56\x2b\x3c\x01\xef\x6b\x8f\x00\x02\xf3\xb2\x01\x6d\xdb\xf0\x88\xfe\xb0\xd8\x81\xe2\x24\x68\x2c\xb1\x70\xb1\x94\xdb\xfe\x1a\xe8\xd1\x6a\xa6\x53\x5b\x59\x7e\x02\x16\xcf\x8d\x64\x9e\x47\xf4\x46\xed\x9d\xb6\xe8\xf4\x9e\xd1\x1e\x12\x65\xf8\x7a\xf0\x83\x25\x1f\xb3\xcd\xbe\xed\x86\x3d\x58\x8e\x08\xac\xd6\xc6\xf3\x89\xfc\x65\x95\x8e\x47\x5b\xc8\x7b\x83\x75\xe0\x07\x44\xb3\x80\xd7\x21\x16\xb9\x0d\xaf\x4a\x61\xe5\x88\xd9\x15\x85\x3f\x0b\x79\xbf\x76\x49\x18\x1e\xdf\x20\x2e\xae\x35\xe4\x22\xfb\x07\xc4\x97\x29\x9b\x7f\x16\xd0\xcd\x03\x8b\x56\x58\x48\x65\xed\x51\x0a\x68\x06\x5c\xaa\xd9\x2b\xb7\x9e\x1f\x7c\xff\xde\xfe\xb9\xbf\x36\x09\x5a\xba\x04\x19\xc7\x57\x49\xef\x36\x43\x2f\x72\x47\x51\xa5\x28\xb9\x3f\x5d\xde\x5a\xd0\x59\xfb\x06\x3c\x51\x90\xde\x36\x85\x43\x86\x12\x9f\x4d\x21\x4a\x58\xf2\xaa\x19\xa8\x67\x39\x9e\x17\x18\xd6\x8c\x55\x1b\x1d\x0f\x95\xa7\xe8\x81\x45\x1f\x51\xc6\xb8\x9b\x19\x5e\x51\x54\x2c\x12\x28\x5f\x4b\xa4\xdb\x81\xf1\xc7\x2f\x44\xeb\xd5\xbe\x01\xae\x94\x37\x4d\xc3\xc1\x38\x7d\x8f\xb8\xda\xb4\xd5\x29\x81\x57\x77\xb8\x6c\x88\x13\x75\x5a\x84\xb3\x0f\xdb\x6c\xa1\x66\xc0\x64\x40\x56\x1f\x33\xeb\xd3\xca\x04\x97\x0f\x5c\x0d\x05\xd4\xbf\x80\x94\x3f\x14\xd1\x2d\xdb\x72\xd6\x06\xca\xe5\x01\xf5\xeb\xe3\xa8\xcc\xf7\xea\xe7\x1f\xf5\xde\x72\x5d\x47\x40\x69\x66\x80\xd4\x83\x4d\x22\x09\xcb\x01\x40\x2b\x64\x41\x04\xb0\xaf\x08\x58\xc6\xc8\x63\x5e\x5b\x40\xe1\x95\x2a\xa0\x61\x99\xc5\xc7\xea\x2a\x72\x24\x65\x75\x26\x5d\xd7\xe9\xe8\xcd\x87\xe3\x06\x09\x53\xe2\x33\x5f\xf5\x85\x4b\x80\x72\x5c\xf2\xd2\x27\xf6\x12\x73\x88\x1f\x2d\x8d\xbb\xfd\xed\x11\x1b\xa3\x92\x1f\x23\x3b\x64\x8e\xf2\x31\xe2\x82\xe1\x25\x86\x51\x75\x20\xd3\x43\x49\xd9\x51\xde\x7e\x2a\x90\x64\xbe\xcb\x36\xb8\x1e\xd6\xf6\xf6\x53\xa5\xb8\xc8\xd1\xc7\xf9\x1f\x16\x92\xd8\x93\xb1\x42\xe4\x0a\xe9\x98\xaf\x52\x1f\x2d\x5d\x62\x87\xe3\xcb\x2c\x65\x1d\x85\x51\x56\x4c\xea\x22\xce\xe9\xa0\xe9\xc9\x46\x37\xa6\x4d\x4b\x2c\xc5\x9b\x4f\xae\xe0\x2e\xa1\xab\x93\xde\xcd\xb6\xc1\x4e\xee\xe4\x15\x4a\x01\x24\x5f\x80\x64\x62\x90\x49\xd7\x4d\x50\x0f\x67\x0e\x29\xd0\x75\x58\xed\x30\xb0\x1c\x68\x09\x80\x9f\x4c\xa7\x3e\xb7\xbe\xa3\x42\x1c\x28\xe2\x31\x02\x36\x15\xe8\xea\x69\x83\x53\x4d\x45\xce\x35\x0a\xe7\xdd\x9c\xac\x1b\x67\xa2\xf4\xa2\x34\xeb\xfa\x38\xa7\xe6\x0d\xe8\xbf\x9c\xc6\xe6\x3f\x6f\xdb\xb1\xeb\x38\xda\xcf\x5f\x15\x71\xc7\x8c\x9a\x40\x49\x7d\xe3\x82\xab\x13\x5a\x2d\xd9\x7c\x9e\xbc\xb4\x69\xd7\x01\x79\x15\x22\xc8\x88\x04\x38\x1c\x2b\x81\xe7\x99\xaf\x51\x00\xf2\x55\x96\x3b\xff\x23\x00\xff\x55\x21\xd8\x52\x1c\x27\x86\x02\xb8\xec\x94\x88\x8d\x8c\x87\xd5\xd6\xb8\x92\xee\x31\xcf\x87\x2d\x12\x30\x03\x73\xd5\xbb\x2d\x3c\x30\x3d\xab\x13\x38\xdd\x36\x56\x97\xda\xdd\x40\xf2\xe7\xbc\x3c\x65\x6c\x04\xd4\x46\xfd\x3a\x44\x4d\x0b\xe8\x12\xba\x1c\x5f\x65\x1d\xa5\x68\x0f\x43\xfb\x12\x1b\x78\x62\xda\x32\xcd\x53\x94\xfb\xa8\xb6\xfe\x26\x33\x75\x75\x01\xce\x4f\xa4\x3d\x46\x1d\x8b\xc8\x80\xa6\x67\x7e\xb3\xb3\x4b\x68\xb3\x2f\x42\xe2\xe9\x47\xb4\x03\x62\xcd\x66\x7c\x43\x95\x73\xf4\xd0\xc5\xfe\x94\x80\x14\xd0\x7b\x1c\xb5\x2e\xb9\xb6\x50\x5f\x50\x2a\xf3\x6d\x2e\x51\xad\xf1\x95\x20\xb1\x4d\x00\x55\xc7\x5e\xca\x05\xf2\x98\x20\xcd\x15\xfd\xbd\x40\xd3\xfe\x7f\x16\x93\x35\x3f\xec\x3e\x1b\x75\xf3\xf0\x17\xaf\xc5\xfb\x53\xd7\x6a\xad\x84\x62\xe6\x7f\xaf\x0a\x6d\xce\x07\xd9\x14\x5d\xc7\xf1\x90\x71\xac\x4f\x39\xc7\x6d\x17\x78\x7c\xc4\xac\x89\x27\x75\x24\x6b\x1d\xec\x61\x77\xb9\x1d\xb7\xc1\x73\x88\x28\xf2\xe2\x6d\x7f\xe4\xfd\xb8\x8f\x0f\x13\xd1\xef\x1f\xc6\x32\x68\x50\x1f\x99\x47\x40\x4c\x1e\xbd\xa5\xb4\x4d\x04\x6b\x1e\x79\x0a\xd0\x51\x28\x0c\xd7\x00\x89\x06\xcd\x28\xd1\x0e\x79\x52\xc8\x4e\x1a\x7f\xc2\xd7\x62\xd9\x28\x89\x83\x79\x0e\x15\x09\x3b\xa0\x50\x00\x6e\x4a\x5a\x51\xcf\xcf\x15\xca\x0c\x00\x8e\x17\x50\x74\x82\x1c\xb5\xf4\xc0\x28\x1d\x78\x71\xde\xbd\x82\xca\x2e\x2c\x87\xeb\x33\x7e\xd5\x94\xc0\x7d\x8f\x18\xe0\x72\xfd\x60\x43\x42\x71\x39\x13\x7a\xd0\x89\x05\xd6\x2c\xaf\xf6\x08\x93\x5c\x4d\xfe\xca\x2c\xcb\xc6\xab\xd4\x6d\xcf\x4a\xfc\xc5\xc6\xfd\xf4\xb0\xa6\xe5\xe3\xc3\xde\x7d\xf9\x57\x8b\xcf\x25\xc6\x34\x2e\xe9\xdf\xd3\x6a\xac\x3a\x46\xe8\x19\x96\x99\x59\x17\x00\x2f\xb8\x0a\x6e\x5f\xac\x37\xba\x74\xe5\x20\x70\xa9\x21\xed\xb7\x63\x20\x0a\xd1\x48\xfc\xc5\x9e\xdc\xd6\xd9\x51\x41\xc4\x66\x3e\xd6\xc0\xbc\x8e\xef\x14\x73\x47\x39\x33\xb0\x1e\x6a\x76\xda\xdc\xc0\x01\xd0\xf1\x23\x97\xcd\x8b\xdf\x59\x59\x3e\xee\xb3\xb1\x76\xe3\x3d\x14\x53\xd3\x07\x45\x9a\x1c\x5f\x1f\x94\x52\x66\xd4\x9b\x5f\xf5\x41\x6c\x5c\xdf\xd0\x7b\x13\xa9\x13\xd2\x06\x77\xcc\x35\x96\xe9\x1c\xdb\x13\x97\xe6\xaa\x02\x64\xad\xdf\xf3\x00\x51\xa9\xee\x0b\x45\x68\x86\xa0\x9d\xbc\x38\xb7\xd0\x60\x57\xdb\xa1\xf9\x60\x72\x90\x7e\x8f\xb9\x39\xa9\xe2\xf0\x88\xaf\x80\xec\xa0\x5a\x53\x95\x6f\xa9\x43\xaf\x60\x6a\xf5\x33\x36\xbf\xc4\x5d\x52\x59\xc9\x17\xcb\x3b\x6d\xcf\x9b\xf3\x69\xfc\xe1\xa0\x24\x2e\xc1\x1f\xdd\x17\x20\xbc\xce\xfe\x86\x7c\xe1\xfd\xfd\xf7\x06\x41\xfb\xdc\x25\x75\x1b\x9b\xb5\x87\x9e\x18\x1c\x01\x47\x48\xfd\xb1\x6b\x84\xf9\x4c\x76\x28\xd5\xfe\x2a\x59\x7b\x78\x1f\x7e\x9a\xd9\xae\xb8\xd0\x3d\xda\xb5\xa3\x10\xbb\x9e\xa1\xb6\x75\xf4\x85\xe8\x9d\x23\x7a\x5f\x89\xde\x75\xe2\xde\x97\x56\x97\x7a\xee\x84\x67\x48\xab\x77\x11\x81\x35\x08\x8e\x03\x80\x6a\x06\xd0\x0b\x2f\xe2\x9c\x2d\x5d\xe2\x9c\xe3\x2b\xfe\x1d\x91\x9a\x42\xef\x65\x47\xfe\x53\x99\x71\x1e\x78\x98\x3c\xcd\xe6\xcc\x0f\x6d\xf3\xae\x35\xaf\x15\xe2\xdc\xbe\xcb\x5a\xdd\x8f\x87\xe5\x90\x75\xfa\xb5\x10\xde\x9f\x70\x1d\x28\xe1\x84\xa9\x58\xef\xb1\xe4\xfc\x88\x63\xb6\xbb\x8c\x74\x5c\x54\x00\xa1\x52\xd5\x60\xa7\x6c\x53\x83\xaa\x5c\xa2\xfa\x7f\x8e\x03\xe9\xf6\xf7\x92\xd1\xb7\x74\xa9\xf0\x1b\x57\x51\xd9\x13\x15\x62\xb3\xde\x4a\x8d\x34\xb0\x3d\x32\x84\x02\x60\x42\x03\xf0\xa6\x3b\x13\xaa\x4d\x08\x8a\x5f\xad\x07\xb9\xe8\xdc\xf0\x91\x1a\xe5\xa9\x31\x55\x02\x59\x76\x77\x9c\x16\x63\x3c\x0c\xc1\x68\x46\xc6\x20\x07\x01\x63\x1d\xc0\xc2\x4d\x82\x92\x89\x55\x9a\xcd\xd7\xc4\xc9\x29\xb0\x6a\xa0\x61\xc2\x45\x3b\xc9\x43\x04\x30\xdf\x59\x56\xf2\x79\xa0\xfe\x15\x7e\x37\xc9\x51\x33\x19\xaa\x5d\x97\xab\x96\x0d\xe4\x39\xd6\x0d\x00\x60\xbd\x81\x73\x64\xc7\xfe\x02\x6b\xfb\x9c\x34\x9c\xd0\xc9\xf7\xfe\xd8\x65\xf7\xc8\x38\xe8\xbb\x6d\xae\x68\x2b\x88\xe5\xc9\x5c\x80\xf8\x77\x25\x5e\x39\x7b\xb7\x19\xde\xa0\xce\x07\x9b\x18\xeb\x2a\xa0\x56\xa2\x49\x9d\x92\x8d\x59\x54\x83\x34\x02\xba\xc6\x0c\x40\xd1\x6c\x70\x5b\x40\xd4\x02\xe4\x5f\x06\xc3\xb5\xb6\xbe\x21\x8c\x9e\xdb\xda\x14\x5a\x93\x8c\x40\x8f\x2d\x83\x14\xbd\xac\x9a\xab\xcd\x60\x89\xd6\x42\x1d\x4f\x7a\x79\x90\x57\xde\x56\x37\xf2\xc3\xee\x9d\x20\x74\xd8\x1d\xa5\x57\xc8\x3a\x5f\x9e\x8f\x0e\x6e\x16\x9b\x3a\x40\x20\x48\xee\x44\xc2\x98\x33\x52\x6e\x4e\x98\x42\xbd\x78\x07\xef\x32\x11\xa4\x98\x13\x41\xcf\x96\x0a\x3f\x77\x46\xef\x57\x20\xfc\x06\xd5\x5f\x14\xf3\xa5\x86\x32\xb7\xba\x43\x1a\x29\xce\x0b\x2c\xcc\x0a\xfc\x6a\xd1\xc0\x67\x18\x6f\x3f\xad\xd3\xee\x4f\xa7\x08\xb6\x64\x04\x2b\xb2\x3f\xde\x8e\xb2\x2e\xf8\x9d\x22\xe5\x92\x6f\x7c\xbe\xc1\xab\xda\xdd\x60\x91\xd4\x8e\x0e\x24\xad\x20\xdd\x91\x2b\xe6\x3a\xd0\x04\xe1\xd7\xfe\x7c\x50\x39\x26\x79\x5c\x00\xbd\x18\x57\xac\x3d\x88\x42\xf5\xca\x2c\x1e\xc8\x60\xcd\x11\xfc\xa9\x5e\x00\x0b\x9b\x5c\xc3\xfe\xff\xed\x40\x95\xc3\xfc\x27\x4f\xe1\x98\x64\x7d\x11\xd2\xfa\x22\xe7\xe2\xa8\x2e\x44\x64\xb8\xdd\x08\x61\x25\x78\x6b\xa6\xe0\xbf\x03\xde\xfa\x3c\xec\x79\x32\xaf\xc8\xfe\xea\x04\xda\xce\xd3\x2d\x7b\x90\xe7\x80\x92\x75\x77\xa6\x2a\x99\x5a\x7b\x21\x0e\x39\x0f\xa6\xf0\x11\x70\x01\xef\x5e\x47\xbe\xca\x29\x7b\x85\x30\x33\xdc\xbc\xba\x84\x69\x3a\x42\xbb\xbd\x85\xb1\x2f\xf2\x83\xc8\x86\x23\x0a\xd3\x28\xf3\x9a\x50\xe3\xe6\x4e\xf6\x86\xb8\x5d\x6d\x1e\x60\x1f\x9b\x79\x08\x20\x4c\x24\x07\xee\x06\x7a\x96\xee\x6f\x56\x64\x73\xde\xd3\xec\xe4\x84\x65\x6e\xc5\xd1\x97\x89\x5d\x45\xc1\x4d\xcb\x12\xaf\x0e\xa4\x75\xd1\x0d\x5c\x44\x1d\x62\x28\xe2\x6c\x24\x32\x53\xa8\xb4\x22\x20\xea\x06\xb0\x22\x3b\x3a\xd7\x58\x46\x81\xca\xdc\x43\x47\x25\x94\xe2\x8c\x08\xc5\x69\x18\xe7\xa1\x48\x81\x08\x2a\x35\x79\xd3\x8d\x7e\x37\x42\xe3\x08\xbd\x21\x1c\x4a\xe8\xa6\x22\x12\xe1\x61\x2c\x14\x53\xec\xc8\xbc\x3e\x02\x7f\xaf\x69\x6b\xd0\x2c\x3a\x08\xb5\x45\xca\x06\x29\xf9\xd0\xfb\x86\x45\x0c\x8a\xd8\xc8\x9a\xd9\x0a\x87\xf8\xea\x26\xcd\x69\x85\x37\x27\xd5\x99\x65\x6b\x47\x50\x50\x58\x64\xc9\x76\x62\xfc\xcc\x09\xb1\xa2\xab\x64\x1c\x14\x4d\x66\x99\x20\x4d\x4d\x30\xf3\x0c\xb1\xde\x23\x54\x7f\xf1\x1b\x63\xa3\x52\xb6\x08\x93\xe9\x30\x06\xb5\x84\x9e\x76\x0d\xc2\x49\x6e\xce\x0a\xb3\xb9\x1e\x19\x22\x71\x9e\xc7\xdc\x83\x80\xae\x01\x56\x0f\x57\x1c\xf1\x90\x5d\xec\x89\x3a\x83\xbd\xb9\x32\x38\xc9\x70\x61\xde\xb4\x8d\xc2\xdc\xdb\xec\xd4\x2b\x60\xa9\x2a\x96\xa0\xee\xd3\x20\xfd\x2a\xee\x4c\x73\xcf\x64\xda\x69\x73\x23\xcd\x38\x02\xfd\x50\x95\x45\x31\x14\xde\xbf\xa9\x6b\xc1\x73\x1c\xf1\x0f\x3c\xe2\xd5\x88\xbf\x26\x5b\x0e\x45\xdb\x9e\x40\x36\xf8\xa8\xbd\x7d\x50\x53\xce\x5a\xad\x0f\x8a\xca\x79\xf8\xaf\x45\xe5\x28\x0f\xfb\xb5\xaa\xdc\xfc\xf3\xbf\xf7\x0e\x35\xef\x5c\x97\x54\x9a\x40\x99\x6e\x1e\xec\xc2\xcc\x0e\x91\xc7\x8c\x7f\xc4\x01\xb7\xfd\x17\x14\xf6\xf2\x28\x3f\x08\x00\x5b\x9c\xfd\xdc\x3a\x1f\xf0\x3c\xef\x79\xb9\xed\xdd\x7d\x9e\x0f\xf0\xea\xcb\x5c\x63\xf1\xff\xd7\xf1\x65\x1a\x99\x61\x56\xc5\xcc\xf6\xfa\x5e\xdb\xb7\x5e\xfc\x0f\xbc\x37\x8b\x79\xcd\x05\x06\xe3\x8b\xf6\x0c\x76\x14\x5b\x82\xe6\xd8\x7a\xb6\xbf\x50\x45\x16\x76\x93\xff\x3d\xfa\x71\xf8\x19\xf7\x3d\x11\xbb\x3a\x52\x8c\xf9\xb6\xf9\xc6\x76\xec\xf2\x83\xdf\x7e\x8e\x56\xc2\xc7\x3e\xe1\xd1\xb1\x9e\xbe\xa6\xb9\xbd\x57\x5f\xf3\xd9\xa5\x7e\xd5\xa2\x9c\xfa\xf6\xb3\x8c\xf4\xb7\xde\xe0\x45\x4f\xb8\x46\xe2\xff\xef\x63\x55\x4e\x63\x7c\x31\x84\xde\x83\x0e\x5f\x0e\xa1\x33\xf6\xf0\x1f\x1a\x42\x7f\xe3\x08\xba\xfd\xc6\x10\xba\x46\xec\xff\xe3\xdf\x43\xe8\xc3\x21\xf4\x5b\x3d\xfc\x23\x88\xea\x17\x3d\xfc\x65\x31\x7c\x93\x4b\xc0\x7b\x7e\x49\x68\xd1\x2b\xa5\xe0\x10\x70\x94\xbc\x66\x22\x18\xb0\x5e\xa7\x95\x4a\xc1\xac\x76\x8f\x2a\x07\x0a\x86\x7c\x8a\x23\xa8\xe0\x10\x08\x2f\xb5\x50\x93\x5d\x26\x4b\xbe\x4b\x57\xf5\x40\xef\x6c\x7d\x19\x90\x29\xaa\xf7\x28\x3d\x0d\xfb\xad\xf7\xba\xe6\xc0\x72\x24\x84\x52\x0a\xe3\xa2\xf7\x3d\x29\xf5\x95\x44\xf4\x47\x05\xb4\x8f\x3d\xc7\xf5\xea\xe4\xdb\xa7\x67\xa3\xea\x1e\x3e\x56\x76\x96\x74\xbc\x78\x72\x21\xf1\xe4\xa0\xad\x4f\xe1\x0f\xdb\x47\x10\x0f\x24\x8b\x3d\x44\x75\x44\xae\x76\xd9\x77\x77\x45\xe5\xb7\x2f\x0a\xe2\x4b\x24\xaf\xc0\xaa\x83\x7f\x5d\x86\x45\x5d\x9a\xf3\xa4\xc9\x12\xf1\xb7\x57\xfd\xe6\x92\x5a\x98\x97\x52\x91\x33\xfb\xdd\x54\x40\x44\x56\x88\x98\x7e\x58\x1d\xba\x7d\x52\x76\x7a\x8f\x02\xb2\x5c\x50\x30\x31\x6e\x5a\x9c\x2c\xa5\x37\xa7\x2d\x4b\x77\x82\xe3\x22\xb1\x41\x43\x43\x4e\xb0\x37\x7b\xe3\xa9\xad\xe9\x1d\x6c\xe6\x27\xed\xf4\x6f\xd4\xb1\xde\xad\xeb\xdb\x10\x85\x17\x6a\x7e\x9e\xd7\x51\x30\xd3\xbd\xd3\x4c\x2e\x70\x76\x41\x78\x04\x87\x00\x56\x7b\x21\x5b\x37\x63\x88\xf5\xa8\xf1\xf0\x4a\x7c\xea\x1f\xe3\xe4\x6c\xce\x86\xb4\x15\x95\xfc\xb4\xe6\xcd\xf9\xf0\x7a\x8d\x7e\xf7\xba\xd9\xac\x8f\x22\x0e\x03\xe2\xe7\x3d\x3e\xf6\xfe\xed\x77\xc8\x0d\x8f\x8b\xc4\x05\xc5\xe2\x9a\x23\x93\xf8\xa0\x0d\xe7\x7a\x1f\xfd\xe3\x17\x6d\xa0\x77\x5b\xd8\x1e\xb7\x95\xed\x71\x34\x94\xb7\x01\x9b\xc0\x19\x79\xeb\x13\x98\x60\x3b\xd1\x96\xd1\x1b\x13\x77\x3b\x5a\x6a\x7b\x36\xe0\xbd\xee\x63\x8f\x11\x5a\xb4\x5a\xb1\x4f\xd5\x5b\x10\x2d\x65\x01\x91\x6c\x11\xfb\xec\x59\x17\x49\x12\x4a\x91\x55\x66\x18\x23\x8c\x19\x04\xee\xa2\xb4\x84\x88\xcd\x5d\x5a\xff\x10\x93\xf7\x01\xa2\x09\xc7\x4e\x44\x68\x5b\xda\xdd\x04\x94\xe7\xda\xd3\x83\xa6\xaa\x14\xb9\xf1\xbe\xf6\x14\x45\x58\xd0\x02\x7a\x1f\x24\x49\xd4\xcb\xa3\x80\xf9\xc2\x9d\x3f\x84\x47\xd9\xfd\x3f\x00\x5d\xf1\x1c\xfb\x53\xda\xe5\x3f\xcc\x9f\xa2\x8a\x5d\x7f\x69\xd2\x5c\xd2\x19\xf3\xab\x42\x93\x39\x25\x54\xd1\xa5\x95\xa0\xb5\x99\x67\x50\x16\xc4\x55\xec\x37\x85\x12\x68\xaf\xa8\x4e\x6d\xa4\xc7\x07\x67\x84\x07\x05\x33\xca\x78\xcd\x05\xec\xcf\x93\xb2\xc8\x4a\x62\x4f\x94\x8c\x10\x25\x57\xc8\x85\x78\xba\x44\xfd\xe0\x12\x64\x48\x1c\x97\xeb\x93\xa7\x82\x95\x79\xf6\xf9\x81\x3b\xd6\x10\x5b\xd0\xb1\xf4\x11\x32\x04\xf7\xed\xc9\x3f\xbf\xc2\xb3\xa0\xba\x06\xd1\xdb\x87\x97\xb0\x47\x3f\x1f\xf5\xee\xa0\xda\x82\x3d\x47\x0f\x00\x3d\x04\x2d\x77\x7b\xe6\xbd\xdd\xae\xa7\x0a\x6d\xc6\xf3\xb9\xf5\xfd\xb9\x43\x82\x3d\x2b\xaf\xa8\xf6\x57\xf0\x7e\x9c\xda\x0e\x22\x22\x7b\xd3\x21\xf0\x22\x6a\x5f\xe5\xaf\x9e\x9a\x45\x6e\x9f\x1d\xf5\xaa\x5f\x5d\x62\xfd\x33\xef\x16\xdf\x00\x65\x73\x5e\x04\xa4\x79\x65\xb0\x14\xd3\xfe\x79\xfb\x39\x0a\x18\x72\xcb\xb2\xff\x69\x89\xfb\x61\x6f\x3f\x3b\x3a\x47\x4e\x4b\x81\x74\x51\x59\x62\x4e\x2d\xe4\xd4\x96\xfd\x67\xf4\x3d\x8f\xd8\x40\x9a\x54\x51\x9a\xcf\xd1\x3f\xf3\x92\xbd\xf2\xde\x13\x6f\xb6\xe5\x7b\xfc\x48\x9c\x87\x54\xfc\x7c\x67\x6a\xdb\x24\x94\x9d\x0f\x89\x01\x2f\xa8\x3d\x3b\x2f\x91\x0b\x9d\x10\xbc\x30\x58\x9d\x28\x07\x2d\xd7\x6d\xff\x4d\xcb\xf3\x30\x1e\xc5\x0b\xf8\xf9\xb8\x30\xae\x9b\x35\xf0\x66\xc7\xc6\xb1\xef\x7c\xc6\xe9\x4a\xa7\x1b\x9c\xee\xbc\x9d\x1f\xe9\xdd\xc3\x3e\x5f\xe2\x78\xb3\x57\x1f\xf4\x92\x38\x98\xd7\xa2\x9b\x53\x6d\x3d\xa0\x1d\x79\x91\x9e\x83\x40\x1c\x99\x1b\x8f\x98\x4b\x79\xc3\xee\xa1\x9f\xee\x6e\x0a\x00\x0a\x4a\x1b\x62\xae\x36\x97\x20\x82\x54\xd2\xa3\xe3\xbb\x42\xa5\x7b\xda\x6a\xce\x2a\xe7\x25\x77\x0d\xb9\xe7\x25\xee\x1b\xfb\x8e\xfd\x50\x9c\xb8\x5f\xe5\xc5\xbb\xea\x25\xfa\x3a\xeb\xe1\xe7\xa9\x03\xf1\x00\xa2\x27\xaa\x7e\xdb\x31\xf6\x8e\x68\xdf\xe1\xf8\xfe\xc3\xff\xca\x63\x70\xc2\xce\x44\x80\xd2\x82\x7f\xe4\x32\xf0\x09\xdd\xfc\x23\x8f\xf5\xc9\x66\xdb\xe2\x3b\x73\x2e\x9e\x0d\xbd\x78\xb6\x00\xbf\x63\x0d\xde\xde\x9b\x83\x3f\xa5\x40\x7a\xb2\x94\x03\xe9\x08\x9f\xcc\xbe\x48\x65\x91\xdb\x70\xfb\xbf\x51\x97\x54\x1b\xe8\x8c\x3f\x5a\xc2\x1c\xe7\x08\x24\x0e\x4e\xc7\xd9\xe6\x19\x80\x23\x52\xdb\xdd\x4e\xbc\xae\xbd\x74\xd0\xbc\x19\xff\xfc\xfb\xdf\xfe\xb2\x39\xac\x97\x60\xde\xfc\xaa\xd2\x46\x52\x09\x23\xa7\xa5\x83\x5f\x2f\x99\x81\x3b\xda\x08\x2d\x27\x82\x30\x33\xd9\xdc\x6c\x44\xb3\xec\x0c\x76\x45\x4e\xe3\x61\x3d\x09\x84\xd8\xe9\xde\x5a\x5a\x62\x06\xf3\x70\x92\x6a\x7b\x32\x3c\xeb\xa2\x0b\xbc\xcc\x66\x4b\x56\x69\xfc\xad\x89\xae\xc3\xbc\xc6\x9c\xcd\x99\x04\x3b\x2b\xd8\x25\xcc\x1c\xca\x89\x76\x4b\x4e\xb6\x64\x44\x54\x8c\x40\xd2\x92\xa5\xb7\xf6\x1c\x7c\xc0\xd8\xfc\xa1\xf7\x3b\xee\xe7\xbf\xba\xd1\x8b\xd6\xbb\x04\xdc\xe6\x57\x08\xfb\x3c\x4a\xe8\xa9\x58\x1f\x21\x4f\x15\x38\x3e\x15\x5c\x7b\xaa\x12\x72\xd7\xc7\x54\xa7\xc8\xcf\x00\x43\xa3\xab\x7a\xc5\xa6\xec\x15\x9b\xb4\x48\x95\xf1\x73\x45\x2b\xa3\x42\x1d\x2a\xe9\x29\x28\xe0\x8f\x0a\x6d\xe2\x6e\x36\x29\x0a\x64\xe0\xcb\x6a\x1e\xc1\x16\xaf\x56\x12\x9e\xa4\x15\x7f\x12\x60\x87\xf8\x24\xd6\x4c\x3d\xb7\x43\xcd\x75\x4e\x56\xd7\xc1\x56\x4c\x4a\x1c\x95\x52\x00\x10\x94\xcf\xce\xeb\x08\x2d\x02\x92\x04\x8a\x2d\xc7\x20\x3e\x07\x2e\xb2\xba\x96\xa3\x50\xb7\xcd\x95\xda\xec\x7d\x70\x3e\xf4\xac\x05\x14\xac\x10\x7a\xb7\xc3\xf6\xda\x53\x3b\x19\x52\x93\x24\x9d\x07\x13\x21\x8b\x82\x65\xf3\x3b\x6b\x43\xce\x4b\x81\xf0\x02\x1c\x74\xce\x20\xad\xe2\xc9\x73\x25\x4c\x9a\xc8\x9d\xbc\xa3\x2c\x8f\x10\x0a\xa8\xea\x11\x7a\xe1\x16\x02\x32\xae\x68\xec\xe1\x1c\xac\xbf\xdf\x08\x1d\xe9\x25\xe6\x36\xc7\xff\x76\x00\xb8\x6a\x68\x5a\x59\x87\x1a\xd5\x69\xc4\xb5\xea\x1b\x76\x8d\x41\x58\xfb\xbe\xab\x73\x97\x28\xc4\xe5\xa6\x9f\x96\x8b\xd0\xfd\x2f\xe2\xfb\x9e\x97\x6c\x9d\x97\x6c\x7d\x3f\xef\x79\x4d\xee\xeb\xbe\xaf\xa4\x11\x34\x3d\x44\x29\x3b\x6e\x86\x9c\x94\x0d\x96\x2c\xc1\x32\xd9\x8c\x2a\xad\xa8\x42\x4d\x40\x1e\x62\x23\x62\xcb\x76\xd2\x2e\xd4\x27\x14\x3b\xb6\x0d\x18\x0e\x44\x25\x68\x8b\x0c\x08\x67\x95\xdb\x86\xdd\x77\xfc\xd9\xd1\xdf\x6d\xb3\x3b\xbe\xfd\xac\x15\x7c\x8d\x69\x11\x68\x01\xd9\x50\x4c\xed\xed\xe7\x1c\xfe\x67\x1b\x11\xcf\x3f\x3b\xfd\x5f\x4b\xcf\x7b\x10\x35\x86\x8c\xcf\xe6\x85\xfe\xf9\xce\xbd\x47\x7d\xbb\xb9\xb3\x1b\x12\xbc\xa9\xee\xef\x0c\x4c\x01\xca\xe1\xb9\x9f\x4f\xb7\xd7\xcf\x23\xf9\xe2\x97\x7d\xf5\xc5\x2f\xc1\xc2\xf9\x15\x35\x80\x39\xc3\x1d\x01\xb3\x54\x40\x50\x4e\xf4\x00\xd2\x8d\x79\x06\x4d\x20\x32\xef\x21\x43\xde\xb5\xc0\x5d\xed\x29\xe4\xb6\xc6\x31\x43\x31\xf7\xdf\x8c\x62\x90\xa1\xe7\xb1\x98\x85\x90\x51\xf7\x4f\x04\x01\x8b\xd1\x8e\x64\xa2\xeb\xd8\x79\x8d\xaa\xe4\x7d\x2b\x0b\x8c\xe3\xee\x93\x35\x90\x6e\xa3\x84\x01\xa8\x7f\xde\x10\xe6\xab\x65\x13\x71\x05\xe6\x04\x81\x45\xca\xb2\x6c\xc2\x94\xd9\x4c\xc0\xd2\x65\x54\x6b\x93\x17\x3c\xad\x12\xa0\xae\x04\x3e\xdb\x9a\x29\x83\x29\xa1\xf6\xdb\x1a\x7b\x0f\x80\x77\xf4\x19\x14\x03\x77\xd4\x90\xc5\x96\x84\x32\x83\xf4\xbe\xc6\xee\xb4\xcf\xa4\x7c\xd5\xba\xc5\x39\xdc\xd7\x8d\xa0\x94\x2f\x3f\x76\xa9\x20\x19\x6d\x8b\x55\x6d\x50\xbb\x8e\xae\x56\x73\x4c\x89\xac\x99\xab\x75\xfe\x14\x0a\x69\x44\x73\xdb\x90\xd3\x9d\x6a\x4b\xa4\x8b\xe7\x6c\xe2\xc1\xd7\xce\xd5\x12\x95\x6d\xc0\xa0\x90\xee\x7d\xc7\x77\xfb\x5f\x49\x44\x20\x88\x94\x26\xf7\x97\x37\x52\xb0\xa6\xbe\x50\x32\xd4\xc6\x99\xa4\xb2\x44\x85\xbc\x4a\x75\xe9\x5d\xf5\x02\x9e\x88\x21\xa6\x2e\x64\xe8\x25\xf5\x0d\xf0\x11\xc6\x01\xa8\xa2\x12\xaa\xed\xeb\xd3\xa6\xb7\x57\x7d\xef\x1a\xff\xfc\x52\xd8\x26\xf7\x12\x46\x9f\x6b\x6c\x8c\xf4\x80\xb3\xd9\x49\x49\xf7\xfa\x47\x6d\xe2\xa3\x2a\x39\xce\xc5\x36\x9a\xc2\x12\x6a\xc1\xf3\xa5\x5e\xf6\x76\x54\x2f\x79\xb5\xf2\x51\xc7\xc4\x5c\xed\x44\xfa\x32\x64\xb0\xbd\x0f\xc4\x44\xa4\xba\xc0\x91\x2d\x16\x73\x57\xdc\x76\x7d\x75\x70\xcb\x08\x60\x44\x93\x74\xcb\x3b\x0e\x07\x59\x6f\x20\x23\xcb\x0a\x65\x4a\xa8\xe2\xaf\x10\xc0\x68\x29\x14\x59\x6c\x42\x5b\x2b\x89\x4c\xbb\x04\xad\xf3\x5e\x14\x65\xa2\x28\x42\xe9\x5c\x38\x97\x41\x6e\x79\x7b\x11\x41\x6f\x2b\x72\xc4\xa4\xcb\x0a\xc8\x8f\xf5\xda\x5c\x36\x09\xe6\xce\x4d\x84\x7d\x75\xe0\x02\x45\x08\x21\xdd\x65\x19\xf9\xd4\xce\x70\x3d\xc1\x45\x2d\x8a\xd7\xad\x60\xb1\x61\xf6\x1f\x89\x6b\xb4\x10\x40\xc1\x04\xc6\xef\xd6\xf4\xdf\xc7\xe6\x70\x23\xb5\xcd\x5e\xf4\x55\x1c\xdf\x8a\x48\x3e\x1f\x9b\xeb\xb2\xaf\xaf\x20\x37\x72\x35\x1f\x57\xbb\xc7\x2f\xbe\xad\xf5\x49\x7f\x84\x93\x70\x2d\x5e\xea\xb4\xb9\xef\xde\x8f\x3f\x5d\xe3\x7c\xed\xe3\x8e\xc7\x43\x9c\x1e\xcd\x91\xf6\x34\xc9\x2b\x03\x23\x34\x09\xb7\xa8\xb0\xa8\x9b\x0d\x24\x84\x64\x4a\xdd\x62\x03\x60\x75\x6c\xfe\xf3\xb6\x1d\xbb\x8e\xa3\xf7\xf3\x15\x36\x1e\xfe\x6e\x7f\xb6\x03\xed\xb8\xc6\xea\xa3\xb8\xff\xdc\xff\x1e\xf7\x03\x23\x4f\xfc\x57\xd1\x12\xfc\xdd\x32\x3a\xbd\xc6\xbb\xff\xcf\xa7\xea\x43\x1e\xa1\x6b\x5e\xb1\xa2\xd4\xa0\x33\xc4\xa1\x0b\x42\xd4\xb5\xca\x1a\x0b\x61\x6f\xc4\x52\xf4\x64\x8f\xcc\x11\xee\x70\xd2\x69\x66\x5b\x29\x21\x13\x30\x49\x46\x7a\x20\xdc\x42\xef\x3f\xea\x92\x6b\x28\x8a\xc0\x48\x0e\x71\x00\x44\x2d\x92\x03\xc1\xd4\x8c\x59\xa0\x94\x19\x72\x1e\x70\xae\xb3\xad\x4b\x7d\x9d\x50\xb1\x0d\xd6\x24\x19\x25\x34\x65\xaf\xe3\x09\x6a\x2d\x4e\x94\x8a\xa4\xfc\x2c\xac\xb3\x19\x62\x1e\x97\x18\xa8\x16\x11\x29\x41\x47\x09\x52\x64\xd1\x56\x42\x4e\xe9\xc6\x18\xce\xe8\x0b\xd3\x13\xd2\x00\x45\x77\xa1\xfd\xce\x82\x40\x4a\xed\x3f\x47\x7b\xef\xe4\x19\xe8\x79\x51\x5b\xa9\x25\x23\xa4\x0e\x6e\x22\x90\xd9\xa3\xf0\xc4\xbc\x8d\x32\x50\xcd\x97\xa1\x1f\xa1\x20\x36\x8a\xff\x1f\x7b\xef\xb6\xe3\x48\x92\x24\x0b\xbe\xf3\x2b\xec\x07\x2c\xc7\x54\xed\x8e\x1d\x0c\x70\xba\xfb\x3c\xc6\x37\x2c\xea\x76\x96\x0f\x8e\x5d\x38\xc6\x97\x0f\xf1\xf5\x0b\x15\x51\x73\x32\x92\x11\x99\x51\x55\x59\x33\xbd\x73\x06\xe8\xae\x60\x92\x4e\xa3\x5f\xcc\xd4\xf4\x22\x2a\xd2\x06\x4c\x11\x65\xfd\x01\x00\xd9\x28\xf9\xa3\x59\xb7\x6c\x06\x2b\xed\xb6\x6f\x02\x24\x9d\xe1\xbf\x59\xc4\x2a\x23\xa1\xff\x27\x51\x79\xc1\xf6\xb8\xaa\xe6\x02\x1d\xfe\xc7\xdf\x15\xda\xd1\xea\x32\xea\xd4\x63\x78\x78\x79\x7e\xfe\x7a\x79\x69\xb6\x6b\x35\xdd\x89\x16\x34\x1f\xa4\xc9\xc6\x4e\xf5\xec\x14\x65\xae\x13\x95\xab\xeb\x44\xb1\xa4\xe8\x16\xc1\x8b\x84\x50\x77\x1d\xab\xa2\x08\x74\xed\x80\x86\x53\xce\xed\x61\x38\xb3\xb1\xc3\xdb\xd9\x84\xf4\xd3\x02\x84\x3f\xc3\x53\xc0\x8a\x96\xb0\x5b\xfa\x3e\xf0\x44\x9f\x33\xc0\x27\xbc\x61\x8c\x04\xbd\x70\x04\xee\xef\x17\xcd\xdb\x7b\xa5\x4a\x1e\xfe\xb6\x18\xdf\x9e\x91\xe5\xaf\x2f\x22\xd9\xa2\x57\xf4\x6c\x57\x6f\x2e\x98\x69\x65\xaf\x6d\x3b\xab\xca\xee\x58\x17\xa6\x6c\x3b\x65\x40\x46\xf0\x82\x81\x0e\x36\x94\xaa\x59\x30\xae\xa3\x79\x8b\x59\x7f\xcf\xe9\x22\xd4\xc9\x2e\xa3\xd0\x90\xb2\xd3\x42\x7c\x56\x9e\x9c\xb1\x45\x88\x3e\x02\x26\x4d\x65\xaf\x39\x28\xa0\xa2\x25\x1f\xaa\xa1\x58\xe0\x56\x94\x35\x0b\x8a\x55\x10\xa5\xac\x60\x57\xa2\xcd\x85\x0a\x7e\xdf\xc9\x0a\xe6\x5a\x1f\x23\x83\x37\x96\xbc\x4d\xae\x26\x2b\x2e\x6f\xe2\xe9\xad\xc1\xec\x30\xb6\xdd\xa0\xe9\xa8\x41\xf3\x6e\x51\xa0\x4c\x0d\xb9\x40\x5f\xf0\x1e\x88\x22\xdf\xc7\x82\xf9\x7c\x00\x6f\x22\x51\x82\x9a\x18\x11\xcd\xe4\xd3\x00\x08\x0a\xe4\x2b\x24\xdd\xb8\x9c\x02\xcd\x9a\xca\xc1\xb4\x0d\x7c\x90\xfb\xab\x87\xcf\xef\xdf\x3b\xee\xa3\xf1\x95\xbd\x30\x77\x3c\xdf\x55\xd7\xec\x1b\x75\xd1\x81\xc4\xfb\xab\xfb\xa7\xf1\xfe\x95\xb8\x86\xf9\x8f\x80\x3d\x5c\xfe\x2a\xe4\x90\x3e\x27\xc1\x9f\x89\x3d\x4a\x5a\x55\xd1\x6c\x6e\x3f\x4a\x0f\x8d\xf6\x49\x52\x28\xab\x55\x15\xf8\xc8\xbb\x68\xbf\xb7\x1d\xfa\x01\xfe\xac\x0b\x79\x8f\x78\xd2\x44\x49\xc6\xe6\xef\x9f\x4a\xdb\x0f\xc7\xbe\xbe\x4c\xb1\x18\x22\xaf\xe5\x97\x13\xb5\xbb\x97\x7a\x30\x6b\x74\xd4\x9f\xdc\x62\x6e\x1d\x08\xdb\xd8\x29\x95\x5c\xbc\x90\x29\x42\x19\x04\xbb\x2b\x28\xa5\x8c\x00\x26\xb8\x4d\x50\xd9\xcf\x73\x13\xc8\xd9\x6d\xcc\x41\x14\x04\x2f\x04\x6a\x9b\x27\x0f\x60\x76\x41\x39\x84\x2b\x19\x68\xdc\x1d\x27\xc4\x56\xf1\x0c\xa5\x4e\x9d\x44\x47\x02\x56\x99\x19\x3f\xd4\xbe\x6b\xb0\xa8\x6b\xf6\xd0\x64\x6c\x35\x14\x69\x1b\x45\x24\x5a\xd9\x48\x65\x05\x9d\x48\x10\xef\xa1\x92\x4a\x55\x09\x82\x2f\x27\xb5\xf2\x6d\x23\xe9\x60\x48\x80\x1a\x04\x54\xe2\x7d\x83\x86\x22\x65\xc0\x41\x25\xa8\x45\x44\x30\xd3\x98\x7c\x20\xd1\xb1\x87\xa3\x73\x6e\x2a\x12\xf2\x90\x5d\x73\xb0\x28\x53\xec\xcf\xde\x01\x12\x4d\xd0\xe2\xdc\x0a\x48\xfd\x54\x2e\x7b\x0f\x90\xa0\x03\x9c\xd4\x7e\x08\x2a\xf1\x62\x6f\x4b\x0e\xc8\x57\xbf\xbe\x54\x29\xa1\xe4\x8c\x5e\x76\x1b\xcd\x95\x70\xb5\x1e\xcd\x35\xfe\xc7\x86\x01\x2b\x76\xc5\x99\x03\x7b\xe9\xa9\xb4\xd1\x49\x1b\x18\x21\xad\x50\xc9\x4a\x0d\x0a\x8d\xc6\xb5\xa7\x20\x27\xcc\x15\x5a\x41\x6c\xb5\x1b\x20\xfe\x10\x2d\x21\x63\xdd\x65\x34\x28\xd7\xb9\x67\x61\x04\x8a\xcc\x12\xe5\xad\xed\xf6\x40\x60\x05\x4d\x4b\xc5\x95\xf7\x97\xe3\x8e\xfe\xa6\xcc\x8c\x14\xc4\xfc\x81\x9f\xcd\xa1\x35\xb9\xec\x76\x39\xa1\x07\x39\x7a\x28\x5b\x0e\x6a\xa7\x3b\x41\x19\xf0\x1d\xa9\xad\xa6\xcf\x25\x88\xdf\xbe\xd1\xbb\x50\x53\x09\xb5\xe8\x15\x19\x16\x09\xda\xd0\x41\x8a\xee\x56\xd9\x53\x20\x4f\x94\x3d\xcc\x62\x5e\x38\x76\x93\x9a\xaf\xb1\x96\x5b\xcc\x63\x5c\xab\x9a\xbf\x44\x27\xa9\x42\x38\x4c\xf2\x78\x7d\x99\x50\x06\x92\xb1\x01\x84\x71\x07\xda\x70\xef\x75\xa8\x72\x94\x74\x35\x27\xec\xbe\xd7\x7c\x21\xf5\x01\xab\x34\xb7\xa6\xd7\xa8\xe0\x0e\x82\x28\x2e\xa3\x32\xcc\x7f\xdc\xf2\x6b\xd4\xd6\x77\x4f\xbc\x42\x84\x57\xc6\x01\xf5\xed\xba\xd5\xda\x42\xaf\x7d\x9f\x36\x7f\xb4\x07\x29\xd7\x9c\x17\xce\x0d\x40\xdd\xcb\x81\x18\x0f\x49\xc7\x91\xfd\x6a\xa3\x00\xbd\x4c\x2d\xfe\x0c\x03\xa9\x9e\xcf\x00\xb1\xc8\x7d\x5b\x2c\x38\x51\x88\xc3\xdf\x78\x81\x50\xab\x08\x5a\x0e\x7c\x76\xd5\x36\x76\xea\x1b\x65\x2e\xcf\x09\x9f\x29\xe6\x64\x4e\xd6\xcc\x67\xe5\xcc\xe6\xa1\xeb\x83\x1e\x11\xfe\xf6\x97\x53\xe2\x08\x20\x66\xef\x0d\x49\xf0\x79\x4e\x7f\xe5\x1a\xab\xec\x79\x84\x42\xc8\x77\x60\xef\x7c\xf1\xb4\xfc\xa1\x12\xe6\x38\x26\x68\xe2\x36\xa1\xe0\xc7\xe0\x0f\x29\x92\xf6\x58\xa1\x2d\x21\xad\x80\xa6\x1d\x46\x99\xe2\x2c\x32\xe0\x0a\xb8\x96\xbc\x17\x8a\x54\x42\x5f\x3b\xf5\x65\x37\x71\x1c\xbc\x85\xe6\x92\x7d\x1d\x18\x1e\x15\xcd\x9f\xbf\xb0\xf3\xb2\xca\x0f\xb9\xa8\xfb\x35\xa1\xb8\xe7\x57\x95\x98\xb1\x7d\xbc\xae\xcb\x1f\xb8\xb0\x9c\xca\x8f\x7c\x62\xe7\xa5\xfd\xd0\x0b\xfb\xd4\x75\x5d\xd8\x48\x8a\xeb\xfa\x6e\x37\xf4\xff\x78\x2a\xf2\xfd\xf4\x0c\x75\xbb\x6f\xce\x0d\x79\x8f\x4a\xe6\x60\xd8\xe9\x3a\x9c\x53\xa6\x63\xaa\x81\x37\x20\x80\x77\x48\xd9\x22\x85\xd0\xed\x80\xe2\x36\x38\x11\x09\x65\x2f\x28\x87\xc9\xd9\x87\x02\x89\x67\x4f\xc8\xc5\xea\x52\x48\x29\x90\x87\xc1\x6c\x33\x2e\xd2\xb7\xda\x4e\x22\xa1\x08\x97\xc9\x3c\x34\xc8\xea\xec\x80\xc2\x63\xdf\xec\xa0\xa2\xe3\x9f\xdd\x4e\xc7\x85\x77\xfc\x0b\xfe\x7d\x1f\x0f\x84\x5a\x42\x02\x06\xb6\x38\xfa\x39\x1c\x7e\x52\x17\xdb\x5a\x52\xe0\xf9\xce\x30\xc2\x79\x2d\x87\x5f\x1d\x2f\x76\x57\xf3\xf4\xed\x1e\x1c\x7e\x47\x70\x7f\xa0\x2d\xec\x3e\x31\x6b\x15\x50\x09\x06\x2f\x82\xdd\xb2\x81\x32\xe0\x58\x57\x8c\x24\xe9\xd8\x59\xbe\x00\x7b\xdf\x97\x25\x5b\x8b\x9b\xd3\x1a\x49\x3b\xfa\x19\x20\x4c\xa8\x5e\xb1\x5f\x08\x6e\xf4\x74\x6e\x3c\xdb\x71\x41\x6a\x8c\x8d\x1b\x14\x75\xe5\x58\x7f\xfd\x83\x1d\x79\x49\x55\xef\xa2\x95\xbd\x65\xf4\x8d\x4a\x87\x43\xde\x2f\x9b\x39\x23\x3b\x82\xd0\x11\xfc\xe4\x08\x33\xb2\x93\xce\x16\x2e\x86\xf3\x82\x8e\xf3\x2a\x5f\x5f\x7a\x6f\xa1\xbf\x5f\xea\x64\x13\x45\x81\x7a\x6f\x0f\xfc\xdf\x4c\xab\x0a\xdc\xc3\x24\x24\x12\x8e\x09\xb0\x47\x0f\x08\x24\x87\x58\x99\x53\x71\xef\x53\x93\x13\x07\x88\x0d\xc3\x51\x43\xf6\xd7\xf6\xaa\x1e\x6a\xa7\x2e\xda\x3a\x8f\xf7\x86\xdf\x21\xd0\x67\x66\xde\x22\x8c\xae\x17\x94\x47\x03\x74\x46\xbf\x77\x32\xc2\xb0\x2d\x85\x67\xb6\x6f\x8a\xbf\x3f\x9e\x90\x48\x1e\x21\xcf\xf1\xfd\x33\x9a\x66\xbb\xbd\x0b\x43\xd3\x38\x0a\x19\x6d\x56\x62\x15\xaf\xce\x4f\x3f\x71\x96\x69\xd1\xc6\x21\x5f\x50\xe6\x41\x86\xaa\x72\xc4\xf3\xc5\xfa\xe8\xf2\x74\xde\xdf\xb7\x25\x4f\xf5\xde\x9f\x9e\xe1\x8f\xd2\xdb\x1d\xfe\x88\x12\xda\x03\xf3\x4a\x74\xea\x15\xd4\x14\xd6\xdf\xf5\x81\x53\xb3\x38\x51\x4a\x5c\x7f\xf9\xf6\xeb\x6a\x0f\xf9\x91\xc3\x8d\x56\x7e\xd4\x70\x52\x3a\xae\xf6\xf2\xc3\x06\x9c\xe3\x87\x5e\x2f\x4e\xf0\x47\x5e\xb0\x9d\xdf\x68\xe5\xc7\x5e\xb0\xe4\xde\x7e\xd4\x80\x10\xae\x9a\xd4\xdb\xf6\xe6\xea\xc7\x4e\xf2\x3b\x7d\x86\xd3\x69\xf8\x1f\x7f\xf7\xab\x4e\x74\x4f\x2e\x3f\x0d\x77\xf9\xc3\xe3\x79\x41\xff\x47\x9e\xde\x0f\x1c\x0e\x37\x4f\x89\x7e\x7d\x6f\xbc\xcb\xef\x1d\x90\x92\x1e\x3f\xf8\x71\x7c\xe3\x04\x7f\xef\x78\x66\xb8\x3e\x73\x7e\x97\xdf\x75\xc1\x3f\xf0\x89\xe0\x04\x7f\xe0\x78\x7c\x20\xbf\xe3\x0e\x5e\x3e\x77\x0b\x7f\xdc\x33\xf9\xfe\x86\xf4\x04\xa1\xf9\xe9\x9b\xa2\x69\x88\x3b\xe7\x07\x7a\x0f\x6f\xbb\x08\xde\xd9\x5e\x4f\x38\x56\xd6\x14\xd2\x9f\x1e\xa4\x99\x67\x59\x37\x05\xf8\xb7\xb6\x0d\x78\xb8\x99\xb6\xe8\xbc\x63\xbe\xe3\x8d\xf2\x27\x7f\xe9\xf2\x22\x45\x64\xcd\x1c\xa2\xc7\x3c\xbc\x79\xa8\x11\x9e\x3c\x7e\x4c\x8c\xa1\x3c\x0f\xb7\x13\x1a\xa2\x67\x76\xad\x16\x67\x32\x89\x28\xfb\xb1\x1b\xb4\xd0\x63\x8f\xfd\x33\x00\xb5\xf7\xdc\xc5\xc7\xb3\x5f\xe5\x05\xb6\x81\xb0\x2b\x64\x87\x94\x2d\x4e\x9b\x1d\xba\x70\x21\xe9\x8b\xa2\x5f\x1a\x64\xd7\xd0\xf9\x6d\x64\xfd\x31\xef\x0e\x57\xd6\x59\xb2\x0f\xab\x9f\x57\x06\x71\x0c\xe6\xd7\x93\x6d\x1d\x7f\x02\xde\x5a\xff\x88\xfe\x2f\x1e\xc7\x37\x3f\xf3\x14\x10\x35\xf5\x40\x09\x77\x62\x1e\x34\x07\x19\xe5\x00\x19\x96\x66\x67\x25\x2c\xac\x65\xe6\x33\x9b\x29\x40\x50\x68\xc6\xf1\xd1\xbe\xc0\xdb\x8d\x63\x68\xeb\xbc\xdd\xe9\x73\x13\xe1\xf2\xfe\x9c\x13\xb9\xef\x39\x9f\xb8\x96\x69\x93\x00\x69\xe2\xca\x1c\x36\x20\x14\x0d\xd1\xdb\x24\x46\xc6\xdc\x4a\x02\x86\x91\x76\xab\xe3\xf3\x37\x0a\xf9\xdd\x0c\x66\x43\xb0\x3a\xa4\x7c\x9c\xf2\x36\x4b\xdd\xe6\xf5\x45\x6a\x1f\x61\xce\xbc\x7b\x45\x3f\xb2\xa4\x1f\xbd\xa6\x1f\x51\xd4\x47\xdd\xc3\x3c\x11\x17\x12\xa1\x40\xae\x67\xa9\x72\x72\xb1\xfb\x01\x90\x7d\xd0\x59\x11\x43\x38\x13\x44\xd1\x43\x34\x94\xbe\x4b\x47\xa3\x55\x0e\x5a\xe9\x69\xe8\x0e\xd6\x32\xb1\x30\x13\x54\xce\xc8\x17\xf6\x61\x93\xa9\x03\x4e\x80\xf3\xf9\x52\xfd\x8c\x98\x74\x2a\x64\xec\x5c\x27\x85\x12\x67\x42\x19\xab\x08\x6e\x9b\x66\xb8\xe2\x3d\xe4\x99\x01\xf4\xe0\x89\x7c\xf1\x53\x41\xcb\xfc\x2e\xcd\x62\xca\xa2\x5e\x8e\xc1\xe9\x80\x39\xa4\x92\x95\x22\x23\x4b\x50\x3e\xe3\xb4\x3f\x21\xcb\x7e\xfa\x16\xaf\xa2\xa4\xac\x98\x6b\xe8\x44\x07\xba\xa7\x56\xd0\xea\x80\xd2\x61\x38\x1d\x91\xdd\x50\xd6\x7c\xee\xad\x45\x4f\xa0\x03\xa7\xb4\x01\x98\x67\x6e\xd0\x58\x60\xb5\x58\xc0\x35\x90\xc5\x82\x43\xc8\xf2\x20\xd3\xec\x83\x5b\xf0\x59\x73\xc0\x0f\x2f\x99\x1d\x4c\x59\xa0\xa4\x5b\x80\xce\x60\xf2\x78\xda\xac\xd3\xd0\x90\x05\xc9\x01\x2a\xea\x78\x33\x3e\xd8\xd6\xc1\xe6\x0a\x18\x60\x26\x63\x52\xad\x3b\xa5\x68\xf9\x0f\x02\x3d\x72\x09\xeb\xe8\x63\x0d\xf0\xd0\xb4\xf5\x24\x43\x21\xbd\x80\x06\x1a\xf1\x3b\xf8\x30\x9d\x73\xaf\xe7\x40\x7e\x54\xa0\x9e\x70\x7e\x60\xe8\x4d\x44\x42\x4a\xdf\x31\xa8\x27\x92\xfd\xef\x8e\xb5\x24\x84\x58\xd5\xe4\xfc\xac\xa4\x10\xeb\xb8\x64\x18\x0a\xa2\x2f\x08\x34\xac\xc5\xc9\xc8\x6c\xfe\xe7\x19\xe2\x24\xe3\x19\x5f\x42\x4f\xb5\x87\xfb\xa1\xe4\x7b\xc6\x08\x17\x30\x95\x91\xe4\xe8\xfc\x9d\x23\x9e\xbf\x7e\x8d\xa4\xaa\x43\x3d\x32\x94\x8d\x04\xc4\x7d\x8b\x8a\xca\xac\xb7\x6c\xa2\x82\x30\x91\x1c\x27\xef\x59\xed\x21\xd7\x0d\x98\xb4\xec\xea\xcc\x98\xfe\x2c\x2f\xea\xc4\x3d\xdc\x00\xa5\x94\x89\x96\x08\x6d\x58\x72\x52\x99\x0f\x0b\x8a\xac\x98\xb0\x9c\x98\xcd\xe0\x66\x30\x1b\xe3\xc4\x28\x83\x5d\xbe\x38\x2e\xf7\x60\xae\xae\xa7\xc3\xe1\x05\x8d\x72\x02\xbe\xbb\x61\xb5\x8c\xdd\x6c\xe9\x28\xf6\x43\x41\x92\x5c\x6c\x7b\xa8\x2e\xa8\x20\xd3\xc9\x31\x5a\xd9\x91\x7c\xa1\xb9\xe2\x6e\x05\x02\x15\x18\x39\x58\xe5\xb5\xa5\xd5\xba\xc3\x64\x85\x69\xc6\xca\x99\x31\x54\xc0\xe9\xcf\x5b\x3e\x42\x59\x14\x0a\xd1\x6f\xb7\x39\x45\x19\xda\xd8\x75\x43\xe7\x14\xa8\xc7\x04\xc6\xa1\x10\x5d\x4b\xfd\x24\xdc\x1f\xaf\xfc\xc9\x6a\x07\x41\x7e\x9c\x19\xb9\xba\xc0\x60\xbc\x4f\x91\x37\x2a\xf2\x4e\xb1\xa0\xa4\x81\x90\x16\x3d\xdb\xa4\x2c\x80\xbc\x60\xfe\xa3\xe5\xc7\xbe\xdf\x13\xd1\x08\xad\xee\x1d\x6c\x47\x76\xbb\x20\x74\x85\xad\x67\x40\x8a\x1c\xfa\xf2\x84\x70\x08\xb3\x4e\xb6\xbe\xb0\x6d\xa3\x62\xa6\xc5\x79\x3f\x5a\xda\x63\x85\x56\xdc\x64\x39\xb8\x15\x27\xf3\x42\x32\xdd\xee\xdb\x9d\x5b\xcb\xd7\x40\x22\xc9\x0a\xf0\x1b\x23\xd4\x84\x91\x51\xe9\x9e\x4e\x24\x04\x26\x6b\x9b\x1c\xb9\x86\x5a\x43\x41\x17\x72\x2c\x40\x2b\x42\x4b\x1c\x36\x84\x2c\xfa\xf6\x30\xfa\x1e\x69\x85\xec\x8e\xa4\x13\x74\x97\x30\xdb\x7d\xa3\xc2\x34\x02\x10\x09\xb3\x9e\x3a\xfb\x1d\xb6\x89\xd8\x84\x45\xbc\x83\xa5\x25\x23\x4c\x5b\x4c\xf3\x2c\x4f\xe0\x75\x26\xc9\xcf\x79\xdc\xb1\xbe\x6a\x73\x6b\x2c\x26\x66\x5b\x50\xeb\xf7\xae\xed\x0a\x9c\x58\x54\xd6\xcd\x37\x05\x02\xa7\x03\x0a\x22\xa4\xa1\xeb\x41\x67\xe8\x94\x28\xab\x30\x28\x9f\xb0\xea\x4f\xe8\xd1\x9f\xbe\x49\x0e\x9b\x6a\x7b\xd8\xf8\x3f\xec\x65\xf4\x7d\x39\xae\x8d\x39\xae\x9d\xf9\x1d\xe5\xb9\x4f\x8c\x35\x33\x32\xe5\xe4\x61\xaa\xc3\x35\xc9\x4f\x9f\xe1\x74\x19\x5e\x5f\x46\xae\xab\x70\x4f\x06\xb7\x47\xef\x28\x9e\xee\x51\x3c\xfd\xa3\xf8\xe0\x20\x7d\x7c\x26\x97\xfb\x65\x0d\xf7\xf1\xdc\xed\x7b\xf4\xfa\xde\x38\x7d\x5f\xfb\x7c\xa4\xa6\x71\x42\x98\xb5\xbb\x91\x24\xcb\xf9\x25\x95\xb2\xfe\x68\xba\x51\x12\xd7\xb2\x67\x93\x54\x3e\xb9\xdb\xd2\x3d\x4e\xaf\xdb\x29\x84\x56\xd3\x73\x3c\xbb\x9e\x63\x7f\x74\x8e\x1f\xda\x50\x8f\x37\x57\xb6\xdb\xaa\x4a\xe1\xb1\xcd\xe3\xa1\xb3\x63\x37\x3f\x23\xd0\xf3\xbd\x90\xae\xa5\x15\xa7\xe6\x4b\xf4\x2a\x6b\xd9\x73\xb5\xa3\x6a\x06\x0c\xe4\x28\x25\xb4\xfb\x16\x97\x17\x61\x25\x02\x04\x77\x69\xe3\x83\x4f\x1b\x97\x53\x1b\x97\x57\x1b\xef\x6e\xed\xeb\x4b\x9d\x12\x6a\x93\x4d\x69\x94\xda\x16\x6b\x87\xbe\xc1\x74\x6d\x25\xe5\xde\x21\x2c\xce\x8a\xda\xb6\x31\x82\x80\x7d\x49\x83\x1f\xa2\xf3\xc0\x7f\xcd\x03\xa0\x10\x49\xd9\x04\x7b\x73\x1b\xbb\x1f\xc3\x91\x0e\x2a\x3f\x58\xe0\xc4\xbe\x8b\x7c\xd9\x68\x10\xeb\x86\x84\x7a\x97\x9d\x50\x63\x9b\x3a\xb3\x06\xad\x63\x9b\x12\xa6\x6c\x9a\x7a\xd0\xd4\x51\x20\xd0\x90\x13\xa4\x63\x70\x6a\x9f\x58\x81\x4f\x18\xda\x9f\xce\xee\xa9\x81\xfa\x10\x94\x20\xc0\x38\x08\x41\x32\x77\x0c\x91\x35\x96\x05\x8f\x66\xdd\xd3\x5e\x12\xe5\x4a\xd2\x76\x7a\x7b\x5e\x53\x89\xab\x8e\x10\xd5\x5b\x37\xd1\xed\x90\x60\xac\x0b\x4b\xf4\xe8\x42\x23\xe7\xff\x00\xc4\xa7\x17\xf8\xd0\xa2\x65\xd7\x11\xa4\x78\x71\x43\x07\x94\x2b\x59\x58\xf7\xf2\x06\x36\xa1\xd7\x17\xc9\x75\xe9\xfc\x0b\x67\x73\xe7\x46\xa6\x08\xb1\x60\x08\x07\x5c\xa5\xb1\x47\x94\x8c\x23\x9e\x70\x37\xdf\x20\xe8\x65\x07\xeb\x1c\x18\xf1\x24\xd7\x03\x65\x57\xe9\x28\x8e\xe0\xb1\x98\x2f\x7b\x67\x4d\x43\x5b\xcd\x1e\xc9\x58\xe5\x2c\xd1\x8e\xe8\x61\xad\xcb\xde\x3b\x97\x8f\x0c\x76\x8c\x94\x16\x46\x5a\xf8\x00\x25\xfb\x5e\x9f\xac\x56\xa0\x67\xe7\x40\x5f\x08\x36\x2e\xf0\x5b\x11\x31\x47\x97\xa5\x42\xbb\x97\x6b\x50\x0e\xf0\x39\x99\x29\xdf\x23\x65\x63\x0a\x82\x00\x54\x97\x51\x37\xa4\xe3\xe2\x38\x67\x3d\xe1\xb8\xda\xbc\xb2\xc4\xb5\x01\x55\x0a\x49\x17\x5c\x17\xd8\xf6\xc6\x09\x65\x64\xe8\xc4\x20\xba\x9e\x7b\x27\x68\x28\x8b\x73\x1b\x30\x4a\xee\x30\x08\x63\x04\x3f\x3d\x8b\x03\x9c\x98\xa9\xec\xe0\x9c\xb6\xfd\xbf\xe6\x83\xf4\x4f\xa2\xed\xf0\xb0\x2c\xef\x88\x13\x00\x48\x68\x6c\x7f\xf4\x57\x3b\xa6\xb4\x94\x20\x63\x17\x19\x00\x1b\x6a\xb7\x0d\x1b\x90\x3c\x68\xde\xd8\x47\x81\xd5\x3c\xd9\xab\x3b\xa6\x30\x08\x5f\x6a\x20\xe4\x18\x8d\x13\xa2\xe9\x16\xa7\x63\xe3\xcc\x16\x0d\xa7\x9f\x66\xb3\x3f\x35\x45\xf1\xe6\x15\x87\xe1\xa0\xe4\x07\x80\xfa\xfe\x88\x77\x0d\xd2\x1b\x47\xfa\x50\x98\xf4\x6a\x9f\x73\x84\x87\x91\x8f\x87\xdf\xfc\xc4\xe2\x7c\x02\xae\xfe\xf4\xdc\x99\x56\x73\x5d\xe4\x2c\x05\x76\x4c\xf8\xf8\xa3\x3a\x5d\x23\x1e\x25\x09\xb6\xcc\xc8\x31\x9f\x80\xc7\x89\xcb\x43\x40\x69\x6e\x44\xaa\x94\x02\x61\xe6\x83\x88\x6c\x30\x2e\xba\x84\x9b\x79\xd2\x9c\xdf\xf5\xa4\xd0\x02\xa3\x22\x81\x96\x6c\x55\xa5\x73\x07\x5f\x22\x50\xd2\x10\x4a\x51\x29\xa4\x43\x5a\xc8\x87\xe0\x91\x1c\x3d\x08\xf8\x7e\x7b\xb7\x90\x45\xb1\x65\xad\x17\xbb\x4c\x94\x93\xa6\x6d\xe2\xaf\x2f\x52\xe6\x08\x95\x93\x8b\xc8\x9f\x00\x8b\xb2\x78\x18\xda\x97\x7a\xd9\x62\x0b\x82\x28\x14\xd8\x4e\x44\xcd\x20\x5d\x23\x3a\x2a\x30\xce\x68\x24\x55\xad\x12\xa2\xc5\xac\xa0\x43\x23\xe5\x89\x76\xa2\x3a\xd8\x70\x76\x6e\x70\x8b\xdb\x00\xb4\x8f\xa4\x26\xbc\x8b\x93\xcd\x7b\x63\x62\x04\x11\x9b\x9d\x90\x5b\xbd\xcc\xfe\x8e\x08\xba\xf5\xec\x5e\x22\x09\xf2\xbe\x2c\x7d\x15\xb4\xfe\x12\x03\x8f\x72\xba\x48\x3f\x9a\x39\x5f\xb6\x00\xd0\xb9\x81\x9e\xaf\xcc\x79\x9e\x48\x79\x07\x52\xb3\x26\xe6\x12\x26\x7a\xb5\xed\x6e\x67\xd9\x7b\x90\xe5\x70\x92\x8d\x2f\xce\xe5\xd6\x84\x1c\xc6\x4c\x6c\x65\xa7\xa5\x8e\x35\xb3\x50\x17\x35\xed\xf0\xb4\xd1\x91\x02\x87\xc6\x66\xc8\xb0\x07\xe2\x79\x2a\x75\xea\x79\x69\x61\xa6\x9b\x59\x31\xa5\xc3\x99\xd7\x04\x13\x52\xd7\x52\x29\x17\x53\xa7\xe1\xaf\x3d\x14\xbf\xed\xca\x46\x3d\x33\x17\x16\xf9\xfb\xae\x9c\x06\x7a\x25\x83\xaa\x1c\xb3\x05\x95\x74\x40\xa1\x0a\x5b\x39\x14\xc5\xc2\x40\x1c\xab\x61\x82\x62\x65\x5e\xf6\x0c\x48\xb0\xfd\x17\x3c\xc2\x5e\x8d\x46\x42\xa2\xb3\xd5\x29\xaa\x08\xc0\x5a\xd0\xa5\xaa\x3d\x40\x8d\x28\x8c\xe1\xd2\x1a\x59\x76\x74\xe6\x61\x33\xcd\x3b\xa2\x26\x70\x92\x93\x28\x11\xdd\x77\x76\x97\x3e\xb1\x46\x9f\x10\xb9\x3f\x3d\xf7\x3f\xb6\xb6\x12\x13\x23\x4b\x18\x2d\x3b\xff\xbd\x2d\xb4\xb1\x29\x90\x77\x65\xec\x00\xdc\x51\xaf\x20\x82\x5a\x1e\x11\x70\x32\x9f\x9a\xc0\x35\xf8\x5b\x5b\x04\x44\x4b\x32\x8a\xe9\x59\x97\x78\x0f\x53\x1a\xde\x49\x80\x2e\x92\x6a\xe6\xb1\xb6\x0d\x37\x3f\x66\xbd\xc6\xb9\x56\x7d\x73\xb5\x23\x76\xb1\x10\x53\xdb\x83\x99\xd6\x72\xb4\x1a\xb2\x6e\x8a\x20\xf8\x1a\x4b\x19\x50\x7f\x49\x94\xfa\xa3\x29\xc1\x0c\x91\x5d\x2d\xba\xc8\x1a\x5a\x3d\xda\x0c\xda\xb6\x52\x34\x88\xfd\xb0\x84\x56\xf0\x35\x38\x90\xd0\x8f\x34\x37\xb0\x9b\xa9\xcf\x6c\x8f\x25\x13\x67\xab\x8e\x2e\xb9\x4a\xda\x8a\xf9\x8f\x68\x8d\xad\x94\x05\xca\x54\x35\x6d\x1a\x0a\xe3\xc5\x41\x26\x5b\xa4\x63\x72\x06\x11\xed\xd1\xd4\xf5\x7b\x5c\x59\x4a\xb7\x62\x61\xe7\x6c\x9b\x22\xf3\xd0\xc1\x61\x9e\x39\x2f\xf9\x67\x07\x9c\x03\x5e\x0b\xfd\x71\x6c\x77\x5b\x94\xd1\xa8\xf0\x90\x2b\x23\x7f\x75\xba\xcd\xc1\x00\x49\x7b\xc8\x23\xf4\x16\x32\x04\x98\x25\xb4\x26\x9b\xa0\x2f\xc1\xfc\x34\x85\xb0\xd0\x16\x6b\xd0\x0d\x19\x8f\x01\x09\xa8\xe1\x3a\x6d\x41\x02\xc5\xa2\xbe\x2c\xd5\x28\x2c\x10\xe6\x7f\x10\x74\x59\x5c\x0b\x90\x4d\x41\xde\x20\x23\xab\xd4\x1d\x5d\x9f\x41\x52\x02\xe0\xa0\x19\x16\x0a\x7c\x56\x2c\xc4\x03\x7d\x0a\x30\xea\xfa\xc0\xf1\x3b\x0f\x60\xd6\x90\x80\x2a\x90\xd3\xa8\x1b\x91\x9b\x6d\x2f\x01\x0c\x57\xc0\xc7\x94\xbe\x39\xed\x93\x7b\xb7\x36\x33\x2d\x7e\x46\x8f\x80\xb9\xf8\xb5\xec\x1a\x10\xb9\xda\x2a\x44\x64\x6f\x51\x64\x42\xea\x8c\xcb\xc5\x3c\x08\xc8\xaa\xd9\x86\x3d\x2e\x08\x27\xa0\x77\xd5\x82\xed\x2f\xcc\x1f\x0d\xe0\x5e\xec\xa6\xd8\x22\x54\x46\xf5\x08\x86\x3c\x78\x15\xdc\xf0\x3d\xc3\x0f\x63\x70\x50\x8e\x46\x2f\x27\x6d\x9e\xc1\x54\x73\x8d\x35\x94\x4a\x87\x0e\xe9\x44\x30\x92\xd6\xa3\xb0\x87\xcc\x62\x03\x1b\xd3\xbe\xd8\xc8\x4a\x1b\x4b\xdb\x94\x32\x46\x69\x43\x09\x27\xe7\x8e\x6d\x00\x85\x01\xc4\x1a\x4e\x17\xde\xf6\xdc\x91\x0c\x68\x81\x75\x9c\x2a\x9b\x90\x94\xc6\x69\x62\x64\xb6\x1d\x7b\x25\x2e\xd1\xe5\x79\xa8\x00\x26\x41\xdb\x05\x32\x6c\xe0\x36\x51\xf0\x8c\xb7\xd0\xc5\xd6\x48\x96\x1d\x0b\x10\xf0\x05\x34\x8c\xf9\x62\xfc\x84\xa5\x79\x02\x28\xff\xf4\x2d\x46\xee\x8c\x3b\x00\x87\x3c\x81\xaa\x64\x8f\xa3\x21\x32\xa7\x9b\x2a\x44\x65\x60\xeb\xc1\x61\x62\xa1\x83\xfd\x69\x66\xe0\x67\x50\xa4\xde\x83\x0c\xdb\xad\xc7\xe1\x12\x06\xe2\xdd\x7a\xc8\x8b\x1c\x42\xaf\x0d\x18\x25\x66\x1c\x4a\xd0\x2a\xa1\x54\x90\x61\xb8\x52\x0a\xe0\x38\x92\x82\x8a\x90\x0b\x56\x7a\xd0\x09\x16\x63\x14\xef\x86\xcd\x77\x68\x12\x90\x8f\x6c\x13\xf8\x2f\x3a\xf7\xa9\x38\x1c\x7f\x76\x45\x41\xdd\xbb\x1a\xc5\xd3\x99\xce\x5f\x0a\x5a\x64\xec\x92\x02\x1b\x80\xe6\xba\x44\x81\x18\x70\xc3\xdb\xb2\x51\xa6\x0a\x95\x96\x52\xf9\x5d\x08\x91\xee\xab\x03\x92\xc6\x97\x27\x7a\xd7\x84\x9e\xae\xab\x02\x78\x91\x19\x55\x33\x6e\xee\x1d\xce\x20\x8d\x48\x5c\xd5\x09\xaa\x1c\x64\xbe\x8a\x79\x4b\x9a\xb6\x1e\x3a\xdb\xba\x21\x6d\x3a\xe1\x13\x64\x20\x8a\x6d\x1c\xcd\xe5\x40\x87\x7b\x01\x9b\x31\xda\xca\xb3\x7b\x3a\x48\x82\x92\xa9\x21\xc0\xe4\xe7\xa5\xa1\xd8\x52\xb0\x05\x5b\x5b\x18\x45\x2e\x30\xe9\x00\xa3\x0e\x45\xa7\x0d\x68\x53\x73\x50\x06\x40\x30\x5f\xa0\xa3\x40\x4e\x28\xdd\x65\xb8\xe4\xc4\x91\x62\x73\x04\x5e\x1a\x2f\x06\x17\xbd\x50\x06\xb1\x04\xec\x35\xe8\x88\xca\x2e\xca\x94\x40\x79\x95\xa9\x59\x4d\x44\x5f\x2e\x1b\x14\x93\xb2\xf6\xf3\x47\xf0\xff\xd7\x17\x91\x66\xa3\xea\x56\xec\x9a\x04\xed\xa9\x10\x7d\xaa\xe8\x47\xdf\xc1\xe0\xad\x1d\xf1\xf9\x0c\x79\xcc\xbd\xe1\x1e\x07\xa2\xc9\xd9\x58\x89\xbd\xb0\x2d\xcf\x27\xb9\x44\x92\x26\xd7\x67\xa2\x20\x26\x92\x30\x65\x84\x41\xb1\x3a\xf5\x28\xb0\xa0\x61\x58\xca\x3e\x50\x94\xb3\x2f\x36\xe1\x2e\x5f\xfa\x7b\x07\xda\x1f\x29\x87\x94\x90\x41\x43\xaf\x48\xfe\x07\x15\x20\x2c\xcd\x25\x41\x2c\xeb\x04\xc4\xde\x3c\x1e\x33\x58\x0c\xa4\x84\xd9\x64\x8b\x33\x94\xcd\x1c\xd6\x4f\xac\xec\x27\xac\xf4\x4f\xcf\x4d\xd4\x50\x97\x5c\x69\xb0\x14\x4a\xf6\xe6\x31\x84\x5a\xd8\xe6\xca\xee\xf4\x3b\x76\x61\x68\x61\x47\x67\x97\x52\xd9\xc1\xde\xc0\xbf\xed\x68\xfa\xf8\xa5\x9b\x13\xb5\xf3\x8e\xb4\x11\xb4\x93\x20\xdd\x56\x1c\x1a\x45\x9a\x59\xe5\x7d\xb2\x92\xc9\x5a\x07\x36\x18\xdf\x08\xa2\x28\x61\x2e\x58\xb6\x36\xe5\xc6\xe9\x66\x2b\x43\x5c\xfa\xc2\x9e\x01\xa0\x9e\x9d\xf4\xb4\x5a\xb5\xc1\x8d\x7e\xe8\xf0\xba\xaa\xff\x83\x09\xc8\x03\xa8\x36\x3b\xc0\x9e\xf8\x20\xaf\x8f\xb4\xb6\x83\x2a\x19\x74\xf3\x65\x02\x66\x3a\x87\x99\xd8\xa8\xa2\xf6\xf0\x5b\x68\xc2\x38\x7b\xea\xe2\xd8\xca\xe8\x66\xcc\x6b\xf5\x6f\xd4\xe3\x5d\xe4\x86\x4d\x43\xdd\x47\x36\x47\x86\xc8\x72\x3a\x81\x90\x2f\x64\xd7\xb5\x37\x5d\x4f\xb3\xd6\x94\x4d\xa3\x3e\x1b\x7d\xd8\x86\x0e\x04\x49\x94\x48\x25\x2f\x19\x45\x4c\x5f\xfa\x34\x3f\xa6\xdf\xa2\xee\xe8\x14\x43\x0e\x15\xc2\x7d\x09\x54\x15\xd5\x82\x1c\x86\x10\xe0\xfd\x61\x6c\xad\x16\x41\xbf\x5e\x5e\x24\x65\xdb\x94\xca\x1e\x07\x15\x36\x1b\x88\xee\xa1\x8c\xa5\x29\xa0\xa6\x51\xba\x79\xaf\x19\x55\xbf\xda\x90\x06\x60\x3e\x22\xcf\x87\xf4\x03\x1d\xe9\x48\x8e\xe6\x5c\x43\x65\xb7\xa3\x80\x98\xdc\xf6\xba\x1e\xfa\x3c\x8a\xf9\x1b\x7b\xb1\xd3\x83\xb0\x46\x2f\xbb\x9d\x60\x83\xdf\x0d\x57\xab\xdb\x9a\x34\xff\x89\x58\x69\x3b\x3b\xdc\x51\xae\xc9\xe9\x9d\x1b\xe6\x16\xd8\x34\x81\x48\x9b\x57\x67\x7c\x99\xa6\xe5\xa9\x7e\x62\x55\xfc\x8f\xa7\x55\x71\xa7\x55\xc7\x12\x98\xce\xa2\x0d\x2e\x6e\x73\x89\x30\x0d\xe0\xf1\xa0\x84\x89\x4c\x06\x61\xad\x22\xac\xea\xa3\x79\xa4\x9f\x6d\xed\xd8\xd4\x87\x97\x22\x10\xba\x53\x48\x8e\x7d\x23\x2b\x71\x68\xd1\x50\xf0\xa6\xf8\x99\x11\xde\x7b\x5d\x0d\x55\xb6\xbd\xa0\xde\xda\xc3\xe8\x68\xf8\x03\xb2\x53\x2b\x19\x33\x2b\x81\xfa\xb5\x3f\x80\x15\x84\x09\x01\xa5\x6b\xb9\xfe\x21\xc7\x79\x54\xf3\x97\xd4\x6f\xe0\x11\xda\xd8\xd6\x3c\xba\x86\x51\x13\x28\x07\x4b\x40\x0f\x2e\x5a\x87\x32\xdb\x3b\x90\xc7\x74\x9a\x03\x3d\x01\xda\x76\xe7\x8f\xc8\xf4\x94\x0b\x59\x9e\xa8\xf2\xdd\xce\x97\x0d\x29\xf9\x0a\xd1\x21\x08\xf6\x5a\x80\x1a\x0a\x77\x6c\xb4\x43\x8e\xa0\x6a\xe6\xd5\x7f\x3f\x16\x04\x4c\x36\x55\xbc\x85\x0e\x6a\xdc\x2c\x04\xa2\x73\x19\x7b\x2e\x1b\x0d\x34\xf5\x30\x2b\x03\x3e\x25\xa6\xba\x33\x3e\xa0\x60\x3d\x9b\x21\xe6\x1e\x1b\x81\xa1\x9c\x4c\xae\x19\x83\x92\x8b\x1b\xfe\xc2\xdc\x46\xef\x36\x03\xcd\xe5\xc4\xe5\xb5\x7e\x4c\x56\xcb\x99\x35\xb3\x70\xa7\x97\x3b\xe2\xdc\xd1\xa7\x9c\xff\xc8\xa0\x29\x37\xfa\xaa\x5e\x7f\xb1\x55\x70\x34\x7b\xb1\x4b\xb7\x7b\x61\x63\x4b\xff\x4c\xee\xe8\x3f\x28\x75\x74\xf9\x9d\xb9\xa3\xbf\x3d\xad\x9e\x7b\xd3\xb3\x76\xdb\x66\x17\xe4\x1b\x09\x4f\x34\x79\x09\xcd\x30\x38\x18\x06\x82\x73\xf4\x8f\x21\x3a\x56\x8a\x58\x30\x59\xa1\x0d\x34\xae\xfd\x00\xfd\x3d\xd6\x85\x27\x0c\xe9\xe0\x31\x9a\x71\x30\x0a\x8c\x27\xf9\x6b\xb8\x13\xa9\xcb\xda\x84\x68\xa1\x25\xbb\x7b\x83\xee\x35\xcc\x1a\xc0\x7d\x6f\xcb\xda\x19\x3a\xa4\xa0\x60\x45\xaf\xc3\xcc\x3e\x9f\x67\x55\xd7\x38\x95\xc9\x3b\x8d\x1a\x44\x7b\x28\x66\x23\x21\xeb\xab\x7e\x12\x97\x5f\x2e\x98\x1d\x6c\x87\x43\xef\xd8\x3a\x1f\x96\xfc\x93\x73\x40\xb0\x56\xc6\xc5\xa2\x47\x74\xb6\x7a\x02\xae\x84\x37\x20\xb2\xd1\x34\x07\x2c\x36\x92\xa5\xf4\xc3\xd9\xdc\xe0\x7b\x34\x96\x97\xd9\x20\xe8\x02\x92\xb0\x17\xe8\x16\x52\xaa\x4f\x2a\x72\x4f\x0c\xef\x25\x77\xba\x6f\xf6\x51\x23\xc1\x3f\x8b\x38\x48\xa1\x61\x22\x4c\x4a\xf2\x26\x12\xde\x96\x45\x38\x61\x06\x09\x69\x26\xd4\x3c\xeb\x01\xf3\x6e\xab\xbf\xfa\xa9\xdb\xf4\xe9\xce\x35\xb1\x17\x33\x5d\x7d\x9a\xff\x8e\xcf\x79\x64\x5e\xaf\x30\x0f\xd8\xa3\xc4\x3d\xa4\xb8\x6e\x59\xa1\xf2\x96\xda\x5e\x67\x1e\x7f\x4e\x47\xb3\x69\x01\x68\x89\xe2\xfc\x21\xc7\xfa\xff\x57\xea\x6b\xae\x9b\xbf\x3f\xad\x9b\x67\x59\xfa\x87\x7c\x4e\x71\x42\x6c\x31\x8f\x31\x28\xad\x6d\x83\xff\xd2\xee\x32\xab\xbb\x52\x03\x0c\xf9\xea\x0e\xf7\xa4\x74\xef\x82\x60\x65\xb5\xc3\x89\xea\x0c\x83\xcc\x3e\x66\x76\xf2\xa2\x20\x02\x3f\x05\x78\xc2\x41\x9d\x30\xcc\x30\xb0\x01\xca\xc2\xb3\xc1\x0b\x61\xe5\x7f\xb2\xa0\xc4\xcf\x40\x7d\xc5\x8e\x35\x88\x39\x67\xe8\x91\x0d\x5d\x3d\xe8\xe0\xa1\x58\xad\x42\x54\xd1\x10\x85\x69\xd7\x8c\x7f\xd1\xbd\xcb\xb4\xbf\x1d\x6b\x80\x0f\x15\xed\xa3\x08\x24\x6c\x03\x99\xf4\x81\x49\xcc\xc5\x90\xde\x2b\x3e\x74\xb1\x9a\x83\x12\x9a\xb7\xc0\x38\x7b\x91\xa7\x2c\x2a\x77\x30\x26\x08\xeb\x20\xa5\x9e\xfd\xf5\x8e\x92\xe6\xf9\x4f\x16\xdf\xb1\xf2\x2b\x16\xef\x64\x01\x94\xfd\x2a\x81\xc7\x60\x56\xf3\x8b\x75\x80\xa4\x6f\xa5\x88\xa2\xa2\x45\xa7\xe5\x50\xcf\x1a\x0e\xb9\x57\x4f\x6e\x9d\xd8\x1d\x6c\x43\x69\x3e\xbb\x8a\x0b\x2e\x6d\x49\x80\x84\x82\x68\x79\x22\x6f\x81\xcd\x32\x41\x4d\x64\xda\x7d\xca\xd8\x5f\x44\xec\x06\x6a\xde\xfb\xa0\x57\x89\x32\x52\x92\x83\xf7\x5c\x6a\xda\xe1\xdc\xda\x13\x81\x78\x12\xee\xb0\x9c\x3a\x23\x48\xb4\x41\xe5\xd8\x73\x6e\x8e\xea\x5b\x49\x61\x08\x97\x6b\x23\x02\xaf\x7a\x5f\x11\xd0\x08\xf0\xff\xf3\xb1\xf2\x9a\x28\x94\x69\x40\xf7\x27\xb6\x63\x73\xed\xb1\xf9\xc0\xe8\x23\xf2\x6f\xc0\xab\xa3\xf1\x13\xe4\xe6\xf6\x8c\xbe\xcd\xfa\xc6\x85\xf2\x8f\xa7\x85\xf2\xeb\x1b\xde\xc5\x77\x37\x98\xe2\x1b\xcc\xf0\x0d\x86\x62\xea\xe5\xdd\x0d\x46\x5d\xc1\x8d\xd2\xad\x9f\xdf\x64\x68\xbe\x85\x9b\x8c\x3e\x6d\x32\xf6\xf0\xe1\x29\xd0\x77\x7c\xda\x64\x48\xbf\xb4\xb6\x19\x67\x83\xde\x61\xbc\xdf\x6e\x34\x9e\x73\x46\x59\x5d\xb8\x3c\x32\x49\xbf\xa0\xa0\xc5\x52\x27\xd2\x6d\xf7\x93\xb2\x2d\xde\xcb\xa5\xe3\x0c\x21\xfb\x43\xad\xf4\x34\xd8\xef\xec\x36\x8c\x99\xd2\xf9\xf2\xab\x1d\x07\xad\xc4\xbf\x63\xcb\x01\x49\x08\x52\x24\x6f\xb6\x9c\x73\xc3\xf1\xed\x06\x99\x52\x4a\x5f\xf2\xcf\xda\x6a\x68\x3d\x2e\x2e\x4b\xf9\xd5\x7e\xf3\xbd\xed\xa6\xac\xcd\x06\xeb\xc1\x7f\x65\x52\xec\xdb\xff\x3a\x9b\xed\x52\xdf\x14\xc2\x1e\x0e\x52\xa7\xee\x02\x87\x14\x97\xd0\xe6\x7f\x9a\x9f\x76\xf9\xd3\x35\xbe\xff\xf9\xb4\x8c\xbe\xd5\x27\x8d\x06\x50\xbb\x56\xba\xca\x85\x99\x67\xea\x6f\x0f\x88\xdb\x9f\x80\x0e\xb9\x03\x3d\x5c\xa7\x51\x57\x55\x08\xee\x0f\x80\x8f\x48\xd1\x0c\x07\x9b\x3a\x3f\x84\x93\x5c\x09\x91\xd3\x98\xc0\x93\x15\xff\xc6\xca\x0e\xc7\xa4\x61\x66\x66\x56\x08\x54\xb4\xf8\x1f\xb9\x08\xdb\x14\x40\x43\x81\x8c\x41\x11\xd2\x25\x67\x62\x6d\x5d\x3c\x1c\x84\x33\x99\xfb\xa1\xcd\xc5\x16\x46\xc3\xf3\xad\x41\x75\xb3\xa0\xeb\xb2\x77\x81\x95\x6a\x0e\xf1\x10\x22\x40\x18\x36\xb1\x70\x74\x30\x7e\x66\xe1\x10\x03\x84\xd2\x2a\x76\xd2\x40\x21\xfb\x0c\xa4\x5a\xf3\x16\xfe\x23\x62\x9b\xd9\x22\xe8\xb9\x72\x79\xb8\x42\xe4\x93\xe0\x15\x0e\x04\x19\xb9\x96\x00\x76\x6a\x32\xd3\x97\xa4\xf7\xaa\x9a\x72\xa7\xdb\x91\x73\x43\x1e\xc9\x82\xa6\x03\xcd\x8c\xb9\x83\x4b\xa9\x24\xec\x83\xb9\x6c\x51\x82\xdc\x28\x25\xdb\x42\xc3\xcc\x35\x0f\x4e\x42\xad\x3b\xda\xcb\x50\x21\x41\xe6\x59\xcd\xd9\xa2\xe2\xd7\xb8\xa0\x9a\x4d\x89\x22\x94\x2e\x46\x88\x30\xf7\xe6\x95\x36\x56\x5a\x8b\xeb\x64\xa1\xbe\x6f\x6e\x5f\x9d\x47\xf1\x8c\xde\x66\xb1\x96\xf4\xbe\x6b\xa0\xfa\x82\x2e\x4e\x14\xe6\x1a\xc4\x99\x29\xd0\xb0\xc4\x7b\x8a\xe4\x6e\xee\x7b\x6b\xc1\x3c\x04\xc4\xd5\x80\x13\x01\x75\x87\xa4\x10\x04\xc5\xf0\x08\xc6\x80\x83\xf8\xfd\x39\xfe\xb7\xa7\xee\xdd\x9f\xd3\xb9\x55\x64\x3d\x29\xa5\x0a\x35\xd9\x7b\xdb\xc0\x65\x24\x65\x53\x04\x7b\x4e\x4e\xdb\xb3\x17\xa8\x0b\xf8\x18\x91\x1e\xdc\x04\xd1\xbc\x4d\x2a\xc0\xfe\xc5\xfb\x49\x25\x8d\x0d\xdc\x9c\xd2\xc7\x46\xac\x97\xc5\x86\xcc\x8c\x81\x5a\xd3\x6e\xd5\x16\xfb\x0c\xaa\x63\xc3\x82\xb0\x7d\x1d\x06\x11\x35\x8b\xd8\xe0\x76\x34\xfb\x4c\xb3\x13\x6d\xab\x36\x10\x12\x61\xf7\x29\x29\xd4\x89\xc1\x15\x32\x07\x6c\x85\x1d\xc0\x1c\x93\x3d\x91\xac\xc6\xd2\x87\x3d\x4e\x9e\x73\x94\x54\x98\xb2\xb5\xf5\x5b\x07\x89\x99\xb4\x84\x3e\xed\xaa\x3b\xe5\x17\x2b\xc2\xf1\x1a\x80\x96\xcf\x16\x15\xf5\xbe\x01\x72\x2d\x65\x03\x1d\x59\x9f\x3b\xea\x69\x01\x43\xa4\x6d\x8d\xbd\x45\xbb\x23\x52\xe7\x8e\x4c\x18\xf8\x2c\x70\x12\x64\x1f\x44\x6a\x17\x27\xbc\xb7\x6e\x06\x17\x57\x31\x36\xd0\x3e\xa9\x7d\x3b\x07\xcd\x6d\x37\x17\x3e\xf4\x1a\x1a\x0b\xd0\xb8\x1f\x4c\x9b\x69\xee\x5b\x47\x2e\x80\x49\x20\x0e\x81\x9b\xe9\xf7\xb9\xe0\xc7\xec\x4e\x34\x36\x81\xaf\x27\x72\xe1\xc9\x45\xa9\x73\x53\xb1\x30\xa2\xc0\x19\x6d\x1a\xee\xcf\x95\x4f\x7c\xb3\x5b\x21\x80\xb5\x66\x14\x11\x7b\x77\x70\x0f\xe7\x0a\x50\xa8\x48\xe0\xeb\x64\x60\x21\x48\xaf\x1d\x51\x31\x41\x91\x9a\x3b\xcd\x3b\x7d\x66\x16\x10\xbd\x60\x8e\x3a\x34\xbd\xde\xd1\x9d\xb6\xe5\xe4\x74\x95\x19\xf8\xcf\x71\xbc\x39\xe8\xe1\xdb\xe7\x98\xbb\x00\xc6\x74\xff\xd9\x63\x9d\x8a\x9f\x5e\x61\x2e\xaf\x80\x5d\x4f\xf3\x2d\xf6\xd6\xb6\xd8\x80\x91\x1c\x99\xaf\xf2\xc8\x37\x7b\xdb\x5f\x93\x02\x28\xca\xc8\x5b\x4f\x23\x14\xd1\xdb\xd0\xbc\x45\xfe\x43\xf8\x22\x16\x91\x5b\x1c\xa7\xda\x90\xa4\x31\xa0\x89\xba\x45\x7c\xbb\x94\xc1\x57\xa5\x8c\x9b\xbd\xed\xaf\x3f\xb1\x5e\x9f\x3a\x64\x7f\x7e\xea\x90\x7d\x88\x81\xb2\x4d\xa3\x2c\xe3\xda\xa6\x10\xb3\xd6\xf5\x1a\xdb\x2a\xff\x60\x87\xa1\x67\x3d\x8f\xe8\x45\x97\x31\x6f\xb1\x33\x73\x35\x6b\x68\xce\x76\x3e\x4f\x91\x43\xb4\xf2\xec\x8a\xa4\x96\xb9\x30\xf5\x86\x41\x61\xae\x89\xd5\x56\x96\xae\x52\x3a\x90\x1d\xb2\xd0\xeb\xc6\x11\xed\x80\xf5\xd6\x71\x1e\xf6\xfa\x22\x32\x21\xc3\xd9\xae\xca\x82\x27\xf0\x77\x93\xcd\xfd\xb1\xb9\x02\xcc\x89\x91\x34\x6b\x34\x07\x31\x30\x6c\x2c\x22\x74\xbb\x33\x22\x60\x84\xd9\x4e\x85\xdb\x02\x70\x64\xa3\x57\x7a\x93\x59\x77\xdb\xb6\xb4\x41\xad\x4f\x86\xee\x8a\xbe\x71\x05\xc3\xea\x9e\x90\x82\xc5\x3f\xcc\xda\x8d\x1a\x7a\xce\x57\x98\x22\x70\x9d\xb0\x66\xdb\x4a\x98\x7d\xdc\xa2\x88\xc8\x35\xf6\x89\x3e\xf4\x5a\x43\xb1\xc3\xaf\xad\x8f\x9b\x24\xa8\x68\x02\x6c\xc2\x7c\x75\x5d\xa4\xc0\x73\x6e\x5a\x43\xeb\x3b\xf9\xa1\x4b\x58\x01\x29\x85\x8c\x9d\xdd\xf3\x53\xa5\xc7\xbf\x3d\x75\xa8\xfd\xfc\xad\x0e\xb5\x41\xac\x07\x2b\x2b\xcc\xe3\x44\x52\x0a\x14\x47\x07\xe1\x95\xc3\x30\x3b\xe9\x06\xd6\xdf\xf5\xc1\x79\xe8\xfa\xf6\xeb\x4b\x03\x35\x72\x99\x37\xe6\x75\x50\xae\x04\x40\x19\xae\x4e\x3d\x21\xf6\x64\x23\x62\xcf\x56\x22\x5c\xee\xb6\x72\x41\x39\xb9\x4c\x4b\x55\x97\x28\x55\xdd\xc1\xb2\xc5\xef\x2b\xf5\x48\xaa\xbe\xbe\x0c\x90\xb6\x7d\xf5\x73\xe7\x8f\x9d\x3f\xf5\xc5\xf5\xd5\x2f\x2b\xf1\xfa\xe1\xef\xf9\xb1\xca\x78\x1e\xbf\xfe\xf8\x7b\x92\x58\x4c\xfa\xcc\xf5\x7d\xa9\xf7\x2b\xfc\xd4\x6f\x1e\x4f\x97\x27\x9a\x3e\x7d\x3b\x3f\xfc\xb9\xcb\xef\xf8\xbd\xd2\x5b\xa8\x79\x35\x24\x34\xac\x61\x75\x42\x6f\x8b\xd4\x32\xf3\xbc\xc4\xf0\xc3\x6c\xcf\xf3\x6c\x50\x6b\x31\xd7\x84\x8d\xd1\x98\xb7\x94\xa3\x44\x5e\x6e\x0c\x73\x70\x90\x53\x06\x73\x38\x24\x6f\xc9\x21\x3e\x19\x0c\x34\x0d\x0d\x9b\x89\x1e\x80\x66\x69\x15\x7b\xec\xb5\x87\x29\xa1\x76\x0a\x52\x0f\x4a\x61\x41\xc1\x3f\x8c\x1e\x6a\xfa\xe8\xfd\x83\x8c\x44\x17\x8c\x81\x03\x6a\x22\x2e\xd5\x69\x07\xeb\xc9\x56\x0a\xb6\x6f\x11\x0d\xb3\x98\x37\xe6\x68\xb7\x9e\x83\x0e\x87\xac\x6a\x0b\xb5\x21\xe9\x09\x20\x36\xc5\x8c\xbb\xf3\x8a\x00\x60\x5a\x3d\x2b\x5e\x9c\x37\x43\x09\xb0\xb6\x3f\x8a\x04\x82\x79\xbe\xf6\x14\x58\x2b\x62\x91\x7a\x40\xb7\xcc\x93\x3f\x2c\xa1\xa1\x88\x70\xb0\xff\x4a\x78\x5e\x82\xfe\x8f\x14\x7a\xb2\x20\xac\x80\xc1\xbe\xcf\xd7\x97\x01\x54\x34\xaa\xd1\x95\xc9\x26\xe2\x5a\x87\xc0\xeb\xbb\x1c\x14\x64\xf1\x67\x47\xd4\x2b\x90\xe6\x12\x98\x78\x02\x82\x90\xa5\x3d\x1c\x85\x97\x14\xfb\x96\x7b\x13\x52\x05\x5b\x96\x5d\xfc\x6c\x1e\x0a\x8b\xed\x13\x78\xca\x78\xdc\xe4\x50\x2d\xa0\x50\x4e\x7e\x0f\x32\xac\x5c\x27\x1e\xb9\x2c\xd0\x22\x9b\x4d\xa8\x79\x9c\x4a\x70\xce\x19\x08\x71\x30\x64\xc9\x2c\xdb\x48\x01\x9e\x00\x3e\x4e\xcd\xa1\xb1\x06\xe0\xe2\xb8\xe3\x84\x36\xae\x16\x40\x64\xb5\x2e\xbb\x79\x43\x23\x38\x78\xb5\x9d\x01\x39\x2a\xd0\x8b\x1a\x95\x82\x40\x82\x20\x9a\x65\x1d\x42\x9b\x27\xff\x91\x10\x51\xa1\x73\xa0\x10\xc5\x1d\xc5\xb9\xfa\x91\x77\x4b\x60\xeb\xb7\x8f\xce\xb5\x8c\x14\x33\x03\xba\x33\xdc\x02\xe1\x1a\xd5\xb2\x1a\x5b\x4f\x58\xe8\x8a\x9c\x94\x10\xfc\xc6\xdb\xce\x14\xe7\xd3\x37\x56\x24\xb5\x3e\xf8\xb0\xe0\xee\x9e\x39\x34\x1d\xa8\x85\x5d\x76\x34\xf4\xb6\x95\x4a\xa0\xb8\x30\x33\x21\xc8\x72\x81\x74\x18\x05\x42\x36\x4c\x65\x07\x33\xd9\x0e\xd0\x77\x54\x01\x41\x54\xd3\xf7\x01\xa5\x6d\x50\xe2\xed\x91\x90\x0e\xd4\xb0\xcc\xf2\x34\x64\xe3\xd0\x43\x6c\xfb\x54\x62\xab\xec\x74\xd9\xdc\x4c\x18\x50\xf3\x64\x57\x91\x63\xb0\x4c\x4b\x6a\xfa\xa2\x3b\x7a\x09\x6c\x3e\x56\x85\x14\xc5\x34\xff\x19\x98\x25\x02\x88\xf3\x61\xd3\xa9\xed\x40\xad\x40\xe1\x60\x1c\xec\x9a\x54\x0b\x62\xf6\xd1\x01\x48\x50\x76\x0c\xf4\x7e\x39\xb0\x52\x42\x6b\x9e\xec\xb0\x78\xcf\x7e\xa5\x15\xb4\x96\xb4\xb2\x0f\xce\x24\x74\x8d\xed\x08\x5c\x48\x09\x49\xca\xb5\x76\x82\x54\x1d\x20\x4a\x08\xa6\x00\x4f\xf5\xc5\xf1\x4a\xe4\x44\x0d\xec\xba\x72\xc6\x1b\x2f\x1d\xb0\x9b\x72\x67\x4c\x91\x07\x38\xf3\x62\xee\xe0\xb4\xc9\x20\x7d\xce\x8e\xda\x94\x94\x00\x00\x9f\xec\x56\x9f\xc8\x51\x7d\xa2\xa3\xf2\x6f\x4f\x1d\x95\x3f\x9f\xa2\x3f\x53\x7a\x68\x00\x12\x43\x29\x3c\xb4\x72\x8d\xb9\xe9\x2d\x4a\xd6\xab\x02\x8a\xae\x0c\x92\xbc\xca\xa6\x2c\xef\x32\x2d\x55\x30\xcb\x59\x97\x91\xe6\x2d\x55\xb1\x7b\x73\xe0\x71\xbe\x58\x9f\xed\x13\xb7\x12\x32\xbf\x16\x4f\x59\x60\x07\x9a\xb5\xc1\x8b\xd3\x0a\x49\xe5\x1d\x7b\x06\x2e\x4f\x4f\x99\x10\x41\xf7\xc4\x12\x06\x59\x2f\xef\x47\xec\xd2\x90\x44\x6a\xe7\x84\x49\x68\xd3\xeb\x09\x72\xd9\x16\x78\xd4\xab\x24\xdb\x03\xd3\xe5\x1a\xfd\xd5\xd5\xac\xe3\x2d\xbe\x7d\xf5\xe6\x85\x48\xfa\xe7\xab\x74\xfc\xae\x42\xc7\xdf\x9e\x7a\xaf\x7e\x2e\x77\xd5\x72\xc4\x13\x5a\x6e\x71\x64\x56\x2b\xd8\xd9\x16\x81\x63\xec\x5e\x62\x05\xe9\x60\x25\xb4\x81\x58\x94\x33\x6d\xcd\xb6\x06\xcf\x31\x91\x21\x33\x77\x8c\x73\xb3\xaf\x51\xf7\x43\xb2\x99\x93\x96\xa9\x58\x95\x24\x0c\x81\x8e\x8e\x60\x19\x4c\xc1\x6a\xab\x16\x12\xa0\xfd\x07\xed\x83\xcd\x25\xae\x2b\x09\x33\x57\x0e\x16\x8c\xb2\xe6\xe7\x0e\xb9\x81\x6d\x78\xa6\x50\x4a\xc8\x25\x87\x52\x76\xcc\x45\xa6\x42\xab\xf7\xb1\x79\x7b\x06\xc5\x00\xdd\x11\x44\xab\x1d\x76\x19\x9b\x35\x68\x39\x08\x28\x85\xa8\x1c\x00\xc5\xbc\x27\x6b\xf3\xfd\x1b\xfd\xd4\x62\xf3\x73\xfd\x56\xeb\xf2\x54\xd0\x25\xb0\x91\xae\x85\xac\x47\xb2\xab\x8f\x7c\x0d\x36\x0a\xbc\x67\xb7\x82\xff\x40\xa8\x50\x43\x29\x2e\x4d\x96\xbd\x7a\x69\x5b\x01\x58\xeb\xc0\x77\x30\x42\x99\x07\xa4\x61\x42\xcd\x8e\x0b\x00\x2f\x4d\x05\xd5\x3b\xd2\x88\x52\x12\x1d\x88\x89\xe8\x84\x45\x73\x3d\x28\x19\x1f\x26\xf9\xbe\x90\xb8\x20\x03\xfc\x70\x68\x4c\xed\x48\xc4\x28\x0c\x39\xea\x1f\xa8\xf1\xdf\x29\x49\x41\x96\xb1\x12\x59\xa4\xfd\x7a\xdb\x7d\x0f\xc8\x24\xdb\x0f\x6c\x76\xd4\x7a\x8b\xb5\x94\x9d\xdd\xa9\xe8\x33\x56\x0d\x69\xe5\xbb\x0f\x97\x5a\x44\x78\x80\xdd\x7a\x09\xcb\xc3\xec\x2e\x21\x29\xdd\x29\x84\x6f\xcf\x11\xa5\x37\x91\xbd\x13\x50\x8f\xfe\xf4\xda\x19\x83\xc1\x48\x8f\x03\xbb\xeb\x60\x5e\xa3\x01\xa0\x57\xca\x8e\xe8\xcd\x6c\x34\x29\x0e\x0a\xe2\x84\xdd\xe1\x6d\x4c\xf3\x78\x8a\xbb\xdb\x3c\x61\x57\x65\x3e\x44\xdd\xee\x21\xd7\xcf\x26\x5a\x19\x0a\x2a\x8c\xeb\x6c\xb7\x2a\x7a\x8d\x33\x7b\x92\x6a\x24\x12\x10\xf5\xe6\x26\xb3\xb9\x52\xe0\xa0\x15\x2d\x2d\xc4\xd6\xbd\xb3\xd6\x3c\x3e\x12\xaf\xba\x82\x6b\x07\xf8\x34\x76\xe4\xda\x71\xe3\x89\x6d\x38\x00\xb2\x9b\x80\xae\x2a\xf9\xd0\x34\x23\x77\x47\xc7\x1e\x09\xcf\xce\xf6\x29\x88\xda\x0b\x09\x0f\x6c\x56\xb5\x7c\xb4\xc4\x7a\xf4\x64\xc3\xba\xb7\x42\xd4\xb3\x87\x99\x38\x18\x72\x95\x32\x54\x4a\xaf\x2f\x6a\x66\xf8\xf7\xce\xdf\x0b\xf3\xda\xb3\xa5\x5b\x5c\xf6\xf4\x1d\x51\xc5\x92\x0b\xc8\xc8\xc0\x93\x8b\xe8\x3d\xb5\xd5\x50\x80\x90\x84\x34\xe6\x65\xb0\x31\xe5\x44\xf6\xb0\xd0\x09\x1e\x37\xe0\xa3\x50\x1d\x23\x22\xca\x8f\xa0\x96\x83\x92\xa1\x6e\xa1\xfa\xc0\x93\x49\xcb\xcc\x86\x30\xb0\x56\x77\xe7\x0e\x20\x2a\x67\x88\x45\xef\x3d\xe8\xd0\x6b\xcc\x50\x79\x78\xe2\x05\xb9\xb5\xae\xcf\x0a\x95\x45\xe5\x62\xb6\x08\x95\xc5\x50\x06\x91\xcb\xf6\xb7\x84\x92\x18\x3e\x01\xe3\x5a\x9d\xcd\xba\x29\x09\x06\xda\x08\x90\xbd\x94\xee\x76\x0d\x7e\x4f\xdb\x87\xda\xed\xb6\x7f\xd5\x06\xa1\xcb\x13\x11\xd0\x0e\xae\x3d\x01\x96\x8d\x76\xaf\xad\x5c\x70\xcc\x02\xf8\x02\x3d\xf3\x49\xfd\x52\xc8\x00\x93\xf1\x12\xd5\x80\x6b\xae\xf5\x8f\x19\xbf\xa7\x16\xa6\x9f\xbf\x29\xae\x65\x5e\xf4\x18\x7a\x8b\x13\x4d\x77\xe0\xe3\x58\x84\x59\x8b\x4a\xeb\x1a\xa5\xf4\x37\x8c\x62\x4e\xaf\x25\x92\x6f\xfc\x9e\x54\xb3\x41\x5a\xf6\x11\x90\xe5\xcc\x27\x81\x67\x6e\x6c\x1f\xc5\xad\xed\x94\x10\x3d\x66\x83\x58\x34\x15\x49\x53\x3f\x50\xb3\x77\x9d\xa6\x1a\x0a\x63\xba\x92\x8e\xbe\x2a\xb0\xec\x10\x3f\xda\x74\xc2\x46\x2f\x46\x1e\x6d\xd5\xea\xc0\xcd\xa8\x07\x08\xd1\x13\xd1\xc5\xc3\xb1\x83\x4b\xd8\x49\x5c\x25\x36\xf5\x8b\x9d\x40\xec\x99\x4c\x8e\x77\x5e\x68\x9c\x23\x1f\x42\x6e\x78\x36\x19\x95\x2f\x41\x1d\x57\x9c\x37\xd6\x42\x07\x9d\x7d\xd7\x66\x71\xb1\x84\x5c\x20\x07\x63\x87\x8d\x20\x67\xf1\x94\x34\x94\x54\x69\x1d\xa1\x42\xbb\x08\x63\x88\xf7\x49\x69\x41\x33\xd5\x1e\x15\x1e\x3c\xf0\x04\x88\x3e\x10\x3a\x00\x85\x8c\x4d\x7f\x2e\x0d\x04\xa6\x74\x9c\xcf\xc0\x71\x07\xb8\x0b\x71\xdd\x17\x7e\x98\xab\x7f\x83\x5f\xa8\x1a\x32\x79\xfb\x9a\x37\xc1\x83\xad\x84\x74\x0b\x04\x4a\xbb\x2a\x23\x8b\xa2\x38\xdf\xc8\x13\x46\x8d\x93\x9c\xe6\xf9\x94\xa8\xb1\xcb\xdb\x07\x79\x03\x32\xd2\x46\x95\xd2\xa4\x83\x91\xeb\xc0\x63\x29\x9d\x4d\x14\xd0\x6b\x61\x99\xd2\x86\xe8\x4e\x4c\xca\x17\xf6\xd7\x67\x0b\x4f\x7d\xf2\xa1\xa2\x2c\x5f\x06\x8a\xcf\x9f\x98\xf4\x4f\x3d\x41\x3f\x7f\x4b\x13\x4d\x4a\x2f\xa1\x69\x86\x9c\x51\x95\x9d\x97\x79\xbf\xca\x45\x95\x8f\x76\x2a\x2c\x55\x5a\x27\x6c\xce\x04\x14\xba\x1e\xaf\x2d\x12\x5b\xf0\x6e\x0b\x5d\x0b\x13\x3a\x2f\xc3\x85\x82\x90\xa7\x64\x6d\x96\xc5\x3e\x24\xf1\xd9\xbe\x05\x7e\x69\x42\x33\x7a\x09\x44\xce\xf5\xb6\xfa\x40\xc5\x7b\x70\x5a\xc2\xed\x40\x91\x02\xa6\xb8\xba\xf3\xff\x20\x4a\x86\x9a\x6d\xf1\x6a\xfc\xe0\x73\xe4\x34\x5c\xb3\xf0\xb2\xe5\x6e\xb3\x10\x93\x10\xd5\x25\xc9\x6c\xb7\x8d\x7d\x9f\x6c\x4e\xc9\xa9\x81\x1b\x02\xe4\x16\xd4\x0b\xb6\x89\xe6\xd7\x81\x70\xb0\xdd\x4b\xcf\x8e\xe6\xbf\xca\xd5\xf9\x51\xe9\x9a\x74\x1e\xc4\x6a\x73\x5a\xd2\x71\x85\x0c\xcd\xbb\x56\x08\xc1\x87\x2c\x39\x68\xf1\x45\xe3\x33\x70\x4d\x40\xcf\xc4\xc6\xd9\x6e\x53\x07\x02\x62\xe4\x58\x2a\x70\x92\xe8\x2f\x40\x2b\xda\x98\x21\xa7\xb2\xc7\x1c\xa8\x47\x95\xfd\xae\x0d\xdf\xfb\x30\xf9\x27\xfa\x79\x2e\xeb\x6e\x13\x83\x02\x34\x36\x21\x28\xcd\x2f\x87\xf9\xe8\xc1\x6e\xb6\x0c\x54\x1a\xe1\xbc\x66\xb0\xd9\xe3\xe5\xac\x02\xea\xa2\x6d\x85\x82\xda\x9d\xb7\xbd\x78\x8b\x3a\x7a\x55\x6e\x71\x52\x2a\x5d\x72\x98\xa7\xdb\xcb\xe6\xc6\x69\x7b\x89\xd9\x53\x94\xe0\xcf\x6a\xfb\xf4\xb6\x2c\xcf\x6c\x8c\xac\xe7\x20\xbf\xdf\x26\xe3\x7b\xb5\x85\x22\x61\x96\x0b\x28\x4d\x44\xcc\x82\x02\xc4\x8c\x8c\x54\x0e\xd0\x3f\xdd\x33\x12\x59\x75\x72\xc9\xa1\xca\x59\xf4\x58\xb3\x10\xe1\xa6\x28\x9e\x31\x26\xea\x8a\x3f\x0f\x20\x84\xda\xfa\x8a\x6d\x62\xc8\x08\xd9\x44\xc5\x1d\x6c\x41\x9c\x42\xf6\x40\xc3\xb7\xf4\x7e\x28\x3a\x79\x3a\xc9\x8a\x33\x51\xe4\xb3\x7c\x62\x7d\x3f\x75\xe2\xfc\x7c\xca\xdc\xe5\x9c\x82\x6c\x10\x32\x53\x29\x1b\x9b\xa0\x20\x24\xd7\x82\x4a\x7e\x7d\xa9\x94\x49\xae\x9b\xf6\x62\x5e\xd9\x06\x96\x99\x62\x66\x2e\x31\x88\x7a\x7d\x51\xf3\xc9\x25\x6f\x70\x5a\x55\x32\xba\xb3\x20\xa3\x6c\x9f\x68\x2a\xaf\x2f\x65\x02\x91\xbe\x65\x10\x3e\x15\xd4\xe6\xb2\x16\xef\xf5\xd3\x94\x5e\x5f\x06\x20\x9a\x63\x9b\xc8\x66\xa1\xbf\x3d\x7b\x95\x8e\x10\x34\x34\xa4\x0d\x08\x55\x02\xe8\x58\x17\xb1\x3e\xec\xed\x36\x00\x10\xde\x91\xa3\x00\x92\xfb\xf5\x45\xf2\x08\x33\x27\xa7\x7b\x4b\x69\xb3\x08\xac\xb4\x7a\xd9\x2c\x02\x0d\xd2\x21\x13\xd2\x73\xd0\xd6\x37\x64\x5a\xca\x16\x15\x75\xff\x56\x36\xa6\x7b\x5e\x5f\x8a\xf4\xd0\x55\xb7\xdc\x6d\xc7\xb2\x73\x9f\xa1\x14\xd9\xc0\x3b\x1f\xa5\x65\xe8\xf7\xa5\x90\x6b\xdf\x14\x9d\xf7\x1b\x52\x9d\x52\x74\x03\xa6\x26\xd5\x4d\x8a\xad\xc8\xba\x23\x3f\x67\x2f\x37\xa2\xd1\xe6\xeb\x8b\x14\x5b\x75\xb3\x6d\xd9\xe6\x33\xf4\x6a\xd1\xab\x30\x36\xf2\x0f\xe8\x58\xba\x82\x3a\xc1\xad\x60\xe1\xcf\x60\x8f\x3d\xb3\x37\x25\x44\x3b\x18\x76\x76\x74\xe0\xdc\xb0\x6d\x87\xb4\xc5\x39\xc2\xc8\x1b\xda\xa8\xe4\xf2\xf6\xf8\x99\x5d\x1d\x81\x20\x53\x30\x12\xc7\x01\xfe\xa9\x80\x4b\x18\xb0\x31\x3c\xe1\x3a\x83\x76\xb4\xf1\x75\xe0\x91\x36\xdb\xbd\x3a\xc8\x04\x46\x43\x55\x6c\x2a\x5a\x3d\x73\x15\x1e\x65\x21\xc9\x36\x4b\x40\x11\xcc\x16\x4c\xc2\x8a\x06\xc5\xc5\x16\x67\x0b\xa5\x41\x79\x1d\xfa\x23\x92\xb7\x62\xc7\xe4\x8a\x18\xca\x2e\x0f\x73\x25\xb2\xdd\x3e\x42\xb5\x7b\xda\xed\x8d\xa5\xad\x96\x23\x70\xa6\x6c\x48\xf0\xc5\x26\x1b\xdb\x5e\x6c\x80\xa8\xc1\x26\xd1\xc6\xf2\xd1\x26\x6a\x26\xef\x02\xdf\x48\x24\xa4\x0d\x34\x54\x6d\xb3\x65\x0d\x79\xc1\x50\x83\x8d\x0d\xb9\xc2\xbd\x85\xcc\xa3\x28\x48\x95\xeb\x5e\xec\xf7\x6d\x76\xd1\x2b\x89\xe0\x14\x77\x14\x14\x01\x2a\xc9\xb1\xe9\xe7\xfd\xed\x1b\x35\xa6\xec\xf4\xed\x3c\x31\x52\xf8\xb6\x38\x30\x17\xeb\x53\x73\xcd\xcf\xcf\xcd\x35\xf7\x62\xa6\x98\x51\xd0\x39\x98\x81\x8c\xd5\x3d\x42\xb8\x49\xec\x35\x42\x41\x71\x34\x80\x19\xeb\x38\xcc\xfc\x13\x5b\xc8\x54\xb1\xe7\x7d\x19\xe7\xea\x09\xd2\xf0\xda\xa2\x26\x8f\x7e\xfb\x12\xd1\x5f\x6a\xfa\x0c\x8b\xf1\x7e\x72\xe2\x70\xe6\x97\x89\x38\xc9\xbe\x81\x9e\x44\x5c\xb2\xd0\x92\xb6\x35\x81\xde\x1c\x96\x1d\x12\x5c\xe2\x3d\xeb\x47\xf4\x3c\x11\x26\x76\x5f\xaa\x13\xb2\x52\x45\x70\xed\x6b\x6f\x97\xbd\x11\x2d\x93\x21\xd2\x76\x14\x25\x02\x0e\x6a\x6d\x23\x0c\x90\x4d\x4a\xb2\x50\x13\x71\x3f\x59\x53\x40\x1b\xd4\xd6\xab\xd8\xdb\x72\x2c\x84\x6c\x8f\x92\x7a\x58\x6f\xe4\xe3\x7e\xd4\xf9\x4d\x1f\x2c\xfb\x06\x9b\xab\xde\x16\xb1\xe5\xb3\x1a\xd0\x6c\x50\x67\xfd\xc6\x06\x04\x0d\x87\x77\x37\x20\xec\x4d\x29\xb4\x16\x9c\x5d\x97\x9f\x5f\xed\x2b\x97\x1d\x5f\x59\x6c\xbc\x3e\x2e\x7e\xeb\x3a\xdb\x93\x0c\xd2\x77\xce\x50\x74\xfc\xb8\x6f\x7d\x62\x72\x3f\xf5\xc8\xfc\xfc\x2c\x81\xf8\x30\xb9\xef\x4f\x93\x30\x99\xfb\xe3\x79\x7c\x8a\xf7\x47\xbb\x9e\x90\x3f\xfe\xf3\xe9\x9f\x47\xdc\xbf\x75\x3e\xfa\xd7\x97\x39\x2c\xee\xd4\x1d\xb8\xa9\xb1\xa0\x8a\x70\x43\xfb\xa9\x91\xd8\xfa\x61\x11\xc7\x10\x47\xb9\xdb\x71\x07\x07\xc3\xe6\x64\x7e\xac\xf7\x30\x89\x77\xcd\xd4\x55\x7a\xbc\xc6\xfa\x40\xb0\x8c\xf7\x59\x26\x64\xb1\x5f\xd8\xb8\x53\x46\x28\x4e\x05\x74\x61\x72\x68\xb2\x93\x70\x89\x17\x2c\x58\xd9\x64\x7f\xcd\xb5\xda\x5e\x07\xd1\x7d\x92\xef\x11\x14\xa7\x02\x25\x64\xe9\x07\xd0\x39\xed\xc8\xe6\x35\xf9\x55\x3c\x42\xf0\xed\x83\x69\x07\xd9\x31\xe8\x8e\xc0\x00\xf6\x7d\x86\xee\xab\xa4\x7f\xfa\x62\xf1\xee\x8c\xc5\xbb\x37\xf6\x66\x4a\x9c\x4e\x59\x5c\x5e\x19\x8e\xbc\x4f\xa8\x4f\x8c\x72\xf9\xb3\xc3\xfc\x15\xeb\xee\x3b\xcb\xee\x5b\x27\xec\x12\xbe\x76\x6a\xfe\x0b\xeb\xf4\x1f\xce\x1e\x27\xcf\x05\x8e\x9d\x22\xdc\x2f\xea\x88\x8f\xe3\x71\x84\x0f\x5d\x63\x3b\xd5\x0f\x5c\xe3\xef\x2f\xcf\xa7\x26\x9c\x9f\x7f\x7e\x4a\xfd\xa6\x32\xee\xcb\xb3\x84\x92\x5c\x39\x0a\x31\xbe\x33\xeb\xad\x7a\x01\x02\x98\x6e\x9b\x4e\x07\x91\xcf\xb9\xe9\x00\x64\xb3\xe0\x9e\xac\xd4\x3b\xa4\x93\x85\xf2\xec\xd9\x1f\xe4\xbf\xd6\x8b\xe2\x1f\xf1\x13\xf2\x8d\xde\xc9\x2f\x7d\x94\x14\x5c\xe6\x01\xa4\x14\xde\xb5\xee\xb1\xa4\x9d\x89\x9e\x9a\xd1\x91\xb4\x85\x24\xb6\xf5\xdc\xdc\x14\xaa\x91\x5f\xab\xe8\x8e\x5e\xb8\xe9\x40\x44\xf0\x09\x36\xb6\xb4\xb5\x0e\x22\xca\x14\x2c\xf0\x63\xa9\x86\x50\x53\xf1\x2a\xdc\xfd\xb5\xd3\x91\x35\x67\x7f\x4a\x8b\xaf\xc4\x5f\x3f\x1e\xf4\xf0\xe5\xfb\x98\x1e\xcf\x14\x69\xb7\x56\x9c\x25\x0a\xc2\x77\xd0\x98\x73\xc3\x72\x8a\xce\x45\xa8\xce\xc1\x80\xb7\xe2\xf6\x9b\xe6\x9b\xd6\xdb\x8e\x5e\x56\xdb\x8c\x36\xc0\x58\xa8\x04\xf7\x76\xa3\x1e\xcf\xe2\x26\x50\x56\x85\xe8\x50\xc0\x84\xb5\x71\x01\xf8\x34\x39\x71\x6a\x5c\x9a\x5f\x5f\x9c\xc1\xe3\x16\x5d\xb3\xc8\xd5\xee\xf0\xe6\x71\x3f\xf6\x5a\xdb\x70\x90\xf4\x1a\xf6\x38\x7f\xcb\x4f\x64\xea\xf8\xab\x2e\xd4\x66\x6e\x10\x2d\xe3\x16\x17\x5d\xf6\xfb\x16\xc2\x36\xf6\xd9\x9e\xce\xe1\x72\x65\x1f\xfd\x3b\xe7\x30\xdb\x35\xf6\x36\xde\xfb\xd6\xb7\xbf\xf4\x95\xd4\xc0\xa3\x2d\xe2\x29\x3e\xdb\xa2\xae\xe3\x5d\x5b\xf4\x89\xe5\xfd\xd4\x2b\xf4\xf3\x53\xaf\xd0\xfb\xcb\x9b\xec\x9c\xe7\x2a\x89\xe7\x32\x89\xb6\x4e\x22\x9b\x46\xd7\x4a\x89\x6b\xa9\x1c\xcb\x22\x9c\x06\x61\xd9\x83\x65\x0e\x60\x0d\xdc\x18\x3c\xd8\x82\x07\x53\x70\x5a\x82\x65\x08\xdc\x0e\x2c\x33\x70\xb7\x02\x77\x23\x40\x1b\x00\x13\x70\x5a\x80\xd3\x00\xdc\xd7\xff\x5a\xfe\xaf\x6b\x41\x23\x3c\x3a\x97\x74\x7c\xb3\xa6\xe3\xe3\xa2\x7e\x58\xd3\x0f\x4b\xfa\x71\x45\x3f\x2c\xe8\x78\x5f\xd1\xf1\xcd\x92\x1e\xe9\x61\xf2\x7e\xe5\x65\xbd\x9d\xed\xa7\x96\x64\xf9\x5a\xf9\xf2\x71\x9e\x3f\x28\x5f\xda\xf8\x3d\xeb\xc3\x82\x7c\x58\xa6\xc7\xc3\xf2\x7d\x67\x59\x3f\xac\x6a\x2c\xea\x65\x16\xee\x56\xe1\x6e\x14\xde\x2e\xe8\x78\x5f\xd1\xf1\x71\x49\x4f\xfd\xcb\x2e\x74\x6a\x0a\x59\xd7\x62\xf9\x70\x5b\xed\xe8\xf4\x7f\xbb\xab\x5e\xde\x6e\xab\x6e\x11\x3e\xd8\x56\x1f\x4d\xc2\xfd\xa4\x5a\x79\xc7\x73\x9e\xed\xfa\x68\x0a\xbe\x7f\xb4\xd9\x80\x8f\x92\x59\x9f\xb6\x59\xbc\xc4\x4f\x59\x92\xcb\x8f\x30\x25\x4f\xdd\x54\x3f\x3f\xab\x4f\x3e\xa4\x8c\xab\x02\x04\xc7\x6a\x2b\x48\x7e\xb0\x5a\xd9\xe8\x21\xe8\x40\xa1\x1b\x0c\x3f\x1a\x39\xde\xea\xce\x34\xb3\x86\x0b\xb4\x7a\xff\x87\xbf\xae\x74\xa1\xeb\xc2\x4f\x13\xb7\x32\xca\x83\x27\x3e\x68\x59\xec\xc7\xc0\x73\x4f\x59\x6c\x68\x8c\x93\x95\xa5\x36\x9e\x10\x5e\x0d\x92\xe3\x48\xc0\x87\xaf\x6c\x0e\x23\x41\xc7\x03\xc9\xfe\x1b\x8e\x7d\x07\x77\x3c\x12\xee\x5f\x8e\xb7\x6c\xfc\x6f\xfe\xf1\x78\xe0\xf1\x01\xa5\xe8\x87\xea\xd5\x2e\x2e\xc9\x55\x46\x05\x6b\x2e\x3e\x52\x14\xe7\x32\x49\xbe\x29\x83\xdd\xc2\xff\x99\x62\xd6\x9c\x2b\x4f\x2d\x43\x3f\x3f\xb5\x0c\x3d\xa2\x71\x67\x63\xc7\x10\x2f\xe0\xbb\x27\xc0\xdb\x23\x4c\xc0\xe0\x06\x7d\x7d\x7b\xda\xd7\x37\x67\xbd\xe4\x7d\x81\x35\x5b\xfc\xce\x30\x72\xe7\xdd\xe9\x2c\x8d\x7d\x7c\x7f\x80\x08\xb4\x18\xb3\xee\x52\x66\xd0\x54\x83\xfd\x2d\xe4\x0e\x40\x61\xfa\x3b\x2a\xe5\xc7\x92\x4b\xbf\x7c\x53\x2f\x1d\x35\xe6\x9a\x30\x7a\xb4\xe1\x5b\x0b\x59\x3b\x6a\x0e\x59\xfb\x2e\x28\x82\x29\x2b\x03\xf6\xe2\xc8\x60\x1d\x19\xbb\xa2\xb2\x8d\xda\x44\xd6\xbe\xe6\x33\x60\xa8\xbf\x63\x3e\xff\xe9\xe9\xfc\xdd\x69\xf2\xf7\xa7\xae\x9b\x5f\xee\x5d\x37\x9a\x24\xf4\xaa\x3b\x0c\x54\x01\xb4\x13\x95\xb2\x31\x59\x88\x7c\xb0\x15\x68\x38\xea\x7a\xa0\x73\xd0\xbb\x2f\xc1\x6b\x11\x89\xce\x6a\xc4\x0b\x16\x71\x21\xdb\x6b\x1c\x15\x1e\x1a\xd9\x55\xcb\x6a\x33\xc2\xe1\x38\x1a\x3b\x8b\x80\x68\x35\x2f\x50\x5f\x57\xfe\x28\x7f\x73\xcc\xd0\xf3\x81\xb3\x82\x86\x2d\x90\x80\x01\xdd\x3a\x8c\xf7\x52\x09\x54\x1e\x44\x48\x4f\x99\x5c\x21\x9f\x46\x63\x15\x97\x6c\x1d\xc3\x3b\x81\x2f\xfe\x9a\xfd\xc4\x0b\x09\x9f\x1e\xb4\x97\xf9\x6d\xef\x00\x70\xea\x0f\x32\xeb\xf4\x09\xcc\x99\xeb\x32\xbb\x30\xbf\xb3\x0e\xfc\xb8\x07\x7a\x7c\x38\x71\xd0\xb9\x50\xc9\x06\x3f\x80\x5e\x01\x38\x80\x4c\xe5\x6c\x92\xe5\x4d\x05\xb9\x3d\x80\xd2\xb9\x77\xdb\xaf\x49\xdd\x5a\xcd\x1f\xc1\x4a\xd0\x1e\x62\x06\xdc\x50\xfb\x81\x57\x02\xea\x4b\x5c\x65\xf0\x2f\x44\x30\x83\x39\xb1\x56\x77\x32\x27\x0d\xde\x30\x00\x96\x36\x9e\x00\x16\xfe\x75\xd4\x4f\x54\x4c\xfe\xfe\xd4\x51\xf2\xcb\x73\x47\xc9\x23\xc3\x91\x96\xa0\x8e\x00\x38\x3d\xe5\xee\x7e\x72\x7e\xf2\x92\xb3\xfb\xc8\x1d\x1e\xf2\x58\xfe\x71\x39\x9a\xb0\x25\x07\x5d\xe2\xf0\x90\x07\x41\xae\x32\x88\x9b\xb1\xbf\xbd\x12\xe5\x3d\x5d\xa3\xdc\x09\x20\xd9\xcb\x73\x16\xd7\xb0\xb2\xc7\xeb\xcb\xe8\x29\x74\x2a\xb9\x4f\x17\x9a\x79\x70\x6d\xf5\xd1\xb5\xd5\xbb\x6b\xdb\xef\xae\x6d\x7f\x70\x6d\xd7\x11\x97\xe3\xf1\xab\x0f\x63\xda\xb3\xaf\xca\x54\x47\x06\x2a\x08\xa8\x3c\x08\x8c\x7d\xec\x5d\x81\x40\xe4\xa3\x72\x9e\x99\x2b\xfb\xfe\x3d\xf5\xf1\xbe\x07\x84\x06\xd9\xdf\x95\xd6\x41\x02\x77\xb6\x77\xc2\x47\xa8\x9e\xbf\x09\x1f\x6f\x74\xd4\xde\xcf\xbe\x7e\x62\x42\x3d\x75\xa4\xfc\xf2\xd4\x91\xf2\x10\x7a\xd9\x1e\x98\x91\xc4\x32\xbb\x45\x6a\x9d\x44\xb3\x05\x28\x3a\x74\x96\xdb\x70\x7c\xfb\xea\xa0\x26\xd0\xb0\x51\x1b\xc8\x5e\x80\xd3\x12\x99\x90\x01\xa6\x21\xaa\xae\xf3\x7b\xac\x5d\xdb\x50\x4e\xe2\x93\x4e\xe6\x75\xc7\xc3\xdf\xe1\x06\x79\x7c\xa9\xd7\xa2\x6d\x87\xaa\x0a\xde\x03\x57\x2f\x81\xf1\x79\x69\xc0\x77\x60\xd9\x5d\x82\xea\x54\xa0\xaa\x8f\x4a\x54\x4b\x9b\x6a\xfd\x5d\x1f\x2c\x95\x2f\x7e\xd1\x7d\x1f\x1d\x1f\xe4\x02\x7a\xfa\x20\xa4\x7e\x37\x17\x60\x47\x3f\x25\x3d\x4a\x1a\xa1\x96\xf2\xfe\xf8\x59\xd3\xef\x18\x3f\x53\x50\xe0\x39\xa9\xf2\xe1\xf8\x36\xbd\xde\x19\xff\xf2\xc1\x0f\x3c\xcf\xc6\x55\xe5\x4e\xe9\x2f\xbb\x41\x3a\x6c\x6f\xd3\xab\xfd\xd0\xfb\x79\x0d\x8f\xaa\xde\xcd\x6c\xfc\xce\xc8\xe5\xf2\x1f\x97\x04\xf9\xfb\x13\x8e\xfc\x97\x67\x65\x9e\xf7\x56\x22\x34\x09\x1e\x96\x46\x7c\x58\x1b\xd1\x16\x87\x6b\x0e\xdd\x97\x47\x3c\xd7\x07\x17\xf2\x7d\x1d\xaf\x65\xbc\x56\x31\x17\xb1\xaf\xe1\xb5\x84\x7d\x05\x63\x01\xfb\xfa\x3d\x97\xef\xb9\x7a\xef\x8b\xf7\x71\x0d\xfe\x08\x1d\xb8\x0b\xe7\x18\x8c\xe4\x47\xd1\xfb\xdb\x79\xf6\x71\xf4\xfe\x38\xc3\x1e\xa2\x77\x5b\x84\x2d\x8d\x8f\xc7\x7f\xbb\x10\x3f\x1e\xff\x71\x09\x7e\x95\x06\xf9\xe6\xf8\x6f\x17\xe2\x7d\xfc\xcb\xd7\x3f\xf0\xb8\x04\xbf\xfa\x81\xd1\xca\x5f\x76\x83\x56\x7a\x43\x34\xd9\x42\x99\x7a\x33\xaf\x2b\x7d\x2b\xff\x6f\x2b\xe3\x4f\x66\x13\x2e\xbf\x2b\x9d\xf0\x23\xd6\xe4\x13\xb6\xff\x97\x6f\xea\xaa\x68\xad\xa1\x43\x0b\x25\x53\x24\xa4\x86\xd2\xbd\xee\x8c\xb0\x8b\x44\xde\xce\x96\xd5\xd8\x54\xc5\xfe\xba\xe2\xac\xe2\x60\x09\xc4\xbf\x91\x31\xe4\x41\x95\x4c\x81\x74\xf7\x85\xd9\x0a\x62\x4d\x03\x88\xba\x4b\x68\x50\xe9\x03\xe7\xee\x17\x72\xb5\xdb\x02\x23\xff\x1e\x80\x4c\xe4\x5e\x00\x80\xa3\x6d\xb1\xcc\x30\xfb\x6e\xe7\x67\xd1\x63\x6f\x61\xca\x2e\xe0\xb7\x64\xf3\x41\xac\x65\x39\xa7\x52\xd1\xe2\x6e\xf1\x5d\xeb\xa1\x80\x86\xae\x15\xf0\xac\x5f\x45\xfa\x65\xcf\x54\xb5\x50\x94\x22\x5d\x04\x70\x3a\xfb\x90\x7b\x07\xac\x91\x8e\xd3\xb1\x03\x2f\x8b\x45\xb2\xc9\x29\x0d\x09\xf2\x65\x01\xd2\xce\x7b\xa2\x38\xd3\x5a\x98\x6d\x67\xb5\x04\x08\xf3\xea\x14\xf3\x95\xfd\x2b\xa4\x50\x18\x47\xd4\x9a\x4f\x55\xba\x3e\xa8\x55\xe3\xfc\xe4\x64\x6d\x92\xee\x44\x2b\x19\x05\x49\x76\x41\x2a\x00\x77\x60\xb1\xb5\x88\xf3\x80\x96\x52\xa8\x63\x17\x30\x97\x39\xcf\x65\x6e\x07\xe8\xaf\x25\xb5\x43\x88\x2b\x07\x8b\x9c\x38\x84\x5e\x26\xe9\xcb\x9a\x78\xa8\xc3\x06\x22\x0f\xf9\x09\xc0\x24\x2a\x1a\x3c\x20\x08\x11\x52\x98\x1e\x38\x91\x97\x90\xd0\x4f\x9b\x1d\xc0\x0f\xcc\xe2\x22\x63\x23\x7c\xae\x07\xe5\xef\x4f\xad\x11\xbf\x7c\xab\x35\xa2\x10\xb8\x2d\x4e\x8d\x83\xcc\xd4\x52\x6b\x23\x15\xfe\x1e\xfd\xd9\x84\x8c\xc6\x12\x62\xe6\x34\xa0\xaf\x41\xd5\x62\x00\x30\x0b\xd7\xd0\x48\xad\x50\x24\xa8\xe4\xd0\xa4\xec\x79\x86\x2a\x61\x56\x8a\x2c\x1e\x93\xb0\xdf\x1d\x14\x02\xd9\x1b\x0b\x0e\x69\x0f\xec\x3c\x9d\xa4\x55\x33\xed\x94\x43\x4f\xea\x11\xa3\x8c\xb2\x92\x67\x73\x3a\x13\x4d\x71\xad\xa1\x21\xe0\x2e\x8d\x65\xca\x8e\xfe\xbb\x1a\x84\xe4\xb6\xd9\x39\x75\x99\x6a\x6b\xab\xd7\x41\x2e\x68\x81\x26\x03\x12\xa9\x65\xb2\xab\x5b\x44\x85\x96\x9f\x6d\xa9\xf9\xde\x6c\xfd\xc5\x41\xdb\x0b\x61\x22\xcc\xd9\x26\xa8\x8e\x3f\xa1\xd3\x49\x5d\x25\x04\x9f\xdb\xb8\x48\xbd\xc3\xf4\xd9\x37\xde\x01\x7d\xbf\x48\x1d\x12\x5a\xa1\x89\xce\x85\xb5\x7a\xca\xa2\x54\xf6\xe3\x34\x76\x2c\xd2\xa1\xa6\x8a\x50\x62\x2b\x10\x59\x81\xd1\x8c\x91\xf6\xc8\x8e\x4e\xb4\x87\x98\x21\x05\xef\xb4\xcc\x90\x13\xca\x12\xed\x62\x7f\xa0\x04\x20\x33\x0c\xc6\xe4\x00\xfa\xd9\x3d\x4b\xe0\x6f\x45\x19\xa3\x85\xa2\xae\x9e\x95\x43\xe4\x74\x06\xa9\xdf\x42\x63\x9f\xf3\x34\x39\x03\x12\x41\xd5\x10\x0b\xc5\x2d\xca\xcb\x38\xa3\x09\xc3\x13\xf4\x76\x4b\xca\xc1\x3f\x7b\xf2\x2e\x25\xb6\x2f\xb2\x67\xa9\xa8\x37\x03\x54\xf1\x72\x2c\x15\xcb\xbc\xcd\x65\xe9\xde\x1c\x94\x57\x24\x25\x31\x85\x12\x1b\x66\x52\xa5\xed\xec\x6c\x75\x68\x83\x2c\x14\xb5\x5c\xdc\x28\xc6\xd2\x8e\x07\xc9\x52\x1e\xe4\x7a\x07\x80\xf2\xb4\x84\xf6\x8c\x92\xc1\x97\xd8\x32\x3a\x38\x6a\xe0\xba\xdf\x05\x3f\xb7\x6e\x48\x73\xaa\xaa\xb6\x47\x5c\x69\xce\x41\x84\xd3\xb4\xb8\xa6\x90\xb0\xdd\xa1\xb7\xa0\x8e\xa1\xa8\x04\x20\x79\x5a\xa6\x81\x0d\xf5\x40\x62\x90\x5c\xa6\x9e\x2d\xce\xcb\x85\x42\x5b\x15\x55\x2d\x6c\x32\x80\x5c\x61\x52\x96\x90\xe1\x93\xcc\x40\x8a\x4f\xe8\x0a\x29\x74\x9e\x34\xed\xb0\x8c\xe4\xde\x9e\x17\xe0\x31\xa1\xc5\xe6\x84\x3b\xae\x01\x28\x54\x80\xa2\xd4\x08\x84\xe2\x26\x6e\x23\x5b\x75\x25\x2c\x26\x76\x2e\x8d\x7a\xb8\x14\x02\x76\xff\x7e\x88\x8b\xc7\x1d\x6b\x81\x9d\x2d\x43\xf5\x14\x04\xe8\x8b\xf5\xb9\xfb\xf3\x56\xb3\xbf\xa0\x11\xa8\x0a\xce\xf3\xb4\x43\xcf\x62\x66\x62\x23\xd9\x06\x79\x52\xe9\xb5\xc3\x95\x90\x86\x79\xec\x39\x95\xd0\xc4\x6d\xc5\x62\xe4\xaa\x29\x93\xce\x06\x4c\xfd\x23\xc4\xae\x10\xa2\x8c\xa3\x9d\x5d\xd5\xbd\x13\x97\x9d\xd7\xa2\x21\xa1\x99\xa7\xee\x9d\xed\x88\xad\xac\x93\xf0\x6b\x50\xbb\xf6\x4e\x45\x0f\xda\xad\x91\x83\xa2\x72\x97\x43\x45\x2f\x27\x52\x9a\x4a\xcd\x83\xd5\x4b\xac\x36\x05\xea\x08\x9e\xe9\xcf\x41\xcd\x4f\x81\x8e\x0a\x1a\xb0\x99\xc8\x40\xc6\xc2\x7f\x9b\x08\x01\x21\x42\x8d\xec\xf1\x30\x35\x01\xac\xcb\x02\xbe\x60\x2c\xba\xcc\x2f\xed\x1d\x8f\x76\xb2\xb3\x69\x87\xa1\xb4\x6b\x01\xc1\x4a\x67\x97\x51\x96\x72\x31\xe3\x57\x34\xd8\x53\xfd\x4c\x42\xe9\xa9\xaf\xe4\x97\x6f\xf6\x95\xc8\x98\xe0\x67\x07\xd3\xf5\xcc\xfb\x0c\xa5\x78\x0d\xaf\xe5\x83\x8a\x4a\x7d\x8b\x83\x3a\x0b\x79\xa7\x29\x95\x05\x41\x52\x17\x6c\x60\xdf\xcc\x02\x08\x6d\x6a\xbb\x50\x9b\x5b\xb5\x0d\x47\xf3\xae\x20\xba\xca\x1a\xda\xde\x17\x70\x51\xea\x16\x8b\x20\x97\x56\x6f\xe9\x96\x36\xf6\xf6\xea\xe0\x94\x2b\x64\xbb\x42\xaf\xab\xf3\x1d\x49\x63\xe8\x92\x9b\x85\x29\x79\x7c\x58\xb9\x18\x2c\x3e\xbc\x4d\xcb\x1f\xd1\x33\xfc\x97\xe3\x9f\xa0\x56\xf1\xf7\xa7\x56\x88\x5f\x9e\x5b\x21\x92\xae\x1d\xbe\x41\x84\xf1\xd3\xea\xea\x3b\x3b\xa1\xcd\xec\xa4\x63\xe6\xd0\xe5\x36\x53\xbf\x8a\x8e\x5b\x9c\xa9\xef\x95\xfa\x3e\x58\xac\x72\x38\xeb\x81\xe7\x71\xf1\x2b\x9d\xb2\xa9\x52\xca\x11\x67\x09\x22\x7a\xfb\x7c\xd2\xe5\x16\x3b\xfa\x57\x9d\xb9\x0a\xac\xdb\xa2\x87\x53\xc2\xfb\xee\x98\xdd\x65\x52\xcc\x1c\x75\x37\x33\x9f\xaf\x89\x4e\x23\x02\xcd\xde\x78\xa3\xd0\xff\x20\xf3\x1c\xdf\xe8\x3c\xc7\x37\x42\xcf\x6f\x74\x9e\x97\xe4\x9f\x38\x81\x57\x96\x7c\xeb\xa4\x71\x5e\x27\xf3\x78\x2e\x0f\xa7\xc2\xd3\x7a\x38\xdd\x5b\xb4\x2f\x52\x6f\xdc\x96\x2c\x59\x2a\xf3\x2b\xf3\xb3\xbd\x0d\x02\xcc\x2c\xea\xbb\xd9\x0b\x42\xb3\x12\xb4\xc7\x90\xa5\xfc\xe0\x43\x1d\xe9\xfe\xe1\xe5\xfc\xf4\xfb\x93\xe9\x09\x77\xff\xcb\xb3\x02\xc6\x8f\x9c\x4c\xad\x0a\x27\x53\xab\xf2\xdf\x93\xe9\xbf\xd8\x64\x7a\xc2\x85\xff\xf2\x8c\x0b\xff\x91\x93\x29\xcf\xca\xc9\x94\x67\xfd\xef\xc9\xf4\x5f\x6c\x32\x3d\xe1\xb0\x7f\x79\xc6\x61\xff\xc8\xc9\x24\x79\x72\x32\x49\x9e\xff\x3d\x99\xfe\x8b\x4d\xa6\x27\xd4\xf0\x2f\x4f\xa8\xe1\x3f\x35\x99\x3a\x5a\xfc\x05\x5e\x3a\x3f\xf4\x17\x60\x01\xf0\x84\x75\x5d\x19\xf0\x7f\xa6\x29\xf4\x38\x83\x2e\xff\xbb\x4d\xa1\xdf\x31\x83\x9e\x80\xa9\xbf\x3c\x93\xd8\x4f\x3d\xcb\xed\xe8\x14\xd3\xd1\x17\xad\x05\xe2\xf0\xcc\x36\x2c\xcd\x5b\x6c\xda\x2c\xea\x6e\xfb\x29\xeb\x84\x46\xbd\x84\xb4\xbc\xa4\x2d\x0e\x0d\xc3\xc9\x47\x78\x80\xe6\x03\xff\xdd\x4a\x09\xa5\xec\xb1\x6b\x98\x42\xba\x85\xa0\xa9\x33\xcb\x04\x4a\xd6\x5e\x10\xe7\x4b\x6f\x01\x28\xab\xc4\x1c\xf9\x70\x6d\x59\xd7\x96\xc6\x5d\x48\xd7\xa8\xb5\xdd\xa0\xb0\xfd\x07\x30\x20\x3b\xc7\x46\xd7\x67\x91\xcb\x81\x66\x5a\x91\xba\xcf\x02\x26\xd4\xd9\xd9\x6c\x85\xb9\xd4\x2d\xbe\xe3\xc9\xf3\xaa\x28\x7b\xc0\xeb\x7e\x7d\x91\x5c\xf8\xec\xde\x49\x90\x1d\x5f\x11\x57\x1c\x6f\xf2\x6d\xc7\x03\x09\xc4\xeb\x8b\xb4\x44\x30\xdc\x3b\x99\xb9\xc7\x23\x8f\x6f\xfe\xc2\xeb\x8b\x8c\xda\x3e\x7b\x3e\x97\x6f\x9e\x90\x4a\xc3\x09\xfd\xc9\xeb\x2a\x69\x38\x28\xea\x2d\xef\xc5\xb7\x2f\xe4\xed\x90\x16\xf8\xea\xf8\x11\x67\x93\x06\x2a\x79\x97\x3f\x3b\x8e\x3d\xf5\x86\x5c\xf2\x9f\x7b\x5a\xf6\xd4\xcd\x24\xfe\xc9\xd3\xb1\x67\x05\x28\xcc\xa7\x4e\xe7\xf2\xf1\xf9\x94\xce\xfc\xc2\x0f\xb8\xcd\x76\x3e\x3f\xe0\x2e\xff\x80\x61\xec\xee\xe4\x51\xfe\xf4\x43\xb7\xab\xd2\xfa\x27\xe7\xe0\xf7\x6d\xf6\x13\x02\xf8\x97\x6f\x22\x80\x5b\x2b\x60\xf6\x3d\x3b\xb8\x1a\x9b\x9c\x91\xa0\xb1\x77\x3f\xa8\xa0\xb6\xf7\x0a\xa8\x22\x24\xe2\x42\x72\x9c\x83\xe8\xd5\x37\xed\x4a\xed\x84\x11\x14\xd5\x52\x26\xa1\xfa\x6a\x17\x1b\xf7\x76\x31\xb2\x48\x60\xfc\x3b\x32\x9c\x2c\x12\x4b\x78\xfc\x26\xa3\x91\x60\x1d\x4a\x5c\x18\x75\xb4\x9b\x4c\xbd\x4a\xcd\xed\xf5\xa5\xa7\x12\xc6\xfb\xc5\x5f\x6f\x1a\xe1\x19\x1f\x67\xa9\xf7\x78\x53\xe1\x35\x87\x65\xf5\xd7\xbd\xfb\xfd\xef\x7c\x3d\x95\x30\xdf\xef\xd4\xfc\xcc\xd7\x47\xd6\x3f\xf3\x75\x78\x5b\xa9\xb6\x3f\x7e\xf5\x09\x9e\x59\xfa\xa3\x27\xf0\x89\x02\xff\x5b\x8c\xca\xc7\x05\xf8\xd9\x6e\xce\xd4\x9d\x40\x24\x2e\x43\x0e\xdb\xd4\xbb\x6d\xc3\x00\x31\x0e\x52\xbb\x17\x6c\x0f\x73\x04\x51\x8b\x6d\x62\x9e\x9b\x6a\x50\x50\x71\x80\xb7\x2b\xa4\x0d\x45\x1e\xbd\xec\x2e\x36\x93\xc8\xe0\x9f\xa1\xb9\x08\xad\x0d\x17\xa1\xc1\xc1\xe8\x6c\xa3\xe4\x06\xc9\x4d\xd5\x07\x8c\xb9\x81\xd6\x9b\x4e\x43\x2a\xd4\x54\x82\xc8\x55\xee\x28\xf1\x0d\x08\xb8\x44\x90\x84\x46\x42\x9e\xf3\xbd\x21\x0e\xef\x80\xa0\xea\x2a\xf5\x5d\x7c\x01\x1c\xd2\x6f\x3e\xc0\xef\xcf\x9f\x8f\x9e\xdf\xe5\xd3\x33\x68\xb5\x5f\xff\x81\x13\x98\xa8\xf0\xfc\xf1\x09\x84\x1b\xf0\x27\x7e\x1f\x37\x40\xcb\xdb\xf5\x7b\xf9\x3d\x33\x18\x6e\xf3\x9f\xbd\x03\x5f\x9f\xc1\xef\x3a\x81\x31\xfe\xcc\x00\xdf\xdf\x27\x9e\xd0\xff\xbf\xfc\x76\xf2\x76\x9a\x27\xcb\x78\x0a\x29\x7b\x14\x16\xfb\x0e\x3d\x0e\xf0\xc7\x10\x72\x95\xa9\x06\x33\x51\x7b\x55\x82\x16\xed\xc5\x4c\x20\xa4\x01\xdf\xba\x85\x47\x79\xa7\x3a\x0e\x0d\xbe\x00\xf4\x2a\xcd\x36\x82\x62\x7f\x0f\xaf\x56\x2c\xcd\x2f\x87\x4a\x69\x59\x65\xe1\x92\xcb\x11\x73\xa5\x1a\x28\xe8\x9b\x40\x9b\x13\xf2\x11\x5b\x90\xba\x43\xfc\x5f\x52\x80\x1a\x75\xd6\xd0\x42\xe9\xbb\x84\x09\xe2\xd7\x5d\xea\x0c\xc0\x71\xa1\x89\x3a\x17\x82\x78\x33\x4a\x73\x32\x88\xfc\xcd\x39\x91\x78\xbb\x74\x3b\x84\x88\x15\x08\x57\x52\x53\x10\x75\xe9\xee\x12\xf8\x8e\x5d\xa0\x30\x14\x37\xb9\xa4\xab\x48\xae\x8c\x10\x50\xbb\x0f\x73\x02\x27\x0d\x94\x05\x86\x90\x2f\xe8\x0d\xcf\xa8\x5d\x2a\xa0\x23\x12\xcc\x94\xe0\x2b\x90\x97\x23\xc1\x10\x0b\xce\x7c\x33\xba\x02\xce\x11\x9d\xb0\x87\xfa\xac\xc8\xd6\x34\x09\xa4\xbb\x77\x7e\x63\x05\x43\x9e\x2e\xa4\xc7\xde\x83\x94\x1c\x5a\x0b\xea\x80\x6b\x6a\xe4\xf7\x43\x15\x74\x8b\x24\x39\x85\x62\xf8\x65\x17\x48\xe5\x06\xe7\x05\x2a\x94\x6e\x95\xb3\x25\xb6\xa3\x80\x95\x96\xd8\x7a\xcc\x69\x58\x6c\x6f\x93\x65\x24\xca\xe7\xe7\xa5\x83\xb5\xd0\x28\x64\x53\x6a\xf5\xfe\x0f\xbe\xc6\x51\x3c\xe8\xe1\xe5\xc3\x11\x8f\xdf\x7c\x18\x12\x00\x48\x5d\x53\x44\x20\x46\xe4\xe1\xf3\x1b\x06\xab\x0e\x66\xa9\x71\xe7\xc0\x45\x10\x6a\x36\xbe\x05\x10\xdb\xcc\x30\x15\x9a\x51\x29\xe4\xa0\xe9\xb2\xd7\x11\x6a\xb1\xe0\x52\xb4\xa3\xed\x9e\xad\x22\xa0\xa0\x04\x5a\x26\x01\xbc\x4b\x44\x11\xa1\xf5\xa2\x54\x91\x42\xd2\x81\xf2\x2f\x2c\xf7\x21\xe4\x9d\x2e\x5b\x03\x15\x7e\x0d\x14\xde\x93\xde\x0e\x36\x10\x08\x23\xc2\x88\x13\x88\xca\x25\x43\xe5\xd1\x69\x77\x12\xc2\xec\xd3\xc5\x8f\x33\x68\x7f\x15\x0c\xde\xa8\x00\x17\x2a\xc9\xae\x92\xa3\xe6\xb2\x67\x14\x66\xdb\x0c\x5a\xca\x01\xf1\x0e\x90\x12\x6a\x11\xb0\x1b\xed\x52\x4a\xe8\x41\xdb\x00\x4f\x8a\x4c\xe7\x59\xe8\xd0\xf4\xf3\xa2\xe4\xa7\xa4\x86\xfe\xf1\xd4\x10\xf2\x6b\xfa\x86\x87\xa9\x16\x51\xea\xb8\x22\x09\xd1\xdb\xb8\x46\xa6\x23\x7a\x5b\x15\xc9\x4f\xa1\x51\x3f\xa6\x85\xfa\x10\xf8\x66\x5f\xf9\x63\xc0\xb7\x7f\x3c\xf5\x19\xfc\xfa\xdc\x67\xf0\x15\xdd\xa0\x22\x01\x33\xbf\x81\x84\xff\xd6\x35\xcc\xf7\x09\x0e\xfe\xc4\x25\x3c\x21\xdb\x7f\xfd\x16\xb2\xdd\x9e\x52\x42\x83\x24\x18\x45\x91\x6a\xaa\xa2\x8e\xf3\xb7\xf7\x2a\x53\x75\xfe\x99\xd6\x76\x9d\x1f\x91\x2f\xe4\xaa\x0b\xd4\x88\x06\x01\x57\xd2\x7a\xff\xae\xc0\x4f\xcc\xf5\x0f\x75\x10\x70\xe0\xa7\xdb\x66\x43\x72\xc4\xa7\x8f\xec\x1b\x8f\x27\x7d\xf9\x1d\x77\xf4\x09\xa1\xfc\xeb\x13\x42\xf9\x0d\x56\xa0\x23\x35\xb5\x89\xb9\xa6\xa5\x79\xfe\x87\x49\x2d\xe6\xb6\xb6\xa8\x39\x83\x97\xca\xff\xbe\x7b\xcc\xfa\xfe\x3d\xa3\x16\x3c\x65\x06\x96\x25\x05\x7d\x6b\xbe\x0f\xf6\xd1\x81\x80\x4a\xac\x81\x1e\x32\x70\x87\xa7\xe7\xde\x0e\x14\xd7\x48\xef\x1c\x79\x8e\x74\x66\xe9\x90\xc5\xc3\xef\x5d\xb6\xc7\x6b\x8a\x7e\x51\x5f\x1f\xf5\xcf\xbb\xf2\x9f\x20\xaf\xbf\x7e\x07\xf2\xda\x43\xd1\xfa\xde\xdd\xfd\x2a\xb7\x69\x81\xb5\xb4\xb9\x79\x84\xdd\xe6\xc7\x47\x7e\xf5\xc0\x1f\xf3\xa0\x6f\x46\x59\x83\x3c\x1d\xf4\x66\xc6\x3d\x66\x1c\xb7\xf5\xe3\x6b\xa0\x77\x8f\xf9\xea\xf1\xbe\x4d\xe3\x5e\xee\x57\x70\x8e\xf6\xfe\x91\xaf\x6f\x6d\xbf\xf9\xd4\xcb\xf8\xdb\xeb\x7f\xde\x39\xf0\x04\x27\xfd\xf5\x09\x4e\xfa\x38\x07\x12\x38\xe6\xc6\x96\x13\x04\x38\xae\xb1\xd5\xb2\x45\x74\x76\xda\x3f\x5b\x2d\x7f\x10\x7a\xf3\xcf\x80\xbc\xf9\xc7\x13\x42\xea\xd7\xf7\x10\x52\x77\xde\xb3\x09\x19\x87\xb4\x13\xe4\x05\x90\x25\x93\x3b\xcd\xd3\x3c\xc0\x76\xee\x94\xd1\x0b\x70\xf2\x41\x18\x51\x9c\x5f\x56\x06\x55\x73\x66\x0d\xc3\x1c\xb6\x11\x40\xaa\x47\x56\xb2\x83\x62\x9d\xc3\xde\xc6\x07\x32\x8f\x11\x64\xec\x3d\x8c\xc0\x8f\x1c\xef\x6a\x6f\xc5\x1e\x3a\x09\x6d\xba\x27\x28\x53\x4b\xa1\x97\xb4\x41\xda\x39\x53\x4a\x1a\xa4\x45\xde\xa0\x97\x9d\x68\x5b\x32\xe8\x62\xf3\xc0\x11\x6c\xdd\x0d\x39\x1d\xf8\xef\x96\xc1\xf9\x69\x1f\x68\x60\x8f\xa0\x5e\x16\x62\x4f\xb7\x6c\x01\xca\xdc\x31\x32\x0e\x89\xea\xec\xcf\x7c\xf5\xfa\x32\xab\x84\xd1\x81\x5b\xc5\xb5\x8d\x75\x6d\x93\xd7\x66\x17\x03\xc1\xec\xc3\xfe\xb3\xdb\xa5\xca\x0c\x94\x76\x18\xc7\x60\x8a\x70\xf8\x25\x65\x73\x5b\xdb\xd8\x51\x05\x43\xab\x59\x22\x95\xb9\xd3\x7a\x76\x47\xdd\x41\x94\x0e\x42\xbc\xe2\xdd\x84\x2a\x6c\xaa\xcf\xe6\x0c\xb3\xa5\xac\x66\xa2\x32\x63\x25\x89\xb0\x40\x1f\xde\x6f\xc0\x1d\xf3\x88\x58\x22\xf3\xc5\xc5\xe9\x73\x85\x8a\x03\xfe\xc2\xe5\xb9\x8e\xe2\x5c\xbe\x88\x1c\x0f\x2a\x87\x2e\x82\x07\x5b\x16\xb5\xd6\x50\x46\xdb\xcd\x09\x07\x89\x24\x59\x73\xa3\x3e\x50\x07\x81\x03\xcb\x8c\xa3\x79\xc9\x25\xa1\xce\x63\xd1\x15\x3d\x7e\xc9\x48\x0e\xee\x90\x9b\xb7\xf9\x84\xdf\xcb\x39\x94\x2f\x75\xc3\x43\xd8\x15\xe9\xd6\x5c\x2c\x32\x6d\xf6\x43\xed\x14\xf6\x45\xa8\x94\xc0\x0e\x1c\xc8\xc0\xae\x28\x24\x35\xcc\xc8\x29\x66\xd9\x06\x62\x50\xb6\xcb\x1e\x51\x32\xe9\xe8\x2e\x28\x44\x52\x1d\x7c\x11\x16\xdf\x89\x53\x33\x25\x6c\x9c\xc6\x0f\x9a\xbd\x24\x0a\xef\xe4\x8c\x25\x6b\x39\xe2\x2c\xdd\xc1\x9d\xcf\xb4\x51\x3b\x62\xed\x61\x0c\x30\xb3\x43\x9c\xd2\x3c\x4b\x05\x7a\x53\x19\x1c\x40\xb6\x05\x1d\x00\x83\x32\x3e\x62\x3e\x7f\x28\x1a\x72\x3f\xa8\x77\x68\xf7\xc4\x05\x77\x24\x07\x08\x1f\x82\xff\x1e\xd1\x65\x60\xa8\x04\x81\xcd\x7b\x52\xaa\x24\xe8\x3b\x96\x40\x9e\x4a\x4c\x14\x80\xaf\x2b\x61\xd3\x51\xc4\x61\xa1\xe4\xe5\xbd\x10\xa5\x0d\xad\x66\x1b\xa9\xed\x94\x4b\x6f\x9c\x79\x6c\xfb\x77\x19\xd4\x08\xb5\x8c\x8d\xac\xea\x8d\x52\x30\x24\xc5\x44\x73\x7c\xfd\xb2\x0a\x74\x4d\x3d\x78\x6e\xe4\x94\xee\x54\xd5\xb4\xa7\x98\x21\x10\x05\x55\x75\xfc\xb0\xfd\xad\xe5\x20\x02\xbb\xa4\x03\xa5\xba\xb6\x17\xb1\xa5\xd2\x3b\x64\xb1\x8e\x4a\x4d\x38\x8b\xa5\x94\xd7\xb3\xa4\xa7\xba\xcf\x2c\x97\x87\xab\xd0\xca\x86\x6e\x58\xc2\x4e\x48\xb1\x01\x6d\xc1\xd3\x7b\x88\xea\xa9\x2f\xac\x21\x97\xcb\xde\x83\xcd\x83\x40\x15\x64\x48\x7a\x26\x0a\x32\x83\xc8\x22\xd9\x6c\xc2\x9c\xb7\x1d\xda\x11\xf5\x95\xaa\x3a\xe8\xe5\xe8\x90\x48\x8c\x0d\x24\x9f\x0e\xdc\xce\x4a\x2b\x49\x42\x5e\x56\x88\xab\xbd\x57\x3d\xf3\x80\x46\x81\xc5\x75\xd9\x7c\xb9\xb5\x8c\x3b\x5f\xd9\xdf\x3c\x12\x93\x32\x10\x1e\x65\x5f\xc5\x74\xda\xc7\x58\xd4\xad\x1b\xf0\xe0\x2c\x6b\x17\x39\x22\x13\x94\xc3\x19\xa1\xb4\xef\x24\xbf\x0e\x82\x2a\xd5\xe1\xe4\x0b\xd4\x26\x23\x27\xb3\xb2\x07\x1a\xb1\xb4\x94\xb3\xdb\xde\x9e\xda\xf4\x26\x8f\x69\x0b\xa6\x50\xc9\x12\x1d\x3d\x23\x07\x69\x1d\x28\xeb\x3c\x83\x86\xd2\x42\x61\xae\xb8\x7c\x62\x63\x64\x03\x02\x77\x44\xcc\xae\xf3\xa5\x6f\x8f\x24\x8b\xf8\xcc\x06\xe9\x47\x9e\xdf\xbe\x8f\xf8\xf0\x3b\x7f\x60\xa3\x7c\x82\xa8\xfe\xda\x57\x42\xad\x8a\x85\x42\x35\xdf\x62\xab\x75\x07\x67\xa6\x90\xdb\x22\x50\x16\x15\xb6\xf7\x4b\xdd\x72\x0f\x79\x6f\x23\x68\xe0\x4d\x3f\x79\x01\xa7\x59\x33\xb3\x84\x45\xaf\x92\x32\x35\x34\xb3\xea\x06\x99\xdc\x79\x8d\x78\x53\xa7\x77\xe2\x43\x63\xca\xcc\xca\xcc\xb6\x06\x83\xb6\x3d\x0e\x6c\x2b\xb9\x6a\xb0\xd8\x8e\xd9\xe5\x3e\x9c\x0f\x9b\x4f\x90\xc2\xb8\xb0\x08\xd7\x5c\x9d\xfa\x1f\xd8\x7c\xb5\xb5\xd4\x29\x0e\x6b\x66\x1d\x96\x5a\x8f\xd2\x88\x1b\x47\x27\xd6\x06\x7d\x88\x76\x1d\xf3\x02\x42\xb9\xdc\x57\x63\xa6\xd6\x73\xea\x29\x89\x85\xa0\x9f\x8e\x84\x43\x38\xfb\xa2\xca\x35\x16\xf3\x9e\x74\x6c\x31\xa3\xd5\x48\xcd\x69\xdc\x44\xa1\xea\xdd\xba\x19\x78\xdc\xb4\xdc\x39\x59\xfb\xdc\x46\x68\x25\xef\x66\xf8\xc1\x8f\xdb\x0a\x56\x3b\xd8\x39\x2a\x04\x96\x8f\xc8\xaf\xb4\x0d\xc4\x05\x5a\x30\xa6\x8f\x7f\xed\x49\x77\xc9\xe8\xcd\xe9\x85\xf2\xe2\x2e\x53\x05\x65\xad\x72\x6e\xdc\x00\x6a\x47\xe8\x98\x50\x70\x83\x29\x66\x24\x45\xc5\x8c\x51\x2f\x41\xfa\x74\x86\x99\x0c\xd6\xf0\x6b\xac\x85\x96\x3c\x2d\x69\x64\x98\x5e\xf6\x91\xa4\x4f\x25\x5b\x9e\xb0\xaa\xbf\x9e\x1c\xd1\x53\x35\xf4\x3c\x6f\xb6\x6e\x20\xae\x13\xbc\x63\x0d\x44\xcc\x16\x93\xd0\x5a\x7b\x07\x09\x4b\x68\x34\xea\xdc\x39\xd1\xb2\xe0\x8a\x52\x5f\xea\x2d\xa7\xb9\x53\x5c\x2b\x44\x41\x9f\x03\x79\xd6\x71\x14\xd5\x34\xb9\x93\x0b\x0a\x18\xb6\xf9\xdf\xa2\x40\x3b\x20\xe3\x31\xc0\x8d\x67\x0f\x85\x3b\x43\x4e\x0a\x5d\xd7\x56\xeb\x27\xe1\xdd\xb1\xdc\x4e\x71\x33\xf6\xe8\x0a\x25\x61\x9a\x49\x14\x5c\x8e\xb4\x7a\xeb\xb7\xf1\xa5\xde\x26\xda\x67\x86\xad\x01\x7b\xec\x97\x03\xcb\xc5\x5c\x3f\xb0\x95\x79\x08\xe4\xbc\xf0\xe4\x23\x0b\xb1\x1d\xea\xbc\xd4\xb8\xf3\x37\x3b\xfd\x5b\x04\xca\x21\x85\x02\x80\xb7\xde\x4a\x57\x0b\x4a\xf4\x16\x4b\xd7\xd7\x97\x26\x85\x1f\xa5\xe6\x1f\xd5\xb9\x45\x56\x32\x05\x4a\xeb\x62\x3e\x35\x76\x65\xb1\x4f\x07\xbe\x78\x95\xd4\x6f\x59\x74\x2b\x14\x07\xbc\xf6\xb6\x95\x1c\xb2\xcc\x9b\x2d\x4f\x88\x32\xce\xd0\xd1\x9a\x04\x66\x7d\x24\xc9\x33\x6f\xb5\xf8\x8e\x2c\xdd\x5d\x60\xa5\x48\x08\x76\x00\x6f\x58\x0e\x20\xa6\xb1\xcb\xbd\x5c\xe1\x45\xda\x49\x5f\xe3\x14\xfe\x7c\x6d\x3b\x63\xb1\x3b\xfc\xc4\x06\x19\x6c\xfc\x80\xee\x98\xb8\x7a\x69\xae\x2d\x54\xa9\x37\x41\xaf\x97\x6d\x4c\xe6\x1e\xd1\x27\x73\xcd\x36\x24\x89\xa9\x65\xdb\x1f\x9a\x27\x01\xdd\xba\x49\xb5\x28\x4e\xba\x5f\xb7\xa4\xad\x87\x9c\x76\xec\xcf\x8d\xf8\xae\xc6\x3e\x9c\xd6\xe0\x5a\x1d\xd2\xc2\xa0\x70\x0d\xf4\xa0\x3e\x13\xef\x7d\xc8\x05\x7a\xf9\x38\xe0\xfb\x88\x0c\xf4\x13\x8b\xec\x09\xc3\xfb\xeb\x13\x86\x57\xa5\xb7\x33\xb3\xc3\x46\x27\x18\x0b\x96\x0c\x59\xac\x1e\xb8\x05\x16\x00\x8f\x86\x96\x54\x21\x5a\x2c\x15\xe7\x65\x09\x52\xd2\x01\x89\xc3\x20\x1d\x4d\xa0\xd2\xd9\x6e\x64\x36\xcd\xce\x9e\x02\xc4\x88\x4e\x9a\x1e\x79\x8a\x73\xe1\xd6\xa4\xa1\x24\x8b\xb8\x5d\x1f\x5d\x2b\x5a\xd8\xcc\xdf\x69\x4e\x3d\x65\x5b\x31\x85\xff\x6a\xa6\x3a\x26\xa5\x69\x51\xd1\x84\x06\x72\xf3\x9e\x2e\x5b\xb4\xcd\x4e\x27\xc9\xa0\x16\x84\x05\x0e\xd0\x54\x2e\x63\x2f\xc5\x36\xe7\x5e\x42\x1b\x48\xe3\xcd\x50\x07\x5b\xaf\xcd\xac\x36\x0b\x81\xba\x59\x0d\x52\x85\xc1\x41\x41\xcc\x44\x02\x0b\x74\x2b\xf1\xda\xc8\x71\xa1\x14\xd4\xe3\xcc\x4a\x9e\xbc\x76\x0f\x99\x9b\x14\x1a\xd0\x5a\x82\x0f\x56\x32\x26\x8b\x17\x00\x0a\xe4\x54\xd8\x40\x24\xd4\x91\x92\xad\x40\x8d\x1d\x39\x77\x34\x88\xc1\xbc\xb0\xf3\x3e\x67\x5a\x00\x28\x3e\x32\xde\xdc\xa1\xc0\xc3\xb2\x6e\xa7\x27\x07\x6a\x62\xf3\xe9\xbf\xdc\xd5\xe6\xfa\x42\xf4\x51\x0c\xe3\xb2\xb3\x73\x86\xa4\xc2\x53\x1f\xd8\x0f\xc7\x81\xe5\x64\xb6\x1e\x12\x04\xb1\x05\x2d\xab\xd3\xf8\x50\xf8\xf9\xd4\x96\x27\x2f\x4b\x77\x4c\x59\x9d\xb6\xbd\x6b\xd9\x15\xcd\x7b\xd8\xd6\xb1\xde\xb3\x47\x5c\x88\x96\x8b\x3b\x9a\x10\xea\x43\x99\x08\x66\x67\xf0\x9d\xd2\x20\xe4\x87\xe9\xc6\xb6\xb2\x48\x36\x76\x78\xbe\x11\x65\x53\x94\xd9\x08\xc5\xec\xa4\xe8\x61\x8f\x71\xec\xd3\x65\xeb\x70\xe5\x1b\x47\xdf\x31\x99\x2d\xb8\x42\x9f\xeb\x65\x97\x59\xc3\x9c\x21\x4b\x09\x3a\xe6\x81\xbe\x3e\xb1\x89\x60\xd7\xda\xec\x6c\xb0\x35\x66\xb8\xdd\x36\x5f\x75\x8f\x1d\xca\x75\x08\x65\x09\x9d\x2c\x0e\x9d\x64\xe7\xaf\xdd\x0d\xea\x6b\xda\x43\x1b\xd0\xbf\x07\x96\x8f\xf2\x4c\x2d\xb3\x9d\x30\x37\x54\xf6\x7a\xc6\x7e\xa0\x50\x46\x8c\x15\xdd\xc1\xd2\xb3\xd9\x3f\xf0\xcb\xa1\x28\x1f\xd6\x7e\x67\x31\x65\x72\x06\xdb\x9a\x82\x6f\x32\xe8\xec\x23\x2c\xcf\x42\xa2\x38\x07\x49\x51\xf0\x98\x29\xd3\xde\x20\x90\xa2\x70\x9c\x87\x5e\xd0\x8f\xed\x1a\x70\x58\xb3\x54\x35\x19\x14\xf0\x59\x94\xd0\x54\x12\x25\x99\xbb\x2d\x35\x42\x04\x6a\x50\x8f\xf4\xc8\xe0\xe4\xd5\x99\x23\xd6\xec\x16\xbd\x76\x37\xa9\x35\x39\x83\x2b\x49\xd9\x3b\x8c\xbd\x56\xc6\xaf\x16\xa5\xd5\x3b\x1f\x24\xed\x18\xe5\xc2\x9c\xd3\x62\x53\x0b\xff\x44\xd0\x8f\x3e\x4b\xd0\x99\x76\x74\x3e\x6a\x10\x88\x5b\xd4\x9d\x04\x21\x28\x79\x4a\xd9\xc5\xc2\x3d\x0b\x22\x4b\x3d\x0a\x62\x47\xa9\xc3\xd6\x76\x4e\x44\x2d\x94\xcb\x91\xed\xdb\x72\xe4\x44\x4c\x6a\xdf\x55\x61\x77\x6d\x3f\xc8\xa8\x60\x42\xa6\xb6\xf4\x4f\x34\xd4\xfd\xe3\x09\xc1\xfe\xeb\x33\x82\xfd\x21\x77\x96\x0b\x09\xc4\x94\x9d\x74\x30\x97\x2b\x5d\x42\xb9\x4e\x75\xad\x53\x4e\xd7\xba\x16\x17\xd4\x05\x60\x57\x9b\x53\x4c\x31\x99\x83\x9e\x68\x42\x8a\x28\xac\x1a\x25\x41\x00\x3c\x07\x36\xb4\x2f\xbd\xaa\xb9\x20\xca\x9d\x72\x21\x66\xc0\xc9\x98\x04\x70\xaf\x19\x96\xdc\x0f\xd8\x9a\x71\x2e\x52\x8b\x92\x94\xab\xf4\x90\x3b\xcf\x13\xd2\x0c\xe3\x24\xd9\x6c\xe6\x3c\x91\xa8\x1b\x50\x9a\x3e\x2e\x3b\x44\x8f\xc0\x9c\xc5\xe2\x5d\x54\xb5\x58\xd0\x13\x2a\x5e\x51\xb4\x1f\x25\x05\x94\xb6\xe6\x6d\x93\x5a\x25\x58\x60\xa3\x02\x03\x4c\x93\xc5\xa2\x5f\x3d\x9b\xb3\xf1\x34\x77\x09\x45\x02\x92\x60\x65\xa9\x1a\xb5\x72\x68\x09\x83\xe2\x28\xa1\x67\xf0\xfe\x63\xad\xa2\x29\xb1\x1f\x82\xe5\x06\xb2\x2b\x7c\xd0\x8e\x5c\x2c\x86\xcf\x07\x98\xf8\x60\xd2\x06\x8a\x8a\x16\x29\xa7\xa0\x3d\x58\x30\x43\x51\x59\x76\x26\x16\x68\x65\xd4\xd0\xd4\x59\xbe\xca\x29\x81\x3e\xa7\xb9\xc3\x6e\xb8\x49\xa0\xa7\x8b\x30\x8d\x4a\xb0\x5e\x46\x9f\xc3\x13\x32\x68\xb3\x5f\x44\x6f\x58\x47\xf6\x35\x07\xe8\xce\xe3\x7c\x71\xff\xf0\xfe\x8d\x73\x94\xfb\xc8\x0f\xbf\xf7\x70\x1a\xe7\xd9\xd9\x13\xaa\x1a\xa6\x54\x20\xd4\xbc\xeb\x9e\x8c\xaa\xb2\x88\x15\xf8\x18\xe6\x6a\xd2\xce\xd0\x41\x67\x06\xcd\x65\x9f\x74\x1e\x11\x8b\x46\xe5\xbe\x8d\xe8\xec\x17\xa6\xc2\xb3\xdd\xf7\x32\xb9\x7f\x56\x62\xc6\x4f\x3e\x5d\xd4\xdf\x6d\x8b\x40\x5d\x5e\x58\x0e\xe7\x03\x4b\x3d\x88\xb6\x43\xb3\x5a\x9c\xaa\x98\xce\xf3\x50\xa0\xe2\xcb\xa1\x70\x1e\x09\x35\xee\x83\x0e\x89\xad\xd7\x4a\x9d\x59\x51\x39\x40\x3e\x88\x2a\x5e\x9b\x29\xd4\x9e\x77\x51\x7b\x94\x40\xd3\x83\xab\xb3\x99\x65\x6b\x14\xb9\xdf\xe3\x20\x11\x7e\xa8\x98\x34\x3b\xc8\xf2\x0a\xda\x7f\x63\x4d\x9c\x2a\xa2\xe9\xa0\x3e\x3d\xb6\x7b\x97\x4b\x9a\x93\xfb\x6d\x1a\x97\x23\x52\x3a\xc7\xb5\xb5\xc5\x41\x7d\xcd\x2c\x27\xd0\xf5\x4e\x46\xce\x55\x50\xa0\x17\x98\x06\x65\xa7\xe1\xe4\xdb\x0f\x95\x20\x9a\x0f\x6a\x12\x71\x33\xab\x35\x80\x57\xee\x13\x26\xe8\xa9\xef\xe1\xd7\x9f\xff\x8f\x07\x55\x4c\xad\x6d\x81\xe1\x45\x57\x5b\xb4\xb4\x20\xed\x26\xed\x1a\x2d\x62\x7b\x7c\x8f\x8c\x8c\x8d\xff\xbb\x96\x71\x23\xa5\xed\x7a\x83\xb7\xd7\x26\x87\xe8\x5f\x31\xec\x03\xe8\xff\x0f\x0e\x7b\x79\x77\xdc\xc7\x86\x81\x1f\x79\xbe\x8f\xbd\x06\x3f\x6c\x5c\x70\xcd\x95\x92\xee\x5c\x73\x70\x3d\x06\xc9\x0e\xe8\x12\x5f\xe3\xc8\x8a\xfc\x30\x05\x5d\xd5\xa6\xa2\x8e\xd0\xc6\x22\x9a\x2b\x29\xe0\xdf\x07\x3e\xbd\xda\xe1\x38\x9a\xdf\x3f\x38\x9c\x47\x29\x8a\xaa\xb4\x9e\x8c\x07\xf8\xff\x15\xba\xb3\x4e\x48\xfc\xf0\xae\x88\x37\x55\x98\x3b\xd5\x56\x04\x6d\xb3\xcc\xae\xe8\xf1\x2d\x1f\xbd\xb4\xf2\x17\x8e\xde\x35\xd9\xe8\x97\xbf\x68\xf8\xd9\xdb\x5f\x78\xf2\xa2\x59\x7f\xc8\xf0\x97\xaf\xc7\xff\xbe\xe1\x78\x6a\x77\xf9\xf5\xb9\xdd\xe5\x41\x05\xa5\x5a\x0c\x2a\xa8\xc5\x82\x10\x73\x13\x94\xd9\x52\x87\xbf\x61\x71\x9c\xd3\xa1\x9e\x79\x17\x46\x3e\x70\x3f\x49\x5f\xe4\xa5\xa1\x32\x42\x33\x77\x12\x5a\x86\xa9\x6d\xd5\x63\x22\x4a\xf0\x32\x01\x4e\x7e\xd4\xe6\xf2\x3f\xa7\x9b\x59\x74\x03\x63\x4c\x4e\x69\x8b\xda\x25\x88\x99\xb7\x2c\x79\x83\x43\xae\x79\xec\x4e\xd9\x81\xf0\x62\x32\xef\xe3\xdb\x97\xbb\xe7\x24\xbe\x81\x37\x81\x6d\x01\x62\x57\xa8\x5d\x8d\x9b\xb9\x28\xfb\x1b\x21\xd5\xcb\xfb\x30\xf5\x1b\xe5\xc3\x58\xf6\x1a\xfb\x49\x14\x92\xe9\x26\x29\x7e\xa4\x9e\x3f\xab\xcc\x40\xe1\x44\x2c\x08\x9e\x38\x5f\xcd\xe3\x66\xe7\x8e\x2b\x89\x52\x1b\x2f\x2e\x66\xe8\x76\x67\xe6\x14\x7d\xe7\x50\xbf\x1b\x5e\x36\xd4\x60\x77\xc8\x6e\x9d\xb4\xc4\x5b\x19\x05\x42\xc2\x7c\x18\x88\x3f\x18\x96\xcc\xa5\x28\x9d\x01\x4a\x68\x8b\xb3\x46\xa7\x53\xc4\x6d\x7c\x10\x9d\x8f\x36\xe7\x0b\x88\x1c\x1a\x99\x25\xe6\x81\x3a\x15\xf1\x71\x95\x8a\x9e\x35\x81\x78\x7d\xcb\xc8\xc8\xeb\xc6\x07\xd1\xd7\x13\xe9\x5b\xf4\x4f\x90\xef\x17\x9e\x90\x40\x85\xd6\x8c\x19\x72\xaa\xb8\x8d\xb6\xb9\x5a\xd4\x6b\xb6\xaa\x6d\xfc\xf5\x35\x2f\x3a\xae\xe5\xac\x56\x62\x5e\x9d\xe7\x9e\x49\x77\x33\x42\xec\x6b\x1e\xb6\x2d\xf2\x6e\xe0\x4a\x21\x88\x8d\x7b\x74\xdc\x6f\xdb\xba\x95\xdb\xba\xcb\xdb\xba\xf1\xf6\x18\x2e\x5b\xf4\x87\x82\xc7\x09\xda\x17\x7b\x54\xc7\x7a\x70\xeb\x49\xfa\x93\x5d\x8f\x7a\x5b\xb3\xe0\xc6\xc9\xf3\xad\xd6\x1d\x4c\xb0\xcd\x67\xdb\xce\x5f\xf1\x49\x78\xac\x59\x79\xce\xd3\xfb\xd4\xe5\x64\xe6\xf9\xd9\x24\xf7\x29\xcf\xf9\xbf\xf9\x82\xb0\xf5\x93\x7b\xf0\x75\x72\x3c\xac\x9d\xb5\xa0\x70\x87\x6c\xa9\xf9\x13\x6f\x97\x9d\xb7\x98\x2b\xf2\x58\x4b\x14\x2b\xd1\xe2\xdf\x2f\x27\x29\xd2\x7d\x71\x9f\x93\xad\x6f\x6e\x09\x76\x45\x8e\x0f\x9b\x14\x82\x81\x58\xb2\x37\x79\x24\xf0\x95\x45\x19\x2b\xe3\x99\x83\x70\x76\x34\x3d\xa7\x7d\xdf\xce\x17\xfc\x64\xc7\xf4\x43\x3d\x2f\x9d\xda\x1d\xc8\x25\x9d\x50\x4d\x48\xb2\xe8\x27\x3a\x44\xfe\xf1\xd4\x21\xf2\xeb\x37\x3b\x44\x4a\xcf\xa1\xa5\xbe\xf7\x00\x41\xb7\x9c\xbd\x9d\x91\xa5\xd7\x61\xeb\xbf\xf7\x20\xd9\xfc\x65\x95\x00\x3a\xf7\x68\x2e\xe2\x9d\x0a\x38\xab\x5d\x3d\xc4\xf4\x3d\xe9\x8b\x4c\x0a\x84\x2c\x3d\x16\x02\x23\x1a\xb8\x71\x03\x70\x43\xf8\x09\x44\xc0\xf6\x13\x42\xa9\x55\xfb\x11\x65\xc9\x8f\xac\xf1\xf6\xf4\x6c\x35\xe7\x50\x27\x70\xc4\xe0\xa0\x3f\x2c\x32\xf6\x94\x23\x20\x26\x35\xb7\x8d\x24\xe3\xd9\x36\x05\x86\xb7\x9d\x6e\x36\x48\x99\xa9\x93\x1c\xb3\xca\xc5\xdb\x00\x20\xcd\x89\x45\x61\x36\x13\xb4\xd4\x80\x10\x1f\x31\x83\xb7\xc5\xfc\xee\x2d\x4e\xf0\x72\x65\xdd\x72\xe9\x21\x17\xc4\xa0\x29\xd0\x3f\x66\x18\xc1\xbc\x12\x65\x98\x55\x28\xbb\x2b\x03\x4d\x7f\x21\x97\x74\x28\x63\x39\x0c\x9d\x51\x9e\xc5\xd0\xbb\xcd\x24\xd5\x50\x53\x0a\xad\x1d\xfc\xf3\x89\x67\xfb\x84\xea\xfe\xf5\x5b\x9c\xee\xb3\x8c\x50\xd3\xd8\x90\x82\xc9\x3a\xaf\xb1\xca\xc6\x6c\x64\x35\x1b\x8a\xe2\x57\x4d\xd7\x58\xe6\x26\x7d\x86\xdc\x0b\x64\x1d\x73\xde\x14\x7a\x87\x4c\xe8\x25\x9b\xb9\x16\xda\xa4\xd7\x97\xda\xa0\xde\x97\xb6\x9c\x10\x66\xd8\x30\xac\xdd\x02\x13\x53\x82\xe4\xf4\xfa\x32\x53\xb7\xa0\x6b\x7d\x3f\x53\x4e\x32\x42\x58\x52\xf3\xb4\xbb\xf3\xfa\x22\x60\x55\x6e\x75\x13\xf6\x7c\x6e\xcc\x67\x4e\x1b\x72\xa6\x30\xc4\xe2\x9a\x91\xbc\x7a\x08\xd2\x74\x24\x27\xcb\x3d\x39\xe9\xe9\x74\xa6\x27\xfb\x3d\x3d\x79\xe1\x8b\xd8\xce\xec\x65\x5c\x69\xd4\xe6\xaa\x04\x14\x3b\x86\x55\x2c\xc7\xfa\xfb\xe6\xd3\x37\x5f\x5c\xc3\x71\xfc\xe3\xf1\x37\x1f\x4f\x86\x27\xf8\x9f\x8c\x07\xba\xfc\x19\x40\xd0\xff\x7c\x82\xff\xfe\xf6\x0c\xff\x7d\x68\x0a\xce\xb9\x84\x9c\xb0\xf1\xa9\x39\x3e\xa0\x21\xb4\x90\x7e\x9e\xa2\x26\xcc\x97\x31\x43\x5c\x9d\xab\xbd\x06\x5b\x51\xd9\xb9\xc4\xbc\xf3\x07\x35\xb7\xee\x3e\x14\x0a\xec\x58\xc6\x29\x03\x42\x81\x56\x5f\x12\x3c\xda\x5c\x42\xb5\x8e\xf9\x38\x3c\x33\xa2\x4f\xf0\x5f\x3e\xdb\xc0\x82\x58\xc8\xcb\x3f\xab\x2e\xba\x3b\x59\x75\x99\xc1\xb7\xfa\xbe\x7a\xcf\xce\x17\xd5\x0b\x68\x9e\xd8\xb7\xc7\xeb\x39\xed\x4a\x47\x23\xbb\x97\x04\x04\x38\x76\xfc\xe9\xc5\x3f\x47\xcb\xc8\xe1\xf2\x2f\xab\x12\x5f\x7d\x5b\xcb\x60\x24\xb7\x0d\x64\x94\x60\x41\x79\x11\xec\xbc\xb3\x40\xe4\xb1\xb7\x10\x9b\x53\xe0\x59\xc4\x52\x64\xa9\x37\x7b\x21\x97\xb2\xbf\xde\x3c\x71\x38\x45\x5d\xf7\x5e\x0d\x57\xd4\x06\x97\xe0\x21\xe2\x60\x80\xdd\x82\x6f\x66\x1e\xa5\x1e\x99\xde\xcd\x8e\x72\x6b\x9f\x41\x26\xb5\xae\x03\xca\xa1\x7b\xbb\x2b\x2d\x3b\x43\x3a\xb8\xcc\x40\xe5\x65\x36\x00\xce\x12\x5d\xbf\x0a\x47\x67\xd2\x00\xfa\xa9\xb1\x32\x3c\x02\x51\x5a\x20\x0a\x70\x0d\x20\x0b\xf1\x0b\xe0\x03\x61\x04\x24\x3c\xa7\x1e\xc8\x27\x3b\xa7\x7e\x23\x77\x9f\xa2\x6a\x55\x6c\x82\xdb\xb6\x48\x82\xb5\x3c\xf8\xab\xed\xec\x40\x20\xf9\x64\xf7\x92\x28\xfd\x3d\x8a\xf6\x63\x53\x49\xf9\xe8\x25\xc4\x5e\x76\x34\x21\x06\x9c\x2b\x25\xd7\x89\xc6\x22\x25\x7e\x39\x34\xc1\x81\x78\x7d\xc9\x23\x07\x20\x95\x88\xe4\xe0\x54\x76\x78\x6d\xfd\x42\x76\x7c\x24\xb0\xd5\x81\x26\xc2\x8e\x13\xd4\xf9\x4a\x40\xb6\x17\xa9\xff\x03\xde\x01\x28\xe7\xd0\x2a\x84\x1a\x46\xef\x44\x8c\xf5\x30\xbe\x9c\xfd\x62\xea\xbb\xd2\x1d\xa6\x33\x0e\xc7\xf0\x08\x3b\xd3\x3a\x69\xc8\x71\xb8\xa6\x25\x50\x8d\x63\x57\xca\x9b\xe4\x8e\x3d\x34\xe0\xdd\x06\x59\x13\x49\x85\x97\xb3\xa7\xa6\xd1\xcb\x43\x0f\x2f\xdb\x4c\x30\x07\xa9\x8e\x5d\x86\x4d\xc4\xc2\xd2\xe0\x51\x5d\x5a\x75\xf7\x58\xc0\xf6\xc1\xca\xc6\x19\xdc\x59\xf6\x67\xa0\x44\x51\x14\xf9\x6c\x1d\xb8\xd9\xcd\x95\x3d\x4e\xad\xf7\xb4\xc0\x76\x4c\x86\x99\xc1\xce\xa1\x41\x20\xb1\x66\x64\xb0\x27\x80\x3b\x41\xf2\x51\x49\x99\x0a\xb0\x18\x18\x27\x74\x6f\xd3\xcb\x82\xae\x8b\xca\x55\x48\xb8\x8b\x26\xd8\x87\x99\x48\xaa\x09\xe2\x4c\xf3\x80\xd5\x79\x2d\x1c\x90\xa4\x7d\x49\x8d\x47\xff\x7a\x49\xcb\x75\xf1\xc6\x8b\x4c\x6e\x49\x6c\x4c\x10\xa5\xd1\xd3\xf7\x93\x99\x03\x94\xd3\x2f\x80\x62\xf5\xcc\x79\xd5\xca\x0e\x98\x0b\x92\xa2\xec\xaa\x01\x06\x0a\x57\xa2\xe3\x88\xe6\x8a\xd8\x9c\x0e\x92\x59\x03\x6b\x01\xbc\x75\x03\x1f\xb3\xf0\xa0\x95\x0a\x16\x64\x23\x30\x87\xca\x7c\xa3\xac\x61\xa0\x2e\x23\x66\xdd\xcb\xa9\x3d\x29\xcd\x02\xbb\xc3\x55\x79\x1a\x88\xf2\x34\x80\x40\x2e\x91\x63\x4f\x74\xf1\xb8\x3a\xd1\xea\x48\x4b\x19\x40\x2c\xf4\xfa\xb2\x9a\x99\xf6\xca\x05\x34\x6c\x76\xf6\x83\x25\x07\x73\xef\xf0\x62\x72\x19\x0f\x2a\xf2\xbc\x5e\x5e\x8a\xc5\x16\xaa\xe0\x5f\xb6\xbb\x3b\xef\xf7\xd2\x6b\x71\x0c\x76\xa7\x83\xc4\x4e\x00\x81\xcb\x02\x2e\x7d\x71\x7b\x30\x50\xbe\x2c\xab\x8a\x87\x2f\xa2\x9c\x49\x70\xca\x5c\x33\x1a\x03\xb3\x46\x2f\x35\xe5\xbd\x70\xc1\x3b\x98\x82\xe0\x29\x59\x05\xf3\xea\x60\x52\x25\xf6\xd1\x96\x0a\x32\xe5\xe2\x3a\x59\xc3\x16\x7e\x09\xd9\x51\x10\xe0\x46\x05\xa3\x8c\x8c\x94\x42\xad\x90\x17\xb6\x93\x3b\x0b\x8a\x0e\x60\x81\x8b\x38\xa9\x97\xd8\xc2\x42\x52\xe6\xa5\x4a\x9f\x3b\x6b\x05\xaa\x66\xa9\x0a\x83\x99\x78\xae\x4f\xe2\x3e\x5e\x44\x80\xd4\x63\x8a\xc2\x56\x24\x6b\x13\x3c\x79\x7a\xf7\x98\x8c\xb0\xac\x8d\xee\xae\x6f\x20\x4c\xf8\x17\xa7\x74\xb4\x3d\x00\x64\x8d\xf3\xc0\x02\x28\xe3\xa8\x23\xcc\x83\xa0\x3c\xbb\x9a\xa1\xa1\x4f\xc5\xcd\x22\x95\xe0\x83\xdd\x62\xfb\x52\xa5\xd9\xea\xe7\xc6\x56\x9d\x9a\x1a\xf7\xad\x9a\xe9\x1a\xc0\xed\xb7\x8b\x3d\xed\x1c\x1c\x9b\x76\x78\x43\x1a\x94\x77\x81\xfb\xcd\x79\x67\x1f\x94\x2b\x0d\x96\xb9\x80\x6c\xc5\x77\x20\x9c\xc3\xe4\xc6\x67\xd1\x34\x08\xa0\x43\x99\x66\x14\x2d\xee\x85\x2b\x20\x47\xa1\xe9\xfa\x8c\x3f\xf2\xd4\xab\xf3\xdb\x47\xbd\x3a\xdf\x1d\xea\xa9\x67\xe6\xb7\xa7\x9e\x99\xcf\x0e\xf5\xd4\x2c\xf2\xdb\x47\xcd\x22\xdf\x1d\xea\xa9\x25\xe1\xb7\x8f\x5a\x12\xbe\x3b\xd4\x13\xb2\xfd\xb7\x8f\x90\xed\xdf\x1d\xea\x09\x17\xfe\xdb\x47\xcc\x99\xdf\x1d\xea\x09\x39\xf7\xdb\x33\xb9\xe3\x77\x87\xfa\x3f\xdb\x7c\xc2\x4a\xfd\xf6\xcc\xeb\xf7\xc9\x53\x7a\x42\x84\xfc\xf6\xcc\xea\xf6\xc9\xa1\x9e\x2a\xa2\xbf\x7d\x54\x11\xfd\xee\x50\x4f\x95\x8d\xdf\x9e\x19\x9d\x3e\x39\xd4\x53\xae\xf3\xb7\xe7\x5c\xe7\x27\x87\x7a\xca\x27\xfc\xf6\x51\x3e\xe1\xbb\x43\x3d\x85\xaf\xbf\x7d\x14\xbe\x7e\x63\xa8\xed\xb7\x7f\xff\xf7\xdf\xf6\xff\xf7\xa7\xed\xab\xc1\x6a\xfa\xa8\x4f\x91\x83\xfd\xeb\xbf\xfc\xaf\xff\xe7\xff\x3e\xfe\xed\xf2\xaf\xff\xf2\xeb\x6f\xff\xeb\xdf\xff\xed\x5f\xff\xe5\xdf\x6f\xff\xd7\xbf\x5d\xfe\xbf\x00\x00\x00\xff\xff\xae\xf1\x3b\x5f\xdb\xc7\x06\x00") + +func uiAppLibFontAwesome470FontsFontawesomeWebfontSvgBytes() ([]byte, error) { + return bindataRead( + _uiAppLibFontAwesome470FontsFontawesomeWebfontSvg, + "ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.svg", + ) +} + +func uiAppLibFontAwesome470FontsFontawesomeWebfontSvg() (*asset, error) { + bytes, err := uiAppLibFontAwesome470FontsFontawesomeWebfontSvgBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.svg", size: 444379, mode: os.FileMode(420), modTime: time.Unix(1, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _uiAppLibFontAwesome470FontsFontawesomeWebfontTtf = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xcc\xbd\x0b\x7c\x54\xd5\xb5\x3f\xfe\x5d\xfb\xbc\x66\x26\xf3\x3e\xf3\x48\x26\x93\x64\x9e\x67\x02\x89\x01\xe6\x19\x79\x24\x23\x20\xaf\x04\x44\xa5\x95\x22\x62\x44\x50\x14\x50\x54\x14\xa4\x3e\x8e\x95\x5a\x54\xaa\x88\x68\xa9\xb5\x36\x3e\x0b\xb7\xd6\x72\x5b\xed\xd5\x16\xbd\xd3\x97\xb5\xad\x5a\x5b\xb9\xd6\x5a\xdb\x9b\xb6\xda\x7a\x2b\xda\x40\xad\x57\x21\x73\xf2\xff\x9c\x73\x66\x92\x49\x00\x6d\xef\xfd\xfd\x7e\x9f\xff\x7c\x72\xce\xd9\xef\xbd\xf6\xda\x6b\xef\xbd\xd6\xda\x6b\xef\x80\x00\x38\xa0\x82\xc3\xe2\x39\x73\x96\x2c\x5c\xfb\xcc\xdc\xa7\xc0\x6e\xda\x01\x20\x3c\x77\xf6\xa9\x73\xd8\x20\x78\xb0\x9b\x36\x00\x88\x9c\x76\xe6\xa4\xf4\xb6\xf4\x96\x22\x40\x4b\x01\xf4\x9d\xbf\xfe\xbc\x0d\xb6\x7f\x9f\x7a\x3d\x60\xdf\x03\xb0\xc3\x17\x9e\x77\xc5\x86\xe1\x61\x70\x60\x37\xad\x01\x60\xb9\x70\xdd\xd5\x17\xdc\xfe\xdf\x8f\x2d\x04\x42\x8f\x82\xf5\xee\x5f\xb3\xfa\xbc\x55\xee\x9b\xdf\x3c\x09\xc0\xeb\x00\xf2\x6b\xd6\xac\x3e\xcf\xc5\xd9\x9e\x00\xc8\x07\x20\xb1\x66\xfd\xc6\xcd\xa7\x5e\x5d\xff\x59\x80\x9e\x04\x6c\x83\xeb\x2e\x3d\xff\x3c\xf6\xf7\x07\x96\x03\xae\x7b\x81\x3a\xf7\xfa\xf3\x36\x6f\xe0\xda\x59\x18\xa0\x4e\x1d\x9e\x4b\xce\x5b\xbf\xfa\x8f\x5f\xb8\xf5\x51\xb0\x0b\xd7\x00\xfc\x4d\x1b\x2e\xbd\x62\xe3\x37\x6e\xff\xd2\xfd\x60\x6b\x07\x81\xd0\x95\x46\xdb\x78\xfa\xd9\x8e\x9f\x6f\xfe\xd4\xb9\xae\xe9\x7f\x47\x9d\x04\xfd\x77\x20\xf3\x42\xba\xfa\x1d\x1e\x1e\x86\x95\x44\xdd\x6b\x01\x33\x72\x40\x7f\x8b\x18\x06\x60\xc5\xf0\xf0\xf0\xb0\x95\x2a\xe1\x23\x3f\xf6\x84\x1e\xc2\x7e\xc0\x1a\x90\x32\x03\x8c\x5c\x7a\xaa\x62\x25\x09\x27\x5e\x44\x3b\x20\x00\xfc\x76\x3e\x03\xe0\x26\xf3\xcb\xae\x00\xe8\x16\x7c\xc4\x6f\xc3\xd5\x97\x5f\x81\x22\x22\x7f\xaf\xc0\x20\x9a\x95\xd7\x42\x10\x01\x71\x2a\x36\x18\x15\x7f\x02\xa0\x12\xa0\xb7\xec\x1f\x78\xce\xd1\x5b\x2a\xaa\xa3\x61\xba\x5b\x7f\x04\xdd\xaf\x8e\x8d\x93\x80\xab\x05\x15\x97\x54\xd3\x88\xd5\x3c\x00\x04\x33\x2c\x24\x56\xfc\x92\x8a\x74\x35\xcd\xf1\x1e\x3d\x1f\x6f\x96\x5d\xd4\xd3\x71\x15\xbf\x51\xb7\x3a\x5a\x6e\x05\x06\x9b\x50\x85\xb3\x26\x0d\x5f\x53\xff\xc7\xb6\xb5\x02\x0b\x8f\xd1\x6f\x6d\x7b\xa5\xb1\x61\x5b\x84\x5a\xd8\x6b\xe2\x45\x06\x12\x80\x7b\x04\x60\xd9\x89\xda\x76\x9c\xa7\x58\x29\x27\xa7\x3f\xd2\x68\xb8\x43\x50\x47\x70\xb7\xa5\x16\x37\xc2\x58\xbc\xbb\x85\x71\x7d\x51\x49\xb7\xcc\x78\xd4\x9a\x76\x98\xb8\x2c\x4a\x06\x01\x8f\xc5\x77\x15\x0f\x35\xf5\x83\x53\x6b\xf0\x30\xda\x27\x23\xed\xae\xfd\x56\x61\x15\x46\xe3\xdb\x79\xe0\x5c\xb1\xa6\x6f\x04\x75\x4c\x7d\x7a\xbb\x59\x2d\xcc\x27\x7c\x54\xf8\x2b\xed\x16\xc6\xf5\xbd\xbb\xf2\xbd\x42\x02\xa8\x92\x86\x1f\x4f\x4b\x12\xe0\x1a\x03\xb7\x8a\x46\xa9\x8a\xf7\xca\x63\xad\x94\xc9\x57\xfa\x92\xa9\x28\xb2\x0a\xde\xaa\x61\xfc\x38\x58\x25\xa0\xb5\x96\x8e\x38\xd5\x84\x61\x3c\xcd\x48\x35\xed\xaf\xe9\xbb\x62\x2d\x4e\x46\xe2\x54\xb3\x7f\x2a\xed\x1a\x81\x91\x07\x4e\xe2\x01\x07\xaf\x62\xa1\xfe\x30\x15\x27\x31\x75\xd4\x5f\xad\x83\xaf\x8c\x17\x71\x2c\xfd\x16\xc5\xf1\x34\x3d\x8e\x5e\x6a\xc6\x66\x35\xae\x58\x19\x7f\x0e\x49\xc5\x49\x95\xbc\x4c\x50\xc1\xaa\x38\xa9\x7c\xfb\x74\x3c\x31\x15\x2b\x45\x40\xd0\x1f\x49\x05\x89\x15\x58\x04\x15\x8e\xea\xf8\x14\x54\x70\xa2\x8a\xc4\xf1\xfa\xbb\x82\x17\x7b\x75\xec\x57\xc3\x48\x1d\x83\xef\x7c\x35\x9c\x07\x38\xfd\xf9\xb8\xf1\x55\xd3\x77\x59\xee\x33\x00\xcf\x81\x17\xaa\xe3\x08\xe8\xac\xa1\xb1\x98\xfe\x48\x30\x1f\xb1\xfa\xd4\xcc\x67\x22\xd0\xa8\xd3\xe0\x38\x1a\xae\x1b\xdf\x8e\x4a\xbd\xb3\x8d\x31\x04\x70\xfa\x53\xc1\x67\x75\x3c\x57\xd3\x8d\xe4\x15\x80\xf6\xca\x77\x64\x1e\x92\x2a\x61\x95\x7e\x88\x48\xea\xf0\x70\xed\x9c\x2a\x00\xfe\xe3\x8c\x95\x91\xb1\xaa\xa7\xb1\x8c\x9b\x8f\xab\x63\xdf\x6a\xa6\x5f\x2f\x8e\xa7\xe9\x4a\xda\xea\xfc\x20\xbd\x8f\x09\xe3\xc7\x53\x05\xce\xea\xdc\x6c\xb4\xcb\x5a\x9b\x67\xf4\xeb\xb6\x8c\x86\x47\xaa\xfd\x61\xfd\xc7\xe7\x46\xfd\x49\x55\x61\xae\xc0\x1f\x91\x00\xb9\xa6\x8e\xd9\x15\x78\x4e\x96\x00\x6f\x4d\xba\x5a\x98\xbb\x04\xa0\xfe\x38\xf3\xc2\xf8\xa7\x41\x02\x56\x89\xc0\xa7\x2a\x70\x4f\xac\x94\x63\x95\x80\x94\xb5\x02\xfb\xf8\xc7\x02\x38\xf5\x47\x50\x8f\x5f\xbe\x65\xdc\xb7\x8a\xdf\x9a\x7e\x30\xdc\x02\x50\x67\x19\xd7\x7e\xcb\x38\xb7\x65\xbc\xbb\xd2\xbf\x15\xbf\x2c\xd6\x94\x59\xa1\x71\x56\xa5\xab\x9a\xf9\x96\xe9\x63\xd4\x02\x88\x95\x38\x66\x81\x39\x2e\x84\x71\xf8\x13\x6a\xca\xb2\x8c\x83\x61\x3c\x4d\x58\x3e\xc0\x12\x6b\xc5\x7f\x3c\x3c\x55\x69\xdb\x32\x8e\x06\xaa\xf1\xd2\xc7\xd0\x86\x34\x0e\x8e\x11\x1a\x78\x62\x4c\xdc\x08\x3d\x0a\xc0\x05\x46\xde\x27\x47\xcb\x1f\x69\xff\xd8\x3e\x09\x88\x80\x53\x02\x9a\x8e\x47\x17\x95\x79\x3c\x69\x39\x7e\xf8\x19\xe3\xe0\x3b\xd5\x3a\x96\x56\xc7\xb7\x2d\x71\xbc\x76\x55\xca\x8e\x8a\xc0\x5a\x1e\x68\xad\x84\x73\xe3\x79\x18\xb1\x4a\xef\xaa\x41\x8f\x5c\x75\x8c\x57\xca\x1f\x49\x2f\x0c\x23\x29\x56\xd6\x23\x61\xec\xfc\xe0\xaa\xa5\x11\x71\xec\x9a\x9f\xb4\x8e\xad\xcb\x3f\x8e\xbe\x8e\xa1\x8d\x9a\xf0\x26\x6b\x0d\x5e\xc6\x3f\x35\xbc\x05\x8d\x1f\x17\x23\x0f\xab\xa1\x75\x15\x93\x75\x9c\x57\x60\x9c\x54\xc3\xa3\x28\xd2\x47\xb1\xc4\x15\x8e\xba\xf2\x84\x2b\x0c\xf1\x41\x70\x86\x2b\x0c\x9e\x5e\xd2\x19\x67\x14\x21\x60\x32\x22\xd8\x8b\xc7\xf0\x38\x9e\xc5\xab\xd1\x58\xac\x39\xd6\x37\xe8\x1c\x6c\x1e\xec\x1a\x5c\x34\xb8\x62\xf0\x92\xc1\xeb\x06\x6f\x1b\xbc\x6f\xf0\xb1\xc1\x6f\x0e\xbe\x38\xf8\xbb\xc1\x77\x07\xb5\x43\xce\x43\xcd\x87\x3a\x0e\x75\x1d\x5a\x74\x68\xc5\xa1\x4b\x0e\x5d\x77\xe8\xb6\x43\xf7\x1d\x7a\xec\xd0\x33\x87\x5e\x3c\xf4\xbb\x43\xef\x1e\xd2\x0e\x3b\x0f\x37\x1f\xee\x3a\xbc\xe8\xf0\x8a\xc3\x97\x1c\xbe\xee\xf0\x6d\x87\xef\x3b\xfc\xd8\xe1\x67\x0e\xbf\x78\xf8\x77\x87\xdf\xfd\x3b\x86\x87\x0d\x7e\x7c\xcf\xb8\x1a\x31\xe8\x1e\x8c\x0e\x16\x07\x17\x0f\xf6\x0d\x6e\x18\x54\x07\x77\x0c\xf6\x0f\xee\x1b\x2c\x0d\xbe\x34\x38\x30\x38\x78\x08\x87\xdc\x87\x22\x87\x26\x1f\x2a\x1e\x5a\x7c\xa8\xef\xd0\x86\x43\xea\xa1\x1d\x87\xfa\x0f\xed\x3b\x54\x3a\xf4\xd2\xa1\x81\x43\x83\x87\x71\xd8\x7d\x38\x7a\xb8\x78\x78\xf1\xe1\xbe\xc3\x1b\x0e\xab\x87\x77\x1c\xee\x3f\xbc\xef\x70\xe9\xf0\x4b\x87\x07\xf4\x1a\x87\xff\x38\xbc\x7c\x78\xe9\xf0\x99\xc3\x33\x87\xa7\xfc\xee\xad\xdf\xbe\xf3\xdb\x47\xdd\x0e\xb7\xdd\x6d\x73\x5b\xdd\x16\xb7\xe4\x16\xdd\x82\x9b\x77\x73\x6e\xe6\xfa\xbb\xeb\x3d\xd7\xdf\x5c\x87\x5d\x87\x5c\x83\xae\xbf\xba\xde\x75\xbd\xe3\x3a\xe8\x7a\xdb\xf5\x17\xd7\x7f\xb9\xde\x72\xfd\xd9\xf5\x27\xd7\x9b\xae\x37\x5c\x7f\x74\xfd\xc1\xf5\x7b\xd7\x80\xeb\x77\xae\xdf\xba\x5e\x77\xfd\xc6\xf5\x9a\xeb\xd7\xae\x57\x5d\xbf\x72\xbd\xe2\xfa\x0f\xd7\x01\xd7\xcb\x8e\xef\x8f\x97\x7d\xfe\x5f\xfc\x74\x81\xac\x5a\x2d\xb1\x8a\x7c\x35\x26\x81\x49\x0a\xff\x7f\xf8\x89\x82\x4d\xe2\xed\x16\x6b\xdd\xff\xad\x0a\xda\xff\x07\xcf\x0e\x53\xa6\xa6\xdd\x00\xdb\x08\xb0\x97\x00\xae\x17\xe0\x06\x01\x7e\x09\x20\x26\x00\x71\x00\xb0\xac\x03\xac\x9b\x01\xeb\x4b\x80\x6d\x09\x50\xd7\x0a\xd4\x1d\x00\xec\x5b\x01\xc7\x2a\xc0\xb9\x07\x70\x1d\x00\xdc\x5b\x01\x0f\x00\xcf\xbd\x80\x77\x1d\x20\xb7\x03\xf2\xab\x80\x4f\x05\x7c\x43\x80\x7f\x07\x10\xc8\x02\x41\x37\x50\xbf\x0a\xa8\x7f\x1e\x68\xd8\x00\x84\xe6\x01\xa1\x5d\x40\x63\x02\x08\xaf\x02\x9a\xda\x81\x66\x0b\xd0\xbc\x11\x68\x69\x05\x22\xdb\x81\xc8\x20\x10\xed\x07\x62\x93\x81\x78\x04\x48\xb4\x03\x89\x01\x40\x99\x0d\xa4\xde\x00\x5a\xef\x05\x26\x2c\x01\x26\xea\x4b\xf7\x7e\xa0\xdd\x0d\xb4\xbf\x07\x9c\xf4\x2a\xd0\x51\x04\x3a\x5e\x05\x26\xf5\x01\x93\xf6\x03\x93\x7d\xc0\xe4\x87\x80\x29\xbb\x80\xf4\x0e\x20\xb3\x0a\xc8\x66\x81\xec\x2e\x20\x17\x01\x72\x2a\x90\x7b\x12\xc8\x47\x80\xfc\x72\x20\xbf\x1f\x28\xcc\x03\x0a\x7b\x80\x4e\x3b\xd0\xd9\x07\x74\x3e\x0e\x9c\xdc\x0b\x9c\xfc\x38\x30\x75\x0d\x30\xf5\x20\x30\xad\x04\x4c\xdf\x00\xcc\xd8\x00\x74\x4d\x07\xba\xde\x00\xba\xd7\x00\xdd\xaf\x02\xc5\x79\x40\x71\x3f\x70\xca\x64\xe0\x94\x27\x81\x99\x4b\x81\x99\x1f\x00\xb3\x56\x01\xb3\xee\x05\x66\xf7\x02\xb3\xdf\x00\x4e\x7d\x12\x98\x73\x2f\x30\x77\x32\x30\xf7\x75\x60\xde\x41\x60\xfe\x76\x60\x41\x27\xd0\xf3\x28\xd0\xfb\x06\xb0\x70\x15\xb0\xa8\x1d\x58\xa4\x02\x8b\x0e\x00\xa7\xed\x03\x16\xf7\x01\x8b\xf7\x00\xa7\x67\x81\xd3\xfb\x81\x33\xec\xc0\x19\xeb\x80\x33\xdb\x81\x33\x77\x03\x4b\xfa\x80\x4f\x4c\x06\xce\x1a\x04\x96\xbe\x0e\x2c\xb3\x00\x67\x17\x81\xb3\xb7\x03\xcb\xa7\x03\xcb\x3f\x00\xce\xd9\x0d\xac\x68\x05\x56\xbc\x01\x9c\xdb\x0f\xf4\x6d\x00\x56\xb6\x03\x2b\xdf\x03\x56\xf1\xc0\xaa\x83\xc0\xea\xc5\xc0\xea\x97\x80\x0b\x7e\x08\x5c\xd8\x07\x5c\xb8\x07\xb8\xa8\x17\xb8\xa8\x04\x5c\x3c\x1b\x58\x6b\x07\xd6\x1e\x00\xd6\xa9\xc0\xfa\x22\x70\x49\x3b\x70\x69\x2f\xb0\x61\x2b\x70\xd9\x43\xc0\xe5\xaf\x03\x57\x6c\x06\x36\xba\x81\x8d\x7b\x80\x2b\x67\x03\x9f\xee\x03\xae\x01\x70\xcd\x7e\xe0\x5a\x37\x70\xed\x43\xc0\x75\xdb\x80\xeb\x77\x01\xea\x7e\xe0\x86\x7a\xe0\x86\xed\xc0\x8d\xf3\x80\xad\x3e\x60\xeb\x01\xe0\xb3\x7b\x80\xcf\xbe\x01\xdc\xb4\x0e\xf8\x5c\x11\xd8\xb6\x1b\xb8\xb9\x04\xdc\xea\x06\xb6\x3f\x07\x7c\x7e\x3b\x70\xdb\x3a\xe0\xf6\x79\xc0\x8e\x08\xb0\xa3\x04\xdc\xb1\x04\xd8\x69\x07\x76\xce\x03\x76\x6e\x05\x76\x96\x80\x9d\x43\xc0\x9d\x7d\xc0\x9d\xcf\x01\xbb\x78\x60\x57\x11\xd8\x35\x08\xdc\xa5\x02\x77\x27\x80\x2f\x2c\x07\x76\x2f\x05\xbe\x18\x06\xee\x99\x0d\xdc\xf3\x24\xf0\xa5\xdd\xc0\xbd\xfd\xc0\x97\x97\x00\xf7\x2d\x05\xee\xfb\x00\xf8\xca\xbd\x40\xff\x6c\xe0\xfe\xc5\xc0\x03\xed\xc0\x03\x0f\x01\x0f\x76\x02\x0f\xee\x01\x1e\x5a\x05\x3c\xbc\x1c\xd8\xb3\x03\xf8\x9a\x05\x78\x34\x0c\x3c\x7a\x10\xf8\xfa\x0e\xe0\xeb\x6f\x01\x8f\xa9\xc0\x37\xea\x81\x6f\xec\x03\xf6\xcd\x03\xf6\x0d\x00\xff\xba\x19\xf8\xd7\xe7\x81\x6f\x46\x80\x6f\x6e\x04\xbe\xf9\x1c\xf0\xad\xa5\xc0\xb7\xde\x03\x1e\xdf\x00\x3c\x01\xe0\x89\x55\xc0\xb7\xc3\xc0\xb7\x0f\x00\xff\xf6\x38\xf0\x6f\x83\xc0\x93\x9b\x81\xa7\x36\x02\x4f\x7d\x00\x7c\xe7\xf9\xd1\xe7\xbb\x7b\x80\xfd\x5b\x81\xa7\x8b\xc0\x33\x3c\xf0\xef\xcf\x01\xa5\x1f\x02\xdf\xb7\x03\xdf\xdf\x0e\xfc\x60\x39\xf0\xc3\x08\xf0\xc3\xfd\xc0\x8f\xdc\xc0\x8f\x9e\x04\x9e\xdd\x05\x3c\x37\x19\x78\x6e\x00\xf8\xc9\x2a\xe0\x27\xcf\x03\x3f\xdd\x03\xfc\x4c\x05\x7e\x36\x00\x3c\xff\x1e\xf0\xc2\x2e\xe0\xc5\xcd\xc0\x8b\x6f\x01\x3f\xdf\x07\xbc\xb4\x1d\xf8\x45\x3b\xf0\x8b\x6d\xc0\x2f\x2d\xc0\x2f\xb7\x01\x2f\xdb\x81\x97\xb7\x03\x2f\x1f\x04\x0e\x74\x02\xff\xd1\x0e\xfc\xc7\xbd\xc0\x2b\x7d\xc0\x2b\x6f\x01\xbf\x5a\x07\xbc\x3a\x0f\x78\xf5\x71\xe0\xd7\x7d\xc0\xaf\x7f\x08\xbc\xb6\x04\x78\xed\x49\xe0\x37\xf5\xc0\x6f\x76\x01\xaf\x17\x81\xd7\x9f\x03\x7e\xbb\x0e\xf8\xed\x20\xf0\xbb\xad\xc0\x7f\xd6\x03\xff\xf9\x28\x30\xb0\x1f\xf8\xfd\x3a\xe0\x0f\x1b\x80\x3f\x46\x80\x3f\xbe\x01\xbc\xa1\x02\x6f\x3e\x07\xfc\xa9\x04\xfc\xb9\x1e\xf8\xf3\x41\xe0\xad\x37\x80\xff\x7a\x15\xf8\xcb\xab\xc0\xdb\xaf\x02\x07\x0f\x00\xef\xbc\x04\xbc\xfb\x3a\xf0\xd7\x37\x80\xc3\x3c\xf0\xb7\xf7\x80\xf7\x54\xe0\xef\x59\xe0\x7d\x37\xf0\xfe\xbd\xc0\x7f\xd7\x03\x1f\x2c\x05\x3e\x28\x01\x1f\x26\x80\x23\xeb\x80\xa3\xfb\x81\xa1\x56\x60\xe8\x49\xa0\x6c\x07\xca\x7d\x40\xf9\x71\x40\xb3\x00\xda\x93\xc0\xb0\x05\x04\x1f\x48\x78\x1c\x24\xbe\x07\x92\x3e\x00\x59\x5e\x02\x59\x57\x81\x6c\x6e\x90\x6d\x37\xa8\xae\x1e\x64\xe7\x41\xf6\x87\x40\x8e\x76\x90\x13\x20\xd7\x36\x90\xa7\x1d\xe4\xe9\x07\x79\x9f\x07\xc9\x9d\x20\xf9\x0d\x90\x6f\x07\xc8\xdf\x0a\xf2\x3f\x04\x0a\x2c\x05\x05\x86\x40\xc1\x12\xa8\x7e\x2b\xa8\x61\x33\x28\x74\x0d\xa8\x71\x09\x28\x7c\x00\xd4\x54\x04\x35\x1d\x00\x35\xef\x00\xb5\xf0\xa0\x96\x6b\x40\x91\x87\x40\xd1\x12\x28\xb6\x19\x14\xb7\x80\xe2\xeb\x40\x09\x1e\x94\x78\x1e\x94\x5a\x03\x6a\x7d\x0b\x34\xb1\x17\xd4\xbe\x04\xd4\xd1\x0b\x9a\xb2\x11\x34\xe5\x3d\x50\x7a\x00\x94\x99\x0c\xca\xec\x03\x65\xf7\x80\x72\x1b\x41\xf9\x25\xa0\x42\x02\xd4\x69\x07\x9d\x3c\x0f\x34\xd5\x0d\x9a\x3a\x08\x9a\xb6\x03\x34\x7d\x2b\x68\xfa\xab\xa0\xee\xa5\xa0\x62\x18\x74\x4a\x09\x34\xf3\x39\xd0\xac\xe7\x40\xb3\xef\x05\x9d\x3a\x0f\x34\x67\x1e\x68\xee\x06\xd0\xbc\x79\xa0\xf9\x9b\x41\x0b\x22\xa0\x05\x6f\x80\x7a\x0e\x80\x7a\xfb\x41\x0b\xeb\x41\x8b\x8a\xa0\xc5\x45\xd0\xe9\xfd\xa0\x33\x06\x40\x67\xce\x06\x2d\x89\x80\x3e\xd1\x0b\xfa\x64\x1f\xe8\x93\x07\x40\x67\x2d\x05\x2d\xcd\x82\x96\xf6\x83\x96\xf1\xa0\x65\xdb\x40\x67\xaf\x02\x9d\x3d\x00\x5a\x7e\x0d\xe8\x9c\x57\x41\x2b\xfa\x41\x7d\xbb\x40\xe7\xcd\x03\x9d\xb7\x1f\xb4\x72\x10\x74\xfe\x52\xd0\xaa\x47\x41\xab\x37\x82\x2e\x58\x03\xba\xf0\x75\xd0\x9a\xc7\x41\x17\x2d\x07\x5d\xbc\x19\x74\xc9\x56\xd0\x86\x22\xe8\x8a\x01\xd0\x55\x6e\xd0\xa6\xe7\x40\x9b\x77\x80\xae\xde\x06\xda\xb2\x1d\xf4\xe9\x35\xa0\x6b\xb6\x83\xae\x0d\x83\xae\x7d\x08\x74\xfd\x72\xd0\xf5\xbb\x41\xd7\x7f\x00\x52\xd7\x81\x6e\xd8\x08\xfa\xcc\x0e\xd0\x8d\x59\xd0\x8d\x0f\x81\xb6\x3e\x07\xfa\xec\x3e\xd0\x4d\x0f\x81\xb6\x6d\x04\xdd\xbc\x1d\x74\x4b\x27\xe8\x56\xfd\xe9\x07\xdd\xd6\x0b\xba\x6d\x0f\xe8\xf6\x25\xa0\x1d\x6e\xd0\x1d\x3e\xd0\x9d\x3b\x40\xbb\x7c\xa0\xbb\x78\xd0\x5d\x43\xa0\xbb\x3f\x00\x7d\xa1\x1f\xf4\xc5\x6b\x40\xf7\x3c\x07\xba\xd7\x0d\xfa\xb2\x05\xf4\xe5\x57\x41\xf7\x5d\x03\xfa\x4a\x3d\xe8\x2b\x6f\x81\xfa\x7f\x08\x7a\xc0\x0e\x7a\x30\x0b\x7a\x68\x33\xe8\xe1\x7d\xa0\x47\x54\xd0\x57\x7b\x41\x7b\xc2\xa0\x3d\x3b\x40\x7b\x0e\x8e\x3e\x7b\x97\x82\xfe\xa5\x15\xf4\xb5\x08\xe8\x6b\xcf\x83\x1e\x7d\x14\xf4\xf5\x3d\xa0\xc7\x22\xa0\xc7\xb6\x81\xbe\xc1\x83\xbe\xb1\x07\xb4\xaf\x08\xda\xb7\x0d\xf4\xed\xfd\xa0\x7f\x5b\x07\x7a\x72\x00\xf4\xd4\x46\xd0\x77\x78\xd0\x77\x76\x81\xbe\x9b\x00\x7d\xf7\x21\xd0\x7e\x0b\x68\xff\x66\xd0\xd3\xbd\xa0\x67\xf4\xe7\x21\xd0\xbf\x47\x40\xa5\x79\xa0\xef\xd5\x83\xbe\xf7\x43\xd0\x0f\x78\xd0\x0f\xde\x00\xfd\xb0\x1f\xf4\xa3\x25\xa0\x67\x5b\x41\xcf\x1e\x04\x3d\x67\x07\xfd\xc4\x0e\xfa\xe9\x36\xd0\xcf\xfa\x41\xcf\x7f\x00\x7a\x31\x0c\xfa\xf9\x2e\xd0\x4b\xeb\x40\xbf\x58\x05\xfa\xe5\xeb\xa0\x97\x17\x83\x5e\xfe\x00\xf4\x1f\x5b\x41\xaf\x6c\x06\xfd\x6a\x03\xe8\x57\x43\xa0\x57\xdf\x03\xbd\xf6\x28\xe8\x37\x4b\x40\xaf\x2f\x01\xfd\xd6\x0e\xfa\xed\x20\xe8\x77\xdb\x40\xff\xd9\x0b\xfa\xbd\x0a\xfa\xc3\x07\xa0\x37\xea\x41\x6f\xda\x41\x7f\x9a\x0e\xfa\xf3\x3c\xd0\x9f\xf7\x80\xde\x4a\x80\xde\x3a\x00\xfa\xaf\x75\xa0\xbf\x84\x41\x7f\x39\x00\x7a\xfb\x0d\xd0\xc1\x2c\xe8\xe0\x93\xa0\x83\xef\x81\xde\x19\x04\xfd\xd5\x02\xfa\xeb\x43\xa0\x41\x1e\x34\xf8\x3c\xe8\x50\x04\x74\x78\x31\xe8\x6f\xeb\x40\x7f\x7b\x0b\xf4\x77\x3b\xe8\xfd\x76\xd0\xfb\x25\xd0\x7f\x6f\x06\xfd\xf7\x00\xe8\x83\x0d\xa0\x0f\xdb\x41\x47\x36\x83\x8e\x6e\x04\x0d\xd9\x41\x43\xab\x40\x65\x3b\xa8\xbc\x1d\xa4\x65\x41\xfa\x7c\x31\xfc\x12\x18\x65\xc1\x58\x18\x8c\x6b\x07\xe3\xd7\x80\x09\x07\xc0\xa4\xc5\x60\xd6\x2c\x98\xed\x00\x98\x7d\x00\xcc\x31\x08\xe6\xaa\x07\x73\x67\xc1\x3c\x6f\x80\xc9\xd3\xc1\x7c\xed\x60\xfe\x76\xb0\x40\x16\x2c\x38\x19\xac\xbe\x13\xac\x21\x01\x16\xda\x06\xd6\xd8\x09\xd6\xf4\x38\x58\xf3\x12\xb0\xe6\xe7\xc1\x22\xd7\x80\x45\xd7\x80\xc5\x1e\x05\x4b\xf4\x82\x25\x27\x83\x29\xf3\xc0\x52\xdb\xc0\x5a\xdf\x03\x9b\xb0\x1d\x6c\xe2\x64\xb0\x89\xaf\x83\xb5\xed\x02\x6b\x7f\x1d\xac\x23\x01\xd6\x71\x10\x6c\xf2\x41\xb0\x29\x5b\xc1\xd2\x45\xb0\xf4\x10\x58\xe6\x49\xb0\xec\x46\xb0\x5c\x02\x2c\xff\x1e\xd8\xc9\x11\xb0\xa9\xdb\xc1\xa6\x1e\x00\x9b\x66\x07\x9b\xb6\x0d\x6c\x7a\x2b\xd8\xf4\x57\xc1\x66\x64\xc1\xba\x9f\x04\x2b\xee\x06\x3b\x65\x00\x6c\x56\x3f\xd8\xec\x21\xb0\x39\xbb\xc1\xe6\xf5\x81\xcd\x7b\x0f\x6c\xfe\xf3\x60\xbd\xfb\xff\x77\x0f\x36\x00\x9c\x5b\xd4\x99\x7f\x09\x28\x44\x3d\x51\xce\x13\xf5\x0c\x50\x49\x2b\x6e\x60\xfd\x1b\x84\xc8\x91\x0d\x22\x8e\x18\x5c\x33\xe1\x9c\x61\x88\x0f\x0a\x2a\x9a\x74\x5e\x58\x22\x4f\x34\x1d\xf0\x89\xf1\x68\x4c\xc9\xe6\x33\x51\x0f\x29\xb9\x6c\x17\x65\xa2\xe9\x66\x12\x1f\x6c\x2b\x6f\xa3\x62\x48\x51\x42\x43\xaa\xfe\xa6\x62\x79\x5b\x5b\xa2\x35\x28\xa8\xc1\xd6\x84\x30\x27\xde\x56\xde\x56\x86\x92\x55\x94\xac\xc2\x81\x6d\x6e\x8b\x07\x1b\x2d\x96\x46\x43\x0a\x19\x86\xa8\xcb\xed\x6d\x00\x79\x7c\x4e\x16\xeb\x60\xd9\x2e\x96\x49\x07\x3d\xc2\x58\x6f\x36\x5f\xa0\x7c\x26\x1d\x10\x31\x7b\xcd\x85\xcb\x2e\x5c\x33\x7b\xf6\x9a\x0b\x4f\xba\xe8\xac\xf2\x58\xaf\xd2\xcc\x15\xed\xee\xd6\x4e\x21\x72\xb4\x3f\xbd\xa8\xcd\xef\x6f\x5b\xb4\x6a\x51\x9b\x3f\xc5\x1a\xde\x29\x4f\xab\x0d\xe0\x7e\xdc\x92\xb1\x11\xf8\x4e\x5d\x32\x1a\x86\xa8\x0a\x2a\x24\x44\x01\xb8\x11\xd1\x1f\xf2\x89\xf1\x58\x8a\xc4\x78\x2c\xa1\x30\xb7\x37\x9f\x88\xf0\x01\xaf\xdf\x27\x51\x80\x57\xb5\x0f\xb5\xdb\xb4\x0f\x49\xa2\xcb\x39\xa9\x37\x9b\x4f\x68\x7b\xbf\xf5\xfa\xed\xda\xd1\xa7\x2f\xbd\xf4\x69\x12\xa8\x99\x84\xa7\x2f\xbd\x86\xce\x4a\x32\x89\x2e\x27\xc9\x4c\xac\xa9\xd9\x5e\x85\x3e\x79\xcd\x68\x8a\x4b\x9f\xd6\x8e\xde\xfe\xfa\xb7\xb4\xbd\x49\x43\x14\x1b\x56\x25\x08\x40\x08\x33\xb0\x10\x48\x7a\x44\x89\x97\x9c\xac\x8d\xc5\x3a\x28\xa5\x24\x95\x94\xc7\x17\xc8\x44\xd3\x79\xcf\x74\xd6\xc1\xc5\xa3\x31\xd1\xef\x0b\x06\x82\xcd\xfc\x34\x96\xee\xe2\x0a\xf9\x42\x17\x15\x3c\x66\xe7\xe4\x3c\x7a\xf7\xa4\x03\xa2\x1a\x49\x6a\xef\xdd\x97\x29\xae\x9f\x4c\x34\x79\x7d\x31\x73\x9f\xf6\x5e\x32\x22\x3b\x84\x92\x43\x26\x41\xb4\x5b\x8e\x14\x1d\xf2\x9d\xdf\x7b\x49\x9c\x1a\x2b\x74\xf8\x88\x7c\x1d\x85\xd8\x54\xf1\xa5\xef\xe5\xcf\x51\x57\xcc\x3c\x52\x9c\xb9\x62\xc5\x4c\xa1\x34\x73\x45\x84\x43\xa2\xf9\xc5\xad\x6d\x93\xa7\x4c\x99\xdc\xb6\xf5\xc5\xe6\x44\x19\x0e\x59\xe6\x5b\x99\xd7\xea\xb1\xd8\x04\xd9\xb1\x67\xe3\xee\x87\x85\x29\xa1\xa4\xd7\x9b\x0c\x4d\x11\x1e\xde\xdd\x76\x47\xdf\xd1\x92\x9e\x9b\xd7\xcb\x30\xfb\x58\x6f\x9b\x8a\x30\xc0\xc7\x52\xd4\xc1\xe7\xb2\xf9\x4c\xba\x99\x05\xbb\xb8\x4c\x3a\xa0\xe3\x94\xbb\x27\xeb\x2d\xef\xb0\xc5\x7b\xa7\x4f\xd2\x06\xba\x6e\xb8\x74\x71\x22\xb1\xf8\xd2\x1b\xba\x06\xb4\x37\xcb\x77\xa8\x5e\xb6\xcc\x92\x38\x77\xd5\x6d\xb3\x5e\xff\xa0\x6d\x7e\x31\x91\x28\xce\x6f\xfb\xe0\xf5\xdf\xbe\x59\xde\x63\x96\xfd\x75\x51\x15\x06\x10\x33\x69\x54\x0e\xf8\x8d\x7e\x4b\x0a\x62\x3c\xa6\xe4\xb2\x05\x59\x27\xd3\x42\x52\xce\xa7\x83\xb2\x10\x10\xd5\x90\x76\xd7\x27\xc9\xef\x93\xfd\x5a\xb7\xd6\x1d\xf0\xfa\xfd\xec\x93\xda\xae\x86\x4e\x7a\xff\xf7\xf2\x74\xf9\xf7\xf4\x7e\x27\x77\x75\x20\xa4\xdd\xa7\xd9\x25\x87\xbf\xc9\x7e\xf0\xa0\xbd\xc9\x2f\x3a\xe9\x3d\x5a\xd9\xe8\x4f\x5a\xe7\xd3\x8f\x27\x4c\xd0\x4e\x9e\x6f\x85\x29\x51\x57\xea\xb6\xea\xd4\x6b\xa5\x64\x1d\x09\xc4\x25\x85\x2a\x1c\x27\x06\x83\xbf\x8c\xd2\xda\xb2\xa7\x9f\xd6\x96\x51\x7a\x3e\x6d\xa1\xab\xe9\xc7\x06\x5c\x13\x4e\x0c\x16\xf3\xd1\x84\x2e\xba\x4e\xfb\x4c\x97\xf6\x2b\xed\xec\x1f\xff\x98\xb3\x55\xc1\x4c\x7f\x04\x94\x3a\x8c\xaa\xa0\xe3\xde\xaf\x8f\xe2\x64\x85\x42\xb2\x5d\x5c\x26\x10\x29\xa4\x9b\x39\xb8\xc5\x88\xe2\xce\x47\x04\x5c\xbb\x74\xe8\x5f\x96\x5e\xeb\xe9\x98\x7b\x65\xef\x8d\xb4\xee\xc6\xde\x2b\xe7\x76\x78\x86\xf1\x7b\xed\xfb\xbf\xff\x3d\x75\xdd\xbc\xfe\xde\x7b\xd7\x7f\xe2\x0b\x5f\x5c\x7f\xaa\xaa\x9e\xba\xfe\x8b\x5f\xe0\xbe\x67\x86\xff\x1e\x40\x9d\x3e\x7e\x24\x7d\xfc\xb8\xd0\x82\x49\xe8\xc6\x69\x38\x17\x97\xe2\x7a\xdc\x8e\xaf\xe0\x1b\x80\x90\xcb\x2a\x6d\x14\x13\x9b\xc8\x17\x98\x46\xe9\xbc\xe7\x63\xfc\xe4\xc9\x2a\x06\x85\x57\x48\x9e\xc6\xc7\xff\x93\xe9\x3f\xae\xbe\xf1\x03\x87\x54\x25\x64\xcc\x62\x27\x78\xf1\x50\x42\x65\xe8\x1e\x0e\x21\x65\x08\xa3\x31\x42\x4d\x4e\x4d\xad\x4d\xf5\x71\x65\xaa\x2b\x66\x7e\x68\x0c\x1a\xb1\x38\x73\x45\x71\x24\x8a\xee\x39\x9e\xb3\x1c\x62\x46\xc1\x9a\xfe\xe6\x47\xc3\x8f\x8e\x3a\xb9\xda\x24\xda\x71\x4b\xa9\x71\x7e\xe7\x88\x51\xb7\x60\x0c\x58\xde\xd0\xc9\xd4\xf6\xa7\x3e\x33\x8f\xc1\x50\x03\x8d\xc3\xd8\xc7\xc4\x73\xe8\xcd\x6a\xc8\xf6\xf6\x66\x99\xf1\x1e\x75\x73\xea\x89\x62\x18\xf4\x29\xb3\x37\x4b\xfa\x9b\x3d\x5f\xe3\x19\x7a\xfe\x44\x31\x86\x02\x17\xc6\x5c\x73\x2c\x2d\x82\xfc\x26\x54\x33\xc8\x84\xca\x33\xce\x3f\x3e\xfe\xff\xb4\x7f\x7c\x7d\x0c\x9d\xad\x5a\xa9\xb5\xb3\xb3\x95\x8a\xfa\x7b\xd4\xcd\xd4\x5a\x5f\x59\x3d\x71\xdc\x3f\x9e\xb2\xd6\x4d\x11\xc3\xa9\xbf\xe8\xd5\x11\x67\x79\xd4\xc9\x1d\x37\xf4\x63\x13\xd4\x14\x66\x2a\xac\x8f\xed\x8b\xff\xe3\xbd\xf0\x8f\x63\x55\x40\x67\xeb\x90\x11\xc6\x95\x5a\x3b\x8f\xe2\xc4\x71\xb5\xee\xff\x21\xae\xc6\xa0\x02\x84\xab\xe1\x14\x3f\xc7\x7f\x13\x01\x00\x3e\x89\x24\x31\x36\x89\x48\xc9\x76\x53\x3e\x1d\xb4\x52\x3e\xdd\x42\xe2\xe7\xc2\xe5\xf6\x6d\xe1\xc5\xe1\x6d\xda\xdd\xe1\xb0\xee\x20\x85\xed\xd0\xfd\xdc\xe1\xc5\x46\x54\x78\x1b\x5d\xac\xfb\xc3\x61\xed\xd7\xec\x8e\x70\x78\x1b\x08\x97\x0c\xbf\x2b\x78\xf9\x9d\x88\x03\x09\x9f\x8b\xc4\x58\xca\x4a\x7a\xd9\x4a\xb6\x60\x1d\x5b\x7e\xc0\x27\x59\x49\xf0\x1a\x25\x6b\xaf\x69\xaf\x99\x25\x91\xa2\xbd\x56\xad\x8d\x94\x4a\xe9\xaf\x91\xa2\x7d\x64\x6c\x78\xa4\x14\x93\x77\x31\xe7\x8b\x38\xda\x30\xdb\xec\xe1\x36\xf3\xa5\x77\x4b\xdc\xec\x9b\x69\x94\xd3\x5f\xe9\x40\x13\x65\xd2\xcd\x54\xe1\xb2\x70\x22\x2e\x8b\x87\xec\x18\x90\x1d\x45\x87\x3c\xe0\x90\x6b\x9c\x63\x78\xaf\x9e\xdc\x89\x78\x2f\x36\x70\x4c\x4e\xdd\xf9\xa7\x1a\x86\xec\x89\x8b\x7b\x4e\xc0\x90\xd5\xb6\xc9\x85\x20\x26\x1f\x43\xb5\xff\x18\xfc\xe5\x92\x5e\x2b\x2b\xfe\x73\x50\x1b\xf0\xfe\xc3\x90\x56\xd6\x78\x51\x1f\x6e\x13\x90\xd3\xb9\x20\x26\xf2\x91\x84\xc2\x72\x59\x6f\x21\x1f\x08\x06\x44\xc9\x49\x7e\x5f\x33\x4b\x77\xb1\x5c\x56\x49\x75\x50\xa1\x8b\x82\x01\xaf\x3e\x67\x9b\x33\xb4\xce\x53\x6f\x79\x51\x7b\x43\x7b\x4e\x7b\xe3\xc5\x2d\xf7\xef\x6c\xbb\xa8\x25\xe2\x9a\xb8\x72\xed\xe9\xb7\x3c\xfd\xd2\xd3\xb7\x9c\xbe\x76\xe5\x44\x57\xa4\xe5\xe2\x89\x3b\xef\x2f\xab\xbd\x6b\x7a\x7b\xd7\xf4\x32\xf5\x5e\x3d\xe5\x96\x17\x29\x7c\xef\xb7\x69\xe6\xfa\x88\xb3\x6d\xe2\x45\x91\x05\xaf\x5c\xbd\xe6\xe9\x5b\x4e\x3f\xfd\x96\xa7\xd7\x5c\xfd\xca\x82\xc8\x45\x13\xdb\x9c\x91\xf5\xda\x33\x6c\x41\xd9\x98\xa0\x99\x31\x41\x9b\x1b\x64\x15\x7e\x70\x74\x5e\x40\x72\x84\x5c\x4c\x22\x49\x7a\x4c\xbf\x0e\xdf\xf1\xfc\xf4\x71\x7e\x78\x9d\x25\xa7\xd7\x78\x91\xfa\xcf\xb9\xfb\xaa\x0e\xef\xe5\x9a\xe1\xa4\xa2\xd3\xeb\x3d\x5c\x36\xdc\x4c\x77\xd3\xe5\x43\xfa\xc7\xc9\xe9\x41\x74\xf8\x88\xe1\x11\x74\xcf\x68\x7f\x18\xf2\xc4\x25\x00\xb2\x4a\x4c\xf4\x05\xd2\x3a\x05\xb9\x48\x94\x02\xc1\x80\x4f\x72\x52\x3c\x36\x89\x44\x49\x94\x0c\xa8\x27\x91\x92\x92\x74\x42\x52\x52\x3a\x9b\xd8\x45\x05\x65\x12\x75\x90\x8e\x8c\x6e\xca\x17\xaa\xa1\x99\x74\x0b\xe5\x0b\xf9\x82\xd1\xc2\x16\x0a\x04\x0b\xf9\x4c\x3a\x18\x08\xea\x2c\xb4\x93\xa4\x40\x0b\x35\x13\x8f\xbb\x0f\xdc\x7d\xf7\x01\x76\xb7\xdb\xfe\x94\xec\x8b\xcf\xb3\x59\x1b\x77\x04\xec\xce\x5b\xda\x27\xb9\x1d\x52\xd3\xef\x9c\x7e\x0a\x4f\x99\xf0\x79\x9b\xcb\x59\x77\x5d\x4a\xb2\xb8\xe6\x79\x1b\x9d\xff\xe6\x70\xbb\xeb\xbe\xe3\x6c\x68\x9d\x65\xb3\x86\xee\x08\x38\x1c\x63\x13\xdf\x66\x75\x39\xec\x37\x24\x8c\xc4\x21\xd7\xbf\x39\xdc\x2c\xa0\xd7\x70\x37\xad\xff\x9d\x3d\xc0\xc2\xf9\x64\x7a\xa9\x3d\x64\x4b\xde\x66\x5d\x17\x74\x6d\x4b\x87\x3d\x8e\x27\xdd\xfe\xb5\xd6\xba\xcb\xf3\x36\x87\xbd\xce\x7f\x76\x43\x7a\x4a\x23\xf3\x3b\x8c\xb4\x1d\x1d\x27\x9f\x6e\xb7\xdb\x1c\x89\xdb\x6d\x6b\x6b\x13\xdb\x36\x65\x2c\x4e\x33\xf1\xe4\x30\xf3\x1b\x6b\xc7\xb0\x2a\x8c\xf2\x20\xd3\x30\x0b\x17\x9a\x7c\x48\x6d\x2f\x0b\x1f\xe3\x97\x3d\x51\x8f\xaf\x59\x97\x51\xbb\x88\xa2\x29\x25\x15\x15\x25\xc1\xa0\xb4\x11\x86\x25\x5e\x1d\xd3\x05\x43\x96\x0d\xb4\x90\xb1\x86\x78\x9d\x46\x9f\x16\x9d\x5e\x3a\x81\x5b\x1d\x52\x9d\x2e\x8e\x2b\x72\x2e\x67\xb9\x8f\x4a\x93\x25\x9b\xf6\x03\x9b\xc4\x5d\xea\x75\xf6\xad\x98\x39\x54\x9a\xb9\xa2\xcf\x20\x9d\xdc\x1c\xd7\x22\x7d\x85\x59\xe4\x9a\x43\x39\xa7\x97\x8b\xd4\x90\x91\xf3\x04\xee\x72\x33\xf7\xf8\x50\x6f\x20\xe9\xf1\x24\xf9\x05\x57\x5a\x19\xb3\xde\x55\x74\x7a\x87\x7a\xcf\xbc\xfa\xca\x33\xb9\x27\x8d\xda\xbf\x9a\xcc\x66\x93\x5f\xf5\x9a\xe3\x3f\x04\x88\x17\x08\x1c\x64\x63\xfc\x1b\x4d\xf3\x44\x3d\x15\xfe\x2b\x67\xa5\x40\x41\x12\xa5\xb8\xb1\x32\xa4\x74\x5a\xd3\x25\xe9\x74\x4b\x75\x3e\xf6\x7b\x82\xcd\xa4\x73\xae\x9a\x3a\x0c\x4d\x0d\x29\xc4\xba\x59\x37\xfd\x67\x97\xc5\xc1\x39\x2c\xe5\xde\x72\xaf\xdd\xee\xb0\x74\x59\x98\x8d\xfd\x3c\xb2\x34\xf2\x9e\x31\x34\x7e\x63\x63\x2c\xa2\x45\x74\xc6\x56\x67\x74\x69\x80\x78\xa2\xd7\x34\x85\x9d\xb2\xc0\xca\x24\x76\x4a\xf9\xdf\x2d\xc4\xac\x0b\x6c\x8d\x16\x76\x56\x28\xf4\xfc\x0f\xf4\xb6\x69\x6b\xbe\xad\xcb\xfc\xe6\xdc\xaa\x77\xb1\x8c\x90\xbe\x6e\x51\x33\xf9\xc7\x31\x90\x41\xc9\x13\x55\x52\xa4\x90\xd9\x8a\xa8\x47\xd8\x1f\x6e\xed\x6c\x3d\x62\xac\xa9\x9c\xda\xda\x17\xde\x4a\x9b\x6d\x76\xed\xc7\x76\x3a\x5f\xeb\x6b\xed\x2c\x83\xdf\x1a\xee\x6b\x3d\xaa\xea\xf1\x62\xb1\xb5\xb3\x35\x3c\x5b\xdb\xd6\x64\xa7\x93\xed\x47\xbc\x3c\x3a\x5b\xa9\xdf\x50\x6a\x70\x23\x63\xd3\x87\x08\xda\x47\x39\x5b\x73\xde\xa9\x90\x0d\xdc\x1d\x14\x71\x92\xbb\x99\x22\x79\xb8\x19\x1f\x49\x30\xb7\x37\x11\xe1\x39\xd5\xeb\x34\x67\x84\x01\x93\x1c\xfa\x77\x1e\xd1\x5e\x3d\xb2\x73\xe7\x11\x6a\x3d\x42\x97\xbf\xa8\x7d\x45\x5b\xa1\x7d\xe5\xc5\x17\xe9\x3c\x7a\x80\xce\xe3\x06\xb4\x11\xba\xd1\x69\xa1\xac\x51\xab\x9e\xd6\xc8\xc1\xce\xad\x4d\xfa\xe2\x8b\x46\x3f\xa6\x01\x69\x91\x00\x78\x30\x0b\xa0\x1c\xd7\x41\xba\x98\x22\x71\x7e\xd1\x94\x73\x7c\xf1\x68\x3a\x9f\xe2\x3a\x48\x97\x76\x24\x4e\x0c\x64\xa2\xb1\x5c\xb6\x40\x3a\xe5\xc6\xf4\xc9\xc5\x48\xa6\xcf\x1c\x71\x1d\x87\x14\xe0\xcf\xaa\x27\x9f\xe3\x3b\x0e\x1f\xd5\x93\xd7\xfe\x9e\xdd\xcb\xde\xef\x28\x17\x1d\x5e\xf2\x91\xcf\xa1\x0d\x3a\x7c\xe4\x23\xaf\xa3\x5c\xec\x08\xd1\xfd\x96\x84\x8f\xce\x74\xf8\xc8\x45\x5e\xc7\x23\x0e\x2f\xb9\xc8\xe7\xa0\x33\x7d\x09\x0b\xdd\x1f\x62\x61\x9e\x8c\x95\x49\x2b\xf1\x76\xb7\x5b\x3b\x79\xbe\xec\x20\xe8\x01\xc3\x70\xc8\xf3\xf3\x5d\xbc\x4f\x0e\xcb\x0e\x73\xde\x74\xc8\x61\xf9\xe8\xc1\xae\xaa\x1c\x21\xea\x4c\xa0\x0b\x49\xcc\x00\x12\x95\xb9\xb0\xfa\x95\xc7\x74\x7b\x30\x90\xee\xd6\x47\x1f\x05\x24\x9d\x8f\x21\xa5\x90\xcf\x44\x2b\x04\xe1\xf7\x44\xd3\x82\xa9\x41\x22\xc5\xf8\x3c\xd2\xd9\x7a\xc4\x60\xd2\xe8\x17\x9f\x9b\x7a\xef\xd4\x6d\xf4\x52\x6b\xa7\xf6\x5d\x4f\x8b\x56\xf4\xe6\xbd\x5a\xb1\xc5\xe3\x99\x48\x50\x42\xa4\x0b\x5f\x98\xf8\x48\xd6\xcc\xa5\xff\x51\x64\x94\xef\xdb\xd6\xd9\xb9\xad\x93\x79\x26\x34\x69\x45\x59\xa6\x52\xd3\x84\x14\x95\x0c\xb9\xa9\x58\x43\x2b\xf5\x48\x18\x3c\x80\x6f\x04\xae\x11\x52\xf1\x7b\x32\xe9\x00\xab\x10\x4b\x17\xb9\x15\xbe\x86\x5e\xf8\x3e\x9b\xf6\xbd\xba\xfa\x3a\xad\xe4\xb2\x58\x02\x25\x63\xe0\x94\x9c\xde\xe7\x47\x68\x66\xe7\xce\x63\xa8\x86\xf5\xd9\xed\xda\xf7\xac\x56\x2a\xba\x65\x9f\x41\x37\x4e\xad\xdf\xcb\xd2\x35\x94\xf6\xf4\x31\xa4\x73\x1c\x58\xcd\x39\xce\x9c\x0c\x4d\x15\x84\xce\x09\xd2\x89\x61\x5d\x51\x03\xa1\x8d\xba\xeb\xea\xeb\xa8\xe8\xfa\xe5\x47\x82\xba\xcb\xa7\xf5\x1b\x93\x5c\x9f\xd7\x69\xb7\x53\xb7\xd5\xaa\x95\xdc\xf4\xe1\x47\x80\x6a\x58\x21\x88\x3a\x0b\xe0\x30\x46\x7e\xb4\x83\x52\x5c\x94\x73\x92\x14\x0d\x46\x93\xa3\xd4\x50\x90\xcd\xd9\x38\x28\x07\xb8\x61\x9a\x4e\x1c\x1d\x28\x4f\x3f\x40\x1c\xd1\xf4\x73\xa9\xc8\xfa\x94\xd0\x11\x35\xa4\x34\xbc\x6b\xcb\x85\xb8\x62\x28\x67\x7b\xb7\x81\x15\xb9\x3a\x46\x83\x9a\x9b\xab\x63\xa5\x07\xb4\x66\x43\x0b\xf9\x87\xae\x19\xac\xb5\x21\x16\x6b\x28\xbf\x3a\xa3\x06\x47\x2e\x34\x1a\x56\xe7\x7a\x7f\xea\x8b\xae\x5e\x61\x3e\x48\x81\x13\x0c\x7b\xbe\x3f\x52\x1e\x70\x79\xdc\xee\x48\x24\xda\xc2\x22\x1f\x39\xe8\xd9\xc3\x0b\xbc\x5a\xc9\x6a\x91\x93\x4c\x4d\xca\x5e\x59\x2b\xfd\xec\xa3\x46\x3d\x8d\xc0\x94\x19\x99\x8b\x52\x4a\x37\x29\xf1\x98\x93\xf9\x9a\x59\x26\xad\xaf\xf7\x69\x7d\x61\x97\x44\x7e\x84\xc9\xcc\xa4\xf9\x60\x21\x1f\x0c\x88\xd0\x29\x75\xa2\xc7\xd3\x72\xcb\xae\x9f\x54\x99\xaf\x4d\x07\xe6\x4b\x6e\x97\xed\x66\x2b\x59\xd6\x6b\x3f\x7d\x74\x94\x55\xbb\x93\xe4\xb5\x9f\x69\x9a\x90\x12\xa0\x15\x43\x4a\x6b\xaa\xf9\x96\x9b\x2b\x2c\xde\x9a\x73\x6d\xcc\x7a\x8b\xa5\xc1\xb6\xf5\x0e\x3d\x25\x75\x52\xf8\xc5\x2d\x97\xae\xbe\xa1\xc5\xe3\xa9\xe5\x67\x12\x98\x6b\x8c\x02\x86\x68\x2c\x91\x92\xc4\xd1\xf9\xda\xe7\xa2\x66\x32\x81\xad\x2c\xbc\x15\x45\xb1\xd1\x94\x11\x3e\x67\x06\x79\x11\x35\x60\x4f\x07\x84\x3f\x53\x51\x5b\xa3\xbd\xbb\x53\xfb\xeb\xda\x1b\xe4\xac\xde\x5d\xa5\x90\x22\xdf\x3c\xf7\xf1\xf3\x6e\x7a\x6b\x4e\xdd\x44\x4b\xa0\xe4\x90\x1b\xf4\xf6\x85\x14\xf9\x96\x5d\x3f\xa9\x04\xfe\xd8\x21\x9f\x42\xf7\x90\xbc\x93\x7c\x6b\x3f\x23\x67\x15\x1a\x10\x98\xf6\x9e\xf6\xad\x4b\x2e\xb8\x41\x36\x8b\x50\xb2\xf2\xcd\x33\xe7\x7d\xe6\x72\xcf\xaa\xa0\xcc\xc9\x7a\x76\x25\x2b\xdf\x72\xb3\x19\xe0\x90\xc8\x4e\x0b\x2f\x5d\x7d\x83\xac\xa0\x62\x6c\x75\x7c\x7d\x01\x68\x1c\x47\x9a\xfb\x18\xff\x78\xb9\x34\xf7\x31\x7e\x79\x9c\xd6\x4a\x3e\x46\x0b\x65\x0a\x02\x27\x7a\xf1\xaa\xec\x18\x32\x3c\x9c\x21\x66\x1c\xdf\xad\xca\x8e\x23\x86\x47\xd0\x3d\xb5\x7a\x5d\xea\x1b\x29\xee\x6f\xc7\x71\x95\x8f\x17\x58\x13\x9d\xe1\x0c\xf7\x90\x5e\x1f\xbf\xb0\x56\xe1\x6b\x8c\x71\xde\xd4\xa7\xb7\xe8\x63\x3c\xa7\xcf\xf6\xfe\x5a\x1d\x91\x2e\x0b\x22\x02\x5d\x12\x0c\x50\x91\xe9\x2c\x2b\x57\xac\x0a\xdd\x11\xb2\xd0\x06\xb2\x44\x5a\x3b\x39\x94\x2e\xbe\xfb\xee\x8b\xb5\x81\xb2\x31\x5f\xb3\x62\x6b\x67\xe9\x49\xb2\x68\x1f\x3c\x59\xea\xd4\xe9\xb2\x58\x91\x23\x3c\x28\x18\x74\x39\x32\xe1\x29\x39\x5d\xaa\xd1\xb9\x41\x9d\xab\xee\x60\xf1\x98\xa9\x87\xd5\xc7\xb9\xce\x33\x07\x82\x81\x4c\xba\x8b\x19\xb5\x17\x8d\x06\x15\x7b\x2e\xee\x11\x4a\x0d\x8d\xbf\xba\x67\xc6\xb5\xcb\x6f\x9d\x5f\xd2\x06\x3d\xee\x90\xd2\xe2\x9f\x7a\xf0\xa9\xb5\xdf\xb9\x4e\x49\xe7\xaf\x3f\xe7\x4c\x47\x48\x11\x30\x4f\x39\xea\xd4\x1b\xce\x1f\x56\xe6\xe5\x7a\x7a\xae\x2c\x0b\x0d\x8d\xce\x8d\xed\xd9\xf6\x9d\x56\x25\xc4\xfe\x14\x09\x3a\x9b\x36\x4f\x9d\x26\x4f\xcc\x4e\x54\xaa\x67\x4e\x0c\x39\xb2\x47\x87\xd0\xc5\x9c\x14\xf7\x8f\xe5\x51\x9b\x28\xad\x33\xf2\xb9\x2c\x4b\x44\x78\xe6\xf7\xb5\xe8\xcb\xf9\x08\x6b\x56\xa5\xb1\x98\x32\x89\x29\xb9\x6c\x45\xc0\x14\xd5\xe9\xbe\xa7\x02\x37\x2f\x1d\xe5\x46\xe7\x5e\x15\x9b\xdd\xb4\x4f\xfb\x95\xf6\x4d\xed\x57\xfb\x9a\x66\xc7\xae\x9a\x3b\x1a\xb7\xf4\xe6\xc0\x53\xbe\xe9\x37\x0d\x50\x96\x7a\x29\x3b\x70\x13\xbb\xe5\x91\x5d\x53\xa2\x67\xae\x8d\x8c\x32\x9f\x91\xb9\xd3\xed\xe7\xae\xdc\x45\xe2\xbd\xf7\x6a\x47\x76\xad\x3c\xd7\x3e\x7d\x6e\x64\x94\x29\x8d\xac\x3d\x33\x3a\x65\xd7\x23\x5f\xa0\xfa\x17\xb6\x6c\x79\x41\x7b\xcb\x6c\x57\x84\x03\x3f\x00\xd9\x9c\xb7\x62\x29\x1a\xa1\x5d\xca\xa7\x03\x1c\x94\xac\xac\x7d\x4b\x3b\x62\xcc\xc3\x22\x2d\x94\xb3\x0a\xdf\x7f\x54\x1f\xe1\xb4\x50\x09\x91\xce\x66\x2e\x34\xc7\xa0\x4e\x2f\x11\x5e\x35\xca\x3a\xe9\xf8\xa5\xc1\xec\x48\x43\x71\x9d\xed\xe0\x8c\xed\x83\xe0\x71\xeb\x20\xf5\x13\x73\x6c\xae\x90\x52\x1f\x8b\xd5\xeb\x8f\x12\x72\xd9\xe6\x1c\xa7\x62\xcd\xbb\xfb\xc6\xb0\x90\x6c\xf4\x37\xf9\x1b\x26\xcd\x9c\xd4\xe0\x6f\xf2\x37\x26\x85\x46\x98\x86\x99\xc3\x4f\x89\xaa\x30\xd7\x80\x67\x3e\xd6\xfe\x33\x30\xf1\x6e\x56\x09\x35\xf6\x64\xb2\x8a\x29\xd2\x8d\x8f\xeb\x22\x9d\x10\xbd\x6e\x96\xd2\x05\xf2\x91\x14\xff\x70\x8b\xe8\x13\xff\xb2\xdd\x61\x6f\x54\x52\x9d\xbe\x05\x67\x9e\xb9\xc0\xd7\x99\x52\x42\x0e\xc7\x76\xfa\x17\xed\x65\x87\x23\xa4\xa4\xa4\x16\xa9\x23\xf1\xe9\x5b\x6e\xf9\x74\xa2\x43\x6a\x91\x8c\xc8\x97\xff\x71\x2c\x14\xb4\x17\xb5\xf2\x34\x41\x09\xa5\x7c\x4d\xae\xfc\x83\x4f\x3e\x98\x77\x35\xf9\x52\x21\x45\x98\xf6\x6d\x2d\xab\x5d\x7f\xb6\xa0\x84\x12\x41\xde\xc1\x37\x84\xce\x26\x37\xa5\xc9\x7d\x76\xa8\x81\x77\xf0\xc1\x44\x48\x11\xce\x86\xdd\x10\xf2\x75\x9a\xe7\x20\xa1\x0e\x2e\xc8\x08\xa2\x11\x2d\x88\x63\x12\x32\xc6\x58\xf5\xc7\x73\xb2\x3f\x9e\x8b\xfa\xe3\x39\x32\x64\x15\x4f\x54\xff\x92\x27\xea\xa1\x4a\xb8\xec\x89\xe6\xe2\x9e\xb8\x27\xea\xcf\xe4\xc8\x4c\xe2\x21\x55\x55\x55\x4e\x55\x87\x54\x5d\xec\xd0\x1f\x0e\xfa\x7b\x18\x65\x95\x57\x55\x3d\x5a\x53\x8d\x6f\x59\x2d\xab\x82\x5a\x36\x82\x38\xe8\xd9\x86\x88\xae\xa7\x4a\x3e\x3d\x96\xa9\x9a\x11\xce\xa0\xe9\xb9\x98\x91\x50\x0f\xd6\x1f\x18\xfb\x80\xd5\xb5\xe1\xd8\x76\xa4\xd0\x56\x69\xcb\x34\x74\x03\x99\xb8\x27\x23\xff\x2f\x9e\xee\xee\xee\xee\x48\x64\x45\x4b\xcb\x97\x5b\x5a\xbe\xdc\xd5\x75\x5d\x4b\x4b\xb7\xf1\xf7\xe5\xee\xee\x2f\x77\x77\x5f\x67\xfc\xad\xe8\xee\x7e\x7a\xc5\x0a\x3d\x59\x77\xb7\xa0\x1e\xb9\x41\xb8\xfe\x7f\xf4\xe8\xfd\x62\xae\xe9\x77\x09\x6f\x1b\x73\x74\x53\x8d\x8e\xa2\xc2\x11\x51\x07\x8d\x48\x62\x14\xa0\x52\xcf\xc5\x3d\x3d\x17\xf3\x57\x25\x35\x7f\x2a\x9b\x4b\x96\x73\x4a\xae\x37\x4b\xfd\x39\x55\x61\x3f\x4b\xf2\x75\x7a\x64\x8f\x56\xcc\x25\x35\x5f\x32\xc9\x9e\x4f\xaa\x39\xea\xcf\xf6\xe6\x94\x72\x3e\x55\xe5\x4d\xef\x92\xd6\x56\xea\xca\x7d\x5c\x6d\x82\x19\xaa\xa4\x28\x9f\xcb\xea\x71\xf1\xcc\x3f\x00\x05\xa9\x46\x70\xa2\xa3\x99\x5e\x49\xea\x71\x6a\x6e\xe0\x1f\x80\x2f\x6b\x04\x86\x5b\xe8\x95\x64\x2e\x9b\x62\x3f\x55\x72\x26\xd8\x1c\x6c\xc3\xaa\x78\xb5\xa0\x62\x09\x56\x61\x23\xa0\xcb\x24\x4e\x5d\xee\x52\x52\x4a\x21\x9b\x2f\xe4\x95\x42\x17\x33\x86\xb1\xa2\xbf\xc7\x3b\x58\xa1\x4b\x0c\x4a\x46\x93\x2a\xf9\x24\x31\x68\x2c\xf3\x05\xca\xa7\x02\x82\x68\xb8\xbb\x29\xaf\x8c\x8a\x72\x35\x7e\xf1\xc2\xd6\x80\xf6\x8e\x7c\xc5\x29\x43\xab\x17\xde\x1e\xae\x0f\x88\x44\x16\x62\x76\xbf\x18\x6c\xb7\x70\x02\xe3\xc2\x9c\x7f\x22\x4f\x12\xcf\x27\x78\x79\x12\x4f\x16\xc6\x9c\x01\xd1\xe2\x71\xc8\xbe\x68\x2a\x4c\x8a\x83\x7d\xb8\x60\x71\x40\x7b\x37\x31\xf7\x9c\xa1\x2f\x35\xd6\xd5\xd9\xea\x37\x73\x5f\x6a\xca\x5b\xa8\x5d\x62\xca\xd1\x77\x78\xbb\x93\xf5\x39\x1a\x78\x3f\x6f\x77\x96\xfb\x1d\x0d\xfc\x9a\x63\x42\xf8\xd8\xc9\xf3\x86\xae\x2a\x9e\xb5\x76\xd1\xac\xe9\x7c\x87\xd3\xd2\x28\xd6\xf9\x1a\x6d\xca\x5a\xc5\xd6\x6a\xa9\x8b\x89\x89\x0d\x31\x6b\x87\xe0\x88\x0b\xa1\x2b\x15\x4b\xdc\x6a\xf1\x85\x2c\xf6\x64\x34\xd5\x10\x20\x91\xb3\x6e\x58\x30\x74\xd5\xa6\x53\x5d\xee\xc6\x39\x2d\x21\xee\x37\x81\xb8\xab\x79\x84\x6d\xd1\x4a\x23\x4e\x73\xef\xf6\x0b\x42\x65\x5f\x98\xd2\x41\x53\x0b\x60\xa8\xc1\xac\x06\x5d\x98\x64\x51\xc8\x67\xf8\xed\x41\x7f\x34\x95\x8a\xca\x0d\x93\xe3\xda\x5c\x6d\x6e\x62\x92\xe9\xf7\x07\x05\xd5\xea\xe8\x8c\x1d\xf9\xef\x58\xa7\xc3\x12\xa1\x3d\xda\xd2\xa8\xee\x17\xac\xb1\x4e\x87\xb5\x3a\x97\xab\xa2\x39\x17\xd9\xe1\xc3\x74\x60\x82\x39\x99\x18\x7a\x9f\x68\x95\x14\x0b\x9e\x8a\xca\xda\xe4\xd0\xe2\xd5\xe5\xb9\x42\x96\x2d\x86\x8a\x42\x67\x17\x54\x4e\x1d\x52\x39\xb5\xbf\xb5\x53\x9f\x71\x4c\x41\x54\x76\x0c\x98\xbc\xcb\x80\x43\xbe\xec\xb4\x62\x67\x2b\xeb\x6f\xed\x0b\xef\x0e\xb7\x16\x4f\xbb\x8c\xa0\xcf\x39\x9d\xad\xfd\x65\x53\xf6\x2c\x6a\x7d\x0e\xb9\x5f\xe7\x66\xfa\x65\x07\xf5\x9f\x76\x19\x8b\xb4\x76\xb6\x86\x77\x87\xfb\x5a\x87\x71\x59\xc5\x0e\xc0\x94\x99\xa3\x98\x00\x20\x1d\xf0\x89\x31\x25\x5b\x61\x06\x46\x19\xa8\x11\x75\x55\x45\x0f\xed\xe6\xe6\xbf\xbb\x77\xef\xbb\x7b\xb9\x01\x9d\x65\x3a\xa2\xea\xef\x81\x8c\xbc\x3a\xc7\x90\x5b\x2d\x67\xca\x17\x8e\xea\x93\xb9\xbe\xbd\x7a\x52\x36\xff\xee\x8b\x87\x8c\x74\x9c\x7a\xf1\xdd\xdb\xa6\xcc\x9d\x3b\x65\xdb\x51\x95\x46\x6c\x16\x46\x75\xcb\x26\x2f\xb7\x18\x20\x2e\x1d\xc8\xa4\x0b\x0a\x15\xba\xf8\x82\x4c\xd3\x48\x17\xd0\xbc\xc1\x66\x0a\x06\x8c\x97\xdf\x27\xfa\x63\x4a\x3c\xc6\x4b\xd9\x6e\x4a\x77\x09\xb9\x6c\x07\xa5\x92\x22\xf3\xfb\x9a\xb9\x4c\xc0\xef\x93\xf4\x48\x31\x2e\xb2\xff\xf8\x97\xe8\xcf\x4f\x96\x95\xb3\x86\x7e\xca\x82\x33\x27\x67\x14\xfb\x3b\x54\xdf\x93\xb3\x70\x2f\x44\x77\x4e\x70\x7d\xb2\xc9\xe7\x92\x6f\x71\x89\xd4\xad\x15\x7b\xb5\xbf\xa4\xf8\x1b\x29\x68\xf1\x5b\x1d\x42\xd7\x19\xa4\x75\x85\x56\x87\xa7\x29\xbd\x1c\xb1\xa9\xff\x35\xd5\x92\xe4\x16\x73\xbf\xd0\xba\x78\x56\x1e\xba\xea\x34\xa9\xce\x26\xa7\x5a\xd8\x1a\x76\xc0\x29\x69\x91\x45\xda\x17\xcf\x8d\xfd\x76\xea\x49\x76\x57\x93\xa8\xc8\x82\x87\x77\x3b\xa9\x2d\x1e\x16\x98\x24\xda\xec\x16\xf7\xfd\xdf\xe7\xd8\x54\xed\x9d\x86\x40\x8b\xd7\x6a\x91\x53\x56\xaf\xcf\xe2\xac\xc8\xd1\xc6\xda\xe5\x47\x1b\xce\x03\x92\x81\x4c\xc4\x93\x4d\x75\xf0\xf1\x98\xe4\x13\xfd\x3e\xb1\x99\x38\x83\x77\xcc\x65\x75\xb6\x52\xf2\x19\x6d\xf6\x19\x03\xbf\x8b\x9f\x4e\x39\x77\xaa\x83\x9f\x44\xba\x88\x16\xc8\xa4\x9b\x39\xbf\xcf\xc9\x49\xcd\xa4\x7f\xe2\x06\x66\x58\xdb\x82\x99\xb4\x79\x42\xe3\xa9\x33\xcf\x9d\x3f\x75\x7e\x98\x18\x59\xc4\x89\xb3\xce\xd8\xb2\x32\x33\x75\xd5\xc6\x99\xe9\xc5\x16\x2a\xbf\xc1\x5c\xdb\x13\x52\x9d\x28\x50\x80\x4f\xe4\x3a\x32\x02\xbf\x92\xde\xb8\x31\xb8\x2c\x38\xe7\xb3\xd7\x2c\xef\x8c\x9e\xb4\xa4\x2b\x77\xcf\x0b\x73\xae\xfc\xca\x9e\xe5\xed\xfb\xda\x2f\xd6\x2e\x71\x45\xe8\xb4\xcb\x67\xb6\x4f\x8f\x7a\x78\x5b\xee\x40\xd6\xb2\x69\xc1\x39\xec\x15\x29\xd4\xbd\x71\xc9\x9c\x8b\xa6\x85\x1d\xe9\x9f\x66\x1a\x2f\x0e\x75\x0c\x6d\x58\xc1\xd7\xbb\xec\xcd\xc9\xf0\x24\x7f\x5a\xe0\x5e\x69\xb3\x38\xac\x02\x4f\x67\x32\x99\x42\x53\x97\x5c\xdb\x93\x3d\xeb\xe4\xa9\x91\xfa\xf8\xb3\x77\xad\xfa\xca\x05\xa7\x86\xc5\x80\x29\x9b\xf2\xfa\xf8\x9c\x0a\xf8\xf5\x39\x2d\x5f\xc8\x87\x28\x95\xeb\x60\xa9\x82\x2e\x9a\x76\x51\x41\x94\x9c\x24\x39\x39\x49\x64\x92\x93\x6b\xa1\x40\x50\x94\x62\xfa\xe4\x1d\xd7\xfb\xd9\x13\x38\xed\x94\xc6\xb0\x83\xb6\x5c\x4c\xf5\x33\x16\xc9\x72\xf4\xb1\x6b\xa7\x4e\x5e\xfd\xf9\xb0\xe0\x6c\xbe\x3d\x69\xb1\x8b\x56\xd6\x78\xb5\x87\x05\xbc\x4e\x22\xcf\x1e\xce\x51\xd7\x56\xd7\xb4\x31\x7c\xcb\xec\xcc\x93\xd7\x7d\x42\x92\x65\x67\x7c\xa6\xc4\xb2\xac\x2e\xde\xe0\xa8\x13\xb8\x0b\x99\x55\x10\xac\x2c\x95\xb6\x25\x5d\xf2\xa4\xe8\x54\xc7\xae\xf2\xef\x97\x58\x57\x9e\xf1\x09\x97\x97\x6f\x6c\x2f\x70\x3e\xe6\x1d\xa5\xd7\x23\x82\x8a\x46\x5c\x0b\x24\xd3\x01\x97\xb9\x1b\xa6\x8f\xe5\x78\x4c\xe9\x36\x77\xc2\xc4\x36\xf2\x90\x2e\x03\xe8\xb2\x80\x3e\x8c\xba\x58\x37\xa5\x03\x06\x89\x8a\x92\x92\xea\x60\xa9\x0e\x4e\x6f\x87\x3e\x17\x07\x7d\x5e\xbf\x4f\xac\x12\xb8\x8b\xc4\x84\x4e\xc3\xca\x0c\xd2\x31\xe2\xc9\x32\x5d\xa0\xd3\xe9\xdc\x10\x74\x9d\x4c\x52\x52\x1e\xf1\xa5\xa8\xd7\x77\x9d\x6f\xaa\xef\x3a\x9f\x37\xba\x78\x71\xad\xe7\xc3\x5f\xe4\xed\x3f\x6e\xdf\xd7\x9e\xb8\x3d\x41\x49\xb1\xb9\xce\xef\xb4\x4c\xe4\x7d\x3c\x13\x52\x4d\x0d\x4d\x9c\xdb\x41\xa2\x5d\x96\x9a\x98\xe7\xfc\xf4\xa2\x88\x95\x78\x41\xb0\xb5\xee\x49\x08\x5c\xac\x57\x7b\xe3\x94\xf4\x4f\x33\x9c\xe7\x53\xeb\xea\x65\x91\x18\xcf\xd5\x7d\x21\xba\xd9\x27\x37\x47\x43\x13\x9d\x6a\x32\xf4\x40\x28\xf4\x40\x28\xc9\xa3\xea\x1a\x02\x3f\xdc\x28\xf0\x44\x24\x38\xea\x88\x36\x0c\x2c\x6e\x72\xf2\xed\x4b\xac\x8b\x4e\x25\x8b\x95\x63\x44\x3c\x7f\x7a\x61\x45\xf9\xf1\xfb\xdd\x97\xce\x8b\xfa\xdb\xdc\xad\x36\xa7\x8b\x98\xcf\x9b\x21\x6b\x63\x24\xe4\x9c\x48\x9f\x58\x4d\xbb\x56\x5f\xc9\x1a\x83\x61\x1f\x6f\xaf\x77\x3a\x36\x5d\xc8\x42\x5e\xba\xde\xc4\x31\x67\xe8\x03\xce\xc3\x5d\x80\x5c\xc1\x63\x82\x0f\x06\xc6\x21\x31\xa7\xe8\x48\x31\x90\xd8\x42\x39\x9f\x3e\x0c\x4e\x80\xc7\x2e\x96\x55\x72\x59\xc3\xa0\x6c\x2c\x26\x29\xdd\xcc\x8c\x0d\x13\x2e\x1e\xeb\xa0\x6c\x3e\x17\xf5\x05\x7c\x4e\xd2\x85\xba\x94\x92\x2d\x74\x71\x99\x74\x33\xf9\x44\x7f\x34\xab\x64\xbb\xe8\x74\x13\xb7\x73\xe8\x3c\xc2\xa6\x68\xb0\x16\xb1\x4e\x9b\x47\x98\xd1\x7c\xdd\xe2\x75\x13\xad\x44\x8c\x8e\x8b\x57\xc9\xca\x91\xa0\x63\x8c\xaf\xfb\xc2\x84\xf7\xdc\x26\x6e\x85\x66\xfb\xf4\x42\x91\x0f\x85\xf8\x62\x61\xba\xdd\xe1\x12\xb8\x21\x70\x82\xcb\x31\x3e\x94\xd7\x43\x85\xeb\x1b\x05\x9e\x11\x4f\x91\x1a\x94\x2f\x9c\x43\x0e\x91\x31\x5e\x38\xbd\xb0\x3b\x5b\x78\xf6\x81\x79\xc7\x47\xb9\x7b\xe3\x37\x3e\xf7\x28\x27\x35\x59\xa4\x05\xf3\x4e\xcf\x0b\xf6\xc6\x3a\xfb\xa6\x35\x06\xce\x8f\x0c\xa7\xda\xf3\x9c\xbf\xd3\xcf\xe5\xdb\x53\xfe\x44\x4b\x9c\xb1\x78\x4b\xc2\x7f\xdc\x40\xf3\x60\xd9\x58\x9d\x86\xb1\xbb\xf6\xbf\xd9\x63\x97\xa0\x84\x3e\x34\xac\x45\xc4\x8a\x65\xcb\x51\xc3\xba\x44\x30\x94\xab\x4a\xe8\x88\xe1\x13\x51\x89\x33\x52\xf2\x6a\x48\x29\x8d\x1a\x9b\x5c\xf0\x31\xce\xff\x47\x70\x9b\xe6\x89\x9c\x5a\x81\xdb\xf0\x09\x55\x6b\x1d\xc3\xc7\xfe\x2f\xc0\x3d\xde\x46\xe1\xe3\xfc\x63\xe1\xae\xc5\x76\x2d\xae\xff\xc7\x98\xfe\x7f\x02\xf3\xc7\xbb\xff\x49\x98\x3f\x42\x57\x37\x7e\xf7\xd8\xf3\x31\xfe\xe3\xd1\xcd\x47\xc5\x7f\x5c\xdb\x09\xb2\xc3\x60\x6d\x4f\xf0\x12\x21\x3b\x8e\x18\x1e\xa1\xe8\x90\x8f\xe0\x44\x31\x27\x72\x0f\x8c\x94\x46\x57\x1c\xcf\x39\xf4\xb7\x11\x27\x7f\xdc\xd0\xe3\x67\x33\x0f\xab\x8e\xc7\xa9\xa9\x87\x8e\xa5\x48\xc9\x9a\x16\xb7\xff\x2c\x36\x8e\xc1\x8e\x2a\x3b\x9c\x56\x6d\xc0\x6a\xa5\x88\xd5\xe9\x90\x05\x55\x76\x7c\x68\xb4\x50\x34\x40\x39\x6a\xbc\xf9\xe2\x78\xf7\x68\x1a\x6e\xa0\x5c\x72\xc8\x7a\xf6\xb0\xfe\xfa\xf8\x96\xd5\x36\xf2\xb8\x6d\xac\xe8\xfe\x4d\x7d\x4e\x3a\x68\xfd\x5f\xb7\xb1\x4f\x6f\xa0\xa1\x19\x74\x5a\x29\x22\xec\xfd\x67\x9b\xc8\x5e\x0c\xeb\x25\x98\xe6\x22\x56\x6d\x40\xb3\xfe\x13\x4d\x34\xf5\x8c\x86\xfd\x70\x8b\xd1\x7f\x86\x14\x55\x6d\x53\x55\xb8\x6e\x22\x32\xb4\x4c\x12\x52\x0e\x7b\xa3\x57\x5b\xbf\x77\x53\xb9\xb8\x69\xef\xde\x4d\xac\xb4\x69\x2f\xdd\xe9\x6d\xb4\x3b\x52\x7c\xff\xd1\xd2\x44\x8f\x20\xd3\x9d\x8f\x54\x63\xf6\x6e\x7a\x98\x76\xca\x82\x67\x44\x9e\x92\x4c\x79\xc0\x89\x66\x74\xe8\x98\xd4\xe5\x93\x7c\x9a\x3c\xd1\x1c\x05\xad\x54\xa3\xd2\xce\x79\xb2\x4a\x70\x9c\x5a\x9b\xa9\x1b\xfa\x37\x6c\xe8\xe7\x37\x1c\x51\xa9\xd8\xcf\xc0\xf0\xa1\xd1\x0e\x51\xc7\xc4\x9d\xb5\x56\x90\xbc\x5b\x4f\xb8\xa1\x5c\xd2\x8a\x25\x23\x29\x45\x64\xc7\x51\x03\x61\x7c\xc9\x21\x47\x8e\x1a\xaa\x6c\xbe\x54\xb1\x59\x1c\x56\x85\xb7\x85\xb5\x10\xe1\x43\x03\x92\x40\xb4\x90\x92\xfc\x19\x3f\x65\xe3\x31\x89\x44\xbf\x2f\x93\xd6\x45\x6f\x2b\x45\x3d\xe4\x73\x11\x15\xf2\x19\x9d\x13\xa4\xb5\x67\xbf\x7d\xb6\xca\xae\x0a\xd8\xa4\xf2\x1f\xa4\x80\x4d\x62\xcd\x52\x9e\xfa\x87\x4a\x5a\x9f\xf0\x76\xf2\x11\xad\xef\x91\x44\x3e\xa7\xbc\x9d\x3c\xfb\xed\xb3\xd7\xaa\x5c\x7f\x40\x4f\x65\x0b\xe8\xa9\x7e\xaa\xf5\x0d\x95\xa8\x9f\x0d\xe4\x92\x8f\x50\xff\xc3\x8a\xf2\x97\x54\x85\xff\xe4\x4d\xdb\x8f\xe0\x58\x4d\x87\x93\x62\x4a\x8a\x14\x43\xf1\xcd\x99\x46\x1a\x74\x77\x54\xdb\xe5\xee\x9e\xd7\xed\xd2\xee\x8c\x52\x3b\xed\xa1\x76\xae\x62\x5b\x81\xf5\x73\x86\x8e\x44\x15\x25\xca\x89\x73\xd6\x1f\xa0\x76\xed\xc0\x18\xbb\x12\x19\x48\x7a\x62\xc6\x5e\xd5\x98\x0d\x6a\xec\x3a\xb2\x73\xe7\x11\x6e\xd7\xb8\x5d\xa9\x3e\xbe\x68\xee\x40\xb1\x43\xc7\xee\x1d\x9a\xfa\x7a\x08\x25\xf8\x0d\xfd\x6b\x36\xd5\xc1\xa5\x94\x98\xc1\xd6\xfb\x7d\x81\x74\x3e\xe9\x43\x04\x39\x9d\xd9\x2a\x74\x51\x3a\x10\x6c\xe6\x82\x01\x06\x1f\x35\x05\xc2\x12\x1f\xe3\xa5\x70\xa0\x89\x7c\x3d\x17\xf7\x30\x68\x07\xb4\xa5\xda\x81\xd3\xc5\xcb\x3e\x75\x49\xd8\x9a\xce\x66\x2c\xe1\x4b\x3e\x75\x99\x78\x3a\xa9\x89\x28\xb5\x45\x0b\x41\xb7\x3b\x58\x88\xb6\x51\x34\x91\xeb\xe9\x79\xe2\x80\x76\x80\xda\x0f\xdc\xf1\x19\xeb\x83\xb7\xfe\xfa\x9c\xe6\x58\xac\xf9\x9c\x5f\xdf\xfa\xa0\xf5\x7a\x73\xbc\x8a\x1f\x08\x2a\x44\x38\x71\x32\xba\x30\x0f\x20\xb3\x37\xa1\x48\x24\x06\x0a\x24\x8f\x25\xed\x60\x20\xa8\x33\xfa\xa9\x31\x1b\x2a\x33\x28\xdb\x4d\xf9\x00\x67\x74\xb9\x44\x05\xd3\x06\x8e\xdb\xbc\x71\xf7\xc6\x3e\x86\x88\x47\x7b\xc0\x13\xf1\xd0\x8a\xd3\xf7\x6e\x1a\x32\xa8\x9c\x2b\x76\xe7\x5d\x1c\x67\x9f\xe2\xf4\x06\x03\x43\x06\x19\x72\xc5\x99\x2b\xac\x45\x57\x6b\x1f\x45\xca\x7d\xda\x00\xbf\x7c\xb9\x36\xb0\x3c\xbc\x38\xbc\x3b\x4c\x7d\x1b\x77\x6f\xec\xec\x63\xa5\x91\x72\xca\x3f\x7f\xc6\x2c\x65\xd3\xde\x06\xc9\xed\xb1\x4f\x71\x8a\xa2\x69\x08\xb2\x62\xe6\x75\x0e\x6b\xd1\xe5\x66\x2f\x68\x03\xe5\x3e\x8a\xb0\xf0\x72\x8a\x2c\x0f\x87\x77\x87\x17\x8f\xe0\xdf\xd8\x27\x6f\xc3\xb2\xf1\xb6\xb6\x53\xd2\x26\x3b\xad\x2f\x4f\xb5\x2d\xd3\x65\xb1\x60\x40\x36\xf7\x2f\x67\x50\x3c\x22\x89\x72\xc0\x18\xf5\x1d\x7c\x2e\xdb\x25\x4d\xa3\x5c\xd6\xb0\x0e\xa2\x80\x4f\x50\xab\x4d\xc4\xb0\x43\x0e\x2d\xec\xb4\x89\x1b\xaa\xad\xf3\x86\x43\x6e\xd9\xff\x8e\xa6\x1a\xa3\xbf\x5f\x7b\xfa\x8a\x4d\x27\x71\x41\x0b\xef\xb6\xd9\x02\x27\x4f\x8c\x4b\xfe\xf8\xb4\x45\x97\xde\xf2\xc4\xc5\xfd\x29\x87\x3d\x24\x93\x2a\xb3\xb8\x56\xae\xb6\x53\x76\x34\x0a\xa1\x18\x5f\x6d\xe5\x2b\xb2\xcd\x51\xef\xb6\x58\xe9\x75\x4d\x95\x05\xcf\xc4\xd2\x8d\x37\x6b\xfb\x82\x75\xcc\xe1\x8c\x5d\xd8\xb7\xb5\x73\xca\x92\xbe\xc5\x67\x9e\x32\x35\x15\x30\x26\x18\x4d\x95\xb3\xd5\xb6\x5f\x2f\xa8\x98\x64\x58\x0e\x7a\x8e\xd7\xad\x7a\x13\x8f\xed\x58\x7d\x26\x93\xcd\xfd\xf8\xb1\x56\x8e\xa3\xcd\x1d\xe9\x51\x9b\x83\x13\xc7\xf6\xa9\xcd\x21\x8a\xbe\x3f\x0f\xfd\xb2\x7e\x66\xbd\x76\x46\x7d\xfd\x25\xf5\x33\xeb\x49\x62\x9f\xab\x9f\x59\x7f\x49\x3d\x5b\xa1\x7d\x7f\x6c\x57\xda\xd8\x48\x57\x6a\x0e\x6b\xd1\xc6\x59\xe8\xc0\xd0\x2f\xeb\xeb\xe9\x31\x23\x43\xbd\xf6\x21\xfb\x9c\x51\x88\x79\x6e\x06\xc3\x90\x20\x02\xb3\x2a\xeb\x8c\xa1\x6a\xf2\x64\xd2\x81\xaa\x01\x81\xa1\x5a\x8a\xfa\x7d\x62\x75\x95\xd5\x27\x67\x43\x27\x55\xdd\xa6\x37\x6c\x94\xa2\xb9\xac\xee\x91\x20\x0f\x43\xce\x2a\x9a\xaa\x86\x14\xc3\xa9\xbf\x94\x90\xaa\xa9\x8a\xe1\x94\x09\xc6\x46\x81\x1e\xad\x3b\xf5\x97\x12\x52\x49\x8f\x26\xb0\x7b\xfe\xb9\xf4\xf2\xd8\xda\x6a\xf4\x00\x4d\x00\xe5\x0d\x3d\x54\x8a\x94\xd4\x38\x5b\x2b\xbf\x27\x5f\xe0\x5e\x96\x43\x21\xb9\x3c\xd5\xca\xd7\x58\xcb\x5b\x85\x2b\x64\x7b\xe8\x48\x31\x64\x97\xd9\xb3\x56\x5b\x79\x59\x95\xe7\x56\x42\xe5\x65\x36\x6b\xcd\xf9\x90\xb6\xf1\xe5\x9f\xa0\x1a\x23\x51\xbe\x20\x8e\xd4\x76\x6c\x9d\xec\x59\x39\x74\x4c\xcd\x53\x4f\x00\x02\x7b\x56\xb6\x87\xca\x53\x0d\x58\xb6\x54\xf4\x5d\x0d\xc7\x81\x25\x3b\x52\xf3\x99\xb5\x35\xcb\xf2\x47\xd4\x26\x67\xe5\xd1\xe2\x8d\xb6\x5e\x23\x5c\x2f\x6c\x45\x1d\x60\x25\xd1\x68\x96\x31\x46\xd7\x1c\x79\x29\x18\x8d\x06\x85\xc9\x41\x76\x5e\xb9\xd9\xe1\x0b\x09\xa5\x90\xcf\x51\x6e\x76\x24\x30\xc6\xa6\xd0\x55\x59\xe1\xc7\x2c\xaa\xc2\xf8\xa3\x3f\xa8\x58\xfe\x1b\xa7\x00\x86\xd4\x5a\x9f\x50\x1c\x95\x7a\x6a\x25\x20\xa5\x4a\xbb\xd5\x7a\x8e\xa9\x45\x1c\x23\x31\x8d\x29\x67\x34\xaf\x68\xe2\x2e\x38\xd2\xb4\x60\xa5\x85\x92\xd1\x5a\x51\x3a\x49\x47\x1d\x7b\x56\x47\x1d\x7b\x56\xd6\xd1\x17\xe2\xad\x3a\xe6\x84\x52\xc8\xae\xe3\xd4\xc6\x9e\x35\x1c\x72\x56\x7f\xd9\x43\xec\x59\x9b\x75\xa4\xfc\x2a\x9d\x1c\x53\x7e\xd0\x33\x76\xcb\x54\xaf\xea\x78\x35\x8e\x25\x93\x13\xd7\x6e\xb5\xb1\x47\x46\x11\xc4\x1e\xb1\x59\x6b\x81\x19\x33\x26\xc6\xc2\x32\x1e\x88\x91\xda\x6b\xeb\x1d\x5b\xe3\xb8\x8a\x8c\xfe\x26\x40\x24\x41\x44\x1d\x1a\x01\xd9\x9c\x14\x8c\xde\xa0\x9a\x1e\xd1\xeb\x71\x8e\xd2\x98\x4e\x7b\xc2\xb3\x35\xdd\xc2\x4e\xaa\xa2\x38\x54\xfe\x93\x69\x0b\xa5\x84\x86\x11\xaa\xf4\xd7\x3d\xc3\xf7\xf0\x8f\x08\x7f\x82\x0f\xb0\xb2\x80\x69\x3d\x5e\x99\x8f\xf4\x89\x94\xbf\xb3\xfc\x0e\x93\x65\xf9\x11\xbd\x27\x42\xb2\xcc\xfe\x24\x67\xe5\x47\x64\xfe\xe5\xf2\x3b\xe5\x77\x0c\xa7\x19\xc4\xfe\x64\xa4\x31\xcb\x5c\x36\x7c\x0f\x7f\x41\xa5\xcc\x63\x0c\xd1\xf5\x42\xcf\x2c\x87\x2a\x79\xe5\xf2\x3b\x66\xe1\xec\x4f\x32\xbb\x53\xaf\xc1\xf0\xc8\x4c\x36\x13\xe8\x09\xc7\xd0\x7e\x1c\x93\x00\xca\x65\x95\x78\xd4\x63\x1e\xe1\xf1\x7b\xa2\xe6\x39\x9e\x4c\xd4\x63\x1e\xe6\xc9\x79\xa2\xe9\xb1\xd6\x3b\x25\xbd\xc9\x06\xde\x87\x8d\xf6\x93\xe9\x31\x0c\xc3\x8a\xe3\xcd\x77\x8a\x95\x98\x63\xf3\x50\xdb\xb1\xb6\x4c\x35\xf6\x44\x15\xb8\xaa\xd0\x1c\x0b\x43\xcd\x59\xa0\xe3\xd6\x5a\x91\x79\xc7\xd7\x52\xdb\xfe\x36\x63\xef\x34\x3b\x89\x0a\xf9\x5c\x76\x12\x29\xf1\x98\xcb\x50\x96\xb9\x74\xfe\xb6\x85\x24\xe3\x1d\xc8\xa4\xbb\x0d\xdd\x66\x37\x8d\x85\xe1\x5a\xf9\x89\x27\x64\x79\x99\xdc\x18\xd2\x1d\xa1\x46\x79\x99\x7c\x6c\x08\xdd\x38\x0e\x36\xba\xef\xa3\x92\x57\x42\xe8\xc5\x13\xe2\x26\x68\xd8\x79\xe9\xd0\xc6\x24\x4a\x29\x26\xac\x41\x1d\xca\x02\x75\x51\x0d\x7c\x02\xef\x3d\x5b\xce\xca\xda\x9a\x3f\xc8\x59\xf9\x6c\xaf\x97\x2e\xd6\xab\x60\x2d\xde\xa1\xf1\x76\x95\xb1\xb0\x77\x99\x2c\x6b\x17\xfd\x41\x96\x97\x79\xc3\x8d\x5e\xed\x6e\x59\x4f\xb7\x60\x1c\x0c\xb5\xf6\x5e\x53\x31\x07\x48\x8e\x3f\x37\x96\xed\xa0\x78\x4c\x12\x0d\x9c\x55\x0c\x43\xfc\x3e\x51\x72\x52\x35\x45\x2e\x9b\x2f\x74\xf1\x89\x71\x26\xa0\x23\x36\xe3\xb8\xf4\x91\xb3\xfe\xa6\xba\x82\x5b\x25\xbb\xdb\x9a\x8b\xc6\xb2\x93\x7b\x5a\x27\x77\x5f\x64\x44\xb6\x45\x23\xb1\xa9\x2d\x0d\xa4\x8e\x83\xbe\x7f\xc4\xb8\x9c\x3d\xb6\xf4\xee\x33\xfe\xa3\xde\xbb\x4a\xb4\xcf\xae\xaf\xcf\x46\x95\x8e\x40\xf8\xca\x59\x09\x3d\x5a\x9e\x21\x7b\xfd\x53\x26\x2d\x98\x31\x9e\x18\x46\xdb\xa4\xcb\x5e\x53\xab\x6d\xf2\x8c\x92\x9e\xa1\xe7\x1e\x21\x42\x6e\x5c\x93\xc7\x58\xfc\xc1\xeb\xec\xab\x1a\xb4\xf6\x99\xd6\xca\x25\xa7\xb7\xa6\x81\xec\x18\xe0\xfb\x9d\x5e\x06\x3d\xb6\xdf\xe9\xd5\x4a\xc6\xc7\xcb\xdd\xd6\x5f\x09\xf1\x7e\x6f\x3c\xbc\xa3\x74\x30\xc9\x38\xfb\x33\x72\x16\xa4\x83\x52\x23\x3a\x17\x27\x49\x19\x9d\x01\xd2\xfd\xcd\x14\x1c\x39\x26\xd2\x45\xa6\x5e\xc6\x49\xd2\x48\xda\x0e\x4a\x8d\x94\xd1\x45\x85\x91\xb4\xcd\x14\xcc\xa4\x03\xfc\xd7\xd7\xeb\x03\x69\x7d\xe4\xfe\x75\xc6\x70\x5a\x77\x7f\x64\x7c\x00\x5d\xa1\x84\x6e\x4f\xbe\x7d\xbf\xe1\xbd\xff\xed\xe4\xed\x7a\xfc\xb8\x00\x86\x13\xe5\x1e\x09\xa0\xf6\x13\x67\xaf\x04\x8c\xb5\xcb\x8c\x1b\x56\xec\x30\x0f\xfe\x48\xe6\xc4\xd8\x4d\x29\x73\x62\x6c\xa9\x4a\x27\x2e\x0a\x06\x7c\xf9\x13\xd9\x21\xce\xdf\x69\x0b\xd9\x6e\xbe\xd9\x16\xb2\xed\xb4\xe9\x5f\xdb\x38\xff\x0b\x1f\x65\x99\x48\x3f\x39\x7e\xa6\x11\x7f\xc3\x47\x9b\x27\x1f\x6b\x3b\x6d\xad\xe1\xbe\x5b\xa8\xb2\x68\x9c\xd0\x88\xf2\x4e\x6d\x99\x3e\xbc\x5f\x93\xe5\x0b\xe4\xac\x7c\x27\xe9\x93\xfc\x05\xf2\x96\x8f\x34\xa6\x7c\x59\x5b\x26\xcb\xa4\x18\x29\x8d\x2c\x7a\xde\x23\xff\x20\x9c\x9f\x85\x15\x5e\xe3\x5c\x70\x36\x45\xc6\x9e\x9d\x60\xd8\x55\x92\xdf\x07\x77\xe5\x8c\x4c\xe5\xc4\x8e\x10\x39\xab\xec\xbc\xb9\xff\xd2\x9f\xec\xfc\xe4\x50\x03\xfb\xdb\xe7\x1e\xde\x75\x64\xa7\x10\xd9\xf2\x82\xf6\x47\xed\x39\xed\x8f\x2f\x6c\xd9\xf2\x02\x35\x51\x27\x35\xbd\xc0\x6e\xbc\xff\xa6\xb2\xeb\x53\x67\xed\xfc\xd9\x7e\x76\xf8\xec\x9d\x43\xbb\x1e\xa0\x6e\xed\x59\xed\x0f\x86\x85\x65\x33\x4d\xa5\x26\xdd\xa5\xaf\x83\xc5\xe1\x9c\x08\xa1\x07\x91\xea\xd9\x21\xa3\x77\x4d\xbd\x5a\xce\x54\xac\x19\x47\xb2\xc8\x60\xac\x4e\xc9\x96\x8b\x94\x54\x94\x9e\x64\x2e\x9b\x2a\x5f\x99\x4c\xb2\x5b\x95\x5c\x56\xe9\x51\x14\xed\x37\xac\x94\x3d\x85\xa9\x6a\xae\x47\x7b\x2d\xb1\x2e\xd1\x9b\x4c\xb2\xed\x86\xb1\xc2\x2d\x8a\xb2\x40\xb9\x58\xd1\x7e\xd3\x63\xf2\x23\x39\xa1\x54\xa9\xcf\xd4\x6d\x19\x4b\x2f\x8d\xe8\xa8\xcc\x8e\x32\x24\x42\xa1\x94\x2c\x5f\x99\xca\x66\x52\x3d\x8a\x42\xc9\x72\x31\x7b\xca\x29\x59\x56\xd2\x7e\xa3\x28\x3d\x4a\x36\xa7\xb0\x5b\x93\xac\x98\x4f\xea\x60\xf4\x28\x17\x2b\x94\xec\xc9\xa9\xb9\x1e\x52\x12\xeb\x12\x3d\x8a\x52\xbe\x52\x9f\xd0\x91\x1b\x56\xc5\x1e\xa1\x88\xa8\x61\xd7\x66\x36\x6c\x84\xeb\x31\x17\xfe\x4a\x33\x75\xc6\xa5\x27\xd9\xa3\xe4\xf2\x09\xed\x35\xa3\x28\xa3\x21\x3d\x8a\xc2\x6e\x8d\x17\xf2\x49\xbd\xba\xdc\x47\xc0\xa2\xc3\x6a\xf2\x16\xb9\xe1\x27\xc4\x1e\x41\xad\x9e\xf5\xae\x22\xb3\xd2\xac\x11\xde\xab\x82\x5b\xb1\xc7\x68\x65\x2e\x59\xbe\x52\x51\x16\xe8\x0e\x52\x7a\xb3\x6a\xb6\x97\x14\x1d\x7f\x3d\x49\x56\xca\x25\xcb\x1b\x75\x7c\x26\xf2\x39\xa5\x27\x99\xd4\x5e\x63\xa5\x6c\x6f\xaf\xde\x17\x4a\x32\xd9\x93\x1a\xe5\x39\x4b\xc6\x9d\x60\xa6\x2c\x97\xf3\xc4\x63\x4e\xc1\xef\x0b\xfa\x2a\x67\xcd\x3b\x58\x8a\xe5\xb2\x05\x6f\x34\xe3\xa9\xca\x6b\x9a\x2e\x41\x0d\xac\xfc\xd2\x17\x2f\x5b\xd9\x15\x17\x04\x8f\xcb\x6d\x97\xec\x2e\xee\xfa\xdc\x03\xec\x27\x03\x4a\x56\x66\xe0\xee\xc9\xea\xa9\x74\xd6\xc2\xde\x92\xff\xc4\x95\xfd\xab\x0b\xb3\xc5\xb8\xd5\xe5\xf3\x58\x43\x31\x89\x9a\x1e\xf9\xf1\x4d\x74\xa7\xce\x89\xc8\xda\x18\x1e\x20\xa8\xf3\x40\x3a\x24\xc1\xc0\x28\x77\x5e\x1d\x7e\x86\x9d\xda\x24\xaa\xf2\x5d\xfa\xf4\x62\x2a\xdd\xfe\x66\xd3\x1e\xdf\x21\x9b\xc6\xb4\x4a\x56\xde\x41\xbd\xb6\x90\xed\x72\x2e\xa8\xbb\xb5\xc7\x75\xb7\xcd\x46\xbd\x3b\x2a\x16\xb4\xf4\x4e\xc8\x48\x3f\x62\x94\xab\xa7\xb7\x5d\xce\xcd\x37\x6c\x71\xf5\x0c\xb6\xcb\x6d\x21\x23\x43\x56\xa9\xd8\xf0\x39\x86\x3f\x2f\xfc\x4d\xb8\xc2\x84\xef\x44\x70\x9c\x08\x6e\xc3\xee\xed\x38\x80\x9c\x00\x6e\x56\x3c\x2e\x20\xec\xce\xe3\x82\x8d\xaa\x1d\xa6\x60\x9e\x51\xac\x8c\xc7\x11\x62\x1d\x19\x21\x23\x04\xa4\x4b\x54\x6a\x67\xab\xd6\x67\x9c\xdf\xd4\xfa\x8c\xc3\x02\xfd\x86\x87\xfa\x5b\x3b\xb9\xc8\xf1\x42\x8d\xf4\x95\xba\x18\x04\x95\x33\x65\xa8\x71\x7a\x62\xbd\xdc\xa3\x86\x99\x2b\x5f\xaa\x94\x54\x3d\x24\x6a\xca\x9e\xba\xfc\x94\x33\xce\xc4\xb8\xc8\x49\xa9\xd1\x73\x6f\x82\x68\x1e\xdd\x39\x89\x3a\xa8\x9b\xba\x28\x28\x8c\xc0\x9b\xcc\x07\x74\x7a\x97\x04\xe1\xa7\x1d\x8d\xa1\x62\xe8\xc2\x0e\xed\x7d\x83\xd2\xb5\xf7\x3b\x2e\x0c\x15\x43\x8d\x1d\x64\xd3\xde\xaf\x44\x91\xcd\x1c\x04\xb6\x4a\x94\xf6\x3e\xfd\x29\x74\x61\xc7\x25\x1d\x8d\xa1\x2f\x6a\x2f\x18\x47\xa9\x33\x5f\x0c\x35\x76\x5c\xd2\x71\x61\xe8\x9e\x7b\xaa\x31\x94\x31\x4e\x67\xbf\x30\x12\x53\xbb\x1e\xe8\x32\xca\x49\x86\x15\xa7\xb7\x3a\xe3\x8f\x3f\x83\xcf\xc9\xd9\x94\x1e\x20\x89\x7e\xd9\x0c\x61\x93\xcc\x29\xbb\x3a\xe5\xb3\x6f\x7a\x1d\x25\x87\xcf\xe7\x28\x39\xbc\xcc\x6b\xb3\x39\x5f\x77\xda\x6c\x1e\x9f\xf3\x29\xa7\x2c\x8c\xe7\x43\x8e\xfe\xf5\x19\xa7\xec\x73\x3c\xe3\xf0\xc9\x74\x01\x5b\x6f\x17\x2d\x16\xd1\x5e\xbe\xd3\xe6\x72\x55\xf7\xb6\x44\x08\x45\x38\x10\x40\x0b\x16\xe8\x5c\x92\x27\x17\xf5\x7b\xfc\x15\xbe\x2f\x63\xec\x30\xfb\x02\x89\xac\xc1\x3c\x67\xd2\xe6\xb9\xb1\xda\x33\x61\xa6\x84\x65\xdc\x74\x62\xac\xce\x19\xf3\xea\x93\x74\x80\xeb\xd7\x4a\x89\x70\x29\x9c\xd0\x3a\x7f\x70\x5d\xa8\xad\xb5\xb3\x93\xbd\xda\xd9\xda\x16\xba\xf6\xfb\xad\xb4\xcf\xeb\xec\xeb\x6c\x3d\x5a\x6a\xed\x34\xb9\xa9\x27\xcf\xb9\xf1\xc6\x73\xd6\xce\x50\xd5\x19\x6b\x75\x17\x3d\xe9\xf4\x3e\xde\x49\x07\x4a\x25\xad\xbd\xb3\xa1\xb1\x91\x5b\x7d\x7f\x4b\xe7\xe2\xce\xce\xc5\x9d\x2d\xf7\xf7\xeb\x6c\x58\x95\xa6\xcc\x13\x87\x37\x7e\xe7\xc6\x85\x0f\x3f\xbc\xf0\xc6\xef\xdc\xe8\x35\xf5\x64\x92\x79\x8f\xc3\x22\x43\xaf\x1c\x8f\xf1\xa2\xa1\x9f\xcd\xa4\x0d\xa3\xb3\x44\x26\x4d\x3e\x49\x84\xa9\x03\xa4\x78\xcc\xc9\xe2\x31\x25\xd5\xc1\xe5\xb2\xe6\xb9\x4f\x45\x77\x14\xba\xf8\x42\x17\x9f\x49\x37\x33\x01\x4a\xe8\x51\xed\xf5\x3f\x6e\x91\x95\x50\xbd\xbf\x71\x85\xef\x66\x92\xbe\x1d\x62\x8a\xaf\x43\x7b\xfb\x37\xaf\x0c\xec\xba\xc5\xb5\x33\xe8\x9e\xd4\xd6\xd5\xd4\x36\xa1\x81\x59\x38\xae\x6b\x41\x57\x98\x59\xcf\xfa\xc2\x33\xeb\x0b\x8f\x7f\xeb\x9b\x77\xa5\x6c\x29\x5f\x2c\x55\x9f\xea\x8e\xb8\x39\x25\xab\x9c\xbf\xf7\x73\xfe\xfa\x90\x22\xd7\xaf\x90\xaf\x59\x43\xe2\xb9\x2b\x07\xb4\xef\xaf\x5f\x37\x49\x58\x50\xec\x2d\xc6\x27\xf2\x4e\xd1\x21\xc5\x17\xe6\xa7\xca\xfc\x6c\x5b\x26\x77\xc5\x2f\xbf\xb2\x29\xe1\x75\x71\xd6\x54\xd2\x96\xf2\x04\xad\xcb\xb7\x6e\xac\xea\x38\x20\xa8\x22\xe0\x42\x06\x10\xc6\xef\xb0\xf8\x8c\x49\x37\x15\x34\x14\x9c\x42\x2e\x9b\x0a\xa6\x9a\x79\x41\xad\xdd\x27\x1b\xc6\x94\xd3\xfa\xfa\x4e\x9b\x32\x8b\xa7\x65\xdb\x6f\x5e\x56\x30\x7d\x33\x39\xd3\xd7\x3f\x62\xbd\xce\xcb\x8b\xb6\x9e\x73\xe6\xbc\x79\x67\x67\xfa\x54\xa2\x09\x4b\x36\xde\xf0\xe8\xca\x6a\xc8\x8a\xcf\x54\x42\x2a\xbc\x84\x8e\x77\x5e\x85\x07\x51\x4c\x01\x48\x49\x05\xfc\x15\x7d\xb8\x28\x05\xf8\x48\xc2\xe8\x0b\x53\x51\x6e\x58\xf1\x42\xef\x85\x08\x52\x4a\xb6\x90\x47\x04\x41\x51\xdd\xfd\xe6\x0c\xd3\xf0\x6a\xc6\x9b\xbb\x3f\x4b\x77\xd0\x01\xba\xa3\xfc\x44\xd8\x77\xed\xb7\xc2\xad\xe1\x2d\x9f\xf4\x71\xeb\x7c\xdb\xb5\x54\xf9\xb0\x96\xda\xee\xf3\x6d\xa7\x5f\x33\x27\xfd\x7a\x3b\x2b\x1e\xbc\x72\xcd\xd5\x4f\x69\x1f\x92\xf4\xd4\xd5\x6b\xae\x3c\xf8\xc2\xdf\xfe\xc6\x4e\x6e\x0d\x7f\xeb\x5a\x5f\x38\xec\xfb\xe4\x16\xed\x97\xb3\xe3\x7f\xd2\xde\xa6\xc0\x9b\xf1\xd9\xf1\x37\x29\xa0\xfd\xe5\x4d\xe3\x5c\x6d\xbf\x04\x7e\x00\x56\x34\x60\x06\x66\xe1\x13\x40\xb2\xd0\x41\x06\xa8\xde\xf1\x70\x26\x75\x38\x2b\xda\xd5\x5c\xb6\xd0\x41\x26\xc4\xd1\xb4\x71\xaa\xb4\x99\x0b\x06\x64\x9f\x28\x51\x80\x37\xd4\xcf\x7c\xbc\x90\x4f\x14\x94\x54\xa1\x99\x82\xac\x6d\xd1\x59\x2b\x67\xbc\xb9\xfb\xab\xec\xe6\xd1\x56\xd0\xe7\xe8\x62\x6d\xf9\x45\x53\x6c\x5e\xfb\x16\x77\xfb\xed\x87\x96\xfa\x7c\x5f\xa4\x67\xc9\xf1\xa9\xb3\xf3\x36\xaf\x10\x4a\x34\x47\x39\x77\xf2\xbe\xcf\x50\xbd\x85\x4a\xbe\xd4\x9c\xbb\xb5\x2b\x7f\xb7\xe0\x00\x5d\x74\xf5\x15\x5f\xed\x3e\xf7\x1b\x27\xff\xe4\xf3\xdd\xa5\xb5\x7a\x3b\x35\x8d\x5d\x32\xda\xcc\xbf\x4a\xec\xe9\xb2\x7d\xff\xa7\xdc\x73\x6c\x5e\x7b\xcf\x29\xaf\xde\xdc\xd2\xdb\xf2\x36\xb9\x3d\xe7\xb9\xed\xb2\x57\x66\x36\x6d\xf2\xad\x6f\xa6\xe9\xfd\x93\xb6\xce\x89\x15\x4f\x7f\xf4\x99\xad\xde\x77\xf7\x7f\xeb\x8a\x0d\xc5\x6f\x9e\x6b\xf6\x9d\x7b\x58\x15\x07\x0d\x7a\x8a\xea\x14\x35\x5e\xfe\x3b\x76\x4e\xe2\x28\x20\x8d\x58\x79\x52\x17\xa5\x03\x7c\xcd\x5e\x2d\xf3\xda\x1c\x75\xaf\xd7\x39\x2a\xb3\x92\x83\x43\x3c\xe9\x99\x16\x3b\x82\xd8\x34\x4f\x32\xce\xc1\x33\x7d\xce\xf4\xfb\x9f\x71\xca\xb2\x53\x7f\xd1\x56\xfa\x99\x5d\xaa\xab\x93\x9c\x5a\xc1\xe6\x70\x70\xfb\x8e\xa8\xdd\xdd\x4d\xb1\x58\x53\x77\xb7\xa0\xb6\x24\x12\x95\x35\x69\x9d\xb0\x0e\x69\x80\x02\xa2\x8b\xe4\xaa\xb6\x3b\x65\x25\x43\xf3\xdd\x46\xca\x24\xa6\xa4\x94\x6e\x93\xa5\xb1\x92\xe9\x0e\x0a\x85\x2e\x12\xfa\xda\x8b\xbd\xf7\xf7\x0b\x1e\x55\xb2\xf3\x9c\x4b\xd4\xfe\x4b\x2b\xe7\x04\x47\x9f\xd5\xc9\x5c\xd6\xa7\x87\xea\x18\xd9\xfa\xac\x4e\x91\x7d\x9f\x38\x8d\x77\x72\xac\x4e\x75\xba\xd9\x17\xfb\x7b\x4b\x42\x5f\xb6\xd4\x7b\x7f\x79\x9e\xec\xec\x13\x89\x73\xd0\x90\x56\xfe\xbe\xc7\xd9\x67\x65\x75\x43\x4f\x4b\x6e\x87\xfd\x3c\x2b\xe5\x88\xa3\xa0\xc5\xed\xae\x53\x1d\xc2\x57\xfa\x7b\x8b\xfa\x4a\x36\x6c\xee\x51\x1c\x6b\x0b\x5d\xb5\x82\x3e\x0d\x57\x00\xc1\x8a\x25\x77\x72\xdc\x97\x6a\xfd\x23\xca\x9b\xca\x7c\x5c\x93\xae\x30\x2e\x2e\x39\xee\xd4\x48\x45\xdc\x8b\xd6\xdc\x25\x10\x50\x29\xa2\x0d\x50\x1f\x15\xb5\x92\xd6\x3f\xde\xcd\x06\x0c\xb7\xaa\xbf\x39\xe8\x21\xa6\x5b\xeb\x1f\x3d\x4a\xc3\x06\x46\xc3\xc9\x28\x2d\x32\x1a\x49\x6a\x6f\xf6\x88\x71\x82\x5d\x5d\x31\xb3\x38\x73\x05\x99\x1f\x35\xdb\x6b\xd6\x1b\x29\x1a\xd9\x8a\x45\x8a\x0c\x81\x22\x54\x32\xbf\x45\x2a\xb2\x08\x45\x0c\xab\xd7\x01\x87\x2c\x0f\x7d\xdd\x48\xa2\x67\x28\xd5\x04\x2f\x3c\x6a\x5c\x78\x22\x20\xdb\xdb\x37\x73\xc5\x8a\x99\x7d\xe6\xbb\xb7\x22\xc7\xf4\x4b\x10\x06\xe0\x45\x01\x97\x01\x24\x4a\x1d\x7c\x8d\x99\x42\x75\x0f\x7b\x06\xc5\x9c\xd4\x21\xa6\xf2\x85\x66\x3e\x13\x35\x8f\x12\x90\x77\x24\x32\x1a\x73\x32\x49\x94\x9c\xb5\x16\x0e\x86\x31\x5f\x97\x38\x92\x9a\xdd\x33\x7d\x61\xa0\x39\x93\xe9\x69\x1f\x30\x8e\xb7\x1e\x11\x44\xab\x56\xb2\x3a\x1d\x72\xe4\xe2\xce\x65\xd9\xde\xf4\xcc\xec\xd4\xc6\x69\x95\x24\x84\xd1\xe3\x7e\x7a\x92\x61\x4c\x5e\x34\x7d\x62\x7d\xa4\xa3\x69\xc2\xac\x19\x67\x9d\xb3\x79\xb6\x59\xc6\xb8\xc0\x6a\x2e\xbe\x65\xf9\x13\x27\x15\xe6\x4d\x68\x32\x54\x0c\x43\xce\xb0\x5e\x8a\xec\x28\x11\x71\x92\x33\x18\xeb\x98\x91\x3a\xe7\x71\x23\xbe\xe4\xf4\xda\xb4\xef\x71\x9b\xaa\x09\x9a\xa7\x77\x77\x74\xad\x9f\xb9\x6c\xf3\xe2\x4f\x66\xa2\x46\xe6\x31\x21\x66\xf2\xd1\xfd\x17\x01\xd0\x59\x53\x37\xe3\xe3\xb1\x94\x28\x88\x92\xa8\xa4\x72\x4a\x5e\xd1\x17\x41\xa1\xa0\xb0\x5c\xb6\x8b\x12\x99\x34\x2f\x61\x50\x5b\xf5\xde\x9c\x9e\x67\xb5\x23\x53\x4e\xf1\x34\xf2\x9c\x40\x36\x66\x67\xd2\x64\xff\x84\xfa\xe6\xba\x2f\x3f\x71\xdb\x20\xf5\x7e\xfb\x3d\xba\x97\xeb\xd0\x1e\xd2\x7e\xfd\x35\xcb\x37\x66\x39\x2d\x2c\xe0\x25\xde\xcd\xbb\x38\x27\xb3\xe4\x82\x9d\x1d\xf3\x5a\x3f\x45\xe2\xdd\x9f\x79\xe7\xd1\xd5\x5f\x1b\x2b\xf3\x67\x8c\x93\xbc\x7e\x9f\xc1\x15\x55\x57\xb2\x26\xf2\x35\x73\xe9\x2e\x6e\x64\x65\xfb\x58\x6d\xfe\x8f\xb4\xfb\xb5\x79\xda\xfd\x3f\x32\x4f\x6e\x4c\x9a\x7e\x46\xc7\xc4\x8e\x33\xa6\x4f\x32\xbd\x43\x50\x42\x9a\x79\xeb\x5a\xe5\x72\xa2\x51\x1f\x2b\xa9\x3f\xd1\x9e\x79\xe2\x09\x9a\xf9\x13\x53\xc5\x98\xed\x55\x02\x3c\x1f\xd0\x05\xa1\x90\xa2\xb0\x0b\x46\x93\xd6\x66\xab\xe8\x87\x97\xc1\x2f\x3e\xc2\x47\xe0\x03\x92\x52\xed\xcd\x22\xd5\x3d\xaa\x3b\x0d\xd5\xf0\x31\xda\xe0\x17\x1e\xae\x6a\x77\x1f\x96\x73\x32\x7b\x53\x96\xcb\x8d\x72\xae\xaa\x1f\x1e\x10\x1f\xe1\xde\xae\xea\x87\x8f\xd9\xbd\x13\xef\x34\xf4\xc3\xc7\x68\x83\xd9\xab\xe5\x46\x59\x2f\x2b\x27\x3f\x2c\xcb\xa6\x62\xfa\x61\xa3\x50\x93\x37\x52\x79\x15\x49\xf4\x54\xef\xb8\xea\xe0\xa6\xd3\x0c\x1a\x73\xf2\xd5\x3c\xf7\x1f\x35\x76\xfd\xab\x1b\x71\x39\x73\x27\xce\x94\x56\x8d\x8b\x3d\xb8\x30\x35\x91\x27\x93\x0e\x08\x90\x1d\x43\x45\x4b\x9d\xc4\xb3\x52\x48\x71\x51\x51\x9e\x2e\x53\xd1\xa5\x84\x4a\xac\xe8\xb6\xf6\x4b\x4c\x75\x69\x25\xdf\x54\x9f\x56\xd2\xc3\xca\x25\x3d\x4c\x76\x70\xa5\x6a\x8e\x88\x43\xe6\x6d\xa2\x47\xf4\x51\x3f\xf5\x2b\xa1\x7a\x0f\xa9\x81\x80\xa6\x7a\xea\x43\x8a\xa6\xd6\x95\x6c\x74\x57\xbd\x47\x53\x83\x41\x32\x82\x48\xb5\x97\xac\x75\xa3\x59\xb4\xbe\x1a\xfd\x91\x2a\x98\x67\xa8\xa7\x02\x89\x8a\xb5\x05\x5f\xf9\xca\x1e\x9f\x28\x09\x01\xbf\x4f\x1a\xb9\x9c\xcf\xe0\xf3\xb8\xb8\x79\x4b\x5f\xba\x99\x0f\x1a\x56\x17\xc6\xcd\x1d\xdc\xf3\xc6\xe7\xf9\x68\xfd\xd1\x83\x8e\x7a\x6e\xb7\x71\x61\x1f\x42\x8a\xdb\xdd\xc8\xfe\xf5\x79\x53\xd1\xed\x6e\x70\xda\x79\x89\xf8\x7f\x0d\x29\x59\xe3\xb6\x0f\xf3\x8f\x2b\x69\xa8\x4f\x72\x5b\xa6\xdb\xdc\x93\x15\x5d\xc2\xaa\x9b\xd0\x32\x45\xe0\x0a\x4a\x56\x71\x78\x5b\xfc\x8a\xa4\x60\xcc\x79\x37\xdf\xb1\xfb\x47\x4d\x86\xae\x43\xdd\xba\xfc\x68\x71\xf9\xd6\xad\xcb\xa9\xb8\x7c\x2b\xeb\x5f\xbe\x95\xeb\x2f\x1b\x7e\xae\xa4\xbf\x23\x5b\x47\xf6\xc4\xa5\xb3\x04\x15\x32\x26\x9a\xd2\xbe\xb9\x2e\x57\x8f\xbb\xa7\x03\xe4\x8f\xc6\x44\x89\xa4\xec\xd8\xf2\xa5\xb3\x5a\xb4\x7d\x6d\x5f\x9a\x79\xb4\x14\xcb\xb5\xd0\xe2\xb6\x2f\xcd\xe4\x8b\xb1\x9c\xb6\x77\xa8\xb4\xe2\xc5\x19\xda\x37\x04\xaa\x54\x1c\x59\xbe\x95\xcd\x6b\x89\x6b\x1b\x33\x73\x43\xcd\x2d\x71\xda\x9e\x99\x1b\xa2\xa9\xfd\xe7\xce\xd3\x36\x8a\xbc\x87\xaf\x01\x86\x50\x1c\x06\x2b\x89\x86\x6d\x0d\x0c\x22\x1a\xbf\x95\x3b\xba\x71\xcb\x4a\x4a\x68\xfc\x36\x6d\xcd\x36\x2b\xff\x5a\x56\x1f\xaf\x35\xbb\xb0\x3c\x46\x36\x5d\x4d\xfc\x51\x51\x02\x57\x32\xeb\xaa\xee\x1d\x8f\xdf\x29\x1e\xbb\x2f\x7c\xdc\x02\x47\x77\x7d\xc7\xed\xf2\x56\x76\x75\x2b\xf7\xb0\x58\xaa\xe7\x9b\x1c\xf0\xc0\xaf\xf7\x59\xd4\x63\x9e\xc2\x8a\x7a\x32\x9e\xaa\x8f\xa9\xc3\xd0\x1f\x01\x1f\x40\x15\x60\x7a\x98\xaa\x81\x81\x61\x08\x3c\x8e\xaa\xaa\x88\x23\x2a\xa7\x96\xc1\x81\xd4\xa3\xfa\x68\x1c\xd5\x59\x4c\x46\xd1\x58\xbd\xf2\x05\x51\x32\x99\xd0\x60\x07\xa5\xf4\x8f\x92\xf2\xfb\x02\x41\x9d\xe7\x69\x26\xe3\x13\xc8\xa4\xbb\xb8\x5c\x36\x95\x3f\x66\x52\x44\xe7\x29\xb3\x1b\x4e\x39\x75\xc6\xf2\xb3\x3e\x2d\xdc\xf0\x87\xd3\x9a\xce\x9e\x94\x5b\x35\xbf\x29\xe0\x08\xf9\xd7\xce\xde\x78\x47\xa8\x7e\xd7\x63\x1b\x7e\xb8\x7d\xf5\x14\xea\xa6\x89\x7b\x37\x0d\x19\x76\x4d\x5c\x69\xd3\x5e\xee\xbe\x06\x6b\xeb\x42\xc5\x31\xf3\xd3\x67\x35\xc9\xd2\xc6\xf3\xd2\x9d\x97\xcf\xa0\x06\xd6\x73\xa5\xd3\xc2\x77\x9f\x41\xcb\xb8\x15\x73\x37\x7d\x69\xef\x12\xaf\xf5\x24\x62\xa3\xb9\xf6\x8e\xd9\x0b\x4d\x00\x23\x9b\x7a\x9e\x4c\x21\xae\x4f\x15\x85\x9c\x62\xe8\xd9\xe3\xfe\x4c\xf5\xa6\x8d\x0c\x3f\xa0\xe7\xdf\xff\xe3\xe6\x37\x27\xcd\xde\xd2\x7d\xc5\xb6\x07\x9f\x7b\xae\x7c\x50\x0f\x32\x4c\x12\x8a\x9b\xf6\xb2\x33\xdf\xda\xd5\xd9\x49\x3f\xb7\xf6\xef\xfc\xda\x5b\xe5\xaf\x9b\x75\x99\x22\xc6\xe8\x9d\x38\x3a\x5f\x15\x47\x0a\x1d\xe8\xaa\x48\x7a\x35\x5c\x7b\xbe\x6a\x6d\x15\xcd\x45\xe1\x56\x22\xa2\x3b\x10\xd1\xdd\x5c\x74\x06\x45\xa5\xda\x23\xf4\xe6\xc5\x6b\xfd\x5e\xe7\xcc\x15\xde\xb0\xb7\xb3\xd5\x79\xd8\xb0\x39\x1a\xba\x5b\xc4\x11\xf0\x6a\xe5\x62\xbf\xa1\xdf\x93\xaa\xe9\x9d\x37\xf4\xc3\x62\xf9\x1a\x51\xed\xc9\x1d\x41\xae\xa7\x27\x27\x22\xd7\xc3\xbe\x19\xf6\xae\x98\xa9\xaf\xe5\xad\x9d\x16\xc3\x2c\x69\xe8\xfb\x2a\xb5\x50\xd7\xef\xf5\xcc\x3c\x53\xb5\xd2\x55\xb7\xa8\xea\x51\x23\x83\xa0\xbf\x8d\x3e\x9f\x27\xde\x69\xc8\xa9\x73\x2b\xf6\x4f\x7a\x37\x1b\xe2\xb6\xde\x04\xbd\x83\x8d\x9b\x35\x3b\x58\x4a\x0a\x56\x14\x68\xa6\x25\x5e\xd6\x9b\xa8\xdc\x06\x59\xa8\x1e\xa7\x6c\xe6\xb9\xe2\x86\xfe\x0d\xf2\x84\x89\x8b\x37\x54\xbe\xdc\x0f\x56\x7a\xac\xa9\x58\x1b\xd7\xf7\x7a\x78\xd1\xc4\xd6\x70\xf9\xbc\x7d\x4f\x3f\xf8\xc2\x33\x94\xee\x7f\xf0\x85\x1b\xe9\xfc\x3e\xae\x23\x16\x59\xe9\x71\xd8\xc4\xc5\x4b\x3e\x75\x32\xb7\xaf\x7f\xc3\x86\xc5\x13\x27\xc8\x1b\x2a\x5f\x0d\x9e\x95\x91\x58\x87\x9e\xb9\x75\xe2\xa2\x30\xfb\xca\x8d\x2f\x3c\xd8\x4f\xe9\x67\x5e\x78\xf0\xe9\x7d\xda\x97\xfb\xb8\xb6\x58\xca\xea\x59\x69\x13\x17\x9e\xb1\x6c\xa6\xa9\x46\xc0\xb0\x4b\x52\x85\x41\x48\xf0\xa0\x11\xd7\xe3\x69\x1c\xad\xb1\xeb\x32\xdb\x17\x48\xe7\x3d\x23\xae\x9a\x7b\x7e\xfc\x1f\x71\xd1\xcf\x3f\x7f\xcd\x4f\xcd\x25\x3f\x64\xd8\x04\x19\x96\x41\xba\x90\x2f\xc6\x52\x7a\x3d\x46\x76\x25\xa5\x98\xe6\x41\x46\x59\x2c\x93\x0e\x04\xf3\xe9\x60\xbe\x9b\xcc\x12\x02\xc1\x80\xe7\x7f\x93\x99\x53\x0d\x2a\xe2\xee\xee\x5d\xd3\xdb\x73\x71\x8f\xf9\xd6\x54\xa7\xf5\x4b\x75\xfe\x58\xa7\x24\x05\x37\xc9\x75\xb6\x2b\x92\xad\x75\x76\x29\xf8\x9d\x3a\x2f\x05\x63\x13\xae\x92\x1c\x75\xb6\x1d\x92\xad\xcb\x1d\xb4\xef\xb6\x39\x47\x92\x06\x36\xeb\x49\x63\x6d\xb5\x49\x2d\x76\x3d\xa9\x7d\xba\x2b\x58\xb7\xdb\xe6\x64\xea\x5d\x76\x6f\x86\xdf\xc2\x2c\xbd\x4e\x9f\xcf\xe7\xec\xb5\xb0\x2d\x7c\xc6\x6b\xbf\xeb\x2e\x87\x27\xc3\xf3\x5d\x9d\x95\x88\xcc\x04\x91\xdf\xcc\x67\x3c\x8e\xbb\xfe\xd9\xf4\x95\xab\x8c\x86\x0d\x26\x3c\xd7\xd3\xc3\xe7\x2a\x0e\x6d\xc7\x53\x36\x99\xea\xe3\x13\x26\xcf\xaa\xb3\xda\xa5\xe6\x4d\xd2\x32\xd9\xbe\x6e\x52\xbd\xcb\xf6\x45\x9b\xff\x53\x92\xe5\xb3\x8d\x56\x9b\x73\x51\xa0\x5d\xa9\x27\x4f\x5d\x6d\x52\x4b\xf3\x55\xd2\x32\xaf\x73\x5d\x47\x4d\x52\x4b\x9d\xbb\x37\x30\x39\x16\x64\x9e\xf2\xc0\x76\xb7\xab\xb1\xe1\xb2\x06\x9e\x9b\xbb\xc2\xcf\x98\x7f\xc5\x5c\x8e\x6f\xb8\xac\xa1\xd1\xe5\xde\xee\x76\x35\x05\xf5\x08\x96\x88\x9c\xe3\x67\x6c\xee\x04\x36\x47\x8f\x0b\x36\xb9\xb8\xc1\xff\x49\xae\x11\xbb\x11\x83\x17\x4e\x1a\x56\xaf\x6e\xd1\xe0\x86\x8d\xeb\x80\x94\x94\x92\xed\x12\x0a\x5d\xbc\xa1\x22\xc8\x27\x22\x3c\xf9\x44\xa9\x99\x0f\x36\x8b\x3a\xa5\xa5\x94\x94\x92\x12\xe3\x11\x7d\xc4\x26\x0a\x5d\x94\xcb\xa6\x9a\x49\x50\xf7\x6b\xdf\xfd\xf7\x4f\x2e\xbb\xe6\x9e\x44\x9a\xab\x93\x19\x11\xc7\x04\x4e\x24\x21\xe1\x6e\xf2\xdb\xae\xb9\x6d\x3f\x9d\x4a\xd7\xd1\xa9\x6c\xfa\x6d\xd7\xd8\xfc\x4d\xee\x84\x40\x22\x27\x30\x8e\x88\xf3\xd9\xd3\x89\x7b\xae\x59\xf6\x49\xed\xd0\x4f\xa6\x36\xdf\x4f\xad\x1b\xaf\xbd\x29\x78\xc3\xdd\xdc\xad\xda\x5f\x0e\xde\xec\x5e\xda\x6a\x95\xdc\x0e\x4e\x12\x45\x5e\xe2\x24\x12\x15\x7f\xb2\xb5\x7e\xde\x2f\x37\xdd\x7a\xf0\xe6\x9b\xcb\x37\x6f\xfe\xc5\xbc\xfa\xd6\xa4\x5f\x11\x49\xe2\x24\x5e\x14\x25\xce\xe9\x26\xc9\xda\xba\xd4\xbd\x95\x5f\xb6\x64\xf9\xe0\x4d\x0b\x7b\xe6\xbe\x32\xc2\x77\x1b\x67\xe7\xa6\x63\xfd\xe8\x6d\x33\x94\x55\xe2\xd1\x6c\x3e\x97\x55\xe2\x23\x92\x90\x27\xa3\x73\x46\xba\x88\x99\xcb\xa6\xba\x28\x9b\xd2\xa3\x53\x5d\x54\xf0\x19\x23\xc3\x78\xc4\x36\xa6\x23\x69\x74\x3e\xd5\x07\xa5\x2e\x39\x65\xd2\xcd\xfa\x08\xcc\xa4\x03\x64\x5e\x49\xc3\x3f\xb2\x28\xad\xf5\xf7\x15\xfb\x42\xf5\xc9\x09\x81\x02\xaf\x34\xb4\x27\x26\xa4\xdc\x91\x88\x23\xd9\x34\x29\x38\x59\x78\xf9\xc6\xab\x4b\x42\x73\xdc\x9b\xf3\xb9\x22\x6d\xea\x14\xab\xc2\x4d\xa7\x47\x3f\x9f\x38\xa7\xef\xbb\x9f\xde\x18\xd0\x06\xf4\xf9\x93\xbc\x89\xd5\x53\xa7\xd4\x07\x95\xb6\x54\x66\xc9\x4d\x73\x26\xef\x5b\xb3\xdb\xbc\xb3\x86\xa9\x99\x85\x53\x7f\x36\x6d\xe5\x8a\xd0\x55\x9f\x6d\x0b\xce\x16\xd2\x91\x5c\x3c\xe1\x2d\xab\xa2\xe4\xb2\x78\xd8\xfc\xaf\x86\x9a\xdd\xf3\x17\x44\xd2\xa7\x36\xcc\xf0\xd0\xf2\xc4\xa7\x16\x44\x13\x0b\x67\xf9\x03\xab\x17\xde\x7a\xff\x49\x6d\xad\x3d\x39\xa6\xe6\x7a\xea\x6f\xec\xc9\x35\x5c\xbd\x75\x62\xf2\x94\x5b\xae\x3c\xe7\xfc\xdd\x18\xb9\x83\xc9\xb0\x25\xed\xd2\x65\xcb\x9a\x19\x2d\x65\xf4\xb5\x81\x8f\xbc\xa9\x31\x91\x9c\x82\x89\x31\x21\x18\x08\x36\xb3\xa0\x3e\x91\x2b\xb9\x68\x3a\x5f\xd0\x57\xc4\xea\x34\x67\x98\x8d\xa6\x94\xd4\xe8\xf2\x53\xe8\x22\x7d\x0a\x93\xfc\x23\x28\x1d\xc1\x57\x5b\xc4\xe5\xcb\x79\xe3\xcd\xc2\xca\xb3\xd4\x1b\x5f\x16\x26\x07\x27\x35\x25\x1d\x91\x88\x3b\x35\x21\xd1\xde\xa0\xf0\x85\xc0\x84\x64\x7d\xa8\xaf\xd8\x47\x7d\xe9\x45\xea\xee\x35\xfb\x26\xc7\xe3\x37\x2d\xc9\xa4\x62\xad\x75\xf5\xf2\xe4\x69\xab\x13\xda\xbb\x06\xd2\x22\x81\x8d\xea\x33\x17\x6d\xd8\xfe\x75\x9a\xce\x29\xd6\x29\xbc\x79\xc8\x52\x43\x7c\x39\x79\x66\x34\x9c\x9a\x6e\x51\x92\xf3\xdd\xcd\xa1\x4f\x9c\x31\x9f\x79\x2c\x2e\x49\x2c\xab\xde\x44\x3c\x17\x49\x0b\xb3\x83\x6d\x9f\xbd\x2a\xb4\x62\xe5\xb4\x9f\x4d\x5d\x98\xbe\x70\xf7\xf9\xe7\x5c\x35\xfb\xd4\x53\x92\xd1\x95\x67\x7e\xd2\x9f\x5e\x78\x63\xbd\x89\xb7\xd6\xf6\xf6\xfb\x6e\x16\x16\xae\x0e\xf8\x67\x2d\x4c\x44\xe7\x57\x78\x82\xaf\x73\x45\x43\x26\x07\x79\x8e\xb9\xdd\x97\x2b\x8e\xbf\xbd\x57\x18\x38\xf2\xa3\x63\xaf\xe7\xad\x1d\x9b\x2a\xc2\x38\x19\xa0\x6c\x07\x67\x48\xea\x3a\x22\x63\x4e\xce\xef\xd3\x65\xa2\x42\x85\xcf\x1c\x77\x67\xb2\xa8\xb6\xcd\xea\x5b\xbe\x66\xf3\xea\x79\xf5\xde\x2e\x6f\xfd\xbc\xd5\x9b\xd7\x2c\xef\x9b\xd5\xf6\x5d\x76\x2a\x9b\xbd\x5f\x7d\xb3\x7c\x87\xf7\x04\xf7\x29\x73\x8f\x9e\x7e\xcd\xfc\x0e\x77\x66\xe1\xac\x70\x20\x10\x9e\xb5\x30\xe3\xee\x98\x7f\xcd\xe9\x7b\xbe\x5b\x7e\x89\x4d\xda\xbf\xe7\xb7\x6f\x96\xf7\x78\x8f\x77\xdd\xf2\xa8\x9d\x6a\x44\x00\x5a\x75\x7e\x2e\xe9\x0b\x38\x59\x2d\xaf\xe1\xaf\x04\x54\xec\x34\xa7\xb2\x66\x6e\x64\xc7\x6c\x24\x99\xb9\x43\xc6\x54\x46\x82\xcb\xa1\x19\x56\x9a\x54\x74\xc8\x15\xef\xcc\x15\x2b\x66\x52\x84\x7c\xa2\x47\xb4\xf1\x5c\xbf\x5c\x1e\x90\xb3\x8a\xb1\xf7\x13\xa2\x92\x92\x95\x59\xa4\x8f\x8f\xf8\x43\x0e\xd3\x30\x5d\x76\x18\x9e\x15\x33\xcb\xc5\x99\x2b\x18\x2f\xd5\xb1\x74\x56\xcf\xa2\x84\x28\x52\xb9\xe3\x20\x12\x52\xe4\xf2\x40\xf5\x1c\xb0\xc9\xeb\xba\x90\x44\x0e\x28\x64\x3c\xf1\x42\x07\x19\xab\xb6\xb9\x2b\xe0\xd1\x79\x2d\x29\x93\x8b\x07\xb8\x8c\xc7\x5c\x88\xfd\xe3\xd9\xd0\x77\xfe\xfc\xe7\xf7\x69\xce\xc6\xf9\x73\x4f\xa6\x69\xf3\xd8\xfc\x3f\xef\xdc\xbc\x6d\x3e\xfb\x33\xc7\xfd\x59\x72\x4d\x6f\xdf\x48\x07\x6a\x59\xcf\x2d\xec\xdb\xaf\x64\x67\xcf\xce\x66\x4e\x3d\x75\xe8\xab\x74\xdb\x3d\xf7\x5d\xb9\x7a\x66\x79\x3b\x6d\x55\xbc\xf1\x29\x5f\x66\x57\xd4\x72\x9b\x86\xee\xdb\xb8\x33\xa5\x0e\x1d\x3a\x65\x19\xec\x84\xc7\xe0\x27\x74\x00\x38\x27\xb5\x51\x2c\xc5\x19\x12\x50\x3e\xe3\xa9\x08\x77\xba\xc4\xe7\x49\x07\x68\xc0\x1b\xf6\x7a\xc3\x5e\xd6\xaf\x84\xb4\x33\x33\xcc\x63\xa7\x46\xa1\x57\x5b\x17\x52\xbe\x7c\xfe\xc8\xd5\x8b\xd9\xf3\xbf\xcc\xfa\xc9\x30\xed\x30\xee\x25\xd3\x1e\x0b\x29\x5a\x93\xdd\xd3\x48\x6f\x2a\xa1\x4f\xff\x88\xc1\x94\xf3\x34\xfc\x68\x44\xfe\x32\xfe\xcf\xe0\xf1\xee\xff\x6d\x32\xef\xf7\xad\x35\xf4\x1f\xb9\x85\xf1\x78\xfb\x7e\xa3\x26\xb9\xcc\x00\xa0\x5c\x1c\xb1\x3f\x36\xae\x47\x53\x95\xac\xbc\xaf\xbc\xd1\xdc\xfe\x63\xdb\xf7\xc9\xa6\xa9\x22\xeb\xd3\x4a\x55\x43\x5c\x23\x61\xd5\x08\xd7\xb8\x90\x91\x3b\x43\x43\x48\x31\xf2\x19\xbb\x80\x7a\xbe\xac\xa2\xd4\xdc\x31\x15\x34\xfe\x97\xf0\xf1\x69\xd0\x3a\xd2\xa6\xac\xd2\xc5\xaa\xa7\x15\xe2\xd1\x89\x4c\x67\x3e\xcd\xa0\x00\x7f\x3c\x12\xa4\x2b\xf6\x6e\xd2\x4a\x15\x9a\x25\xa3\x25\xda\x40\x85\x66\x2b\x61\x9b\xf6\xea\xe2\xd7\xf1\x48\x91\x32\xe5\x62\x0d\xe5\xb2\x92\x49\xb9\x16\x93\xac\x47\xe4\x7d\x15\x22\x1c\x98\x0f\x90\x92\x8b\xfa\x7d\x81\x64\x2e\xea\x93\xba\xa8\xe0\xf7\x99\x2b\x18\x19\x1b\x3f\xd5\x7e\x30\xf7\x48\x8c\x59\x39\xa5\xa4\x3a\x2a\x8a\xa5\x5c\x8d\x54\x4c\x3f\x5d\x30\x8c\xa7\xf9\x1f\x0c\x63\xc1\xe7\x9f\x56\xcf\xfc\xfc\x0b\x97\x4d\xcc\x29\x4d\x33\x66\xf5\x5c\xe9\x75\x0e\x95\x9c\xde\x2b\x7b\x66\xcd\x68\x52\x72\x13\x2f\x7b\xe1\xf3\x67\x76\xb6\x52\x64\xc5\x4c\x56\x9c\xb9\x82\x22\xad\x9d\xec\xf3\x0f\xfc\xa2\x6f\xd1\x9e\xf7\xfb\x7e\xf1\x40\xd3\x9e\x17\xd5\xb9\x3b\x36\x9e\x26\xe4\x27\xc4\x16\x66\xf2\x0b\xce\x3e\xd5\xbc\x61\xe6\xd4\xb3\x17\xe4\x33\x0b\x63\x13\xf2\xc2\x69\x1b\x77\xcc\x55\x5b\x3b\x4d\x1d\x66\xa7\xf9\x0f\xf5\x46\xce\x2c\xe8\x92\x4d\x0b\x52\x68\x47\x1a\x37\xe0\x0e\x80\xf2\x29\x45\x12\x83\x01\xf3\x5d\xc8\xa7\x2a\xfe\x60\x5e\x49\x29\xc6\xd7\xf0\x37\x53\x36\x1e\xf3\x15\xf4\x90\x3c\x65\x11\x81\xdf\xe7\x0d\x06\x74\x59\xc2\xc9\x3a\xc8\x68\xb0\xb1\x22\x07\x9b\xc9\xb8\x80\x4a\xef\xbf\x82\x52\xc8\x07\x5a\x74\x89\xbc\x8b\x05\x03\xfa\xda\xe3\xe4\x24\xf3\xa8\x76\xa0\x90\xf7\x8e\xa7\x67\x26\xf1\x92\x55\xe0\x25\x6b\x50\x90\x44\x51\x12\xc4\x49\x4c\x92\x88\x93\x2c\x01\x46\x9c\x68\x11\xc4\xb3\x59\x9d\x95\x67\x75\xd6\x0e\xbb\x6d\x06\x0b\x30\xe6\x63\x9f\x31\xcf\x3a\xfc\xf0\x1e\xaf\x87\x44\x39\xdb\xde\x66\x09\xc6\x98\x50\xc7\xd5\x39\x45\xef\x44\xbb\xbb\xad\x3d\xe2\x94\x42\x53\x16\xcc\x4b\xe5\xea\x9b\xe4\xb9\x0d\xa1\xa9\xdb\xa7\xd6\xc5\x7b\xe5\xa6\xfa\x5c\xb8\xad\x38\x43\x89\x93\xc7\x7b\xcf\x0f\x09\xb5\xf3\x05\x2d\x16\x25\x49\x10\x25\xa9\x43\xe2\x78\x8b\x85\xe3\xa7\xf0\x3c\xe3\x05\x8e\xc9\x24\x31\xc9\x22\x89\x73\x25\x9e\x93\x24\x9e\xe3\xdd\x6e\x97\xc4\x4b\x16\x9e\x4e\x35\x8e\x86\x1c\xf8\xaa\xf6\xf7\x2c\xe7\xb6\x67\xdb\x88\x23\x6b\x4b\x68\x9a\x8b\x84\x3a\x8b\xc4\x37\x06\xc2\x61\x49\x9c\x14\x10\x1b\x72\xe7\xcf\x39\x6d\x6a\xd7\x02\xb1\xd1\xed\xf6\x78\xa4\x40\xb3\xb8\xa0\x6b\xea\x69\x27\x9f\x95\x4b\xb8\xf9\x96\x62\xeb\x4a\x66\x77\x73\x59\xaa\x63\x9f\xab\x9d\x93\xaa\x77\x27\x94\x8c\xbe\x33\xe6\x81\x8f\xbe\xbf\xcf\xb8\x68\x33\x5f\xd0\xc9\xcd\xdc\x5f\x37\xa3\xa2\xb1\x94\x52\x51\xc1\x9d\xe8\x06\xbf\xaf\xf9\xcf\x9f\x41\x98\x71\xbe\x9f\xbe\x66\x5c\xe2\x37\x71\x18\xa6\x9d\xea\x30\x26\x7a\x3c\x2d\x54\xf2\xe6\xbd\x54\x6a\x51\x4e\x70\x89\x5f\xe7\xbc\x79\x9d\x9d\xac\xaf\xb5\x3a\x4c\x5b\x53\xcd\x54\x92\xe5\xff\x8f\xb7\x37\x81\x6f\xa3\x3a\xf7\x86\xcf\x73\xce\x2c\xda\x66\x24\xcd\x68\xb3\x2c\xcb\x92\x65\x49\x5e\xe5\x44\xab\x1d\x6f\x8a\xb3\x91\xd8\x49\x9c\x95\x40\x42\x62\xb2\x11\xcc\x96\x00\x21\x2c\x59\xa6\x90\x02\x21\x14\x02\x29\x21\xa5\xa5\x31\x94\x16\x28\xe5\x96\xd2\xdb\x85\x36\xb4\xba\x2d\xa5\x7d\x4b\xa1\x84\x0b\xb7\x1b\xed\x35\x5d\xb8\xb4\x85\x96\xb7\xbd\xb4\x25\xb6\xc6\xdf\x6f\xce\x68\xb3\xe2\x10\x7a\xbf\xf7\x7d\x13\x6b\xe6\xcc\x99\x73\x66\xce\x36\xe7\x3c\xe7\x59\xfe\x8f\x9a\xf5\x97\xd6\x59\x76\x8a\x55\xd0\x6c\xb4\x45\x5b\x67\xa9\x69\xb2\x46\x0f\x52\x31\x30\x35\xcb\x17\x41\xfb\xaa\xb0\x93\xaa\x74\x38\x8a\x86\xe1\x1a\x01\x23\x65\x1c\x58\x07\xfa\xd1\xd3\xd2\x8c\x3a\x8f\x4d\xd7\x18\xd4\xd3\xd2\xa1\xe5\xc7\x6e\x3f\xb0\x07\x44\xb3\xc5\x64\x30\x99\x18\xa3\xbc\xcc\xd1\xf3\x56\x77\xeb\x25\xf3\x3a\x0f\xcd\x1d\x39\x30\xbb\xc6\xe5\x71\x79\x2e\xae\xe9\x7a\xa3\xeb\x2b\x97\x7c\xe4\xb5\x3d\xca\x9d\x93\x9f\xdc\xfb\xc3\xae\x5f\x77\x7a\x2e\xae\x59\xbc\xcd\x55\xd3\xb8\x58\x59\xbb\xec\x81\xef\xdc\xd8\xf3\x5f\x73\xe4\x21\xc7\x8a\x25\x26\x86\x58\xb0\x4d\xc2\xcf\xb7\x1d\xae\xf5\xfb\xda\xbd\xee\xf5\xae\xb0\x04\xc6\x59\x6e\x8f\x2b\x3d\x7b\xf1\xef\xff\xfc\x91\xa6\xb1\x66\xf7\xf9\x6d\x75\xae\xfa\xc6\xf6\x9f\x80\xe3\xf0\x67\xd5\x6f\x4e\x64\xda\xea\xea\xae\x5a\xec\x59\xe7\x6e\x7a\xa8\xf9\xaa\xd7\x5e\xfa\xea\xdc\xee\xde\x65\xb3\x4c\xdb\x56\xbb\x2f\x74\x0b\x1e\x63\x80\x69\x7a\xb0\x52\x17\x62\x39\x42\x1a\xc9\xaf\x83\x64\x51\xe2\x0d\x69\x9f\x13\x53\x00\x2f\xa2\xd8\xb2\x5a\x9d\xb0\x36\xed\x14\xaa\xe7\xf6\x13\x1d\x3a\x4b\x0b\x62\xb7\xcb\xed\x62\x15\x87\xd9\xb9\x6d\xe3\x86\xda\x64\x7f\xfd\xb0\x71\xf3\xd2\x03\xea\x9f\x96\xcf\x0a\x11\xbf\x59\xe2\x13\x9d\xf1\x9a\xf3\x6b\x45\x5e\x0a\x99\x23\x01\x2b\xa9\x13\xbb\xe6\x75\x99\x78\x27\x0c\x3d\x77\x08\x37\x88\xb5\x46\xa9\x33\xde\xe3\x10\xeb\x5a\x98\x9a\xae\x85\xf2\x42\x8e\x40\x53\xed\xf9\x35\xf1\xce\x04\x2f\x99\xfd\x24\x34\x6b\x39\x48\x07\x96\x6e\x36\x0e\xd7\xf7\x27\x6b\x37\x6c\xdc\xe6\x34\x3b\x08\xb7\x50\x5e\xd8\x55\xc3\xb4\xd4\x89\x8e\x9e\x78\xa7\x64\xac\x15\x1b\xf0\xa1\xe7\x86\xc0\xc9\x9b\xba\xe6\x75\x89\x75\xc4\x1a\x88\x98\x43\x12\x5f\x5c\xc3\x4a\x18\xb2\xe8\x5c\x86\x69\xcc\x48\xd9\x3e\x64\xe3\xaf\xca\x26\x24\x7b\x1e\x67\x51\x71\xdd\xd1\xee\x8d\x95\x6f\xe8\xeb\xb6\x8e\x61\xc2\xe9\x78\x86\x76\xc8\xb8\x41\xfe\x40\x30\x13\x65\x12\xc1\xa3\x17\x5c\x00\x8f\x5a\xce\x8a\x6a\x82\x26\x22\x70\x6c\xcd\x1a\x75\x94\xbd\xf0\x83\xf1\x4d\xca\x3c\xb6\x45\xe8\x7c\x4a\x43\x32\xd1\x18\xd6\x85\xff\x31\x1c\x8d\x41\x49\x01\x40\x0b\xb2\xa1\x06\x1d\x0b\x9a\x71\xbb\x90\xdb\xcf\x52\xc0\xbe\x33\x19\x6d\x4c\x60\x76\xac\x9d\x63\x7d\x2e\x93\xb5\xb5\xb1\x59\xe0\x65\x8b\x8b\x6c\xb9\xab\x13\x0b\x1c\xdf\x3c\xbb\xd9\xe4\x20\xc4\xe3\xad\x75\x9b\xcc\xb3\x52\xb1\xf9\x2c\x2b\xf0\x12\xee\x81\xae\x47\xb8\x59\x52\x73\x4d\xa3\xad\xeb\xa8\xd3\x55\x35\xad\x9d\x6f\x36\xb9\x6b\xbd\x1e\x42\x1c\xa6\xe6\xd9\xcd\x3c\x27\xe0\xcc\xdd\x5b\x88\xcb\x22\xf3\x42\x73\x63\xab\xd5\xe4\xf2\xb1\x5c\x7b\x6c\x76\x80\x71\x39\x8f\x76\xd9\x1a\x6b\x9a\xa5\x59\xdc\x23\xea\xf7\x7b\xb0\xc4\x0b\x2c\x3b\x3f\x96\x22\x5d\x95\xf3\x12\xa0\x36\x84\xb8\xd5\x2c\xa2\xf2\x78\xca\xc9\xc0\x22\x30\xfa\x4e\x35\x13\x83\xc2\xa9\x17\x5c\x6e\x2a\xfb\x76\x31\xee\x02\xbe\x56\x3a\xc3\xf1\x69\x6e\xf5\xbc\x4d\x30\xf4\xc9\xff\x50\x5f\xf9\x82\xfa\xbf\xdf\x08\xb5\xbe\xf1\xd4\xa5\x9f\xab\x0f\xfa\x5a\x5b\x76\x1e\x9d\xbf\x6c\x60\x59\xdb\x0d\xb0\xfe\x79\xc3\xb3\xb7\xde\x39\x72\xc5\x48\xf8\xd2\x8b\x98\x1d\x9b\x17\x88\xbe\x9b\xd5\xfc\x9f\xbe\x76\xc5\x3d\xcc\x1d\x78\xdf\xc5\xac\xd9\xfd\xa5\xdd\x4c\x84\xb4\xdd\xb5\x6a\xdd\xe0\x7d\x5f\x36\x45\x1a\x6f\x7d\x76\xbb\xb3\xeb\x9a\x7e\x13\xdd\x1f\x6c\x9a\x52\xc8\xb7\x39\xa4\xf3\xbf\x29\x87\x30\x48\x42\xf6\xa0\x3d\x64\xd7\x65\x6d\xe4\xdb\x0f\xae\xed\x81\x70\x54\x55\x5f\x9a\x42\x53\x2f\x3f\x79\x94\xfd\x6f\xf5\x1f\xe7\x9d\xf7\xac\xfa\xd3\xbc\x11\xff\x1d\x9a\x7e\xfe\x8d\x17\x75\x5b\xe7\xa9\x47\x69\xbf\xae\x46\x1b\xd0\x56\x74\x19\xba\x06\xdd\x88\x6e\x46\xb7\xeb\x5a\x36\x4e\x07\xe2\x39\x7d\x2a\x8a\xf6\x31\xda\x6e\x2d\x1a\xe1\xac\x10\x69\xe0\x63\x98\xe7\xdc\xda\x54\x44\xdc\x1a\x99\xd0\x10\x89\xc6\xa0\x03\x1a\x38\x3f\xd4\x03\xfd\x91\x7e\xa0\x93\x5c\x34\x82\x52\x49\x49\x2e\x2d\xb9\x95\xe7\x69\x97\xda\xd2\x9c\xe4\x1b\x9c\x8e\x4c\x3c\xa3\xdd\x2b\x2a\xee\xa8\xbf\x78\xab\xd6\x0b\xc9\xae\xf5\x17\xcf\x6d\x5e\x1e\x6e\xf7\x8d\x46\x23\x17\x3d\x7f\x91\x2d\x75\xb5\xaf\x3d\xbc\xbc\x39\x7b\xf1\xfa\xae\xa8\xc9\x39\x6b\x60\xae\x5b\xee\x76\x38\x9c\x36\xce\xc2\xf3\xae\x56\x93\x49\xe8\x3b\x6f\x9e\xcb\x0d\xde\xda\xb7\xd4\x5f\xbc\xb4\x86\x98\x4c\x84\x98\x8c\x21\xde\x68\xe2\x78\xa3\xa9\xd1\x68\x34\x18\x8d\x52\xdc\x60\xb1\x18\x8c\x82\x65\x2e\xb1\x59\x0d\x76\xeb\x3c\xbb\xcd\x6e\x9b\x83\x6d\x36\x26\x40\x35\x81\x4e\x4d\xa8\x57\x2d\x65\x3d\x12\x39\xda\x7b\x71\x3b\xe7\x49\x2f\xbf\x65\xcd\x9e\xf3\xd7\xef\x32\x36\x79\x3c\x5e\xaf\x39\xd0\x6e\xdc\xb5\xfe\xfc\x3d\x6b\x6e\x1e\x4e\x7b\xb8\xc6\x79\x26\x53\x6b\x73\xa0\x89\x21\x46\x51\x64\x59\x53\xa7\xdb\x1d\xe9\x10\x80\x61\x22\xdb\x18\xc9\xc3\x2e\x85\x7b\x26\x4e\xc1\xc5\x93\x07\x78\x96\xb0\x3c\xcb\x79\x59\xb3\x91\x63\xcd\xa6\x08\x6f\x11\x78\xd6\xdb\x68\x30\x5b\x8c\x06\xb3\xc5\x66\x66\x19\x17\xc3\xf1\x02\x36\x0b\xd8\x69\xc6\xc4\x63\x98\x26\xeb\x08\x4f\x43\xa6\x8e\x68\x9d\x9e\x98\x8e\xd7\xa3\x51\x63\x28\x80\x38\x25\xe2\xcd\x7a\x23\xc7\x5e\x3d\x36\x52\x76\x32\x80\xc7\x74\xcc\x1d\x92\x2b\xda\x1a\x8c\x1e\x3b\x36\x9a\xeb\x6c\xaa\x40\x3d\x7c\x06\x78\xf5\xfd\x12\x76\xba\x3e\xa7\xd5\x14\x70\xc8\x50\x15\x36\x50\xc2\x49\x47\x5d\x2a\x19\x09\xd9\xa9\x3d\x84\x36\xe9\x65\x52\x41\x67\x22\x15\x74\x72\xe3\xda\x3c\xa6\x1b\xd9\x0a\x32\xa7\xc8\x82\x20\xbf\xaf\xc8\xc2\x08\x20\x05\x14\x56\xd9\x38\x50\x36\xab\x55\x64\x61\x7c\x5c\x90\x27\x90\x2c\xe0\x91\xfc\x98\x20\x2b\xda\x3f\x5d\x27\x86\x2d\xfa\x4b\xea\xad\xb0\x00\x76\xe9\x4c\x4e\x6d\x19\xa1\x5c\xcd\x4c\xba\x1b\x5c\x8c\xdb\x25\xb1\xa5\x3b\x18\x35\x96\xef\x59\x28\x0e\xbd\x6e\x10\x8c\x77\x62\x59\xaa\xbb\xad\xa6\x11\xbb\xd4\x6f\xfe\xae\x26\xe8\xb4\x7b\xd9\x31\x68\xdc\x75\xf5\x6d\x58\xc0\x0e\xc9\x77\xb7\x37\x0c\x96\xa7\xd5\xdf\xa8\xfb\x7e\x52\x13\x72\x48\x5e\x02\x1c\xfc\xe7\x37\xbe\xf9\x1f\xa0\x5b\x09\xab\xdf\xf3\x39\x9c\xc1\x9a\xdf\xc1\x02\x17\x6e\xac\xb9\xad\x4e\xb2\x0b\xb7\x5d\xbd\x4b\x7d\xfd\xe1\x5a\x87\x23\x54\xf3\x13\xb8\x05\xea\x9e\x16\x20\x5c\x73\xb7\x4f\x92\x84\xff\xf8\xe6\x37\xd4\x60\xc1\xce\x14\x15\x64\x6b\xf5\xa8\x59\xa3\x70\x50\x95\x7c\xcd\x5d\xed\x5b\x26\x58\x84\x5f\x86\x19\xd1\x6a\x19\x5b\xc7\x40\x47\xc7\x00\x74\xd0\xd3\x89\x4a\x83\xe5\x89\x38\xf3\xa9\x07\x19\x8f\x38\xf9\x17\xd1\xc3\x30\x5f\xd2\x5b\xda\xf6\x3d\xfb\x86\x0c\x11\x33\x1b\xec\xdf\xb3\xc1\xc5\x03\x7a\x36\xed\xef\x5d\x28\x23\x66\xc1\x3b\xf0\x6b\xc1\x6e\x17\xf2\xfb\x0b\x5b\xe4\x6c\x4d\x1c\x6f\x4c\x0d\x0c\xa4\xf2\x0f\xc7\xe9\x1a\x70\x0b\xe5\x23\xc4\x50\x92\x8e\x06\x6d\x57\xe8\xe0\x42\x28\x2c\x82\xcb\x2d\x82\x1f\xbb\x45\xd0\xd6\xf5\x74\xa6\x84\x76\x1e\xd0\x06\x0d\xb1\x23\xd6\xce\x70\x4a\x6a\x70\x30\x35\x94\x54\x37\xa9\xbb\xe7\x0c\x30\x11\x07\x27\xcd\xee\x88\xd4\x7d\xf6\x0b\x31\xbe\x5d\xae\x25\x26\xfb\x8d\xf4\x9d\xe3\xf0\x65\x78\x31\x39\xa4\xa8\xd7\xa9\x77\xc0\x0d\x44\xa1\x7c\xdf\xe4\x10\xac\x0f\xca\x1b\x2f\x8b\x06\xe7\x26\xba\x9b\xfd\x73\xe2\xb5\x2d\xee\x8f\xf4\x5c\xb7\x7a\x57\x7a\xe3\x40\x6e\x60\x23\x28\x43\xc9\xc9\x46\xf2\x0d\xf5\x95\x66\xf5\x2f\x2d\x94\xef\x94\x9d\x42\x5c\x8e\x43\xc8\x8c\x6a\xd0\x5c\x84\x98\x24\xa5\xa9\x1a\xb4\xfd\x0c\x04\x91\x3d\x19\xc3\x0d\x22\x76\xda\xe8\xc6\x86\x3a\x28\xd0\x9a\x58\x9b\xe3\xa4\x8c\x8e\xea\xe9\x74\xf0\x2e\x49\x9b\xe0\xc8\x11\x5b\xf7\x9a\xc0\x25\x8b\xf3\xd7\xb1\x0e\xf5\x6f\xb3\x2e\xfc\xc4\x37\x3e\x71\xe1\x2c\x26\x37\x94\x54\xb3\xc7\x5e\x3d\xa6\x66\x93\x43\xf1\x95\xeb\x7a\xa3\x7f\xf8\x96\xa1\x73\xb8\xd3\xf0\xad\x3f\x44\x7b\xd7\xad\x7c\x2a\xb0\xa6\xdb\x66\x5b\x7c\x09\xcc\x82\x36\xec\x48\x5c\xbe\xb9\xbf\x7f\xf3\xe5\x89\xfc\xdb\xea\xab\xc9\x21\xed\xab\x1b\x4a\xb6\x6c\x38\xfa\xf9\xbf\x1c\x3e\x0e\xac\x4f\x76\x68\x9f\x9f\x43\xf6\xa9\x13\xc7\x0f\xff\xe5\xf3\x47\x37\xd0\x6f\x1e\x4f\x29\xac\xca\xee\xa3\x7b\x33\xb7\x8b\xe7\xac\xf4\xd8\x01\x3a\x15\xa5\x9d\xa3\x11\xfd\xd8\x4f\x59\xa8\xda\x31\x93\xd6\x8f\xf5\x14\xf5\x51\x3b\xba\x5d\xfa\x51\xcb\xed\x76\xf1\xec\xc8\x1d\x7e\x93\xa5\xe9\x64\xca\x52\x5f\xd7\xfc\x8d\x59\xa6\x66\x0b\x5f\xef\xb8\xed\x36\x5f\x4b\xb3\x69\xd6\x37\x9a\xeb\xea\x2d\xa9\x93\x4d\x16\x93\xff\x8e\xaa\x54\xcd\x75\xb7\xdd\x56\xd7\x3c\x3d\x0d\x56\xaa\xb2\x61\x97\x96\xcd\xdc\x5c\xce\xd6\xe2\x9b\xfe\xe8\x66\x93\xa5\xfe\xf0\x61\xbf\xd9\x34\x2d\x4d\xc9\x27\x99\xf6\x9d\xa7\xd0\x8e\x6a\x7e\x2a\xd5\x2a\x0c\x35\xf0\x1c\x5f\x90\x6e\xd8\x35\x9a\x30\x31\x8d\x9f\x5a\x64\x11\x72\x05\x86\x6a\xc1\x92\xb7\x48\x6b\xf4\xb1\x1a\x9d\xc9\xe8\x52\x9f\x60\x89\x9b\xca\x7e\x6e\x59\x3c\x9f\xf3\x37\xfa\x2f\x58\xe4\x19\xf0\x08\x4d\xe7\x2d\xf2\x2f\x58\x14\x08\x9c\xf7\xad\xef\xad\x78\xb6\xc0\x45\x85\xc1\xe4\x90\x72\xff\xa5\x8f\x33\x41\xca\x49\xfd\xe8\xb3\x8f\x74\x17\xd8\xa8\x01\x93\xdb\xe3\xac\x15\x3d\x78\x6e\x48\x68\x6a\xe8\xe8\x8f\xec\xfb\x8c\x0b\xae\xab\x64\xa6\x3a\xba\x52\xab\x5a\xe7\xf5\x1e\x6e\x73\x66\x57\xac\xa8\xe9\xca\x2b\xd9\x6c\x25\x13\x75\x28\x75\xe9\xf1\xbe\x2e\x9d\x83\xba\xa0\x5b\x67\x04\x1a\x65\xbb\xcf\xea\x23\x4b\x32\xce\x95\x7d\xd9\xd0\xad\x37\xce\xef\x39\x8e\x2a\xda\x27\x85\x7a\xd1\x2e\x84\xc2\x09\xbb\x8e\x4b\x44\xff\xc7\x18\x2a\xb8\xf3\x63\x27\x75\xd6\xe6\x4a\x04\x35\xd2\xcb\xcd\x39\x5c\x6e\x5d\x6d\xb3\x0f\xaa\xb6\x51\x74\x97\xd1\x0f\xba\x20\x46\xdf\x6a\x24\x82\x3a\xe9\xe2\x27\x1a\x29\xce\x51\xfa\x6c\x24\x10\x08\xcd\xed\x69\xaa\x33\x30\xe7\x35\x89\x1e\x90\x25\x97\xd3\xb0\xe8\x02\x7f\xa3\x3f\x9f\x8b\x2f\x1b\x4a\xc2\xa0\xce\x59\x65\x2e\x3e\x7f\xf5\xf3\xdf\x82\x1d\xfa\x56\x6b\x30\xa5\x8e\x77\x3f\xf2\xad\x03\x77\x3d\x05\xd0\x4b\x82\xcc\xe3\x97\xde\x7f\x7c\x07\x5c\xe7\xfa\xcc\xbe\x48\x7f\x47\x43\x93\x10\x9a\x8b\x3d\x62\xad\xd3\xe3\x36\x41\x20\x35\xa8\x60\xc5\x13\x6f\x09\x1a\xd9\x15\x59\x57\x8c\x44\x83\x11\x77\xef\xbc\xd6\x55\xa9\x2e\xc7\xd2\x44\x72\x88\x32\x56\x03\x4b\x16\xdb\x3c\x81\x35\x2b\xb3\xd9\x48\xa1\x61\xf3\x4a\x6a\xb0\x7b\xc1\x27\xef\x64\x87\xb6\xbb\x9c\x5d\x7d\xc7\x2f\xbd\xe4\x78\xcf\xfc\x1b\x6f\x0d\x65\xfb\x56\x3a\x33\x4b\x88\xcf\xea\xb3\xcb\xc6\x41\x54\x89\xff\x5f\x18\x57\x4c\xb1\x19\x92\xa1\x06\x3e\x06\x0d\x54\x46\xcc\xdb\x75\xc9\xa7\x9d\xc2\xf7\xea\xde\xee\xe8\x7f\xba\xb4\x51\x46\x3d\x57\xb1\xea\xc5\xd8\xc2\xce\x25\xad\xfb\x0a\xa4\xcc\x11\x97\x9b\x52\x7d\xc5\x6d\xe7\xe7\xa6\x75\x73\xf2\x8c\x91\x80\x95\x6c\x56\xd1\xba\x3c\x3f\x73\x97\x5f\x52\x1e\x18\x17\xea\xae\x0c\x7b\x2a\xc7\xe3\xd9\x06\xed\xda\x0f\x31\x3a\x4b\x43\x79\x5a\xfb\x24\x51\x0f\xda\x49\xa9\x7a\xa0\x4a\x00\x94\xf7\xa3\xfd\x17\x19\x7d\x04\xe1\x84\x9d\x6e\x56\x53\x76\x8d\xe6\x75\xc5\xd3\x19\xed\x0a\x97\x50\x27\xb8\x0e\xba\xf7\xe0\x78\x2a\x67\x8d\xa4\xec\x45\xc0\x5a\xaa\xfd\x55\x61\x45\xaa\xed\xe2\xb2\xd9\xfc\x07\xf4\x7a\xac\xab\xdc\xe9\x4a\x61\x17\x5f\xe8\xec\xf4\x5c\xad\xb3\xd3\x4b\x6e\xb8\xad\xaa\xb3\xe9\xb7\xd3\xbd\x00\x67\x57\x3f\xff\xad\xf3\xce\x35\x6a\x43\xfa\xa0\x25\xbd\xb4\x69\xf3\xf3\xf5\x91\xea\xe7\x3f\x78\xa4\x16\xc6\xf5\xf4\xbd\x50\x3d\xa5\x8a\xa8\x3d\x66\x26\x5d\x30\x3d\xe4\x39\x47\x3d\x80\x2b\xde\x0f\x5a\x4c\x95\x7d\x26\x8b\x22\x5e\xd5\xf4\xac\x2c\xaf\x97\xd2\x92\x7a\x6c\xbd\x24\xad\x87\x51\x29\x2d\xad\x97\xa4\x67\xe1\x6f\xde\x08\xa0\x99\x2c\x36\x9f\xd5\x0d\x15\xb5\xf4\x69\x69\xbd\x7a\x4c\x92\xb4\xc0\xb3\x1f\x6c\xc3\x49\xcb\x86\x92\x1d\x00\xd4\x16\xd2\x51\x0f\x25\x9b\x51\x5a\x44\x57\x3c\x03\x99\x4a\x8b\x43\x96\xa5\xcf\xd6\x0b\xa3\x9a\x28\x85\xf8\xb7\x42\x51\x61\x74\x3d\x08\xd5\x45\xdb\x96\xa6\xa5\x2f\x14\xc6\x5b\x2e\x28\x8c\xae\x57\xcf\x6a\xa7\x59\x28\x57\x54\xb7\xd1\x04\xbd\x28\xfd\x50\xb2\xaa\xa5\xce\x19\x1a\xa7\xdb\x6b\x9e\x51\xf3\xd2\xcb\x40\xac\x2e\xd5\x76\x5a\x5a\xe9\x2c\x75\xc9\x9f\xab\x5c\x1d\xb4\xb9\x4a\xca\xa1\xba\x21\xa9\xc3\x0d\xb4\x58\xd3\x30\x50\x58\x66\xc6\x9a\x4b\xb4\x55\xce\x2c\xd7\xd6\x72\x2f\xcf\x30\x06\xd0\xd4\x07\xd9\xc1\x99\xe1\xa7\xd8\x53\x65\xf7\x20\x02\x1f\xd7\xd1\x9d\x33\x69\x77\x24\x9d\xe9\x83\x7e\xe0\x22\x51\x07\x9f\x8c\x70\xd1\xe2\x96\xbc\x41\x84\x50\x44\xc4\xbc\x08\xbc\xb6\xd3\x4a\x47\xa2\x09\x7a\x8b\xe7\xfc\xe0\x74\x69\xcb\x83\x76\x8b\x73\xb9\x5d\x22\xb6\x6a\xd9\x23\xd1\x08\xaf\xfd\xb4\xd4\x7d\x90\x4a\x67\xfa\x70\xc8\x45\xf5\xfe\xfd\x90\x70\xa5\xa3\x2e\x9a\x82\x73\x47\x44\xd0\xde\xd0\xa0\x3d\x32\xad\x3d\x90\x52\x7f\x2e\x5e\x9b\x39\x5c\xbc\xb6\x37\xd6\x36\x83\x11\x8d\x18\xa1\x2a\x38\xbc\xfe\x10\x77\xc6\xe5\x8e\xf0\x1c\xef\xe2\x63\x38\xaa\x2d\xe9\x2e\xb7\x1f\x67\x5c\x7c\x9a\x52\x27\x5a\xb9\x5c\x99\x06\xce\xc1\xbb\x39\x57\x86\x2b\x30\x85\xc0\xcd\xb9\xf8\x06\x2e\x44\xf9\x40\x99\xb4\x0e\x64\x1d\xf7\x63\x9e\xa3\x77\x43\x71\x97\xce\x2d\xa2\x78\x7f\xf1\x34\x75\x45\x95\xd1\xef\x69\x1b\x71\x57\x26\x9d\xe2\xa2\xc9\x18\x4e\x27\xe2\x69\x9a\x57\x6b\x25\xce\xd9\x10\xed\x83\x4c\x1f\x89\x50\x7e\x1c\xcf\x69\x77\xb4\xe9\x9e\xc6\x82\x8b\x2a\x49\x84\x5c\x69\x6d\x4f\x1a\xc9\xb8\x32\xf4\xe5\xe9\x0c\x5d\x18\xfa\x20\xd2\x01\xc9\x54\x34\x06\xba\x94\x36\x1a\xcf\x34\xc4\x20\x94\xd6\xb2\xba\x32\xfa\x29\x9d\xa4\x1d\x92\x0e\x51\x76\x73\x24\x9a\xd6\xce\x11\x92\xa6\xea\xef\xd1\x74\x01\xf7\x91\x17\x89\x3b\x12\x8d\x61\x8a\x6e\x19\x49\x47\x23\x22\xa3\x85\x62\x90\xf2\x53\x6a\x8f\xe7\xdc\x0e\xce\xed\xa8\xb6\x60\x21\xf3\xb1\x95\xc3\x2c\x0b\x9c\x4d\x8c\x34\xd8\xb1\x9b\x10\x0f\xc1\x16\x33\x70\x46\x11\x9b\x4c\x1c\x60\x2b\x06\x42\x58\xce\xc0\x03\xe1\x08\x87\x89\x99\x58\x6d\x26\xce\x48\x78\x16\xac\x0e\x62\x48\xf2\x2c\xf0\x20\xf8\x18\xe2\x25\x2c\xcf\x63\xe0\x58\x86\x98\x65\x86\x37\xba\x39\xb6\xb1\x26\xc8\x71\xbc\x85\x60\x62\x04\x0b\x4f\x42\x56\x56\x60\x8c\x26\x99\x15\x89\xd1\x62\x64\x18\x8b\xd5\x60\x02\xbb\xcd\x00\x46\xd6\x60\x20\x3e\x93\x5c\xcb\xd7\x72\x2c\x98\x4d\x02\x16\x39\x2c\x98\x80\x70\x2c\x6b\x20\x7c\xc0\xc4\x78\xec\x2c\xc3\x00\x61\x44\x12\x9b\xc5\x71\xac\x0d\x37\x18\x58\x91\xe3\xdd\x0e\xcc\x63\xc6\x2a\x1a\x6c\xdc\xbd\x17\xf0\x2c\x83\x89\xc9\xc8\x41\xab\x8c\x89\x00\x36\x20\x3c\xcf\xb3\x80\x89\x5d\x10\x82\x1c\x26\x92\x85\x61\x2c\x06\xec\x06\x20\x40\x6a\x08\x60\x86\xc3\x5e\x2b\x26\x2c\xc6\x06\x23\x07\xc4\x24\x3a\x30\x67\x33\x18\x5d\x1c\xcb\x61\x2c\x58\x1c\x84\xad\x35\x98\x2c\x76\xd6\xea\xe3\x1b\x65\xcc\x9a\x79\xcc\x7a\x59\x0e\x88\xc3\x20\xd6\x4b\x2c\xc1\x98\x31\x62\x0e\xc0\x81\x59\x17\x4b\x04\x0c\x04\x83\x91\xc3\x66\x8b\xcc\x03\xc3\x71\x7c\x03\x2f\xc8\x2c\x70\xc4\xc2\x60\xad\xf0\x40\x08\xf0\xad\x9c\x95\x67\x31\xeb\x21\x35\x2c\x31\x10\x9e\x35\x61\xb3\x81\x37\x80\xf6\xcf\xca\x9b\x4c\x20\xda\x19\x27\xc7\x33\x60\xe0\xc1\xc8\xb3\x2c\x6b\xb4\x18\x78\xb6\x9e\xf0\x98\x30\x2e\x6c\x27\x44\x12\x4c\x36\x62\x31\x12\x3b\xb6\xba\xec\xcf\xbe\x74\x0f\x91\x89\xc4\x01\x6f\xb4\x11\x6c\x62\xcc\x1c\xaf\x75\x15\x06\xa7\x95\xb5\x18\xcd\x1c\x8b\x81\x17\x59\x62\x35\x8a\x8c\x80\x09\x87\xb1\x8c\x19\xc2\xcb\xb5\x98\xb1\xd9\xe0\x0c\x03\x25\xf5\x7b\x60\x07\x93\x05\x78\x03\xc7\x19\x64\xec\x02\xcc\xb2\x2e\xb0\x09\x98\xe3\x31\x03\xc4\xe8\x21\xac\x85\xc1\x3c\xc7\x9a\x4c\x18\x80\x05\x8c\x81\xe5\x18\x60\x6c\x1c\x63\x34\x60\xd6\xc8\x70\x46\x99\x70\x22\xcb\xdb\x05\x83\x8d\x31\x38\x39\x2a\x07\xc0\xac\xcb\x5a\xc3\x1a\x8c\x82\x60\x64\x41\xb4\x12\xce\xad\x75\xac\xd5\xc2\x58\x59\x0f\xcb\x81\x09\x3c\x06\x90\x78\xcc\x18\x19\x06\xdc\x16\x33\xd4\x80\xd5\x20\x82\xc5\xca\x60\x96\x37\xf2\x0c\x03\x26\x06\x58\x06\x33\x0e\x86\xad\x61\x8c\x04\x18\xcc\x1b\x2c\x0c\x26\x02\xb6\x7a\x01\x63\x23\x88\x3c\x6b\x33\x32\x84\xe3\x2c\x1c\x11\x0d\x00\xc3\x77\xf1\x00\x36\x8e\x33\x98\xc1\x67\x67\xcc\x3c\x16\x09\x5b\x0b\x81\x28\x03\x96\x76\x42\x9a\x0c\x80\xcd\x46\x8e\x0d\x71\x9c\xcf\x88\x79\x51\xcb\x83\x1d\x2d\x35\x0c\xeb\x64\x08\xc3\x00\xef\xb4\xb9\x30\x57\xeb\x34\x1a\x1a\x39\x5e\xe0\x4c\x18\xdb\x09\xc3\x02\x6e\x60\x64\x03\x08\x92\x99\x70\x12\xc7\xb0\x06\x0f\x26\x75\xd6\x20\x18\x0d\x46\x8e\x97\x18\x83\x87\x18\xb1\x01\x8c\x18\x48\x9d\x81\xb1\x09\x16\x1e\x40\x26\x56\x03\x21\x98\x31\xb4\xd8\x4c\x41\xbb\x0d\x5b\x09\x00\x30\x0c\x60\x42\x8c\x9c\x59\x00\x3b\x5b\x2b\x11\x86\x60\x1e\x13\x56\x34\x35\x31\x04\xdb\xcd\xbc\xc1\x68\x34\x10\x49\x36\x02\x6b\x60\x64\x9b\x91\x63\x58\x33\xb1\x61\x8b\xc9\x60\xe0\x79\x0e\x1b\x6c\x0c\x6b\x00\x33\x83\x05\xb3\x91\xe3\x31\x00\x36\x71\xec\xe4\xcd\x8d\x9f\x20\x04\xf3\xc0\x5b\xb4\xd2\x1a\x08\x87\xb5\x91\x46\xc0\xce\x82\x91\xc5\x1c\xeb\x20\x6c\x0d\xc7\x11\xce\x8c\x8d\x84\xb1\x11\x86\x25\xa6\xb8\x50\x6f\xaf\xb1\xba\x18\xbe\xd6\x40\xad\x23\x9c\x53\x4e\x6e\x3f\xdd\x33\x39\x51\x47\x79\xcf\x64\x2c\x58\xe4\xa6\x92\x19\xf0\x03\xe8\x1a\x13\xc8\x86\xa8\x2f\x0a\x07\xcf\x3a\xdd\xba\x3b\x0a\x9d\xb4\xc2\x9f\xcf\xaf\x0d\xa7\x92\xd1\xd1\x48\x04\x3f\x1e\xbd\x1f\xbf\xee\xee\xf8\xe3\xc7\x74\x63\xa0\x39\x07\xda\x6c\x36\xf5\x17\xff\xc6\x7e\xfc\x26\xa3\xd5\x5e\x90\x85\xfc\x36\xbf\x36\x1c\xbe\xbc\x31\x9d\x8a\xe0\xc7\x37\xdf\x0f\x77\x46\xe7\xdd\xfa\xa8\xce\x54\x0a\xfa\xcd\x0d\xe6\xc7\xc7\x2f\x23\xeb\x17\x39\x50\xa5\x4f\x4e\xdd\x8e\xa3\x16\xb5\xa2\x6e\x84\xc2\xc1\x54\x10\x8a\xbf\x73\xf8\x72\xad\xbe\x66\x90\x46\xfb\xab\x0a\x83\x26\x11\xa6\xf8\xfa\xf8\x43\x21\x41\x52\x98\x7e\x50\x94\xc9\x6c\x91\xed\xe5\x8d\x44\xe0\xcd\xb3\x5d\x68\x7b\x6f\x76\x4a\x61\x6f\x62\x11\xd5\x53\x75\xf1\x25\x98\xbb\x48\xca\xae\xfb\x8a\x8a\xb3\x37\xd9\xeb\x55\x99\xa2\xdb\x4d\x21\x59\x95\xeb\xed\xf6\x16\x16\xb5\x30\x3f\x6b\xae\x53\xe5\xbc\x97\x02\xdb\x21\xd9\x0b\x6f\xc2\x3b\x75\xcd\xd1\x32\x0e\x26\xed\x39\x37\xaa\xa5\xb6\xab\xd3\xda\x20\xe8\x2c\x62\x4e\x85\x9c\x41\xea\x87\xa0\x5a\xb4\x8a\x15\x8c\x54\xc4\x14\x7c\xab\xe0\xb1\x88\x17\xb2\xde\xc8\xc8\x14\x62\xd0\xfb\x68\xe3\x00\x8c\xe8\x2c\x3c\x18\x19\xd8\xc8\x22\x25\x8f\xd4\x80\xce\x4e\x19\xd3\xaa\x36\xa6\x28\x30\xae\x2a\xa0\x0c\x6c\xd4\x41\xc1\x37\x56\xea\x9d\x2e\x42\xc8\x88\x33\x69\x77\x91\xbd\x17\x8d\xf4\x83\x91\xae\x40\x45\xc6\x53\xba\x1e\x8c\xc0\x17\x9d\x18\xe9\x98\x59\x56\x30\x52\x6e\x43\x81\xb4\xa7\x77\x59\xa2\x3e\x08\x5b\x8e\xd4\x35\x47\x8b\x0e\x83\x8e\xa8\x0f\xaa\x0f\x1e\xd1\x1a\xa8\xe0\x0c\xe8\x08\x6c\x51\x1f\x3c\x22\x7b\x2d\x96\xa6\x88\x17\x72\x34\x0d\x6c\x81\x2d\x34\x0d\xe4\xbc\x11\x8a\x00\x46\x7e\x33\x73\x3e\x7f\xb4\x2a\x97\xcc\xea\xb9\xb4\x14\xf4\xdd\x34\x85\xf6\x6e\x56\xd6\xf5\x2a\x11\xc5\x39\xb7\xa3\xd9\xa8\x0b\xcd\x45\xab\xd0\x7a\xca\xcd\xd7\x36\x28\x36\x9d\x93\x90\xe1\x9c\x0e\x28\xe9\xb4\xb3\x89\x38\xf5\x61\x99\x88\xfb\xd9\x22\x97\xae\xe8\xbd\x9a\x42\x47\x50\x75\x25\xaa\x40\x0c\x89\x38\x2e\xa4\xc0\x2b\x1e\xbe\xe4\xd6\x95\x3b\xf7\x72\x83\xd7\x77\xcf\x1b\x60\x19\xe5\xde\x1b\x26\x8f\xdd\x70\x2f\xef\x0c\xa4\x17\x6e\xeb\x35\x0d\x0c\xdf\x7a\xfb\xad\xc3\x03\xa6\xde\x6d\x0b\xd3\x01\x27\x3f\xa9\xe3\xf2\x91\xb5\x05\xed\x58\x12\xdc\xb9\xf2\xd6\x4b\x1e\x5e\xc1\x0e\xcc\xeb\xbe\x7e\x90\xdb\xab\x2b\x3f\x62\x85\xbd\x69\xc5\x32\xb8\xb8\xa5\xd5\x1d\xae\x3b\x9c\x17\xaf\x3f\x7c\xf8\xfa\xd4\xb6\xdd\x5b\x37\xcd\x6b\x6a\x4d\xb5\xb6\xa6\x5a\x9b\xe6\x6d\xda\xba\x7b\x1b\x1b\xa7\xba\x85\x6a\x7d\xc1\x55\x76\xfe\xc4\xb2\x15\x37\xb1\xbb\x0f\xd7\x85\xdd\xad\x2d\x30\x4a\x6f\x16\xed\xd4\x8e\x70\x3b\xd9\x77\x51\x10\xcd\x43\x97\x16\xd0\x52\x42\x0d\xbc\x9f\xa1\xdb\xb6\x18\x89\x96\x81\x5d\xd2\x50\x04\x7e\x29\xc6\x65\x8a\xaa\x41\xc4\x9d\x46\xba\x25\xbe\x3e\xcf\x44\x0b\x18\x00\x05\xe3\x31\x97\xd3\xc1\xbb\x69\x88\x7d\xca\xf7\xb2\xaf\xa9\xc5\x4f\x02\x66\x99\xef\x6c\xb2\xd6\x78\x2d\xf5\x24\xe8\x7b\xa9\xb6\xb9\xc9\x77\xd4\x97\x9f\xeb\x7b\xc9\xd7\x14\xad\x3b\xea\xf3\xbd\x5c\xdb\x5c\x9d\x8a\x1c\x58\x73\x74\xd5\xf5\x37\xac\x7a\x69\xd5\xba\x75\x6b\x6f\xbc\x7e\xf5\xcb\xab\xab\xae\x21\xdb\xe4\x7b\xd9\x17\x20\xf5\x16\x6f\x8d\xb5\xa9\x93\x97\xcd\x01\x52\xdf\xd2\xe4\xfb\x71\xad\xf7\x5e\x1f\x7e\xab\xc9\xf7\x63\x5f\xed\xbd\xbe\x68\x93\xef\xe5\xda\xfa\xe9\x89\xf2\x6f\xbc\xbb\xea\xde\x55\x6b\x7e\xbc\xea\xfa\x9b\xd6\xae\x5b\xb7\xfa\xe5\xd5\xd3\x2f\x0b\x18\x97\x0a\xc5\xf6\x46\xfa\xb8\x40\xa9\x24\xd5\x55\x45\x89\x38\xe3\xd6\xc5\xb0\xbc\x1f\x78\xe5\x8d\x13\x13\xb9\x67\xd4\xf7\xef\xba\x16\x43\xdb\xab\x9f\x06\xe8\x5e\x38\x32\x7a\xac\xf9\x23\x8f\x81\x72\xe2\x0d\xe0\x9f\x39\xf8\x8b\xb4\xcf\xfa\x2a\xb4\x3d\x75\x57\xdf\xb1\xd1\xc1\x7e\xff\x29\x84\xd1\x35\x53\x0a\x27\x50\xfb\xfa\x20\x42\x61\x1d\x6a\x29\xa3\x6b\xf6\x17\x34\x6d\x5a\xb5\x65\x20\x08\xd1\x94\x3d\x64\x77\xb2\x7f\xef\x5c\x30\x3a\xa1\x8c\x2e\xe8\x84\xbf\x67\x8b\xd0\x5a\x11\x6f\x56\x7d\x5b\x7d\x17\xff\x40\x7d\xd7\xa1\xac\xbb\xe0\xc0\x81\x0b\x48\x0d\xdc\x5d\xd0\x49\xdb\x35\x5f\x5d\x05\x4f\xd6\x87\xe1\x6e\x75\x57\x58\x9f\x76\xa0\xa0\x9b\xc9\xa3\x65\x68\x03\x1a\x45\xd7\xa3\x5b\xd1\x9d\x65\xcc\x7f\x16\x28\x7f\x91\xce\x71\x94\x38\x17\x0b\x9f\x3a\xa5\xd9\x13\x54\x31\x97\xea\x68\x36\x50\x1f\x32\x54\x1c\x4d\xa9\x6d\xde\x55\x0f\x85\x4e\x77\xbb\x78\x36\x4d\x61\xb8\xe9\x76\x22\x11\x27\x7d\x14\x32\x88\x17\x29\x46\x10\xb8\x53\xc9\x7e\x88\x52\x14\x77\xe0\xeb\x01\xa2\xe0\xe4\x29\x98\x7f\x3d\x40\x46\x7b\x2b\xd1\x19\x67\x70\x39\x4c\xf8\x08\xeb\x57\x04\x9b\x5d\xcc\x2f\xbb\xd2\xc0\x88\x0c\xbf\x79\xd5\xc1\x7b\x6e\x5f\x7b\xa1\x99\xdf\xbc\xf2\xe0\xbd\xab\xe6\x1b\x85\x1b\x6f\x14\x8c\xf3\x57\xdd\x7b\x70\xe5\x66\x9e\x6d\x6e\x5d\x73\xe8\x9e\x83\xab\x36\xf3\x8c\xc8\x18\xae\xc4\x4f\x8b\x76\x9b\xa0\xf8\x59\xe2\x9b\xd8\x10\x8b\xaf\xd8\xb0\x75\x49\x54\x3f\xc5\x56\xc4\x63\xd1\x25\x5b\x37\xe8\x27\x10\x47\x82\xe2\x72\x2f\x11\x59\xcc\xc0\x4f\x46\xf0\xb8\x92\x47\x63\x46\xcc\x32\x22\xe3\x25\x23\x4a\xfe\x1f\x5f\xc2\x66\xac\x2f\x92\x5e\xf5\x6a\x47\x63\xc8\x96\xe5\x0d\x70\xcb\x00\x03\xb3\x67\x2d\xfd\x58\x6a\xf5\xb2\xd5\x37\x0d\xdd\x95\x5a\x5d\x2f\x18\x17\x2f\x36\x0a\xf5\xab\x53\x77\x0d\x75\x5f\x1e\x5d\xbe\x3a\x79\xd7\xd2\x59\xb3\x81\x19\x80\x5b\x0c\x7c\xd6\x16\x6a\x74\xdc\xd1\x72\x30\xd1\xdd\xa8\x1d\xf2\xdd\x89\x83\x2d\x8d\xf4\x80\xc7\xe6\x98\x1b\x1d\x86\x0e\x2f\xb1\x31\x98\xc0\xef\x03\x38\x9b\x55\x57\xec\x1a\x31\x60\x86\xb1\x31\x5e\x35\x97\x85\xe3\x77\x10\x46\x97\xc3\xe8\xeb\x46\x3d\x6a\x40\x61\x94\x40\x3d\x55\x72\x98\xc2\x0a\x59\xb4\x56\x71\xda\xd3\x09\x1e\x82\x46\x08\xca\xda\x22\x52\x70\xd1\x99\x4c\x97\x2e\xb8\xb1\xa2\x44\x28\x3f\xde\xd4\xd9\xe4\x83\xe3\xbe\x91\x26\x18\x6b\xea\x9c\xdf\xa3\xa8\xaf\x41\x6b\x9e\x1e\x9f\x83\x1e\x95\x22\x13\x60\xd4\x44\x7e\xaa\x07\x99\x12\xa4\x00\x04\x0a\xbe\x27\xe0\xb8\xaf\xa9\xb3\x49\xfd\x7a\xd3\x6b\xea\x6b\xf8\x09\xf5\x35\xf5\x11\xe8\x81\x31\xea\x28\x53\x01\xd4\x34\x32\xf9\x0f\x46\xd1\xaf\x28\x4f\x9b\x99\x3a\xc8\xee\x65\xf7\x52\x14\x68\x47\x11\x55\x43\x47\xee\x28\x28\xe8\x17\xac\x36\x80\x32\x9b\x92\x15\xd7\xce\xaa\xf4\xec\xde\x4f\xef\xbe\x6d\xeb\xe4\xdf\x77\xbd\x7e\xe2\xd3\xd7\xe0\x8b\x4c\xbd\x36\xc1\x94\x7f\x78\xf9\xf6\xd1\x7b\x87\x88\xa1\x7f\x65\x76\x75\x7f\xfe\x9b\xde\x86\xba\x48\x0d\x3c\x60\xea\xb3\x59\x4c\xea\xf6\xfe\xab\x57\xae\xeb\xc5\x0b\xb6\xde\xbf\xfb\xd3\x5b\x89\xe1\x9a\x4f\x9d\xf8\xd5\xae\xfc\xc3\x26\x8b\xad\xd7\x84\x37\x2d\x3d\x36\x7a\xe9\xd0\xe4\xdf\xfb\x57\x67\x57\xf6\xe3\x05\x9e\x48\x5d\xa0\x56\xdd\x6e\xb2\xd8\xfa\x4c\xf0\x40\xef\xba\x95\x57\xf7\xe7\xbf\xb9\x79\x9a\x6e\x5f\x10\xcd\x46\x0b\x74\x1f\x1f\x54\x9f\x8f\xfa\x8f\x29\xdb\xf5\xdb\x13\x45\x96\x57\xb5\x0d\x6a\xb5\xcd\x9d\x5b\xa3\xd2\x14\x82\xf2\x88\x28\x8a\xc3\xa4\xfe\x97\x69\x96\x55\x97\xc8\x29\x4a\x67\x13\xc9\x36\x75\xaa\x4a\x85\x65\xb0\x52\xf2\x4d\x4a\x9b\xdf\xe3\x6b\xa2\xce\x89\x14\x71\xb6\x09\x6a\x4c\x8e\xa2\x61\xff\x04\xd2\x91\x22\x30\xaa\x90\xee\xc8\x93\xf4\x2e\x4b\xbd\x96\xaa\x6f\xf9\x46\xce\x8d\xc3\x57\x29\x5e\x67\x46\xa6\x9b\xad\xe8\xf2\x39\x2a\xd7\xd2\xf1\x8e\xff\x69\x64\xef\xe9\x38\x7f\x67\x0b\x57\xa0\x77\xbf\x39\x53\x90\xae\xf1\x39\x1e\xb1\xd9\x82\x7c\x2d\x8a\x32\x1a\x45\x53\xb4\x60\x93\x8a\x52\xc3\xaa\xb7\xa3\xb3\xc4\x9f\x89\x2a\x4d\xe5\x86\xfa\x1f\xfb\x6e\xa5\xa4\xed\xb4\x32\x43\x64\x65\xf8\x65\x9a\x0d\x8e\xe8\x00\xc3\x63\x25\x20\x65\xf2\x9b\xea\x18\xf8\x6b\x05\xca\xb2\xd6\xac\x56\x6a\x5b\xfa\x77\xe4\x47\x3d\x68\x08\x6d\x40\x97\xa3\xbd\x08\xb1\xf4\x2b\xc8\xe8\x5f\x07\x1f\xed\xc3\x99\x54\x03\x17\xa2\x8e\xac\x78\x3f\xc8\xce\x20\x65\xba\xea\xf2\x92\x68\x1f\x15\x0e\x3b\x44\xcc\x27\x52\x67\x02\x91\x07\x53\x89\xa4\x46\x6d\x72\x7c\x34\x93\xb0\x9f\xb3\x11\xf6\x5d\xb1\x62\x74\xa0\x6b\x76\x57\x5d\xeb\xa5\x5e\xc3\xec\x46\xd9\x36\xd7\x36\x0a\x4b\x37\x25\x7a\xb0\x7a\x8c\xeb\x18\x18\xe8\xa8\xab\x89\x85\xd6\x78\x36\xcd\x59\xbc\x75\xfe\xca\x05\x70\x80\xfd\x83\xde\x0e\x92\xa8\x37\x94\xfa\xa5\xcb\x00\x1b\x5a\x16\xdd\x3e\xca\xbe\x5d\x79\xa7\xb2\xb5\x56\x0f\x6f\x18\x58\xd7\x5e\xe7\xcb\x1a\x3a\x4d\xf3\x9a\x25\xc0\xa9\xe3\xeb\xae\xb1\x2c\xc1\xd9\x13\x8d\x52\x62\x75\xb2\xb5\xcd\x5d\x53\x3b\xa7\x3b\xd1\xb5\x6a\x51\x7c\x55\x2c\x53\xd3\xa3\xfe\x9b\xde\x66\xa2\x24\x93\xeb\xb6\x6c\x69\x7e\xa8\xd9\x62\x0f\x0f\x1d\x50\x2f\x57\xf7\x95\x6e\x54\xb5\x2b\xa9\xb0\x7f\x4a\xa1\x6d\x74\x2e\x9d\xa6\xdc\x18\xd6\x8d\x63\xd2\x3a\x28\xac\xee\x40\xa2\x03\x0a\x0b\x5b\x49\x38\x40\x82\x05\xb4\xdc\xa2\x34\x4e\x37\x68\xd1\xe8\xe6\x54\x46\xd7\x56\x72\x17\xb0\xde\x52\xc9\x68\x84\xa3\x86\xca\xef\x53\x2d\x46\xf8\xae\xcf\x3d\xeb\xd6\x8f\x02\x13\xdf\x3d\x70\x95\xc9\x2c\xb2\x96\xd5\x62\x3c\xb5\xee\xc6\xab\xe7\xcf\x1b\x18\x78\x6d\xc1\x8e\x39\xe1\xb7\xe1\x93\x7c\xb3\x7b\x56\xf8\xbc\xe1\xc5\xc3\x37\x5d\xbd\xe2\xce\x2e\xab\x41\xdb\x37\x6e\xb7\xfa\xad\x6c\xa8\xbd\xb5\xaf\x7b\x71\x76\x70\x69\x7b\xc7\x8a\x06\xac\x94\x7d\xef\x65\x43\xed\x9b\x2f\xfc\x8a\x72\x40\xb6\x34\x46\x86\x6f\xea\x91\x6a\x09\x87\xef\xeb\x5c\xdf\x3d\x67\xdd\xe2\x79\xf3\xfa\x1c\x31\x9f\x67\x0a\x45\x53\x57\x6d\xeb\x9c\x15\x8a\xcd\x92\x9c\xee\x26\x9b\xc5\x20\x0a\x97\xcf\xf2\x47\xc2\x6d\xb8\x61\x49\xc4\xd0\x15\x6e\x74\xba\x6a\xbd\x3d\xbd\xf3\x57\x2f\xae\xab\xe0\x8b\x6e\x41\xd7\x20\x24\x47\x3a\x74\x20\x5c\x5a\xa7\x78\x86\x77\x3b\x39\xbd\x41\x5c\x4e\xb7\x5c\x51\x5b\xbd\xc6\x31\xbd\xc9\xac\x10\xcd\x24\xdc\xae\x8c\xbb\xd4\x58\x5a\x7a\x97\xec\x2a\xb7\x9c\x2e\xc3\x4a\xd9\x93\xd1\x48\x35\xae\xe1\xac\xb0\x81\x08\xb5\x3d\xc9\x83\x0d\x6b\x57\x5e\xeb\xef\xf4\x03\xee\xc9\xf6\xc8\x02\x80\xc8\xb5\x87\x7a\xd7\x5d\xb0\xe3\xfc\xce\xd6\x59\xf6\x46\xbb\x93\xb7\x72\x0c\x2b\x37\xb4\x6e\x15\xf1\xea\x17\x87\xae\x97\x38\xa6\x3d\xba\x98\xb3\x12\x83\xc8\x39\xad\xde\xc8\x92\xc1\xcb\xae\xb8\xf7\xd1\xdd\x7b\x7a\x7a\x5d\x36\x7b\x0d\xbb\x56\x12\xcb\x6e\xd4\xd9\x20\xc6\xeb\x80\xe1\x09\x03\x58\xcc\x1a\x8d\x35\xe2\x75\x42\x94\xfb\x9d\xfa\xd6\xde\x65\xdd\xc1\x0e\x9f\x14\x6c\xf4\x75\xce\x59\xfc\xa9\xe5\x9b\x8f\xae\xed\x9e\xe7\x0c\x01\x26\x6b\x4d\x44\xc0\x11\x81\xf7\x58\xc0\xcc\x59\xbd\x7c\x93\x59\x56\x6f\xfb\xee\x15\x43\xb1\xb9\x73\xba\x02\xc1\x58\xc7\xe0\xd0\x9e\xe1\x07\x61\xe9\xc9\x9a\xc6\xd3\x37\x17\xfb\x46\x42\xc8\x54\xd2\xe1\xa8\xf6\x29\x70\x37\x3a\xa1\x23\x46\x54\xd6\xdd\x5e\x75\x5d\xdd\x36\xff\xa7\xaf\xab\xdf\x57\xed\x23\x14\xa3\x22\x7e\x1f\xd5\x88\xae\x08\x4f\xbf\xa3\xa2\xb3\xdf\xfb\xf0\x29\x2b\xc3\xda\x76\x97\xea\x22\xb0\xd9\x81\x8d\x65\x4c\x43\xb8\xab\x14\x54\xcb\x41\x22\xce\x14\x7b\xce\x04\x15\x0f\x83\x65\x95\x1e\x46\xb5\x79\xb8\x76\xea\x93\x05\x3c\x0a\x99\xda\x4b\xb6\xa2\x04\x42\x46\x88\x42\x23\xd5\xf7\xee\x28\xe1\x98\x86\xdd\xda\x4c\xd1\x0f\x70\x96\x33\xf3\x39\x08\x5f\xa6\xfe\x02\xb7\x48\xa7\x4f\x4b\x69\xe9\x79\x49\x62\x39\xed\x7c\xfa\x85\xcd\x9b\xfd\xfe\xcd\x9b\xfd\xb0\xf7\xb9\xe7\x7a\x7a\x9e\x7b\xae\x87\xfc\xaa\x10\x93\xff\x74\x21\x40\xbe\x49\xf3\xbe\x96\xd6\xf2\x4a\xcf\x4b\x69\x2d\xaf\xf4\xfc\x3d\xf4\xa6\x7f\xb3\x3a\x49\xf3\xf5\x3c\x97\xdf\x58\x88\xc1\xfe\x42\x80\xf2\x1e\xb2\x25\xfa\xdf\x86\x3c\x68\x69\x85\x84\x3d\x68\xd7\xb7\x78\x25\xb3\x1c\xbb\x43\x64\x22\x21\x5d\x21\x82\x1e\x43\x0d\x9c\xbe\xf1\xb3\x27\x23\x7d\xa4\x1f\xfa\x80\xc2\x63\x24\xca\xc6\xde\xea\x8f\x40\xf9\xb4\x60\xfc\xae\x91\xd5\x55\xfb\x61\xc8\x20\x8b\x41\x4b\x94\x68\x9b\x52\x6d\x27\x9b\x25\x51\x4b\x50\x94\x0d\x11\x2f\x00\x63\x94\x85\xe7\xe5\xfe\xda\xb1\x88\x97\x41\xde\x88\x6e\x0b\x80\x15\x40\xc6\xef\x1a\x85\xfc\xbf\xd0\x4b\x26\x37\x89\xac\x6e\xd1\x48\x00\x46\x8f\x1d\x1b\xd5\x7e\x00\xc4\x28\xba\xad\xde\x08\x64\x0d\x69\x57\x47\x6d\x83\xf0\xbc\xec\xcd\xe9\x00\x02\x65\x1a\x66\x49\x09\x87\x41\x9b\x88\xb4\xad\x7d\x1f\xa4\x28\xf8\xa6\x48\x9c\x0e\x97\x5b\x17\x42\x14\xbc\x60\xea\x24\x65\x24\x53\xd0\x2f\xd0\x26\x77\xc2\xb9\x23\x38\x95\x94\x1a\x03\x0c\x87\x5e\x52\x4f\x9c\xba\xea\xb2\x6e\xd9\xd8\xee\x18\xed\xbd\xe1\x5b\x3b\xf6\xfc\xfa\xae\x4b\xbf\x7a\x60\x7d\xeb\xf0\x52\xbf\x01\x5b\x30\x67\x4f\x9c\x7a\xfc\xfe\xc7\x0f\x5d\xd6\xbb\x44\x34\x84\xdd\xe9\x78\xdf\xda\x9a\x2d\x76\xe6\x25\xb5\x88\x1e\xba\x82\xf2\x69\x03\x17\x2d\x6a\xf8\x52\xb4\xeb\xd0\xbb\xc7\xae\xfe\xc1\xfe\x39\x23\xfb\x6e\x9d\xb7\xe3\xd3\x01\x4b\x80\x9f\xc5\xb9\x1d\xbd\x17\xde\xff\xb3\x47\x6e\xf9\xfc\x9f\xce\xef\x0d\xed\xbe\xa0\x3e\x3e\x70\xf5\x9a\xc5\xb3\xd5\x8d\x0b\x2f\x5b\x0f\x7b\x7f\x7f\x4a\x97\x02\x95\xeb\x36\x54\x41\xf7\x17\x6b\x27\xe9\xce\xc1\x0a\x95\xa3\x93\xef\x07\x56\x2e\x34\xcd\x7e\x38\xdf\xba\xc6\x6d\x6c\x73\x5e\xda\xf3\x95\xdf\x2d\xbc\xe9\xab\xa3\x3b\xbe\xb2\xef\xc2\xd6\xe5\x4b\x05\x27\x63\x62\x39\x7b\xfc\xc7\x8f\xde\xf7\xe8\x6d\xa3\x3d\x5a\xe5\x5c\xa9\xd9\xbd\x6b\x3c\x9b\x3d\xf6\xaf\x55\xda\x18\xdf\xb8\xae\xe1\x8b\xd1\x4e\x88\xfe\x7a\xf5\x83\x37\x2c\xee\x1a\xb9\xe9\xa3\x03\xdb\x3f\x15\x60\x4d\x62\x9b\xdd\x2d\xf7\xad\x3b\xf6\xda\xc3\x1f\x79\xec\xed\xf3\x7b\x1a\x76\x9f\x5f\x3f\x7b\xee\xae\x55\xe7\xcd\x56\x37\x6f\x7d\xa0\x64\x88\x5c\x96\x6d\xd5\x52\x7a\x0d\x41\x32\x1a\x74\x26\xc4\x02\x9c\x40\xdc\x9d\xd1\x4a\x6d\xd3\x08\x9d\x70\x22\x15\x4a\x85\x9c\x21\x67\xc2\x99\xa8\xa6\x50\xc9\x7d\x9c\x7a\xec\x67\xa4\x76\xd6\x9a\xf4\x96\x3b\xef\xdc\xb2\xa1\x77\xc7\xe5\xf7\x8d\x8d\x8f\x8f\x7d\xf6\x05\xb8\xe0\x8a\x2b\xae\xbc\xf2\xca\x2b\x41\xaa\xa4\x61\xf1\x1e\x6f\xe4\xa0\x27\x99\x0e\xdd\xf5\x83\xbb\xba\xb7\x6d\x7d\x43\xfd\xce\x1b\xaf\xec\xd1\x92\x5d\x89\x3f\x3a\x8d\xba\xd5\xd6\xbf\xcf\x18\x11\x7b\x51\x01\x0b\xd8\x81\x2b\x9c\x62\x07\xdc\x3c\x55\xe5\x76\xd0\x11\x46\x32\xc1\x54\xd0\x15\x76\x6a\x64\x58\x28\x95\x48\x25\x9c\xec\x83\xff\xa2\x7e\xeb\xe5\xfb\xd4\x77\x9f\xbb\xf6\xda\xe7\xc0\x76\x1f\xf8\x5f\xfc\xfe\xee\x2f\xde\x74\xea\xc6\x1b\x4f\xdd\xb4\xea\xf0\x85\xf3\xea\x39\x75\x04\xff\xab\x85\x6c\x39\xf5\xca\xa9\x53\xaf\xe0\xab\x5e\x56\xbf\xf9\x35\x2d\x21\xb4\x80\xed\xb9\x6b\x73\xdf\xde\xb5\xf7\xb5\xc9\xd7\xf6\xc6\x16\xac\x5b\x16\x9a\xec\xef\xd7\xd2\x9c\x3a\x55\xe2\x21\x2a\x2c\x42\x16\xe4\x43\x6d\x74\x27\x48\x5d\x97\xf2\xee\x74\x26\x61\x0f\x35\x3a\x44\xdc\x10\xc3\xc9\x3e\x1c\xf7\x03\xd8\xf5\x2f\x38\x64\x8f\xbb\x9c\xc1\xe4\x19\x33\x3a\x41\xa0\x28\x57\x7f\x7c\x69\x8b\x80\x15\x8c\x5a\x96\xee\x3f\xb6\x7f\x69\x8b\x7e\xc2\x2d\xa3\xc7\x26\x14\xed\xbb\x63\x94\x63\x7f\x88\x78\xdf\xa7\x1c\x07\x1e\x79\x23\xa0\x8c\x40\xee\xd0\x70\xd8\xa1\x8e\xbf\x79\xe7\x91\xbd\xcb\x96\xed\x3d\xa2\x9f\xd4\x16\x8c\xb4\x0c\x2a\x3d\x92\x6c\xd9\x5f\x50\xa4\x80\x35\xc0\x20\xa2\x20\xa1\x68\x25\x43\xf1\x0c\x12\xc1\x38\x83\x64\x35\x2b\x27\xb5\x03\x75\x96\x44\x2e\xa4\x61\x19\x72\x72\xb2\x88\xf3\x00\x88\x41\x24\xab\xe7\xd5\x7d\x7d\xeb\x4a\xfe\x0c\xd2\xbd\x2c\xd1\xc4\x32\xe4\x80\xea\x4a\xc8\xba\x42\xbe\x9e\x37\x8b\x14\xac\x30\xf4\xbd\x05\xcf\xba\x05\x68\x03\x6d\x67\x5f\x7e\x11\x93\xad\x7c\x8e\x5c\xf4\xa7\xac\xe0\x2c\x53\x51\x66\x1d\x48\xd0\x0d\x38\x4b\xcb\xac\xbf\x0b\x3f\x50\x2e\x7c\xa4\xf0\xde\xe9\xb6\x35\x75\x08\x25\x82\x54\x37\x32\x6c\x0f\xda\x67\x58\x5b\xc7\xf0\x48\x5e\x91\xd9\x2b\xf2\x0a\x1e\xd1\x5d\x67\x97\xd6\x3b\x46\x99\x18\x13\xe4\x00\x33\x32\xa1\xc8\xcc\x8b\x95\x7e\x48\xb4\xf1\x99\x63\x74\xec\xb9\xda\xea\x56\x95\xaa\xda\x69\x7a\x1b\x47\xaa\x9a\xed\xe7\x15\x2d\x31\x43\x1b\xd2\xf7\x60\x74\xee\xbe\x9b\xf6\xa0\x42\x5e\x82\x0a\x65\x3c\x47\xdf\x91\xea\xf7\x96\xed\x89\xbd\x68\x4e\xe5\xce\xd4\xe5\x66\xdc\x7e\xdc\x8d\xa9\xec\x3b\x9c\x96\x1d\x1c\x8f\x78\x91\x69\xc5\xd4\xb0\xa0\x91\x4a\x71\x0b\x6e\xa2\x74\x46\x79\x5b\x17\x8c\xde\xd6\xb5\xe8\xba\x04\x40\xe2\xba\x45\x5d\x9f\x87\xf3\xba\x5a\x37\x2f\x56\x6f\xdf\x60\x9a\xdb\xda\x9b\x76\x03\xb8\xd3\xbd\xad\x73\x4d\xeb\xd5\xcf\x37\xf4\x5d\xb9\x6a\x29\x9b\x9b\xbb\x89\xcc\x99\x7c\x93\x6a\xe1\x7b\x67\x47\xfe\xb6\xa5\xa5\x63\xf6\xec\x8e\x96\x9b\x7e\x15\x85\xb5\xcb\x8f\x24\xd4\x89\x2c\xdf\x51\xd7\x28\x49\x8d\x75\x1d\x7c\xf6\x1d\x4f\xcb\xd1\xfe\x65\x3b\x36\xd2\x3e\x7f\x8a\x43\xec\xe5\xd4\xee\xaf\xb5\x80\x6f\xe1\xd2\x55\x75\x93\xe9\xb8\x8b\x72\xf4\x75\x17\xf5\x4e\x7b\x50\xb2\x75\x40\xd0\x19\xa2\x26\x96\x70\x91\xfa\x55\xd8\x04\x97\xac\xc6\x2b\xb7\x5e\xf2\xb9\xad\xcc\xdd\xea\xd7\x56\xac\xed\x5f\xe3\x34\xab\x5f\xc3\x00\xb0\x18\x3b\x5a\x16\x5d\xd2\xff\xc4\xcb\xe4\xee\xc9\x20\xf9\x4f\x88\x2f\xde\xbc\x79\xf1\x92\x8b\x2f\x9e\xfc\x65\xfe\x07\x58\xba\x74\xcf\x82\x84\x3f\x91\xff\x09\xdc\x0d\xef\xce\x9a\x75\x24\x30\xab\xb3\xfe\x37\xd3\xf1\xf5\x93\x74\x4d\xa4\x3e\xfd\xa3\x91\x74\x3f\xa4\x13\x2e\x37\x9d\xb7\x30\x5d\x3b\x38\xbe\x8a\xcd\x4f\x9d\xfe\xbb\x38\x74\xe3\x4b\xea\x6f\x3f\xf5\x05\xf5\x87\x57\xf0\x60\x38\x64\xb2\xda\xf8\xc5\xaf\xee\x29\x7a\xfe\xdf\xfc\xaf\x0b\x0f\x55\x70\xe6\x6f\xbe\x0c\xe4\xa3\x9f\x02\xdf\x4b\xc4\xa7\xfe\x40\xfd\xed\x4b\x37\xde\x73\xd0\x54\x63\xb8\xc3\x88\x4d\x9b\x76\x14\x1c\xff\x2f\x1a\xb8\xa3\x82\x73\xff\x91\x6d\x57\xdd\xf8\x12\x02\xd4\x34\xe5\xe4\xfe\xc8\xfe\x14\xed\x42\x28\x38\x0d\xb4\x96\xe7\x1a\xa2\x7e\xce\xe9\xe0\x45\xb6\x10\xd7\xc7\x50\x73\x68\xd6\x5d\x18\x42\x31\x2e\x95\xcc\xf4\xb1\x05\xde\x91\xc8\x50\xd3\x12\x36\xea\x72\x58\xa1\x88\x05\xfb\xc7\xf0\x65\xd4\xef\xee\x7d\x91\xd6\x29\xb4\x5f\x6c\x12\xb1\x93\xb1\x31\x06\xe2\x23\xb5\x66\xaf\xe4\x15\x9a\x7c\xea\x0e\x9f\xd1\xe8\x32\xfb\x89\x3f\x62\xb2\xd9\x4d\x76\xce\x81\x45\x11\x36\xcc\x94\x14\x8e\xcf\x90\x74\x3f\xa0\xd6\x54\x32\x0a\x97\x85\x53\xe1\xcb\xc3\x61\xb8\xbc\x31\x9d\x6a\x05\xb4\x5f\x14\xb1\x83\xb3\x9b\xec\x36\x53\xc4\x4f\xfc\x66\x97\xd1\x48\x39\x65\x82\x57\xf2\x9a\x6b\x89\x8f\x18\x18\x1b\xe3\xc4\x62\x93\xf6\xae\x33\x93\xaa\x3b\x66\x4a\xba\x7f\x0a\xb5\x86\xd5\xfb\xa2\x65\x0c\x0f\x5d\x9f\x38\x88\x9a\xa9\x64\x63\xb0\x6c\x5b\x5d\x22\xe6\xe4\x74\x0c\x38\x9e\x88\x54\xdf\x23\x9d\x49\x47\x1a\xab\x52\x14\x35\xe2\xc0\xc6\xeb\x72\x1f\x7b\xd1\xf3\x3b\x28\xd4\x0b\x32\x98\xf5\xd3\xdf\xb7\x71\xb5\xf1\x18\xbf\xad\x67\xa3\xcd\x31\xfc\xc0\x1d\x0e\x5b\x1b\xde\x4c\xef\xe4\x5f\xa0\x27\x5c\x48\x77\xf8\x63\x72\xe8\xf4\xad\x21\xf9\x63\x77\xbd\x0b\x43\x70\x39\x0c\xbd\x7b\x17\xd0\x3b\x83\xb8\xe0\x1e\xf9\x04\xec\xf7\xb6\x8b\xb5\x5e\xf5\x66\x76\x69\xcf\xd2\x3b\x9a\x86\x97\xf6\x5c\x2d\xea\x29\x5e\xa0\xa7\xdd\x7a\xba\x9c\x3a\xf1\xab\xba\xba\x5f\x02\xf7\x55\xed\x21\x77\xbd\xab\xfe\x6b\x09\xbb\x91\xd6\xdd\xa5\xad\x7f\x28\xc0\x68\x7b\xca\x7a\xe0\x39\x3e\xad\xa3\xd1\x37\xa6\x6d\x11\xa6\x0c\xc6\x15\x6a\xa8\x46\xe3\xa2\x20\xd1\x43\xea\x0e\xf5\xc1\x53\x77\xdf\x7c\x7e\xad\x27\x76\xfc\xa6\xd6\xae\x05\xbd\x3f\x82\x2d\xa7\x4e\xc1\x8a\x0a\x8c\x2e\xd6\xea\x39\x03\xa4\xeb\x5d\xf8\x14\xbc\x05\x9f\x62\x94\xc3\x6f\x1f\xda\xf9\xc2\x92\xf8\xc8\xfa\x15\xfd\x97\x47\x38\xc3\xe1\xb7\x41\x7a\xfb\xfb\x65\xe0\x2e\xa7\x7d\x06\xdc\xae\x7f\x81\xe8\x13\x4f\x94\x79\x10\x08\x39\xd0\x1c\xb4\xb5\xb2\x16\xa5\x3a\x24\x23\x5a\x2f\x7c\x00\x8a\x02\x7c\x30\x7e\x82\xd3\xc1\x91\x0b\xd4\x97\xd4\xbf\x3d\x38\x3a\x72\x71\xa8\xc1\xd7\x96\x5a\x36\xf8\x09\x30\x3d\xf8\x60\xfe\xd3\xb0\x1f\x16\x9c\x3c\x07\xba\x02\x3b\xe7\x43\xa1\x2a\xdc\xc5\x28\x3b\x9e\xde\xbe\xf2\x78\x67\xe7\x6a\x87\x5c\x6f\x12\x77\x3c\xfd\xa3\xa7\xdf\x3a\xf4\xf6\x39\xa0\x16\x26\xfe\x71\x6e\x94\x85\x9b\xae\x3f\x85\x00\xc1\x14\x22\x7b\x59\x85\x62\x3f\xbb\xf8\x82\x79\x53\x46\x66\x75\xe1\x44\x41\x19\xde\xe9\xe0\x49\x38\x9d\x88\x93\xdd\x92\x39\xff\x5b\xa1\x8e\x31\xd9\xed\xcc\xf7\xd4\x51\xc6\x20\x09\x12\xfb\xbf\x18\x8f\x0d\xce\x93\xbd\xec\x13\x70\xa7\x81\x91\xc9\x0f\x1d\x9e\x89\x9b\x6a\x30\xeb\xb3\x91\xa6\x6d\x60\xb6\x7a\x48\x97\x28\xd5\xd8\x0d\x26\x75\xf6\x66\x5c\xe9\xfb\x63\xcd\x74\x7e\x68\x37\xa4\x82\xce\x44\xb5\x73\xe4\x19\xe3\xa8\xe0\x36\x34\xdd\x79\x46\x2b\x38\x83\x05\x14\x41\x1e\x75\x36\xe9\x26\x85\x23\x2a\xa2\x1c\xd9\x19\xaf\x86\x92\x58\xbf\xa6\x86\x87\x4d\x23\x18\x25\x87\x46\x9a\x3a\x2b\xcd\x11\x73\xb9\x62\xea\x19\xae\x92\x43\xb9\x62\x5e\x2d\x36\x37\x94\xcc\x75\x96\x69\x93\x1c\x92\xd1\x72\x74\x41\x81\x2e\x2a\x2a\xbc\xbb\xe2\xe9\x94\x3d\x1d\xd7\xb9\x8c\xda\xb6\x89\x2b\x8a\x82\x62\x10\x8d\x41\xd5\x25\x5d\xcc\x74\x5c\x82\x34\xd2\x56\x0d\x3f\xb8\x5d\xe0\x8c\x34\xf0\xf4\x71\x44\x39\xfe\xf2\xf1\x48\x32\xb2\x6c\xeb\xb2\x60\x1f\x09\xca\x82\xd9\x32\x7b\xdd\x9c\xf9\xd7\xb7\xf2\x4e\xc6\x6c\x97\xcc\x8c\x93\x6f\xdd\x73\xfb\x1e\x7a\x29\xd9\xe9\xe5\xf5\xf3\xe7\xac\x9b\x6d\x31\x0b\x32\xb4\xa3\x29\x58\xf3\xad\x3b\x41\x18\xff\x6c\x10\xf2\xa8\xa5\xad\x25\x92\x8c\xe0\xe7\xf2\x27\x77\x1c\x3f\xbe\x43\x23\x61\xe2\xcb\x96\xc5\xf1\x7c\x73\x44\x90\x4d\xb1\xd8\x92\x1e\x53\x23\x67\xb7\x73\x8d\xa6\x9e\x25\x95\xe1\x58\xcc\x24\x0b\x2c\xfe\x1a\xd8\x6f\x1f\x3e\xfa\x9b\x3b\x30\x7e\x65\x33\xc6\x9b\x35\xa2\x94\x29\xc9\x55\x0c\xc8\x83\x6a\xb5\x1d\x08\x1b\xd4\x65\x29\xc1\x33\x98\x25\xc1\x92\x0d\x77\xef\x74\xa7\x28\x94\x7b\x4f\x10\xa1\x32\x0e\x55\x01\x24\x0b\x79\xca\xcd\xc4\x39\x41\x06\x04\xad\xea\x6b\x18\x95\x85\x2d\x9d\x4d\x4c\xb6\xa9\xd3\x69\xd5\xd6\x02\x05\x2b\x9d\x4d\x30\x06\x81\x12\x56\x6c\xfe\x0a\x68\x55\xd7\xe4\x69\x9f\x8f\xe9\x6c\xfa\xce\x26\xf5\xeb\x82\x55\xdd\x41\x59\xf5\x7a\xdf\x51\x5f\x30\x36\xd4\x84\x36\x50\xd9\x24\x35\x2b\x2f\xec\x99\xfc\xe0\x2e\x58\x35\x38\x74\x4f\xd9\x89\x34\xdd\xef\x66\x1c\xbc\x88\xcb\x68\x23\xda\xce\x90\x1a\x6c\xd1\x9e\x2b\xfe\x62\x58\x07\xee\x8d\xfb\x31\x1e\x97\xbd\xf2\xe5\x49\xad\x5c\xf1\x2d\x83\x63\x0b\xae\xba\xed\x8e\xdb\xae\x5a\x30\xdf\xd4\x6c\x52\x84\xdf\x0a\x8a\xa9\xd9\x34\x5f\xb9\xa4\xbd\xbb\x87\xe9\xa8\xa9\x69\x17\xfa\x63\x8e\xe1\x8d\xc3\x8e\x58\xbf\xd0\x5e\x53\xd3\xc1\xf4\x74\xb7\x5f\x72\xc1\x3d\x5f\xfb\xd6\xd7\xee\xb9\x80\x50\xce\x6b\x2c\x2e\x7b\xe5\xc0\x50\xf2\xbc\xbd\xcb\xdb\xdb\x97\xef\x3d\x6f\xdb\x72\x73\x9b\xf9\x13\xf7\xdc\xf3\x09\x73\x9b\x79\xf9\xb6\x4f\xee\x9a\x3d\x74\x4d\xdc\x97\x0e\xd7\xd6\x86\x93\x75\x6e\x4f\x2c\xde\x96\x4c\xb6\xc5\x63\x1e\x77\x5d\x52\x8b\x4b\xfb\xe2\xd7\x0c\xcd\xde\xf5\xc9\x2d\x4f\xec\x9a\x3b\x77\xd7\x13\x74\xfe\xd7\xb1\x67\xbd\xd4\x06\x85\xb2\xa9\xcb\xb2\x21\xdd\x8f\x24\x55\x97\xb0\x55\xe0\x52\x46\xca\x86\xea\x3a\x9c\x99\x70\x7a\x4c\x16\x2c\x16\xf5\xdf\x8c\x46\xc8\x52\x57\x91\x23\x82\x5c\x40\x99\x3c\x3d\x46\x51\x7e\x47\x74\x14\x49\x18\xc9\x09\x72\x4e\x90\x4d\x90\x35\x0a\xa2\x96\x5a\x16\x72\x32\x0e\x16\xc1\x22\x29\x6b\xb9\x04\x09\x59\xc4\x08\xa4\xbe\x89\x52\xd4\x06\xb8\xb5\x2c\x01\x2a\xca\xb2\xe2\x19\x48\xb3\x1f\x20\x57\x66\x91\x24\x8e\xd3\x07\x8f\x0b\xb2\x11\x46\x8c\x3e\x23\x6c\x32\xe1\xa2\xb4\xf9\xce\xeb\x30\xb4\xbd\xfa\x29\x20\xdd\x8b\x36\x8d\x1e\x6b\xbe\xf9\x51\x3c\x22\x4a\x30\x42\xe5\x3c\x63\xd4\x03\xe6\x98\xd1\x08\x9b\x2c\xaf\x52\x19\xf4\xcd\xaf\x67\xfc\xc2\xab\xd0\xf6\x2f\x47\xfa\x8e\x8d\x0e\xf5\xd5\x9f\x3a\xb3\x8c\x51\xaa\xb8\xac\xe3\x53\x94\xf4\x70\x13\x05\x44\x88\xb3\x96\x51\x7b\x8d\xcf\xa8\x3e\x64\xaa\x28\xec\x07\x94\x71\x4c\xd4\x6a\x62\x54\x1f\xb2\x58\x44\x49\xa5\x6d\x0c\x23\xb2\xfa\xce\x59\x0a\x89\x2a\x7d\xa4\xf3\x68\x1d\x1a\x29\x4b\x74\xd8\x92\xae\x06\xc9\x70\x75\x40\x41\x0a\x74\x50\x82\x54\x32\xe3\x0a\x64\x5c\x75\x14\x7c\xb7\x88\x66\x16\xa5\xd3\xd1\xb4\xeb\x48\x34\x99\x8e\xe1\xa8\x9f\x29\x29\x76\xe8\xa2\x5e\x26\xa2\xab\x6d\x98\xc3\x73\x76\xcc\x77\xcd\x59\xb8\x73\x6c\xe7\xa2\xae\x9a\x83\xb0\xf0\x60\xcd\xe8\xb1\x40\xe7\x70\x67\x60\x68\xc7\x10\x3d\x2f\xe8\x06\x60\x4c\x86\xf9\x3b\xe6\x84\xcd\x6a\xae\xa0\xc6\xf1\x73\x2a\xc2\xde\x77\xc3\x1d\x77\xdc\x30\x7f\xff\xb1\x6b\xd6\x5b\x93\xf3\x5f\x70\x6c\xed\x1d\xde\xb9\x73\xb8\x77\xab\xe3\x85\xbe\xfa\x1d\x3b\xea\xfb\xb2\xc7\x46\x2f\xa8\x6b\xd1\x3e\xee\x96\xba\x0b\x92\x43\x43\xc9\xf2\xd5\xfc\x3d\x0d\xa6\xb9\xf5\xc9\x16\xd9\xba\xfe\x9a\x63\xfb\xc9\x4f\x0b\x0a\x1d\x25\xdb\x72\xbd\x2d\x96\x96\x29\xbd\x8c\x83\xe3\xed\x0e\x26\xd0\xd8\x0b\xba\xdd\x6f\x22\xee\xa6\x62\x1f\xfa\x45\xd8\x1d\xae\x40\x5a\xd7\xc5\xa7\x3c\x21\xbd\xf7\xec\x0e\x8e\x77\xea\x77\x28\x25\x11\x2f\x99\x2d\x2c\xea\xd2\xe1\xa3\x1f\x79\x3d\xe2\xe5\x4c\xf6\x9e\x50\x6a\x70\x30\x15\xac\x3f\x09\x86\x93\xf5\x41\x2d\x1c\xea\xb1\x9b\x38\x6f\xe4\xf5\x47\xb4\xa8\xae\x45\x3b\xc7\x76\x12\x5d\xe9\x20\xdb\xb7\xd9\xa9\xee\x3e\xf1\xc6\x1b\x27\x0e\x3a\x7e\x7a\x84\x42\x6a\xf8\x1b\x07\x47\x07\x25\xf5\x4a\xca\xbd\xbb\x57\x1a\x1c\x1d\x6c\xf4\xe3\x88\x57\x45\x47\x7e\xea\x38\x48\x23\x0f\x3b\x37\xf7\x0d\xef\xdc\x59\xf0\xf5\xa9\xcb\x55\xb5\xdd\x6c\x58\xd7\x8d\x62\xcb\xf0\xe8\xf6\xa0\x3d\x51\x52\x85\x2a\x60\xa8\x27\x8a\x1a\x51\xea\x18\x45\x75\x64\xc6\x26\x91\xa2\xab\x40\x61\x74\x70\x43\x36\xbb\xe1\x20\xa3\x28\xca\x04\x3a\xb8\x81\x64\x37\x1c\x9c\x40\x2c\xd2\x35\x9f\xc6\x27\x73\x1b\x0e\xb2\xe8\x20\xc2\x15\x36\x62\x89\x2a\x0b\xb1\x0f\x6f\x15\x46\xb2\x1f\xd2\x10\xec\x43\x19\x7e\xe9\xb4\x61\xb6\x40\xdb\x37\xd0\x9e\xa6\x95\x85\xa0\x3e\xe8\x91\x4d\xa3\x25\xa6\x71\x10\x38\x65\xe7\x70\x36\x3b\xfc\xfe\xbb\x3c\x3a\x36\x3a\x81\x46\x8f\xf1\xd9\x37\x4e\x64\x0f\x6e\xc8\x67\x37\x1c\x8c\x78\x19\xe5\x04\x99\x35\xb6\x53\x55\xf2\xb9\xd1\x63\xc7\x18\xa3\xfa\x9d\x37\x02\x5a\x7b\xe1\x71\x6f\xa4\x12\x0b\xbd\x1d\x0d\xe8\xd4\x00\x5f\xb2\x30\xd5\x87\x14\x1d\x32\x2e\x1d\x7b\x65\x7a\x98\x2d\xa5\x0c\x55\xfa\x5d\x5d\xd4\x45\x81\xff\xbb\x16\x55\xc2\x28\x44\x92\x11\x82\x68\xfc\xb8\x20\x9f\x3c\x08\xc8\x1b\x61\x73\x79\xa5\x77\xab\x63\xf2\x3d\xed\x23\x20\x66\xc7\xd6\x5e\xac\xc3\xc3\x8e\x50\x65\xbc\xb1\xea\xf0\xfb\xd4\x67\x06\x46\xb2\x40\x02\x07\x4f\xea\x72\x5f\xdd\x7e\x45\x46\xde\x02\x06\xee\x2a\xea\xd1\xc0\x59\x2d\x64\xe7\xed\xc1\x48\x14\x22\x50\x58\xe1\xed\x30\x0d\x5e\x26\x92\x62\xab\xa4\x80\xd5\x52\x41\xf6\xa4\xaf\xa9\x24\x79\x57\x9a\x46\x7c\x07\xe1\x7a\x93\x45\xfd\xbe\x05\xb6\x50\xf5\x06\x04\x48\x12\x8b\x90\x33\xa2\x84\xc7\x8b\xa1\xca\x58\x49\x64\x0e\xfa\x46\x9a\x26\x14\xed\x29\x1c\x95\xc2\xcf\x57\x6f\xaf\xb3\x40\x97\xe5\xb4\xc4\x20\x8d\x1c\x38\x8d\xc8\x48\x51\x68\x24\x8e\x95\xa5\x7b\x53\xa8\x1c\x46\x8e\x0a\xfc\xfa\x33\x65\x49\x5f\x44\xdf\x46\x3f\x46\xff\x89\xfe\x8c\xa6\xc0\x0a\xf5\xd0\x0e\xbd\x67\xfa\xad\x4e\x55\x5d\xb3\x55\xd7\xd5\xe9\xab\xfd\x56\x57\xdf\x3f\xd7\xf5\xff\xeb\xfc\xe7\x4a\x5f\x5d\x5f\xd0\xa6\x98\xa2\xb6\xe5\x19\x58\x4c\xa0\x94\x51\xba\x2b\xf0\xba\x51\x39\x3c\x55\x11\x26\x67\x89\x3f\x5b\xf8\xff\x46\x7a\x7c\x96\xf8\xe9\x65\x06\x65\x42\xd1\xea\x46\x81\xb1\x50\xa5\xf7\xf7\xf1\x52\x4d\xff\x7a\x66\xc5\x2b\xe2\xf2\x7f\x9d\x21\x72\xa6\xd0\xff\xa9\x84\xea\x4c\x91\xe5\xc3\xe9\xa3\x1c\x3a\x8d\xc6\x75\x02\xae\x42\x1d\x18\x09\x1f\xf8\xcd\x7c\x0d\xfd\x02\xbd\xf7\xff\xfe\x2b\xf9\x9f\x8c\xd2\x92\x5e\x46\xc5\x78\xad\x81\xa2\xbf\x81\x50\x6a\xba\xb6\x51\x2f\x24\x9c\x67\xe2\xdb\x27\x82\xa5\x1d\xcc\xff\x95\xd1\xfd\x61\x47\xdf\x94\xb6\x13\xce\x36\x75\x6a\x61\x7d\x14\xd2\x5b\x15\xe5\x51\x0a\xcf\x2b\x8e\x4d\xc8\x76\x36\x41\xae\xa9\x13\xb2\xff\xc7\xc6\xe8\x39\x46\xd4\xe4\x51\x46\x09\x68\x13\x76\x60\x42\xa1\xe3\x8a\xe4\xf4\x82\x8e\x8c\x94\x14\xab\xf4\x70\x7b\xf9\xf3\x01\x9a\x43\x1d\x8f\x20\x96\xca\x5e\x75\xba\xcd\x86\x3c\xa8\x07\x6d\x99\x2e\x7d\xa5\x10\xae\x45\x72\x4e\xa6\xdd\x57\xf2\x1e\x11\x2a\xba\x90\x70\x96\x7a\x33\x9e\xd6\x01\x20\xa6\x09\x68\x23\x54\x3a\x9b\xd6\x65\xb3\xa5\x65\x98\xb2\xdd\xd4\x17\x40\xf9\xb4\x68\xf8\x2e\x8f\x59\x44\x23\x5e\x90\xc4\x71\x2a\xea\xd6\xb1\xf3\x8b\x41\x40\x11\x6f\xae\x28\xaf\xa5\xdf\x8d\x57\x7e\x5e\xce\x7a\xc7\x74\x29\x4e\x81\x85\xa7\x00\xc2\xfc\x77\x2d\xa6\xfc\x93\xf4\x9a\x04\xce\x78\x8e\x16\xc4\xb1\x09\xc5\x1b\x29\x4a\x6e\x23\xc9\x08\x8c\x79\xb3\xf2\xf3\x32\xd5\x57\x8f\x14\xb1\x25\x74\xdc\xfa\x28\x9a\x8d\xfa\xa9\x8d\xfb\x87\xa9\xfa\x87\xa2\x0a\xe9\xee\x69\x86\x2a\xe6\x75\x6a\x51\xa1\xd4\x0f\x93\x9b\xc8\x8d\x95\xa9\xc5\x40\x60\xc3\x41\x18\x9b\xb9\x36\x7f\xfa\x40\x22\xb2\x88\xcf\x41\x71\xe1\xe7\x20\x04\x9c\x00\x7c\x48\x27\xc1\x5b\x49\x2a\x61\x0f\xf1\xa1\x68\x2a\x91\x4a\xa4\xa2\xa9\x4c\x2a\x94\x0a\xa5\x32\x09\x77\xc2\x1e\x4a\x75\x63\x5d\xd7\x17\x12\x6e\xd6\x0f\x6e\x5e\x01\xf5\x0d\x75\x6c\x3c\xab\xfe\x62\x81\xd6\xfc\x23\x63\xd9\xec\x58\x6e\x24\x10\x50\x72\x39\x25\x10\x18\xc9\x69\xd7\x94\x18\x5a\x00\xe1\xec\x38\x8c\x28\x47\x0c\x38\x1b\xc8\x06\xb2\xea\x98\x51\x34\x06\x60\x6c\x3c\x90\x0b\x18\x3c\x8a\xc7\x10\xc8\x05\xc6\x61\x2c\x60\xd4\x36\x82\xd9\x80\x6f\x96\x89\xee\x1f\xb2\x05\xfd\x13\x0e\x79\x74\xe9\x84\x46\xe6\x3a\x83\xa9\x0c\x6d\xcf\x68\x26\x98\x09\xba\x79\x0a\xc0\x3d\x98\x62\x94\x09\x45\x51\x4e\xbc\x91\x0d\xc0\x78\x80\xe4\x02\x59\xac\x68\x5f\x6b\x6a\x50\xcd\xe6\x72\xb9\x37\x4e\x40\x36\xab\x28\xb9\xc0\xe4\xf8\x34\x9f\xa9\x09\x84\xc2\x65\x77\xa9\x55\x7a\x8f\x3a\x3c\x08\xc5\x3f\x3c\x03\x07\x88\xea\xf1\xa9\xa8\xec\xb7\x16\x17\x3d\xa7\x56\xca\x6e\x73\xba\xec\x4a\xcd\xd1\x61\x44\xc5\x47\xda\x84\xa0\xe6\xbc\x91\x08\xf9\x46\x95\x6e\x62\x55\xb9\x3e\x8c\x2f\xd7\x99\xca\xa5\xe6\xf4\xb2\xe5\xf4\x77\xe9\xa5\xca\x56\x97\x4c\x77\xe6\x9a\xd5\x4b\x37\x3d\x03\x9e\x33\xbd\x60\x18\xb5\xa3\xa5\xe4\xaf\x4c\x02\x39\x50\xb3\xb6\xa3\xad\xf6\x85\xcb\x1b\x81\x99\x29\x12\x5f\x63\x8a\x9b\xbc\x26\x35\x66\x32\xc1\x2b\x26\xaf\x29\x6e\x32\xa9\x7b\xe0\x10\xdc\x31\x63\xf4\x93\x34\x44\x63\xe0\x15\x93\x9e\x64\x8f\xba\xc7\x34\x73\xb4\xee\x57\x0d\x2d\x25\xff\x5e\x2c\x17\x2a\xeb\xb6\x94\x7d\xea\x32\x33\x45\xe2\x55\xda\xcb\xf5\xe7\x1e\x52\xf7\xe8\x0f\x85\x57\xe0\x8e\x19\xa3\xf1\x52\xbd\xac\xf4\xea\x10\x1c\x2a\x94\x38\x66\x9a\x39\x5a\x2b\xd7\x52\xf4\x31\x26\xc1\xac\x9a\xd6\x5e\xd3\xfd\x43\x48\x33\x45\x32\x89\x73\xd5\x7a\x5a\xf4\x3b\x67\x14\x55\x7b\x3f\x5c\x37\x63\x34\xd2\xcb\xf5\x24\x93\x60\xae\xa9\x6c\xaf\x2a\x1f\x13\xd2\x4c\x91\x4c\xe2\xec\xd5\x9d\x21\x1a\x3f\x79\x66\xe7\x9a\x4c\x71\xad\x60\x33\x44\x6b\x73\x51\x3b\x5a\x8a\xaf\xa1\xfd\xa8\x95\xca\x08\xd5\xee\x96\xf1\x35\xc5\xd4\xd3\xc6\x0d\x79\x67\xe6\xc6\xa2\xf3\x9b\x80\x96\xe2\x55\xa5\x67\x7e\xe8\x41\x70\xb6\xde\xa6\xcf\x5c\x0a\x02\x93\x20\xab\xf4\x67\xfe\x13\x1d\x08\x57\x9c\xad\x4f\xb4\x67\xb6\x33\x09\x72\x4d\xb9\x9c\x1f\xb2\xf1\x49\xfb\x59\x9a\xb3\x20\x87\xd6\xe9\xc6\x0e\x1d\x2f\xb5\x12\xa5\x47\x97\xe5\x3b\xfc\xa5\x1d\x79\xb2\x0f\x52\x15\x73\x08\x8f\x64\xe1\x7d\x4a\x22\x70\x59\x2a\xdb\xcf\x8f\x07\x02\xba\x93\xf4\x40\x20\x4f\x21\x92\xb8\xec\xc0\x46\x1c\x20\x94\xa6\x98\xa4\xba\xc1\x4b\x27\x72\x03\x1b\xc3\x2b\x7a\x05\x6d\x0e\x11\x7b\x86\x23\x65\x75\xb4\x0a\x1d\x10\x2b\xb5\x58\xd7\xe6\xb6\xe9\x92\x86\x10\x54\x60\xcf\x69\x65\xd5\x48\xc0\x02\xcd\x98\x60\xe3\xc9\x56\x68\x70\x24\x60\xac\xa4\xe4\x36\x30\x31\x26\x0b\x0c\x7d\xfd\x44\x4e\x90\xd9\x91\x31\x1d\xb6\x69\x8c\xec\xb4\xd9\xc6\x6c\x36\x40\x3a\x7a\xa8\x8e\x7e\x4b\x46\xca\x0c\x6e\x79\x72\x15\x65\x56\x8f\x8c\x04\x02\x25\x7d\x70\x46\xa7\x75\xdc\x28\x5a\xa6\x73\xc2\x33\xb6\x5a\x25\xcb\x40\xc7\x79\xf8\x5c\xa1\x05\x04\xa2\x37\x56\x19\x0b\x6f\x3b\x65\x20\x8c\xeb\x1c\xe5\x49\xad\x04\xe4\xc5\x69\x8a\x7a\x8c\x5e\x00\xca\x37\x71\xeb\xda\xe8\x67\x7b\x3b\xa6\x4d\xd0\x0d\xd5\x2e\x0c\xe0\x65\x0a\x88\x84\xa6\x64\x41\x45\xb4\x8e\x48\x90\x73\x5a\x13\x8c\xc1\xac\xa1\xa4\x8a\x74\xee\x43\x72\x68\x93\x8e\x9b\x44\x9b\x40\xe7\xf7\x93\xa5\x81\x40\x60\x92\x26\x60\xb4\x63\xe5\xfa\x63\x46\x6e\x84\x50\xc1\x53\x6d\x1f\xe8\xc2\xc9\x92\x97\xe7\x8f\x97\x9c\xd2\xde\x7b\xef\x19\x6e\x69\x99\xb1\x0a\xa7\xb5\xcf\xce\x84\xf5\x50\x58\xd3\x83\xd4\xfb\x4f\xb9\x3e\x7d\xb8\x1b\x8a\x8e\x8e\x4b\x6e\xc8\x2a\xdd\xfd\xcc\x9c\x80\xa0\x9d\xc3\xaa\x32\xbc\x73\xc5\x1d\xcf\xee\xa0\xab\x59\x76\xf4\x58\x67\xd3\xf8\xf0\x4e\xa2\x9c\xe5\x06\xce\x6a\xd1\x3b\x87\x71\x6e\xc7\xb3\x77\xac\xa0\x4b\xdf\xb1\xd1\x40\x53\xa7\x9e\x7c\x86\x78\x34\x63\xb9\x45\x5c\xb1\xcd\x49\xf7\xea\xdb\x99\x4a\x37\x45\x1f\x9c\x80\xa0\x33\x0a\xb6\x73\x18\x14\xad\xdc\x67\xb9\xc1\xe4\xf2\xd9\xea\x12\x03\x2d\xf1\x59\xe2\x11\xc5\xca\xcb\x4e\x65\x29\xbf\xd0\x88\xec\x14\x15\x4d\xfb\xfe\xba\x0b\xb6\x06\x3a\x8e\x4e\xbc\x64\x31\x58\xb4\x2e\x70\xe8\xec\xd7\xb2\xbd\xc1\xcc\x29\x74\xad\x3d\x2c\x0e\xa6\x92\x43\x83\xa3\xb8\x57\x17\xae\x1f\xa6\x27\x26\x4f\x5d\x05\x8c\x0e\x4e\xf6\x6c\x3c\xb8\x71\xe3\x41\xe6\xdd\x82\xe8\x5d\x07\x34\xbb\xf9\xe0\x86\x8b\x6e\xb9\xe5\xa2\x0d\x07\xbf\x3b\x3a\xa8\x25\x54\xff\x4b\xa7\xd6\x75\x41\x7a\xfe\x2e\xed\x81\x83\x83\xe4\x7f\x6b\x59\x37\xe6\x3f\xa3\xdf\xd4\x4d\x12\xd4\xab\xf5\x9c\x07\xa7\xeb\x8c\x98\x75\x3d\xca\xe2\x28\xe5\xaa\x51\x49\x0a\xba\x8d\x15\x83\x71\x9a\xff\x5a\x70\x10\x11\xf3\x45\x10\xd3\x74\x2a\x19\x63\x5b\xa7\xeb\x5f\x39\xed\x89\x80\xec\xe2\xd1\x01\x62\xb5\xf0\x16\x9b\xd5\xce\xb2\xa1\xbe\xcd\xbb\x3e\xf1\xc9\xcd\xe3\x11\xea\xae\x56\xdb\x43\x26\x23\xe3\xf8\x7f\x3d\x9c\x82\xb1\xcf\xa9\xbf\xe1\x1b\xbc\x46\xbb\xc3\x6a\x0c\x71\xf3\x33\xdb\xc6\x76\xaf\x49\xd7\x5b\xa6\x90\x37\x42\x93\x69\x87\x88\x77\x0a\xa9\x57\xdc\x5a\xc2\x92\x45\xf4\xbb\x9b\x8d\xd6\x69\x2b\x81\x08\x0d\x31\x48\x52\x2f\x7b\x15\x61\xb7\x8e\x2a\xd5\x10\xd5\xf5\x23\xfd\xa4\x1b\xe2\x7d\x44\x76\xf0\x22\x13\x6a\x88\x31\xd1\xa2\x64\x4c\xe7\x9b\xbb\xfb\x20\x41\x99\xbf\x58\xa9\xe9\x5d\xdd\x5b\xa3\x1d\xf0\x27\x4a\xc1\x67\xee\xb8\xae\xf9\x81\x45\x5f\x58\x74\xbc\xf5\xba\x3b\xb2\x9b\xef\xbd\x75\xe5\x63\x2b\x6f\xbd\x77\x73\x76\xbc\x37\x72\xdb\xd1\x7f\x3b\xb6\x61\x99\xf2\xe8\x1d\xb7\x8f\x06\xfb\x6e\xaf\x4d\x5c\xfe\xc8\x65\x47\x1f\xfe\xf8\xc1\x4b\x1f\xb9\x2c\x51\x7b\x3b\xec\x18\x5e\x3d\x7f\xfe\xea\xe9\x87\xbd\xd7\x3f\xe6\x34\x9b\x9d\x8f\x5d\xbf\xee\x96\xc1\x76\x51\x6c\x1f\xbc\x05\x0c\x3f\xde\xbb\x74\x67\x4f\xc8\xc8\xc9\xcd\x7d\x5b\xe7\xde\xf4\xf2\x3b\x27\x56\xae\xbb\x76\xfb\xf2\xd5\xa1\xc0\xca\x65\xdb\xaf\x3d\x7f\xc5\xd8\xf4\xef\xca\xad\xf5\x42\x61\xde\xd3\xbe\x9a\x0f\x9c\x7d\x75\x6f\x49\xa8\xb3\x29\x9f\x2d\x8b\x9f\x99\x5c\x53\xe7\x19\x0e\x94\xc6\x31\xbd\x97\x2d\x41\x0a\xe2\xb7\xaa\x3d\x2a\xe9\x7e\x2c\x77\xb3\x0a\xb2\xa3\x28\x5a\x80\x10\x24\x75\x10\x3b\xce\xe9\xa0\xa0\xbd\x90\x0e\x07\x53\xd5\x05\x83\x3e\x60\xcb\x9e\x97\x2a\xcb\x45\x25\xe6\x6e\x17\xf7\x5e\x6a\x22\xd7\xb4\xde\xab\xfe\x5c\x4a\x31\xd9\xa6\x0d\x35\x10\x91\x26\x0e\x13\x54\xc4\x2e\xd4\x0a\x0d\xa8\xed\x08\xdb\x15\x53\x7f\xd6\x7a\xef\xbc\x89\x5c\xa9\xdc\x81\x0d\x07\x73\xe9\x0b\x5d\x56\x7c\x51\xa8\xb5\x5e\xbd\xcf\x63\x0b\xb5\xd5\xc3\x65\xae\x7f\x1d\x2b\x57\xe5\x09\xe8\x4e\x2d\xf8\x4c\xdf\x1c\xf5\xbe\xd4\x82\x72\x65\x36\x8c\xcd\x8e\x05\x4a\xfe\x8b\x0a\xfe\xc8\x7d\xa8\x11\x25\xa9\x97\x21\x2a\x42\x8d\x50\xb8\x11\x8a\x07\xdd\x07\x7e\xa8\x06\xf5\x43\xb6\x18\x0e\x88\xd8\xe6\xc7\x81\x3e\x90\x2a\x9d\x94\x5f\x19\xfe\xa1\xfa\xc3\xb0\xc1\xe3\xad\xe9\x30\xd4\xdc\xf6\xd8\x6d\x35\x86\x59\x71\x8f\x6a\xd2\x75\x69\x06\x75\x5d\x9a\xc1\xed\x4f\xbc\xa3\x4e\xbe\xf3\xc4\xf6\xed\x4f\xbc\x03\xcc\x3b\x4f\xbc\x59\xed\x68\xfd\xc5\x1b\x3e\xfe\xf1\x1b\x6a\x3a\x0c\x06\x8f\x77\x78\xcb\x96\x61\xaf\xc7\xd6\x01\x3f\x1e\xd5\x73\xd3\x4f\x5f\xd5\xb2\x6d\x2f\x3f\x06\x67\xab\xbf\xdb\x99\xeb\xe6\xa2\x30\x7e\xba\xbc\x3f\x1a\x83\x8c\xf6\xb9\xfc\x13\x75\x33\x78\xe2\xb3\x0a\xb5\xea\xa8\xf1\x7a\x0c\x5a\x5d\xd5\xcc\x3f\x57\xb7\x44\x4d\x87\xad\x58\x2d\x83\xa1\xa3\xe6\x86\x8f\x7f\x1c\x1b\xff\xa7\x75\x33\x53\xdd\xfd\x56\x94\x29\xeb\x21\x6a\x43\xec\xc3\x57\x49\x89\x78\xf3\x74\xbf\x89\x15\xaf\x1a\xf9\xe7\x6a\xa2\x0b\x05\xe1\x2b\xff\x54\xe1\x0b\x74\x1e\x83\x0a\xab\xcc\xbc\x0f\xc7\x21\x61\xaa\xf4\xbb\x1a\x6d\x28\xd4\x10\x0d\x71\x3a\x04\x44\x30\x4e\xb2\x92\x98\x93\x44\x45\x94\x74\x8b\x87\x62\x10\x67\x0b\x95\x29\x9c\xd4\x57\x5f\xcd\xdd\xfb\xfa\xbd\xb9\x57\xd5\x57\xa1\xed\x55\xa2\xbc\x0a\xb9\x33\xf2\x68\xc1\x4b\x68\x75\x0a\x1a\x5e\x14\xa7\x5c\x51\xa0\x0d\x1e\x83\x36\xa4\x51\xa8\x45\xbe\x88\x36\x17\x87\x50\x07\x5d\x2b\x57\xa1\x4d\xe8\x32\xb4\x07\xdd\x42\x39\xaf\x9f\x41\x5f\xa6\x52\xfc\x56\x68\xe8\x85\x64\x37\xc4\x33\x15\xe1\x68\x45\x18\x9c\x8e\x50\x50\x0b\x27\x82\xf1\xf0\xd9\xd3\x9c\x33\xfe\x6c\x61\xb6\x32\x6c\x2f\x85\x53\xda\xb5\x4c\xbd\x93\x55\xcb\x04\x6c\x23\x36\xdb\x88\x4d\xb1\x8d\xdb\x6c\xe3\xb6\xc2\x15\x83\x6c\x93\x63\x36\x1b\x19\xb1\xe5\x4b\xf7\xe9\x09\x66\xbe\x2c\x9e\x55\x54\xb8\x2e\x9f\xc7\x6d\xb6\x9d\x5a\x86\xf7\x15\x1e\x0d\xa6\xde\xa7\xd8\x99\x9c\x92\x1a\x84\x9d\x34\xc5\xbb\x15\xc7\xfc\xbb\x67\x44\xa9\x33\x5c\x14\x4e\xa0\x9f\x0a\x7f\xea\x18\x4d\x67\xcb\x23\xa2\x4c\x2a\xda\x4f\x7b\x11\xd1\x8e\xa8\x80\xa3\xa9\xf3\xea\x5c\xa8\x05\xad\xd5\xa8\xb5\xa2\x6e\x10\x6f\xa7\x7e\x42\x28\x36\x00\x54\x89\x0d\x0b\xd2\xc1\xa2\x75\x5c\x0c\x87\x1a\x98\x12\x7a\x44\x86\xaa\xbd\x16\x2d\xc6\xdc\x2e\x4e\x79\xfc\xd0\xca\xfe\xad\x8f\x6d\x7c\xf2\xcd\xf7\x4e\x66\x2e\xde\x92\xc9\xf8\xda\xba\xae\x9f\xb8\x22\x54\x47\xe5\x5d\x75\xa1\xc1\xd1\x41\x36\x17\x32\xf1\x3f\xbf\x7f\xdd\x42\x5f\x76\xe1\xce\x39\xdb\xd5\xf7\x36\x59\x25\x9b\x2d\x50\x1f\x3a\xff\x63\x8f\x2c\xde\xf9\x9d\x9d\x91\xc4\x8d\x27\x5d\xc6\xfa\xfa\x7a\xf8\x23\xde\xb1\x3e\x30\x3b\x73\x20\xff\xf8\x2e\x6b\xb8\xa6\x56\x74\x91\x5d\xa1\x39\xf6\x09\x91\xca\xdf\xfe\x62\x9f\x13\x4a\x0d\x0e\xee\xce\xb3\x51\x89\x65\xae\x0d\x89\x41\xbf\x6f\xdd\x1c\xa3\x41\x0e\xe3\x37\x43\x0e\x67\x6b\x6f\xa4\x2f\x23\xef\xb4\xb0\x36\xc9\x81\x10\x57\xaa\x3b\x8b\xcc\xa8\x05\xc5\xd1\x42\x74\xb5\xf6\x1d\x72\xbc\x33\x2d\xd3\x23\xa4\xb8\x68\x2a\x12\x8d\x19\x43\x0d\xbc\x93\x56\xca\xed\x74\x25\xe2\x72\x4a\xab\xab\xd3\xf5\xff\xab\x59\x48\xf6\x2b\x2f\xbc\xf8\xe5\x2f\xbc\xfa\x13\xf2\xfb\x3f\xde\xe7\x90\xd9\x4e\x21\x2e\xc7\xbc\x6d\xa1\x36\x97\xdb\x2b\x6f\xff\xca\x65\xb2\xa3\x65\xf6\xf5\x4f\x3e\x7e\xa8\x3d\xf8\xf1\x89\x2f\xfc\x8f\xda\x0a\x7b\x72\xb6\x6d\xcf\x8c\xc0\x53\xdf\x33\x5c\xf7\xec\x55\x6a\xe7\xd7\xaf\x6d\x1f\xe7\x8c\xc4\xc7\x79\x78\x99\x33\x33\x0c\xf9\xd5\x9c\x94\x91\x3b\x69\xc7\xfc\xb3\xeb\x0d\xcf\xb5\xc0\x9f\xfe\x67\x0d\x89\x91\xa0\xd1\x25\x94\x7f\xd0\xa8\x7b\xe3\xac\xe2\x1f\xb8\x1c\xd5\xf6\xa7\x78\xf1\x4c\x0c\x05\x13\xd3\x2e\x89\x93\x54\x10\x4a\xb4\x59\xab\x79\x66\x2e\x8a\xda\x5e\x61\x79\xa7\x8d\xe1\xf6\xa9\xa3\xfc\x2a\xe6\x1d\xfa\xfe\xae\x82\x8f\xd1\xe9\xec\x35\x97\xc3\x08\x22\x74\x40\x0c\x32\xd0\x47\x21\xac\x67\x2c\x26\xbe\x74\x26\x6e\x9b\x09\x2f\x50\x0f\x33\x6e\x4b\x9f\x20\x30\xb0\x5b\x0f\xe0\x8f\xcd\x58\x81\x43\x33\x73\xa2\x98\xe0\xe9\xf7\x04\x81\xb1\x33\x6e\x81\x35\xeb\x81\xfc\x8e\x99\x2b\x57\xd6\x8d\xff\x26\x72\xa2\x6e\x3a\x7b\x16\xe0\x69\xb4\x0a\xb9\x5d\x75\x40\x01\xeb\x1c\x22\x29\x80\x38\x48\xd1\x18\x44\xab\x12\x39\xed\x8c\xdb\x85\x15\x8a\x60\xa3\x93\xdb\x75\xcd\x51\xf5\x1a\x59\xe6\x84\x86\xd6\x94\x8f\x33\x38\x38\x52\x83\x5b\xef\xcb\xbe\xf6\xd0\xf4\x34\xf0\xc9\x93\x8f\xc3\xf3\x0b\x5b\xec\x6c\x91\xf6\xae\xb7\xdb\x5b\x16\xa8\x57\xcb\x49\x59\x5d\x3a\xe7\xfe\x7d\xfb\x3a\x2d\x76\x30\x78\xe1\xc8\x67\x17\x2d\x17\x26\xaa\xd2\xa9\xa7\x7d\xff\xf6\xa4\x4e\xab\xe2\xa9\x27\xb9\xfd\xec\x38\x32\xa1\x26\x84\xa0\x1d\x3a\x80\xd8\xdd\x2c\x89\x1a\x41\xa6\xf8\xad\x61\xea\xf3\x28\x23\x43\x24\x9d\x09\xcb\x1a\x05\x2e\xb3\x7e\x60\x1e\x06\x50\x3f\x35\xe0\x3f\xd1\x0d\x7d\x3d\x16\x78\x4f\xbd\x6f\x2d\xeb\x72\xdb\xdd\x6a\xbf\xda\xef\xb6\xbb\x5d\xec\x5a\xf5\xe3\x01\xa9\x1d\xfe\xf6\x86\xa3\xce\xe7\x7c\x03\xfe\xd6\x2e\xe1\x79\xa7\x93\xa6\x1e\x18\x98\xec\xad\x7f\x0c\xb6\x0c\x40\x4a\xfd\xb4\x6a\x09\x86\x2d\x6f\xbf\x6d\x09\x07\xe1\xbf\x61\x73\x20\xc3\x2f\x86\xef\x37\x37\xab\x5d\x8b\xf9\x4c\x09\x7b\x57\xa1\x3a\xc6\xa8\x0c\xaa\x1f\x6c\x88\x41\x9a\x2a\x98\xb9\xfd\xc0\xde\x90\x57\xec\x4d\xac\xc9\x55\x9b\xcf\xb9\x42\x26\xc9\xc1\x22\xc1\x56\x2b\x59\x79\xe6\x33\x13\x28\x84\xd9\x90\x0b\x67\x6b\xdb\x9a\x4c\x58\xe1\x65\xb1\xb9\x88\xb5\xa9\xd1\xe6\x18\xb1\xa8\x93\x22\xf8\x1b\x21\xa8\x4b\x00\x4b\x62\xbe\x60\x41\x97\x42\xdf\xe8\x96\x9d\x50\x67\xd2\x71\xb7\xcb\x61\xd5\x95\x5e\xda\xf1\xaa\xbc\x82\x57\xe5\x9f\x64\x94\xa2\xa8\x62\x72\x6c\x9a\xe4\x82\xac\xfa\x9b\xc9\x6b\x32\x1a\xff\x4e\x05\x3b\x78\x55\xfe\xe7\x78\x55\x7e\xa4\x42\xba\x41\x46\x2a\x24\x1c\x7f\x37\x1a\x4d\x5e\xd3\xdf\x26\x9f\x94\x50\xc1\x7f\x11\x53\xf6\xa3\x32\x58\xe6\xa3\x48\x55\x3a\xe3\x19\x07\xc7\xeb\x3e\x62\xea\x80\x32\xc0\xe8\x76\x2f\x53\x9c\xe7\x9c\xda\xdc\x97\xce\xf4\xb1\xa9\x42\x04\x04\x3a\x87\x3b\x8b\x7f\xf8\xeb\xf4\x74\x3c\xd9\x86\xc7\xe7\xdd\xae\xac\x6a\x4b\xee\x1c\xdb\x99\x6c\x2b\x9c\xd2\x5b\x33\x73\x87\x5a\xa2\x76\x7a\xe9\xa1\x59\x98\xaf\xd3\xd3\x79\xf4\x38\x92\xbc\xa0\x46\x7d\xe3\x40\xa4\xb5\xa9\x6f\x81\xb7\xe6\x82\xa4\xb6\x71\x4f\x5e\x50\x43\x92\xe5\xb0\x6a\xf5\xd6\xdb\x6b\xc2\x2d\x3d\xcb\x0b\x91\x3a\xd6\xbd\x42\x6d\x39\x05\x54\x83\xc2\x28\x8b\x36\xa0\x1d\xe8\x5a\x74\x73\xc1\x43\x70\x81\xf3\xe8\x72\xb8\x75\x9d\x58\xaa\xe3\x12\xa9\xa0\x17\xd9\x92\x8d\x42\x34\x03\x7e\xe8\x07\x0a\x51\x91\x71\xb9\xc1\x05\x7c\x09\x2c\xc7\x0d\x7c\x84\x2a\x23\xf6\x17\x0c\x11\x98\x8a\x47\x40\xc5\xa3\xd9\x69\x2f\x85\xaf\x4d\x21\xb3\xc7\x6c\x34\x02\xd2\x3a\x6f\x4c\xf7\xb4\x34\x5e\x61\x0b\xcb\x62\x1d\x02\x47\x7d\xda\xe9\xfc\x33\xd8\x6b\x57\xd6\x1e\xf5\xf9\xd4\x3f\x49\x21\x27\x0c\xaf\xce\xdf\xff\x67\xf5\xcf\x05\x38\x1d\x90\xa4\x90\x53\x7d\xaa\x80\x98\x03\xcb\x9c\xf8\xae\x8a\xc7\xe4\xff\xa2\x3f\x1a\xee\x9f\xf6\x42\x30\x4e\x21\x3a\x12\x80\x9e\x12\x15\xe6\xb8\xe3\x34\xfd\xd8\xf5\xab\xee\x5d\xb5\x06\x96\x3b\x43\x92\xfa\xa7\x5a\xd0\xc1\x75\x40\xfe\xb3\xd3\xa9\x3e\xb5\x16\x6f\x94\x40\x2a\x00\xee\xa8\x7f\x7a\xd7\xe9\x84\xe1\xb5\xd7\xd1\x0c\xea\x97\x9c\x97\xea\x4e\xa3\x50\xc5\x23\x3f\x3b\xed\x65\xda\x7c\x30\x82\x10\x99\xa4\x7c\xcd\x1e\x5d\xaf\x73\x9a\xe4\x5b\x9b\xcd\xc4\xca\x58\xaa\xe8\x5e\x80\x85\xa6\x6b\x29\x64\xa4\x60\xdc\x8f\x71\xce\x63\x7b\xd7\xe6\xa1\x07\xe8\xa9\x8f\x2e\x6a\x8b\x36\x67\x3c\xb6\x77\xad\xce\x9b\x97\x75\xc7\x2f\xea\x9d\xdb\x1a\x3a\x4f\x90\x2c\xc2\x23\x02\x6b\x18\x83\x59\xc3\x0f\xdf\xbc\x12\x3c\xc5\x0c\x1e\x7c\x5e\x7a\x63\x77\x4f\xad\xcb\xbd\xba\xc6\x5e\x1f\x96\xdb\x57\x1d\x0d\xd5\xce\xe9\x68\xc9\xd6\xd5\x5c\x68\x33\xec\x33\xf9\x05\x30\xf5\xed\xb8\xbf\xb8\xd7\xc6\xda\xf7\xec\x47\xb1\xe9\xc8\x17\xba\x9b\xde\xe2\x42\xe6\xd4\xbe\x59\x52\xbd\xba\x29\x3a\x0f\x38\xe2\xcd\x66\x8b\xae\xb0\xb3\xde\x88\xa2\xfb\xa2\xd1\x81\xc8\x4a\xb0\x17\xa0\x14\x04\x63\xf9\x5c\x84\xd9\x4e\x05\x4b\xba\xe1\x2b\x46\x9b\x11\xc2\xfe\x92\xdf\x91\xaa\x97\xc8\x44\xdf\x4f\x47\x49\xa4\x60\xc3\x5d\xf9\x78\xbf\x0f\xa2\xda\x65\x14\x7c\x10\xf6\x42\xd6\x1b\x86\xc0\xb8\x76\x53\x3b\x30\x5c\x9e\x26\x24\x14\x10\x4d\x9b\xb1\x10\xab\xb2\x97\xa1\x30\x5a\xa2\xd5\x35\xd4\x01\x91\x28\x75\x71\x68\x85\x60\x2a\x21\x93\x50\x2a\x48\x21\x0f\x12\xe9\x7e\x1c\x74\x86\x88\x0c\xce\x20\x55\x27\x66\x8a\x7d\x14\xd5\x7d\xd8\x50\x4b\x9d\x44\x8a\x7c\xe4\x1f\x27\x3c\x06\x42\x80\x30\x60\xb2\x7e\x52\x55\x95\xef\x3d\x73\x08\x1c\x87\xb1\xd3\x40\x08\x31\xd4\xdc\x09\xb0\xef\xeb\x3f\xc2\x7f\xc8\xab\x84\x49\x2e\xbb\x70\x59\xb2\xbb\x39\x11\x13\x5d\x97\x7a\xc3\xab\x2e\xbd\xf2\xf6\xd9\x83\xeb\x86\x32\xe4\xad\x47\x1f\x9d\x6c\x31\x5a\x08\x6f\xc4\x0e\xcf\xe9\x47\x21\x04\xb6\xc7\x7e\xcb\x44\x8c\x16\xa3\xa5\xe5\xb7\x8f\xa9\xef\xa9\x3f\xc5\x8f\xbe\x54\xeb\x93\xb2\xa3\xf3\xfa\x63\x7d\xc1\xc8\xec\xa8\xb9\x76\x43\xb8\x6e\xee\x9e\x2d\x9d\x1b\xbb\xe7\xb4\xf6\x04\x87\xf5\x75\x88\x9d\x42\x1c\x22\x37\xa3\x30\x5a\xfc\xe1\xea\xc6\x9e\xbd\x6e\xe4\xc3\xd7\xed\xed\xbc\xca\x90\xe9\x75\x1b\xbe\xfc\xca\xdb\x17\x6c\xd9\xba\x84\x39\x77\xd5\x7e\xf6\x52\x6d\x3b\x9c\x59\xb3\x81\x4b\xe7\xcd\x99\x1f\x1d\xa6\xf5\x02\x84\xf8\x03\xac\x8e\x37\x87\xc2\x10\x34\x82\x8b\xe3\x81\x8e\x90\x68\x84\xae\x63\xc1\xb8\x8b\x28\x30\x9c\x47\xea\x53\xdc\x7b\x56\x73\xcd\xa4\x12\x99\x93\x47\x91\x7e\x9b\xd5\x5c\x43\x94\xc8\x1c\x82\x22\xfd\x14\x67\x8f\x49\x35\x0c\xfa\x26\x51\x5b\x73\x43\xc3\xa0\x8f\x41\x6d\xcd\x3a\xbf\xef\x75\x3a\x97\xee\xd0\x31\xb2\x28\x7a\xb6\xd3\xe1\xe2\x9d\x0d\xbc\x88\x75\xf4\xe7\x92\xed\xb1\x1f\x17\xc8\x0f\xea\x23\x24\xda\x90\xb2\xfb\xb1\x4e\xe8\xa6\x92\xd4\x45\x52\x01\xa8\x84\x82\x4d\xa7\x33\x4e\xad\xf9\x9d\x0e\xb7\x8e\x3c\x1d\x77\x71\xca\x05\xcb\x9b\x17\xb7\xcf\x0f\x5f\x19\x00\x97\xb9\xe1\xc0\x8e\x58\xef\xea\x50\x73\xe8\xf2\x15\xab\xaf\xf3\x87\xfd\xb1\xf0\xf0\xa6\x63\xc6\xb0\x51\x00\x8c\x71\x7d\x98\x1c\xdb\x34\x1c\x8e\xf9\xc3\xfe\xeb\xd6\x0c\x5f\x1e\x6a\x0e\xad\xee\xcd\xbe\xd5\x01\x2c\x0b\x9e\x50\x5b\xbb\xab\x6b\xf6\x70\xeb\xca\xf5\xf0\xd5\x15\xda\xad\xbd\xd1\xe3\x51\x16\x88\xdd\x94\xea\x0a\xcf\x6f\x5f\xdc\xbc\xfc\x82\xf5\x2b\x5b\x87\x67\x77\xb9\xda\xdb\x42\x1e\xcc\x60\x0c\xc0\xa0\xaa\xac\x85\x92\x74\xa5\xfc\x55\x6f\x2b\xd0\x65\x8c\x42\x7d\xd9\x25\xe8\xf7\x88\x78\x67\xc9\x5b\x3a\x55\x40\x8f\x20\xed\xeb\xa4\x9c\x77\x14\x28\x84\xb5\x25\x21\x40\x97\x84\x80\x8b\x51\xd4\x9f\xfd\x8c\xc2\x10\x16\xf8\x0d\x80\x7e\xa6\xfe\x2c\x92\x8c\xe8\x20\x8b\x91\x64\x64\x0a\x9d\x54\xff\x71\xf2\x24\x18\x4e\x92\xac\xf2\x4b\xf5\x19\xcf\x41\x5d\xb9\xf2\xa0\x07\x16\xfd\x52\x9f\x32\x74\xfc\x46\x8a\x92\xb3\x5d\x45\x07\x4f\x9e\x3c\x88\xb5\x23\x22\x48\x98\x52\xd8\x6b\xa8\xbe\xeb\x3c\x6d\x65\x07\x3e\x52\x2a\x8e\x11\x74\x2d\x7a\xde\x95\x88\x57\x14\xf2\x8c\x0a\x44\xf9\x4a\xcc\x03\x97\x23\x0c\x3a\x08\x3a\x58\xb7\xb5\x44\x92\x11\xe6\x52\xf5\xfe\x93\x07\x33\xe9\x91\x8b\x2f\x7f\x86\x96\xf7\x8c\xfa\xec\xbb\x52\x35\x79\x4d\x2b\x4d\x26\xe6\x15\x7a\x56\x6f\xcc\x1f\x3d\x79\x70\xfb\x67\xf1\xf2\x6d\x97\x5c\xa5\x57\x20\x85\xfd\xea\xfd\xca\xc1\x93\xf2\x48\xa2\x50\x11\xef\xb4\xaa\x0a\xf3\x55\x93\x69\xa5\xc9\xab\x3d\x42\x3b\xdf\x98\x3f\xaa\xd5\xf0\xba\x92\x9e\xb4\xee\x27\xa9\x41\xd7\x73\x48\x67\xd2\xb2\xdd\x21\xb2\xd4\xe1\x65\x09\x8b\x9c\xc9\xaa\xd9\x3d\x1b\xff\x98\x9b\xb7\xe5\xd0\xb5\xfb\x53\x36\x8b\xcf\x62\x4b\xed\xbf\xf6\xd0\x96\x79\xba\xc2\x0b\xce\x62\x65\xe2\xee\xfe\x25\x5f\x27\x4f\xe5\xd1\xda\xc7\x6f\xd9\xbb\x72\xb1\x97\xe7\x38\xde\xbb\x78\xe5\xde\x5b\x1e\x5f\xab\x4f\x8c\x05\x7a\x09\x95\xf0\x21\x42\x68\x11\x42\xee\xa0\x3d\x18\xae\xd2\x7e\x38\xf3\xba\xca\x62\xa8\x40\xe8\x95\x42\x89\xb8\x4b\x61\x95\xd3\x0a\x54\x40\xbc\x90\x0a\x25\x50\x50\x86\x92\xa7\xa9\xb7\x45\x65\xe3\x40\x76\x60\x23\xe8\x27\x25\x39\xa4\x30\x28\x07\x01\x0a\xa2\x41\xe9\xbb\x8a\xf0\xb2\x09\x2a\xa2\x62\x51\x72\x48\xf7\x9c\xa7\x1f\x87\x68\xbb\x11\x4a\xf3\x8e\x23\x1e\x0d\x95\xf5\xcb\xc3\x05\x58\xc7\x70\x0c\x52\x41\xe7\x74\xc5\xda\x4c\x2a\xd4\x50\xd8\x63\xc4\x20\xd3\xc7\x94\x15\xa4\x83\xc9\x74\x26\x4c\xe1\x62\xb0\xae\x59\x4e\x3e\x67\x31\x58\x18\xa2\x66\xcd\xe2\x14\xba\xea\x1e\x7d\xf1\xdb\xb7\x25\xd0\xbd\x73\x51\xaf\x83\xb1\x37\xd9\x04\xb7\xdd\xc2\xca\x9d\x73\x2f\xed\xac\xd9\x78\x70\xa3\x08\x31\xd1\x0c\x39\xc2\x58\x0c\x16\x56\xef\xf3\x11\x35\x67\x33\xf2\x30\x82\x25\xf3\x76\xf7\x53\xd7\x4c\xd2\xa5\x8a\x04\x46\x1f\xf7\x5f\xd5\xd1\xbd\x24\x68\x08\xf1\x96\xb8\xc7\x14\x18\x9c\xbb\x40\x6a\x69\xd3\x6a\x15\xac\x37\x4b\x78\x04\x78\xa3\x56\xb7\xc6\xa9\x00\xa7\xcb\x25\xdb\x2b\x3c\xd0\x3a\x34\xea\x95\x70\x3c\xab\x23\xf8\x64\x64\x28\x85\xb4\xf2\x67\xd2\x8d\xc1\xb8\x8b\x1d\xa3\x84\x2a\x78\xee\x7f\x7a\xc5\xd5\x0e\x2c\xaa\x0a\x6f\xb4\x98\xb3\x02\xbb\x46\xfd\x2f\xf5\x6d\xc2\x89\xc6\xac\xdd\x32\x6e\xb2\xc1\x4d\x23\xc3\x27\x61\x35\xb0\xa2\x83\xd1\x29\x56\x50\xde\x57\xef\xfb\xf2\xf0\x88\xfa\x51\x9b\x69\x9c\x31\x6a\x9d\xe6\x80\x9a\x35\x60\xcc\xca\x0e\x50\x44\xec\xb8\x7a\xc5\x37\xef\x92\x4b\xfe\x7d\x4e\xe9\xfb\x0d\x20\x41\x39\x1d\x8d\xb4\x6a\xe7\x20\x09\xca\x24\x48\xf1\xad\xb9\x53\x8f\xa8\x4f\x3f\x2d\xf8\x6a\x3b\x1f\xff\x91\xfa\xf4\x8f\xd4\x5f\x6b\xc7\x4f\x30\x93\xdb\xbe\xd4\xdd\xd3\x82\x27\xf2\x2c\xc9\x76\x06\x82\x93\x8b\xc8\x33\xda\x0f\x16\xad\x58\xbc\xf8\xdb\xd3\xf5\x60\xb4\x09\x07\x85\x33\xe9\x64\xd4\x08\x45\xac\x7a\x8e\x5a\xa3\x54\x8a\x7a\xc8\xc7\xb6\xcb\xb2\xfa\x22\x24\x64\x79\xbb\xb6\xa3\x9b\x23\xcb\xf0\xbc\x9c\xc4\xb7\x56\x71\x35\x3f\xa6\xdd\x85\x04\x24\xe4\xa4\xac\xe5\x98\xa3\x27\xc6\x3f\x39\x2b\xbe\xba\xfe\x7e\x48\x53\x6b\x13\x8a\xa9\x6e\x2c\x80\xbf\x57\xbe\x1f\xbf\x08\xcf\x17\x1e\xb7\x5d\x96\x21\xa1\xbe\x48\x0b\x42\x16\x56\xbf\x5f\x2b\x95\x56\x34\xbd\x98\x2f\xaa\x2f\xd2\x1c\xe7\x7a\x3f\x64\xd2\x45\x6b\x17\x1d\x02\xdf\x58\xf5\x7e\xe6\x63\x15\xb5\x91\xcb\x95\x84\xea\x06\x00\xbd\x05\xaa\x0b\x0b\xd5\x05\x98\xa1\x0f\x8a\xcd\x6f\x2c\x36\x44\x75\x1f\xb4\x9f\x51\x2f\xbd\x13\xaa\x59\xcb\xef\xd0\x46\xa8\xee\x30\xbc\x67\x86\x36\xc8\x52\xdb\x11\x3b\x1d\x61\x99\xa0\x1c\xb4\x42\x07\x84\x64\x36\x91\x0a\xcb\xc1\x28\x04\x09\x1b\x66\x46\x6d\x93\x77\x76\xe0\xad\xae\xef\x3d\x27\x7c\xd1\x05\xa3\x0c\x5c\x12\xcf\xef\xb5\xaa\x9d\xac\xa2\xe4\xbf\x95\xff\x0e\x79\xe2\x8b\xf9\x3f\xfc\x36\x95\xba\x53\xfd\xc3\x56\xd8\x82\x03\x5f\x81\xd7\x4e\x6f\x7e\xf8\x61\x3a\x7e\x2d\x53\x59\xee\xbf\x0b\x18\x72\x41\x23\x96\x83\x3c\x1b\x96\x83\x72\x30\x13\x04\x99\x7d\x43\xfd\xdb\xe4\xeb\xf9\x85\x8b\xa0\xb9\x0e\x3e\x07\x6f\xce\x9f\x38\x6f\x0e\xf3\x4c\x64\xe2\x3c\x56\x39\xfd\x82\xfa\x1e\x98\x61\xeb\xd1\x87\x1e\x82\x55\xd0\xfc\xed\x42\x5b\xd9\x78\xdd\x67\xc7\x9a\x8a\x6f\x55\x9f\x87\x3a\x80\x63\x02\x8d\xd1\x33\x70\x68\xfd\xe0\xae\xd8\x36\x57\x6c\x40\x9d\x89\xa2\x94\xdb\xde\x07\x99\x22\x58\x2d\xc9\xe9\xb3\xd2\x76\x87\x81\xb1\x98\x2f\xda\xa3\xee\x52\x93\xea\xae\x3d\x17\x19\x45\xc6\xe0\x90\x44\x18\x71\x19\x0c\xd6\xad\xf3\xde\xbb\x4f\x27\xb6\xe7\x2c\x3c\xf6\xea\xb1\x85\x73\xf4\x8b\xfb\xde\x9b\xb7\xd5\x6a\x30\xb8\x60\x44\x94\x98\x37\xe9\xdc\x34\x39\xa6\x8e\xb9\x0c\xd8\x78\xd1\xdd\x8f\x3e\x7a\xf7\x45\x46\xac\xdf\x74\xc8\xb6\xad\xeb\xf7\x39\xf0\x6d\x94\x7a\xff\x4c\xc3\xee\x85\xa3\xc7\x8e\x8d\x2e\xdc\xdd\xf0\x19\x1a\x91\xbf\xc1\xb1\x6f\xfd\x56\x9b\xec\x90\xf4\xef\x9f\xd2\x0d\xa1\x33\x7c\x6c\x75\x83\x5d\xf7\x44\x5a\x40\x12\xa0\xde\x7a\x99\x40\xd9\xa9\x57\xa0\x40\x19\x14\xdc\x7d\x95\x45\x62\x14\x0b\x38\x4b\xfd\x79\x3d\xa3\x95\x5c\x7b\xbb\x9a\x9b\x2e\xcf\xd2\xf7\xf8\x94\x5a\x29\x23\xdd\x46\x02\x9c\xcd\x15\x40\x36\x54\xf8\x9d\x4d\x26\xa2\x43\xd8\x82\xab\x60\xfb\x04\x17\xeb\x8e\x4a\x29\xfb\xff\x0b\xe7\x10\x8a\xe0\x3f\xe8\x90\xb5\x17\x43\xdf\x1b\x5a\x7e\xbc\xba\x94\xb5\x2d\xbf\xff\x9c\x92\x1d\xca\x4f\xc1\x88\x55\x48\x11\x4f\xeb\x8c\x1d\x63\xb5\xee\xf4\x19\xba\xd4\x4a\x67\x13\x6d\xa7\x5c\x53\x27\x46\x33\x87\x49\xa0\x18\x9a\xf1\x50\xd2\x79\x81\x32\xae\xd7\x19\xe5\xb0\x9f\xe3\xba\xb2\x1c\x33\x1d\xa0\x5c\x06\xf8\xe9\x4c\xc1\x4a\x9f\xd3\x3c\xaa\x45\x29\xb4\xa0\x42\xf7\x25\x82\xa2\x11\x2a\x27\xa2\x3e\x12\x80\xd2\x1e\x11\x1c\x83\xc6\x68\x84\xd7\xe3\x5d\x8c\xa4\xdf\x38\xd3\x43\x23\xd6\x55\x86\xe1\xf3\x82\xfa\xcc\xef\x45\x87\x5d\x78\xe0\x75\x33\x48\x82\x22\x38\xe0\x00\xbb\xfd\x4b\xbf\x57\xdf\x78\x40\x34\x9a\x24\xe1\x47\xb0\xe1\x14\x4f\x6f\x98\xcc\x50\x5f\xa9\x19\xa9\x5b\xf4\x37\xfc\x1e\x16\x09\xe0\x10\x14\x41\x02\xf3\xeb\x0f\x08\x76\x87\xf0\x00\xd4\xff\xfe\x4b\xdb\x59\x30\x99\x68\x2c\x7f\x4a\x7d\xe4\x47\x82\x64\x32\x92\x17\xab\xf5\x25\xcb\x32\xbc\xda\x2a\x0f\x18\x74\x2a\xa7\xce\x79\xe8\x5e\xe2\x0c\x2f\x09\x4f\x07\x02\xf9\xf1\xfa\x60\x20\x60\xb3\xd9\xad\x67\x20\xe7\xe7\xef\x97\x96\x48\x90\x95\x25\x39\x9c\x57\xc2\xb2\xc1\x88\x08\x4a\x4f\xa5\xb8\x17\xd8\x1f\x52\x5a\xae\x03\x21\x23\x5b\x5e\x2d\xb4\x49\x5a\x67\x09\xa7\x93\x91\x06\x3e\x5a\xa4\x80\x29\x27\xcc\xed\x72\x30\x08\x7a\xf2\xcf\xa9\xcf\xc1\xa5\x78\x54\x96\xa9\xef\x91\xfc\x31\x59\x86\x51\x29\x4d\x0e\x4f\xee\x0e\x5f\x16\xde\xdf\xb9\x73\xac\x73\x5f\x38\x4c\x0e\x87\x2f\x0b\xef\xd3\x2e\xf6\x87\x99\x1e\xf5\xb9\xfc\x73\xd0\xa3\x6a\xb9\x92\x5a\x6a\x2d\x57\x52\xcb\x8f\xef\x9e\xbc\x36\x1c\xde\xdf\x39\xb6\xb3\x73\x7f\xf8\xb2\x30\xb9\x23\x1c\xde\xa7\x5d\xec\x0b\x5f\x36\xad\x5d\xf4\xbd\x7f\xb5\xc9\xf2\x0c\xba\xac\xba\xc2\x2c\x39\x43\xaf\x96\x6a\xaf\xea\x2c\x86\xe9\xda\xaa\x64\x9a\x5f\xd3\x8e\x19\x38\x0c\xe7\xd0\xeb\x62\x14\xdd\xe9\xb3\x24\x12\x1d\xc9\xad\xac\xd0\xa5\x54\xfa\x3d\xc5\xe3\x25\x7e\xbd\x1a\xa7\x6e\x51\xf5\x94\xe4\xe6\x4a\x17\xa8\x08\xb4\x12\x91\xd3\xec\x01\xe4\x43\x08\xb8\x56\x28\x83\x95\xa7\x13\x41\x7b\xa8\xec\xfe\x97\x9c\x96\x9a\x72\x92\x98\xcf\x3a\x0d\x06\xcb\x98\xd1\x06\xd9\x5c\x93\x64\xf7\x42\x56\xea\x93\x20\x5b\x4b\x3e\x1b\x9e\x1c\x13\x25\xc9\x61\xcd\x99\xb1\x12\x0e\xd7\x83\xe2\x72\xa9\x4a\x80\xae\x65\x64\x4a\x21\xa7\x59\xa4\x8d\x36\xb9\xc8\xbf\x29\xa8\x12\x66\xb4\xe9\x38\x48\x29\xc4\x74\x00\xe7\x04\x39\xd7\xd4\x58\xab\xe6\xa4\x3e\x49\xcd\x79\xed\x52\x53\x4e\xcd\x89\xe6\x31\xc1\x68\x64\x91\x2c\x4e\x3e\xb4\x24\xa0\x2a\x2e\x17\x28\xf5\x91\x30\x56\xcc\x39\xd1\x21\x4f\xa7\x05\x1a\x2b\x68\x01\x88\x96\x69\x81\x33\x3e\xc3\x27\xf1\xf6\xc2\xea\xde\xfe\xef\x05\x72\x40\xa3\x89\xb6\x57\xf6\xe2\x3b\x78\x7b\x81\x16\x68\xff\xf7\x42\xe2\x07\x64\x72\x6b\x65\x7f\x96\xe7\x7d\x0e\xd9\x90\xb3\xd0\xa7\x6e\x3e\x94\x0a\xa5\x28\xbc\x02\x6d\x3f\x23\xb1\x43\xc1\x99\x91\xf5\x4c\x1d\xb9\x8f\x1f\x4f\x76\x8e\xc0\x2b\xa2\x5d\xfd\xa5\x5d\x10\xed\x10\xb2\xab\x13\x38\xa0\x8e\xe7\xc7\x89\xb2\xc1\xe7\x3b\xee\x1b\xf6\x6d\xc0\x63\xd3\xbc\xb2\x7e\xe1\x78\x72\xa4\x13\xbe\x21\x68\x59\x44\x41\xcb\x92\xcf\xe2\x00\x04\xf2\xe3\xea\x38\x1e\xd9\xe0\x1b\xf6\x1d\xf7\xf9\x36\x8c\x9c\xed\xbb\xaf\x41\xcd\x25\xbd\x4b\x9e\xab\x2f\x7a\x0c\xca\x80\xce\x40\x98\x51\x6b\x3b\x40\xe1\xe1\xf3\x7f\xd0\x1b\x02\xbb\x8e\x48\xb5\x16\x21\x5a\x35\xec\x47\x60\xdc\x1b\x89\x36\xd7\x69\xe9\x68\xcb\x61\xd7\x11\x99\xb5\xe3\x96\x6a\x7f\xf9\x7a\x39\xa8\x2f\x7f\x63\x71\xd2\xa9\x83\x06\x91\xd5\x59\x14\x99\x74\x14\x67\xfa\x20\xa1\x5f\x9d\x81\x50\xf6\x0e\x8c\xc8\xb2\x3a\xe6\x8f\x36\xed\xf9\xce\x2d\x17\x77\x06\x4d\x8f\x9a\x45\x9e\x73\x91\xb6\xd1\xd8\x63\x77\x36\x59\x2c\x5e\x1c\x99\xd6\x5c\x5f\x86\x11\x6d\x26\x18\xa9\xb7\xdb\x5b\xc6\xa2\xfd\x9b\x46\x6e\xdc\xd6\xf3\x95\xff\xb4\x10\xa3\x07\x36\xef\x49\x76\x8c\xb5\xd8\x59\x9c\x9b\xd6\x58\xe5\xf9\x1f\x23\x0e\x49\xc8\x4f\xe5\x29\x60\x07\x3b\xb2\xc5\xa0\xa0\x79\x38\xcd\x0d\x15\x56\x00\x4d\x21\x50\x54\x44\x02\x15\x2a\x86\x67\x28\x20\x42\x4e\x51\x60\x79\xfe\xd7\x53\x08\xfb\xd5\x5f\x52\x25\x45\x3d\x35\xde\x54\xb5\x24\x97\xf1\xdc\x04\x54\xa7\xed\xb2\xa0\xfc\xd1\x24\x82\xf1\xea\x99\xa2\xba\x95\x98\x1b\x24\xb7\x9a\x93\x07\x64\x35\xe7\x96\xec\x4d\x58\x69\x3a\x5e\xd0\xf3\x14\x08\x85\x52\xa8\x6c\x22\x72\x51\xa8\x5e\xcd\xd6\xd6\x42\xae\x3e\x14\xca\x07\xa6\x29\x85\x56\xcd\x5f\x55\x65\xd2\xa7\x8b\xc2\x24\x71\xee\x32\xd9\x9b\xf2\x4a\x93\x5d\x72\x43\x56\x1e\x90\x21\xeb\xde\x7d\xf6\x32\xc1\x67\x42\xa1\x50\x3d\xe4\x6a\x6b\xd5\x6c\xbd\xfa\xf3\x0f\x5f\x26\xaa\xa7\xac\xcb\x7f\xd3\x6e\x38\x67\x99\xb2\xda\xf3\x43\xfa\xbb\x7e\x51\x29\x0b\xad\x1a\xdc\x0f\x55\x34\xa5\x5d\x6b\xdb\xfc\xdb\x84\xce\xc4\x34\x07\x79\x69\xba\x9f\x63\x8d\x90\xf9\x2b\xab\xa0\x11\x84\xc2\x6e\x17\x67\x05\x91\x0f\x35\xa0\x68\x89\xa4\x8e\x64\x4a\xc1\x34\xa2\xde\xba\x5d\x56\x5d\x5c\xca\x86\x1a\x38\x5e\x27\xc2\xb9\x50\x90\x73\xeb\x41\x11\x42\x41\x8a\x31\xc5\xf4\x43\xda\xed\x22\x2f\x87\x88\xc5\xcc\x32\x82\xec\xa9\x0d\x36\x44\xe5\x3f\xa8\x0f\xf7\x6f\xd2\x1a\x68\x00\x93\x79\x5a\xa1\x36\xcf\x83\x8b\xc7\xb7\x6f\x30\x1b\x39\xd2\x4a\x5c\x02\xc3\x58\x1d\x35\xb5\xf5\xe2\xfe\x1f\xc4\xe1\x55\x9b\xd1\x44\x3c\x6c\xad\xea\x21\x04\x5e\xb0\x9a\x8c\xc4\x83\x25\xb3\xba\x6f\xd6\x0b\x07\xa4\xc6\x7a\x9f\xd3\xc6\xb0\x82\x60\xf9\xdd\x09\x8b\x93\x01\x4c\x38\x96\x65\x19\x0c\xec\x2f\x65\x61\x97\x20\x77\xcd\x92\xc4\xab\x45\xe9\x15\x40\x6e\x62\x31\x0b\x27\x04\x81\x01\x20\x0c\x21\x58\xd9\x69\xb1\x88\x57\x7b\xc3\xf3\x2d\x16\xeb\x4e\xb3\x75\xf7\x21\xc2\xb0\x2c\x03\x98\xe5\xf9\xc2\x7e\x9c\x4c\xb2\x0a\xea\x2f\x6b\xd5\x4e\xe7\xec\xeb\x28\x2f\x71\xb7\x1f\xac\xc0\xf1\x1c\x75\x85\xcd\x15\x14\xd6\x74\xc8\xf5\x02\x27\x87\x4c\x4a\xe2\xe4\x7c\x51\x92\x85\x8b\x37\x69\x35\xdd\xf4\xf7\x6f\x3f\x73\xcc\x88\x0d\x97\x18\x05\xc1\xc4\xb6\x8c\xb4\xaf\xd9\x01\xb3\xa9\x21\xd9\x8f\xe1\xd3\x92\xf8\xb0\x28\xc1\xdd\xea\x3d\x5a\xca\x63\x82\x0c\x07\x64\xe1\x16\x51\xfa\xcf\x27\x7e\xb5\xcf\x50\x63\x3a\x60\x06\x6c\x64\x7d\x8d\x1b\x87\x7e\x22\x89\xb7\x08\xb2\xfa\xd1\xaf\xe8\xa0\xc6\x80\x92\x53\x88\xbc\xc2\x21\xb4\x59\xf7\xb3\x5e\x22\x31\x63\x0c\x5d\x1c\x33\x69\xf7\x2c\x1d\xa2\x37\x9d\x4a\xc6\x48\x34\x66\x48\x25\xd3\x99\x12\xaf\xc9\xcf\xd0\xee\xd3\xaa\x51\x70\x25\xc9\xb8\xfd\x1c\x79\xe5\xfb\x27\x24\xf1\x36\x41\x1e\xb8\x69\x78\x7e\x0d\x6b\xb7\x5e\xc2\xdb\xac\x46\xbc\xeb\xe6\x70\x78\xc5\x4d\xfe\xf0\x70\x32\x1d\x6d\x5f\xd6\x31\xd0\x1c\xab\xb1\x3f\xf7\xa0\x2c\xdc\x26\x4a\x5d\x97\xcd\xeb\x91\x38\xbb\x65\x85\xc1\x2a\x0a\xc4\x9d\xe9\x3b\xbf\x65\xd3\xf5\xf6\x96\xf0\x60\xac\x23\xd5\x39\x92\x59\x10\xf6\xc2\xa6\x4f\xfc\xd2\xfb\x45\xad\x35\xbe\x68\x6c\x6b\x4f\x78\x38\xa7\xe3\x36\x13\xc6\x66\xbc\xc5\x6b\x58\xbb\xdc\x17\x6f\x68\x76\x3b\x6d\x52\xa8\xb6\xad\xb9\xab\x7b\x49\xf3\x1d\x2f\xfb\xff\x55\x90\x25\xf1\x29\xae\x21\xd8\x62\xe3\x24\xc7\xbd\x56\x20\x26\x22\x85\xea\xdc\x6b\xe7\x7b\xdb\xa2\xb5\x21\x59\x72\xb8\x3b\x22\x7d\x73\xd7\x15\xfa\xec\x66\x56\x41\x7d\x45\x1a\x5c\x04\xde\x55\xf0\x14\x1c\x45\xd1\x92\xf2\x70\xa6\x44\xc0\x44\x8a\x74\x78\xd1\x14\xbc\x15\x5c\xee\x44\xdc\x45\x6e\x96\xc4\xc7\xdc\xaf\x7e\xfe\x51\x68\x14\x4d\x06\xe7\x77\x6d\x46\xf5\xa5\x9c\x51\x16\x76\x1e\x7c\xc8\xa5\xae\xa1\x3c\xb5\x07\xbb\xfe\xfd\x1e\xad\x68\x84\x7e\x7f\xbf\xef\xb0\x3f\x21\x4a\x4c\xcb\x76\x51\x3a\xf2\xaf\x8e\xa7\xd5\x07\x6c\x92\x64\x81\xab\x7e\x64\x14\x0e\x08\xf2\xda\x95\x92\xb8\x5d\x94\x76\xc9\xc2\x47\xb5\xb4\xdb\x45\xa9\x77\x95\x44\x41\x0d\x11\x99\x62\x15\x8d\x5a\x0f\x86\x0a\x40\xfe\x05\x98\x92\xd2\x70\xd3\x49\x8e\xb8\x5b\x76\xb9\xfb\x20\x23\xd3\xb0\x8b\x87\x44\x71\x98\x39\xcb\x03\xce\xc1\xe1\xf5\x5f\x10\x64\x95\xda\x28\x42\x40\x3f\xff\x87\xfa\x6d\x83\xc1\x24\x7d\x47\x36\xfd\x44\x0e\x9b\x9a\xf9\x6f\x1b\x9c\xdf\xb6\x9b\x8c\x06\xf5\xfb\x3f\xa1\x63\xee\x57\xd0\xa0\x9f\x65\x49\x84\x25\x92\x78\x89\x20\xaf\x91\xc4\x1d\x82\x8c\x07\x6c\x36\x9b\xa4\x9e\x1f\x39\xdf\xb3\xce\x0e\x8f\xc8\x36\xd1\x9e\x7f\x56\x16\x76\x88\xd2\x1a\x59\xb8\x44\x94\xd4\xaf\x0a\x72\xc1\xef\xbd\xbe\xef\xe8\xa4\x7b\x75\x6d\xe0\xc7\x91\x6d\x5a\xc9\x4a\x83\xb1\xfc\xe9\x94\x42\xfa\xac\xc6\xc8\x37\x8f\xaa\x39\xc8\x8e\xc2\x55\xf9\x1f\xa8\x5f\x80\xf7\x29\xc3\x92\x97\x85\x47\x8b\x22\xea\xa2\xdc\x1a\xd7\xfe\x80\x5c\xf2\x83\xbd\x6a\x16\x1e\x52\xf7\xff\xf7\x75\xd5\x8a\x6c\xd7\x49\xe2\x7d\x82\x8c\x77\x8b\x52\x85\xff\x21\x03\xb2\x20\x1b\xaa\x41\x75\xe8\x4a\x84\x40\x0e\xc9\x2e\x87\x3b\x99\x96\x33\x41\x77\x30\x11\x0d\x69\x11\x0e\x57\x21\x42\xdf\x23\x12\x3a\x62\x48\x88\xe8\x9e\xa4\x49\xa9\xb4\xe5\xf9\x90\x14\xfb\x25\x28\x4f\x3b\xbb\x78\x52\x62\x38\xf0\x89\xb8\x0b\xe3\x15\x27\x06\x01\xe0\xda\x90\xfa\x7a\x00\x1e\x3a\x1c\x5a\x08\x27\x96\x3d\xbc\x02\x00\xae\x0a\xaa\x3f\xa1\xf8\xdd\xaf\x3d\xc2\x7b\x4e\x78\xf8\xcf\x9d\x7a\x94\xf7\x9c\x30\xdb\xf1\xd8\xcb\x5a\x7d\xbe\x18\xbc\x4b\x3b\x5d\x71\x01\x6b\x32\xd9\x0e\x79\xd9\x0b\xe1\x92\x8b\x79\xcf\x7e\x0f\xbf\x19\xae\xb8\x88\xf5\x1e\xb2\x99\x4c\xec\xfa\xab\xb4\x24\xf7\x34\x7c\x59\x94\x60\x0d\xb4\xaa\xaf\x02\x03\xc0\xc2\x17\x14\x45\xc9\xbf\x0a\x6d\xea\x6b\xc0\x02\x30\xf0\xa4\xa2\x04\xb2\xa2\x94\x3f\xee\xf1\xe0\x1d\xf9\xe3\x1e\xd1\x84\x77\x50\x5a\x5b\xe7\x2c\xc3\x3a\xab\x60\xf1\xa8\xc7\x61\x87\x47\x3f\x5a\x04\xab\xfa\x58\x21\x81\xb6\xbf\xed\x9c\x42\xcc\x5b\xac\x82\x12\xe8\x3c\x8a\x39\xe4\xe2\xfd\xc0\x8b\x0c\xef\x0c\xa5\x1a\xa2\xce\x90\xbd\x21\xd2\x0a\x99\x44\x3c\x63\x4f\x44\x42\xf6\x48\x2b\xa4\xdc\xf1\x4c\x2a\xe1\x4c\x27\x52\x09\xa7\x9f\x90\x64\x8c\x69\xa0\x20\xa4\xf1\x3e\x4e\xbb\x10\x41\xbb\xe8\xe3\x98\xbb\xa5\xfb\x76\x5f\x2b\xf0\x89\x65\xd7\x1e\x58\xf9\xc0\x70\xcb\x03\xd2\x79\xf2\x0f\xea\xaf\x8a\x1b\x6c\x9c\x49\x18\xba\xea\xd5\x6c\xf0\x81\x95\x4d\x0f\x2c\xbf\x71\x47\xef\x29\x7f\xdb\xa2\x9e\x75\xf1\xe5\x06\xc3\x9c\xc8\xfc\xd9\x73\x63\xb3\xfd\xf2\xa2\x9a\xc6\x9e\xf8\xe2\xd6\xb9\x3c\xdb\xdd\x30\xd0\xd6\x1d\x69\x94\x88\xf2\xd5\x21\xdf\xb1\xc3\x8b\x2e\x5f\xd8\xe1\x62\xa6\x26\x60\x12\x4d\xc1\xd7\x12\x70\x2f\x40\xfd\xfc\x47\x00\x26\xff\x8e\xdf\x9b\xe4\xeb\xbb\x2f\xce\x3f\xd8\xd8\xd9\x58\x63\xe1\xb0\xfa\x2f\x40\x58\x8b\xcd\xdb\x10\x83\x7f\x04\x13\x41\xb7\x89\x03\x50\x5f\x04\x20\x06\xd1\x5d\x1f\xd3\x71\x31\x28\xb6\x44\xc1\x5e\xd2\xe5\x06\x97\x9b\xd5\x6d\x06\x2b\x96\x64\x06\xb9\x44\x38\x2e\x8a\xf9\xc7\x3a\x9b\x70\xa0\x04\x11\x11\x60\x10\xfc\x54\x14\xd5\x1d\xa2\x2b\xd0\xd4\x39\x31\x5e\x44\x7c\xd0\xfd\x79\x94\x9e\xdb\x84\x3a\xd1\x79\x5a\x9b\xba\x83\x76\x97\x9b\x4c\x7f\xb4\xdd\xe1\x92\xcf\x01\xd3\x5d\x7d\xcd\x9e\x14\x45\xb5\xc9\x25\xce\xaf\x2c\x4a\xe7\x0f\x66\x82\xa2\xa8\x0e\x33\x8d\xa2\x4b\x2b\x72\xfe\xb9\x72\x69\xf3\xe3\x4d\x9d\xf9\x40\x69\x6f\x06\xe2\x4c\x41\x8d\xfe\x6c\x98\x42\xdc\x3e\x0e\x21\x13\x6a\x44\x03\x68\x25\x42\x90\xe8\x80\x48\x2a\xc4\x3b\x38\x1e\x74\x1c\xa6\xe2\xf6\x49\x5f\x74\xe8\xae\x8a\x75\x06\x53\x90\xee\x87\x54\x03\x17\xe2\x5a\x81\x7a\x31\x00\xce\x0a\x4e\x2d\x61\x4a\x76\x06\x53\x89\x68\x88\x4f\x68\x67\x39\x21\x33\x8f\x7e\xe9\x3c\x0b\x66\x08\xcf\xe4\xdf\x35\xa9\xff\x66\x12\x2c\x66\x35\x67\x35\x18\x5c\x39\xaa\xcb\x92\x13\x25\x32\x3f\xff\x75\xd8\x65\x31\x9a\xb1\x91\x58\xa4\xb7\xae\xc7\x19\xf5\x6e\xce\x6a\x16\x8d\xce\x7f\xbc\xa2\x8e\x0f\x76\xfc\xb5\x63\x50\x7d\x63\xe1\x9b\x0f\xbf\xc9\xec\xf8\x79\x87\x8d\x71\x40\x83\x65\xc2\x5f\x04\x81\xb2\xc9\x0e\x96\x42\x6f\x9c\x1e\x93\x3e\xfa\xfb\x0b\xb1\x5d\x32\x1a\x09\x90\x6b\x7e\x77\x41\xfe\x4f\x06\xc9\x8c\x31\xde\x43\x3e\x32\x3a\x7a\xe4\xc8\xe8\x28\x3e\x96\x1f\xd5\x65\x3f\x95\xf5\x4e\x6a\xf5\x0e\x97\xeb\xcd\x9e\xb5\xde\x50\x55\x33\xf2\x81\xed\xf0\x21\xea\xfd\xe0\xb4\xda\xc9\x67\x6d\x85\x52\xb5\x7f\x3d\x53\xad\xd5\xc9\x72\xf5\x98\x03\x67\x34\x81\x89\x10\xd8\x83\x58\xad\xce\x94\x3f\xab\xed\xcb\xfe\x3f\xda\xfe\x03\x3e\x8e\xe2\xfc\x1f\xc7\xe7\x99\x6d\x57\xf7\x6e\x6f\xf7\x76\x4f\x77\xa7\xeb\xb7\xab\x7a\x92\xae\xad\x7a\x77\x91\x2c\xdb\xb2\x70\x2f\xb2\x42\x71\x05\xdc\x00\x57\xcc\xd9\x86\x04\x48\x30\x60\x7a\x17\x60\x20\x14\x27\x04\x4c\x71\x28\x51\x20\x10\xc2\x27\x94\x84\x10\x42\x02\xc1\x49\x0c\x09\x84\x9e\x02\xd8\xba\xf5\xff\xb5\x7b\x27\x5b\x36\xa6\xe4\xf5\xfd\xff\xc0\xda\x9d\xb2\xbb\x37\x33\x3b\x3b\xf3\x3c\x33\xcf\xf3\x7e\x37\xa0\x1e\x34\x0f\xa1\xf8\xd7\xbc\xe2\x63\x57\x0c\x8e\x37\x84\xf8\xa6\x38\xde\x7f\xe2\x2a\x93\xa1\xf1\x2b\x0b\xba\xaa\x9f\x33\x3a\x72\xce\x88\x68\x05\xa2\x85\x11\x23\x72\x18\x19\x11\xc4\xba\x86\x4e\x54\xeb\x71\xd0\xef\x9f\x7e\x43\xb0\x30\xdd\x8d\xd5\xdf\x71\xb4\xfe\xc7\xd7\xf2\xab\xdb\xe3\x4b\x2b\x28\xdf\x10\x27\x8f\xa9\x80\x16\x3a\x71\x6b\xe0\xe1\xe3\xea\x7c\x4c\x6b\x1c\x6d\xa7\xd0\x91\xaa\xac\x3d\x51\x53\xc0\xda\x6f\x6e\x00\xa3\xcf\x53\x2f\x16\xfb\x7c\x17\x9a\x8d\x50\xdc\xd8\xe4\x37\x76\xee\xbf\xba\xcf\xc7\x05\x96\x30\xd8\x1e\xd4\x82\x1c\xaa\x46\x59\x38\xe2\xf5\xa4\x7f\x00\x29\xce\x60\x23\x61\x68\x83\x34\x82\xa3\x3a\xe7\x36\xa5\x5b\x7b\xba\x93\x13\xf3\x37\x7f\x45\xa5\x3f\xf4\xd6\xf7\x9f\x3d\xa1\x35\xe1\x71\x29\x0e\x67\x5c\x9e\x79\x9a\x13\xbb\x67\x54\xad\xf8\xee\x65\x67\x6c\xde\x1d\xd0\x2a\xef\x02\xcc\x98\x5c\xad\x03\x23\x9b\xdf\x6a\x5b\xd1\xbb\xb6\x2f\x3b\xfb\x44\x75\x56\x5b\xd7\x9f\x31\x50\xe7\x34\x31\x6b\x18\xd2\x7e\xf6\x1c\xc9\x7f\xe9\x69\xcb\x77\x3d\x81\x6b\xd6\xae\x85\xfb\x19\x0f\xe5\xb4\xd9\x5d\x8d\xb3\xf7\xe5\xd7\xa2\x2f\xd5\x5d\x35\xac\xa1\x8f\xd6\xfd\xeb\xc7\xb9\xe3\xaa\xc7\x7f\x5d\x73\x7c\x8b\xba\xbf\x3c\xbe\x7e\x4f\x7f\x4d\x43\x90\xc5\xca\x1f\xba\xe7\x44\xb5\x1f\x3d\xbe\x9a\x54\xea\x84\xed\x31\x86\x1b\xd9\x5e\x5c\x87\x5d\x38\xf6\xd6\x0b\x06\x1b\xc7\xaf\xfb\x51\x02\x23\xba\x45\x46\x34\xb8\xc4\x68\xa6\x12\x47\x0c\xd6\xdb\x02\x9c\x54\x01\x92\xb0\x15\x1b\xd4\xb9\xa9\x64\x80\x72\x0b\x2c\x30\x2c\x2e\xf2\xf2\x7b\x7d\xf1\xb8\xcf\x2b\x0f\xcb\x5e\xcd\xd8\xe3\x85\x90\x57\x26\x87\x55\x07\x91\xe0\x38\x87\x62\x6e\x6c\xbf\x20\xd6\xc7\x75\xde\x38\x67\xea\xe6\xa8\x57\x8e\x95\x78\x96\xd5\x75\x87\x5d\x5e\xb3\x99\xb1\xfa\x05\xde\x9b\xe8\xa9\x09\x3b\xcc\xc0\xf3\x2e\x82\x35\x91\xe0\x9e\xb6\xd6\xd8\xb5\xf1\xc5\xe3\xd8\x77\xc4\x81\x43\x96\xbd\xb3\xdb\xaa\x42\x7d\x2d\xf5\x2d\x0d\xf1\xd5\x13\xfa\x70\xd0\xe7\xad\x04\x88\x7b\xf1\xb6\x92\x38\xc6\x6b\xdb\xe7\x84\x5d\xcd\xf1\x0a\xa5\xaa\x59\xe0\xdd\xc1\x64\x59\x73\xc0\x23\xf7\x55\x45\x68\x8f\xc0\xae\x45\x47\x78\xd3\xdb\x0d\x1f\x33\x5f\x11\x87\xf1\xc8\xcb\x3b\x5e\x83\x8f\x8b\x6e\x43\x1b\xc6\x52\x00\xbb\x05\x03\xce\x38\x81\x15\x83\xbc\xdf\x00\xd1\x34\x9a\x44\x6f\x8f\x26\x42\x94\x44\xc6\xf8\x63\x84\xaf\x6a\x88\xe5\x2a\xac\x99\xa6\xfd\x93\x34\xb1\x84\xcb\x25\x80\xd9\x11\xae\xe9\x49\x78\x79\xc1\x6f\x65\xcc\x66\xaf\x2b\xdc\x5d\xb7\xcc\x53\x12\x93\xbd\xd1\xcd\x53\xe7\xdc\xd8\xc9\xf5\xc5\x2e\x68\x6f\x34\x2b\x0e\x8e\x4b\x10\xc4\x58\x4b\xe4\xdf\x2e\xb4\x81\xd1\x1e\x3f\x6e\x99\x3b\x6d\x2d\x2b\x78\xe8\x78\xd9\x54\xd9\x13\x68\x2e\x4b\x06\xdd\xbc\xd0\x5c\xa5\x54\xc4\x9b\x5d\xe1\x39\xed\x6b\x31\x8e\x97\xe0\x6d\xde\x38\x40\xa5\xd7\x17\xc4\x7d\x13\x56\xc7\x1b\x5a\xea\x5b\xfa\x42\x08\xd9\x8e\xac\x65\x98\x8d\x7d\xa4\x4a\xd4\x82\x16\xa2\x53\xd1\x79\xe8\x07\xe8\x66\xf4\x00\x7a\xca\xe0\x35\x89\x46\x18\xb7\x98\x4a\xaa\xa9\x4c\x3a\xe2\x8e\xbb\xa3\x5c\x94\x8b\x66\x28\x2e\x9a\x29\x6e\xe2\xa5\x8a\xcb\xf7\x1c\x55\xb4\x11\x72\x47\x39\x5d\x7c\x4c\x4a\xa2\xe4\x16\xc6\x58\x62\x5a\x20\x6d\x18\xc1\x96\x42\xd4\x2d\xa4\x92\x6a\x3a\x9b\xce\x80\x5b\x88\xb4\x40\x3a\x09\x69\x83\x96\x2e\x1c\x32\xd0\x49\x8b\xe0\x97\x21\xa3\x9f\x01\x1f\x65\x94\xa8\x01\x86\xe9\x4e\xc5\x33\xe9\x02\x8d\x4f\x29\x14\x17\xee\xa4\x14\x17\xe5\x8a\xe5\x88\x16\xcb\xf1\xa5\x05\xbc\x6b\x4a\x39\xa7\x93\x2b\x7d\xb4\xb3\x33\xff\x4c\x7f\xef\x34\xf8\x49\x97\x12\x0f\x9b\xe9\x4e\x00\x56\x10\xa1\x8d\xb1\x95\x47\xc3\x5d\x5d\xa1\x58\xb9\x8d\x39\x84\x09\x9b\x2f\x93\x2e\x75\x0b\xa5\x4b\x7c\xee\x0b\x22\x1e\x1a\xb4\x6d\xed\xed\xd8\xcd\x5b\x3a\x2b\x2f\xd4\xde\xd7\x3e\xb8\xb0\xaa\xc3\x22\x08\x96\x8e\xca\x8b\xb0\x7c\x51\x65\x87\x45\xc8\xdb\xe7\x4f\x49\x65\xa6\x31\x21\x53\xd4\xda\x0b\x61\x77\x69\x5d\xca\xe7\x76\xfb\x52\x75\xa5\xee\x87\xba\xba\x0c\x38\xeb\x2e\xda\x1a\x8a\x95\xc3\x67\xe3\x17\x78\xde\xbd\x29\xe9\xdc\xef\xbc\x37\x92\x4a\xfd\x63\xa2\x36\x0f\xee\x9a\xb8\x55\xbb\xbc\xac\xda\xcf\xc5\x21\xa2\x7d\xea\xc1\x8e\x20\x78\x56\xed\x4a\xbb\x2b\xca\x63\xf0\xc1\xad\x65\x15\xee\x87\xcd\xa5\xac\xe8\x2a\x93\x7d\x4d\xdb\x9a\x7c\xb2\x5c\xda\xd0\xd7\x91\xf2\x82\xcd\x6d\x25\xea\x6f\x4c\xa5\x6e\x4c\xe7\x89\x9f\x9c\x54\xd5\x44\x39\x1c\x54\x53\xd5\x9c\x3d\xf7\xcf\xac\x6c\xd6\xc3\xcd\x95\x33\x89\x26\x28\x7b\xfa\x69\x69\xa1\xb4\x54\xfd\xd5\x86\xed\x8d\xa5\xb2\x5c\xda\x68\x9c\x7c\xcd\xb0\x56\x7b\x3b\xe8\xc4\x1e\x70\x6a\x7f\x8a\xbb\x7c\xd5\x60\x3a\x76\x0d\xd7\x8a\x7c\x87\x11\xf5\xb6\xe1\x2f\x3b\xd6\x3f\x16\xa0\x53\xd0\xb9\xe8\x22\x74\x03\xfa\xb1\xa1\xa7\x47\x23\x0a\x97\x4d\x25\x29\x77\x34\x93\x4e\xc6\x53\x99\xb0\x3b\xc5\xa5\xc2\x27\x78\x2d\x63\x2f\x2f\x13\xe5\x52\x19\xe3\xe5\xc5\x33\x51\xa3\xc3\xb4\x40\xea\x4b\x2f\x56\xcd\x42\x26\x1d\x29\x05\x21\x69\x30\xe0\x32\x74\xc8\xe8\x22\x99\xb4\xd1\x2b\x42\x46\x0f\x81\x14\xc1\x45\x39\x59\x91\x95\x14\x3f\xd6\xf7\x0a\xfd\x4c\xef\x7b\xf1\x13\xf4\x50\xe2\xff\x14\x49\x14\x25\x05\x06\xe6\xcf\x1f\x6d\x5c\xa9\x3d\xb7\xfc\x54\x08\xcd\x9b\x17\xf0\xb9\x08\x98\x67\xb2\x25\x6a\xb3\xb0\xc7\xcc\x65\x93\x95\xf3\xe6\x55\xd7\x66\x39\x33\x0c\x2c\xc0\x4c\x38\xf1\xa0\x4f\xe9\xea\x56\xfc\xa5\xca\x84\xc9\x31\x17\x81\xf3\xc3\xb3\x67\xe3\x97\xbc\xec\xdc\xc6\x47\xf3\xde\x47\x1b\xe7\xd9\xbd\x5e\x76\x6e\xd3\x23\xf8\x1d\x23\x3c\xea\x5d\xb2\xf1\x54\xb6\x26\xee\x5f\x31\x09\x1e\xf6\xcb\xdd\x5d\xb2\xdf\x2f\x77\x75\xcb\x7e\x98\xbe\x20\x93\x4c\xd8\x4d\x0b\x80\x70\xf9\x02\x10\x7b\xa5\x4b\x84\x6a\xb1\x3b\x91\xe8\xbe\x7a\x70\x30\xff\x4b\xf8\x50\xfb\x6e\x85\x9b\x08\xc1\xe9\xda\xc6\x3a\x4f\xbc\x65\xf0\x99\x1e\x6f\x7d\xf6\xf5\xfc\xf2\x5a\x55\xf5\x9d\x64\x4f\x59\x62\x13\xe6\x2c\x9d\x1e\x4f\xa5\xe2\xd3\xf7\x4c\x8f\xa7\x32\x3e\x9f\x99\x78\xea\xb7\x13\x26\xfc\x76\x62\x7e\xce\x7b\x67\x35\xf5\xd3\x6e\x37\xdd\xdf\xb4\xfa\x43\x3d\xcc\x08\x02\xd3\xdf\xb4\x9a\x64\xb5\x35\xda\x27\xe0\xe8\xbd\x78\xe9\x4c\xed\x8b\x89\x3f\x9e\x11\x4f\xa5\xe4\xfe\x1f\xf7\xeb\x0f\x19\xd0\xec\x6a\x6b\xdc\x93\x82\x8b\xb5\xcb\xc3\x58\xac\x84\x73\x0b\xb6\x94\x39\x6a\x33\xf5\x5f\xc4\x23\x05\x21\xa0\x0b\x1a\xb4\xca\x27\x95\x31\x85\x19\x44\x06\xdc\x63\x8b\x32\x90\x05\x3d\x11\xcf\xb2\x7c\xe6\x93\x3f\x72\x0b\x96\x3c\xc0\xad\x36\xab\x59\xfa\xa8\xcc\x4b\x3c\x6f\xb5\xe6\x3f\x86\x7e\xab\xc5\x22\x7e\x54\xe1\xd1\xf6\xb8\x30\x94\x28\x9f\x88\xc4\x69\x2e\xad\x37\x11\xe1\x61\x04\x40\x12\x1d\x8e\x6a\x38\xd5\xe9\x1e\x9d\x0f\xf9\xeb\x04\xce\x51\x8d\xcf\x0c\x11\x3b\xab\x8f\xe5\xce\xe7\x8f\xf0\x8b\xc8\x95\x60\xec\x20\xb8\x09\x5a\x12\x9b\x20\xa9\x82\x91\x02\x22\x18\xb1\xac\x02\x19\xc8\x4a\x5f\xda\x7c\xd9\xea\x0e\x3e\xea\x32\x31\xa6\x73\x7f\x61\x36\x9b\x9c\xfb\x82\x3c\xa1\x32\xdc\x63\x01\x5e\x3b\x0d\x80\x12\x42\x8f\xba\x18\x93\x59\x1b\x85\xeb\x4c\x7f\x3a\x66\x91\x9a\x80\x37\x23\x56\x1b\xf7\x07\xd0\xee\x64\x59\x7b\x8c\x98\x61\x8b\xe6\x15\xac\x85\xa3\x36\xbb\x03\xde\x00\xfc\x8a\xf3\xc2\x2f\x63\xd6\x20\x0b\x83\xc8\xff\x22\x6c\x20\x22\x55\x03\x9f\x24\x83\x90\x0c\x50\x45\x1e\xfc\x52\x10\x19\x16\x1c\xc0\xd2\x51\x3a\x2c\xc7\x6a\x70\x61\x26\x49\x80\xd2\x02\xb2\xc1\x37\xdf\x4a\xa7\xb2\xf8\x97\x70\x40\xf3\xef\xfb\x21\x34\xf4\xf4\x40\x88\x0d\x7b\x42\x01\x96\xe6\x15\xc6\x64\x06\xe0\x99\x18\xcb\xb2\x81\x90\x27\xec\x08\xc2\x21\xed\xc2\x97\xb4\x97\x6a\xeb\x62\xb1\x78\x87\xe7\xcb\x57\xb0\x21\x38\x04\xd7\x1e\xcc\xc3\x52\x33\x45\x12\x04\x6d\x71\x4a\x0e\xba\x64\xa1\xda\x7e\x79\x79\xd9\x85\x97\x5f\xae\xce\xe3\x38\x87\xe4\xb0\xd0\x04\xc1\x63\x33\x41\x92\x94\x25\x54\xf2\xa5\x7c\xa7\x9e\xef\x42\x05\x1c\x2c\x7a\x84\xba\xd8\xd8\x5b\x95\x90\x0f\x05\x11\x32\x93\x6e\x70\x2b\x4c\x06\x32\x12\x64\x24\xd5\x6d\xb6\xc1\x2e\xf8\x50\xbb\x47\x13\xa9\x2a\x4d\x04\xd0\xa4\x2b\x60\x36\x00\xcc\xc9\xcf\x80\xd9\x9a\x4b\xfb\x11\x95\x80\x01\x4d\xd2\xee\x86\x39\xf0\xae\xf6\x23\xcd\x45\xb4\x68\x2f\x69\x7f\x83\x36\xed\xc0\xe9\xda\x9f\x0c\x3e\xf6\xf8\xe9\x43\xe0\xc7\x00\x58\x3b\x40\xfe\x41\xfb\x9b\xf6\x32\xb0\xda\xa7\xda\x27\xda\xcf\xa1\x94\xd8\xaa\xfd\x5c\xfb\x14\x6a\x11\x8d\xac\x87\x11\xf5\x1f\xc3\xc6\xc4\x8a\x1c\xc5\xf2\x20\x2a\xcc\x45\xb9\x30\x17\x8d\xab\x14\x03\x2a\x18\x7f\x04\x30\x66\xc8\x84\xdd\x94\xf9\xd0\x6d\xc3\xd4\xcd\xc3\xa3\x03\x61\xc2\x11\xce\xcf\xed\xc2\xaf\x76\xe5\xff\xbd\x04\x2f\x59\xf2\x3a\xbc\x99\xd3\xa2\xf9\x07\x88\xd0\x10\xec\xcf\xe7\x70\xae\xea\xa6\x3b\x6e\xc4\xde\x5d\xda\x9e\xcb\xf1\xc3\x9b\xf3\x87\x37\x13\x9b\xf3\xe7\x0d\xe1\x6d\x07\x6f\xbd\xe5\x96\x13\xd8\x5e\x4c\x47\x4b\xc7\xe1\xf6\x17\xc1\x68\xc7\x70\x6e\x63\x11\x99\xc5\x06\x65\x2a\x21\x0a\x74\xa1\x0f\x04\x88\x6c\x52\xd4\xa5\x27\x50\x5b\x09\xd9\x40\xb1\xd5\xe5\x08\x02\x39\xc7\x8d\x73\xce\xa3\xc3\xdc\x98\x99\x46\xe8\x1d\xed\xd1\x77\xde\x81\xc9\x30\x90\xed\xcb\x66\xfb\xb4\x49\xec\xf7\x27\x6f\x9c\x55\x9a\xec\x13\xac\x0e\x4a\x6f\x39\xca\x61\x15\xfa\x92\xa5\xb3\x36\x4e\xfe\xfe\x57\x67\xe1\x33\x29\xcb\x81\x97\xe7\x6a\xd9\xb9\x2f\x1f\xb0\x50\x46\x18\x9e\xd7\xc3\x58\x34\x0c\x3a\x60\x77\xe1\x57\xde\x31\x7e\x24\x9b\xfb\x96\x8f\x3d\x36\x4b\x3b\xf3\xcb\xcf\x37\xc2\xc7\x7c\xd7\x0e\x03\xe7\xe3\x78\x7b\x99\xd4\x11\xcf\xd7\x31\x6f\x15\x83\xea\xa8\xf0\xa5\xc1\xf5\x5b\xee\xdf\xb2\xe5\x7e\x7c\xbf\x71\x1a\xe3\x31\x2a\x7c\x81\xa3\x3f\xd4\xd3\x8a\xff\xc6\xff\x0e\x46\x66\x83\x07\x9c\x0f\x53\x29\x33\xa4\xd4\xf0\x31\xa6\x5a\xe8\x57\xda\x99\x38\x3b\xa8\x65\xb4\xcc\xe0\x32\x6c\x81\x43\xc7\x23\x25\xec\xd2\x5e\xdc\x8f\x1f\xcc\x4f\x1d\x86\xba\x13\xf9\x27\xf7\x53\xdb\xa8\xdb\x91\xc5\xf0\xae\xec\xd2\xfb\x02\x88\xb4\x92\x80\xac\x9a\x0d\x80\x94\x00\x86\x05\x29\x00\x6a\x2b\xf0\x09\xac\xc4\x28\x16\x33\x01\x2c\x89\x6a\x2b\xe6\x0d\x7f\x08\x59\x49\x10\x8a\xac\xb4\x81\x18\x52\x03\x40\xf3\xb4\x81\xbb\x10\x97\x95\x04\xa9\xe7\xb4\x92\x6a\x56\x8d\x51\xa2\x14\x00\xa2\xc6\x74\x76\x46\x29\xf5\xcb\xb1\x1e\x75\x15\xfb\xec\xc9\x6d\x53\x08\xf2\x8a\x85\x0b\x36\x1d\x10\x26\x57\xd5\x69\x6f\x6a\x1f\x54\x26\xda\x5d\x81\x85\x6a\xf3\x81\x37\xda\x32\x0b\x67\x9b\x1c\xf6\xaa\xd8\xec\x97\x9e\x59\x9a\x98\x34\xd0\x2e\x94\x84\x68\xd7\x5b\x58\xdd\xef\xa6\x9d\x0f\x79\x67\x51\x55\x95\xe1\x51\xed\xfa\xcf\x77\x39\xdc\x76\x8a\xc1\xe6\xa8\xdb\x6b\x26\x4a\x23\xf5\xb1\xc0\xb9\x8f\xc3\x66\x28\xbf\xa1\xd9\x09\xf8\x8e\xb6\xbe\x10\x37\x30\xc0\xb9\x6c\x4d\xdc\xca\xb5\x55\xfe\x8d\x13\x16\xe4\x4c\xa6\x6b\xf1\x26\x5f\xd4\x6c\xaa\xa9\x63\x2c\x11\xaf\x3f\x6a\x66\x4a\xfd\x26\x53\x74\xd4\xe5\x3d\xad\xab\x47\xa8\xad\x21\x38\x93\x10\xc9\x44\x87\x7e\xe1\x34\x5f\x79\x25\x1d\xa9\x27\x1e\xbd\x4b\xf3\x04\xd2\x7e\x6e\xab\xec\x5b\x6d\x2b\x2d\xf7\xa5\xcd\xc9\xe7\x36\xdf\x37\xd9\x5b\x1d\x08\x38\xac\x09\x57\x7c\x4e\xa2\x4f\x68\x35\x70\x60\x0b\xef\xca\x64\x8c\xf6\x8d\x68\x5e\x81\xdd\x5a\x36\xa8\x88\xb3\xaa\xe1\xce\x6e\xb8\xea\xf3\x7a\xfb\xe8\x63\xa6\xae\x7c\x48\x01\xcc\xa7\xb3\xb2\x42\x87\x14\x07\x18\x1c\x86\x7a\xc3\x66\x15\x59\x91\x29\x9a\x29\xb4\x75\x80\x90\x44\x89\xd4\x75\x15\xd7\x97\x04\xc3\xfe\x81\x58\x25\x54\x2a\x33\x7b\x4d\x73\xcf\x5f\x41\x60\xb5\x7a\xe2\xa5\x0f\x0b\x5d\x4a\xd5\x0d\x77\x57\xc9\x5d\x6e\x7b\x22\x12\x78\xf6\xb7\xe1\x58\xb2\xde\x4a\x39\x6e\xd5\x96\xdd\x66\xa3\xbc\x8e\x9a\x9b\xbe\x78\x30\x12\x70\x7c\xcf\xcc\x55\xae\xfe\x83\xf6\xc9\xf9\x83\x72\x65\x8a\x34\x89\x31\x1a\x4c\xb4\xcb\xbe\xfc\x41\x20\x1e\xf2\x04\x83\x64\x2d\x94\x1d\xb3\x9b\x77\x7d\x65\x42\x14\x96\xbb\xa4\x6c\x4b\xe7\x99\xb6\x85\x5d\x75\x73\x85\xe0\x00\x34\xba\xbd\x34\x25\x08\x34\x53\x22\xf0\x1e\x86\x8a\x46\x28\xa6\x24\x4f\x30\x4a\x09\xb9\x62\x05\x6d\xbb\xbe\x7e\x86\x2f\x71\x0a\xdf\xb1\x02\xff\x32\x23\xaa\xe1\x36\x9f\x2d\xe2\x10\x6a\x03\xdd\x3f\x78\x3e\x46\xa5\x85\x88\xb5\x5f\xf0\x2f\xb0\x0b\xb2\x1b\xac\x90\x3c\x6e\x1e\x02\xd4\x7d\x38\x47\xea\xcd\x1a\x41\x28\x2e\xe9\xc3\x4a\x82\xc8\x70\xd1\x4c\x2b\xa9\x1a\x08\x83\x61\x77\x98\x13\x02\x58\xcd\x12\xf7\xf7\x4b\xf7\xcf\x5b\xb6\x67\xf5\xb4\xf0\x0f\x27\xaf\xed\xae\x15\x28\x60\xc8\x7f\xc3\x54\xed\x01\x7b\xa8\xab\x76\xda\x4b\x1f\x44\x5b\x01\xd7\x2f\xdc\xb0\xa1\x11\x87\x5e\xf3\xce\x59\xb4\x6a\x4e\x35\xc5\x68\x73\x47\xf3\x07\x03\xe9\x4c\x00\xf0\xf8\x7d\xfe\x02\x83\xac\x42\x47\xe9\x04\xce\x70\xe1\x4c\x98\x8b\x46\x18\x96\x60\xdc\x29\xe3\xb7\x5a\xe1\x4b\x7b\xa1\xab\x5b\xab\x9a\x62\xe9\x12\x0b\xc0\x61\xf4\xb8\x09\xa8\x92\xcc\x69\xdd\xdb\x2b\xe7\xdc\x70\xca\x84\xef\xc1\x6d\xe3\xdb\x6f\xca\x23\x22\x48\x65\xe5\x12\xec\x7c\x0a\x26\x5a\xaa\x66\x2f\x9b\x5d\x72\x87\x36\xd8\x70\xd6\x8a\x0e\x0c\xb5\x64\xcd\xb1\x7b\xa1\xc4\xe1\x76\x9c\xa7\x91\x81\xda\x23\x9e\x58\xa5\xc7\xff\x71\xda\xb5\xdb\x2c\x76\xd6\xa2\xdd\x64\x37\x99\x85\x22\x5e\x20\x20\xd9\xa9\xe5\x2c\x16\xc8\x39\x79\x9e\x34\xf6\x2c\x0e\x8d\xd9\x94\x20\x9c\xa7\x46\xf4\x67\x16\xed\x56\x8e\xc0\x26\xab\x45\x27\x31\x9c\x3f\xf2\x1c\xb7\xd3\x0e\x83\xfa\xd3\xe1\x14\x3b\xc9\xf3\x87\x0c\x03\x6e\x72\xbf\xec\x84\x9c\xc5\xa2\xe5\x9c\x45\x6e\x2b\x20\x18\x44\xe4\x8d\x67\x8e\xa1\xe0\x8f\x61\xe0\x4b\x05\xf0\x0c\x06\xe9\x25\x38\xae\x50\x78\xff\xb1\xbf\x71\x32\x6b\xd4\xa0\xc8\xb5\x45\xd0\x23\xc5\x67\x16\xf6\xa5\x8f\x45\xcf\x97\x40\xa4\x47\xf4\x22\x1c\x57\x2a\xbc\x83\xb5\x68\x37\xb3\xa6\xf1\x55\xd0\x6e\xb3\x1c\xb1\xc7\x5f\x43\x23\x24\x1b\x5e\x8f\x45\x75\x4e\x17\xd6\xa3\x11\x02\x67\x8a\xd2\xb6\x2e\xb3\x1b\x1a\x5f\x81\x23\x14\xc6\xb8\x55\x0b\x44\x77\x92\x20\x52\x6b\x94\x99\xdb\x72\x75\x0b\x66\x77\xb4\xcc\x98\x91\xba\xf6\xaa\x2b\xd6\xac\xb9\x77\xf2\xf2\x65\x91\xea\x93\x97\x4c\x5a\x3f\x98\x4e\x4f\x8f\x76\x5c\xac\xfd\xa5\x34\xd0\x96\xcd\xc6\xbb\x88\x29\xbd\xf7\x03\x01\x00\x1d\xe7\x9e\xfb\x8b\x50\x28\x1c\x01\x02\xa8\x4f\x0f\xec\xba\x2c\x10\x88\x44\x3a\x62\xed\x5d\xa9\xc1\x35\x5b\x9e\x25\x37\xb5\x4c\x99\xd2\x96\x75\x59\xe9\xab\x4e\x5f\x59\x4e\x38\x09\xd2\x76\xc4\x9e\xdf\xc0\x22\x2f\x48\x07\x08\xb8\x38\x67\xb0\x39\x15\xcf\xf8\x9e\xfc\x6c\xfd\x8f\xce\x8d\x9e\x4d\x7c\x7f\xf4\x6c\xec\xca\x9f\x3d\x88\xab\xf1\xdf\xf3\x67\xe0\x4c\x7e\xfd\xe8\x87\xe7\xe2\xab\x88\x33\x47\xdf\xc1\x37\x19\xfc\x91\x06\xee\x2c\xb5\xd5\x98\xef\xfd\x48\x45\x53\xd1\x02\x84\x50\x32\x6b\xcc\x4f\x64\xf1\x4c\x15\x66\xb1\x42\xe7\x2e\x40\x59\x1a\x0e\x95\x2d\xba\xba\x6b\x2c\x2e\x28\xc6\x1e\x21\x04\xc0\x1d\x4e\x67\x0d\x4b\xd6\x20\x64\x93\x92\x9a\x95\x44\xc6\xf8\x32\x8a\x1f\x46\x52\x84\x37\x43\x92\x14\x12\xe1\xf1\x90\x28\x86\xa4\xd1\x43\x15\xcd\x4d\xb3\x9b\x9b\xc9\xe9\xed\xd5\x53\x9a\x67\x37\x5f\xdc\x5c\x59\xd1\x0c\xbd\x89\x76\xfc\xa3\x95\xb9\xd1\x53\x72\xa7\x4f\x62\x6c\x76\x66\xf2\xe2\xdf\x2d\x9e\xcc\xd8\x6d\x0c\x5c\xad\xe7\x37\x57\x54\x36\x93\xa5\x92\xfe\x9c\xc2\xbf\x97\x9a\x2b\xb4\x81\xca\xe6\xe6\x4a\xf8\x51\x45\x33\x9f\x5f\x92\x68\xff\x9b\x1e\xfb\x5b\xe1\xd8\x9e\xc0\xd7\xc3\x55\xea\x33\x67\x9f\xfd\x8c\xba\xc3\xce\xd0\xb6\xf3\x2b\x2a\xce\xb7\xd1\x8c\x3d\x7f\xd5\xd8\x5d\x95\x4d\x4d\xc8\x6c\xc8\x5d\x5f\x18\x9c\x1b\x0e\x14\x01\x13\xb8\x21\x0e\x29\xe8\x81\x4f\x0c\x3c\x95\x28\x9d\x49\xab\x49\x89\x96\x99\xac\x24\x82\xac\x8f\x3b\x0c\xad\x8f\xdf\xad\x44\x33\xc8\x90\x56\x74\x81\xa7\x20\xef\x88\x92\xc1\x21\xab\x4b\x3e\xc6\x4c\x27\x67\x8b\xcb\x29\xfa\x20\xcf\xd0\xa2\x9a\x4d\x67\x12\x84\x42\x4b\x42\x34\x01\xb4\x92\x95\x15\x99\x66\xe8\x00\xe8\x9a\x21\x63\x38\x40\x49\x49\x91\x36\x9c\x57\x8d\x29\x96\xd0\xc7\x7e\x42\x9f\x12\xa0\xc0\x71\xc2\xd0\x8a\x5c\x98\x11\x28\x51\x12\x58\x8a\x61\xb1\x3e\x2f\xe8\xbd\x93\xc5\xc6\x90\x28\xea\x97\xe8\xef\xc1\x28\xa5\x61\x5d\x69\xdc\x1d\xc0\xee\xac\x92\xd0\x07\x2c\x49\x2c\x38\xf2\xeb\x17\x18\x1b\xb8\x59\x83\x3a\xbf\x15\x44\xd0\x0b\xe4\x16\xa5\x24\x43\xa7\x92\x94\x5e\x25\xb2\x30\x55\x29\xe9\x04\x30\x11\x3d\x28\x09\x6a\x56\x4d\xeb\xc2\x5c\x94\xd5\xc5\x7e\x2c\x89\xfa\x13\x92\x59\x08\x60\xbd\x38\x60\x40\xb3\x10\x06\x78\x11\xc3\x12\x4a\xa1\x29\xf4\x1f\xd0\x1b\x41\x97\x0e\x21\x63\x14\x51\x2f\x1c\xc1\x08\xb4\x54\x30\x01\xc5\x6a\x2b\x36\x56\xe3\x64\x3d\xd3\x58\x87\x23\xd4\xac\x5a\x98\x1f\x53\x06\x98\x0d\x53\xbc\x56\x34\x24\x4f\xe3\xb1\x2c\xe8\xd5\x10\x8b\x0f\x2e\xb6\x74\x80\xc2\xd7\x58\xcd\x24\xc5\x53\x0b\x49\x87\xc5\x63\x22\xb4\x1b\x48\x92\x22\x08\xc6\x62\x26\x39\x12\x30\x06\x4c\xcc\x52\x49\x86\x20\x30\x03\x66\xb0\xf4\x46\x3d\xe1\x39\x61\xab\x12\x74\x80\xd5\xec\x76\xd9\xed\xc0\x46\x4a\x44\x92\x14\xac\x8a\xa3\x89\x36\xd1\x62\x49\xdc\x6f\xb1\xba\xdc\x76\x8a\x2b\x11\x9d\x2b\x5d\x60\x2e\x2f\x21\x20\xe2\xf7\x95\x62\x30\x73\x8c\x85\x26\xad\x0c\x07\x20\x78\x38\x01\x40\x34\x9b\x14\xb0\x53\x16\x56\xb4\xf8\xc4\x1a\x15\x57\xf8\x42\x94\xd9\x4a\x11\x66\x9b\xd0\x63\xae\xf2\x96\x64\x2d\x00\xce\x92\x0a\x4e\x8e\x84\x7d\xa2\x1d\x63\x9a\xb6\x32\x76\xc2\x3f\x3d\x2b\xba\x2b\x44\x02\x02\xa5\x76\x97\x34\xdd\x84\x81\x36\xb9\x43\x24\xa6\x49\x0a\xe3\x58\x82\x2a\x23\x85\x1f\x9a\x9d\x44\x30\x60\xaa\x60\x13\x0a\x69\xa7\x81\x10\x2c\x89\x0d\x17\x54\x49\x56\x1b\x06\xd1\x4c\xbb\x09\x09\x63\x0e\x8b\x8e\x18\x74\x4d\xcb\xdf\x4a\x58\x69\x33\x26\x2c\x04\x61\x25\xe0\x76\x6c\xe6\x68\xca\x4c\xd1\x98\x60\x2b\x5c\x66\xeb\x5e\x8b\x8d\xa0\x49\x92\x60\x49\x13\xce\x52\x76\xc2\x61\x36\x53\x04\x06\x0b\x26\x49\x13\x6b\x02\x27\x8b\x55\x41\xc4\x8c\x47\x8a\x7b\x65\x93\xbc\xd8\xcf\x2d\x91\x5d\x92\x25\x12\xa8\x9a\xcd\xf7\x09\x55\x93\x62\x29\x7f\xe9\xee\x76\xbe\x3d\x56\xe9\xa1\x2c\x11\x00\x8b\x05\x2c\xec\x6c\x2e\xe0\x71\x67\x42\xa9\x88\xd9\xee\xc2\x36\x8a\x84\x08\x41\x44\x84\x6d\x51\xcf\xa9\x1d\x52\x65\x25\xe1\x12\x2c\x1b\x6b\xbb\xab\xad\x24\x01\xe0\x0a\x30\xa6\xb8\x28\x0b\x67\xb2\x36\x12\xa7\xfb\x95\x8e\xcc\x8a\x58\xc3\x04\x8a\x8a\x46\x4e\x51\xe7\x39\x4c\xb4\xcb\x6a\xf1\xf9\xb2\x11\x97\xcf\x65\x66\xb1\x28\xbb\x9c\x02\x6f\xa9\x9f\x5f\xd6\xd4\xd2\x93\xa9\xb5\x2a\xa1\x70\x98\x60\x81\x75\x78\x9d\x3e\xf2\x34\xe0\x81\xb6\x11\x2c\x38\x08\xab\x9d\xd6\x06\xc0\xc4\x51\x94\xc9\x0a\xe0\xb4\x10\x26\xfd\x85\x63\xed\x7a\x97\xc7\x51\xe2\x73\x96\x5a\x22\x4c\x25\x55\x7b\xa6\x20\xb4\xdd\x76\x56\x19\x26\xab\x37\x25\x94\xe6\xa0\xcb\x06\xad\x03\x81\x98\xe8\xee\x88\x98\x88\x00\x40\x32\x0d\x44\x67\x09\xef\x60\xc8\x76\x2a\x50\xe6\x36\x13\xa6\xad\x0e\x33\x41\x32\x0d\x9d\x00\x0d\x41\x47\x55\x10\x13\x56\x33\x94\xf2\x62\x00\x2a\x62\xa4\x83\xb5\x49\xc0\x7a\x29\x93\xe4\xb0\x02\xe6\xc0\x66\xe6\xcc\x2c\x4d\x58\xed\x04\x1d\x24\x79\x92\x62\x30\x49\x3a\x24\x00\x9b\x93\x77\x98\x49\x33\xa6\x28\x92\x26\x18\x60\x9b\xbd\x36\x6b\x6b\xd0\x4c\x30\x25\x6d\xb5\xdd\xa5\xf4\x0f\x1b\x5c\x4b\x4c\x1e\x77\xb0\xcd\xef\xe7\x01\xc8\x8e\xd3\x6c\x21\x52\xfa\x9e\xd9\x91\x28\x23\x1c\x4d\x75\x09\x4f\xb7\xc9\x69\xc2\x94\x99\x49\x3b\x1d\x93\x65\x13\x9d\x28\xe9\x92\x4a\x81\x3f\x2b\xe4\x5e\x3e\xcf\xeb\x8a\x87\xac\x44\x05\xe7\xc5\xd8\x4c\x81\x43\x78\xca\xc4\x10\x24\x61\xa1\x19\xc0\x4e\x95\x04\xd7\x7e\x2b\x67\x02\x92\x04\xd2\x47\x50\xf8\x3d\x4c\x9b\xb0\x03\xec\x76\x9a\xb4\x53\x34\x41\xdb\x08\x20\x0f\x3e\x67\x2b\x91\x44\x91\x13\xec\x2e\x92\xef\xf5\x39\x19\x97\xb9\x54\xe4\x40\x9f\xa2\xfc\xa1\x12\x80\x66\x3b\x69\x65\x6c\x9c\x55\x9a\x63\x75\xd6\xc6\x63\x66\x1b\x69\x71\x45\x22\x3d\x61\x81\x22\xec\x8e\x0a\xda\x63\x13\xad\x8e\x6e\x96\x33\xd3\x25\x26\x3a\xc4\x12\x74\x55\xba\x43\xe1\x9e\x4c\xf7\x46\xcc\x1e\xa7\x58\x9a\xa8\x75\xb9\x97\x64\xbb\x85\x4b\xd3\xab\x9f\x9d\xbf\xb9\xd2\x0d\xa5\xbe\x8a\x5b\xba\x17\xaf\x5f\xb3\xbc\xe9\xe5\x39\x75\x93\xca\x30\x8e\xc4\x03\x00\x26\xde\x56\x4a\xc5\xd9\x99\xea\xc4\x73\x3b\x26\x51\xe1\xba\x68\x89\x2b\x1e\x2a\xb1\x5a\x7b\x27\xd9\x82\xa9\x80\xcf\xea\x28\xfa\xc7\xeb\xb2\x18\x8b\x42\x48\x41\x09\x94\x44\xad\x68\x36\x3a\x19\xa1\xb8\x4c\x44\x19\x96\x64\x14\x31\x95\x24\x64\x85\x0c\xeb\xb3\xb4\x54\xa0\x03\x56\x64\x85\x05\x26\x44\xc9\x8c\x3e\xc8\x41\x84\xc9\x52\xfa\xfc\x2e\x4a\xad\x24\x2f\x2b\xfa\x5d\xc6\x68\xd2\x0a\xc9\x00\x29\x65\x8f\xf1\x20\xa8\x38\x19\x63\x67\xf6\xca\xad\x17\x46\x1d\x8f\xbe\x77\x7e\x8b\x3b\xa4\xfd\x4a\xbb\x1a\xe6\xf6\x27\xaf\xb8\x78\xb3\x1c\x27\x5d\x4b\x37\x6c\xb9\x78\x24\x04\x09\xe2\x8d\xdf\xfe\x72\x4e\xf9\xaa\x2b\x47\x3f\x01\x00\x3c\x7d\xdf\xe7\x7d\xd3\x77\xac\x9b\xb0\x69\x52\xb3\xe3\x00\xb1\x0b\xcc\x42\xd7\x94\x73\x27\x94\xf0\xd8\x4c\xc4\xa6\x4e\xec\x6e\xce\x54\x06\x2c\x9b\x8e\xd3\xc3\x62\xfa\x9d\xb4\x7b\xea\x9c\x9d\x53\xad\x57\xe3\x2b\xea\x5a\x17\x31\xec\x96\xbf\xcc\x9b\x77\xc3\x60\x37\x6b\x07\xea\xf7\xaf\xde\xd1\xf1\xe9\x35\x1f\x35\x07\x3f\x7a\x67\xca\xdb\xc4\x19\x00\x97\xef\xe6\xef\xf9\x9d\x77\x42\xb6\xd9\xad\x45\xfe\xf1\x00\xd8\x4a\xda\x1b\x7a\xfc\x99\x0a\xca\x43\x51\x24\x41\xd1\x0c\x85\x9f\x3b\x11\x1e\x63\xb1\xfd\x5a\xd1\xa0\xae\x7f\x24\x88\x1a\x48\x90\x99\x74\x2a\x19\x20\x0a\xb6\x57\x10\x35\xe8\x99\x0c\xd4\x1c\xa9\xc0\xd1\x9b\x20\xc6\xf6\x51\x5a\x71\x81\x78\x8b\x36\x98\x66\x0b\xe8\x73\xba\x54\x94\x4d\x25\x49\xd1\xe5\x16\x18\x91\xbc\x4a\x69\x9c\x3b\xb5\x6e\x59\xc0\x5f\xe1\x72\x5c\x56\xd9\x5d\x16\xab\xf2\xd6\x34\xac\xbe\x6f\xa8\x3b\xb7\xaa\x4b\xee\x9d\xdd\xbc\x6b\xbe\x18\xea\xef\x48\xcd\xa8\xab\x48\x96\x26\x53\xff\xbe\xbb\xe7\xbb\xab\x3a\x61\xe5\x5f\x6e\xd9\xbe\x6c\x6a\xcf\xa5\xda\xa1\x27\x56\x39\xfb\x8b\x11\xa0\xf4\x08\xbc\x9e\x3c\x29\x5b\xe5\xb1\x7a\x18\xc6\xe9\xf4\x72\x53\x3d\xe1\x88\xa7\xbd\x5a\x9d\x97\x08\xb6\xad\xea\x69\x59\xd0\x1c\x67\x63\x22\x2b\x94\x29\xa9\x50\x75\x75\xa8\xb9\x7a\xe1\x8e\xf8\xc4\xb3\x2f\xbb\xe5\x2f\xfd\xce\x55\x4f\x00\x75\x69\xcf\xd4\x65\xdb\x0b\x11\xed\x90\x1e\x31\xf4\xf3\xaa\xc3\x39\xf2\xff\x0c\x5f\x96\x36\xd4\x6d\x78\x5c\x8d\xed\x87\xa8\x06\x3e\x79\xd2\xa0\x29\x96\xc7\xed\x72\x66\x55\xda\x02\x0c\x4b\x1a\x06\xbe\xc0\x82\x72\x14\x3e\x95\xc8\x7a\x81\xf8\x47\x9c\xf2\xbb\xf3\xf5\x52\x90\x86\xa8\x14\x08\x7f\x24\x06\x08\x8f\x9d\x0c\xba\xb5\x3f\x96\xca\x72\x29\xcc\x77\x45\xde\x71\x4c\x6d\x25\x69\x5a\xf4\x25\xc3\xda\x27\x76\xb3\x49\x1b\x14\x7b\x6c\x6a\xdf\x00\xb1\x61\x71\xbb\x78\x33\xd9\x3a\x95\x9c\xf6\x94\x14\x89\x08\x87\x1e\x64\x68\x18\xf2\x3a\x4a\x1d\xdb\x5b\xdc\xb2\x5c\x5a\x51\x1a\xf7\x7d\xd8\xa3\x9d\xab\xfd\x92\x13\xdd\x55\xa2\x60\x31\x6b\xbe\x12\xc6\x2c\xf6\x51\xdb\xd5\xc5\x2b\x56\x8c\xbe\xc7\x41\x03\xec\x40\xc7\xad\x3b\x14\x34\x95\x2f\x59\x6a\x7e\x03\xc6\xe9\x88\x8b\xd5\x0c\x99\x19\xf6\x17\x77\x6c\x8f\xc4\x86\x65\xef\x41\x63\x4b\x86\xca\x79\xe5\x11\xd2\xd8\xef\x1d\x45\x06\x31\x39\x36\x76\x72\x8d\xfd\x5c\x82\x3d\x7a\x91\x7c\x84\x0b\x91\x42\xd4\x7e\x83\xff\xb1\xb0\x0b\xa5\x10\x51\x37\x2f\x1a\x76\x4c\xc7\x90\xb3\xa4\x55\x3e\x13\x25\x8a\x6c\x6d\x86\xef\xb7\x04\x47\x20\xdd\x28\x54\x5f\x96\x2a\xfd\x5b\xf5\x67\x66\xd9\x3b\xd2\x99\x18\x4e\x74\x8e\x78\x65\xf3\x67\xd5\x7f\x2b\x4d\x95\xd5\x3b\x01\xf5\x2c\x85\xdc\xd2\x1e\x40\x4e\x6d\x68\xc7\x4f\x77\xec\xf8\x29\xec\x2f\xab\xaf\x84\x59\xe7\x6b\xa7\x39\x5c\x5e\x59\xfb\x38\xd1\xd9\x99\x00\xa7\xec\x75\x39\xe0\x86\xf3\xb5\x7b\x2b\xeb\xcb\x4a\x3d\x90\x5b\xb9\x52\xcb\x79\x88\x21\xfd\x86\x1d\x85\xb2\x92\x7a\x59\xe3\x86\x25\x6e\x51\xd8\x8d\x7e\xc5\xb9\xd0\x66\x47\xf0\xd9\x50\x7d\x7f\x7d\x7b\xe7\xc2\x4e\xe3\xaf\xbe\xbf\x7e\x75\x3f\xce\xf5\xaf\xd6\xf6\x1b\xa5\x21\xda\xb5\x02\x4f\xde\xd0\xe8\x6a\xa3\x24\x2f\x6b\xb5\xfa\x99\xb8\x4c\x33\x30\xfe\x60\xb8\x7f\xf5\x6a\x78\xe1\x68\x39\x0a\xef\xd1\x8d\xc2\x08\xc5\xa1\x15\x64\x45\x1e\x63\xb5\xc3\x0c\x0b\xa2\x14\x1b\xbf\xc0\x43\xc1\xa0\x93\x2b\xad\x29\x9b\xdd\xe2\x89\x35\x37\xc5\x3c\x2d\xb3\xcb\x13\xa5\x9c\x93\x9c\x7b\xdc\x00\xf3\x1e\xbc\x2e\xf6\x0e\x05\xbd\x10\xf1\x97\x95\xf9\x23\xe0\x0d\x0e\xf5\x8a\x3b\x4f\x30\x46\x54\x1d\x46\xf4\xef\xa8\xc3\xc8\x81\x7a\x10\x42\x05\xc2\x36\x21\x80\x93\xad\x10\xa7\x19\x03\x1c\x4a\x89\x1b\x3e\xd6\x94\x61\x16\x1c\x97\x15\xb9\x0d\x74\x39\x53\x8d\x1b\x36\xc2\x94\x6a\x90\xcd\x1b\x18\x3e\x94\x61\x88\x2b\x89\xd4\xc8\x82\x1b\x5e\x7d\xef\xd5\x1b\x16\x14\x4e\xb0\x8a\x74\x6a\x6f\xd8\x1d\xac\xf6\xc6\x5e\x4b\xc8\xb2\x57\x7b\x83\x75\xd8\xb5\x37\x9c\x24\x65\xde\xbb\xd7\x4c\x91\x4e\x88\xd9\x1d\x2c\xc4\xf6\x9a\x23\xe6\xbd\x10\x63\x1d\x76\x88\x15\x33\xb1\xf5\xe8\x63\x16\x2c\xb8\x21\xe3\xa0\x86\xb4\x17\x9d\x16\x0b\x3d\xf8\xb9\xdd\xfe\xf9\x20\x6d\xb1\x38\x21\x39\x44\x39\x38\xdb\xe7\x9f\xdb\x9d\x0e\x6a\x08\x92\x85\x5c\x9b\xad\x90\xab\xbd\x38\x44\x39\x9c\xf6\xcf\x3f\xb7\x15\x75\xbf\x27\xa9\xf3\x90\x0b\xd5\x21\x14\xd7\xc7\x35\x7d\x58\xa3\x8d\x11\x30\x95\x8c\xc5\x69\xb2\x38\xd4\xb9\xb2\x31\x43\x52\x66\xc1\x6d\x90\x6a\x1b\x92\x38\xf9\x61\xb6\xfe\x61\xed\xf9\xbd\xcb\x7e\x75\x78\xc9\xbd\x1f\x6c\xbf\x0c\x08\x90\x07\xb5\x0b\xf6\xdf\xa8\x1d\x78\x71\xd3\xba\x67\xc0\x75\x5d\x15\xe7\x0a\xcf\x5e\xb0\xeb\xe0\x95\xe7\x9c\x59\x1e\x64\x99\x77\xcd\x7b\x21\xfb\xf0\xc8\x1d\xcd\xda\x8f\x5e\xdb\xfe\xc1\xbd\x4b\x36\x3f\xfd\x7f\xff\xda\xf4\x22\xf8\x6f\xbc\x0e\xa4\x5f\x9f\x4b\xe3\xf2\xf2\xe0\xb4\x97\xd6\x5d\x79\x70\x57\xca\x15\x64\xcb\x0a\xd8\x66\xf4\x48\x71\x4f\xbb\xb2\x68\xc1\x68\x6c\xe7\x87\xbf\x64\xc7\xff\x25\xdf\x96\xf6\x71\x68\x1a\x78\xc9\xf8\x2f\xb8\x5d\xf6\x1e\x34\x72\x68\xe4\x95\xf1\x9d\x05\xf8\x3f\x34\x6a\x20\x7d\x18\xbb\xb0\x70\xe7\x51\x1c\x0e\x03\xc7\x23\x74\x78\x98\x1e\xa2\x46\x50\x27\x9a\x6c\x78\xe2\x55\x82\xc0\x48\xa2\x60\x74\x03\x96\x8c\x72\x51\x2e\x92\xc0\x35\x63\xd4\x8b\x6d\x50\x24\x7d\x68\x02\x4e\xd1\xbf\x8f\xa0\x81\x10\x54\x04\x08\x82\x70\x3a\x1b\x12\xe9\x21\xd9\xbb\xbf\xeb\x65\x9e\x77\x65\x5d\xcf\x52\x42\x7b\xe7\xc9\xb5\xb9\xd4\x69\x3d\x4d\xac\xe3\x11\xc1\xef\xe1\x79\x82\x7b\xbe\xb1\x00\xf7\xb1\x87\x97\xd3\xfc\x1e\xa2\x6f\x0f\x9f\x96\xf9\x3d\xfb\xbd\xda\xc4\x7c\xee\x31\xb0\x3c\x86\xe7\xa7\xe5\x7b\xd7\xff\x86\x4f\xf3\x3c\xff\x0c\xe5\x2c\x0f\x79\x89\xdc\x68\xce\xa7\x28\x76\xf6\x25\xb7\xd3\x95\x11\xfe\xb6\x76\x58\xaf\x98\x5c\xb8\xb1\xf0\x18\xed\x8f\x18\x5d\xf0\xd8\x63\x08\xc1\xe1\xc3\x08\x98\x73\xc9\x49\xe8\x02\xc3\x66\x90\x66\x58\x1c\xc0\x06\x90\x46\x00\xb3\x10\xa5\x68\xb9\x06\x12\x04\xc3\x92\x92\x60\x50\x60\x44\x69\xbd\x86\x09\x02\x2b\x06\xda\x56\x2a\x1e\x00\x7d\x8e\xd4\x8f\x01\x22\xa9\xb6\x92\x06\x76\x84\xa1\x70\xe9\x3d\x45\x0a\x10\x82\x81\x07\x63\xac\x8a\xb7\x62\x35\x5b\xd8\xff\xc0\x52\x3c\x2b\x4a\xcc\xb9\xd2\x1e\x4f\x79\x59\x20\xc8\xf0\x89\x08\x09\x97\x24\x09\x86\x31\x55\xc8\x87\x91\xa7\x5d\x10\x02\xfd\x0d\x1d\x1e\xc2\xe2\xe1\x1d\xc0\x90\xa4\x2b\xba\x6e\xd2\xd5\x6b\x16\x79\x4a\x2c\xd1\xd3\x97\x5d\xd2\x4c\x13\xa4\xa3\x02\x5c\x36\x91\xa2\x9c\x26\x21\xed\x70\x96\x66\x2b\xcb\xfc\x76\x4c\xbb\xcc\x16\x0a\xb3\x0c\x5d\xd2\x6c\x77\x39\xc5\xcc\x4f\x07\x32\x82\x8f\x65\x30\x81\x81\xe6\x58\x93\x2b\x52\xd1\x1a\x6f\xae\x21\x6d\x14\x89\x69\xc1\x02\x21\x25\x49\x13\x9f\xb7\xbf\x13\xca\xa4\x2a\x1a\x7c\x15\x55\x41\x8c\x77\xcc\xa7\x1c\x72\xa0\x84\xa4\x04\x9b\xcd\x3d\x7b\x42\x8d\x09\x28\x4f\x74\x42\xa5\xa3\x84\xa6\x78\x82\x2c\xef\xe8\xf2\x78\x2c\x65\x3b\x87\x81\xbe\xc4\x29\x52\x34\x8f\xb1\x99\x24\xac\xee\xe4\x4a\x7f\x69\xf3\xdc\x3a\x3f\x05\xa6\x58\xe3\xb2\x9e\xb2\x4e\xbb\x2d\x62\xc6\x22\x6f\xf5\x62\xb0\x51\x5c\x30\xdc\x98\x9e\x27\x5b\x5b\x23\x35\x41\x33\x26\xbd\x95\x0b\x5a\x97\x6d\xb4\x38\x08\x02\x08\x02\x30\xe5\x30\x1b\x5c\xc1\xf7\xd0\x9f\x51\x53\x90\xc5\x18\xf1\x6a\xd0\x2c\xb4\x1c\x9d\x87\x50\xfc\x88\x4e\xac\xcf\xc6\x46\x50\x12\xb3\xd2\x18\xde\xa7\x14\x80\x78\x02\x62\x0c\x4d\xea\x1f\xa2\x9a\x8d\xc5\x05\x56\x1f\x15\x13\x90\x49\xbb\xd4\x6c\x4c\x57\x07\x03\x90\x35\x70\xd1\xf4\xcf\xd6\x50\x2d\x71\x00\x8a\x80\xa1\x59\x99\xa1\x0b\x2a\x65\xdc\x48\x33\x92\x94\x04\xe8\x2a\xbb\xae\xa2\xe3\xdb\xdd\x42\x34\x32\xcd\x2d\xba\xba\x67\x9c\x65\x32\xdb\xd9\x52\x86\x0b\xb0\x81\x87\xaa\xff\xba\x6a\xe5\x8c\x9a\x9a\xdf\xac\x58\xb5\x18\xac\xe6\x61\xed\xf0\xae\xb7\xb4\x3f\xb1\xe6\x61\x80\x5d\x6f\x41\x1c\xe4\xde\xcb\x7e\xae\xe5\xb5\x77\xb4\x7f\xbf\xba\xfd\xfb\xb9\xbb\x61\x5e\x6f\x47\x35\x49\xb3\x0e\x9a\xfe\xfe\xef\x13\xd5\xd5\x98\x62\x2d\xb6\x86\x85\xdd\x67\xcd\x2c\xe1\x4d\x95\x92\x24\x32\xc2\xdc\x36\x4f\x05\x49\x79\x3d\xcd\x30\x6b\x4e\x4a\x31\x27\xb3\x5e\x93\x3f\xd6\xda\x7a\xdf\x1c\x7f\xad\x2d\xe8\xdf\xfc\xe9\x68\x64\xa2\x83\xf5\x86\x23\x13\x42\xbe\x1b\xec\x3e\x8a\xb2\xda\x83\x2c\x65\x1d\x5c\x32\x14\x8b\xec\x5b\xbc\x68\xa1\xaf\xf4\xa1\xe6\xa1\x2b\x27\xb2\xd2\x07\xbb\x0a\xa7\x9d\xdd\x97\xee\x58\xd6\xda\xb5\xfe\x91\xd3\xd7\x01\x99\xbb\xfb\xbb\xbd\xed\x97\xb3\x36\x4c\x60\xdc\xd4\xd2\xb6\xce\xce\x5a\x49\xd2\xd5\xb8\x1c\x2f\x1e\xdc\x5c\x2f\x89\x8c\xa9\x52\x6a\x1b\xb2\x53\x5e\x8f\xa7\x9c\xb2\x4f\x1f\xca\xaf\xf3\x79\x5d\x49\xdf\xc0\xde\xee\x09\x19\x17\x1d\xac\xaf\xa1\xbd\x53\xc6\xcb\x16\x6b\x91\x19\xf1\xa8\x14\x21\x83\xdf\xb6\x15\xd4\x00\x00\x27\x60\x46\xe6\xd2\xae\x18\x38\x19\x19\x67\x38\x91\x74\x91\x67\xdc\xfb\xcc\x2f\xee\xbd\xf8\xe9\x48\xf4\x69\xed\x86\xfc\xaf\x1f\xba\x0b\x62\x64\xe6\xa1\x5f\xe7\x1f\x84\xd8\x5d\x91\xc1\xc1\x39\x9f\x5f\x76\xd9\xe7\x54\x8b\xe6\x1b\xd5\xbe\x73\xca\x6b\xe0\x79\x0c\x26\xfc\x3e\x5f\xa1\xfd\xe3\xb5\x53\xe0\x96\x51\x78\x3b\xf0\x7b\xed\xb1\x22\xd6\x33\xa2\x36\xd1\x08\xad\x44\x08\x58\x42\x17\x55\x69\xc4\x18\x28\x1f\xd9\x98\xca\xe2\x04\xa1\xb4\x42\x00\x4b\x59\x3d\x4c\xe9\x61\x2a\x08\xd9\x4c\x82\xca\xaa\x01\x92\xc5\x0e\x10\x05\xa6\x95\x12\x25\x56\xff\x90\x69\x3d\x48\x6d\x0a\xcd\x1d\x5c\x76\xca\xe0\xf4\x66\x27\xb7\x46\xbb\xe5\x65\xde\xeb\xe5\xf7\x40\xe5\x92\xd8\xe4\xc1\xb9\x27\xcf\x3e\x29\xbc\xf6\xb9\xef\xad\x6d\x2b\xc9\x78\x19\x71\x52\xf7\xe2\x81\xd9\xed\xd5\xf4\xc4\xf3\x4e\x9e\xdd\x92\x0a\x8b\x14\x69\x33\xf9\x26\xd5\xa7\x59\x39\xd5\x73\x46\x73\x8c\xa2\x05\x97\x89\x01\x20\xd8\x9a\xec\xdc\xc5\xdb\xba\xb1\xd2\x32\x6d\xd6\xcc\xbe\x26\x8e\x93\x92\xb4\x67\x4a\xff\xfa\xb3\x76\xc2\x4f\xfa\xcf\x6a\x09\x11\x6c\xa0\xc4\x62\x39\xa0\x7d\x01\x5e\xb9\x04\x5e\x7d\x9c\x75\x99\xec\x55\xbd\x5b\x4f\xaa\x11\xa2\xd3\xfa\xaa\x76\x0c\x03\x81\x09\xae\xb4\xbe\x77\xdd\x44\x3f\xc7\x97\x37\xb5\xb5\xd5\x39\x9c\x9b\x7a\x68\x61\x42\xef\xea\x35\x97\x74\x97\xf4\xf4\xcf\x9f\x7b\xd2\xc4\xac\xc3\x41\x2e\xf4\x32\x52\x5b\xa6\x31\x88\xa5\x69\xe7\x0d\xb4\x04\x5c\x40\x10\xc4\x15\x17\x32\x52\x53\x42\xc6\x75\x88\x44\xee\xc3\x88\xfc\x27\x85\x0c\x4b\x72\xc1\xf0\xaf\x32\x24\x2c\x28\xd8\xec\x83\x3b\xcc\xe9\x7f\x71\xf7\x18\x23\x13\xf9\xcf\x75\x33\x1a\xb4\xd1\xfc\x47\x33\xd6\x91\xbf\x3f\x54\x31\xf6\xb7\x6e\x06\x31\x6d\xc6\x3a\xf0\x75\xce\x5a\xaf\xfd\x0b\xec\xeb\x67\x75\xc2\xc4\xc3\xe8\x30\x4c\x3e\x8c\x0e\xff\xa0\xab\x6b\xe6\xfa\xf5\xe3\xe4\xcc\x12\x14\xd7\x67\x4d\xf4\x95\x34\xa6\xe2\x57\x38\x77\x91\xb9\x22\x91\xe9\x18\xc9\x66\x81\xc8\xf4\xee\xaf\x73\xf4\xc2\x3b\x4f\xc0\x67\x7a\xef\xd7\x39\x7c\x1d\x23\x13\x17\xcb\x7a\x2c\x1b\xeb\x78\x32\x56\xd7\x57\x96\x95\xb7\x6b\xc3\x7a\x01\x8f\x52\xb1\xc2\x90\x9d\x1f\xfe\xda\xc2\xee\x2f\x16\x11\xda\xcc\xfe\x31\x46\x56\xed\xf0\xd7\x96\xf6\x4b\xf2\x7b\x61\xcd\xf4\x68\x31\x8f\x97\xdf\xbf\xb4\xdb\x80\x64\xaf\xc0\x15\xdc\xce\x38\xc1\x2b\x03\xfa\x1a\x07\xb5\x91\x7c\xce\x2b\xdb\x8a\x6e\x63\x36\x79\xf4\xd9\x6f\xe1\x0f\xc6\x20\x1e\x05\x8f\xfa\xe1\xbb\xbe\x82\x31\xa0\xb8\x9f\x5b\xf1\x75\xbc\x01\x45\xef\x7a\x08\x7d\x2d\x7d\x40\xd1\xc6\x7d\x11\xb5\x1f\xb9\x51\x16\x21\x90\x0c\x71\x4c\x97\xc6\x54\x49\x9f\x5b\x51\x4a\x17\x4a\x25\x63\x34\x22\x0a\x40\x62\xaa\x41\x2e\xea\x16\x68\x85\x0f\xbb\xc3\x52\x38\x29\xf1\xc4\xe1\x25\x8d\xda\xcb\x8f\xdd\xa8\x7d\x76\xc3\x6f\xee\xe1\x36\xed\x02\x66\xdf\xd6\x57\xcf\xc6\xbe\xc6\xc3\xc8\xee\x2c\xe3\x3e\xd2\xca\x3c\x71\x62\x08\x9b\xd8\xd9\xd9\xce\xc1\x65\xdd\x71\xb8\x4b\x5b\xee\x84\x5f\x96\x71\x07\x60\xd1\xaf\x1f\xfc\xf3\x0d\x60\xbe\xf1\x21\xa8\x68\xdd\x91\x7d\xeb\x82\x7d\xda\x17\xdb\xdf\xf4\xae\xcd\x31\x51\x78\x33\xec\x21\xac\x5c\x49\xaa\x6d\xb0\x73\xc2\x77\x18\xed\xad\x5c\x2e\xaa\x35\x9c\x80\xd7\x27\xab\xc8\x44\x36\x95\x64\x58\x30\xcc\x29\xe5\xc2\x92\xae\x54\xf0\xcd\x92\xc4\x54\x92\x77\x7d\xc9\x3a\xd1\x66\xb9\xf7\xef\x33\xaa\xe4\x59\x56\xf2\x07\xd1\x4a\xc5\x1e\x0a\x6c\x6f\x5a\xee\x3b\xdd\x97\xee\xb3\x36\x24\x1d\xcd\x8e\xee\xa1\x9b\xfe\xfa\xc6\xc1\x63\xde\xe7\xf6\x3f\xd0\x26\xed\x5f\xfc\x50\xc3\x1b\x77\x67\x7f\xf5\x84\x8d\x59\xe4\x19\xf2\x74\xa5\x1f\x54\xff\xa4\x3e\x08\x32\xf8\xe0\xbc\x63\x76\xd0\xe0\x08\x0f\x86\xae\xff\x0a\x98\x2c\xa8\x61\x47\x0c\x8c\xda\x20\x33\x3e\x3c\xe6\x86\x15\xcf\x8a\xa5\x20\x30\x94\x7b\x2c\xc0\x65\x51\x31\x93\xcc\x3d\xa1\x3d\xfe\xb3\x61\xd6\xf5\x1a\x41\x5b\xcc\x76\xe9\xdd\xb1\xb3\x8b\x1d\x66\x5d\xb0\xde\xe1\x95\xb4\xf5\xc5\xd3\xe3\x40\x1a\xa9\x78\xe4\x67\xda\xe3\x4f\xb8\x58\x7c\x4a\x27\xd0\x16\x67\x4e\x32\x4d\x5a\x74\x24\x74\x50\xd7\x2a\x1f\x3a\x8b\x12\xf4\xd8\xc6\x45\x63\x01\xad\xc4\x0e\xc2\x93\xac\xcb\x35\xce\xf7\x3b\x5a\x44\x9f\x76\x17\xdd\x8c\x0a\x95\x39\x32\x18\x1d\xd9\x15\xfb\x96\xfe\xe0\x5a\x81\xd5\x52\x1b\x36\x94\xdf\xa1\x82\x0f\xca\xd0\x37\x7a\x87\x7f\xe9\x7a\xe3\x49\x5f\xe7\x2d\x5e\xf4\x8b\x35\xe5\x28\x84\x14\x83\xf1\xaf\xbf\xb0\xfb\x96\x29\x28\xc1\x09\x28\xd0\x1a\x67\x9b\x20\x93\x4a\x4a\x61\x43\x82\x31\x4c\x51\x81\x51\x45\x81\x91\xb2\x69\x05\xc2\x34\x13\xa1\x1d\x00\x2c\x54\x02\x91\x4a\x12\x51\x3e\x95\x14\x25\x08\x90\x29\x2a\x2c\xe3\xd3\xcf\xbc\x39\xd7\x6e\xe7\x99\xc6\xa9\x53\x1b\x19\xde\xde\x9e\xbb\xf9\x4c\x72\x5e\xc5\x36\xe7\xbc\x4d\xd5\xd5\x9b\xe6\x39\xb7\x55\xd0\x99\xcc\x8c\xee\xee\x43\xb3\x88\xcf\x5e\xff\xa8\x61\xb5\xcf\xaf\xed\xf7\xce\xab\x1e\x5a\x54\x7a\xd3\x4d\xa5\x8b\x86\x12\x73\xbd\x10\x22\xd9\x9a\x64\x4f\x0c\x9e\x1b\x35\x9f\x05\xc3\xed\xed\x35\x61\x4f\x09\xe6\x3c\x1c\x2e\xf1\x84\x6b\xda\xdb\x19\x91\x70\xa4\xaa\x62\x55\x29\x07\x21\x32\xa3\xb1\xd5\xb1\x40\xed\x95\xb5\xda\xef\xe5\x8a\x5a\x8f\x47\xdb\xef\x95\xe1\x65\xd8\x0f\x2f\xcb\x5e\x6d\x3f\x69\x0f\x97\xb8\xfb\xdb\x8b\xdf\x47\x8e\x46\x68\xc0\xb0\x4f\xd6\x3f\x56\x5d\x43\x2c\xec\x22\xd5\x00\x75\x34\x38\x46\xd0\xd0\x06\xc4\xd1\xa0\x52\x34\x63\x0d\x42\xfc\x68\xb0\x08\x6f\x47\x3b\x80\x57\xb3\x10\x27\x28\xea\xa3\xd6\x93\x16\xdd\x57\xcf\xcc\x6c\xaa\x99\xea\x50\xb5\xe7\x55\xd3\xcc\xe6\x9a\x3e\x87\x7a\x5d\xa9\xbb\x65\x86\x5a\x75\xe3\xf2\x1b\xbd\x62\xf3\x80\x5a\x75\x53\xa6\x90\x91\x85\x6c\xd6\x34\x4b\xbf\x38\x73\x9b\x5b\x6c\x9e\xd5\x5c\x75\xd3\xf2\xdd\x9e\xd1\x51\xc8\x2e\xd7\x9e\xc7\x9f\xcf\x68\xf9\x4e\xb8\xe9\x2e\xb7\xb7\x69\x76\xb6\xfa\x8e\x15\xbb\x3d\x92\x1e\xb8\x3d\x63\xee\x6f\xa9\xe9\x73\x64\xa0\x21\x6b\x9a\xa1\x3f\x25\x73\x8b\x47\x6a\x9e\x95\xad\x1e\x5e\x3e\xac\x5f\xa2\x56\xdd\xaa\xd2\xd3\x9b\xaa\x7b\x1c\x59\xed\x17\xf5\x26\xed\xe0\x72\x68\x5a\x79\xfc\x5a\x4d\xb9\x61\x49\x75\x9c\x8d\x08\x70\x45\x22\xfb\x06\x28\x52\xd9\x2b\xc5\x1e\x3b\xd6\x81\x8b\x78\x19\x74\xb2\x95\x52\xe3\xad\x30\xde\x88\x84\xd8\x1f\x0c\x47\x9e\xc9\x9c\xdc\xd9\x79\x72\xcd\x93\x35\xb6\x0a\x4b\x7d\x19\xd1\x5e\x56\xaf\x96\x8f\x8e\x94\xd5\xb7\xc4\x6b\x1e\x52\x08\x3f\xeb\xe7\x3d\x6e\xc1\xed\xe1\xfd\xac\x9f\x00\x6b\xb4\xed\x58\x5b\x93\x43\xfb\x61\x6f\x54\x10\xb7\xc6\x26\x4c\x08\x6d\x0c\x99\x64\x93\xd6\x57\x56\x5f\x8f\x4f\x2b\x6f\xac\x2f\x8b\x4f\x2f\x09\xad\xf5\x62\xde\xcc\x99\x2d\x14\x65\x31\x73\x66\x1e\xff\x48\x9a\x8e\xc6\xf6\x12\x0d\xdf\x03\x0a\xb5\xa1\x49\x68\x06\xfa\x0e\x5a\x83\x10\x9f\x56\x41\xc6\x06\x42\x26\x61\x6c\xfd\xc8\x8e\xc2\x9a\x86\xae\x3b\xf1\x47\x92\x22\x72\x34\x1b\x4b\x25\x49\xa9\xe0\xe2\x49\x4b\x22\xc5\x8b\x92\x31\x07\x8a\x6e\x01\x33\x7c\x36\x93\x46\x21\x52\x74\x39\x31\x4d\x86\x62\x32\x76\xba\xb2\x28\x14\xcb\xba\x9c\x58\x8e\x85\x48\x1a\x3b\x5d\xe2\x79\x5d\xb0\xea\x17\x1f\x52\x26\xca\x61\xf2\x91\x7d\xda\x7b\x89\x0a\x9e\xe5\xf9\x17\xa6\x9c\x67\xe3\x68\xc2\x61\xeb\xdf\xf0\x43\xed\x1f\xc5\x34\x26\x64\x59\x0e\x27\x3d\x7b\x05\x58\x97\x5b\xd4\x5e\x92\xb4\xd1\x2e\x46\x24\xda\x34\xfa\x03\x20\xb7\x6e\x5b\xbd\x9c\xd8\xbc\xf8\xe5\x1f\xff\xb3\x69\xf4\x36\x38\x1d\xfa\x3e\xde\xb9\xf3\x63\x6d\xaf\x76\xa5\xb6\x57\x0f\xc1\x2c\x98\x0f\x2d\x6f\x5f\x78\xe1\xdb\xda\xd3\xda\x9d\xda\xd3\x7a\x08\xe7\x6e\xbf\x7a\x94\x5f\x0c\x67\x81\x89\x57\x9a\xfd\xf3\xed\x87\x11\xd1\x48\x50\x38\x5c\x0a\x16\x30\x83\xcd\xc5\xb3\x60\xd2\x1e\xd5\x4c\x44\xfb\x58\xea\xf0\x63\x2b\x86\x66\xa8\x36\x0f\xef\x73\x04\x6c\x31\x6a\xe5\x2b\xf9\x8d\x34\x55\x15\x22\x07\x7e\xf4\xf4\x6f\xb4\x5b\x96\xe0\x3b\xef\x5e\x59\x81\xd3\xc7\xfc\x70\x9f\x51\x98\x2f\x1e\xb9\xf0\x6d\x68\x39\xae\x0c\x47\xb8\xa0\xf4\xf6\x77\x21\x9f\x2e\x41\x50\x72\x4c\xff\x46\x62\xaa\x9b\x26\xdd\x02\x29\x71\xc0\xc7\x55\x59\xc9\x90\x12\xd9\xaa\x7d\x7c\x40\xfb\xc1\xef\x7f\x05\x8b\x5e\x7f\x5d\x7b\x17\x32\xef\x11\x7b\xe2\xf9\x7f\x5d\xb1\xfe\x56\x70\xff\x9a\x46\x07\x51\x4e\xd8\x9d\xdf\xf5\x83\xcf\x76\x7b\xef\x93\xf7\x5f\x7a\xed\x3b\x01\xaa\x5f\x6b\xd3\x36\xad\x3d\x69\x62\xe9\x7d\xe1\x2d\x63\x36\xe6\x06\xef\x94\x0d\xc9\xa8\x16\x21\x33\xb8\xa3\xc5\x2e\x1c\xcd\x40\x98\x4b\x71\xe3\xfe\x8e\x62\xc7\x51\x63\xc1\x14\x31\x42\x8c\xe4\xca\xfd\x07\x2d\xfe\xf2\x1c\x20\x40\xb9\xb1\x7f\x4d\xfe\xf2\x2f\x72\xe5\xfe\x26\xba\xc9\x5f\xfe\x79\xae\xdc\x4f\x23\x2d\x57\x40\x00\x39\x8c\xf2\x88\x18\xf7\x57\x80\x27\x1d\x91\xbd\x7a\x7e\xb1\xfe\xe6\x82\xef\xba\x2e\x2f\xf0\xa2\xd1\x51\x54\x9e\x12\x93\x6a\x91\x6f\x2b\xce\x02\x23\xba\x05\x86\x2f\xda\x78\xca\x2a\xaf\x0f\xb6\x59\x35\x3e\xc6\xeb\x45\x7f\xe8\x22\xef\xd3\x7e\xaf\xed\xd6\x7e\x7f\x1f\xe9\xc2\xad\x62\x5a\x24\xfb\xc5\x43\xc3\xa4\x8d\xcc\x9f\x55\x59\x4f\xb7\x35\x36\x62\x8b\xd9\x31\xe2\x30\x5b\x70\x63\x63\x87\x75\x8e\xf6\xa0\x28\x92\x43\xa4\x8d\x24\x87\xf0\xe3\xda\x2f\x26\x9c\x33\x61\xc2\x39\x13\xa0\xf9\x21\x86\xc1\xce\x84\x49\x1b\x06\x78\x31\x72\xc3\x69\xb1\x9e\x09\xb2\x36\x9d\xb5\x5a\xad\x56\x16\x7e\x22\x4f\xe8\x91\x5f\xda\xbc\xcc\x94\x30\xc1\x10\x80\x36\x8c\x00\x9d\x71\x38\x47\x5d\x51\xb0\x69\x01\x5e\x8e\x46\x18\x5e\x46\x58\x11\x53\x49\x35\x00\x2e\xa9\x95\x50\xf5\x60\x1d\x4b\x30\x34\xb1\xc0\xde\x5a\x59\xde\x6e\x2f\xd3\x0e\xdf\xbf\xa8\x31\x59\xd5\xd5\x76\xc9\xcf\x2b\xe2\x97\xcf\xdf\x50\x93\xcd\xd4\x37\xfa\xdb\xa3\xd3\x2c\xbb\x70\x57\xbe\xc5\x6a\xc5\x4f\x4f\x80\x67\xa0\xec\xfb\x0e\xc7\xaa\x0f\xb4\x5f\x4c\x68\x79\xf7\x8a\x17\xe6\xb0\xac\x72\x4a\xe3\x77\xb9\xcf\x8b\x9c\x38\xd4\x5f\x8c\x39\x14\x41\x58\xff\xca\x0a\xeb\x5d\x4e\x57\x36\x96\x0a\x49\x8c\x1c\x8d\x18\x42\x5e\x2a\xd9\x4a\xa8\x61\x02\xe1\x57\x6d\x0f\x6b\x3f\xfe\xe3\x4d\xda\x81\x17\x37\x6e\x7c\x11\xfc\x37\x41\xd5\x6b\xbf\xd9\xfc\xc8\xb6\x3f\xe5\x72\x7f\xda\x36\x67\xd7\xe0\xc4\x30\xad\xf5\xe1\x0f\xbb\x5a\x5e\xd7\xee\x1d\xd1\x2f\x80\x46\xf0\xbf\xb8\xf1\x57\xbf\x5a\xbf\xfd\x2d\xed\xf3\xb7\xb6\xd7\x4e\x5e\x38\x10\x2f\xd8\x95\x15\xc6\x09\x27\x2a\x41\x11\x34\xcd\xd8\x8d\x10\x19\x3a\xa4\xc8\x86\x11\x7d\x2a\xa9\x66\x93\xb1\x22\x60\x73\x92\x2a\x4a\x9c\xa2\x9a\x96\x23\x8c\xac\xf0\x92\x20\x26\xb3\x06\xb6\xa9\x22\x33\x04\xcd\x14\x1d\x3d\x24\xda\x2d\x90\xa9\x64\x2c\x93\x56\x5a\x21\x36\x6e\x94\x88\x85\x48\x91\x9c\xe4\x74\xb6\x6a\x1f\xb6\x3a\x9d\xb4\x8b\xae\xdd\xb8\xa1\x8e\x76\x69\xaf\xa4\x7b\x33\x99\x5e\xf8\x59\xa6\x37\x9d\xee\xcd\x1c\x9a\x78\x6a\x6c\xfb\x43\x6d\xcf\xe9\x89\xf1\xac\xf7\x4d\x9e\x9e\xb0\x77\x5b\x34\x9d\x9c\x18\x0f\xd2\xe0\x79\xe6\x59\xf0\x30\x81\x18\x2c\x39\xc1\xf7\x08\x6b\x9c\x8e\xd6\x56\x87\x93\xa6\xeb\xea\xe8\xdf\xf5\xa6\xd3\x71\x39\x3d\x3f\xae\x3f\x33\x3d\x50\x37\x31\x36\x9f\x06\x5f\x75\x3c\x9d\xe9\xcd\x24\xeb\x28\xb7\xf6\x1c\x33\x3f\x3e\xb1\x2e\xda\xe8\xf0\x95\xee\x7c\xfe\xf9\x9d\xa1\x12\x47\xc3\x63\xc7\x3d\x70\xe7\xce\x8f\x8f\xc5\xc1\x72\x18\x6c\x4e\xfa\x78\x6a\xb4\x53\xa4\xd8\x4e\x7a\x33\xc5\xc7\x9a\x49\xa4\x8e\x84\x54\xa3\x71\x64\x45\x95\xf4\x77\xf7\x15\x4d\x55\xf0\xb6\x57\xbe\x6c\xb7\x44\xdc\x6b\xb7\x67\xde\xcf\xd8\xed\x94\x93\xaa\x78\xb1\x82\x72\x6a\x5a\xa2\x35\x51\xdd\x5e\x0d\x03\x85\xf3\x6b\xcd\x95\x15\xc1\x35\xd7\x67\xef\x85\xea\x60\xa8\xba\x3a\x54\xeb\x7e\x82\x23\x9b\xaf\x5f\x15\xa8\xaa\x6c\x0e\x79\xa9\x8f\xef\xbe\xe7\x63\xba\x24\x08\xa9\x63\xf0\x27\xae\xb1\xdb\x33\x19\xbb\x9d\xa6\x2b\x2a\xe8\xab\x83\x89\x84\x71\x67\xf1\x3c\xa9\xa2\x39\x38\x8d\xfc\x97\x12\xaa\xaa\x6e\xaf\xae\xac\xa0\x5c\xda\xbf\xe9\xa9\xa1\xe6\x8a\x40\xd2\x5e\x22\x6d\xda\xb3\x67\x53\x89\xc7\x5e\x07\x07\x4e\xac\x97\x04\x50\xad\x81\xc8\xac\x16\xc1\xc7\x8e\x98\xa5\x18\x15\x2c\x98\x9c\x94\x02\x95\x29\x1a\xaa\xb4\x00\xa3\xb8\xf5\x0e\x74\x8c\x99\xe4\xc9\xf3\xcf\x1a\x3e\xcb\x2f\xfb\xae\x59\x37\x30\x63\x9d\x4f\xe0\x7d\x70\xd1\xd5\xfa\x69\x7e\xf3\x59\xb7\xad\x83\x19\xc7\xeb\x2f\xfb\x7c\xad\xd3\x57\xaf\x9a\xae\xbd\x2d\xf8\x7c\xc2\x86\x4d\x03\x6b\xd7\xf4\x83\x87\xf7\xfb\xf9\xec\x5b\x9b\xb6\x0a\x3e\x3f\xbf\xd9\xeb\xdf\xdc\xbf\x76\x2d\xec\x39\x5e\xab\xd1\xc7\xa8\xdb\x99\x1c\xb5\xc8\x28\xb7\x81\x8b\x54\x28\x74\xc1\xc5\xfe\x08\x79\xbd\x51\x68\x86\x0a\x8f\xe5\x48\x6a\x21\x8b\x94\x9b\x67\x36\x8f\xfe\xe4\x81\x43\x30\xb9\x79\x66\x73\xfe\xc7\xf7\x8f\x3e\x0d\x97\xc2\xe4\x43\x0f\xfc\x64\x74\xc7\xd3\xcd\x33\x9b\x89\xfa\x73\x2a\x9a\x9b\x2b\xf2\x37\xfe\xf8\xf3\x43\x0f\x80\x45\x3b\x58\xd9\xd4\x54\x89\x4f\xbf\xf7\xd3\x7f\xdf\x77\x61\xe3\xad\xda\x7f\x1f\x38\xf4\xc5\xfd\x60\x6b\x69\xd4\x3e\xad\x68\x6a\xaa\x18\xaf\xaf\xd8\x51\x29\x42\x71\x2e\xcc\x85\x0b\xf4\xa8\x27\x90\x8f\xa9\x91\x7c\xbb\x16\x5a\xb4\x03\x8f\xc0\xfe\x45\x3b\xda\xc7\xbf\xdf\x61\xd8\x8f\x47\x76\x2c\xd2\x42\xf9\xf6\x1d\x64\xe9\xb1\x06\x7b\x26\x84\x90\xd7\x84\xc8\x77\x10\x85\xcc\xc8\x6e\x70\x93\x95\xa2\xb8\x81\x9b\xa3\x4f\x0f\xe1\x12\x88\x72\xc0\xa5\x38\xc2\x9d\xca\xf0\x61\x2e\x9c\x09\x67\xc2\x71\x2e\xca\xc1\xf8\xf0\xe4\x5f\xe7\xdf\x87\xc9\x9b\xe1\xba\x17\x5e\x78\x61\x00\xbb\xf3\xff\x84\xc9\xda\xa3\x7a\xc2\xf5\x58\xc8\xbf\x0f\x93\xb4\x7d\x30\x69\x33\xf9\xce\x68\x39\xde\x97\xff\x27\xac\xd1\x2e\xc5\xee\xfc\x24\xbc\x0f\x02\xbf\xfe\xb5\xf6\xd7\xd1\x81\xdb\x07\x76\x17\x12\x8f\x04\xc7\x7d\x5f\x66\x03\x1b\xb5\x16\xb5\x17\xf8\x77\x0a\x3e\x1f\xe3\x42\xce\x22\x90\x37\xc3\xa9\x19\x31\x95\xc4\x46\x3c\x5a\x88\x7c\x49\x11\x17\xfb\x32\x95\x3e\x7f\x45\x46\xfb\x4f\x31\x80\xb7\xde\x7f\xae\xc0\x4b\xea\x9c\x2d\xaf\xa4\x3a\xcf\xbd\xeb\x27\xe7\xf6\x76\xfd\xf4\x15\xb5\xe5\x5c\x42\x3a\xc6\x88\xb2\x3b\x37\xdf\x01\x6e\x0e\x66\xe4\x16\xe8\xe7\x7c\x1d\xd8\x9e\x24\xa6\x35\x2e\xa6\xf3\xe7\x97\xbf\xc8\xe3\xe5\x60\x7b\x32\x36\xfa\x68\xf9\x8b\x3c\x7c\x7e\x6c\xfb\x5a\x50\xf9\x61\x33\xf3\x02\x8d\xd0\x76\xf4\x38\x7a\x1e\xbd\x88\xde\x40\x7f\x43\x7f\x47\xef\xa2\x0f\xd0\x47\xba\x0e\x1a\x20\xa4\x00\x96\x58\xcc\x24\xa8\xa8\x03\x44\x29\xc0\x04\x41\x64\x31\x23\x17\x1c\x48\xd2\x6a\x2b\x56\x64\x43\x45\x35\x2c\x6f\xc8\x82\xb0\xad\x4f\x89\xad\x44\x41\xa3\x96\xc6\x24\x6c\x4c\x17\x51\x3a\x70\x26\xad\x2a\xfa\x00\x62\xf8\xc8\x49\x2a\x4b\x48\x6a\x82\x51\x12\xb8\x02\xa2\x11\xa6\x95\x52\x03\xb8\x0d\xdc\x52\x56\x6d\x35\xb5\x15\x6c\x96\x58\xcc\x04\xc0\x2d\x10\xfa\x03\x03\x44\x41\xb2\x53\x25\x06\x0a\xc0\xd4\x4a\x2b\x4e\x01\xa3\xe8\x99\x7c\x4a\x62\x20\xe3\x76\x40\x1b\x26\x9f\x9d\x72\xd1\x29\x4b\x3b\x2a\xc3\x0b\x9a\x27\xd4\x6e\xbc\x31\x56\xd5\xec\x53\x12\xa7\xf4\x58\x68\xd2\x4c\x57\x31\x41\xca\x45\xd0\x00\xc0\x98\x38\x22\x7a\x7e\x48\x09\x63\x02\x37\xa9\xe0\xe1\x63\xd7\xb4\x94\x9c\xb6\xda\x4f\xbb\xb5\x40\xd0\xe9\xe1\x58\x78\xc7\x64\x75\xf3\x3e\x8a\x94\x68\x87\x97\xb9\xdd\xcc\x95\x70\x8e\x87\x01\xee\x10\x6b\x2e\xab\x51\x6b\x2c\xdd\x95\xd4\x40\x6b\x95\x5a\x21\xb8\x2d\x1e\x5b\x92\x28\xab\x8e\x42\x0b\xc5\x31\x2c\x6d\x61\xcc\x24\xe3\xf0\xba\x6a\xd8\xad\x0b\x9c\x65\xdd\x6d\xa5\x93\x4c\xb6\x50\x48\xb4\x89\x9f\x6d\xf1\x57\x95\x97\x44\xd8\xa8\xb5\xd2\xc4\xe0\xf2\xe9\xa3\x7b\xd9\xfa\x2a\x8e\xa8\xfc\x4c\xd9\x97\x35\xfb\x4a\xa5\x12\xbc\x71\x73\x4b\xbb\xf6\x45\xed\x19\x3d\x70\x2b\x11\x6d\x48\xd5\x93\x8c\x7b\x7a\x87\x5f\x9b\x30\x44\x5b\xaa\x6d\xfc\x2b\x41\x4b\x39\xb1\x11\xb0\xfe\xff\x62\xa2\x66\xe2\xfa\xef\x4c\xae\x5f\xa1\xb6\x04\xd4\x36\x67\xfc\xc6\x3d\x8f\x5f\xf5\x1d\x4c\x52\x66\x2a\xce\x94\xda\x02\x25\x71\x31\xec\x6d\x2b\xef\x73\x80\xdb\xe2\x0c\xf6\x8a\xf6\x86\x16\x37\xf6\x66\x16\x6d\xbd\x4e\x20\xbd\xab\x45\xa7\x43\x22\x56\xb0\xa2\xdd\x42\x52\x18\xec\x21\x2e\x2e\x72\x0e\x91\x28\x73\x7a\x1f\x19\xae\x8b\x45\x08\xc1\xe3\x74\xf1\x55\x3d\xde\x90\x93\x60\xed\xb1\x60\xbb\xbf\xa4\xac\x0c\x5b\x1d\xbf\xa7\xdc\x26\x07\x6d\xa1\x28\x4c\x90\x50\x19\x08\x7b\x13\xbe\x93\xcc\xe6\x6a\x3f\x40\x1f\x2c\x5e\xec\x8e\x29\x52\x35\xd7\xc0\xf7\x39\xcc\x99\xd9\x77\x3c\x5b\x49\x98\x2d\x66\x3e\xcb\x58\x47\x67\x7a\x2b\x83\xd9\x44\x3d\x55\x6d\x25\x62\xb6\x9f\xd4\x6a\x2f\x3b\x80\x71\x58\x4d\x0c\x54\x62\x3b\x83\xcf\x12\x38\xb0\xe5\xb7\x9c\x64\xa3\xeb\x00\x8c\x27\x17\x74\x5c\x17\x8d\xa8\x0f\x91\x84\xb2\x68\x11\xda\x81\x10\x25\x17\x57\x43\xa2\x91\x82\xf9\xb8\xe1\x6d\x69\x98\x35\x17\xbe\x32\xc3\xa4\x8e\x49\x25\x0d\x83\x35\x35\x0b\xe9\x04\xd6\x05\x91\x28\x9d\x20\x0c\xb5\xc8\x98\xd5\x5a\x0b\xb6\xcf\x86\xc5\x97\x50\x9c\xeb\x33\xe9\x56\x4a\x35\xba\xac\x5a\xd4\x8f\xc8\x4b\x29\x3e\xb0\xb6\x77\x5b\x3b\x65\xb2\x3a\x18\x30\x45\x56\x9e\x9c\x2c\x9f\x53\xc9\xd8\xaa\x78\x41\xca\xd4\x78\x4a\xeb\xbc\xac\x99\x93\x08\x07\xcd\x9a\x9d\x2c\x6f\xf5\x45\xad\x26\x0b\x65\x91\x60\xbe\x45\xaa\x0e\x84\x73\xdb\x63\xbe\x9e\xe9\x73\x57\xab\xeb\x76\x63\xdc\x57\xda\x35\xb1\xe1\xea\x73\x36\x85\xbc\xd3\x3a\x26\x09\xd1\x9a\x90\xbf\x34\xb3\xe5\x65\xed\x9f\xda\xcb\xda\x3b\xaf\xe6\x94\xa6\x81\x29\x03\x35\x3c\xdb\x1b\x6d\x09\xc4\xaa\x4c\xdb\x1a\xaa\xee\xab\x74\xc7\x66\x75\x9d\xa4\x2a\x49\x9e\x15\x23\x75\xa4\x8d\x16\x2c\x21\x3f\x41\x90\x61\x1f\x63\x3b\xbf\x86\x75\x58\x6c\x55\x1e\xc1\xc4\x08\xd8\x4e\x5a\x48\x9a\xc0\x0e\xd6\xc1\xd1\xa4\x0d\x6a\xc4\xea\x6a\xff\x49\x33\xa1\xac\xb1\xb1\x0c\xe0\x86\xd3\x56\xa7\x05\xae\x63\x6a\x3b\x40\x4b\x4f\x2b\x10\x91\x44\xf9\x86\x17\x77\x6b\x7f\xff\xd9\xe9\xeb\x7e\x09\xfe\xe1\x79\x77\x6d\x59\x33\xa5\xbd\xd4\x62\x8a\x0b\x65\x1e\xff\xbc\x19\x37\xc8\xa5\xd3\x7c\x76\xcf\x84\xc9\xe7\x6c\xbd\x17\x8d\xc7\xde\x0a\xa0\x66\x34\x1f\x6d\x40\x08\x1c\x98\x05\x65\xcc\x9f\x57\x95\xb3\x6d\x20\x31\xb4\x20\x89\xc9\x36\x82\x90\x18\x45\x8e\xd0\x42\x90\x60\x6a\x70\x02\xd4\x44\x01\x47\x48\x94\xb2\x62\xc1\x89\x54\xa1\xe5\x1a\x50\x25\x5d\x00\xab\x21\xd4\x20\x0e\x00\x13\x00\x42\xa0\x19\xd1\xf0\x1c\xce\xa6\xe5\x88\x83\x50\xda\x70\x2b\x48\xc6\xc0\x41\x26\x86\xaf\x09\x74\xec\x99\xe5\x5c\xdd\x33\x6b\xc3\xbc\x09\x62\xa2\xc3\x76\x8d\x35\x1e\x8f\x2f\x8b\x07\xae\xb9\xf5\x49\xdb\xb5\xb6\xf8\xb2\xde\x78\xe9\xb5\xc3\xd7\xdc\x7a\x4d\xa0\xbb\xca\x37\x71\xfe\x86\x59\x7d\xeb\x6c\x33\xef\x25\x96\x6e\x98\xd5\xbb\x96\x9d\xfd\x58\xb7\xf5\x1a\xe3\x9a\xc0\xb5\xc3\xd7\x0e\x5f\x5b\xda\x5e\xe3\xee\x3b\x0d\x2f\xe9\xf3\x26\xba\x6c\xd7\xd8\xe2\xbd\xcb\x8c\x8c\x5b\xaf\x2d\xed\x7a\x74\xb6\x75\xdd\xb4\x59\x1b\xe0\xa5\xe1\x6b\x03\xed\x09\xf7\xc4\xf9\x1b\x67\x4d\x5e\xed\x9c\xfd\xa3\x0e\xdb\xb5\xd6\xf8\x32\x39\xae\x5f\x88\x5d\xfa\x2f\xf6\x2e\xd7\x7f\xf1\xda\xe1\x6b\x03\x5d\xfb\xe6\x38\x56\xf7\xcc\xda\x78\x72\xaf\x50\x73\xe8\xaa\x59\x1b\x07\x27\xf9\xab\xba\x8d\x4b\x96\x15\x7f\x30\xd0\xbe\x67\x96\x75\x1d\x29\x4d\x3d\xcb\x3a\xeb\x91\xae\x62\x79\x8b\x59\x5d\xd5\xde\x29\x4b\x36\x16\x78\x3b\x0a\x98\x19\x13\xd0\x5c\xb4\x00\x2d\x46\x4b\xd1\x0a\x74\x11\xba\x1d\x21\xd0\x9b\xcb\x30\xfd\x2c\x18\x73\x2a\x45\x0b\x45\x55\xd6\x87\x43\x5a\x28\x18\x72\x2a\xb2\x62\x38\x1d\x67\x53\x7a\x26\x96\x44\x46\x30\x6c\x3c\x0b\x26\x9b\x84\x61\xa0\x19\xd5\xaf\x52\x8d\xdd\x30\x35\x49\x49\x0a\xc4\x39\x0a\x24\x42\x21\x24\x55\x02\x8a\x03\x89\xd1\x7f\xc2\x40\x84\x29\xac\x8b\x18\xf7\xa6\x92\xc6\xc7\x05\x9c\xb1\x95\xad\xa4\x15\xce\xb0\x6e\x51\x39\x2a\x59\x05\xa9\xa4\x9b\xc3\x3b\x41\x12\x84\xaa\x4a\xa6\x9b\xec\xea\x9a\xe1\x21\x83\x04\xdd\xe7\xde\xc6\x72\xdd\xd8\xb4\xc4\xa4\x04\x30\x06\xca\x2b\x79\x5c\x16\x12\xe8\xb8\xb5\xb1\xe6\x54\x6c\xe9\xb4\x9a\x4b\x48\x12\x13\x25\x7e\xa2\x24\xdd\x6e\x3b\x97\x22\xed\x2f\x11\x8c\x4d\x0e\x04\xbc\x12\x4b\x02\x11\x16\x6a\x63\x3c\x87\x9f\x6c\xfb\xfe\xa1\xcf\xf1\xc3\xf9\x5e\xf2\xf5\x25\x0f\x9d\xfa\x87\x25\xd5\xaf\x68\x09\xdc\xa2\x1d\xbc\x39\x5b\xb6\x7d\x57\x63\x78\xe6\xf4\x4f\xda\x4c\x16\x13\xe9\x0f\x93\x3d\x7b\x26\x2d\xbe\x6c\x96\x23\x18\xb7\xc0\x55\xa3\x07\xd9\x7c\x82\xb1\x53\x40\x00\xe5\x58\x59\x81\x13\x18\x5a\xa0\x89\x14\xe0\x79\x82\x31\x99\x85\x52\x2a\x83\x97\x4e\x5b\xec\xc0\x24\x26\xe7\x7a\x1e\xf6\x05\x2e\x32\x43\x04\x5b\x4d\x80\x39\xb0\x50\x0c\x43\x72\x34\x87\x69\xc2\xe9\x8c\xe2\x28\x49\x58\x00\x6c\x6e\x9c\x6c\xa0\x92\x33\xfc\x74\x1a\x43\x1d\xec\x77\xd8\x25\x87\x8d\x90\x1c\x5e\x82\x20\x49\xd6\x86\x77\xfd\xad\x22\x7f\xdd\x3f\x48\xd3\xbb\xf9\x6c\x10\x5f\x1e\xcc\xff\x23\x78\x66\x07\xd1\xf4\x28\x6c\x39\xc8\xd9\x87\x3b\x4f\x2a\xb1\x4d\x4b\x30\x66\x93\xd5\xe1\xc2\xf1\xba\xd2\x18\xc3\xb9\x69\x32\x77\xe8\x57\xff\xa5\xff\x65\x07\x4c\x66\xcd\x40\x53\x31\x16\x72\xcf\x9e\xb9\xd2\xad\x0d\x1a\xfe\xc6\x63\xd8\x0b\x0a\x52\xd1\x24\x34\x07\x2d\x45\xeb\xd1\xf7\xd0\x35\xe8\x2e\xf4\x08\x1a\x39\xb2\xd2\x73\x84\x1c\x96\x3a\x16\xb2\x5c\x97\x1f\x82\x10\x00\xf7\x51\x1a\xbd\x02\x1e\x3b\xf7\x0d\xf1\xff\xaf\xaf\xe7\x0b\xc0\x62\x61\x0e\x42\x9d\x83\x83\x9d\x39\xfd\x40\xed\x6f\x9c\x78\xf5\x8a\xd1\xe1\xce\xc1\xfa\x32\x3c\x5c\x36\xe4\xbf\xd6\x5f\x96\x0f\x19\x40\x47\x5f\x79\x00\xf4\xff\x96\x3f\x34\x5c\x56\x9f\xcf\x91\xb9\xc1\xce\xa3\xec\xca\xb7\x47\xce\x99\x90\x47\x2b\xae\x1e\xec\xa4\x51\x59\x7d\x99\xff\x5a\xff\x50\xd9\xa1\xdc\x91\xdb\x80\x3d\x51\x50\x3b\x61\xea\xff\x72\x01\xec\x04\x54\x5f\x36\xac\x21\x24\x14\x6c\xe8\x69\x54\xdc\xbb\x69\x43\xd3\xd1\x62\xb4\x0a\x9d\x67\x30\x08\xfe\x18\xfd\x0c\xbd\x84\xde\x42\x1f\xa1\xc3\xe0\x80\x20\xd4\x40\xdb\x09\x56\xfc\x8e\x90\x24\x16\xda\x9d\xfb\x1f\xe3\xc4\xff\xf8\x3e\xbf\x4d\xff\x38\x1e\xc8\xe7\xff\xf5\x79\xff\xff\x2c\x1f\x65\x18\xab\x1c\x2a\x58\xa9\x8c\x1c\xa5\x1d\xf8\xfa\x43\xee\xdb\x5e\x78\xf4\x80\xd1\x38\x66\xa2\x6f\x7d\x17\xa0\xff\xfd\x97\x68\x24\x7b\xbf\x30\xd6\xb9\xe8\x9c\x57\xd6\xc6\x41\xce\x7e\xfa\x4d\xc1\x07\xbe\x01\x02\xe9\xc4\xc1\x43\xec\x11\xe0\x14\xfc\x3f\xdc\x36\xfa\x3f\x5c\x7b\x0c\x0c\x13\xc2\xa8\xfd\xb0\x93\x1c\xa1\x86\x50\x10\x29\x08\x99\x8f\x37\xb2\x03\x39\xad\x8e\x19\x0b\x49\xa2\x30\xe6\x65\x4a\xee\xd6\xde\x28\xda\xd6\x69\x6f\xf8\xfd\xa5\xd3\xfd\x07\x60\xf5\x01\x7f\xbf\xdf\xaf\x0d\x17\x0c\xec\xde\xd0\xde\x18\x7d\xce\x30\xad\xcb\x69\x39\xc3\xb4\xae\x1e\x62\xfa\x05\xfe\x03\x07\xf4\x1b\xde\x2e\xd8\xd6\x51\x45\xee\xe5\x1c\x72\xa0\x52\x63\xd7\x68\x06\x42\x20\x14\xf4\x9e\x4c\xda\xd0\x4b\xa0\xc0\x15\x03\xc5\x29\x94\x4a\x92\x2e\xb7\x60\xf0\xc5\x44\x23\x74\x34\x92\x49\xb7\xe2\xf8\xb8\xab\xdd\x02\x0b\x71\x83\x1b\xa6\x20\x4e\xb5\x02\x61\x93\xe7\xb6\xf4\x6d\x69\x96\xe7\xb6\x4c\xdd\xdc\xac\xdd\x33\x73\x6a\xdf\x8e\x89\xc6\x01\x2e\x3e\x07\x5c\x8f\x46\xda\x3a\x2b\xbb\x3f\x6a\xeb\xcc\xf7\x3e\xb2\xfa\xae\x97\x61\x72\xcb\x5c\xb9\x79\xf3\x54\xfd\xb8\x05\x4e\x9d\x3a\x73\xe2\x8e\x3e\xfd\x40\x96\x35\xaf\x9c\xb6\xee\xc6\x1e\xfd\x78\x43\xfe\x95\xfe\x73\x56\xdd\xd8\xdb\xbf\x7e\xd5\x4d\x35\x4f\x6b\xef\xae\x4b\xb4\x94\x5a\xe7\xcf\xdb\x35\xfb\x95\x1f\x9d\xf3\xca\xb4\x95\xcd\xbd\x37\xac\x9b\xb6\xb2\xb9\xe7\xc6\x75\xcb\xd6\xf7\xf7\xde\xb8\xea\x9c\xfe\xde\x9b\x56\x21\x40\xed\x87\x11\x1e\xa1\x91\xe1\x1b\x2a\xd0\x0c\x2f\x16\x9d\xdd\x0b\x85\x4f\x06\x00\x8f\xac\x5d\x5c\x8d\x63\xde\x11\x6f\x0c\x57\x2f\x5e\x3b\xeb\xea\x7b\xae\x9e\x45\x7c\x7c\xf9\x33\xf1\xd1\xff\x33\x2c\xc1\x32\xf1\x67\x2e\xcf\xfd\xeb\xa6\x9b\xfe\x75\x14\x53\x64\xcc\xef\x28\x88\x10\x05\x1c\xa5\x54\x83\x5d\x7f\x89\x05\x24\xd5\x22\x56\x88\xb1\x88\x1a\x00\x22\x87\x73\xf9\x5c\x3b\xfe\x69\x7e\x62\x7e\x22\x75\x30\x16\xcc\xb7\xfb\x3b\xfd\xf9\xf6\x60\x2c\x21\xe3\x11\xb1\x4a\xc4\x23\x72\x62\x11\x2c\xc2\x5b\xde\x5d\xa3\x69\x1a\xce\xa3\x68\x33\xa7\xe5\x9c\x4e\xc8\x71\xcd\x51\x02\x95\x75\xb2\x80\x4c\xa6\xc3\x88\xed\x2c\x40\xe5\xa1\xc3\xc8\x54\xe0\x31\x39\xea\x15\xdd\x89\x10\x15\x37\xca\x41\x41\xf1\xac\x8c\xc5\xf5\x72\x51\x74\x44\x89\xcb\x4a\x31\x50\x2c\x60\xdc\x38\x64\x93\x92\x31\xf9\x52\x01\xc0\x06\x89\x50\x3b\x5c\xa9\x9d\xae\x9d\x4e\xfd\x6e\x5c\xa4\xaa\x10\xde\xa7\x4d\xd2\x26\x51\x5f\xc8\x61\xad\xbd\xa4\xbd\x44\x6b\x27\x09\x4c\x15\x83\x61\xb9\x32\x0a\x0f\x54\x46\x61\x44\xca\x4a\x30\x12\xad\x84\x07\x62\x15\x43\x23\xd0\xb8\x7b\xf5\x9e\x3d\x7b\xf2\x97\x8c\x85\x36\xdc\x01\x96\xdd\xab\x9f\x78\xe2\x89\x7c\x8b\x36\x14\x6b\x75\xee\x67\xd9\xfd\x18\x63\xac\x9f\x9d\xad\x31\x18\x96\xdb\x9d\x3f\x85\xcb\xe4\x76\xe7\x88\xc5\x32\xe2\x6c\x97\xb5\xd5\x3f\x75\xb6\x17\xf6\x54\x34\x13\xa2\x30\x22\x90\x19\x05\x91\x8c\x12\xa8\x03\x21\x08\xbb\xc3\x44\x84\x66\xc2\x32\x91\xcc\xaa\x29\x1c\x8e\xe0\x4c\x1a\x15\x7a\x24\x13\x16\xc4\x78\x38\x99\x49\x47\xc3\x99\xb0\xae\xab\x47\xc3\xf1\x70\xd2\xa0\x38\x32\x3a\x2c\x11\x0d\x33\xf5\x1a\xc0\xe1\xd1\xf9\xab\x69\xb8\xd6\x75\x67\xdb\x39\xdc\x9b\xa7\x6a\xfb\x7e\x9f\x07\xea\xc5\x8b\x5f\x38\x0d\xe7\xcf\x5c\x77\x28\x0b\x65\x2f\xfc\x52\xfb\x2d\x94\x4c\x5b\xf0\xa4\x36\xaa\xfd\x13\x0f\xcc\xb9\xf0\xec\xb6\xfb\xd6\x9e\x55\x77\xd2\xda\xdc\xc4\xfc\x4d\xe4\x9e\x2d\xda\x6f\x97\xcf\x7f\x3a\xff\x48\xbb\xaa\xbd\x00\xa6\xd7\x5e\x06\xfe\xc2\x3f\x5f\xc4\x05\x56\x6d\x4c\xde\xb5\xf7\xc9\x9e\xa9\x97\xbd\xe6\xef\xda\xba\xe0\xa1\x81\xd0\x9d\x1b\xa7\x6c\x9e\xd9\xe8\x2d\xbe\xc3\xb1\xf5\xcc\x00\x8a\xa3\x2a\xd4\x81\x26\x19\x3c\x3f\xc7\xcd\x86\xbc\xb1\xfa\x94\x49\x2b\xc6\x42\x03\x11\xcd\xa4\x92\x6e\xa1\x78\xa2\x22\x72\x26\x9c\xcd\x1c\x45\xf7\x51\xa3\x2c\x10\x49\x29\xda\x0a\x44\xd8\x1d\x1e\xbf\x13\xf6\x8a\x76\x09\x6c\x3d\x7b\xf8\xd2\x95\x4a\xef\xcc\xa9\xf7\xdf\xbe\xfe\x3b\xfb\x9e\xd8\x82\x2d\xdd\x93\xe1\x06\xb8\x6a\x5b\x6e\xf7\xcd\xdf\x7d\xa1\xf5\x62\x6b\x4f\xdd\x1a\xab\x46\x4e\x5c\x01\x6d\xda\xcf\x8f\xdd\x05\xd3\x2e\x1f\xfd\x60\xdd\x9a\x9b\x2b\xd2\xab\x1b\xa6\x57\x70\xda\x53\x8f\xce\x1f\xd4\x7e\xf2\xfa\x9a\x65\xa1\xbe\x09\x16\xe1\xfc\x9f\xdc\xb7\xfd\x7b\xbb\x7f\x16\x29\x83\x33\x37\xd5\x77\x82\x65\xea\x98\xae\xc5\x8c\xe1\xdc\x2b\xa8\x6d\x1c\x6b\x81\xb1\x06\x2b\x8d\xd9\x9f\x29\xba\x64\x0e\xe3\x10\x8a\x54\x01\x45\xc1\x18\x43\x6a\x80\xa3\x0c\xf3\x99\x2c\x4a\x25\x11\x9d\xb8\xf4\xf9\x4b\x2f\x7d\x3e\x7f\xc9\xae\x65\x3e\xdf\xb2\xa9\x1d\xc1\xe0\xb5\x7d\xee\x01\x21\x74\xce\xa4\x65\xc4\xcb\x0f\x6e\x3d\xef\xc1\x07\xcf\xdb\xfa\xe0\xd5\xda\x7f\x1e\xd7\xa6\xd8\x9e\x3a\x7f\xe3\x4f\x4b\xde\x81\x0b\xa6\x0f\xda\x45\xf0\x63\xb0\x3e\xf6\x38\x58\xc9\xa0\x7e\xff\xa5\x87\x9e\x7c\x79\x17\x5d\x11\xbc\xa6\x6f\x6a\x7b\xd0\x14\x36\x35\xf7\x10\x6f\x6d\x7d\xf0\xc1\xad\xe7\x3d\xf0\xc0\x79\x4f\x68\xff\xd5\x7e\xbe\xed\x81\x6b\xcf\x5a\x08\x7b\x6e\xaa\xc5\x70\xcd\x63\x60\xd2\xfe\x83\x8e\xd1\x1d\x4d\xc8\x87\xba\xd0\xd4\x22\x12\x80\x5b\x10\x0b\x8b\x63\xb2\x62\xb8\x2f\x67\xe5\x1a\xc8\x1e\x5d\x08\x6b\x19\x53\x3c\xe2\xc9\xe2\x7b\x62\x08\xbd\xf6\xf1\xb1\xf5\xe5\x42\x9b\xe8\xca\xe1\x1f\xd7\x0e\xaf\x59\x33\xac\x39\xcf\x1a\xa8\x1f\x2c\x49\x27\x9a\x37\x94\x78\x52\x2d\x03\xa2\x30\x40\x8c\x16\xde\xc4\x7d\xc2\x15\x8b\x97\x5d\x6f\x81\x79\x57\xbf\xf2\xca\xd5\x57\xfe\x16\xff\xc5\xcc\x4f\x69\xd5\x5e\x2b\xbc\xa0\xcf\x76\x3e\x77\xc9\x25\xa7\x9e\x76\x09\x51\x3e\xbc\x66\xed\xf4\xfe\x35\xda\x73\x77\xae\x6b\xac\x15\x04\x4f\xaa\xa5\x79\x83\x27\x4c\xe1\x33\x0a\x2f\xf3\xba\x09\x0b\x37\xfc\x60\xe9\xe8\x2b\x57\x5d\xfd\xca\x6f\xae\xd4\x9e\x84\xf8\x7a\xf8\xdd\xfa\xbb\xef\xd6\x86\x4f\xbd\xe4\x92\xe7\x76\x5e\x82\x68\xe4\x3c\x3c\x9b\xfe\x88\x3a\x8c\xec\x28\x80\xaa\x51\x33\x9a\x62\xa0\x26\x11\x4c\xdc\xd8\x7c\x6d\xc5\xaa\xe8\x03\x85\x25\x1c\x40\x24\xa0\x0d\xb2\xaa\x02\x04\x6b\x20\xeb\x4a\x04\xaf\xb7\x00\xd0\x44\x5c\xe1\x5b\x41\x0a\x50\xc0\x8b\x34\xc3\x52\x8c\x4c\xc4\x15\x95\x88\xab\x09\xa2\x06\xa8\xac\x18\x04\x91\xe8\x76\x60\x6d\x61\xac\xd5\x69\x65\x1c\xe6\x08\x9e\x56\xb5\xf7\x8a\xb6\xef\xd4\x06\x09\xf2\x49\x0e\x33\xa6\xe8\xf4\x1f\xd0\xb9\xc7\x6d\x75\xbc\x6b\xd2\x95\xa6\x77\x5e\x61\xee\xf9\x6b\x43\x5e\xa9\xf9\xa3\xf6\x34\xff\x17\xa1\xbf\xcc\x53\x17\xad\xf5\xd4\xe2\x6b\x7e\xe7\xb2\x8a\xf6\xb2\x58\x4b\x78\xa2\x35\xf2\x77\x68\xd8\xb2\xf3\x0d\x6d\xd1\x35\x91\x81\x09\xcd\x1c\x07\x57\x05\xb3\x36\xab\x02\xab\xb4\xcb\xc4\x52\xa2\x21\xee\xab\xef\x8d\x2d\x64\x6c\xb8\x51\xbb\x60\xe1\xe4\xcb\x97\xcf\x74\xbb\xe1\x34\x6f\x33\xe7\x6a\x3b\x77\x76\xfe\x3d\xed\xba\xd2\x28\x41\x32\xd4\x6e\x58\x05\x2b\xf6\x38\x45\x91\x78\xa0\x4d\xfb\xc1\x63\x36\x38\x35\xe8\x27\xb1\x20\x56\x95\x64\xb5\x67\xb4\xab\xe2\xd3\xa2\x42\x44\x14\x2d\x2e\x62\x32\x9c\xfe\xf4\x07\x27\x69\xdf\x17\x66\xcf\xbb\x7e\x51\x97\xdd\x0e\x84\xcf\xe1\x68\x29\xf4\x91\x76\x53\xa1\xcf\x73\xa8\x04\x75\x1d\x45\x8b\xe0\xc3\x44\x02\x0c\x72\xfd\x23\x29\xe3\x1d\x47\xc3\x63\x0e\xa4\x63\x44\x22\x7c\x2b\xe8\xdd\x43\xe2\x53\x49\x11\xf6\x0f\x9e\x3f\x38\x78\xfe\x76\xe2\xf3\x79\xd8\x63\xce\x23\xb3\x07\x53\x84\x91\xa4\xb9\xd8\xa1\xd5\xc3\xab\x47\xd1\xea\xe1\xd5\x43\xac\x6b\xc7\x22\xff\x72\xe9\xb6\x93\x09\x74\xf2\x6d\xd2\x72\xff\xa2\x1d\xb0\x55\xbf\x68\x10\xf6\xc3\x69\x26\x9e\x37\xe5\x4b\x0a\x51\xa4\xe5\x58\x57\xae\x7f\xf5\xea\xfe\x5c\xe1\xe8\x62\x21\xb7\x68\x07\xdc\x3e\x78\xde\x79\x83\xda\xa2\x1d\x05\xbf\x5a\x93\x3e\xdc\xa6\x50\x13\x9a\xa0\xf7\xf5\x23\xba\xda\xd7\x14\xb8\x80\xb3\x1c\x2e\x32\x62\x49\xfc\x98\xdf\x2c\x1c\xad\x7b\x31\x85\x09\x2d\xda\x71\xc2\xa2\xe7\x0a\xa8\x78\x39\xbd\x02\x5f\x1c\x2c\x14\xf7\xd4\x71\xf5\x26\xc3\x46\x1a\xce\xed\x58\xa4\x57\xa2\x5d\x2f\x7e\x7b\xe1\x78\xb4\x12\x05\x00\x5a\xbd\x2a\x5a\xc8\x68\x26\xd8\x5e\x68\x80\xd1\xc7\x8c\x28\x02\x14\x3a\x8c\xa8\xfd\x46\xfd\x50\x4c\xff\x50\x03\x63\x58\x7f\x99\xb4\x81\x39\x9c\x56\xf5\x9a\x1d\x39\x16\xf8\x84\xe9\x4a\x28\x1e\xa9\xfd\xb2\x57\x4b\x82\x25\x56\xa2\x8d\x94\xc4\x2c\xa0\x25\xbd\x32\x0f\xbb\xde\x36\x8e\xcf\xe8\xc7\x1c\x9f\xd6\x0f\xb2\xf7\x19\xd8\xc5\xcb\xde\xb7\x61\xd7\xfc\xb4\xcc\x5d\x22\x97\x44\xa3\x25\xf2\x25\x9c\x9c\xe6\xe1\x8a\x23\x87\x1c\xcf\x6b\x39\x3e\x2d\x6b\x67\x18\x87\x71\x63\x8d\x1b\x55\xa2\x6e\xc3\x16\xa6\x08\x9a\x54\x18\xe5\x8b\x6e\xd8\x59\x35\xad\xc8\xe1\x71\xa9\x21\x23\x95\x4f\x2b\x72\xcc\x58\x4f\x3c\x72\x35\x69\xd0\xf3\xc1\x78\xd3\xb4\xa5\x81\x9f\x6b\x17\x5c\x5f\xe1\x13\xa9\xd0\xf9\xab\xfe\x7a\x2f\xcf\xf2\xfe\xa1\xe8\x07\xda\xaf\xae\xbb\xba\x36\x5a\xc2\x04\x36\x6d\x03\xe9\x37\x1e\xb6\x24\x7a\x7a\xd9\x56\xed\x81\xfb\x7f\x3d\x2c\x05\xcb\x83\xd6\xd2\x0b\x7e\x74\x0b\x54\x2f\x75\xf3\xa5\x95\x2f\x1c\x0f\x3f\x3f\x31\xc4\xaf\x8b\x98\x2b\x85\x52\x93\x6f\xa9\xd5\xf7\x7e\x99\xfb\x92\x0a\x7b\xaa\x24\x6a\x0a\x6f\xb1\x47\x81\xab\x91\x7a\xa6\xd4\x30\xf1\x40\xb0\xc2\x14\xef\x6e\xb1\x95\x2f\x38\x6e\x33\x08\x0a\x5c\xb6\x34\x42\xbc\x2e\x0d\x4b\x61\x2e\xcc\x10\x4c\x98\x03\x25\xcc\x85\x55\x5e\x0d\x93\x48\xfb\x8d\x07\x24\x8d\xaa\xda\x19\xd0\x5e\x81\x1a\x8f\xf6\x2e\x1c\xaa\xda\x19\x80\x6a\xf2\x37\xf9\x9f\x06\xb5\xef\x04\xb4\x8f\x02\x50\x83\x27\x05\xe0\x96\x00\x70\x01\x84\x10\x87\x10\xfa\x81\x19\x91\x67\x21\x16\xc5\x0d\x46\xfb\x66\x34\x19\xcd\x44\x27\xa3\x53\xd0\x1a\x74\x1e\xba\x04\x5d\x86\x6e\x46\xf7\xa1\x11\xf4\x3b\x84\xe2\xaa\xde\x4b\x23\xb4\x9b\x30\x46\xec\xb8\x4a\xa4\x15\x59\x6f\x5b\x86\x10\xa4\x31\xf2\x80\x0c\x48\x86\x9d\xbf\x9a\x4d\xaa\x12\xa3\xcb\xc0\x8a\x9a\x4e\x25\x81\x90\x18\x21\x6a\xa4\xa7\x92\x41\x38\x9a\x11\x2c\x1a\xee\x28\xaa\x3e\xc6\x9b\x81\x67\x04\x83\x19\x89\xd7\x47\x7c\xf5\xf8\x58\x21\x52\xf0\x0b\x6f\x00\x42\xcf\xd6\xe7\x40\x3e\x9d\xd5\x3f\xa7\xb1\x58\x2b\x24\x45\x9e\xa9\x33\x62\x98\xcf\x64\x8b\xce\xf8\x06\x7e\xb3\x21\xd5\xe9\x09\xc8\xd8\xa4\x20\x9c\x4e\x27\xd8\x2d\x66\x96\x65\xc1\x6e\x16\xa1\xc2\x6a\xb3\x9b\x9c\x26\x3b\x58\xac\xb4\x99\xb5\x9a\xcd\x87\xde\x17\x04\xcc\x62\x8e\xc3\xec\x5c\xaf\x17\x9b\xcc\x92\x64\x36\x81\xf7\xf1\x92\x12\xab\x05\xbb\xdd\xd8\x62\x1d\x94\x24\x6c\xb3\xbb\xdd\x76\xdb\x90\xdb\x8d\x59\xda\x2c\x08\x66\x9a\x85\x6d\xda\x5b\x6e\xb7\x85\x71\x62\x97\x0b\x3b\x19\xcb\x20\xcf\x5b\x4d\x2e\xec\x74\x62\x97\xc9\x7a\xb2\xcb\x85\x05\x1e\x3b\x9d\x76\x93\xd9\x06\x17\x3d\xeb\x70\x38\x04\x16\x58\xd6\x21\x38\x4e\x61\x59\xa7\xe8\x04\x9b\x0d\x9c\xa2\xe3\x55\xd6\xe5\x75\x01\x4d\xdb\xb0\xc5\x6c\x35\x31\x2c\x26\x97\xdc\x79\xf6\xe8\x87\x76\x97\x7f\xd6\xd0\xd3\x10\xe0\x32\x0d\x67\xdf\xb9\xfb\x13\x6c\xb5\xb0\xac\x25\xff\x9f\x4f\x2c\xf6\xf4\x2b\xb8\xd7\x69\xa2\x28\x93\x93\xce\x3f\x01\xff\x04\x0b\x63\x35\x33\x76\x38\x3d\xb7\xd5\x6c\xde\x9a\x33\x4f\x7c\xe9\xff\xcc\x96\xe7\x5f\x32\x6b\x49\xf8\xe7\x7f\x3e\xb0\x5a\x3f\xf8\x8f\x8d\x1a\xfd\xb7\xdd\xfe\xef\x51\x7b\xf0\xbd\xff\x3a\xcd\xcc\x7f\xdf\xa3\xcd\x9a\x88\xcf\xd0\xce\xff\x2f\x63\x75\xfd\x17\xb6\xb8\xac\xd3\xb5\xaa\x7f\x9b\xac\xfc\xbf\xe1\x77\xbc\x35\xa4\xd1\x9f\xba\xdd\x9f\xc2\x41\xb3\xdd\x9e\xe7\xf0\x7b\x1a\xfe\xc8\xe2\x60\xad\x1f\x81\x66\x65\xd9\x80\x26\xbc\x6f\x75\x3a\xad\xef\xc3\xfb\x36\xa7\x53\x33\xfd\xdd\xee\x72\xd9\xd7\x9e\x8d\xb7\x10\x0e\x33\x43\x99\x5c\xf9\x2b\xcf\xbe\x03\xbb\xec\xc4\x0e\xc9\x12\xd1\xbe\x18\x11\xef\x3c\xc2\x37\x88\x0c\x0e\x63\x9f\x81\x40\x8a\x50\x28\xa6\xba\x05\x63\x85\xbe\x05\xc4\xaf\x8f\x91\x06\x38\x75\x21\x9a\xce\x62\x1e\xfe\x08\x37\xae\x7f\x51\xbb\x59\x1b\xd2\x6e\x7e\x71\x3d\xdc\xf8\x0d\xf1\x7d\x30\x0c\x27\xbf\x38\x16\x7f\x91\x40\xb3\x67\xde\x53\xb0\xc7\xb8\x67\xe6\xe8\x3d\xe3\x22\x50\x31\x2e\x42\x56\x4c\x38\x67\x42\xae\x10\xcb\x4d\x38\x67\xdc\x7a\x2e\x8f\xbc\x28\x8a\x06\xd1\x29\xe8\x2c\x74\x1e\xfa\x1e\x42\xf0\xe5\xf5\x3a\x89\xe1\xc2\xb2\x02\xb2\x61\x6c\x9d\xe1\xc2\x1c\x18\xbb\x65\x92\xc8\x08\x34\xe3\x2e\xac\x99\x33\xd8\xe0\xed\x53\x64\x03\xf7\x48\x12\xdd\x59\x35\xab\x26\x40\xcd\x36\xe1\xa4\xe1\x7f\x2f\x96\x02\xcd\x88\x90\x55\x59\x00\x5a\xca\xaa\x69\x35\xab\xca\x19\x39\x23\x2b\x02\x43\xe8\x97\x2a\xfa\x53\x68\x4a\x8e\xea\xdf\x64\x9a\x7a\xdc\x5f\x76\x04\x40\x39\x57\x36\xe4\x3f\x1f\x36\x58\x6c\xda\x2f\x6d\x70\x8a\x36\x54\x56\x9f\x47\x58\x0b\xa7\x9a\x1a\xaf\x08\x38\x59\x0c\x74\x47\xed\x77\xdb\xde\xbc\xf7\xba\x79\x0e\xbb\x07\x28\x0b\x69\x1e\x9c\xc5\x9a\x71\x5a\xed\x8e\x79\xec\x76\x6b\xd0\x0d\x92\xcd\x65\xc6\x18\xb0\x4d\xd5\x7c\xe9\x59\xa9\x1e\xd8\xe6\xb0\x03\xcd\x18\x08\x15\x36\xd8\xf2\xbd\xab\xb0\x48\xf5\xa5\x7c\xf5\x01\xbc\xde\x73\x56\x5f\x2d\x4b\x92\xe7\x1b\x4b\x6c\x63\x30\xcc\x65\xfe\x6e\xed\xc2\x52\x1b\x34\xd8\x0e\xba\x48\x54\x5f\x06\xc3\x07\x11\x9e\xe1\x0d\x30\x75\x62\x00\x30\x80\x5c\x16\xf6\x34\x69\x07\x19\x1b\x90\x16\x6f\xd9\xd2\x6a\xb3\x03\xe3\x59\xab\x2f\xdc\x3a\x70\x43\xb2\xcc\xe1\xae\xa1\x31\x41\x05\x36\x4f\xd8\xad\xf9\x3c\xdf\x2d\x9b\x4b\x6c\xaa\x98\xcf\xc4\x89\x32\x92\x04\xc0\x20\xb2\x00\xf9\xe5\x59\x1f\x70\x54\xd7\x19\xb3\x57\xd5\x5b\x3d\x7e\x00\x74\x4c\x3f\x2b\xbc\xa3\x99\xdf\xee\xdd\xf0\xee\x14\x9f\xe2\xb3\x6a\x36\x93\x92\x02\x20\xf1\x29\xde\x80\xf4\x23\x68\x07\x44\xd3\x09\xc8\x24\x40\x21\xa2\x86\x6c\x17\x55\x64\x85\x48\x65\xbe\xb1\xa5\x97\x4f\xdc\x7d\x4b\x8e\x21\x30\x49\x00\x45\xe4\x6e\xd9\x3d\x51\xfb\xdd\xfc\x53\x28\x8c\x49\xc0\x40\xe3\xcb\xd6\x5e\x86\x29\x20\x49\x8c\xa9\x53\xe6\x7f\x8b\x66\x23\x72\x2b\xf3\x2b\xe1\x6d\xc1\xeb\x34\x79\x88\x88\x59\xf3\xe1\xab\x56\xae\xd4\x7a\x05\xaf\x9b\x60\xcc\x98\x0a\x99\x71\x38\xff\x96\x39\x48\xbb\xdd\x5e\x01\x1e\x5e\xf9\xe5\x76\x38\xe9\xdb\xb5\x43\xdc\x1d\xce\x44\xd5\x56\xdc\x04\xa2\x14\xc0\x41\x88\xea\x71\xa2\xd0\x18\x06\x84\x5b\x54\x56\xe4\x1a\x30\xe2\x3c\xf1\x8d\x8d\x00\xd5\x50\x32\x65\x29\x65\xa1\x00\x03\x89\x29\x86\x58\xd9\x07\xd1\xee\x91\xa7\xbb\xb4\x77\x7b\x97\x92\x36\x02\x63\x20\x69\xeb\x8a\x3e\xed\xcf\xdd\x4f\x3c\xf5\x2d\x9a\xe1\xbd\x15\x2b\x6e\x65\x78\x13\x49\x93\x8c\x99\xbc\x75\xc5\x0a\xe0\xc0\xbb\x72\xe5\x2d\x0c\x4f\x12\x24\x6d\xb5\xdd\xb2\x72\xa5\xf6\xb1\xf6\xf6\x98\x8d\xcc\xf8\xfa\xd7\x1b\xb6\xc0\xdf\xb6\x05\x32\xa9\x64\x81\xa7\x5b\x91\xa3\x61\x77\x8a\x83\x28\xa7\x7f\xb9\x6e\x81\xa1\xbf\xb9\xce\x21\x98\xb4\xe8\xa2\xbe\x8a\xae\xe9\xbd\x6d\xb5\x03\xda\x65\x0b\x81\x5a\xbf\x21\x1d\xac\x6f\x0d\x7e\xbb\x0a\xde\xe5\x90\x72\x03\x33\x36\xf8\xf8\x95\xf9\x57\xc1\x03\x36\x57\x78\x60\x5e\xd0\x71\xa2\x3a\x55\xa0\xe4\xb7\x1c\x79\xb8\x70\x46\x95\x80\x2c\x98\x4b\x09\xdf\x58\x05\x32\x37\x8a\x46\x72\x90\xd3\xfa\x87\x57\xaf\x1e\x5e\xfd\x2d\xca\x0d\x23\xda\xc8\x88\x7e\x4b\x6e\xb5\x7e\x0b\x42\xe6\x23\x65\x1d\x5b\x97\xd1\xcb\xab\xa2\x5e\x03\x65\x3d\x13\x75\x53\x99\x68\x69\xf1\xec\xfe\xe6\x3a\x44\xdd\xd1\x4c\x98\x03\xc3\x43\xd8\xb0\x82\xce\xf2\x99\x94\x3b\x95\x14\x71\x51\x8c\xc6\xb9\x1c\x20\xe3\x8f\x68\xfe\xda\xda\xe5\x72\x1a\xc2\x97\xac\x34\x5d\xfe\xe7\xcb\x4d\xee\x53\x72\xd3\xc5\xc8\xe3\x06\xd7\x1b\x99\x1b\xf7\x1f\x7c\x53\x8d\x73\xb9\x83\x08\xff\x46\xbb\xdd\x57\x72\xd2\x19\x67\x9c\x54\xe2\x6b\x83\xa9\xb9\x9c\x57\xf3\x1a\xfc\x8c\x47\x6c\x5e\xc7\xbd\xab\x06\xd4\x67\x58\xb3\x7d\xab\x79\xc2\x3d\xc6\x1a\x79\x84\xb8\x41\xcd\x42\x52\xcd\x3a\x95\x02\xb2\x9a\xe8\x34\x50\x57\x94\xa4\x9a\x4d\x2b\x09\xd0\x53\x04\x23\xe5\x9b\x3b\xe7\xfb\x82\xc1\x1d\x79\xe7\x0e\x5d\x31\xd8\x71\xa7\x13\xf6\x06\xf9\x6d\xdb\x9c\x59\xc1\x4d\x71\xa7\x9e\xca\x51\x6e\xd7\x13\x3e\x61\xce\x1c\x57\x56\xc6\x7c\x3a\xcd\x63\x5e\xf8\x36\xa3\x53\xc2\x24\xe6\xf7\x8b\x26\x6c\xbe\xcb\x58\x37\xbe\xcb\x91\x9f\xe4\xb9\x05\xae\xbd\xc5\x4d\x73\x5c\xc6\xbd\x59\x7b\x6a\xb3\x3b\xe3\x74\x5c\x29\x2c\x1a\x5d\xc4\xe3\x58\x46\x68\xb8\xb2\x41\xc8\xb8\xb8\x13\xf4\xe9\xd4\xb7\xfd\x4e\x8f\x5f\x1b\xa2\xc6\x5a\xcd\x40\xc3\x4c\x25\xbf\x79\x2a\x34\x58\x88\x35\xe3\x48\x9c\xae\x37\x0b\x6b\xd6\x3e\x03\xb3\xf9\x5b\xcd\x63\x44\x6e\xec\x5e\xc8\xa5\xfb\xb0\x49\xcc\x8f\xe8\xf5\x07\xcb\x7c\xb0\x98\x4f\xf0\xfe\x55\x34\x05\x2d\xf8\x96\x35\x6b\x85\x20\x04\xc0\x01\x06\xa3\x11\x6d\xb8\xaf\x84\x45\x86\x30\x78\x8b\xa0\x0d\x14\x39\xdb\x06\x59\x51\x82\x04\xa8\x7c\xe1\x5a\x3d\x53\xf9\xe6\x97\x3f\x64\xf2\x5a\x53\x56\xc2\xf4\xf0\xc3\x26\xc2\x9a\xb2\x7a\x4d\x7f\x65\x59\x92\x64\xd9\xbf\x1e\x9f\xae\x9d\x63\x77\xe0\x8b\xb1\x68\x6f\x2b\x9e\xbf\x55\x8b\x58\x09\x93\x6c\xf2\x5a\xff\xf5\x2f\xab\xd7\x24\x9b\x08\x2b\x54\xf3\x3c\xcf\x6b\xaf\x1c\x9f\x9e\xa7\xb1\x68\x27\xf4\x47\x5b\xb0\x68\x1f\xfd\xb9\xdd\x81\x11\x20\xe5\xf0\x35\xd4\xeb\x34\x32\x2c\x74\xdd\x74\x94\xc6\x05\x62\x1f\x0b\x28\x61\xd1\xab\xcb\x4e\xaa\x7c\x84\x71\x9d\x61\x21\x92\x00\x65\xfc\x72\x1f\xf5\xfa\x69\xdf\xe9\xf8\xd5\x6d\x35\xfd\x03\xfe\x8e\xe5\xa7\xae\x1b\x9a\xe3\x03\x9f\x77\xee\xc6\x4d\xd3\xef\x3e\x67\xe7\x6d\x2f\xef\x7d\xe0\xc9\x46\xa6\xa4\xab\xa9\xc3\x15\x6c\x4c\x66\xda\x7f\x7b\x5b\x2b\x7e\xe6\x59\xe9\x42\xed\xd3\x5b\xbd\xd5\xb5\x5c\x66\xed\xa5\x7f\x01\x06\xce\x7c\xe9\x8f\xda\x35\xda\x47\xcf\x0e\xdd\xfd\xc1\x64\x28\xdb\x37\xf2\x9f\x57\x46\x6e\x39\x0f\x48\x9b\x12\x5a\x3a\x63\xce\xfc\x53\x16\xfc\xf4\xb5\xe2\x9e\x3e\x53\x18\xd7\x68\x64\x41\x2c\x72\x21\x37\x2a\x41\xd5\x08\xf1\xc0\xc5\x29\x55\x31\x43\x7c\x6c\xc1\xd9\x0c\x12\x47\xc5\x81\xa3\x38\xa1\x48\x2a\xa6\xab\x24\x05\x15\xfa\x0f\x78\x81\xf6\x80\xf6\xd0\xcf\x7f\x4e\xa4\xf0\x02\xed\x5f\xda\x03\x53\xc1\xa9\x7d\xac\x7d\xfc\x7d\x98\x96\xbf\x83\x7c\xe1\xe7\xda\x43\x60\xcf\xdf\x41\xa4\x22\xa3\x2f\xb8\xab\xdc\xa3\x2f\x44\x22\x44\xca\x5d\xe5\x26\x52\x11\x58\xa5\x9d\x09\x4b\xdf\x8a\x6d\xdb\x36\xfa\x06\xec\xda\xfb\xd6\x77\x1f\x7e\xf8\xe1\x45\x6f\xc1\x52\xed\x4c\xed\xa3\x6d\x80\x63\x7b\x61\x97\x76\x5d\x65\xfe\xcf\xe5\x52\xfe\xcf\x76\x3b\x8e\x48\xe5\x38\x52\x2e\xe1\x88\xdd\x9e\xff\xb3\x34\x86\xd7\x8a\x4c\x88\xda\x80\xa2\x68\x4e\xa1\x4f\x1a\xab\x76\xd1\x70\x25\x36\x76\x38\x8e\x00\x78\xc4\x52\xc6\x3e\x07\x0d\x86\xf2\x9c\x00\xe5\x08\x5e\x78\x80\x4a\x15\x57\xf1\x98\x31\x1b\xb0\x68\xa4\xc0\xaa\x65\x5a\x75\xd1\xfb\x77\x91\x0e\xe2\xd0\x24\xc0\xd4\x3d\xef\x9f\xb9\xd0\xb6\xfb\xec\xc5\x53\xa7\x80\xf2\xe0\x9d\xe0\xb9\x1d\x0e\xfe\xfa\x87\x5b\x2e\x5a\xea\x6c\xb3\x75\x4d\x55\xa7\x4e\xcd\x54\xcd\xe8\xe8\xe8\x99\xb1\xa6\x63\xe3\x5d\x3f\xdc\x7c\xe9\xc9\x8b\x3a\xfb\xd2\xfd\xbd\x0d\x95\xd3\x3b\x3a\x7b\x06\x56\xb5\x6d\xba\x07\x8f\x26\x7e\xb9\x69\xf7\xbb\x60\xf9\xfb\x1d\x67\xfe\x34\xab\x54\xae\xbb\xad\xf1\xfa\xc7\x6f\xd5\xde\xbf\x9d\xf6\x68\x1f\x6f\xda\x79\x8a\xd0\xc3\x76\x74\x65\x33\xdd\x15\xdd\x03\x03\xdd\x15\x97\xae\xdf\xb8\xf3\x3b\xa7\xb7\x77\xa6\x1a\x26\x14\x12\x2e\x39\xd6\xff\xa0\x80\xbd\xa9\xa0\x1a\xa4\x1a\x9c\x9c\xc7\x38\x0d\xc4\x42\x8c\x94\x4d\x4a\x2a\xa8\x72\x5a\x55\x68\x27\x0a\xa9\x0a\x1d\x51\x18\x57\x28\x6b\x70\xcb\x52\x52\xd6\xa9\x30\xa2\x80\x9f\xff\xb2\xe9\x3f\x1e\xd1\xce\xbf\xf7\xa9\x81\x7b\x06\x9e\x3a\xf4\xc9\x53\x7e\xff\x53\xf3\x71\x27\x6c\x29\x24\x3c\x5f\xa4\x8a\x25\x4e\x7d\x6a\xfe\xfc\xa7\xfc\x34\x3a\x81\xa5\x30\x3b\x5f\xbf\xe9\xd0\x27\xc6\x0d\xf7\x6a\xe7\xe7\x9f\x34\x12\x40\xfe\x4b\xe1\x66\xd3\x53\xf7\x16\x1e\x67\xac\xd7\x84\xe8\xfd\xd4\x6b\x28\x6c\xf8\x68\x8d\x19\x38\xb9\x62\xaa\x9b\x46\x6e\x21\x80\x43\xad\x38\x93\x46\x4a\x46\x24\x5d\xf4\xfe\x8b\xfe\xae\x8d\x68\xc3\xda\xc8\xdf\x2f\x7a\x0a\xfa\x5f\x7c\x53\x7b\xb3\xc8\x6b\xbb\x44\x7b\xf3\xcd\x17\xa1\xff\x29\x9c\xbb\x5f\xcf\xbc\xe8\xef\xd0\x7e\xff\xab\xb0\xee\xe3\xe0\x81\x6a\x6d\xf8\x9d\xed\x05\x1a\xdb\xed\xef\xc0\x50\xf5\x81\xe0\xc7\xda\x25\x08\x01\xe2\x0f\x23\xfa\x43\x1a\xa1\x53\x10\xe2\xb3\x2e\x35\x59\x27\x30\x2c\x69\x18\x93\x18\x0e\xec\x90\xd0\x87\x27\xa2\x06\xd4\x00\x04\x21\x6b\x58\x03\xe9\x02\xa3\x9e\x69\x04\x58\xc3\x2b\xbe\xe0\xec\x9e\x20\x6b\x40\x4e\x89\x75\x01\x93\xe4\x2a\xda\x96\xf3\xa6\x3f\x3c\x43\x81\xa9\xac\xbd\x3e\x4c\xf5\x4c\x4e\x2e\x9b\xda\xea\x74\x2a\x7e\x87\xcf\xce\x5a\xca\xab\x2b\x58\xfb\x32\x65\x9a\xc0\x83\xe2\x16\x6e\x1d\x0e\x2b\x04\x29\x4e\xf7\xfb\x97\x56\x0d\xf0\x7c\x30\x22\xd4\x84\xe7\xcd\x98\x24\xba\x9b\x7b\x3c\x64\xa8\xa2\xae\x9c\xb5\xb3\x8c\xa5\xac\x7a\x7a\x5d\x77\x65\xad\x9f\x07\xe2\xcf\xda\x99\x87\xf7\x69\x7b\xff\x79\x01\xbe\xfa\x75\xd8\xb4\x0d\xb0\x29\xb5\x64\xfd\xb5\x57\xdd\x39\x29\xa9\x38\x83\x9c\x33\xb5\x63\xed\xa9\x81\xd2\x92\xba\xb0\x97\xa6\xd7\x71\x13\xbd\xbe\xda\x55\xa1\xe0\x23\x0f\x25\xd6\x44\xc2\xf1\x49\x1c\xb7\x8e\x9d\x5c\x5a\x5a\x7f\xc3\xbe\xf6\xea\xa0\x10\xe6\x9c\x99\x2d\xeb\xb7\xac\x5e\x7a\x52\x0b\xc7\xd9\x89\xd2\x48\x67\xb2\xbf\x77\xc9\xb2\xed\x93\xb4\xbc\x76\xea\x3b\x57\x7e\x0e\x03\x05\xb9\xc7\xe8\x6b\x36\xe4\x43\x65\xa8\x1f\x2d\x42\xa7\xa3\x8d\xe8\x22\x74\x1d\x42\x94\x5b\x8e\x29\xaa\x28\xa9\xa2\xc4\x88\xc0\x88\x12\x23\x3b\x55\x89\x66\x24\xda\x2d\x80\x44\x93\x4c\x26\xab\x2a\x59\x55\xca\x12\x8c\x28\x30\x12\xcd\x28\x7a\x5e\x44\x51\x65\x85\x91\x15\xa3\x5b\xea\xb9\xaa\x92\x4d\x4a\x8c\xfe\x18\x70\xd3\xc5\xcb\x94\x6c\x0c\x39\x19\x25\x5b\xb0\xbd\x54\x65\x45\xd5\x6f\x31\xee\xd2\xbb\x02\x1a\xe7\x0c\x43\x16\x9c\x63\x8e\x31\x83\x27\x56\xbc\xac\xdd\xbc\xa2\xb1\xb4\xaa\xe3\xca\x37\xb8\x8e\xfc\x5f\x4f\x12\x7d\x0d\x27\x9f\xdc\x10\xe0\x07\xa2\x94\xa9\x71\x85\x76\xf3\xcb\xf5\x1d\xdc\x1b\x57\x76\x54\x6d\x7a\x97\x65\xff\x11\xec\xda\xd7\x30\xbf\x36\xbd\x30\x5d\x3b\xbf\x61\x5f\x57\xf0\x1f\x2c\xfb\x6e\xb8\x73\x5f\xd3\xdc\xda\xaa\xd3\xab\x6a\xe7\x36\xed\xeb\xd4\x2a\x3a\xea\xf5\xcb\xe5\x68\xc3\x0a\x18\x22\x9d\x27\x37\xf8\xc4\x93\x62\xd1\x01\x3e\xd0\x20\x36\x44\x65\xfd\x47\xea\x3b\x7e\x03\x43\x60\xff\xde\x01\xed\x17\xda\x9d\xda\x2f\x0e\x7c\xef\x7b\x07\xa0\x19\xe6\x43\xf3\x81\x07\x4f\xf0\x81\x2c\xe9\xa4\x5f\xba\x2f\x52\x97\x6c\xf8\x61\xd5\x6c\x1b\xe6\xfc\xcd\xe9\xf0\x5e\xb8\x7e\x6f\xb8\xbe\xde\x7f\xea\xea\x33\xb4\x7f\x44\xee\x7b\x89\xee\x04\xdb\xec\xaa\x1f\x36\x24\xf1\x82\xfe\x8a\xd9\x15\xfd\x0b\xa7\xde\xd6\xe5\xfa\xc4\x62\xf9\xc4\xd5\x75\xdb\xd4\x85\x46\xd2\xa2\xbe\xdb\xba\x5d\x1f\x5b\x2c\x1f\xbb\xba\x6f\xeb\xc3\x72\x27\xb6\xce\xae\xb8\xbb\xbe\xa2\x3e\x7c\xdf\x4b\xf9\x7b\xb5\x25\x7b\xff\x7f\x9c\x7d\x07\x9c\x14\x45\xda\x77\x3d\xd5\x69\xc2\x4e\xec\x99\xee\xc9\xbb\x93\x7a\x36\x2f\x3b\x71\xf3\x0e\x69\x49\x4b\xce\x79\x41\x32\x28\x49\xa2\x08\x43\x12\x14\xf5\x14\x15\x03\x06\xee\x3c\x10\x91\x43\x51\x4f\x45\x51\x57\xef\x3c\x03\xea\xe9\x9d\xfa\x1e\x9e\x7a\x78\xe7\xdd\x7b\xfa\x5e\xf4\x92\xb0\x3b\xc5\xf7\xeb\xea\xd9\x00\xea\xdd\xf7\xbe\xb0\x3d\x5d\x5d\x55\xdd\x5d\x55\x5d\xf5\x54\x78\x9e\xfa\xff\x83\xc9\x26\xdf\xe2\x2b\x57\x2d\xf0\xd5\xd5\x05\x95\x60\x5d\x79\xdd\xc3\xe5\x53\x8c\x78\x10\xff\xd3\x3c\xa2\x29\xdb\xd3\x3f\xb5\xf8\x81\x6f\xb2\xce\x17\xfa\xed\x8b\xb5\xa2\x7a\x34\x14\x2d\x45\x6b\xd1\x4e\x84\xa2\x8e\x70\x28\x95\x4c\xc4\x99\xc2\x59\xca\xa4\xf8\x70\x8f\xd9\xbd\x93\x77\x3a\xe8\x4f\x00\x27\xe2\xea\xb4\x43\x15\xc3\x74\x06\x12\x4b\x8b\x09\xda\x6b\x84\xd5\xf1\x0d\x97\xd2\x70\xe3\xe3\x52\x22\x15\x56\xfd\xfc\x10\x76\xaa\xe2\x37\xe1\x0c\x3b\x1d\x01\x86\x2a\x8f\x34\x45\x4c\xfa\x72\x0a\x54\xdc\x36\x7b\xf9\xfc\x45\x91\x91\xa3\x47\x47\x94\x23\x63\xea\xe3\x4d\x53\xd6\x37\x56\x2a\x65\xab\x4b\x87\xb4\x57\x9c\xeb\x18\xe3\xad\xad\x1d\x3d\xc3\x10\x1d\x76\x3d\xc6\xd7\x33\x70\x21\xa0\xa4\x92\xfa\xb0\x7e\x29\x73\x23\xdb\x14\x01\xc6\xca\x62\xce\x5e\x5c\xa7\x64\xc9\x6b\x03\x86\xd7\xc6\xdb\x6a\xf1\x82\xfe\x2a\xb1\xcf\x06\xb5\x66\xe1\x8e\xc9\x93\x66\x24\xa2\xd7\xfa\xfd\x6b\xa6\xc4\x97\x58\x18\xdb\x90\x94\x8b\x89\x2e\xaa\x1a\x1c\xb6\x9e\x1e\x9c\x35\x73\xc5\xae\x4a\x9d\xe5\xaa\xb1\x2e\x9f\x9e\xcc\xf3\x66\x60\x67\xb5\x2c\x0f\x20\x1b\xe3\xfa\x4d\xce\x09\x9f\xe2\x75\x13\x1c\xae\xe2\x9a\x75\x0c\xe0\xb3\xd1\x74\xa3\xe2\xc2\x1f\x46\x32\xe9\x68\x24\x95\x9e\x78\x19\xc6\x2b\x8f\x86\x5c\x44\xfc\x69\x8a\x81\x6d\xa5\x6b\x98\x2b\xd0\x06\x84\xa2\xc9\x70\xc8\xe9\x48\xc4\x19\xb5\x47\x52\x1d\x6a\xcb\xa0\x4c\xea\x14\x99\x85\x73\x5a\x83\x21\x6a\x9a\x9c\x52\x27\x0f\xa9\x82\x1e\x5f\x8e\x43\x38\x9d\xb2\x25\x63\x09\xde\x69\x73\x44\x9d\x14\xd5\x2a\x65\x4b\xa4\x42\x14\xb1\x3f\x91\xa2\x21\x09\x67\x48\xa9\x00\x9b\xa3\x60\xf9\xad\xf5\x7f\x78\xe2\xe1\xfb\x8f\xdf\xd9\xd8\xd4\xb8\x65\xcb\x06\x30\x45\x2a\xac\xfb\xb7\x94\xc6\xaa\x86\x4d\x99\x32\xac\x8a\xdc\x31\x74\xf3\x55\x03\x9f\x1a\xdc\x3a\x7c\xee\x0b\x37\x76\x4c\x98\x0f\x4f\x7d\xc2\xb2\x9f\xb0\x78\xf6\xb0\xc5\x2d\x33\xe2\x7e\x1d\x16\x5c\xbc\x53\xe9\xe0\x7f\xc3\x3f\x62\xa9\x37\x4f\x9e\xda\x9c\xff\xcb\x98\xfa\x86\x71\x63\x1b\x1b\xa4\x05\x4b\x16\x32\xb3\x9a\x27\xdc\xba\x07\xde\x7a\xa3\xc8\x50\x51\xb6\xed\x09\x59\xa7\xc4\x8a\xcb\x64\x67\xa0\x6a\x62\x3d\x79\xc7\x5d\xbf\x7c\xe4\xe1\x26\xb6\x6c\xf2\x95\x3e\xd6\xf5\xf0\xf8\x7d\xa7\x6a\xba\x5f\xa8\x9a\x8e\xe7\xcd\x09\x05\x67\xe6\x0f\x4e\x3f\xf9\xe3\x58\x69\x53\xc7\xb4\x46\x98\xcb\x62\xfe\x85\xf6\x74\xb8\x6c\xcb\x0b\x2c\xb9\x6d\x27\x6b\xbe\x7a\xea\xd4\x86\xc6\x69\x5f\xe7\xa5\xd6\x43\x98\xe1\x85\x18\x13\x06\x5b\xe2\x6b\xfb\x3d\xca\xc0\xb0\xea\x3e\x97\xa3\xfc\xe0\x46\x10\x16\xe2\xff\xba\xc4\x28\xdd\x01\x7f\x23\xaf\x0d\xa8\x9c\x05\x75\x44\x24\xa7\x99\x1b\x2e\xe5\x9e\xad\xbf\x88\xd8\x57\x79\x84\xfc\x14\x2b\x48\x03\x07\x13\xb0\x28\xf1\x42\x38\xa4\xc4\x14\x0d\xb9\x31\x95\x4c\xc7\x59\xab\x2a\xfe\x0b\xd0\x1d\x14\x4a\x4c\x03\x16\x72\x3a\x64\x0d\xfc\x38\x95\x6c\xc1\x89\x38\xcb\x8c\x5c\x33\xb6\x29\xd1\x92\xfa\x57\x15\x78\x9d\x9c\x23\x80\xcd\x4e\xa5\x6d\x48\x69\xf3\x30\xeb\xea\x43\xf0\xa7\x7b\xc9\xdf\xee\xcf\x0e\x76\xca\x1c\x17\x71\x26\xea\xe7\x3d\x9e\x6b\x6f\xcf\x3d\xfe\xf2\xe3\xb9\xf6\xa4\xc1\xa4\x94\x19\xb2\xb3\xef\xfd\xc5\xfa\xfb\xc1\xc4\x3a\x0e\xad\x0e\x0f\x1e\x4b\x6e\x22\x2e\x29\x88\xbd\x8e\xad\x7f\x7b\xf1\x87\x3b\x9a\x66\x8c\x0a\x97\x8f\x5b\x5d\x4d\x7e\x4c\xfe\x7e\xaf\x99\x8b\x3a\x1d\x32\x6b\x2a\xdc\xde\x9e\x7b\x7c\xde\x9a\x25\x8e\x52\x87\x59\xbc\xe6\xe6\x0d\xbf\xb8\x77\xd6\xbd\x08\x90\xbd\xd0\x0f\x2e\x45\x08\x0a\x86\xb2\x99\xa4\x9d\xae\x3c\x07\xf8\x62\x50\x2b\x9d\xd3\x11\x00\x67\x61\x54\x55\xcd\xc6\x94\xb0\xc0\x0b\x01\x0d\x7d\x33\xdc\x43\x29\x43\x0d\x6d\xab\x99\x94\x46\x2c\x13\xcf\xa4\x53\x14\x28\x26\x24\x98\x41\x2b\xa4\x94\x15\xcc\x3a\xc9\x04\x36\xf3\xa9\x6b\xf7\x9d\xda\xbd\xbb\x76\x42\x53\x3c\x54\xec\x28\x82\x8c\x9d\x61\x47\x4f\x8d\x45\xf4\x4e\x9b\xd3\x68\x05\xc0\x5c\xe3\x08\xc7\xc4\x8c\x0e\xb3\x5c\xf6\x4f\xa9\xb5\xe3\xb3\x16\x9d\x39\xab\x2b\xfb\xc1\x84\xf0\x90\xf5\x93\x06\x3a\x8a\x8d\x8d\x0e\xd6\x80\xf1\x80\x8d\x26\x8e\xd5\xd9\x47\x94\x01\xcb\x32\x32\xfe\x50\x0c\x3a\x1a\xac\x52\x4b\xd1\x3e\xa8\x68\x1a\x94\x71\xa6\x1b\xc6\xb4\x5d\x31\xae\x81\x9b\x38\xd8\x9c\x2c\x02\x8e\x83\x35\xaf\xaf\xa8\x58\x63\x71\x94\x38\x8b\x31\xb0\xf7\x0c\x75\x44\xab\xcb\x59\x17\x3f\xcf\x2e\x89\x1c\x66\x01\xaa\x4a\x19\x8b\x27\x1d\x2d\x8d\xf9\xb1\x04\x18\x63\xc6\xf8\x7c\x0b\xe3\x28\x1b\xcc\xea\x21\x5d\x0d\x62\xcf\xb8\xab\x45\x87\xb8\x97\x29\x4e\x78\x10\x55\xa1\x11\x14\x43\xb6\x6f\xd0\xde\x5f\xd5\x8d\xbf\xd9\x1b\x94\x70\x88\x55\xeb\x03\x6d\x9c\x31\x21\x13\xb1\x25\xed\xea\xb8\x54\x02\x07\x2f\xc8\x1a\xe8\x9c\x95\x8e\x54\x25\x3c\x24\x5e\x56\x31\x68\x50\x45\x19\xe3\x4e\x94\x7a\xab\xaa\xbc\xa5\x89\x3f\xd4\x6a\x3e\xf8\x78\x32\xa6\xfa\xc4\x92\xe4\x9f\xc5\xb1\x87\xc9\x67\x0f\xca\xe1\xa0\x67\x40\x8b\x77\x82\x3e\x3f\x9c\x7c\xf2\x23\x18\xfd\xca\x63\x50\xff\x73\xbc\xf2\xfa\x75\x99\x57\x0f\x0c\x51\x23\x3c\x08\xbe\x87\xbf\x0b\xbe\x47\x58\xc3\x84\x78\xa2\x34\x96\x20\x73\x7d\x95\x55\x5e\x5f\x55\x25\xfc\xf9\x72\x8f\x63\xec\x3d\xe4\xfc\xbd\x63\x46\x32\x8c\x81\xb5\xe1\x6d\x1f\x9e\x81\xe2\x87\xc1\xf7\xe0\xae\xcf\xf3\xad\xeb\xde\x9f\xfa\xc3\x2b\xa3\x37\x7d\x09\x81\x2f\x6f\xba\xe9\x6f\x1a\x7e\x09\x7f\x91\x47\x14\x8d\x43\x12\x0a\xc0\xc2\x51\x46\x83\x48\x4a\xd9\xf4\x10\x55\x62\x1a\xba\x32\xff\x59\x90\xbf\x88\x38\xaf\xd9\x66\x34\x91\xc6\x2f\xed\xc5\x26\xbd\x28\x33\x1d\x5d\x3f\x27\xeb\xa2\x0c\x0e\xf1\x39\x8b\xcd\xc1\xfd\xc3\x55\x7a\x01\xf9\xad\x3a\xee\x14\x39\x2b\xb3\x42\xd0\x01\xb3\xd9\x70\xf7\x15\xdf\x33\x97\x95\x8a\x4c\xa7\xbe\x0f\x2f\xe1\x22\xf7\x2f\xe4\x41\x25\x97\xbc\x15\x7a\xde\x5a\x78\x27\x88\xc0\xe9\xa1\xff\x7b\xf3\x7f\x25\x1f\xd8\xfd\x66\xbd\x28\x91\xd2\x28\xc3\x84\xf9\x5c\x98\x9c\xf9\xf8\xc2\x22\x18\xc7\xcc\x25\xa1\xbe\xb7\xff\x17\x39\xe5\xa4\x6f\xff\xf1\x4b\xe6\xb2\x98\x83\xe9\x74\x5e\x30\x73\x15\xdd\xaf\x5c\x8f\xb7\x75\xff\xe6\x12\xb9\x93\xa4\x32\x41\x1d\x7f\x84\x43\x11\x6d\x2e\x9b\x90\x0a\xa6\xfb\xd4\xa2\x9f\x17\x64\x49\xe8\x91\x44\x14\x2e\x98\x7e\x5c\xee\x52\x42\x5b\x6d\xfb\x3e\x8f\x36\xbf\x4d\x3e\xbb\xf7\x38\x79\xe3\x4a\x01\x74\xd7\x1b\x2c\x56\x61\xc4\x7b\x1b\x96\x3c\x7f\xc3\xf8\xf1\x37\x3c\xbf\x64\xfe\x93\x6d\xd7\x17\xdb\x6c\xe5\x24\xeb\x51\x4a\x63\x81\x1d\xcb\x41\xbc\xed\x5e\xf0\xbd\x9d\xbf\xd0\x63\xbc\x77\x8e\x1a\xa1\x31\x3e\xf2\x1a\xf9\xec\xed\xcd\xb7\xee\x32\xb8\x75\x37\xe8\xb1\x61\xee\x92\xf1\x37\x3c\xff\xce\xf3\x37\x8c\x1f\x36\xe8\x86\x40\xac\x54\xf1\x40\x67\xb9\xcd\x56\xbc\x7d\xe1\xca\xcd\x6f\xdf\x45\x7a\xad\xf9\x3a\x7a\xec\xd7\xfa\xec\x57\x28\xd7\xbf\x19\x5b\xe9\x38\xdc\x5a\x0d\x97\xec\x26\xdb\x41\xba\xb5\x91\x35\x1d\x82\x2f\x7a\x04\x6e\xbd\x4c\x71\xc8\xa1\x45\x8f\xfc\xb1\x7f\x24\xf2\xf4\xd7\x74\x83\x2d\x17\x73\xfc\xcb\x5c\x0e\xed\x46\x88\x2b\x58\x9f\x51\x29\x99\x49\xa7\x98\x64\x4c\x63\x1b\x77\x32\x0e\x39\xc0\x14\x66\x75\xfd\x63\xc4\x6c\xc9\x74\x35\x1b\xab\x86\x1e\xda\xa7\x44\x5c\x9b\xbd\x99\xb1\xc0\x3b\x45\x87\x2c\x25\x82\xaa\x2c\x12\x93\xb1\x6a\xfc\xcd\x31\xe8\x73\xf9\xfd\x95\x27\xab\x2a\x1f\xab\x74\x79\x42\x95\x0d\xd6\x20\x80\x29\x9a\x9f\xad\x98\x00\xa2\xd6\x6c\xbc\xd4\xed\xaa\x39\x55\x5d\x71\xac\x5c\x76\x17\x97\xa5\x2d\x41\x50\x65\x94\xce\xac\xb7\x34\x55\x47\x5c\xae\xea\x53\xd5\xe5\x0f\x97\xbb\xdd\xa1\x8a\x3a\x4b\x18\xc0\xe4\xc1\xcf\xb9\x4d\x00\x61\xfb\xf8\x84\xdb\x5d\xf9\x58\x65\xc5\xf1\x0a\xb7\x3b\x5c\xd5\x60\x09\x43\xc8\xda\x54\x13\x71\xe5\x04\xa1\xcc\x5d\x1c\x60\x0d\x06\xe7\x06\xd8\xe3\x34\xb0\xac\xc1\x49\x6e\xba\x59\x32\xf0\xe0\x2f\xf6\x54\x0a\x42\xb9\x2b\x10\xe0\x0c\x06\x79\x63\x3d\x53\xc5\x54\x7b\xe3\xa1\x98\x8b\x37\xb0\x3e\x1a\x56\xe9\x09\x78\x31\x6f\x70\xee\x23\x9d\x4e\x23\xc3\x18\x9d\x90\xdd\xe7\x34\x32\xb2\x52\x08\xf4\x01\x67\x90\x6f\xe8\x1e\xbf\xc1\x69\x10\xb0\x3f\xe0\xa9\xa4\x18\x43\xae\x8b\x39\x96\x70\x39\x54\x59\xc0\x8f\xa0\xdb\x4f\xfa\x0c\xb4\xc3\xbd\x2e\x25\x46\xfb\xa8\x4c\x3a\x93\x2e\x83\xb8\xc4\x92\xa8\x2b\xce\x7a\x78\x26\xe2\x5e\xe1\x8e\x7c\x27\xec\x59\xe1\x09\xdf\x36\x7f\xeb\xa0\xec\xb4\x69\x9b\x56\x42\x1c\x7e\xe5\x8e\x70\x83\x47\xf8\xb3\xc0\xbb\x8d\xa9\xae\x9c\x3b\x12\x71\xb3\x2f\x77\xb5\xa8\x67\xf8\x4b\x51\x4d\xc3\xa6\x75\x37\x1f\xd9\xb8\xbe\x2c\x1a\xa1\xf3\x08\xb5\x4e\xa1\x7e\xbc\x23\x35\xa8\x15\x0d\x46\xc3\x10\x8a\x3a\x83\xa9\xe8\xd7\x2c\x85\x83\x29\xd1\x19\x4e\xa9\x67\xe6\xf2\xb0\xcb\xd7\xca\x9c\x61\x4a\x53\x09\x1d\xe4\x10\xa6\xf4\x5a\x05\x5c\xb7\x43\xdd\x87\xce\x9d\xe3\x51\xbe\xe4\x5c\x9f\x27\x93\xeb\x73\xe3\xec\xb9\x73\xdd\x87\x72\xb9\x5c\xae\x1f\x88\x9c\x02\xb9\x5c\x0e\xa3\x5c\xae\x1b\xe5\x72\xec\x25\x21\x04\xf5\xbf\x2a\x44\xd3\xf4\xdb\x05\x6e\x7a\x04\x71\xc9\xca\x97\xa8\x65\x18\x55\xeb\xa9\x55\xed\x47\xa3\x6a\xe5\x2c\x91\xac\xaa\x74\xe2\x24\x87\xc0\xa5\xd9\xce\xdd\xcf\x3d\x47\xfe\xf9\x1c\x26\x77\xcd\xda\xba\xfb\xb9\xe7\x76\x6f\x9d\x05\x4b\xf0\x73\x60\xa0\x4e\x72\x17\xc6\xb0\x64\x16\x46\x6a\x94\xe7\x76\x17\x49\x4f\x4e\x51\x83\xa6\x3c\x29\x15\x69\xb7\x4d\x79\x52\x72\x49\x4f\x4e\xb9\xa4\xad\x52\x5e\xfc\x88\xb6\x07\x36\x9d\x8c\x65\xa4\x84\xb6\x94\xec\x74\xd0\x0d\xce\x94\x1c\x2f\x43\x37\xc4\x7e\x6d\x2b\x1f\x87\xae\x9d\x36\xa9\xf9\xaf\x18\xff\xb5\x79\xd2\xb4\x6b\xaf\x7d\x6c\x2b\xfe\x6b\xcb\xc4\x69\xd7\x5e\x3b\x6d\x62\xcb\x5f\xf1\xd6\xc7\xe0\xda\xfe\x43\xa5\xfc\x63\x5b\x1b\x36\x5a\xcd\xd6\x8d\x0d\x5b\x1f\xbb\xf6\xda\x69\x82\x75\x63\xfd\xb5\x8f\x5d\x5b\xbf\xd1\x2a\x4c\xbb\x96\x39\xd7\x7f\xdc\x24\xf4\xce\x1d\x6d\xa8\x06\xb5\xa0\x76\x34\x0d\x2d\x40\x6b\x11\x42\x74\xd9\x97\xae\xf0\x52\xc5\x44\x26\x0d\xb2\x20\x4b\x0e\x0b\x45\x40\xe8\x9b\xc8\x25\xe2\x32\x35\x94\x15\xe9\xe2\x71\xc1\x6a\x56\x72\xc8\x7c\xff\xab\xb4\x56\x77\xa9\xfc\x8c\x15\x4c\x57\xa8\x56\x5d\xc3\x76\x49\x6a\xd0\x68\x0e\x3c\xd4\x31\xc0\xbd\xe2\x48\xa5\xc1\xe1\x36\x19\xcb\xed\xa1\xed\x93\xdc\xcc\x33\xd5\x7f\x1f\x22\x8a\xd9\xe9\x2b\x9f\x27\x5d\xe4\xd7\xa4\xeb\xf9\x95\x14\x4e\xf5\xa9\xef\x66\xc5\x94\x38\xa4\xcb\x50\x64\x32\xcc\xd4\xeb\x0d\x1e\xc3\x0c\xc3\x47\x46\x97\x71\x86\xc1\xa0\xf7\xea\x67\xea\x4b\xec\x66\x0a\x7c\xd2\x61\x3e\x61\xf7\xd9\xed\x3e\xfb\x9d\x33\xd5\xa8\x06\xc3\x0c\x83\xc7\xa0\x67\xee\x89\x3b\x0c\x95\x47\x56\xb8\x07\x18\xb8\xd2\x49\xdb\x43\x46\xf8\x41\xf5\xdf\x86\x88\x29\x31\xfb\xdd\xa7\xbe\xd3\xf3\x0e\x08\x00\xf7\xfc\xca\xe9\x59\x51\x1c\x02\x95\x85\x1b\xf5\x33\xf5\xde\x3f\xd3\x5f\x3d\xf5\x79\x8e\x3e\xfb\x50\xe1\x55\x76\xfb\xd0\x9e\xf7\xeb\x0d\x9e\x02\x2e\x81\x5a\xb6\x2c\x72\xa8\x5f\x1e\xa2\x1c\x13\xc4\x97\x2d\x01\x41\xba\x19\x84\x98\x28\x2b\x31\x99\x8b\x66\x78\x21\x23\x0a\x31\xa7\x43\xce\x70\xa2\x20\xc5\x33\x31\x31\x8a\xe7\x41\x31\x14\x5f\x49\xee\xe3\xbe\xbe\x06\xc4\x5e\x79\xc7\xa2\xbf\xb4\x5e\x77\xe0\xcf\x29\xf2\x29\xf9\x34\xf5\xe7\x03\x7b\x5a\xfe\xb2\xe8\x8e\x00\xb4\xed\xbb\x7a\xdd\x3f\xd7\x5d\xbd\x0f\xda\xf0\x3b\xef\xbc\x43\x1e\x63\x73\xdf\x30\xc1\xed\x1a\x7e\xa6\x8b\x99\x7e\x0e\x06\x17\xbd\xdd\xbe\xe5\x81\x07\xb6\xb4\xbf\x5d\x44\x9e\x3f\x37\x9d\xe9\x3a\xb3\xab\x94\x7c\x30\x34\x16\x1b\x0a\xe5\xa5\x88\x72\xd7\x15\xf8\xa1\x7b\xf6\x14\x8c\xa0\xac\x21\x9b\xd0\xf5\xe8\x7b\xe8\x71\x74\x5a\x95\x0e\x3d\xcc\xd5\x05\x2a\xf7\xcb\xae\xe1\x3f\x84\x47\x7b\x8c\x9a\xc2\xff\x29\xe6\x7f\x0e\x0f\xa6\x92\x1c\x4b\x81\x1d\x5a\xd8\x48\x09\x1b\x60\x6d\x97\x45\xb1\xf5\x12\x87\x82\xc6\x12\xa9\x51\x45\xf6\x39\x71\xf6\x1b\xbd\xf3\x2f\xfb\x14\x8c\x15\x2f\xbe\xf8\xbf\xb9\x0b\x72\x79\x42\x76\x90\x1d\x79\x62\x4b\x8c\xbb\xe9\x09\x30\x41\x0b\x14\x3d\x79\xd3\xb8\x84\xad\x2f\x8e\xe2\x25\x39\xaf\x72\xae\x8f\x47\xb4\x8f\x5d\x94\xac\xf9\x26\xdf\xfd\x8a\x77\xfb\x76\xaf\x92\xff\x5f\xdc\x02\x37\x98\x0c\x4b\x30\x2c\x34\x98\x6c\xc9\xf6\x51\xa3\x1b\xa2\xd1\x86\xd1\xa3\xda\x93\x64\x6a\x5f\x8c\x49\xdb\xbd\x8a\xe2\xdd\xde\xab\xf7\x2b\xe0\x22\x38\xa8\xf5\x4e\x7d\x01\x07\xac\x57\x2e\x89\xe9\x44\x90\x2a\xfa\x7a\x3c\xa8\x2a\x21\x2e\x43\x2f\xb4\x1b\xd7\xeb\xc2\x9d\x8a\x47\xf1\x10\xe4\x51\xce\x0b\x2e\xfc\xfb\x8b\x88\x45\xda\xa5\x47\x81\xa3\x2e\xa1\xfb\x2c\x39\x64\x37\x43\x89\xd9\x8e\x0f\xf5\xb8\xd8\xce\x3c\xf2\x28\x79\xda\x55\x60\xc4\x2c\x95\xf3\x59\xdc\xd9\x9d\x23\x85\x4e\x41\xf1\x30\x48\x86\xcc\xb9\x3e\xd2\x73\x6d\x9c\x4b\xd3\xec\x57\x47\x9c\x0e\x01\x64\x81\x67\x63\x10\x4e\x81\x62\x6f\x05\x19\xd2\x71\xea\x09\xe9\x38\xff\xcb\x68\x94\xac\x3c\x70\xe8\x41\xd2\x78\x8a\x1c\xf8\x21\x2c\xdb\x52\xf3\xe0\xa1\x03\x70\x8b\xb2\x6c\x64\x94\xac\xfa\x02\x6e\x55\x96\xb1\x8d\xca\x52\x85\xac\x3a\x70\xe8\xc1\x9a\x2d\x34\xca\x29\x78\x45\x8d\x73\x6b\x74\xe4\xf2\x28\x59\xf9\x05\xdc\x12\xa5\xba\x7f\xf7\xc5\x22\xfe\xbf\x29\x6f\x9f\x13\x35\x50\x56\xa2\xfe\x28\x08\xdf\xc0\x75\x19\xe0\xe2\xe9\x44\x9a\xc2\x7b\xa6\xe5\x78\x00\xb7\x70\x19\x5e\xb0\x6b\xbb\xef\x32\x0c\x55\xfb\x17\xf8\x12\x44\x4a\xbe\x10\x00\xb9\xd0\x07\x38\x6d\x99\xb4\xc4\x2c\xdd\xf6\xf8\xb6\x6d\x8f\x6f\x83\x7f\x6e\x9d\x31\x7d\xdb\xb6\xe9\x33\xb6\x7e\x9a\x1d\xdb\x75\x74\x62\x63\xc5\xcc\x61\x33\x13\xd3\x7d\x93\xf1\x10\x2f\xcf\x7a\xc2\xc2\x4a\xae\x55\x1e\xa2\x0c\x4b\x8c\x68\x1e\xf9\x93\x4d\x5d\x93\x96\x0f\x5a\xb7\x64\xcc\x14\x16\x74\x41\x01\xd8\xa9\x63\x97\xac\x1b\xb8\x74\x62\xd7\x26\x77\x79\x8c\xb5\x30\x73\x06\xb3\x9f\x0f\x9e\xe3\x8c\x95\x33\xbe\x89\x1b\x36\x4c\x9c\xb4\x7e\xfd\xa4\xc2\x99\x7c\x85\x0f\x4e\x1d\x31\x64\x56\x7e\xae\x1c\x92\x2c\x02\xb0\xe0\xe3\x19\xb7\x67\x26\xcb\x00\x30\xbc\xd1\x2a\x17\xbb\xee\x58\x4c\x7e\xf3\xe4\xea\x70\x49\x4d\x62\x35\xb4\x01\xd6\x01\x39\xb1\x26\x5e\x53\x12\x59\xf3\x24\x78\x17\xdf\x11\x4d\x7a\xb1\x81\xc1\x4f\x0d\x5f\xb4\x68\x78\x7e\xa4\xc5\x9b\x54\xcb\x6c\xc1\xc5\x1c\x7f\x6f\x41\x4f\x6b\x41\x6e\xb5\x66\x51\x3a\x31\x9b\x98\xb1\x05\x6d\x41\x67\x06\x6c\x10\x14\xc2\xa9\xa0\x4d\x64\x72\xb7\xe2\xe2\x5b\x6f\xcd\x77\x4d\x81\xb6\xb3\x8c\x8f\x8c\x21\xcf\x9e\x3d\x4b\xd6\x5c\xc9\x8e\x21\x63\xe0\x71\xf5\xc8\xeb\x08\xe3\xed\xfa\xef\xb3\x67\xd9\x63\xdd\x46\x32\xe6\xec\x59\xf6\x3a\x08\x6a\x75\x78\xfa\x45\xe0\x8e\x71\x79\x24\xa1\x0a\xd4\x8a\xc6\xa0\x85\xaa\xa4\xc2\x6a\x51\xd3\x41\x94\x36\x0b\xa6\x00\x9e\x31\xde\x02\x2c\xdd\xd7\xa8\xb4\x80\x1c\x97\xe9\xd6\x37\x50\x3b\xc0\x98\xc2\x50\x70\xce\x02\xcf\x03\xa8\xdf\x06\x14\x0a\xeb\x29\x4b\x76\x4e\x12\x78\x8e\x17\x32\xbc\x86\xb6\x4a\x4d\x6a\x02\x20\x33\x1c\x70\x45\xb1\xf4\xc5\xb0\x89\x05\x8e\x6d\xba\x13\x1a\x2d\xb5\x6e\x97\xf7\x00\x53\xbb\x91\xfc\xd1\x16\x16\x8b\x38\x9d\xbd\x3c\x6c\x7a\x7e\x58\xe5\x24\xd9\xcd\xd4\x0b\x0f\x27\xa2\x1e\xf3\xb1\x1a\x33\x67\x0b\x0f\x80\xf5\x67\xc6\xe8\x7c\xf9\x19\x5c\x63\x43\x1d\xb9\x4e\xe7\x2d\x83\xd1\x0d\xa5\x7a\x46\xc1\x07\x19\xbf\x85\xfc\x64\xb0\x0b\xe4\x6a\x73\x20\x00\x23\xaf\x8d\xeb\x7d\xd1\x01\x07\xf8\xb3\xdb\xc8\x47\xa6\x12\x9d\x7e\x4e\xb9\xc5\x59\x64\x36\x8c\x7c\xa2\x4d\x34\xea\x0d\xca\x67\x19\x4b\x6c\x1a\x0e\xb9\xe3\xed\x3f\x1c\x82\x47\xfb\xed\x21\x7d\x05\x39\x9d\xfe\xc0\x61\x76\x1a\xc0\x39\xda\x19\x77\x56\xd8\x20\x36\xc8\x2b\x48\x78\xfc\x22\x87\x6d\x1a\x9e\x12\xf6\x56\xcc\xb6\x18\xc2\xf6\xfc\x4b\xaf\xc5\x1c\x86\x76\x8b\x0e\xf3\x0e\xa9\xa6\x14\x16\x3e\x32\x88\x17\x6d\xf2\xc7\xf5\x74\x7f\xbf\xa6\xc7\xc9\x5d\xb2\xf7\xc1\x8b\xc2\xa8\x92\x72\xd6\x04\x6d\x41\x3a\xca\xb3\x51\x98\xc7\xd4\x25\x87\x3a\x86\xa5\x8b\x84\x41\x9b\x43\xb8\x04\xd2\x21\x98\x62\x11\xc9\x41\x2e\x97\xa7\x3b\x35\x38\x44\x10\xee\x77\x74\xa3\x9c\x92\x54\xf8\xdc\x05\x64\xe4\xce\x78\x94\xdc\xaa\x71\xe7\x73\xe3\x56\x01\x52\x6f\xba\x88\x72\x39\x06\xd1\xfb\x50\xaf\x3e\x9e\x1e\xdd\x59\xa6\x53\x03\x12\x66\xb3\x5d\x9d\xc1\x62\x85\xfd\xb0\x8b\xda\xaa\xb2\xd9\x1c\x62\x51\x39\x32\x09\x1f\x50\xbc\x85\x62\x54\x8f\xc6\x23\x14\x29\xb4\x5a\xa7\x23\x13\xaa\x86\x50\x61\x17\x4d\xa6\x05\xe2\x1a\xfc\x3c\xc5\xbf\x0a\x87\xcc\x8c\xe6\x9f\x8e\x94\xb0\xd4\x5f\x0c\xc5\x94\x48\x09\x5b\xc0\x05\xeb\xf3\x67\x1d\xa5\xfb\xaf\x9d\x70\xed\x12\xdc\xbe\x6d\xc7\xb6\x51\x8c\xfd\x4e\xc3\x98\x3f\xfc\xee\x0f\x63\x0c\x77\xa2\x8b\xc6\xa2\xbd\xbf\xbf\x6b\xf2\x23\xdb\x16\x34\x60\xdb\x01\xc3\x2e\xd8\x08\x39\xd8\xb8\xcb\x70\x80\x18\x8d\x4f\x90\x6d\xa4\x8e\x6c\x7b\xc2\x68\xb4\xdd\x69\x78\x0e\xb3\xd8\x83\xd9\xe7\x0c\x77\x9a\x6e\x73\x94\x54\x56\x96\x38\xb6\xc4\xe3\xf1\xf8\x01\xbb\xc9\x30\x7a\xda\xb4\xd1\x06\x93\xfd\x00\x58\x75\x4b\xaf\xa8\x6c\x69\xa9\x3c\x60\x2f\x32\xec\xda\xbf\x7f\x97\xa1\xc8\x7e\x00\x2c\xfa\xfb\x1e\x78\xe0\x3e\xbd\x1a\xf1\xd9\x37\xdf\x7c\x56\x8d\x88\x90\x49\xdb\x37\x43\xd7\x31\xfb\x6b\xa5\x5a\xd1\x28\x34\x11\x5d\x81\x96\xa3\x6b\x10\x62\x2f\xe3\x84\x43\xff\xcb\x33\xd8\x0a\x28\x22\x52\x3c\xdd\xdf\xaf\x3f\xd6\x9d\xb5\x9f\x0d\x76\xff\x31\x2e\xe4\x46\x2d\x1b\x35\x6a\x19\x9c\xa1\x27\xa2\x9d\x98\x51\xfd\xaf\xbe\xd1\x93\x19\xd5\xbe\xa4\xbd\x7d\x49\x3b\xe9\xb9\xbf\x67\x3b\x1e\x87\x3c\x0a\xf5\x3a\xd3\x9e\xbc\x40\x35\xe7\x5c\x2e\xd9\x9e\x5a\xa6\xdd\xad\xfe\xc1\x19\x7a\x22\x67\xfa\x5f\x7d\xa3\x67\x3e\x07\x7d\xda\x7b\x7c\x51\x0b\xea\xa4\xb0\xd4\xda\x7c\x83\x1c\xa6\x7e\x0c\xba\x80\xd4\x78\xbc\xfa\x8b\x30\xd2\x5f\x44\xdc\x9f\x79\x84\x62\x68\x28\x5d\x07\xc1\xc1\x70\x88\xb7\x00\x23\x98\x81\x6e\x82\x6a\x61\x32\xe9\x46\xa0\xf4\x37\x54\x80\x48\xb2\x14\xd3\x28\x9d\x1c\xe1\x58\x48\xe0\x19\x5a\x44\x99\x1e\x8b\xf4\x00\x70\x7f\xb6\x4b\x53\x49\xa8\xd2\xad\x70\x6c\x06\x73\x31\x77\x97\xd3\xc5\xe8\xc3\xf6\x88\x9e\x53\x76\xee\x5e\xfc\xe8\xaa\x45\x29\x97\x11\x18\x96\x1d\x7b\x77\xf5\xb8\x4f\x56\xef\x9b\x31\x63\x81\x1d\x4f\x04\x23\x39\x2b\xf9\x99\xdf\x73\x55\x7e\x3c\x25\xb4\x6d\xc0\xf2\xd5\xcc\xe6\x49\x1b\xc9\x90\xa0\x47\x24\x47\x2c\x9e\x60\xc0\x59\x77\x6e\xd5\xaf\xea\xa2\x58\x8e\x2d\x9d\x7b\x67\x5b\x2b\xcf\x00\xd3\xf8\xc4\xf2\xed\x9f\x4f\x28\xc5\x00\x1d\xba\xfc\x3f\x0d\x41\x89\x7b\xd1\xaf\x78\xc4\xb2\xef\xab\x32\x3c\x56\xe8\x6b\x0d\xc8\x8e\xdc\xa8\x54\x9d\x55\xc9\x48\x0c\x62\x46\x49\x27\x80\x17\x30\x93\xce\xd8\x45\xbb\xea\xa3\x07\x2b\x83\x81\x06\xa8\x39\xb0\xc3\xa9\xa0\x08\x86\x0e\x32\x68\xdb\x5f\x8a\xec\x0e\xe6\xfb\xb5\xed\x63\x4f\x96\xb2\x3f\xff\xf4\x7f\xa0\x22\x4c\x9a\xcb\x08\x62\x97\x2c\x1c\x4c\x3e\x72\x8f\x67\x45\x2b\x2c\x76\x86\xb9\xb5\x4c\x87\x87\xdc\x4e\x16\xc1\x29\x48\x5a\xc3\xe4\xe0\xab\x2f\x43\x1a\x7c\x1f\x7f\x46\x8e\xc3\x77\xc8\xe9\xbc\x48\x56\xe3\xbb\x99\x58\xbe\x93\x4c\x23\x5b\xf0\x00\x6c\x84\x2a\xf0\x5a\xdd\x1e\x07\x59\xac\xe9\x46\xf4\xda\xbe\x11\x0b\x72\x21\x1f\x6a\xd1\x78\xe8\x21\x9c\x6e\x85\x16\xc8\xc8\x1c\xa3\x84\x83\x02\x1b\xa5\xb4\x40\x62\x02\x98\x84\x18\xe6\xe8\x4e\x11\x5e\x2e\xac\xa7\xd6\x80\x20\x25\xa4\x74\x26\x19\xd3\x16\xf1\xd3\xc5\x10\x0d\x87\x04\x26\x91\x49\x48\x72\xe2\xf2\x5a\x2c\x3c\x7d\x83\x39\xc9\xb0\x45\x4c\xd1\x85\x1d\x0d\xc6\x2c\xf9\x3b\x86\x0c\x58\xbe\x67\xf3\xac\x1f\xbe\xe7\x51\xe0\xa2\x47\x96\x1c\xc1\x77\x0d\x1d\x77\xcd\xbd\x00\xfb\x07\x28\x4d\xb1\x29\x6d\x92\x3c\x72\xe5\x8e\xfb\xf0\x8d\xb5\x95\xb5\xd5\x6d\x69\x0b\x74\xe6\x06\x4a\xff\x3c\x11\x7e\x8f\xb3\xdc\x93\x6b\x4f\x7e\x45\xab\x93\x0e\x25\xdb\x71\x28\x7a\xb3\xde\x50\x62\xc8\x6c\x84\x58\xda\x34\x76\x16\x19\x39\xbd\x6d\x83\x9f\x60\xbc\x3d\xbf\x15\xef\xb0\x7a\xd7\xcf\x59\x34\x5c\x8e\x38\x03\x25\x41\xe3\x2d\x21\xd8\xb8\x60\xd9\x10\x77\xc8\x29\x05\xc1\xad\x3b\x98\xce\x3f\xd9\x21\x8d\x64\x5e\xee\xa2\x0f\xe3\x68\xdd\x74\xf5\x96\x8d\x0d\xb9\x51\x05\x4a\xa0\x2c\x1a\x86\xa6\xa1\x2b\xd0\x62\xb4\x1a\x6d\x46\xf7\xa2\x67\xd0\xab\xe8\xb7\xe8\x3c\x18\xc1\x0d\x55\xd0\x04\x23\x61\x1a\x5c\x03\xfb\x10\x02\xa5\x87\x9c\x23\x11\xcf\x28\xd8\x9e\xe1\xb1\x5d\x4e\xdb\x71\x4c\xb2\x63\x81\xae\xa9\xa7\xe8\xba\x1a\x24\x52\x61\x67\xc2\xd9\x88\x53\x61\x21\x16\x76\x26\x52\x72\x22\xc3\x38\x2b\x20\xd5\x08\xce\x44\x2c\x9e\xc8\xa4\x93\x35\x10\xaa\x00\x67\x22\x95\x88\x24\x7b\x95\xfa\x91\xb8\x1c\x66\x35\x59\xcc\x87\x43\xe9\x82\x2b\x24\x87\x62\x21\x85\x6a\x53\x92\x99\x74\x6d\x3c\x45\x4d\x5b\x6b\x65\xa7\xe4\x14\x7c\x10\x16\xf8\x30\x1f\x4d\xa4\x92\x4a\x2c\x24\x68\xec\xc7\xce\x44\x2a\x99\x88\xfb\x81\x9e\x9c\x72\xa2\x19\xc2\xce\x9e\x69\x76\x2b\x24\x6b\x40\x51\x03\xe4\x8c\xb6\xf2\x4b\xd7\xd1\xc3\xa1\x98\x9a\xfe\x34\x5d\xe4\x6d\x56\x93\x9f\x0a\x3b\xd5\x2c\x38\x12\xf1\x4c\xcf\x2e\x2f\x35\x2c\xa6\xbe\x29\xd1\xf7\x16\x39\xa3\x48\x85\xc0\x98\xb6\xa5\x88\x3e\xf7\xf2\x97\x5e\x72\x43\x21\xb0\x27\x4c\x08\x85\x79\x81\xa7\x7a\x39\x07\x5d\x9c\xcc\xa8\x13\xe3\x4c\x3a\x95\x8c\x29\x31\xb5\x9c\x94\xaf\xe1\xfb\xcc\xcd\xdd\xbd\xf8\xf9\xbd\xe3\xc7\xef\x3d\xbd\xe4\xee\xdc\xce\x39\x73\x1f\xdc\x3a\x6b\xe6\xb6\x6d\x33\x67\xcd\xde\x31\x77\xce\xce\xdc\xdd\x4b\x4e\xab\x61\xcf\x2f\xbe\x1b\x2f\x14\x6c\x02\xe3\x67\x39\x9e\xe7\x18\x9e\xe5\x74\x98\x61\x30\xc3\x52\x1a\x58\xc0\xc0\x33\xd0\x25\x49\xa2\x5d\x92\xec\x22\x1c\x6e\xe2\xda\x60\x8f\x14\x91\x25\xd1\x7e\x41\x8e\xc8\x72\x64\x0f\xc6\x40\x4d\x60\x31\xc6\x0c\xb0\x98\xde\x84\xe1\xc2\xe9\x80\xdf\x5d\x62\x31\x17\xbb\x2c\x81\x40\x30\xe0\x0f\x06\x8e\xf8\xfd\x36\x8f\x5f\x51\xfc\x3e\xcb\xe3\x35\x66\xd9\x2d\x3b\x8a\xa4\xa0\x27\x50\x63\x72\x15\xbb\x1d\x26\x77\xd0\x1f\xdc\xa1\x33\x99\xc4\x01\x03\x02\x3e\x5f\x8d\x73\xa1\x5f\x89\x05\x82\x92\xd9\xee\x0c\x09\x0b\x23\x3b\xe5\xa2\x40\xc0\x6f\xd0\xe9\xf5\xf6\x58\xd0\x2f\x9a\xed\x36\xbb\x2c\xdb\x45\xab\xd9\xe1\x0b\xbe\x1d\x08\x58\xbc\xfe\x58\xcc\xef\x33\xef\x96\x8b\xfc\x7e\x35\x9a\x6e\x9b\xdf\x6f\xa9\x8b\xc5\x7c\x7e\xf3\x18\xac\x26\x4d\x1d\x91\x62\x96\x61\xb1\x7a\x45\x53\xa8\xa6\x7a\x71\xff\x06\xc4\x3e\x32\x79\xfc\xde\xd3\x8b\xd5\x62\x99\xbc\x1c\x9a\xa1\x69\xe2\x15\xe4\xe7\xe4\xbd\x2b\xae\x80\x4a\xa8\xba\x66\x39\xf9\x11\xf9\xd1\x32\x35\xc6\x92\xc5\xa7\xf7\x8e\xef\x3e\xcb\x30\x36\x87\xc9\xe4\xb0\x98\x4c\xa4\x1e\x33\x06\x0e\xd4\x52\x30\x71\x95\x8a\xcb\x6d\x17\x5d\x53\x4b\x8a\x35\x87\x3b\xe2\x56\x4f\x7e\x60\x69\x2a\xb0\x56\x3e\xac\x9a\x08\x4c\x13\x31\xd9\xe5\x07\x97\xcb\x61\xdd\x33\x2a\x12\x19\xa5\x1e\x43\x06\x5b\x1d\xa5\x2d\xa5\x0e\x57\x88\xc7\xac\xc1\x62\x74\x99\x5d\x8e\xa0\xea\xb4\x99\x65\x9b\xcb\xec\x16\xa4\x66\x6f\x59\x99\xb7\x39\x7e\x73\x69\x71\x49\x4c\x94\x2c\xc1\xa2\x92\x98\xc3\xba\xa7\x3d\xcc\xfa\xd8\xd2\x96\x52\xab\xcb\x04\x2e\xc5\x55\xe4\xb2\xee\xeb\x79\xd4\xe6\x9e\xe0\x7d\x43\x36\x0f\x73\x94\x35\x95\x39\x18\xf5\x8b\xa9\x25\x82\x69\x2a\xd4\x7f\xea\x37\xc7\xd4\x96\x1a\xd8\xdf\xf6\x17\x05\x1a\x3f\x3d\x95\x05\x06\x64\xa3\x2b\x7f\x83\xd0\x54\x34\x1f\x2d\x43\xab\xd1\xb5\xe8\x06\x74\x0f\x65\x39\xe4\x2b\x28\xfe\xab\x14\x75\x50\x07\x97\x54\x2a\xc0\xd6\x43\x0e\xcf\x15\x74\xc8\xe9\xbe\x26\x45\x89\x42\x35\x8c\x6b\xda\xaa\xa8\x2e\xb9\x60\xe8\x93\xea\x69\x14\x60\x33\x43\x11\xe6\x82\x7d\xe3\x85\x28\x65\xa2\x17\x33\x6a\xeb\x2b\x1c\x90\xa0\x96\x57\xea\xeb\x52\x5f\xd3\x1a\x42\x7d\xc4\xdf\x64\xb3\x35\xfb\x22\xfc\x5f\xb2\xa2\xa3\xf5\xfc\xc4\x05\x63\xe7\xce\x1d\x59\xd5\x14\x18\x38\x10\xb2\x65\x19\xbf\xd3\xeb\xf4\xbb\x42\x65\xf5\x95\x4d\x91\xea\xa8\x4e\xf4\x49\x03\xe4\xf2\xca\x61\x89\x2c\x48\xd1\xb2\xda\xd6\xd6\xea\x0a\xa5\xb4\x74\xe4\xe2\x45\x23\xcb\xd9\x7f\x0d\x7c\x80\xfc\x98\x3c\x4c\x1c\x84\xf0\x41\x8f\xd2\xfd\x83\x65\x07\x96\x2d\x3b\x00\xf8\x96\x61\x33\xa6\x0f\xbb\xf9\x9d\x67\x36\xac\x5d\xbb\xe1\x19\xd8\x33\x6e\x69\x7b\x4b\xdd\xbc\x81\x7a\x08\x8e\xce\x7c\xa5\xcb\x8c\x1e\x9d\x11\xbe\xca\x8c\xc6\xff\x4a\x04\x3d\x1f\x79\x8b\x4d\xc9\x85\x6b\x46\xce\x26\x4f\x28\x89\xe9\x30\xfa\xf7\xa5\x95\x0e\x83\xdd\x6c\x75\x7a\x2b\xa3\x99\xd2\x70\x99\xd5\xc4\x17\x49\x0e\x6f\x65\x69\xb6\xb9\x6c\x74\x74\x60\x7c\xc0\x60\x65\xb4\x63\xe1\xfe\x85\xf9\xa7\xb1\xa5\x74\xda\xfe\xed\x37\x0e\x50\xf0\x8f\xd5\x97\x2e\xd3\xc1\x94\x73\xe7\xc8\x31\x7d\xdd\x8c\xba\x91\xf5\xe4\x89\x1b\xad\x63\x6a\x92\xe4\x89\xdd\x38\xd2\x55\x54\x37\x66\x4c\x1d\xfb\xf7\xba\x31\x63\xd4\xe1\xb8\xbd\xf7\xdb\x61\x64\x44\x66\xe4\x44\x3e\x14\x46\x0a\x6a\x40\x63\xd1\x4c\xf4\x36\xfa\x35\x3a\x0f\x1c\xe8\x21\x02\xad\x30\x1f\x21\x31\x11\x83\x8c\x2a\x8c\x9d\x61\x67\x54\x4e\xc9\x49\x55\xfc\xc6\xa3\xda\x09\xb4\x13\x97\x88\x45\x6d\xe1\x94\x10\x8e\x39\xc3\xb1\xb0\x10\x16\x13\xa2\x2d\x21\x67\xc0\x61\x66\x43\x4a\xd8\x19\x8e\x09\x41\x5b\x50\xce\x24\xe2\x51\x67\xd8\x96\x70\x6a\x0f\xeb\xdd\xc4\x65\x4b\x64\x12\x32\x95\xf5\xce\x60\x2a\x13\xf7\x43\x30\x15\xc0\xe9\x1e\x4f\x5b\xd8\x19\x53\xff\xa8\x28\x54\xfb\x5e\x7a\x25\xf4\xce\x71\x69\x40\x48\x48\x05\x9d\x4a\x05\xa8\x87\x40\xf7\x20\xc9\x89\x54\x22\x9e\x51\x3b\x0a\x0d\x27\x3d\xa3\x26\xda\xc1\x0b\x01\xf0\x43\x98\x56\x0d\x35\x29\x71\xaa\xa2\xa3\x7e\xc9\x74\x35\x43\x3d\xe5\xb8\x04\xfd\x93\x69\x0b\xdb\x40\xab\xc0\xa9\xa4\xa2\xed\xaf\x6f\x04\x67\x38\xe4\x74\x48\xe9\x00\x64\x9c\x7c\x4f\x18\x4f\xf5\x11\x85\xb0\x00\x30\xb6\x9e\xe2\x08\xa5\x92\x8d\xe0\x0c\x29\x66\x96\x62\x5f\x64\x68\xe9\xa4\x36\x4c\xaf\xc2\x03\x47\xb6\x3d\x78\xf3\xcd\xd0\x7c\xc5\xf3\xa5\x93\x26\x96\x41\xb0\x7c\xc2\xf8\x0a\xf2\x85\xfa\x0b\x67\xa6\x57\x76\x4b\x83\xe6\xd4\xcf\xd9\xe5\xde\xe3\x6e\xbb\xba\xe3\xaa\x65\x93\x47\xe3\xbb\x8c\x36\x9f\x2b\xe6\x2a\xd3\x6f\x1d\x37\xf1\x22\x02\x76\xdc\x84\x9f\x5e\x49\x3e\x3e\x7b\xf6\xae\xdb\x6f\xe7\xde\xd3\xea\xd6\x4a\x77\xc6\xfd\xa1\xb8\xda\x81\xfd\x06\x03\xc8\x72\xb6\x6c\xb2\xde\x5d\xe7\xfe\x4d\xe8\xa9\x27\xdd\xa7\xe4\xf3\x43\x4b\x8f\xbb\x6a\xf3\x37\x56\x54\xfc\x44\x7a\x78\x8c\x56\x0d\x37\x26\x02\x27\x33\x32\xf9\x71\x71\xdd\xbb\xf2\x90\x2f\xd2\x71\xf2\x20\x4c\xcd\x24\x7f\xee\x6c\x2c\x3e\xa1\xd3\xb1\xd8\x56\x5f\x7c\xb4\x29\x5f\xe5\x92\xdc\xf6\x81\xae\xd0\xd0\x81\xf7\x0c\x68\x20\xff\xe3\x76\x7a\x6c\x03\x01\xb8\x22\xd9\xde\x96\xbd\xbb\xb6\x01\xdb\x7e\xf1\x8b\x3b\x6f\xbf\x9d\xfc\x71\x10\xfe\xd7\xa2\xad\x5b\x43\xa1\xda\x78\x28\x59\xba\x63\x43\x24\x5c\x5b\x1b\xfe\xb3\x2b\x7b\xed\xb5\x41\x77\xb4\x22\xea\x4e\x95\x6e\x5f\x1f\x69\x18\x7b\xfb\xac\xcd\xbb\x3c\xd7\xb9\x47\x6d\xdf\xdd\x2a\x94\x5b\x8a\x8b\x6c\xbc\x37\xe2\x9f\x35\xef\xca\x2b\xd6\x30\x53\x56\xe4\xaf\x1b\x3b\xb6\x36\x93\x1e\x73\xd5\xd9\xa6\xe0\xd0\x52\x7f\x33\x7c\xe9\x6f\x52\x56\xd4\x90\xbf\xbe\xf7\xde\x7b\xef\x35\x35\x81\x85\x5c\x04\x78\xe6\x99\xfc\x7b\x8e\x80\xc3\x24\x60\x98\x39\x63\x06\x58\xa6\x4f\xef\xae\x03\x4b\x7d\x6d\x26\x9d\x7f\xf7\xb7\x99\xb1\x63\x33\xf8\x48\x73\x73\x75\x75\x4d\xcd\x15\x60\x9e\x22\x17\x15\x01\x6e\x6e\x6e\x68\x80\xcd\x95\x95\x95\x95\x92\x24\x49\xf3\xe6\x55\x56\x3e\x01\x7b\xd4\x98\xf9\x19\x52\xe1\x5f\x43\x03\xb9\xae\xb1\x71\xba\x69\xd1\x15\xac\x6e\xaa\xcb\xd5\x25\x97\xea\xf5\x21\x7f\xba\x2a\xe8\xbc\x02\x2c\x01\x38\xea\x2a\xd5\xeb\x83\x81\x94\x3e\x6c\x91\x0c\xc2\x7c\xb0\x80\x3f\x7f\x75\x1d\x58\xea\x6a\x33\x69\xfc\x30\xf9\x2b\x58\xf2\x57\x4f\x69\x70\x5b\x0d\x82\x12\x89\x95\xd7\xbb\xad\x7a\xe0\xa3\xe6\x85\xe1\x06\xb7\xa9\x08\x38\x63\x34\xa0\x7a\x3a\x58\x1e\x0f\x22\x5f\x9e\x39\xd3\xd4\xb4\xfb\x86\x46\x0c\x8c\xc1\xe6\x17\x95\xd2\xf7\x2f\x22\x40\xa7\x4f\xab\xed\xd3\xd8\xdb\x3e\x8d\x48\x46\x61\xd4\x80\x26\xa2\xab\xd0\x6e\xf4\x00\x3a\x81\x4e\xa1\xd7\x0b\x6c\x54\x85\x75\xa2\xa8\x83\x0f\x0b\xea\x8c\x20\x1e\x80\xfe\xeb\x47\x51\x0a\x3a\x22\x30\xbc\xd4\x08\xf1\x56\x68\xc1\x54\x4b\xc6\x89\x69\xea\xdd\x6f\xf7\x36\xef\x74\x34\x82\x3a\x1d\xab\x80\x90\x05\x28\x91\x3f\x35\x0e\x90\xb5\x80\x0c\xfc\x7f\x3f\xc9\xa1\xdd\x21\xa6\x92\x34\xbe\x40\xe1\x4e\x32\x60\x86\x42\x02\xa5\xcb\xe5\x30\xfe\x3c\x11\xf5\x87\xe3\x51\x5f\x94\xb1\x55\x56\x96\xd8\xb0\xd1\x2e\x79\x5c\x30\x37\x11\xf1\x47\x54\xdf\x0b\x47\x47\xb7\x1c\x12\xf1\x40\xd0\xf1\xed\x0e\x6c\x87\x22\xbb\x55\x62\xa6\xcc\x87\x54\x99\xea\x63\x66\xbc\x43\x86\x2f\x1c\xda\xe0\x6b\xb2\xb3\xa6\xa1\x22\xbc\xac\xe3\x46\x1b\x85\x65\x95\x9c\x6d\x14\xa7\x8b\x55\xc1\x04\xd3\x68\xa3\x80\x2e\xc2\xd6\xd1\x2d\x0f\x38\xe8\x43\x26\x14\xb1\x5f\x7f\x88\x67\xa8\xfa\x10\x7f\x93\x4d\x7d\xc8\xc7\xa6\x91\x46\x1a\x75\x90\x88\xcf\x8f\xe0\xca\x63\x41\x1b\x36\x8a\xa5\x11\x61\xcd\x25\xe3\xea\xf5\xd1\xda\x12\x5f\x34\x11\xdc\x58\x1e\x80\xe5\x46\xd6\xf9\x70\x24\x4e\xaf\x6f\x6e\x4c\x89\x64\x09\x6f\x10\xaf\xd2\x19\x18\x3c\xef\xd7\xc0\xf1\x86\x60\xe9\x8a\x11\x8d\x6d\x2e\x47\x91\xde\x0a\x4e\x83\xde\x70\xef\x01\xab\x9e\xc3\x6b\x76\xb1\xab\x74\x26\x03\xac\xaa\x2b\xdc\x62\xba\xfa\xeb\xb7\x80\x95\xb5\xc2\x71\x30\x1b\x49\x07\xe6\xf4\x22\x88\x61\x09\x96\x1b\x65\xf8\xd5\x25\x5d\x31\x32\xf4\xeb\x8b\x2d\x28\x8e\x86\xa3\xa9\x68\x26\x5a\x81\xae\x46\xfb\xd0\x41\xad\x1f\x0e\x87\x62\xea\xe8\x97\x0b\xa7\x69\x2f\x4c\xfb\xdd\x42\xb7\x2b\x14\x10\xb9\xd5\xb1\xac\x42\xbb\xdd\x4c\x1a\x32\xe1\x94\x85\x49\x14\xb6\x51\x6a\x06\x5d\x1c\xed\x80\x85\x58\xd8\x96\xb0\xa5\x13\x71\x91\xf6\xe0\x74\x97\x6b\xac\x80\x26\x99\xe9\x9b\xc0\xd3\x00\xbe\x70\x3f\x1d\xfe\x2a\xb1\xc4\xd7\x30\x39\xf9\x66\xa7\x18\x94\xed\x7e\x5f\x3d\x3c\x75\x15\x1f\x4f\x9c\xff\xc3\xa0\x21\x91\x12\xa5\x61\x90\x7d\xf0\x84\xd1\xd5\x03\x06\x0e\x8e\x15\x0f\xf0\x4f\x28\xb6\x0f\xef\x18\x3f\x20\x01\x31\xb1\x63\xbb\xbd\xda\xd6\x52\xa9\x8c\x28\xa9\x29\x29\x2a\x87\xeb\x2d\xa6\x92\x1a\x83\x61\xe7\x01\x4f\x9d\xb5\xe6\xc0\x01\x7c\x55\x55\xe9\xb0\x6c\x4a\xb7\xeb\x40\xa4\x64\x62\xa2\x99\x54\x56\x0f\xaa\xae\x1e\xc4\x3c\x36\x20\x3e\xa7\x63\x65\x6b\x66\xd9\xc2\x46\x6b\xfd\xb0\x0a\x87\xcc\x7d\x85\x2f\x9d\x25\x6d\x1a\x1a\x0d\xeb\xcf\x05\xa6\xcc\xff\xbc\x71\xa0\xdb\x24\x99\x3d\xc1\x55\x25\x4a\xac\xad\x61\xa0\xcb\x2c\x5b\x8b\xdd\xf6\xd5\x65\xd1\x32\x08\xaf\xdc\xe3\x5c\xa3\x5b\xfc\xcb\x49\x91\x80\x71\xbd\x10\x7f\xc5\xbd\x8f\x29\x09\xd4\x91\x32\x88\x17\x93\x47\xe1\xbf\x3e\xd9\x5c\x9f\xac\xab\xc9\x5f\xe3\xbe\xd3\x58\x37\x10\x7e\xac\xbe\xb9\x86\xfc\xcf\xea\xd6\xec\xae\x35\xb9\xa6\x4c\xe9\xe2\x62\x51\xac\x31\xe3\x93\x97\x7c\x38\x06\x99\x2f\x22\xe1\x4b\x1e\xd1\x76\xde\x8a\x10\xd8\x65\xb5\x80\x1c\x7c\x48\x89\x71\xf1\x24\x6d\xcb\x6a\x2f\x03\x12\x2f\x68\x68\x6c\xe9\x56\x50\x52\x2d\x6c\x2a\x69\xcf\xf4\x2c\x3e\x09\x01\x90\x21\x2d\xc9\xbc\xd4\xfc\xc7\xf6\x24\xc9\x1e\x78\xef\x0e\x00\x64\xb5\x36\x4e\x2e\x59\xcc\x26\x74\x60\xf8\xea\x31\x83\x57\x37\x49\x07\x86\x67\xc5\xf8\x84\x69\xcd\xb1\x2f\x5e\xd0\xd5\x8d\xab\xd3\x6d\x79\x21\x05\xdf\x33\x78\x75\xf8\x38\xb9\xf7\xb5\x64\xfb\xb2\x03\x77\x2c\x7b\xb4\x64\x72\xa3\xd5\x3a\x62\x31\x9f\x35\x78\xf5\xe7\x8f\xe9\xb0\xa1\xc3\xe0\xd5\x7d\xb7\x24\x54\x3e\xeb\xb6\x63\x5f\xee\xbb\x0b\x38\x9f\xe8\x28\xad\xab\x2b\x75\x88\xf6\xed\xb3\x61\xb9\x0e\x1b\xb4\xfd\x6c\x7d\xf9\x90\x90\x82\xc6\x20\xc4\xf6\x25\x3e\xa1\x87\x02\x35\xa3\x15\x7a\x73\x97\x09\x2a\x4c\xc6\x0e\xf2\xff\x47\xc6\x58\x2d\x2b\x23\xf2\xff\x62\xae\x2c\xff\xe1\xee\xd9\x77\xcf\x18\xc0\x76\xf6\x64\xf4\x0e\xfc\x8f\x23\xcd\x2b\x9b\x61\xf0\xa4\xff\x98\xd1\xc7\x0a\x99\x83\xff\xc1\x5f\x4d\x5b\xd7\x3a\x7f\x45\x82\xe4\x48\x56\xcb\xf8\xf6\xe7\xc0\x3a\x8f\xdc\xcb\x1e\xed\xf8\xff\xcd\x78\x2f\xc6\x31\x97\xeb\xd5\x73\x65\xd0\x4c\x8d\xbb\x90\x8a\x50\x9b\x86\xf6\xf4\x9f\xae\x21\x18\x53\x62\x41\x5e\xe0\x7a\x78\x05\xb5\x06\x12\xee\xe1\x80\xc8\x68\xeb\x38\xc5\xa0\xca\x4b\xf4\xcd\x30\x4d\xfd\xdd\xf9\x73\xd0\x39\x40\x30\x90\x1f\x19\x04\x66\xa5\xdd\xdc\xa1\x11\x38\x50\x85\x23\xa4\xda\x2c\x63\x4a\x21\x5b\x3a\xc6\xd2\x06\x29\xb3\xfd\x10\xa6\xaa\x9c\x3c\xbd\xf5\x5b\xdc\xcc\x9f\xd6\xe9\x31\xd6\xdf\x91\x35\xdb\xbb\xdb\x27\x6e\x5a\x37\x91\x79\x86\xbe\xe6\xa1\x68\x32\x19\x7d\xc8\xde\x0f\xcb\xb8\x92\x5a\x3a\x22\xd0\x20\x87\x90\x06\xe9\xc2\xf8\xd5\x91\x53\xa8\xb9\xbf\xb5\x54\x8f\x5a\x0d\x7f\x9b\x0d\x0a\xbb\x75\xc4\xda\x4d\xf5\x6f\x91\x3f\x82\xf5\x4c\x68\xe2\xe2\x09\x75\xd6\xf5\xd6\x9d\xc3\x6f\x3c\xf9\xf4\xcd\x43\x6e\xd4\xf3\x1b\x78\x43\xf7\x7f\xb2\x51\x81\xb7\xaf\x8c\x8f\xa9\x90\x40\xfa\xe9\x19\xb0\xea\xbd\x65\xc3\xab\xae\xb4\x5a\xdb\x2a\x6a\x9f\xde\x7f\xe7\x2b\x03\xca\xdb\x04\xbd\x9e\xa9\xf8\x4f\x56\x2c\xfd\xf5\xf0\x66\x34\x1f\x21\x9a\x07\x33\xd6\xe8\x44\x81\x73\x98\xb1\x10\xd2\x24\x5b\x61\xe9\xd7\x4e\xd1\x26\x5b\x35\x26\x4e\x59\x12\x18\x9a\xe1\x16\x36\x65\x45\xc1\x10\xcd\xab\x2a\x23\xa5\x62\x8d\xb2\x0d\xfa\xc1\x95\x23\xe6\xcd\xe5\x73\x5a\x37\xcf\x6f\x5e\x3e\xaf\xe3\xd0\x64\x9c\x1c\x79\xcd\x8d\xa3\x78\x51\x98\x5b\xe3\xe3\x92\x0f\xcc\xf9\xee\xc9\x5d\xbf\xde\x3d\x75\xaf\x82\x8d\xa0\xe7\xd6\x73\x3a\x0e\x6f\xe4\xdc\x25\xbe\x86\x69\x83\x06\x90\xef\x93\x8f\x7a\x2c\xe1\x3f\x3b\x69\xf4\xe8\xca\x74\x80\x0d\x8b\xba\x76\x53\x1e\x3f\xca\xcf\x07\xd3\xe0\x28\x3e\xbf\x62\x73\xf3\x8a\x23\xf3\x56\x6d\xde\xfd\xaa\x6d\xe5\xf1\xf9\x09\x0c\xa9\x60\x7c\xd0\xb4\x17\x4f\xdc\x07\x86\x83\xc3\xb2\x62\x1d\x5f\x64\xe4\x8c\xf9\x7b\x5c\xae\x98\x07\xf4\xb1\xe6\xf5\x63\x20\x02\xb3\x7a\x8a\xe8\x16\x3d\x36\xd6\x16\x15\x99\xf4\x13\x67\xa8\x8f\x84\x3a\xf0\xbd\xbd\x99\x4c\xeb\xb5\xdb\xa2\xeb\x7a\x61\x54\x8a\x10\x92\xac\x16\xa0\x5a\x7f\x3e\x54\x03\xc0\x57\x00\x17\x13\x53\xc9\x0c\x14\x94\xf6\xc5\x90\x49\xeb\x21\x06\x4e\x7e\xc8\xe9\x39\x9f\x2e\x31\x18\x7e\x66\xf0\x18\x96\xe6\x0f\x47\x53\x67\x2e\xa2\x6c\x2e\x8a\x67\x2e\xd5\xfc\x96\xfc\x6a\x76\xf7\x2b\x38\xdb\x99\xef\xe4\xd1\x69\xf2\xaf\xd9\xbf\x5a\x62\xf0\x18\x7e\x66\xa0\x71\x73\x59\x40\x67\x52\x34\x2e\xf5\x5b\xf2\xe9\x9c\x0b\x59\x1a\xb7\xb3\x60\x47\x46\xa8\x1e\xb2\xac\xc0\xd1\x21\x20\xa1\x97\x9c\x93\x12\x37\x48\x28\x1c\xaa\xc6\xa9\x00\x93\x88\x67\x5a\x58\x7e\x6c\xdb\xd2\x2a\xf2\xe4\xee\x79\x9b\xb6\xfe\x70\x16\xde\xda\xd8\xfd\x6c\x6c\xcf\x44\x60\xc9\x3f\xfe\xeb\x9a\x17\xd6\x36\x08\x43\xea\x5a\x2c\x65\x66\xf7\xc0\x91\x8b\x96\xf0\x68\x76\x5b\xeb\xb4\xfc\xbe\x6b\x66\x9e\xda\x96\x9b\x84\x07\xa7\xbb\xfe\xd9\xbe\x42\x1a\xf6\x3e\xf9\xfb\xec\xef\xbd\xb9\x9e\x8b\xc7\x42\xd1\x41\xb3\x1b\x23\x96\x4b\xf4\xa1\x55\xbd\x68\x7a\x14\xa1\x3a\x4e\x31\x34\x35\x88\x4b\x9c\xa0\x57\x58\xad\x36\x94\xa5\xb2\x00\x58\x1c\xc0\xa2\x33\x54\x0d\x31\x0d\x3b\x56\xa0\x10\x5e\xdf\x7c\xa1\xce\x64\xd2\x8d\x60\x0b\xf6\xfe\xd7\x66\x34\x9a\x35\x15\x9b\xea\xd3\x29\x7e\xfd\x42\x40\xe7\x51\xd5\x38\xc5\x17\xa8\x08\xbb\x4a\x25\xc9\x1f\x19\x57\x5d\x35\x2e\x12\x70\xca\x31\x57\xb8\x22\xe0\x53\xc6\xcd\xd0\x02\x43\xf4\xa2\xaa\x10\xa7\xaa\x7a\x5c\xc4\x2f\x49\xa5\x6a\x9c\xaf\xdf\x42\x43\x03\x15\xe1\x55\xe3\xb2\x80\x7a\xfe\x67\xc7\xad\xea\x42\xc3\xeb\x52\xa3\x44\x5f\xc8\x27\x2a\x33\xf0\xb7\x5e\xe4\x48\x0e\x72\x3e\xaf\xcb\x2b\x99\xad\xa2\xdb\xe3\xf3\xbb\xdd\xa2\xd5\x2c\x79\x5d\x5e\x1f\xf5\xa5\x2e\xc8\x76\x6a\xa1\x3e\x8f\x16\x7a\x59\x44\x8f\xdb\x2b\x75\x8e\x5b\x05\x9d\x24\xdb\x73\xac\x62\xac\xa3\x27\x8e\x4a\xf9\x2b\x5d\x25\xc5\x0d\xca\xed\xed\xdf\x7a\xa1\xb5\x79\xaa\xaf\xe2\xd4\x71\x78\xd0\x19\xb4\x25\x6c\x7a\x08\xda\xf4\xa0\x43\x5f\xa1\x1c\x8f\x00\x9d\xcf\x41\x27\xce\xe6\x78\x74\x21\xc7\xa2\xee\x1c\xce\xe2\x6c\xbe\xb3\x97\x1b\xa5\x93\xf6\x83\x56\x24\x21\xa4\x07\x8d\xf5\xc9\x6a\x8f\x24\xc4\xa0\x03\x0b\x62\xd0\x16\x67\xed\x0c\xc2\xa1\x65\xe4\xb7\xf7\xbd\xab\xc9\x9b\x77\x9f\x63\xb8\x8d\x2b\xbe\x9f\x47\xef\xc2\xbc\xb7\xf1\x75\xf9\x4f\x56\x6c\xec\x91\x42\x79\x74\x1f\xf9\xed\x32\xfc\x3d\x06\xbd\x4d\x1e\xb8\x24\x6d\xc5\x3d\x69\x53\xbb\x0c\xb5\xa5\xa9\xcd\x2d\x46\x5b\x18\xc4\xb4\x85\x73\x9a\x5e\x01\xc5\xac\x9b\xf2\x7b\x0c\x1e\xc3\xe7\xa4\xa3\x13\x8f\x50\x1d\xf0\xce\x26\xab\xcd\x09\x4f\x98\xed\x5a\x1e\xce\x91\xd1\x4e\x1b\x8d\xd5\x13\x49\x8b\x13\xb3\x17\xf8\x96\x04\xc4\x4e\x45\x1d\xea\x48\x52\x0e\x30\x32\xab\xd9\x0c\xf3\xb1\x6a\x46\xad\x84\x05\xd0\x12\x6d\x8f\x48\x30\x44\x91\x8c\x71\x22\x1e\xe0\xe5\x02\xda\x36\x4f\x41\x5d\xe5\x00\xc8\xe1\x00\x96\x05\x25\x46\x07\x92\x5c\x91\xc1\x10\x48\x46\xa2\x30\xf4\xe7\x77\x34\x2e\x1d\xd3\x1e\xaf\x0f\xd4\x1a\x4b\x1a\xa7\x6d\x9c\xd0\x71\x62\xd1\xfb\xf7\x9d\x1c\x5f\xe7\x9d\x64\xf1\xc3\x4e\x72\xf1\xb6\x7f\xec\x9d\x7a\xeb\xab\x4b\xa7\xde\xb2\x78\x6a\x43\x63\x79\x83\xa7\xe3\xfa\xf1\x6b\x95\xd6\x09\x53\xa7\x8d\xac\x33\x32\x8f\xae\x1c\x33\x79\x00\x14\x49\x01\x76\xbb\xc7\x27\x8f\xac\x6d\x63\xb2\x7c\xd8\x5f\xe6\x35\x19\x66\xfe\x75\xff\x4b\xd1\xf4\xdc\x71\xdb\xc6\x5e\xe7\x1b\xbf\x74\x5a\xe9\xca\xc7\x3b\x0e\xfd\x79\x6e\x6b\xea\xae\x50\x04\xee\xba\x1f\x60\xff\xd2\x37\xee\x9c\xa5\xb4\xcc\x5f\x70\xdd\xda\xfd\xe9\xd7\xe6\x8d\x2b\x6f\x2a\x29\x96\xab\x1a\x97\xb6\x59\x6d\x57\x7d\x9f\x65\xe4\x72\xa3\xb7\x8a\xbb\xa2\xd6\x09\xce\x41\x97\xf4\x05\x53\xa9\xce\x3e\x19\xab\xc6\xb1\x64\xcf\xf2\x55\x58\x92\x33\x4a\x4c\xc3\x23\x71\x50\xe4\x5b\xc6\x0f\x12\x35\x5c\xe5\xd4\x32\x92\x9d\x9a\xec\xcf\xf4\x42\x17\xd3\x66\x2e\x24\xbe\x01\xa7\xfe\xae\x2f\xc2\x91\x52\x3d\x8b\x6b\x23\x69\x1b\x38\xc4\xd9\x31\x43\x70\x68\x62\xdc\x16\x6c\x9d\xb7\xc0\x5f\x1a\xf7\xc2\xc4\xc6\x79\x6d\x72\x7d\x6c\xe8\xd8\xdc\xc4\x85\x4f\x2d\x63\xd8\xd9\x27\xae\x7c\x76\xb6\xc3\xd8\x54\xbe\x66\xfa\xda\xbb\xbe\xbf\x64\xd5\xd5\xd5\xba\xb0\x54\x16\xc9\xd4\xb5\x97\x2f\xbf\x6b\xc9\x25\x3c\x06\x9f\xfd\x60\x90\xc1\x14\xf5\x61\x93\x11\x47\x6a\x2c\x96\xc8\xb0\xb4\xc1\xef\x58\x3b\x4e\xb0\x76\x4c\xf3\xeb\x2c\xbe\x32\x0f\xd7\xd0\x76\x4b\xcd\x1d\x8b\x36\x0c\xaf\x5d\xf5\xcc\x02\x58\xf1\xd4\xea\xab\xbc\xae\x2b\xc7\x0d\x3f\xb1\x6e\xe9\xd1\xe5\x1b\x9c\x73\x1b\x66\xd6\x0f\x89\x79\xf7\xe1\xdf\x5e\xba\xe1\x81\x29\xe8\x78\x35\x0c\xd1\xc4\x65\xcc\xbb\x91\x64\x35\x0e\x07\x25\xbb\x15\x0b\xc1\x78\x0b\xd8\xad\x66\x1c\x0e\x86\xaa\xb1\xb5\x05\x27\x82\xf1\x00\xb0\xb9\x82\x1d\xab\x76\x62\xa8\x55\x2c\xd9\xba\x61\xdf\xbe\x0d\xb0\x63\xc9\xf3\x37\xbc\xab\xf6\x6d\x79\xd4\xd3\xcb\x31\xaa\x0b\xbb\xfa\x6e\xe8\x39\xcd\x20\x7f\x27\x6f\x92\xbf\xcf\x18\x7f\x03\x3c\x74\xd9\xf8\xa0\xdf\x7e\x42\x44\xd1\xf2\x91\x0b\xb4\xb7\xe3\x42\x6a\x80\xed\x35\xeb\x77\x04\xa0\xf7\x3d\x8b\x7a\xdf\xcd\x3e\x7e\xc9\x1b\x81\x14\x1e\xdd\x33\x86\xb8\xf5\x92\xc4\x50\xf9\x8f\x90\x5e\x3d\x99\x91\x1d\xb9\x50\x25\x45\xe5\x0a\x86\x94\x56\x50\x6b\xbf\x55\x6d\x1b\xb1\x84\x12\xe3\x20\x28\x48\x32\x4b\x41\xf9\x45\x49\x33\x79\xa6\xe3\x86\x12\x64\x45\x25\x28\x95\x4c\x67\x62\x6a\x37\xaa\xd6\x1b\x64\x45\xea\x9c\x8d\xd2\xd3\x26\x82\xce\x60\xac\xe0\x8a\xcb\x90\x4e\xc4\xf1\x05\xf2\x93\xd2\xb0\xeb\xf4\xc0\xe1\xbb\x4e\x9f\xde\xb5\xf6\xb1\x07\x9f\xb5\xd7\xc3\x6a\x28\x21\x25\x57\x2c\x75\x72\xdc\xe9\x5d\x4d\xcd\x27\x2c\x06\xc9\xe2\x0c\xdb\x4f\xcc\x3e\x0d\x3a\x68\x22\xe7\xc9\xcd\xe4\xfc\xd8\xb6\x81\xe4\x01\x7b\xf0\x15\xb9\xfb\xe8\x29\x72\x1e\x84\x53\x6b\x16\x5e\x4f\x4d\x2b\x21\x07\x4f\x4c\xfe\x44\x33\x8c\x0c\x3a\xc0\x38\x73\xe1\x29\xc8\xb5\x95\x74\x15\x9f\x26\x5f\x9d\xbe\xf5\xcf\x93\x5b\x6f\x87\xdc\xae\xc5\x77\xfc\x18\x74\xa7\x5d\xa4\x5b\x4e\x9a\x8d\x7e\x60\xe7\xee\xd8\x75\x1a\xe8\x73\x41\x38\x35\xef\x07\xad\xf3\x49\x85\xe7\xfb\x1f\x81\x00\x6b\x40\xc8\x3c\xad\x24\x95\x5c\x4e\x49\x2a\x3e\xb2\xaa\xb2\xff\xbe\x6a\x81\xd6\x9c\x0a\x34\xaa\x0f\x81\xab\x47\x9f\x2c\xf6\x80\x51\x31\x3c\xd5\x05\xe3\x4b\x78\x84\xc3\x97\xe3\x5b\xd9\x92\x19\xb1\x05\x22\x25\xac\x24\x8b\x3d\xfa\x61\x56\xd3\xdd\xfa\x87\x73\x61\xb9\x7b\x99\x1c\xe6\x86\x73\x4a\x80\x55\x02\xca\x7f\xfb\x1c\xf9\x9c\xc3\xe7\x73\xe0\x9c\x03\x8e\xab\x91\xf3\x68\xd4\xb2\x51\x39\xf7\x62\xfd\x49\xf0\xc2\x14\xf0\x9e\xd4\x2f\x95\xc1\xd8\x4f\xff\x8b\x8b\x20\x27\xfb\xfd\x32\xc9\x05\xaa\xab\xf1\x55\xa5\x3e\x5f\xa9\x2f\x3f\x33\x7f\x38\x97\x1a\x35\x2a\x95\xd3\x7e\xf1\xcc\x55\x2b\xe1\x27\x63\xd6\x37\x35\xad\x1f\x43\x1a\x16\xd1\x7e\x61\xaf\x0e\x71\x5f\x21\x23\xaa\x46\x13\xb4\xdd\x26\xc1\xc2\xb7\xe3\x92\x31\x0d\xc7\x2a\x11\x54\x22\x85\x6d\x04\x41\x4d\x91\x15\x94\xd8\x44\xbc\x05\x83\x3a\x31\xd0\x8c\x28\xc3\x21\x14\xd3\xe4\x47\x23\xd0\x01\x67\x24\x11\x47\x72\x22\x2e\x71\x4f\xc7\x23\xf9\x41\x91\x78\x3c\x82\x5f\x88\x80\x4e\xee\x2e\x57\xdd\xcc\x8d\xd3\xc8\x87\x3f\x38\x49\x7e\xfe\xa8\xcc\x7c\xa0\x7a\x74\x5f\x3d\x0d\x62\x3f\xd8\xf5\xe5\x89\x25\xb0\x36\x1e\xd9\x69\xdb\xf9\x11\xf9\xe9\x43\xff\x24\xcb\xaf\x78\x5e\x0d\xdd\x65\xdb\xf9\x11\xd4\x1e\xfd\x07\xdc\x71\xc5\xe9\x48\x1c\xff\xa6\x2d\x91\x68\x4b\x4c\x99\x32\x29\x1e\x8e\xc4\xbf\x73\xf4\x51\xf2\xde\xc9\x1e\xf7\xe2\x47\xff\x0a\xbb\xc2\xf1\xc9\x93\x1f\x22\x3f\xfd\x78\x27\x18\xce\xc6\x23\xf4\x0a\x6a\x3f\xde\x49\xfe\x79\x36\x8e\x10\x8f\x8c\x17\x11\xfb\x8f\xc2\xb7\xf5\xa2\x4a\xb4\x8e\x62\x8a\x33\xb2\x3d\x95\x0c\x87\xe8\x5e\xe9\x6a\x0c\x0e\x51\x15\x9f\x8c\xda\x24\x18\x4a\x4e\x9d\x4e\x25\x69\xbf\xc2\x33\x05\x95\x56\xda\x96\xac\x06\x0d\x20\x8b\x77\x3a\x02\x6c\x26\x4e\xe1\x93\x34\x48\x72\xa7\x43\x72\x0a\xbc\x53\x89\xf1\xe1\x02\xf5\x5a\x2a\x99\x91\x0a\x1d\x0f\x5d\xae\xe8\xdb\x28\xac\x99\x8a\x8b\x92\xdc\xc2\x51\xb5\x21\x13\x60\x9c\x0e\xac\xa1\xf9\x63\xe6\xd4\x9a\x75\x87\x95\x7a\x72\x63\x80\x89\x86\x8a\xca\xc3\xe4\xad\x07\x6c\x25\x96\xa6\x4d\xa3\x06\x88\x8e\xb1\x8b\x77\x85\xcc\x72\x89\x49\xa9\x1f\xe4\x77\x24\xee\x77\x37\x9e\xbf\xef\x37\x07\xef\xc2\x4e\x47\x1d\x79\x7d\x6d\xb4\xa8\xa8\x62\xc8\xd4\x69\x13\xfc\x56\xc1\x65\xb5\xb0\xbe\x21\xcd\x25\xd9\xe9\x51\x86\xbd\x5e\xaf\x0b\xe2\xf1\xe9\x09\x0f\x07\x93\xba\xd1\x75\x45\xfe\x47\xfd\x15\xe9\x35\x93\xe7\xf8\x36\x37\xfb\xcb\x1e\x9c\x30\x66\xe7\xcb\x3c\xe6\xab\xcb\x06\xb7\x8c\x8d\x0e\x9b\xf0\x40\xf3\x58\xc5\x3c\xe7\x58\xf7\x5d\x2b\x57\xdd\xf1\x21\x7b\x1d\x79\xc6\x09\x3f\x1a\x5c\xd7\xbd\x6a\x9c\xae\xdc\x8d\x05\x81\xd9\x3d\x9f\x4c\x37\x70\x30\xf7\xa3\x70\xf7\x3f\x22\x47\x6e\xf4\x98\x5d\x63\x4a\xc6\xcd\xcf\xa6\xc9\x7d\x65\xad\xb7\x7e\xff\xd8\xc3\x80\x2b\x06\xb4\xdb\x6b\x53\x46\x2e\x10\x4a\xfa\x44\x96\xc5\xa2\x18\xf1\x79\x24\x57\xf5\xde\xa1\xc5\x6b\x03\x45\x45\xd8\xf0\x36\x16\xcc\xa9\x11\xf7\x8e\x0f\x05\xb3\x45\x4b\x6c\x45\xa1\x4f\xa6\x67\x16\x6e\xf1\x8c\x0c\xb4\x6c\xb6\xc0\xdb\x4b\xc7\x2d\xcc\x3f\x67\xe3\xad\xdb\xae\xba\x75\xe1\xf0\xf9\x23\x56\x90\x36\x4b\xcb\x9c\xd9\xd9\x03\xa4\xfb\x85\xab\xca\xeb\xc1\xd4\xc7\xf7\xa7\xf6\x7f\x1e\x94\xa6\x38\xf1\x08\x12\xfd\x3b\xb3\x70\xa1\xf7\x53\x3b\xba\xe8\xb7\x86\xa4\xa3\x49\x75\xf0\x1a\x53\x82\x25\x82\x19\x6b\x5f\x50\x0e\x60\x59\x62\x83\x25\x99\x16\x9c\x69\x01\xd1\x16\xb4\x31\xb6\x9f\x9a\x1f\xde\xf1\xbd\x53\xcf\xde\x78\xfb\x51\xd3\x19\xae\x39\x51\xdf\x6a\xf0\xa4\x63\x73\xf1\x07\x6f\x9b\x8f\xf6\xf8\xbf\xc9\xb6\xc4\x55\xff\x54\xac\x36\x03\x57\x16\x57\xf1\x16\x1f\x9e\x92\xbf\x2f\xff\x9d\xc9\x9c\xdb\xc6\x57\x05\x02\x55\xbc\x5d\xe6\x2b\x61\x0f\x88\x78\xfe\x54\xce\x65\xe3\xaa\x03\x9d\x5f\x21\x6c\xbd\xff\x87\xbf\x7f\xed\xe5\xff\x39\x71\x28\xdb\xb6\x69\xdd\x80\xe1\x83\x23\xfb\x2e\xf7\x68\x7f\xea\xa7\xaf\x35\xeb\x8a\xec\xb8\xb5\x95\xb5\x98\x74\x4d\xaf\xbe\xfb\xce\xab\xcd\x3a\xb3\x99\x0b\x96\x0c\x64\xcd\x66\x7d\xd3\x4f\x98\x33\x17\x54\xb1\xd5\xd3\xaf\x70\x1d\x5c\x0e\xf9\x51\xa3\x66\xf1\x58\x00\x48\x57\xfa\x31\x3a\xd2\x96\x4e\x19\x87\xcd\xd0\xd3\xd9\xf7\x30\x3b\xa6\x7b\x2e\x98\x73\x94\x5b\xf2\xd0\x2a\xf2\x17\xea\xb0\x9b\xe1\x9d\x3d\x9f\xed\x86\xdc\xee\xcf\xf6\x90\x01\xea\xf5\x21\xb3\x1d\xac\xab\x0e\x51\x07\x73\x0b\xb1\xd2\x38\x7f\x59\x75\xa8\x8b\x02\x7b\x73\x59\xb3\x7d\xf7\x67\x30\xa2\xfb\x96\x3d\x9f\xed\xb6\x9b\x19\x6d\x12\x8f\x0e\xad\x62\x56\x69\x7b\x40\xd8\x7e\x7b\x40\x5a\xa8\x05\x0f\xba\xdc\x3a\x96\xd3\xb0\xaa\x85\x1e\xc0\xea\x46\x88\xf7\x04\x7d\xd3\x55\x34\xd5\x6b\xa8\x43\xc3\x0a\x78\xeb\x97\x8d\x68\x8a\xbd\xae\x37\x5c\x3e\x9f\xeb\x0d\x97\x97\x48\x03\x53\xbb\x87\xf8\x7c\x43\x76\xa4\x06\x3a\x33\x92\xd7\x3d\xc7\xe5\x73\xa6\x25\x9f\x6b\x9e\xcb\x2b\x65\x9c\x78\xf4\xa0\x14\xf9\x2a\x35\x48\xca\x38\x8b\x5b\x5f\x4c\x0d\xda\xba\xb7\xa3\xeb\x9d\x8e\xbd\x7b\x3b\xd8\x01\x1d\x7b\xf1\x53\x6b\xd4\xa7\xa8\x3f\xe4\x42\x6a\x60\x32\x39\x30\x75\x41\x92\x7e\xa7\xfa\xfd\xae\xf7\xbc\xfe\x9e\xd4\xc0\x81\x29\xb2\xc8\xe9\x7c\xb2\x7c\x20\xbe\xaf\xef\xee\xbd\xfd\xb9\x0b\x31\xd2\x53\x2b\xc2\xa0\x17\x82\xea\x7f\xfd\xd7\xf6\x15\xde\x46\x3e\xbc\xed\x73\xc8\x90\xd3\x64\x38\x39\x0d\x19\xd8\x86\x97\x1d\x5b\xdf\x9d\x5d\x7f\xec\xd8\x7a\xa6\x73\xfd\x31\x78\x19\xc7\xba\xef\x64\x51\x37\x82\x06\x7c\xa4\xcf\xff\x98\x5a\x1d\xe4\x5e\x3c\xc6\xd1\x68\x32\x9a\x87\x96\xa0\x2b\xd1\x1a\xb4\x11\x6d\x43\xbb\xd0\xf5\xe8\x56\x74\x00\xdd\x8b\x0e\xa1\xef\xa3\x87\xd0\x31\xf4\x28\x7a\x06\x3d\x87\x5e\x40\x2f\xa1\x33\x1a\xd6\x31\x43\x77\x84\x32\x05\x2d\x68\x90\x57\x0f\x4d\xae\x31\x74\xc3\x2d\xa3\xa1\x1f\x88\x49\xd5\x4b\x2c\xc8\xb6\x60\x5a\x3d\x34\xd8\x09\x91\xe2\xe8\x8a\x01\x80\x20\x84\x21\x98\x8e\x03\xf5\x95\x33\xb6\x18\x2f\x40\x50\x8e\x06\xf9\x10\xa4\x33\x31\x21\x9c\x61\x40\x86\x8c\x18\x84\x34\x97\x80\xa0\x4d\x96\x98\x60\x06\x2c\x90\x48\x09\x92\xcd\xa1\xde\x24\xdb\x32\x36\x19\x6a\x40\xb0\x65\x62\x7c\x34\xcc\xc9\x4e\x3d\x8e\xc6\x6c\x9c\x90\x00\x59\xac\xc1\x4a\x33\x30\x4a\x4c\x8f\x53\x8c\x18\x16\x41\x68\x05\x4a\x47\x67\x04\x39\xad\x43\x1e\xc7\x5b\x8c\xdb\xf1\x12\x13\x74\xb9\xad\x64\x95\x2d\x69\x23\xab\x6d\x1e\x39\xc4\xbe\xe4\x70\x33\x6f\x3b\xdc\x5e\xc7\xab\x10\x7a\x97\x0d\xc9\x1e\x3b\xdc\x68\x4d\x5b\xe1\x66\xbb\x1a\xfa\x53\xb9\x44\x78\x4e\x74\x77\xc7\x60\x37\x39\xf6\x1d\x72\x0c\x96\xd8\xcb\xbb\x67\x02\x7e\xc7\x72\xfa\x39\x93\x15\x1f\x25\x5b\x5e\xc0\xe5\xe4\xf7\xd6\x4a\xfc\x28\xb0\x59\x5b\x40\xea\x26\xbf\x68\x85\x0d\xd6\x81\x64\x32\x8c\xd6\x75\xaf\xe2\x60\x0a\xd9\xc7\x9a\xed\xb0\x3f\x4b\xce\xdc\xf7\xd2\x83\x47\x59\xd0\x3d\x12\xb8\x1b\xca\x7e\xf5\x2b\xf6\xad\x17\x79\x66\x83\x35\x7f\xdb\xfb\xe4\xbf\x20\x03\xa5\xf9\x6b\xf6\xc2\xef\xca\x27\x43\xf4\x4f\xbb\x18\x90\x74\xbf\xe0\x74\x64\x14\xa4\xbb\x3b\x1f\x7c\xf0\xc1\x07\xd9\xe6\x01\x3b\x4a\x7f\x8a\x99\x47\xb6\x8f\xe6\xf0\x76\x67\x31\x4b\xee\xd5\xeb\x1d\xc5\x2c\x79\x54\xa7\x93\x43\x76\x87\xc3\x11\x74\xe9\x8a\x60\x2c\x5b\xec\xd0\xeb\x61\x01\x57\xec\x70\x16\xb3\x30\x0d\x58\x88\x58\x60\xb9\x41\xe7\x0a\x3a\x9d\x4e\x67\xd0\xc5\x17\x91\x7b\x20\x28\x99\xcc\xe4\x34\x5b\xdc\xfd\x16\xcc\x27\xf7\x5b\x19\x1f\xab\x37\x70\xe4\x2e\xfe\x55\x98\xf9\xb2\x0e\x43\xe7\x6b\xaf\x59\xbb\x26\xf1\xdc\x90\xb1\x4b\xc1\x40\xde\xca\x92\x5b\x7c\x90\x26\x0f\xb3\x16\x98\x4f\x4e\xf2\x1c\x6c\x1c\x04\x03\x8f\x7c\xfc\xfc\x49\x1d\x93\x02\x0c\x56\xd3\x49\x30\x19\xc9\xeb\xf7\x41\xc3\x1f\x3e\xd1\x91\xaf\x46\xbe\x8e\x8b\xce\x7d\x5a\x41\x5e\x21\x2f\x41\xc2\x72\x13\xf9\xec\xe3\x4a\xd8\xdb\x85\x57\x71\xe0\x34\x59\x31\x6c\x04\x96\xd4\x92\x53\xf0\xcf\x5f\x91\xdf\x75\x5f\x4f\x7e\x0b\xde\xdf\xfc\xa6\x0d\x96\x1a\x58\xb0\x40\x69\xfe\xde\x09\x8c\xb6\x5e\x42\xf1\xff\x4d\xc8\x8b\x10\xad\xfe\xbd\x8d\x21\x1a\xeb\x6f\x88\xf7\xf4\x4e\xfc\x3b\xe8\x78\x7a\x67\xf7\xdf\x77\x3e\xcd\xbe\xf3\x58\xb6\x9a\xf8\xaa\xb3\x03\xab\x98\x69\x3b\x5f\x84\x45\x17\x06\xed\x7a\xe1\x85\x5d\x91\x27\xe1\xe1\xea\x41\x83\xaa\x89\xa3\x7a\xb0\x26\x6f\x76\xf2\x88\xbb\x16\x19\x28\xb3\x77\x19\x42\xc0\x22\x46\x1d\xb8\x44\x12\x71\x4e\x92\xd5\x8b\x98\x1d\x81\x1d\x45\xb5\x0b\x4e\x89\xf1\x42\x1a\x65\x78\x41\x62\x8e\x90\x1f\x91\xd0\x06\xc7\x5b\xd0\xf1\xce\x04\x58\x30\x7b\x18\xb9\x26\xff\xca\xca\xd9\x2d\xab\x70\x9a\x3c\xb8\x16\xdb\xe0\x8a\x52\x33\xf9\x88\x64\x37\x2c\x66\x7e\xfa\xd2\x89\x3d\x07\xaf\x84\x91\x6f\x3a\xc7\x0d\xe4\x96\x6d\x22\x7e\xf2\xd2\xf4\xa9\xef\xc0\xbc\xb7\x6e\x18\x38\x63\x75\xfe\x25\x72\xcd\xf0\x19\xb0\x03\x37\x74\x35\xc1\x02\xec\x58\x3f\x6b\xf1\x46\xd2\x42\x7e\x69\x76\xc4\x07\x4e\x92\xdf\x82\x51\x57\xdd\xb5\xeb\xd1\x82\x6c\xd0\x21\xf6\x5f\xd4\xf6\x57\x95\xe4\xa2\xc6\xf2\x43\x35\x24\x15\x20\xa6\x83\x71\x39\x9d\x28\x81\xb8\x44\x87\x2b\xd4\x9f\x51\x27\xba\x72\x3a\xa3\x91\xd3\x09\x94\x1d\x4a\x4e\xcb\xc2\xc2\x83\x3b\xb7\xbe\xf6\xd2\xaf\x6f\xbf\xfd\xd7\x2f\xbd\x96\xdb\xc2\x1d\x3c\x07\xf8\xf3\x7b\xee\xf9\x1c\x30\xf9\xeb\xf6\xb7\xef\xdb\xf2\xc8\x2b\xe7\x0e\x1c\x38\xf7\xca\x23\x5b\x96\x6e\x7a\x6c\xc6\x1b\xc7\x8f\x7f\x99\xf9\xf9\xed\x77\x7d\xf2\xd8\xa1\x35\x5b\xde\x5d\xf7\xee\xe1\xe3\x6f\xb0\x1b\xbb\x74\xf5\x33\x6f\xbf\x7d\x66\x3d\xfb\xd5\xb6\x65\xcb\xba\x8e\xd4\x0f\x64\xf2\x63\x6e\xba\x69\x4c\x37\x53\x51\x19\x5e\xb1\x22\xc4\xec\x63\xef\x3c\x38\xa8\x7b\x62\x22\xbe\x68\x39\xa7\x8d\xa3\x0f\xeb\x10\x37\xb3\x77\xbf\xc5\xac\xff\xfd\x3a\xf4\xd7\xae\xfb\x00\x56\xfb\x21\xad\x50\xd9\x12\x00\xee\xa3\x80\x63\xb6\x23\x40\x7f\xc8\x67\x01\xc7\x42\xd5\xbd\xd0\x11\x20\x1f\x7d\xb3\x9b\xdb\xfb\x87\x23\x5d\x91\x23\x7f\xd8\xba\xd4\xf0\xdd\xd5\x8b\xc6\x54\x41\xf9\xf3\x77\x74\xdf\x66\xde\x73\xfc\x30\xfe\xd8\x19\x08\x38\xf3\x61\x35\x22\x16\xd5\xdf\xfc\x1f\xd5\x5f\xf8\x81\xfa\x4b\x26\x52\xf7\x32\xea\x3e\xe0\x08\x04\x8e\x1c\xf9\xc3\x1f\x8e\x5c\xfd\x4a\x3c\x14\x5b\xfd\xdd\xc1\x4f\x7f\x71\x5b\xf7\x1d\x83\xea\x82\xbf\x44\x08\xc5\x10\xba\xd8\xc2\x6b\x7b\x67\x34\x9e\x36\x27\x65\x6a\x0b\x52\xae\xb6\x2a\x54\x8b\x52\xa8\x1e\x35\xa3\x81\x68\x28\x1a\x81\x46\xa3\xf1\x68\x32\x9a\x8e\x66\xa3\x79\x68\x31\x5a\x8e\x56\xa2\xb5\x68\x03\xba\x06\x6d\x43\xbb\xd1\xf5\xe8\x26\x74\x2b\xba\x03\xdd\x8d\x0e\xa3\xf7\x11\xb2\x05\x6d\x7a\x88\xd2\xdf\x54\xd0\x29\x3a\xc3\x29\xf9\xf2\x23\x23\x0b\xfd\x8f\x56\xb8\xf4\x00\x67\x38\x15\xfc\x37\x87\x1a\x9e\x70\x66\xbe\x25\x54\x4e\xa9\xa1\xc2\x37\x1c\xd1\x9e\x11\x16\x05\xbf\x09\xe0\xb4\x66\x8e\x16\xee\xb5\xa7\x03\x5e\xd1\xb0\xfe\x25\x39\x91\xa9\xe6\xc3\x21\x33\xe6\x51\xf7\x57\x79\x1d\x77\xef\x85\xd7\xf0\x1d\xf8\xc1\x0b\xaf\x8d\x8f\xf6\xfc\x6b\xb5\x2c\xb5\x14\x5b\x96\x5a\x02\xf4\xbc\xc4\x32\x76\xa9\x65\xe9\xc6\xa5\x96\xa5\x9b\x0a\xe7\xee\x81\x6b\xc0\xb1\x16\x9c\x6b\xc1\xb1\x86\xfe\x15\xdc\x5d\xcf\x44\xd7\x7e\xef\x72\xff\xbf\x8c\x59\xdb\xfb\xe0\x68\x7e\xef\xf6\x67\x9e\xd9\xbe\xe3\xe9\xa7\xc9\xd9\x58\xd3\x90\xa6\xd8\xaa\x79\x1e\xa6\x78\xf0\x5c\x7f\xa6\x2e\x9c\x19\x37\x36\x53\x56\xea\x0c\x8d\xb0\x30\x01\x26\xa2\x0f\x98\x3d\x52\x91\x3f\x93\x0a\xf2\xe8\xc2\x2d\xe4\x04\x4c\x18\xc8\xdc\xdf\x3d\x9f\x7c\xc8\x95\xbe\xfe\x3a\xf9\x60\xed\xda\xdb\xfb\xfd\x7d\x27\x54\x13\x34\x87\xaa\x43\xea\x61\x0a\x56\x87\x42\xd5\xc1\x9a\x39\xd5\xa1\x6a\xf5\x98\x5d\x13\xaa\x66\xdf\x8d\x5c\xf6\x8f\x1c\x1f\xbb\xf6\x52\x9f\xb5\x63\x23\x97\x3c\xf3\xf6\xb5\x6b\xc3\x4f\xef\xd0\x52\x0b\xd7\x46\xca\xf4\x1c\x88\xce\xda\x44\x6b\xb9\x41\xaa\x2c\xae\xae\x11\xc0\xe8\x70\xba\x78\x49\x6e\x00\x0b\x63\x64\x78\x6c\x90\xab\x7a\xf8\x05\xd6\xea\x10\x77\x13\xc5\x7b\x28\xbf\x6c\x0e\xfb\x4d\x9b\xf3\x0a\x34\xb2\xea\x40\x63\xee\x03\xe7\xee\xbf\xff\x1c\x43\xee\x3f\xf7\xc0\x03\xe7\xe0\x5c\x6b\xd5\x57\xbf\xa8\x6a\x6d\xad\x82\x47\x2b\xb3\xf8\xcb\x6c\x25\x3c\x5a\xd5\x0a\x7b\xd5\xb0\xfb\xd5\x88\xab\x56\xdf\xcf\xd6\x5d\x38\x5d\xd9\xda\x5a\xc9\x0d\x51\x7f\xbf\xfb\xdd\xca\xd6\xd6\xc2\x38\xb4\x54\x87\xd8\xb3\x08\xa1\x19\x08\x01\xd7\x03\x77\x24\xf4\xe9\xe7\xe9\x42\xb3\xd3\x21\xa8\xf3\x48\x75\x14\x81\xfa\x43\x24\x15\x2c\x07\x52\x9a\x92\xa3\xc7\x94\x5d\xbb\x21\xcd\x1d\x00\xf6\xf6\x9f\x7d\x78\xff\xe4\x7b\x36\xaf\x59\xb2\x78\xcd\xc6\xbb\x26\xde\xf3\xa3\x77\x1e\x58\xf0\x8b\xc9\x5c\x89\x4f\x67\x76\x36\x2d\x24\xff\xd8\xb6\xfb\xd3\x3d\xe0\x7d\x7b\xe3\xfb\xf7\xdf\xba\xfb\xba\xc3\x33\x16\xed\xde\x3e\x37\xb0\xd8\xe6\x28\xb6\xfd\xd7\x03\x0d\xcb\x9b\xe3\x3a\x8b\xd3\xdd\xf8\xd8\x9c\x17\x09\x5b\xcf\x9c\x7a\xf3\x95\xfd\xf7\xbd\x9b\x99\xb5\x71\xd7\xee\x8d\xb3\x32\x4f\xdf\x7d\xdf\xb3\xa3\x9a\x59\xbf\xe8\x34\xbb\x52\xd3\x56\x5c\xfd\xc1\x75\x6f\x81\x75\xea\xbe\x87\x8e\xee\x9b\x7a\xcd\xc2\xb9\xb9\x68\xc0\x61\x1f\xe3\x78\xe0\x9d\x68\x65\xd4\x69\x11\xbd\x83\x47\x74\xbd\x10\xf5\x5b\x0a\x63\xd9\x1c\x87\xe8\x5e\x82\x0a\x34\x95\x96\x7a\x85\xc6\x49\xe9\x07\x6a\x2a\xd6\x08\x14\x64\xa4\x19\x28\x2a\x86\xc6\xc7\x51\x38\x8b\x94\x61\x81\xf2\x0a\x04\xe3\x52\x8f\xa8\x6b\x81\x0c\xd3\xb3\xa6\x12\x60\xd5\x69\x38\xdb\xa9\x78\x72\x4a\x52\xd1\x38\x7c\xa9\x23\xff\x3b\xcd\x86\x5c\x33\x25\x3f\x53\xe2\xee\xfa\x03\x08\x9c\x8b\xb9\x4b\x8d\xd2\x8d\x3c\x8a\x14\xc5\x27\xdf\xd4\x96\x4d\xac\x6e\x8b\x91\x15\x80\x3d\xe9\x51\x98\x4b\x9f\xa2\x3a\xf2\xfd\x0d\xcb\x99\x4e\x82\x5c\x51\x66\xb3\xe0\x77\x19\xac\x03\x94\xa4\xa2\x78\xcc\x89\x21\x2c\x93\x51\x92\x8a\xc9\x5e\x2c\x45\x05\xa5\x0f\xd7\x5e\xcd\xb7\x66\x8f\x3f\x51\xab\x6d\x96\x1e\x33\x7a\xca\x80\x26\x83\x14\xcf\xc0\xff\x35\xcf\x1c\x52\x92\xe2\x6d\x4a\x52\xb9\x4d\x4c\x2a\x22\x20\x31\x29\x02\xca\xdf\xf6\x7f\xce\xb5\xb8\x1f\xa2\x6a\x00\xf9\xe5\x7e\x51\x49\x8a\x17\x91\xa8\x3e\x2f\xf4\xbf\xcf\xbb\xc6\xa3\xa1\x8d\xdf\x39\xa4\x47\x45\x74\xaf\x99\x82\x90\xa8\x67\x82\x31\x31\xa8\xc7\xc1\x68\x90\xa1\x03\xfa\xa8\xa6\x32\xa7\xcc\x1e\x19\x50\xf3\xf6\x1e\x5e\x49\xde\x83\xcf\x61\x76\xbe\xed\xfa\x37\xc9\x05\x72\x8e\xc9\xe3\x95\xe4\xf9\xee\x97\xf1\xb1\x37\xc9\x9f\xf0\x4a\x98\x41\xce\x91\x0b\x30\x1d\x72\x66\x6c\xed\xce\xda\x1b\xec\xdd\x59\x2b\x36\x43\xce\x1e\x64\x73\x41\x06\xe5\x17\xe3\xbb\xbb\xbb\x19\x96\xf2\x6d\x74\xff\x37\xbe\x9b\x3a\x20\xb7\x88\x20\x7b\x8d\xad\x1b\x39\x1c\x2c\xb2\xd5\xd8\x31\xf2\x20\x06\x89\x17\x91\xf0\x47\x1e\xa1\x11\xe8\x4e\x74\x08\x21\x2e\x1d\x2f\x06\x21\x46\xa1\xa8\xff\xfd\x4f\x46\xdb\x1c\xfb\xad\x3f\xd1\xfe\x91\x6c\x8c\x92\x6e\x05\x5b\x22\x15\x4c\x05\x9d\x41\x67\xc2\x26\x07\x40\x60\x6c\x7d\xb1\xff\xd3\x2b\xc1\x19\xe5\x52\x6a\x37\x23\x88\x62\x52\xcc\xcd\x98\x38\xd1\x9e\xb6\x4f\x9c\x28\x26\xc5\x6f\xfd\x51\x23\xfd\xbb\xf0\x89\x17\xaa\xfa\xc5\xca\xfe\xcc\xe6\x08\x9c\xcc\x69\x6a\xa0\xdc\xc9\x80\xc3\xf6\x33\xb1\xff\x93\xfe\xed\xeb\x20\x0b\x39\xc8\xe5\x08\x12\x45\xed\x81\xe2\xb7\x1d\xff\x26\x74\x93\x1a\x3a\x61\x82\x28\x4e\xc8\x42\x14\x1a\x3c\xcd\x86\x06\xa8\xc8\xe5\x72\x39\xf2\x7e\x83\xa1\xd9\x43\x7e\x42\x7e\x69\x17\x45\x35\xc2\xbf\x79\x08\xeb\xd1\x20\x37\x7b\xda\x1f\xd7\xc3\xe5\x32\x18\xad\x47\x28\x28\xd6\x00\x88\x16\x80\x02\x09\x64\xa8\xc0\x05\xa9\xd1\x38\xea\x13\xf1\x16\xa6\x11\xe2\x01\x26\x11\x6f\xd1\x69\x1b\xa3\x7b\xdb\x1e\x93\x89\x25\x54\x41\xab\x09\xdb\x8c\xda\x99\xc7\x29\x48\x0b\x50\x20\x57\x49\x48\x08\x01\x06\x67\x3b\x3a\xd4\x82\xc8\x75\x00\xc2\xd8\x30\xa5\x6d\x9e\xe0\x13\xe6\xb5\x4d\x31\x50\x3b\x5d\x23\xc6\x46\xa6\x88\x33\x19\x6d\x76\xd9\x14\xa9\x16\x0d\x26\x63\x91\xd1\x64\x10\xab\x23\x26\xd9\x6e\x33\x9a\xb8\x22\xc6\x48\x63\xc1\xf7\xf6\x6f\xea\x3e\xb0\x69\xbf\xde\x5f\x3d\x3e\x35\xe3\x03\x09\xbf\xfc\x33\xdb\xd0\x48\x49\x65\x60\x45\xd3\x8a\x40\x65\x49\x64\xa8\xed\x67\x2f\x0b\xde\x0f\x26\xb4\x4e\x2f\xb7\x42\x67\x2e\x9b\xcf\xe1\x5c\x36\x87\xe3\x2c\xd6\x89\x18\x8b\x3a\xcc\xda\xf5\x8c\x20\xb0\x41\x9d\x47\xe7\x10\x8a\x58\xd6\x1d\x0e\xb9\xdd\xa1\xb0\x9b\x65\x8b\x04\x87\xce\xa3\x0b\xb2\x82\xc0\xe8\xbb\x1f\xdc\x74\xc3\x0d\x9b\x9a\xd7\x5c\x7f\xd5\x3c\xcf\x47\xd9\x6c\x91\xa3\xb4\xae\xbe\xbc\xe5\x96\xf2\x68\x4b\x4b\xb4\xfc\x96\x96\xf2\xfa\xba\xd2\xf1\x63\x3f\x0d\x6e\x3b\xf4\x9d\x82\xde\x20\xcf\x21\xd4\x8e\x66\xa1\x55\x08\x81\x64\xc6\xb1\x6a\x88\x29\x54\x51\x42\x97\x40\xc3\xfd\x16\xbe\x95\xde\x3d\xe1\x01\x2c\x07\x13\xb1\x70\x48\xc9\x50\x5d\xbb\x5a\xdd\x0b\x8b\x12\x7c\x05\xc8\x69\x39\x00\x10\x4f\x67\x82\x1a\x45\x3a\x5d\x6e\x2f\x85\xf4\xd7\xd6\xd8\x75\xf9\xa2\x21\x3b\x9e\x5b\xfc\xdd\x3f\x5a\x8b\xc6\x8e\x1d\xd6\x71\x55\xd4\x7b\x11\x0d\xed\x5d\x06\x6f\x6f\x77\x5d\xf3\x43\xba\x1d\x2c\x37\xe6\xba\x2b\x2a\xfd\x18\xad\x9d\xfc\x49\x40\xe1\x58\xc5\x95\x0f\x3a\xda\xd6\x88\xde\x85\x6a\xe0\x13\x6b\x77\xde\xf2\x9d\x37\xbe\x7a\x6f\xed\x63\x32\xf9\x49\xd8\x61\xb7\xdd\x56\x53\xb9\xeb\xf4\x69\x2e\x07\xba\xd3\x97\xae\xb9\xc3\xdf\x17\xbf\xb8\xb7\x5d\x30\x7e\x76\x68\xe5\xab\xc3\x96\x8f\xfb\x6c\x87\x37\xd6\xb3\x32\xee\xad\xba\x4a\x49\x2a\xde\xb8\x5f\xca\x55\x05\xe4\x80\x6f\xe9\x1a\x51\xf1\xe4\x3c\xca\xf1\x56\xaf\xe7\x6c\xbe\xeb\xd6\x95\xc5\x25\xc5\xe0\x34\x9d\x26\x5f\x9d\x3e\x7d\xf9\x72\x7b\x81\xdf\x88\xcb\x71\xe7\x50\x0a\x8d\x55\x7b\xc2\xa0\xc3\x8c\x4b\xaa\xb1\x86\xa7\x21\xc9\x12\x2f\x98\x59\x21\xc0\xc6\x5b\x98\x0c\x05\xd6\xa0\x5b\x18\x19\x6d\xad\xaa\xbf\xc5\x49\xaf\x5d\x5e\xa1\xc7\xe0\x72\xd7\xbc\xf5\x0f\x72\xe1\x1f\x6f\x5d\x33\xe8\xea\x8d\xc3\x3c\x95\x2c\x57\xec\x69\xe8\xa8\x2f\xb5\x00\x33\x60\xfe\x8e\x17\xdf\x7b\x71\xc7\xfc\x01\x0c\x58\x4a\xeb\x3b\x1a\x3c\xc5\x1c\x5b\xe9\x19\xb6\xf1\xea\x41\x24\xa7\x78\xb2\xda\x16\xa7\xac\x47\x19\x95\x82\x5c\x6a\x54\x07\xe5\xba\x6a\x5d\xd8\x5c\x5c\xdc\xbc\xb0\xb5\x76\x6c\x3a\x5c\xc4\x15\x7b\x3c\x95\xac\xc1\xeb\x92\xad\xac\xb1\x38\x1c\x70\x38\x02\x91\xe2\x22\xd6\xec\x92\xbd\x06\xb6\xd2\xe3\x29\xe6\x8a\xc2\xe9\xb1\xcc\x58\x92\xf3\x28\x24\xa7\xe9\x23\xd4\x23\x35\x6a\x14\x1c\xd5\x38\xb1\x70\x2f\x67\x8d\x97\x5a\x4f\x05\xcd\x60\x01\x0d\xc3\x32\x16\x8c\xa7\x33\x5e\xd0\xb8\x5c\x44\x59\x02\x87\x10\x8c\x55\x83\xc0\x0b\x46\xa8\x86\x10\x2f\x30\xc1\x02\x46\x24\x96\x5b\x98\x84\xda\xe9\x41\x2d\x67\x60\x99\xfc\xad\xf6\xa4\x3d\x7f\x0b\x67\x85\xd5\x52\x98\x6b\x7b\x81\x0f\x49\xce\x10\xbf\xbf\xce\x8e\x63\x8b\xc9\x77\x56\xea\xc2\x62\x95\x71\xfb\x8f\xf9\x70\x65\x88\xbb\x9a\x4c\x5f\x4c\xce\xb5\x6c\x5f\x39\x2e\x12\x19\xb7\x72\x7b\xcb\x39\x82\x11\xaf\x67\xd8\xfc\x51\xbb\x1d\xcf\xc0\x76\xaf\x13\xdc\xf9\x85\x0e\x8f\xc7\x01\xbf\x5d\x15\x86\xe3\xb7\x1e\xfc\xd8\xe6\xc0\x5c\x19\x99\x80\x4f\x38\x3c\x5e\x27\x19\x70\xf0\xd6\x8f\xbe\xaa\x18\x91\x8d\x44\xb2\x23\x2a\xbe\x52\xc7\x70\xf8\x22\x62\x73\x5c\x37\xdd\x5b\x83\xc0\x81\x04\x5b\xa2\xa7\x56\xf7\x2e\xd4\xf5\xe2\xed\xda\xaa\x01\x53\xf6\x59\xd6\x1e\xb1\x22\xaa\x2f\x62\x73\xe4\xec\xd9\x73\x7d\xa0\x31\x9a\xf3\xc0\xdf\xb6\x17\x19\xf7\x7d\xba\xfb\x18\x94\x9f\xe8\x46\x5a\x8d\x23\xe7\xc9\xcd\x4c\xe7\xc7\xe4\x94\x8b\x74\xf7\x8b\xaa\x99\x13\xb1\xd6\x13\x60\x3f\x78\xdd\xef\xf6\x5b\xc4\xfd\xe4\x0b\xbb\xa6\xcd\x51\xef\xea\xaf\x07\x8d\xa1\x9a\xcb\x38\x21\x29\x1b\x32\x0e\x55\x63\xaa\x00\x96\xa1\x00\x84\x93\xd0\xd2\x86\xac\x5c\xa7\x47\xa1\x2f\x20\x3b\xb6\xce\x3c\xf8\xfe\x17\xef\x1f\x9c\x39\xf3\xe0\xfb\xeb\xce\xdc\x0b\x5b\x49\x17\x5d\xac\x5c\xdc\x93\x34\x72\x9e\xcb\x29\x1e\xa2\x99\x2d\xf1\x64\xfb\xbd\x67\xd6\x69\xb1\xd5\x9b\xb6\xc2\x56\xfa\x98\x0b\xb9\xbe\xbc\xf4\xda\xa2\xb0\xaa\x6c\x6e\xd6\xf6\xce\xd9\x9d\x0e\x24\x38\xff\x4d\x11\xa6\x14\x44\x2d\xce\x62\x8a\x2a\x3f\xe4\x80\x2a\x35\xa8\x24\x11\xf8\x9e\x44\x33\x2d\xb7\x9e\x24\x67\xcf\x6a\x88\x0d\xf4\xb5\x9a\xf3\x2c\x39\x7b\xf2\xd6\xc3\xad\xbc\x68\x1b\xea\xd4\x55\x76\xfe\xa1\xb3\x52\xe7\x6f\xb6\x89\x7c\x6b\xfe\xfb\x7d\x99\x60\x7f\x3c\x9c\xfc\xcf\x43\x6a\x29\xef\xea\x77\x2b\x75\xee\x72\xc1\xb0\x8f\x1f\x02\xe7\xf0\x8e\x93\x56\xaf\x63\xd9\x8e\x1d\xcb\x1c\x5e\xeb\xc9\xae\x8f\xfa\x65\x89\xd6\x07\xda\xd7\x0c\x42\x23\x11\x82\x1e\x83\xf7\x9e\x6c\x08\xd2\x7f\xcc\x9f\x5a\x45\xd2\x48\x15\x02\x51\xb5\x7d\xf7\x64\x8a\x45\x76\x33\x94\xf4\x7c\x8d\xad\xdf\x94\xbf\x3b\xfe\xb6\xa3\xc8\x0a\x25\x67\xd6\x7f\x34\x0d\x5d\xbc\xce\x6c\xcf\xef\xe9\xf7\x6d\xce\x99\xed\x8a\x87\xd0\x2a\x73\xdd\xc5\xfb\x5f\xff\xe6\x0c\x5a\x4f\x80\xed\xe0\x9b\x50\x21\x9b\x07\xb5\x11\xbb\xb9\xab\xa3\xff\xd7\xc2\xbd\x7b\x4b\x97\xa3\xb5\xff\xb7\xbc\xa9\xdf\x2e\x13\x13\x7a\x21\x87\x9d\x97\xac\xb6\xf7\x74\x06\x99\x5e\xa4\xe2\x74\xc9\xa5\x85\xc0\xfd\xe7\x42\x38\x4b\xce\x6e\x4d\x2e\xd4\x7b\x0c\x03\x0c\xa0\x5f\xba\x92\x86\x28\x1e\x28\x51\x03\x77\x2f\x9b\x52\x08\x98\x51\x7f\x3f\xec\xbf\xff\xff\x58\x4a\x6a\x35\x78\xfd\xfe\xd4\x4a\x03\xe8\x2a\x75\x5e\xc3\xda\x55\xd7\xd1\x3a\xdf\x93\xae\xe5\x73\x0a\x01\x57\xd4\x6d\xdd\xfa\xb5\x52\x44\x88\x53\xeb\x08\x4f\xb8\x3c\xaa\x43\x2d\x68\x14\x9a\x40\x35\x33\x12\xe6\xbf\x49\x74\x04\xbf\x45\x88\xa8\x35\x44\x4e\xcb\x12\x82\xb4\x35\xc6\x5b\x99\x38\x1d\x90\x28\xb4\xe3\x05\x9b\x12\xe3\x05\x1b\xc4\x91\x15\x85\x43\x02\x1d\x96\xf0\xa4\x68\xfb\xdf\x0e\xf4\x93\x18\x04\x5d\x26\x6e\x6c\x10\x7b\xeb\xed\x47\x1e\x79\xfb\x2d\x88\x75\xdf\x96\xcb\xe5\x3a\xd7\x2e\xbe\xe7\x9e\xc5\x6b\x69\xcf\x8a\xcf\x5f\xbf\x61\xc3\xf5\x38\x7b\x4a\xcd\xc5\x29\x1a\xc0\xfc\xf9\x20\xf9\xd3\x09\xeb\x25\xa2\xe8\xeb\x02\xe9\x6d\xa8\x12\x9d\x6b\xd7\x3a\x45\xf2\xf3\xfc\x1b\x3b\x61\xc5\xce\x9d\xe4\x76\xf2\xcf\xfa\xc3\xbf\x3e\xf7\x50\xbd\x56\xe4\x24\x07\xac\x65\xec\x58\x0b\xe9\x86\x82\x6c\xa8\x7f\xe8\xdc\xaf\x0f\xd7\xab\xe3\x36\xb8\xc8\x0b\x6a\x7d\x6b\x43\xe3\xd0\x1c\xb4\xe2\x9b\xea\x5c\x00\x04\x1e\x09\x7c\x24\x56\xcd\x64\xb4\xae\x33\xda\x6b\x87\x79\x69\xe5\x94\x0b\x0d\x0a\x92\x74\xa0\x22\xb7\x40\xd4\x21\xc9\x4a\x2a\x89\x32\xd5\xea\x80\x05\xe2\x28\x95\x54\x62\xb4\x12\x07\x80\xbf\xa4\xa6\xb5\xb7\x4a\xc5\xe4\xcb\xa7\x7f\x46\x1e\x1c\xbc\xee\x9d\xdb\xc6\xe9\xf4\x37\xfc\x7a\xcf\xfa\x5f\x4e\xa7\xf5\xa7\x7f\xbc\xc6\xd0\x53\xfb\xa9\x27\x41\xec\xf7\x3e\x64\xbf\xf7\x61\x77\xee\x93\xc3\x0c\x98\xcf\xa4\x3e\xde\x73\x8a\x9c\x67\x3a\x4f\x81\xf0\xc9\x61\x86\x7c\x79\x26\xf5\x31\xdb\xd1\xbf\xae\xcd\xfd\x53\xee\x29\xd2\xed\xf1\x7f\xf8\x22\xbf\xf8\xc1\x4f\x36\xec\xf9\xe2\x0e\x8b\xd6\x06\xb3\xfd\x63\x8d\x9c\xab\x5f\x4b\xec\x66\x72\xc8\xa1\xb8\x2f\x3c\x44\x7f\x8e\x76\xcb\xfe\xc0\xcf\xa0\x35\xba\x71\x3f\x39\xdf\x2d\x80\x70\xea\x68\xb7\xec\x2b\xfe\x19\x79\x29\xba\x71\x3f\x62\x11\x5f\xd0\x6b\x8c\x44\xe3\xd0\x2c\xb4\xe4\xdf\x94\x61\x8c\xff\xff\x13\x4c\x94\x6e\x44\x2b\x4a\x5a\xf7\xe8\x50\x2f\xa3\x58\xd5\xda\xd7\x5b\xe7\xac\x82\xc4\xe7\x2e\x2b\xc2\x12\xf2\xaf\x1f\xfe\xea\xd9\x75\xfb\xbe\xd6\x66\x0f\x9e\xbf\x56\x76\x83\xe9\xd9\x73\xcf\xee\x3f\xf1\x7a\xa1\x55\xa2\x5c\x2e\x97\xcf\x81\x70\x6a\xdd\xc2\x7b\xee\x59\xb8\xee\x14\x53\xaf\x55\x3e\x7a\x79\x69\x3b\x9d\xfb\xa7\xdc\x93\xa4\xdb\x1b\xda\x32\xc6\xf2\xf5\xc6\x6a\x3b\x05\xa1\xef\x3d\x07\x16\x7f\x68\xcb\x3c\xda\x1a\xff\xbb\x50\x0d\x61\xa5\x5a\xfd\xea\x1f\x82\xce\x87\xea\xbb\x7b\xab\x1e\xc9\x3e\x54\x7f\x89\xed\x50\x23\x45\x8e\xef\xdf\x67\x0a\xbd\xc6\x92\xc2\xa5\xbd\x67\xa6\xcf\x62\xf2\x5b\xfb\xd1\xf7\x6f\xd4\xeb\xab\xf5\x1e\xc3\x8d\x63\x2e\xed\x4f\xc7\x1c\xd7\xfc\x8f\xbf\xff\xef\xfb\xd5\x0f\x6e\x34\x78\xf4\xd5\x7a\xfd\x4d\x63\x2f\xed\x5f\xc7\x1c\xd7\xfc\x8f\xbf\xff\x2d\xfd\x2c\xbe\xc8\xd2\x7e\xb6\x9e\xf2\x39\x4a\xc8\xe9\xc0\x2c\x55\xeb\xda\xd3\x99\x54\xdf\x47\x16\x34\x50\x27\x2d\x1b\x3d\xf9\xec\xab\x16\xb8\x90\x1f\x9c\x3b\x0b\xb1\x13\xe4\x83\x63\xbb\x3f\xdd\x67\x54\x25\x0b\x55\x7e\x1e\x9a\xa5\x25\xe2\x0d\x31\x29\xbe\xa1\xe5\x67\x96\x16\x70\xbe\x2f\x37\xcc\x16\x17\x39\xf5\xf1\x43\xe4\x8b\xfd\xa2\x65\xff\xef\xae\x3b\x08\xf6\x13\x56\xed\xb3\x1d\x9e\xa5\xdd\xf3\xba\x28\xbe\xae\x3d\x68\xd6\x61\x1a\xd0\x95\xbb\xb4\x1f\x62\x11\x12\x72\xec\xd6\x9e\xbc\x50\x14\x74\x2d\xd5\xfd\xc4\x25\x8f\xc2\xa1\x48\x61\xb4\x25\xc9\x89\x54\x8f\x12\x34\xd8\x03\x46\xd5\xf3\x6d\x84\x2b\x45\x91\x7c\xa8\xf7\xea\xab\x0c\x86\x53\xe4\xc3\x82\x8c\xff\x96\x34\x82\x72\xca\x60\xa8\xd2\x7b\xf5\x5d\xd9\xbe\x2c\xe1\x2b\xc5\xa4\x48\x3e\xd4\x02\x4e\x69\x52\xf0\x2c\x39\x7b\x02\xca\x7b\xcb\x47\xf3\x3c\xa5\xbd\xa5\xfb\x8f\x5f\xeb\x57\xe9\xb7\x91\x51\x71\x61\x0c\xd9\x0b\x04\x87\xd4\x19\x41\x3c\x80\x7b\x87\x01\xea\x70\x91\xa6\xe4\x2c\x39\x5b\xf8\xf8\x79\xa1\x5f\xe9\xd2\x01\x62\xfe\x5e\x6a\x13\xbe\x40\xed\xa9\x0a\xb5\x24\x7f\xe6\xb2\x77\x22\xc4\xe6\xd8\x1c\x12\x90\x8c\x10\x2a\x0c\x46\x51\x6f\x75\x8e\x07\x80\x45\xe4\x7c\xef\x38\x72\x4f\x5f\x6d\xfd\xe2\xfd\x83\xd0\xaf\xcf\xc4\xa9\x3e\xff\x99\x33\x0f\xa2\x7e\x38\x6c\x91\x7e\x5c\x9b\xb6\x44\x26\xac\x0e\xdf\x33\xd4\x94\xd0\x0f\x61\x67\xc2\xd6\x0b\x1c\xf7\x48\x38\x1e\x0f\x93\x4d\xaf\x06\x7e\x5b\x33\x64\x73\xeb\xda\xbd\x0f\xbe\xf6\x5a\x3e\xa8\xfa\x71\xb9\x78\xf8\xc2\xb1\x70\x1c\x4f\xfc\xfd\xed\x75\x75\xf0\x53\xfd\xa1\xfd\x8f\xfc\x3e\xff\x83\x78\x98\x9b\x12\x8e\xa3\xc2\xbb\x38\x55\xbe\xb5\x23\x64\x4b\xaa\xf3\x02\x56\xa2\xa4\xa3\x21\x25\x66\xe6\x2d\x40\x0d\x19\xed\x99\xbe\x65\x77\xcd\x16\x9c\xa5\x8b\xa6\x14\xd8\x5c\xd3\xda\x56\x33\xa3\x76\x1d\xff\xc9\xe2\xfb\xc1\x7a\x4c\x99\xb0\xfe\xf8\xe2\x21\xd7\xf9\x0d\x11\x63\x40\x2a\x8f\x47\xcd\x7a\x4b\xc5\x0c\xa1\x64\xc9\xb8\xe6\x21\xd3\x66\x64\x33\x73\x5a\x6b\xbd\xa6\x5f\x3e\xf6\x1a\xf9\xbb\xdb\xef\x0e\x48\xd8\x92\x18\x5b\x21\x31\x8f\xac\x78\xf1\xe6\x25\xc9\xdd\xe4\x50\xc7\x33\xc7\xb6\x8f\xce\xd6\xc5\x6e\xab\xb8\xa2\x62\xc2\x88\x38\x67\xb8\xaf\x78\xd6\x6f\x61\x46\x60\xe0\x92\x89\xfb\xc7\xb7\x0c\xba\xd0\xd2\x3a\x31\x3e\x65\xc9\xba\xa5\x35\x3f\x78\x89\xe4\x5f\xad\x9c\x30\xa0\x42\xef\x9b\xc1\x58\x26\x2c\xbf\xb2\x67\x5d\x7a\x33\x8f\xb8\xeb\x50\x05\x6a\x41\xe3\x11\x42\x1a\x32\x09\xb5\x3d\xa7\xf3\xec\x8c\x46\x47\x26\x51\x6b\x44\xa0\x19\xa2\x38\x43\x52\x22\xce\xf4\xc7\xb9\x15\x32\x92\xbd\x07\x86\x2c\x1c\x8a\x71\x22\x35\x3e\x62\xde\xf4\x3c\xcc\x61\x9b\xf5\xaa\x9a\xfa\xdd\xf3\x6f\x69\x1f\x0e\xcc\x30\x97\x8f\x77\x09\xa2\x45\xa7\x8b\x0f\xe5\x42\x43\xea\xe6\x16\x19\x2c\xab\xb6\x7d\x7e\x74\xc1\x82\xa3\x9f\x93\xcf\x8f\x2e\xd8\x38\xf6\xcb\xfb\x43\x10\x07\xf9\x8d\x8d\x1b\xdf\x20\x9f\xdf\xfd\xa3\x63\x64\xee\xde\x15\x1b\xdf\xc0\xf1\x69\x7a\xce\x10\xac\x88\xa5\x5a\xaa\xf6\xaf\x5a\x3e\x55\x37\x73\xb0\xc4\x98\x9c\x8e\xbd\x82\x73\x84\x41\xd0\x8d\xc8\xa6\x06\x08\x64\x6c\xe1\x21\x0b\x8e\x7e\xbe\xed\xcc\xe1\xcf\x47\x2f\xe1\x16\xa9\x0f\x21\x6f\x93\xcf\xdf\xd8\x38\xe7\x3a\xb8\xe3\xf1\x9f\xdf\x0d\xf2\x1b\x94\xd7\xa5\x80\x3f\xa6\xe1\x05\x89\x74\x8d\x38\x86\x2a\xd4\x19\x4b\x26\x98\x0a\xda\x82\xa9\x60\xef\x56\xa5\x7e\x6e\x7b\x2f\xce\x08\xe5\xa3\xa1\x47\x8e\x45\xdd\x48\x3d\xf8\x92\xba\x71\x75\x75\xe3\x2e\xb8\xfa\x5d\x68\x7f\x77\x9d\x47\x02\xd2\x8e\x1c\x05\xa5\xb9\x8b\x06\xb0\x25\x3d\x2e\xac\xc5\xcc\x97\x90\x1c\xe4\x30\xea\xfb\xed\xd5\x3b\x52\x2c\xee\x0a\x34\x06\x21\x54\xa2\x58\xd3\x25\x92\x15\x0a\x43\xd8\x7e\x56\x24\x3d\xfd\x40\xb0\xc7\x7a\x84\x12\x9c\x3b\x7b\x16\x93\xb8\x44\xcf\x0c\x26\x11\x97\x29\x33\xde\x5c\xf2\xf2\xa7\x9f\x42\xcb\xa7\x38\x0b\x1d\x26\x51\x34\x91\x43\xa2\xa9\xd3\x24\x92\x43\xea\x05\x74\xd0\x8b\x7c\x49\x7b\x12\xd0\x90\xc5\xdd\x07\x36\xed\x17\x9c\x25\xe9\xb6\x85\xcd\xa2\x63\xec\x9d\x8f\xdf\x39\xd6\x21\xee\x9a\xfc\xab\x64\x3b\xce\x15\x00\xfe\xc9\x03\x5f\xbf\x5b\x7b\x6e\xbe\x33\xd9\xfe\xa7\xf8\x0d\x9b\x52\x0b\xd7\x2d\x98\x3b\xb8\xd4\xd6\xdc\xdc\xdc\x6c\xeb\x68\x4f\xf6\xd8\x44\x0b\xff\xa2\xf9\x4b\xa0\x29\xfd\xf2\xa7\xd6\x44\x0b\x68\x68\x19\x1a\x16\x60\x2a\xd9\x4a\x9b\x58\x2b\x50\x5a\x3e\x8d\x9c\x4f\xad\xaf\x9c\x40\xe1\x16\xfa\x67\x54\x2a\xa1\xd9\xa4\x83\xaf\xbe\x7c\xfe\xf0\xbc\x5e\xbf\x57\x6f\x32\xeb\xcf\x9f\xd7\x9b\x4d\xfa\xbd\x7a\xd5\x71\x99\x4f\xde\xf9\xc3\x68\x74\xa2\x53\xbe\x24\xc3\xf7\xc0\xc8\x7b\x1c\xa2\xcf\xef\xf3\x44\x7b\xf3\x9b\xff\xd5\xb7\x3f\xa4\xcf\xe7\x87\xd1\x74\x2a\x3a\x91\xe9\xcb\xfc\xe6\xcd\x36\xde\x5b\x1d\x4c\x47\xfb\xd9\xc5\xda\x91\x87\xca\x2f\x3a\x54\xd2\xec\xf4\x0b\x9f\xb0\xa7\xea\x05\x7b\x2d\x69\x00\xf1\x9d\x1e\xe5\x22\xba\x80\x2e\x22\xba\x08\x84\xb3\x07\xde\x3b\x70\xe0\x3d\x6e\xca\xa7\x0f\xe4\xb3\x1e\x05\x23\xc5\x43\xb2\xa0\x8a\x79\x8a\x75\x46\x24\x35\xf4\x40\xf6\x81\x4f\x15\x0f\xc9\xf5\x61\xe9\xaa\x72\x4c\xa2\x56\x2e\x4c\xc2\x19\x14\x82\xce\xa0\x5e\xad\xeb\xb1\x60\x2a\xc1\x50\x93\x17\x31\xcc\xa3\xce\x4e\xf2\xa7\x0c\x8c\x20\x0b\xc9\x41\x72\x90\x2c\x84\x11\x19\xf2\xa7\xce\x4e\x40\x30\x18\x36\xc3\x60\x82\x56\xfc\x82\x47\x24\xdb\x99\xeb\xec\xee\x64\xd4\x13\x74\xe6\x11\x83\xba\xb2\xd0\xc7\xab\x8d\x0a\x7d\x4d\x58\x95\xcf\xac\x2a\x9f\x05\x59\xa2\x9f\xaa\x55\xa3\xd5\x8e\x24\xec\x3d\xcc\xa2\xb6\xa0\x8d\x55\xc7\xfd\x5d\x4f\xbe\x6f\xb5\x4a\x5d\xe7\x24\xab\xf5\xfd\x27\xbb\x40\x38\xf5\x17\x4a\xe2\xc4\xa0\xae\x1c\x8f\x9e\xdb\xdd\x9d\xdb\xf1\x0c\xf7\x86\xa5\xb4\xd4\xf2\x06\xf7\xcc\x0e\x26\xb7\xfb\xb9\x0b\x9d\x94\xb3\x09\xde\xc1\x88\xa0\x4b\x79\xa6\xb4\x77\x57\x68\xab\x11\xdf\xfc\x7e\xdc\xef\xfd\xe8\x3f\xa6\xe5\xd7\x1a\x67\x69\x36\x7f\x8e\x21\x1a\xa5\x69\x36\xdf\xf9\x2d\xc9\xd2\xa8\x5e\xe1\x65\x35\x59\xf9\xfe\x17\x3d\xba\x9a\x1b\x04\xc4\xad\xa7\xfc\x2b\x3e\x8a\x79\x63\xa3\x1d\x44\x81\xce\x3b\x11\x97\x41\x92\xf5\xd8\xe6\xe0\x43\xb1\xa8\xda\x57\xeb\x41\xf3\xc4\x93\xdd\x2e\x9b\x95\xd4\x38\xfd\x0e\xd1\x1c\x80\x8b\x4c\x16\x4b\xf9\x2f\xd8\xe5\xbe\x01\x32\x19\x86\xdd\xf9\x8b\x95\x64\x33\x0c\xb1\x85\xcd\x45\xd8\xcf\xb2\x33\xbb\x96\xbb\xc3\xba\xcf\x0d\x35\x32\x7b\xb5\xc3\x67\xb9\x88\x98\xc5\xdd\xf7\x83\x01\xb7\x75\xfd\xda\x5d\x6c\xfa\x88\xf9\x2d\xd3\xfd\xe2\x30\xbc\x19\x5b\x7c\x3c\xf9\x12\x5f\x82\xaf\x6e\xb9\x1c\x5f\x3d\x68\xbb\x1c\x53\xfd\x02\xba\x0c\x49\x9d\x3d\xa6\x59\xbf\xb9\xd0\xa4\x8b\xbc\xee\xfb\xdc\xc5\xc2\x3e\xe5\x1a\x34\x04\x8d\x46\xdd\xc0\x83\x1d\xbc\x10\x85\x38\x34\xc1\x30\x18\x0f\x73\x60\x05\x6c\x80\x27\xe0\x65\x38\x0b\x9f\x03\xc1\x26\x84\x38\x33\x50\x4c\xb5\x74\x26\x2d\x71\x01\xd0\x98\x98\x63\x0a\x9f\xa1\x6e\x4a\x6a\xc6\x6b\x71\x52\x49\x35\x0e\x24\x42\x42\x01\x5c\x27\x56\x50\x67\x26\x95\x4c\x35\x08\x2d\x38\x00\x20\x09\x92\x53\xd2\x9e\xc8\x46\x29\x49\x75\x26\x9d\x51\xd4\xc9\x45\xe1\x37\xa9\xcd\x6f\xe5\x54\xa1\xdb\x4b\x67\x5a\xb0\x24\x27\xd4\xae\xae\x05\x32\x4a\x4c\x89\x25\x33\xd5\x85\xfb\xd2\x92\xec\x08\x30\xb2\xa4\x3e\x42\xa0\x18\x4b\xd5\x6c\x2c\x02\x92\x2c\x65\x12\x2d\x4c\x2b\xb4\x80\xac\x2d\xa9\x82\xe0\xe4\x05\x5e\x08\x80\xac\x46\x4a\xb4\x40\x80\x86\x50\x14\xd4\xb0\x43\x48\x6b\xef\x74\x4a\xea\xaf\x20\xc9\x69\x70\xa8\xbf\x6a\xce\xd4\x49\x92\xc6\xa2\x18\xe3\x85\x50\x4c\x92\xe3\x99\xb4\xc2\x51\x43\x0b\x85\x72\x67\xc9\x4a\x3a\x53\xab\xc4\xcc\xea\x4c\x33\x9d\xe1\x2d\x90\xe2\x65\x5a\x4e\x01\xc8\xa8\x09\x46\x05\xfe\x84\x54\x92\x51\x84\x14\x2f\x69\xfe\x0a\xd7\x02\x4a\x2c\xc5\x87\x35\x1a\x93\x28\x4f\x19\xae\x5b\x20\xc3\x0b\x92\x20\xb1\x72\x3a\x92\x51\x32\xc9\x16\x68\x06\x27\x7d\x33\xc5\x0c\x8c\x99\x75\x61\x3e\x66\x66\x04\x3e\xcc\xc7\x34\x1f\x75\xc2\x2f\x31\xe9\x94\x5a\x54\x66\x90\xb5\xcf\x43\x0d\x76\xd5\xbb\x1c\xbc\x53\xa2\x70\x53\x61\x5e\x96\x64\x96\x52\xd4\xf3\xf4\x9e\xb0\x33\x1e\x55\xb3\x25\xa4\x53\x1a\x5c\x9e\x92\xa2\x8f\xe2\xd2\x1a\x36\xac\x43\x4b\x26\x7c\xa2\x53\xec\xee\x14\x86\x09\x5e\x59\xe2\x92\x82\x22\xba\x53\x80\x27\x7a\x25\xa9\xde\x34\x35\x54\x35\x72\xcf\x80\xd2\x9a\x0b\x6b\x4c\x53\x34\x67\x35\x7e\x1d\xca\xc2\xde\x50\x5a\x49\xfa\xb8\x55\x63\xc7\xad\x5a\x75\xee\x8a\xbf\x6d\xf1\xae\xbc\x76\xfd\x78\xfc\xa5\x4e\x14\x60\x66\x2e\x3d\x60\x9a\x94\x1f\x9f\xff\xb1\x3c\xb5\x76\xca\x73\x80\x39\x51\xc7\xbb\xcd\x5e\x41\x6f\xf4\xf9\x03\x26\xd9\x17\xf6\xd8\x1d\x46\x21\x35\xcd\xa8\xd7\x5b\xc6\xe0\x90\xe2\xe3\x4c\xd5\x66\x06\x1b\xca\x0c\x16\x8b\x3c\x04\x5a\x56\xfb\x4a\x9c\x3a\xeb\x48\xb9\x81\x61\x30\x2b\x70\xde\xda\x01\xf1\xd2\xcd\x35\xcd\x8b\x6e\xbd\xde\x51\x9e\x0c\xb6\x14\xe1\x89\x90\x9a\xdf\x34\x39\x02\x9c\xc0\x62\x0c\x4c\x83\x3c\xc2\x2e\x38\x4b\x7c\x2b\x9b\x86\xb9\xcc\x36\x63\xb9\x1e\x58\x6b\xa5\x89\xf3\x29\x21\x3c\xd6\xac\xd7\x15\x4d\x4b\x19\x04\x70\xd8\x3d\x61\x9f\x6c\x0e\x7a\xbc\x46\x83\xce\x67\x92\xc9\x3f\xf4\x13\x02\xac\xd7\xe7\x28\x19\x13\x76\x9b\x06\x07\x4c\x1c\x53\x97\xb0\x8c\x0c\x98\xcb\x8d\x4e\xc9\x1a\x38\xff\x42\x60\x82\x3e\x28\xfa\xbc\xa5\xfe\x21\x26\x77\x38\x6a\x49\x64\x58\xfd\xb3\xe6\x46\x31\x52\x55\xed\x71\x33\x67\x75\x36\x86\x31\xd9\x4a\x2b\xc1\x45\xce\xfd\xfe\xc8\x91\xdf\x1f\x49\x2f\x5d\x06\x82\xc1\xbf\xbd\x58\xcf\x72\xe4\x4b\x1d\xc3\xe2\xf7\x30\xcb\xf3\xc6\xd0\x75\xe4\x2e\x6b\x59\xbd\xc5\xce\x30\x06\x6e\xe8\xcb\x4c\x74\x17\xc8\x47\x8e\x83\xf3\x60\x90\x01\x6c\x1b\x64\xf1\xd4\x25\x8a\x39\x56\x30\x60\x5e\x2f\x14\xe9\xac\x3a\x91\x5d\x56\xcf\x16\x05\xac\x3e\x9e\x79\xc2\x85\xd3\x35\x95\x45\x3a\x9b\xbe\xc1\x0f\xe3\x19\xdb\x90\x58\xd9\xa6\x69\x5c\x78\x47\x3a\x31\xc5\x24\xb3\x3f\x7a\x65\xfe\xe1\x79\xbc\x8c\x8b\xf5\x45\x95\x06\x11\x30\x23\x4e\xc6\x0e\xbc\x90\x9c\x68\x1f\xa7\xd3\x0d\xcc\xbe\xf3\x0e\x00\x7b\x88\x75\x99\x45\x60\x2c\x96\x72\xb3\xbe\x18\x5b\x8b\xde\x7c\xe2\x27\xb8\x83\x9b\xb6\xb1\x5c\x19\x6a\x63\x0c\x53\x12\xe9\x1d\xfb\xac\x51\x41\xef\x16\xa5\x41\x1c\x9b\x70\xf6\x73\x4f\xf3\x0e\xd4\x9b\xc2\xc1\xea\x2b\x39\x6e\x72\xa8\x9f\x9b\x1d\x64\xd1\x55\x79\xc3\xf1\x0a\x59\x1c\xb9\x74\xe9\xed\x4b\x3f\xbc\xb2\x6a\x70\xd3\x08\xbe\xf4\xca\x0b\x1f\x19\x8b\x65\x5b\xdd\xea\x36\x8c\x6b\xca\xdd\xee\xb2\x01\x98\x39\x38\x51\xb2\x17\x1b\x0d\x7a\xc9\xef\xd7\x1b\xcc\x0e\xb3\x5f\x57\xe4\xe3\x04\xd6\x32\x02\x1b\x86\xa6\x94\x8a\x96\xa0\x2d\x6a\x70\xdb\x39\x3b\xc3\x02\x07\x46\xbe\x94\xe1\x59\x1c\x2c\x8e\xac\xaa\xdb\x9a\xb2\xca\x7e\xf0\x58\x5d\x66\xc6\x8c\xab\x7d\xac\xbd\xba\x21\x35\xc2\xa4\xb3\x98\x74\x66\x66\x2b\xf9\xd7\xa4\x1b\x0c\x22\x63\x76\x59\xcc\x66\x9f\xcb\x96\xdc\x5a\xbf\x2a\x5c\x12\xc4\x06\x5c\xc6\x15\x01\x07\x1c\x63\xe7\xec\x2e\x9d\x62\x2b\x69\x2d\x2d\x4b\xb5\xe9\x71\xad\xcb\xc2\x0a\x9c\xaf\x48\xef\xb3\xda\x4d\x7a\x83\x2f\xe0\xd4\x31\x8f\xfa\xdd\x25\x0b\xa2\xd7\xf8\x45\x76\x7d\xf9\xee\x06\x53\x89\xd9\x9c\x5d\x68\xb5\x18\x60\xed\x16\x66\xc8\x75\xb5\x0b\x4a\xdc\x7e\x3b\x2b\xfa\xaf\xd9\x57\x6c\x6e\xd8\x5d\xce\x5b\xac\x0b\x06\xda\x06\x6e\x59\xc9\x9a\x45\x98\xbe\x9c\x89\x29\x37\x89\x76\x41\xe7\xd8\xd9\x84\xf1\xce\xc3\x57\xaf\x3b\x7c\x78\xdd\xd5\x44\xc1\x18\xbc\xeb\x05\x33\x18\x99\xe1\x83\x9f\x65\xa7\x4d\x13\x81\x71\x4c\x9a\xc0\x59\xf0\x6b\x8d\x1b\xdc\x3a\xde\x6e\xbd\xdd\x8f\x77\xc8\xa6\x9b\x7e\x92\xa9\x7d\xf9\x6e\x93\x13\x33\x0c\x00\x60\x01\x66\x94\x2b\x31\x5e\x67\xaa\xe5\x74\x3c\xc7\x60\x0c\xa0\x77\xd8\x44\x23\x83\xc1\x56\xdf\xaa\xd7\x55\x9b\x4c\xfe\x08\xcf\xe2\xfc\x2e\xb3\x75\xd8\x7a\x63\x51\x6a\x79\x3a\x35\x0e\xe3\xa6\x8f\x5a\xeb\x56\x37\x27\xf7\xce\x63\xf5\xc0\x63\xbb\x28\x1b\x4d\xc6\x89\x83\x43\x6f\x39\x9d\xb7\xd5\x86\x25\x86\x71\xfa\x9a\x72\x50\x93\x1e\xa4\x04\x61\x74\xbb\xce\xa6\x77\x39\xec\x2c\xc7\xea\x5e\x98\xd3\x78\x63\x7a\x79\xaa\xc8\xb8\xa1\xcd\x6a\xae\x6d\xc2\x78\x9c\x36\x66\x18\xac\x07\xee\x79\x3a\x32\x6f\xa4\x7c\xde\x97\x58\x29\x40\x80\x2b\x82\x44\x3c\xc0\xaa\x22\x49\x68\xe1\xaa\x19\x81\x8f\x54\x0b\xdc\xdf\x3b\xf6\xce\x9b\xb7\x37\xbf\x76\xde\xde\x8e\x8e\xbd\xf9\x19\xf5\xcb\xf7\x5c\xff\xa3\xb7\x20\x06\xf5\xbf\xd8\xf7\xf3\x3b\xe7\x55\x31\xe5\xc3\x56\x6c\x19\x7d\x6a\xa1\xff\xff\x31\xf7\xde\xf1\x51\x5c\xf7\xfa\xf0\xf9\x9e\x69\x5b\x67\xfb\x8e\xb4\x92\x56\x5b\x67\x55\x57\xd2\x56\x09\x49\xab\x45\x88\x2a\x01\xa2\x0b\x84\x84\x68\x46\x88\x26\x9a\xc1\x18\x9b\x35\xe0\x0a\xd8\x18\x03\xae\x18\xc5\xd8\x71\xb7\x83\x6f\xe2\x5e\x64\x27\x71\x8b\x4d\xec\xc4\x3d\x2e\x72\x8d\x49\x62\xc7\x71\x62\xc7\x46\xda\xd1\xfb\x99\x33\x2b\x21\x04\xb9\xc9\xef\xde\xfb\xc7\xab\x8f\x76\x4f\x99\x33\x33\x67\xce\x9e\x39\xf5\xf9\x3e\xcf\xa2\xb6\x8e\x09\xa2\x6e\xfa\x4d\xd2\xf1\xbb\xa4\xf7\xdf\x7f\x6a\xe7\xc6\x86\x06\x77\x59\xb1\x7c\xd2\x62\x72\xea\x62\xa6\xa2\x66\x7e\x63\xb8\x40\xe0\x19\x8d\xe0\x2a\xab\x9c\x34\x63\xf9\xea\xb1\x47\x16\x84\x37\x2d\x3a\x6f\x46\x73\x4d\x38\xdf\x48\x61\xa3\x33\x12\x9e\x52\x3d\x3b\x3e\x63\x08\x73\x90\xd1\xe5\xca\x27\xac\xa0\x8d\x68\x05\xda\x42\x94\xb9\x46\x2a\x15\x89\xbe\x51\x34\xcd\x96\x90\xcd\x64\x2d\x06\x4f\xd4\x14\x09\xd3\x64\xb2\xc8\x0d\x2f\x27\x04\x21\x1a\xc1\x2e\xda\x3c\x64\xf3\x6c\xb1\x29\x98\x3b\x85\xe4\x3a\x0f\x86\x43\xa2\x8b\x1d\xcd\x85\x48\x17\x4a\x0f\x48\xaf\x7c\xb4\x7b\xf7\x47\x10\x81\x99\x10\x91\x7d\xe9\x35\x67\x33\x3d\x6f\x30\x1a\x5d\x46\x23\x5c\xd8\xd5\xe8\xcd\x23\x53\xfc\x3c\xef\x0c\xc5\xb2\x79\xc8\x54\xfa\x77\x24\x7a\xd7\xe3\xbb\x88\x7b\x42\x7a\xff\x04\xd5\x21\x3a\x06\x52\x43\x84\xea\x4c\xef\xee\x8f\xa4\x57\x46\xdd\xed\x57\xe7\xe0\x85\x4e\x4f\x33\x4a\xf2\xbd\xfa\x8c\xc9\xc6\xa8\x77\x8c\x69\x03\x6f\x36\xf3\x1b\x4c\x63\xbc\x51\xaa\x71\x94\x61\xb6\xf4\xb5\xb2\x9c\xd6\xb6\x6b\x57\x9b\xe2\x3b\x70\xe2\xc4\xc0\xd5\x98\xb0\x22\x12\xaa\xde\x21\x7b\x32\xb5\xc2\x2b\x2f\x90\x71\x9d\x3c\x17\x0b\x9b\xbc\xa3\x8a\x22\x4a\x46\x53\xb6\xd1\xd0\xaa\x90\x9d\x4b\xfd\x98\xe2\x50\x2a\x65\xe6\x7f\x20\x20\x78\x8e\xd8\xc8\x37\x46\xdb\xeb\x7f\xe8\xad\x6f\x6f\xaf\xe7\x92\xf5\xed\xd1\x46\x1a\xc9\x63\xd9\x74\x2f\xa4\x94\x05\xfd\x01\xc5\xf6\xbd\x47\x4a\x45\x1b\x7b\xe4\x64\x14\x49\xdc\xd3\x88\x46\xe5\x29\x67\x38\x4f\x99\xf5\x88\x51\x59\xb0\x65\xc3\x59\x59\x35\x01\x62\x10\x26\xf6\x41\x23\x73\x31\x2a\x8b\x14\x4a\x23\xdc\xdb\x18\x1d\x95\x85\x74\xc7\x99\x79\x04\xd7\xff\x45\x7e\xa8\x14\x8d\xfe\xff\x94\x1f\x8c\x98\xff\xbb\xf2\xc1\xc3\xf9\x11\x50\xf1\xe9\x95\xa3\xff\x24\x27\xaa\xff\x3e\x17\xd4\x7f\x74\x7f\x40\x68\x90\xa1\x2f\x64\x11\xca\x25\x2c\x9e\xac\xd7\x6d\x19\x92\xca\x24\x8a\x26\x62\x46\xf9\x5d\xa0\xd7\x10\xf9\x8f\x9d\x2f\x69\xac\x59\xc7\xb3\xcb\xb5\xcf\x48\x2f\x5a\x1c\x3a\x5d\x41\x81\x4e\x97\x63\x86\xaf\x9c\x81\x02\xc9\x97\x5d\xae\x6d\xd4\x58\xb3\xe0\x57\xd2\x8b\x16\xc6\x54\xc4\xf4\x15\x99\x18\x8b\xc2\x5f\x4d\xa5\x58\x44\x34\x0a\x5c\x36\x53\xd8\xe6\x35\x59\xdd\x61\x9b\xd7\x15\x60\xdd\xde\x68\xd8\x15\x35\x79\xa3\x61\x53\x84\xf8\x85\x98\x3b\x6c\xa3\x92\x52\x6f\x2a\x05\xc9\x64\x52\xfa\xa6\xbb\x5b\xfa\x26\x99\x84\x64\x2a\x25\xf5\x26\x93\x60\xec\xee\x06\x63\x92\x49\xf5\x49\x1d\xa9\x74\x5f\x5f\xea\xc0\x81\x54\x1f\x76\xa5\xa0\x87\x78\x95\xe2\x1c\xb2\x6b\x18\x52\x7b\x28\x26\xac\x17\xd5\x64\xe5\xd4\x6b\x0a\x9b\x08\x10\xc9\x24\xbf\xa9\x6e\x9b\x3b\xea\x66\x6c\x44\x84\x39\x6a\x8a\x7a\x6d\xfe\x68\xd8\x44\x10\xad\xa6\xb0\xa2\xa7\x9b\x31\x58\x97\x5d\x62\xbf\x6e\x53\xa1\x54\x4a\x4a\xf5\x23\x29\x95\x4a\x41\x8a\x41\x90\x1a\x44\xa9\x1f\x51\x2a\xc5\xa2\x54\xaa\x5f\x71\x25\x04\xa9\x81\x94\x94\xa2\x52\x69\x84\x53\xe9\x14\x8d\x06\x91\x94\xa2\x53\x03\x99\xb3\x68\x04\x43\xfa\xb8\xa7\x90\xfc\x4d\x67\x34\x1f\x64\x5f\x1a\x91\x1a\x94\xc2\x72\x2d\x92\x4f\xc8\x70\xe7\x20\xb5\xfc\x4c\xf9\xc3\x6b\x44\xe1\x8c\x86\xc5\xbc\x33\x9f\xea\xcc\x67\x33\x79\x87\x9e\x10\x46\x3e\xa5\xd7\x16\xf6\xbb\x4f\x3f\x2a\x44\x89\x3a\xb5\x5c\xcf\xa2\xee\xcc\xa5\xc2\x36\x77\x54\x4d\x9e\x55\x7e\x92\x94\x94\x52\xb2\x4e\xa5\x40\x76\xc8\x53\xa7\x51\xea\x54\x2a\x95\x62\x52\xa9\x54\x7f\x8a\x4a\xa5\x52\x03\x8a\x2e\x85\x1c\x31\x74\x0a\x45\x68\x8c\x95\x73\xe5\x0f\x26\xae\x94\x11\x07\x26\xdf\xfd\x99\xa2\xc0\x64\xfb\x23\xad\x1c\x41\x78\xe8\x9e\x72\x01\x9c\x9e\x0b\x9a\x50\x16\x79\x6b\x47\xbc\x1d\x26\xb7\x87\x15\xdc\x72\xad\xe5\x68\x34\xd0\x51\x50\x59\x59\xc0\x24\x0b\x2a\x89\x44\x31\x5c\x64\x08\x3d\x1a\x9a\x09\x2e\xa9\x43\x89\xad\x2c\x18\xe8\xa8\x9c\x34\x33\xf4\x68\xc8\x80\x46\xda\xda\xb0\x44\x57\x19\x81\xd7\x16\xab\x83\x98\x7f\x68\xf5\x43\x6e\xbb\x0d\x70\xda\x1c\x8a\x58\x0a\x6d\xfd\x21\x4f\xf7\x98\x4e\xfa\x16\x5c\xfd\x88\x4a\x55\xc2\x8b\x05\xb9\x8f\xe6\x76\x14\x0c\xa0\xa1\x5b\x03\xfa\x41\xa3\x7b\x4c\x77\x84\x4a\xf5\x23\x70\x15\x54\x52\x3d\x03\xa8\xa0\x23\xf7\xd1\xdc\x82\x4c\x26\x86\x34\x9d\x86\xf8\xb3\xb2\x50\x00\x8d\x45\xb3\xd1\x32\x62\x75\x39\x4c\x48\x18\x1b\xf6\xdb\xc3\x76\x86\x88\xa5\x78\x3d\x01\x9b\x13\xf2\xc1\xe5\x8f\xb2\x1c\x2b\x46\xc8\x7c\x31\x08\x65\x20\x12\x4b\xe6\x38\x31\x5d\x8b\x2a\x8a\xdb\x1e\xd1\xeb\x36\xb9\xcf\x36\x75\xe2\x8e\xe6\x0b\x2a\xcd\x8d\x37\x6a\x54\x82\xde\x29\x50\xba\x3d\x7b\x28\x2d\x08\xfd\x2b\x3f\x6b\x1a\xb7\xfa\x82\xe8\x15\x85\x45\x30\x09\xbf\xbc\x74\xf9\xea\x6d\xdb\x56\x2f\x5f\x5a\xde\x99\x9b\xbb\xe3\x91\x25\x25\x25\x4b\x1e\xd9\xb1\x9c\x9a\x3c\xb7\xbe\x2a\x39\xb3\x9e\x32\x33\x52\x15\xfc\x79\xca\xa2\x33\x29\x8a\x22\x11\x3f\x83\xf7\x62\xe6\xc1\x90\x87\x86\x4b\x80\xee\x83\x88\xf4\xca\x98\xc9\xd5\xdd\x06\x23\x80\x7b\x7d\x84\x53\x2d\x79\x7c\x89\x8a\x0b\x77\xeb\x0c\x18\xb3\x05\xcd\x1d\x9b\x3a\x9a\x0b\x58\xfa\xea\xd8\x78\x86\x52\x8d\x0b\xc6\xeb\x29\x90\xf0\x64\x2a\x76\x06\xff\x10\x33\x5c\x4e\x0c\xd2\x22\x07\x0a\xa2\x84\x5c\x03\x78\xb0\xda\x7d\x11\x31\x60\x8a\x21\xa2\x7c\x16\x24\xd2\x9d\x2e\x1a\x88\x21\x37\xb1\x50\x35\xd3\x61\x77\x28\x81\xcf\xb2\x9a\x5a\xd0\xb5\x7b\x37\x5e\xb2\xbb\xab\x0b\x5a\x8f\x48\xdf\x1e\xdd\xf2\xee\x91\xb6\x23\xc0\x43\x02\x78\x9c\xbb\xee\xd1\xbf\xef\x92\x7e\xff\x33\xe9\xdd\x07\x1f\x80\xa2\x07\xa0\xf4\x92\xef\x1e\x5d\x07\x2d\x23\x9f\x12\x02\xf8\x17\x85\x4f\xfd\xe9\xa9\xa7\xfe\xf4\x54\x61\x7a\x4a\x21\xbc\x2e\x3d\x27\x7d\x7b\xa4\xed\xc8\xbb\x5b\x8e\x02\x7f\xe4\x88\xd4\xb4\xe7\xbb\x9f\x76\xdc\x26\xbd\xf5\xf8\xbd\xd2\x1f\xee\x59\x7e\xf7\x5f\x28\xf6\x4c\x1e\x2c\xea\x8c\xb1\x5a\x35\x42\xcc\xa8\xb6\xfd\x2c\xfe\x68\x9b\xf7\xb4\x01\x9b\x9d\xf0\xf6\x9d\xe6\xa6\x4a\x59\xf4\xfd\xbd\x7a\x8b\x45\x4f\x27\xf5\x96\x54\x7b\x7d\x3f\x69\xea\xe9\x64\x7d\xbb\x94\x1a\x3e\xd6\xd3\x33\x14\xd9\x21\x27\xcb\x44\xd3\x53\x4f\x27\x6e\x87\x44\x4f\xcf\xd0\x91\x54\x26\x2e\xa3\xf7\xaa\x92\xdb\x6e\x8c\x18\x14\x45\xb5\x68\x0e\x5a\x83\x90\x1a\xdc\x6a\x70\x03\x0f\x9c\x69\x78\xfd\x77\x78\xd5\x37\x08\x81\xe1\x00\x61\x19\x1f\x4a\x42\x0f\xad\x69\x29\x3b\x2e\x04\x58\x18\x0b\x09\x4e\x9a\x19\x1d\xc1\xf6\x4a\x29\x0a\xfd\x28\xb7\xa0\x08\x7e\xc1\xd7\x15\x60\x32\x0a\x3b\x45\x7a\x37\xdc\x51\x50\xc7\x4b\x36\xd2\x83\xfd\xd9\xb6\x64\xfb\x12\x1b\xfc\x99\x6c\x1f\xd6\xd5\x97\x95\xd5\x97\xd1\xfb\xdb\xae\xbe\x6e\xf7\x75\x57\xb7\x4d\xd8\xb0\xac\x93\x36\x37\x99\xe9\xce\x65\x1b\x26\xf4\xa3\x73\xc5\xd2\xc9\x74\x12\xf7\xa6\x93\x54\xaa\xa0\x8e\x3f\xf5\xdd\x69\x7a\x22\x46\xcb\xd7\x15\x10\x5f\xd5\xc4\x89\x55\xc4\x63\x2c\x93\x2f\x3f\xb0\x78\xf2\xa6\x7a\xb7\xbb\x7e\xd3\x64\xed\xde\xd7\x1f\x7e\x9c\x73\xbb\xb9\xc7\x1f\x7e\x7d\xaf\xf6\x9c\xb1\x23\xd7\x38\x4b\xd1\x54\x84\xc0\x88\x39\xbb\x79\x08\xf2\x70\x5a\x82\xcb\x68\x8e\x8b\xd8\x34\x62\x13\x9f\x1c\x86\x04\x15\x75\x5b\x9d\x58\x70\x82\x95\xe5\x78\xca\xe6\x8e\x04\x71\x20\x08\x91\x18\x93\x7a\xb3\xa7\xe7\x4d\xa5\x4c\x48\x96\x3b\x86\xc3\x8c\x62\x4f\x79\xd5\xd4\xfd\x1b\x27\x0c\xa0\x09\x1b\xf7\x4f\xb5\x08\x82\x45\x0e\xd1\x43\x21\x26\x25\xf5\x4b\xeb\xba\xba\xa4\x75\x52\xff\x08\x76\x26\x06\xae\xed\xea\x82\x6b\x81\x19\xc1\xd2\x54\x93\xb7\xe3\xa1\x6f\x77\xef\xfe\xf6\xa1\x1d\x79\x9c\xbb\xc0\xcd\x9d\x19\x1c\xb9\xb6\x5a\x4a\xfa\xa3\xff\xb7\x27\x2c\x06\xb7\x55\x70\xc7\x4c\xf2\x63\x79\x79\xca\xf6\x6f\x1f\xab\x6f\x00\xa9\xa9\xaf\xd5\x0d\xeb\xf7\x36\x7d\xd1\xb4\x77\x7d\xc3\x7f\xfe\x24\xf5\x89\xda\x53\xe3\x76\xfe\xf5\xf8\x8e\xfc\xfc\x1d\xc7\xff\xba\xf3\xcc\x75\x61\x39\xef\xd5\xff\xb3\xbc\x53\x41\x08\x78\x79\xe0\xfe\x93\xac\xcf\xa1\xe6\xce\xa9\x8a\x3d\xb2\xe2\x8b\x15\x8f\xc4\xfe\xf3\x9c\x9f\x78\xe8\xa1\x01\x7e\xdf\x4b\x45\x45\x2f\xed\x3b\xb3\x3e\x4d\xfc\xdf\xd5\x27\x96\x73\x8b\xff\xb3\xca\x74\xe5\x2a\xfc\xe4\xaa\x2b\xff\x77\x15\x29\x7c\xed\xb5\x61\xa5\x0a\x8d\xf8\x1d\x0c\xa8\x0a\x4d\x46\x88\x19\xd5\xa4\xc4\x13\xaa\x78\x50\x15\x70\xf3\x2a\xce\xa9\x12\x2c\xa3\x8e\x32\x7d\xa7\x73\xbe\x84\x72\x78\xc6\x54\x34\x47\xe6\x97\x14\x17\x97\xcc\x8f\x34\x57\x8c\xf1\x38\x28\x7a\xe0\x5c\xb1\x4b\x4e\x9f\x95\x34\xf3\xc4\x32\x39\xc5\x9b\x93\xf1\xce\xb9\x2d\xc9\xc6\xd2\xb1\xce\xdc\x5c\xe7\xd8\xd2\xc6\x64\xcb\xdc\xce\xf8\xb9\xe2\x58\x74\xfa\xa4\x11\xd8\x09\x84\xc6\xa2\x2e\x84\x88\x55\xb2\x37\x23\xa9\x6e\x0a\x28\x9e\x3c\xb0\x0a\x60\xb7\x29\x6d\x7c\x2d\x44\xe2\x96\x58\x86\x70\x4c\x49\x1b\x18\xe9\x0d\x84\x88\x16\x38\xf9\xca\x03\x2b\x21\xe9\x52\x3a\x05\x50\x1e\x3b\x24\x28\x66\x7c\x14\x8a\x36\xba\x92\xe5\xc1\x7a\xf2\xe5\x85\x58\x40\x74\xe0\x94\x43\xd4\xac\xd6\x90\xd8\x50\x80\x57\x07\xeb\x5d\x63\x43\x8c\x6a\xf6\xd8\xaa\xfa\xea\x4e\x4f\x8e\x6b\xd9\x5e\xfd\x1a\xb6\xbb\x39\x9d\x9a\xbd\x5a\x7a\xa5\x69\xdf\x52\x2d\xc3\xee\x59\x14\x09\x4e\xa2\x53\x8d\xd1\x54\x5b\xf9\xb8\xfa\xa0\x34\xcb\x79\x9f\xec\xf6\x95\x79\xa5\x77\x02\x75\xf2\xb4\x37\xbb\xd0\x07\x3f\xf7\x15\x7e\x2f\x47\xbb\x2e\x2a\x18\xab\xc2\xf5\xc1\xd4\xb6\xf0\x54\x06\x52\x21\x4f\xac\x82\xbb\x66\xd9\xf7\xe1\x2a\xa9\x29\xab\xac\xb9\x7b\xf3\x6c\x28\x98\x7c\x5e\xdf\xd2\x7d\xb0\x68\xa7\x6d\xfc\xe9\xbd\x9e\x0e\x16\xa1\x0a\xd4\x82\x10\x92\x8b\xc5\xab\xd8\x82\x64\xc3\x10\x09\x23\x90\x92\x89\x5b\x62\xd1\x8c\x95\x88\x77\x84\x3b\x5c\x16\x31\x79\x8a\xc4\x51\xca\x90\x2c\x00\x19\xab\x3f\x65\x9b\x22\x46\xdd\xba\xb0\xde\x55\xbf\xb0\xfe\x26\x31\x19\x6d\x74\x40\x4a\x4c\xe2\x9f\x79\x62\x5c\x13\x53\xaf\xc4\xbb\x7e\x7e\xc5\xc6\x7c\x8b\xb0\x74\xdf\xca\xeb\x55\x4d\xfc\x45\x33\xd2\xcd\x35\x6b\x7c\x52\x2a\x7c\xb8\x6b\x5a\x68\xdf\x52\xc1\x92\xcf\xa4\xea\x83\xe9\x6e\x6c\x0c\xd6\xd7\x07\xd3\xdf\x0c\xa2\x57\xc3\x8d\xd1\x62\x8f\x84\xc2\x25\x1e\x38\xe4\xca\x81\x6f\x89\xdd\xe8\x37\x43\x09\xf0\xfe\xe0\x73\x13\x6b\xe9\x7d\x4b\x4d\xec\xde\x95\x12\x5f\x50\x2c\xad\x9e\xde\x19\x2f\xc3\xa8\x61\x6e\xd7\x61\x0f\x3c\xb4\x74\x1f\x5d\x3b\xcc\xc1\x47\xf6\x7a\x45\x14\x45\x53\xd0\x12\xb4\x0b\x21\x46\x9e\x5f\x29\xcb\x2c\x71\xb7\x02\x19\x1f\x66\x9a\x66\x32\x70\x25\x8e\x61\x29\x79\xfc\xa9\xd0\x17\xf9\x83\x10\x25\x55\x86\x63\x08\x47\xaf\x1c\x95\x00\xca\x3f\x44\x4b\xcd\xd8\x32\x9c\x23\xf1\x68\xa4\x0e\x28\x72\x54\xb1\xf1\xe7\x32\xda\x15\xb5\x10\x26\xa6\x91\x36\xf9\xd2\x74\xc5\xf1\x63\x75\x42\x62\x32\x23\xf5\x77\x1d\x3e\xdc\xb5\xbe\x64\x4a\xeb\xe1\xae\x60\x29\xde\x04\xd7\x76\x1d\x5e\x3d\x57\xba\x7f\xe1\x35\x37\x1f\x73\xfa\xea\x83\x0e\x2b\xcc\xac\xa8\x83\xa4\xec\x93\x3e\xcc\x35\x17\x1b\x8d\x75\x21\xab\x19\x3a\x9c\xbe\x2f\xd3\xe7\x67\xd9\xa3\x8d\xa5\x7e\xcc\xa7\xc9\x8c\x14\x0b\x27\x83\xeb\x56\xcf\x9c\x0c\xb3\x8a\x63\x8d\x51\xe9\x95\x2b\x7c\x72\xb9\x57\x45\xc6\x07\x45\xe9\xe5\xd4\xbe\x8a\x28\xe3\xdc\x3c\x5e\xd4\x1c\x7e\xe3\xb0\x29\x77\x57\x73\xd7\x61\xd3\x5f\x0f\x77\xa5\x97\xb5\xec\xb1\xcd\x11\xf0\x0b\x13\xa7\xf0\x71\x77\xb0\x5e\x73\x93\xa6\x39\x34\x88\x82\xf5\x9a\xdd\x7a\x95\xc3\xe6\xb7\x87\x92\xea\x1e\x3e\x4e\x99\x7e\x50\x35\x46\x0b\xea\xf9\x17\x93\x8d\x5d\x8d\x5d\xcf\xd7\x15\x9f\x37\x80\x2c\x73\xb4\xe3\x4b\xf0\x2d\xd1\xc6\x8b\xdd\x15\xd2\x3b\xc1\xc4\x84\xe0\x6b\xaf\x4d\x28\x51\xcd\x88\x16\x4d\x32\xed\x1b\xae\x7b\x64\x3e\xe8\x23\xfc\x78\x21\xbb\xfc\x1a\x0e\x4b\x60\xfa\x87\x07\x2b\xf2\x8f\x10\x50\xfc\x60\x8a\x04\x40\x19\x72\x59\x9d\x20\xbf\x6a\x6e\x9b\x3b\xc3\x9a\x14\x76\x13\x54\x45\x66\x56\x20\xbf\xd6\x72\xbd\x15\x18\x27\x64\xbc\x31\x7a\x47\xed\x5a\x1f\xae\x39\xbf\xbb\x59\x4a\x35\x77\x4b\x9f\xa4\x3f\x6c\xee\xbe\x7b\x0b\xdc\x5e\x94\x9e\xb9\xec\x3a\xd5\xd8\xee\x66\xb6\xb7\x2d\xfd\xcb\x40\x72\x60\xac\x43\xa4\x8c\x26\x4d\x38\x9f\x4a\x0e\xf4\x3a\x44\x4a\x35\xa9\x14\xa7\x5a\x0b\x2a\x99\xa4\x26\x94\x2f\x8d\xaf\x6f\x17\x1d\xb8\xc2\xa8\x87\xda\xac\x3c\xd1\x01\x29\x87\xc8\xa2\xca\x8a\x81\xbf\x1f\x7d\x51\x3a\xd2\xdc\xdd\xdd\x7c\xfc\x9a\xee\x66\xd7\x96\xbb\x53\x97\x2f\x9d\xbe\xc2\xd5\xdc\xfd\x63\x2f\x2c\x3d\xb2\x83\xd2\x47\x44\x87\xcb\x1b\xb4\xe6\x8b\x2e\xd1\x51\xc2\x97\x8c\xa9\x2c\x30\x18\x7a\xf3\xfc\xed\xf5\x2e\x87\xc8\xdd\xaa\x0f\xe6\xfc\x9a\x2c\x60\x29\x9c\x78\xf2\xd8\x2e\x84\x36\xc9\x6d\x96\x18\xa0\xc4\x68\x84\x7c\xc5\x32\x14\x6f\x39\x90\xa1\x7a\x03\x9b\x95\xa3\x32\x94\x24\x2c\x07\xac\x97\xf2\xb0\x1c\xe5\xa5\x86\xc8\xa4\x2c\x23\xbc\x4e\x90\x3f\x61\x77\x28\x0e\x8a\xa1\x1e\xc7\x44\x23\x0e\x88\x0f\x91\x9d\x50\x5e\x8b\xec\x85\xdf\x4c\xbd\xc0\xb2\x5c\xcf\x6c\xe2\xb6\xb7\x99\x76\xcd\x9b\xb5\xd3\x3a\x6b\x85\x75\xe7\xac\xf9\x97\xf2\x0b\xb7\x72\x17\x6a\xe2\xf6\x72\x4f\x45\xf6\xca\xc3\x55\x21\x89\x69\x98\x53\x21\xd6\xaa\x6f\xdf\x71\xad\xba\x56\x2c\x4f\x52\xbb\x1d\x4b\xd5\x09\xb1\xac\x9e\xda\xc4\xd1\xaa\x65\xaa\x88\x1b\x3f\x5c\xe4\x81\xfe\xca\xc6\x48\xb1\x47\x7a\x35\x39\x89\xa2\x93\x65\x81\x5a\xf5\x26\xc7\x61\xaa\x6e\x10\x2d\x6a\x84\x6b\xab\xc2\xa5\x76\xf8\x20\xc7\xd9\x76\x85\x66\xce\xea\x15\x33\xa4\xdb\xe1\xbe\x19\x2b\x36\xce\xd3\x5c\xd5\x96\xe5\x95\x10\x57\x6c\x74\x6a\xb5\x07\x57\x26\xba\x45\x69\x77\x98\x4d\x95\x8b\xe9\xb9\x78\x81\x58\x5e\x5f\x66\xd0\xa7\x3f\x80\x1b\xfc\xe1\xfa\x20\xaf\x93\x3c\xb9\x9b\x9c\xd2\x3a\x57\xa1\x03\x2e\x2c\x1e\x17\x99\xec\xf8\xe2\x53\x1a\x74\x50\xa0\x37\x6b\xcb\x1a\xca\x45\xc9\x89\xbb\x79\xbe\xbc\x21\xb3\xe7\x2b\x97\x6b\x98\x30\x90\x2c\x25\x4c\x5c\xe7\x6e\xe9\x6a\x15\x91\x71\x6f\x74\x44\x3f\xa0\x78\x4c\x11\x31\x40\x9a\xbb\x30\xe9\x09\x4e\x77\x04\x67\x37\x7c\x96\x8c\xca\x94\xfc\xc1\xa9\x68\xe3\xf5\x85\xf5\x91\x29\x4a\xe3\x77\xc2\xee\x65\x16\x66\x55\x36\x57\x2a\x5d\xc4\x94\x58\xb4\xd1\x35\x25\xb6\xea\x90\x5d\xb3\x74\x4a\x59\x64\xfd\xc4\x9c\xbc\xf6\x9d\xb9\x0b\x8d\x9d\xf5\xe9\x90\xd2\x10\x1e\x5a\x39\xb1\xfa\xf0\x9f\x5c\xe0\x92\xff\x99\x54\x63\x54\x42\x52\xea\xe5\x58\x53\x84\x34\x82\x39\x36\xe8\xee\x58\xf2\x6e\x61\x4d\x65\x41\xad\xdc\x0f\x24\x17\xc4\xa7\x37\x46\x3b\xf0\x98\xf8\xf4\xd4\xcd\xab\xde\xc7\xe3\x6d\xf3\xb8\xcb\xdb\xdf\xdd\xb4\x46\xda\x9f\x9c\xa1\x34\x83\x2b\xaf\xf7\x62\x6f\xd7\xe1\x53\x19\x3b\x34\xe5\x33\x62\x5f\xdc\x4f\x54\x6c\x17\xa3\x9d\x44\x69\x65\xe4\x23\x46\x4d\x54\x06\xc2\x94\x0f\x0a\xd7\xaa\x49\x0e\x70\x1e\xd6\x40\xa8\x08\x49\x25\x12\x3c\x3c\x95\x61\xb0\x54\xba\x8e\x88\x08\x56\xc1\x62\x8b\xc7\xaa\x21\x3e\xd4\x7d\x28\x55\x13\x32\x25\x4e\x11\xd6\x97\x80\x32\xaf\x8e\x91\x89\x95\x01\xe4\xa9\x17\xa3\xaa\x29\xdb\x27\xcc\xb1\xed\x69\x49\x2f\xeb\x3a\xfc\x57\xd3\xe1\xae\xe6\x5d\xb9\xa6\xc3\x6f\x1c\xce\xb1\x8d\xdf\xfc\xb8\x3b\xce\x4f\x99\x18\x0f\x35\x6b\x6e\xd2\xd4\x3f\x68\xf7\xdb\x1c\x2a\xfd\x6e\x4d\x7d\xd0\x1d\xe7\x7b\xd4\xc9\xfe\xb1\xaa\x1f\xce\x2b\xae\x7b\xbe\xab\xb1\xab\x31\xf9\x22\x5f\x5f\x10\x6d\xa4\x73\x4b\xc6\x6b\xe7\x58\xf6\x99\x26\x15\x45\x67\xa8\x4a\x26\xbc\xf6\x5a\x70\x42\x22\x28\xbd\x53\xe1\xbe\xb8\x31\x4a\x5d\x20\xd4\x1d\x3b\xde\xbe\x50\xba\x7f\xee\xea\xc3\x5d\x70\x2d\xde\x54\x1a\xec\x3a\xdc\x3a\xa5\x64\xbd\xdc\x10\x4b\xfd\xcc\xe4\xb8\xcf\x79\xec\xe6\xba\x0a\x98\x69\x75\x04\xeb\x2f\x37\x1a\x8b\xcd\xb9\xd2\x87\xb2\xdf\xe7\x84\x0e\xb3\x35\x54\x07\x2b\xec\x59\xe9\xf3\xc7\xaf\x0b\x9e\xc4\x82\xdc\xee\xa6\x53\x98\xf7\x97\x36\x9e\xfa\x73\xac\x18\x66\x4d\x9e\xd9\x2a\xbd\x2c\x06\xc7\x47\xaa\xe4\x5e\xcf\x77\x85\xf4\x4a\xb4\x71\x98\x07\x86\xfb\x39\x8d\x50\x36\x19\x3f\xda\xce\x8d\xdc\x09\xd9\x19\x8b\x9d\x23\xb1\x01\x2d\xc8\x6e\x40\x0b\x44\xd8\x27\x20\x46\x2d\x0a\x71\xa8\x85\x6c\x4a\x5b\x14\x4e\x98\xf9\x16\xbd\xf4\x96\x59\x7f\xb9\xde\x22\xbd\xad\xb7\x98\x79\x2a\x5b\x6f\xa1\xf9\xa9\xa0\xd6\xe8\x2f\xd3\x99\x21\xf8\x94\xca\xb6\xd5\xaa\x7e\xb2\x14\xcc\xba\xcb\xf5\x1a\xf5\x34\x30\xeb\xae\xb6\xaa\xdf\xd7\x68\x28\x3d\xfd\x81\xda\xba\x4f\x6f\xa6\xfa\x36\xeb\xcd\x03\x6f\x90\x93\x4b\xcc\xfa\xcd\xbc\xd9\xa2\x19\xa8\xd3\x6b\x35\x26\x1d\x6e\x92\xe6\x59\x2c\x70\x6f\xfa\x21\x9d\x49\xa3\xe1\xa9\x67\x75\x26\x4b\xfa\x87\xac\x1c\xce\xab\xc6\x2a\x8b\x69\x08\xc3\xa0\xcc\xa9\xd5\xa8\x08\x8d\x51\xec\x10\x02\x8a\x8c\x43\x4c\xc8\x3c\x4b\x80\xf2\x9e\x49\x75\xa3\x80\xc9\x38\x3b\x1e\xb5\x49\x82\x46\x6c\x90\xf8\x5c\xb4\x9d\x36\xd7\xb8\x67\x5f\x78\x5b\xfd\xa4\xc8\xab\x2a\xb5\xca\x72\x83\x55\xf5\xdc\xcd\x66\x5e\xc1\x41\x8b\xa9\xc4\x9c\x25\x73\x26\xb3\xa5\xd2\x1b\xd2\x37\xbf\xde\xbc\xf9\xd7\x60\x84\x12\x30\x12\xdf\x7b\xe7\xd8\x85\xa0\xc6\xb6\xb8\xcd\xd2\x1f\xa7\xbc\x2b\xed\x31\xf1\x46\x13\xac\x91\x6e\x93\xaf\x43\xf5\xf2\xe6\xac\xfc\x5b\xce\x5b\x78\x9d\x4f\x43\xc5\x36\xff\x5a\xfa\x66\xd4\xf5\xa4\xc6\x51\x17\xba\xfa\xea\x6f\x46\x3e\x77\x29\x6a\x55\x94\xae\x20\x14\x8f\x95\x81\x18\x10\x0d\xc0\x33\xc3\xf4\x46\xf9\x60\x8f\xc7\xea\x20\x16\x08\xd2\xca\x58\xc1\xfd\x9f\x25\x3b\xab\x68\x46\xed\x1f\xe1\xb6\x1b\x3b\x79\x6d\x29\x6b\x36\x6a\x69\xda\x60\xcd\x71\xfa\x2d\x4d\x4b\x3a\xa6\xf8\xc7\x1b\x8d\x5a\x83\x51\x15\xd5\x1b\x28\x63\x49\x74\x66\xe9\xc1\x5f\x3d\x47\xe9\x6e\xec\xe4\x35\xa5\x2a\xd3\xbf\x49\x7a\xdd\xaf\x9f\x0b\x9c\x5d\x98\xe9\xdb\xcf\xde\x3c\x82\xb2\x4e\xb3\x79\xa6\x9e\xc6\x7a\x8a\xd6\x19\x78\x1d\xb7\x6c\x6a\xd3\xd2\x5c\x9e\xd7\x02\xd6\x4d\xb3\x5a\x68\x63\x7e\xb6\xf5\xd9\xfd\x07\x9e\x91\x53\xf1\xd4\xbf\x4b\x45\x57\x9c\xa3\xd8\xc1\x76\x8e\xdf\x50\x7e\x8f\x92\x83\x7d\x5c\x2f\xe3\x22\x98\x12\xa4\xa6\x05\x2e\xa0\x86\xb8\x9a\x0a\xc4\x05\x35\x70\xc0\x01\xee\x93\x1b\xba\x74\x07\xee\xb9\xab\x63\x92\xe4\x82\xbe\x67\xa5\x8f\x70\x0f\xee\x49\x77\xdc\xd5\x31\x09\xfa\x24\xd7\xb3\xe0\xee\x90\x52\xb8\x4f\x4a\x49\x29\xf9\x00\x49\x26\x47\xe7\xcb\x89\x32\xc9\xe4\xd3\x3e\xee\x80\x14\x3a\x63\xdd\x48\xbe\x67\x00\x21\xbf\x1a\x38\x81\x53\x83\x10\x0f\xa8\x99\x78\x20\xae\x86\x00\x37\xba\xea\xe2\x57\xc1\x20\x9d\x6c\xe9\xed\x90\x4e\x82\x50\x30\x6f\x87\x34\x86\x2a\x81\xe7\xa5\x31\xd2\xdf\x40\x68\xe9\xed\x00\x41\x3a\x59\x30\x8f\x6a\x3a\xc7\x43\x3e\x0c\x06\x10\x5a\x9e\xe9\x00\x41\x3e\x31\x25\x8d\x91\xea\xe1\x79\x78\x5e\xfa\x9b\x74\xb2\xe5\x99\x0e\xe9\xa4\x74\xb2\xa0\x05\x7e\x3c\x47\xa5\xd4\x20\x34\xf8\xbe\x1a\x31\x3e\xa4\x45\x16\x94\x9b\x51\xd9\x1c\x8f\x66\xa1\x56\x94\x3a\x53\x15\x60\x68\x57\x95\xc9\xc0\xcb\x62\x44\x44\x98\x68\xa5\x90\x54\x72\xab\xef\xcb\xf8\xc2\x0a\xcc\x9e\x07\x42\xc0\x06\xa2\xdb\xc5\x85\x9c\xd8\x16\x49\xe0\x21\x24\xaf\xc5\xcd\x13\x78\x3a\xa6\x49\xfb\xce\x05\x81\xf0\x58\xfa\x70\x94\xc0\x66\xdc\x44\xfc\x1c\xef\x89\x8b\x81\x78\x3c\x20\xc6\xe9\x9d\xf1\x69\xf1\xf8\xb4\x81\xc0\xfa\x9e\xf5\xeb\x7b\xd6\xd3\x97\xac\x6f\x9e\xbe\x61\x7d\xcf\xc0\xf8\x63\x1b\x37\x1d\xbb\xfd\x8b\x63\xf4\xce\x63\x9b\x36\x1e\x3b\xb6\x71\xd3\xc0\x47\xd2\xdf\x9e\xb9\xe8\x8d\xed\xdb\xdf\xb8\xe8\x19\xea\x5e\x49\xfa\x9d\xf4\xac\xb4\xf9\x8d\x1b\x5b\xe7\x1d\x3a\x81\x67\x48\xdf\x4a\x3b\xa5\xbf\x81\x01\x2e\xa6\x61\x47\x49\x42\xbd\xf6\x26\xe9\x87\x9b\x2f\xfd\xb2\xb9\x6c\xa6\x76\x8e\xab\xf9\xe4\xa5\x37\x4b\x3f\xdc\xb4\x56\x9d\x28\x81\x35\x87\xe0\x96\x4f\xfa\xe0\x2a\x9c\xa3\xdc\x3e\x8e\xe5\xbb\xc7\xda\xe5\x7b\xae\x5f\x0f\x24\x0f\xbd\xe4\xc6\xc7\xe0\x8b\x63\xc7\xbe\x38\x26\x15\xc0\xc5\x60\xd8\xfe\xe6\xa9\x37\xb7\xd3\xda\x75\x6b\x5b\x6f\x7a\x63\xf3\xc6\xd7\x6f\x68\x4f\x73\x72\xb4\xf4\x37\xf9\xb6\x34\x1d\xde\x11\xbe\xfe\xf1\x5b\xa4\x1f\x6e\xec\x5e\x5a\x79\xa1\xfd\x02\xff\xd2\xf5\x37\x82\xea\x96\xc7\xaf\x0f\xef\x08\x2f\x5b\xdf\x8d\x28\x74\xde\x20\xa2\x6f\x22\xed\xa2\x05\x35\x21\x44\xc8\x1a\x91\x0b\xd9\xac\xa7\xc1\x39\xe0\x04\x1e\x73\x2c\x27\x64\xc0\xef\x01\x31\x90\x01\x97\xc7\x21\x2e\x06\x82\x94\x82\x43\x72\xd2\xe1\x10\x11\x17\x73\x02\x55\x23\x5d\x21\x7d\x0f\x1a\xd8\x0a\x1a\xe9\xf0\xa3\xbb\x76\x3d\xba\x0b\x4a\xf4\xb4\xbe\xa0\x34\xb0\xf1\xc5\xc9\xa0\x75\x3a\x75\xf9\x73\xf3\xc7\xbd\x28\x7d\x97\x3f\xd7\xa9\xcb\xcf\x07\xed\xa4\xdf\x6c\x08\x94\x16\xe8\x69\xbd\xc6\x57\x9e\x74\x33\xd6\xfa\x49\xdd\x55\xad\x3f\xf5\x8b\xee\x64\xb9\x0f\x6f\x06\xcd\x13\x4f\x82\x46\xfa\xfe\xc9\x27\xe0\xe6\x5d\x6d\x0b\x77\xed\x5a\xd8\x96\xbe\x33\xa7\xd4\x57\xe8\xce\x9e\x6c\x9b\x44\xae\xa2\x77\x3a\x1b\x5e\x94\xfe\xe1\x74\xea\x9d\x73\xe5\xeb\xd9\x26\x67\xbb\x0b\x7d\xa5\x39\x56\x27\x6f\x76\xd0\xbc\xd7\x61\x0f\x67\x67\x3b\xcc\xbc\x73\x04\x7f\x18\x87\x62\x28\x41\xd0\xaa\x43\xbb\xf6\x41\x60\x39\x1e\x7b\xc4\x32\xe2\x63\xed\x82\x5d\xe0\x58\x8e\xb5\xe6\x83\x3d\x54\x07\x76\x41\xfe\x8e\x45\xca\xb0\x3c\xfe\xc5\x46\xd1\xc5\x1a\xed\xae\xb3\x96\x8f\x8f\xb6\xed\x6e\x6b\xdb\x0d\x61\x8d\xaf\x3a\x5f\x23\x6e\xdf\x79\x7e\x4e\x4e\x7e\xb5\x4f\x63\x2f\x18\x37\xeb\x9a\xf0\xd5\x15\x76\xbb\xda\x5e\x6b\x7f\x66\xc3\x54\x7b\xad\x5d\x6d\xb7\x3f\x13\xd9\x37\x7b\x5c\xc1\xc4\xa7\xa5\x7f\x3c\xfd\x34\xe8\xf0\xb6\x91\x54\xa7\x94\x24\x5f\xa9\x2d\xfd\xbd\x35\x8b\xc9\x56\x65\x15\xf8\xcc\xe6\x6c\x26\xcb\x5a\x5a\x5d\x12\xe5\x23\x57\x97\x67\x2e\xb0\xb1\x49\xb9\xe4\xd3\x11\x3e\x5a\x52\x0d\x66\xd0\x3d\x2d\x5f\x0d\xbe\x3c\x93\xdf\x54\x59\x83\x78\x94\x49\x21\xb3\xa2\x5b\x27\x4f\x72\x08\x12\xda\x27\xe2\x8c\x78\xf9\xf0\x88\x5c\x0d\xc3\x43\x51\x36\x6f\xec\x82\x2b\x3e\x97\x9e\x7d\xf0\x67\xd2\xb3\x5f\x5c\xb1\x30\x89\x9f\x2d\xf3\xc2\x41\xff\xf8\x8a\x32\xaf\xf4\x94\xf4\x94\x37\x58\x31\xde\x07\x87\xdc\x4c\xaa\x75\x6c\xfa\xc7\x9f\x49\xbd\x5f\x5c\x7e\xf9\x17\x90\xfc\x19\xe6\x92\x0b\xfb\xdf\x71\xc3\x6e\x6f\xa8\x62\xbc\x5b\x7a\x19\x62\xee\xf1\x15\x61\x8f\xb4\xdd\x9d\xc1\xa8\xdf\xa0\x46\xcc\x0a\xb9\xce\x31\xc0\x22\x8e\x15\xa3\x22\x0a\x04\xb1\x37\x22\x46\xdd\x36\x1e\x0b\x76\x24\xc4\xcc\x71\x11\x07\xc4\x40\x94\xb1\x29\x00\x2e\x02\xaf\x8b\x45\xa2\xa1\x04\x84\x6d\x3c\x70\x94\xdd\x2c\x40\x10\x07\xa2\x8c\xfc\x33\x21\x8e\x79\x4b\x7a\x37\x5b\xfa\x6e\x2c\x44\x67\x4a\x77\xcc\xb5\xb5\x6e\x2a\x01\x3c\x31\x30\x23\x62\x74\xc0\x45\xa5\xf9\xef\xd9\x2d\x6f\xe5\x89\xc7\x30\xd4\x8c\xb3\xb9\x57\xbb\xd6\xd6\x65\x35\x2c\x82\xe4\x9b\xd7\x59\x12\x1b\xdc\x6f\xea\x3f\xe7\xe0\x31\x7e\x62\xb5\x03\x5e\x01\xd8\x93\x48\x7f\xeb\x5e\x81\x1f\xa9\x48\x0f\x5e\x0a\x00\xcf\x52\xd6\x97\x43\x1b\xe7\x32\xa2\x2a\x84\x73\xc7\x78\xab\x07\xf6\x2f\xab\x85\x9b\x8b\x02\xf0\x59\x74\x3c\x0e\x41\x19\x0e\x06\x27\xfc\xb5\xe1\xad\x43\xf1\x0a\xcc\xf9\x58\x80\x0a\x9c\x08\x49\x13\xdc\x69\xc9\x44\xfd\x28\x56\xf0\x10\xa2\x71\x09\xbd\xaf\x3f\xd9\x38\x82\x4f\x5b\x83\xb2\xd0\x06\xb4\x13\x1d\x18\xd1\xe2\xc9\x33\x4f\x9e\xe6\x20\x41\xfb\xad\x5c\x10\x7b\x3d\x36\xab\xc0\x03\x47\x66\x05\xf9\x64\xbb\x35\x81\xa3\x11\x42\x99\x1d\x84\x00\x99\x2f\x19\xe4\x71\x7e\xdc\x89\x89\x70\x4f\x19\x51\xf6\x93\x47\xba\x65\x64\x5e\xc0\x12\xf9\x36\x27\x08\x44\x1c\xa3\x0e\x9c\xa0\x20\x3c\x46\xf6\xd8\x67\xf4\x06\xd4\x2f\xdc\xd9\x0e\xd1\x13\x12\x0d\xd0\xae\xde\x7c\xd9\x9e\x45\x94\x74\x8c\xdb\xba\x7b\x6f\x3b\xbe\xaa\x93\xca\xcd\xa6\xf5\xd5\x53\x3e\xd8\x65\x04\x9e\x61\xc1\x38\x69\xca\x0b\xf7\x43\x96\x45\xcf\xda\x05\xbc\xfe\xd6\xfc\xf1\x1a\x2d\xd3\xc0\xaf\xc1\xee\x1c\x5a\x9f\x6d\xb5\x4e\xed\xdb\x6d\xc0\x7a\x86\x05\xc3\xc4\xba\x57\x1e\x0c\xe8\xb4\xfe\x75\x37\xe6\x57\x6a\xb4\x74\x15\x3f\x67\xc7\x5b\xd2\x3b\xd2\xe3\xd2\x3b\x6f\xed\xd8\xf1\x16\x14\xc0\x04\x28\x78\xeb\xa3\x73\x74\x30\x78\x97\x43\x94\xb3\xe3\x9e\x85\xc7\xab\xd6\x6c\xdf\xd9\xca\xa6\x9f\xe4\xd6\x5e\xb8\xab\xb5\xe6\xa5\x7b\xb0\xd9\xa0\xd7\x78\xba\x8f\xb8\xc6\x69\xb4\x74\x83\x61\x25\xf6\x3b\x69\x7d\x5e\x01\xd5\xf8\xf1\x6e\x03\xa5\x93\x6f\x3b\x69\xdc\x89\xfb\xc1\x6e\xd4\xb1\x16\x9d\xae\xfb\x26\xe7\x38\x8d\x96\xa9\xd7\xaf\xa9\x54\xeb\x93\x8d\x1f\xee\xd4\x61\xf9\x11\xf4\x93\xfe\x48\x6e\xbe\x63\x64\x86\xf0\x25\xff\x6a\x1c\x05\x99\xbe\xd5\x8e\x3c\xa8\x08\x21\x88\x09\x76\xc1\x2f\xd2\x1c\xc4\x7c\x6a\xb0\xd3\x71\x4a\xf4\xe1\xa8\xd1\x6f\x37\x63\x96\x63\xfd\x10\xc3\x01\x5f\xc8\x4e\x1a\x16\xea\xa2\x6f\x7e\xff\xe5\xd6\xb4\xa3\x47\xfa\x47\x58\xfa\x4b\x0a\xd6\xa6\x3f\x80\x19\x93\xc0\x7e\xd3\x17\x6f\x48\x3f\x7d\x81\xfd\xd5\x18\x6a\xd9\x89\x6b\xbe\x90\xfe\x01\x87\x5a\xb4\xcb\xa5\xca\x53\xc7\x8f\x9f\x3a\xce\x22\xbc\xed\xb2\xaf\x03\xea\x3b\x0f\xc0\x5d\x47\xef\x97\x56\xa7\x57\x5e\x73\x30\x4f\xaa\x75\xff\x08\x3b\xde\x07\x6d\xfc\xb0\xf4\x8c\xf4\x41\x7a\xd6\xa5\x3c\x5e\xb7\x0b\xea\xce\x67\x8f\xcb\x27\xc9\xef\x15\x96\xeb\x17\xf3\x12\xd9\x4d\x70\xa1\x80\x88\x1d\x10\xa7\x12\x20\x8f\xc5\xe5\x77\x88\x22\x98\x4f\xcc\x09\x01\xd6\x89\xe3\x09\x2c\x38\x81\xe3\xe9\x00\x0f\x01\x27\x24\x70\x3c\x16\x94\x3d\x42\x0c\x07\x68\x64\xb1\x63\x1e\x68\xea\x72\xe9\x73\x69\xfc\xea\x31\xe6\x09\x37\xac\xd0\x6a\x37\xe8\x8b\xbe\xda\x14\xdb\xc5\x65\x37\x86\xe7\xa8\x0c\xda\x6c\x46\x58\x50\x69\xd8\x63\xb6\x85\x9b\x0b\xc3\xed\x93\xfd\xb5\x55\x6a\xa0\x78\x7b\xa1\xa3\xe6\xee\x8b\xa6\x1c\xef\x39\xb4\x2a\xa7\x58\x35\xae\x74\xde\xb2\x1c\xc3\xb5\x57\x82\x1a\x44\x1a\xcf\xb9\xed\x1d\xe9\xe4\x20\x82\xd2\x1f\x76\xc1\x6c\x18\x0f\xc5\x6d\xd2\x1f\x79\xca\x34\x63\x03\x2e\xfd\x6d\x8d\x4a\x4b\xd3\xc0\xcc\xf0\x72\x42\xb9\xe6\xa9\x71\xc5\x53\x2b\x73\x38\x75\x38\x80\xe9\x31\x3e\xcc\x99\xf5\x2a\x6a\xd1\x0c\x6d\x6d\x71\xfe\xe4\xf3\xa2\xad\xbf\x79\x40\x14\x67\x4d\xbc\x07\x16\xac\x9b\x2a\xad\x92\x7e\xbd\x63\x10\xbd\x7f\xdf\xd2\x51\x3c\xfe\x71\x45\xaf\x91\x26\x10\x57\x27\x08\x76\x3a\x1c\x8a\x13\xc3\x0f\x51\x6e\xf0\x22\xe6\x98\xaf\x1a\xec\x34\x58\x31\xa1\x52\x88\x99\xa3\x11\x1c\x20\xda\x8a\x66\xe6\xcd\x3b\x9e\xbb\x59\xfa\xcb\x79\x8d\xf3\x69\x7a\x7e\xe3\x79\x60\xbd\xf9\xb9\x3b\x2e\x90\x5e\xbd\x3b\x8f\x7f\x50\xfa\xd5\x67\x97\xc9\x75\xe3\x61\xea\x2e\xa8\x80\xdb\x6f\xba\xa2\xf3\xfc\x2b\xcf\xbf\xe9\x85\xe7\x6f\xda\x72\xf9\x96\x55\x97\x5f\xcf\xe4\xae\x3d\xb0\xa3\xed\xd4\xbe\xa2\x7d\xa7\xda\x76\x1c\x58\xbb\x7a\x2b\xa8\x0e\x7e\x0d\x0d\xc7\x1f\x96\x6b\x12\x6c\x19\xf8\xa1\x57\xba\xf7\xe2\xba\xd9\x95\xb0\xe4\xb3\x4f\x61\x49\xd5\xac\xb1\x17\x49\xf7\x65\xe6\x27\x46\x0e\x31\xdf\xa0\x62\x14\x45\x75\x68\x02\xd1\xbb\x71\x2b\xb3\x56\x37\x0f\x72\xae\x59\xaf\xc7\x14\x89\xc7\xe2\x66\x3f\x4b\x99\x91\x3b\x24\xf8\xc2\x21\x42\x83\x63\xa7\x48\x93\x2d\xff\x6e\x40\xd6\xfc\x82\x10\x60\xc1\x4d\x26\xb5\x1c\xe2\xfa\x2f\xf9\xc3\xc1\xa5\xf7\x87\xe0\xce\xca\xcf\xa5\x13\x77\x3d\x71\xf7\x67\x3f\xfd\xaa\xd4\xb4\xf0\x05\xb0\x3e\xfa\xf7\x3a\x78\x0c\xb2\x9d\x06\x34\xf8\x50\xb2\x73\x4e\x79\xe3\xf2\x09\x5d\xb3\x57\x1f\xb8\xe0\x37\xe3\xc3\x3f\x3e\xbf\x78\xee\xc6\xeb\xb7\x3d\x12\x5c\x02\x3f\xe0\x77\x98\x77\xae\xd9\xff\x36\x9e\x57\x59\x7e\xe0\xd7\x6d\xb3\x8f\xfe\xe3\xd2\x59\x9b\x80\xdb\xd8\x53\x73\x37\x74\x7e\x3f\x5d\xfa\x0a\xcc\xb0\x08\x36\x3b\xe2\x4b\xea\x37\xdd\xf3\x30\xfc\x6c\xd6\x92\x09\x65\x77\xaf\xbb\xbc\x7f\xfb\xdc\xb6\x59\x93\x3e\xbc\xec\x55\x3c\xe5\xea\xa7\x9f\x1e\x5a\x67\x4b\x71\x8a\xce\x48\x18\xa1\xd1\x88\x30\x65\x57\xd3\x76\xd6\x7e\x61\x74\xe4\xc6\x34\xb2\xe8\x7f\x24\x3b\x96\xac\xb2\x9b\x99\x76\x01\xd9\x88\x18\x20\x1b\x11\xd0\x91\x76\xd5\xb7\xb7\xd7\xb3\xc9\xfa\x76\x70\x51\x24\xe1\x40\x52\x6f\xb1\x50\xaf\x0e\x28\xf8\x97\xa1\xfd\x86\x54\x06\xf3\xa2\xe4\xcb\x3e\x98\x62\xff\xc4\xa4\x90\x80\x12\x08\x59\xc2\x2c\xc7\x53\x0a\x08\x5a\xb0\x0b\x99\xbb\x17\x0e\x9b\x3b\xc6\x28\x86\xa7\x38\x36\x40\xb6\xda\x14\xe9\x6b\x27\x25\xf8\xc5\xab\x7e\x3d\xa1\xd2\x17\xe4\xa9\x2c\xb3\x85\xc6\x61\x67\xd5\x22\xe9\x9b\xf2\x86\x06\xfa\x4b\x88\x94\x37\x34\x94\x3f\xf4\x86\x51\x2a\xc6\xd6\xa2\xa9\xf1\x0b\x9b\x5c\x45\xb5\x1e\xaf\x4d\x63\xb6\xce\xa9\x29\x9d\x5a\x15\xf6\x9a\xe0\x8d\x06\x26\x95\x9c\x53\x79\xfe\xa5\xab\x8e\x2c\x9a\x6f\x51\x7f\xdd\x7a\x6f\x67\x43\x39\x93\x25\x9f\x78\xea\xcb\xf2\x86\xdf\xc1\xd2\xe5\xa5\x53\x26\x54\xe8\x1c\xf5\x39\x0d\x4f\x1f\x3b\xf6\xe2\x34\xb1\x30\xa9\xd7\x69\x85\xb2\x0a\xd7\xb2\x07\x87\xb5\x6b\x98\x0b\xc8\x7a\xc9\x04\x74\x2f\xfa\x35\x42\x0c\xa7\x50\x84\x28\x50\x68\x31\xae\x80\xb8\x33\x66\x51\x64\x12\x27\x7b\x81\x13\xec\xdc\xd9\xd6\x2b\xf1\x8c\xe9\x8a\x60\x67\xac\x84\xa2\xd8\x43\x2e\x12\xf5\x92\xeb\x08\x61\x53\xc6\xe2\x4a\x81\xb2\x8b\xf1\x58\x3e\x0c\xd1\x1e\x2b\x5a\x4c\xa6\x0c\x7b\x9b\x12\x34\x00\x61\x44\xc9\xfc\x8c\x56\xaf\xdb\x14\xce\xf0\xc4\xc8\x79\xa0\xec\xd6\xe1\xac\xca\xa9\x09\xb2\x9d\xbc\x88\xcc\x05\xec\xfa\x03\x37\x1d\xbb\xe3\x86\x83\xeb\xd6\x27\x8a\x74\x74\x24\xcc\x80\x39\x37\x74\xde\x92\xd4\xee\xfd\xd7\x5c\x9a\x5a\xcc\x6a\x0c\x3a\x9b\x4f\xb2\xd5\xd7\xd9\x72\x4d\x06\x8d\x3a\x51\xcf\x68\x0c\x46\x6c\x56\xd5\xd7\x1b\x9d\x66\x3d\xcb\x8d\x1d\x6b\x76\xe6\xc0\x0b\xc1\xd2\x19\xcd\x6f\x7d\xfb\x56\xf3\xcc\x62\x03\xa8\x23\x21\x8d\xbf\x06\xa8\xa5\x2b\x0f\x5e\xf7\xda\xeb\x07\xc6\xc4\x72\x0d\xc6\x5c\x9e\x17\xb5\x9d\xfb\x27\x4d\xec\x5c\x35\x31\xb9\x76\x77\xc7\x43\x97\x4d\xde\xb7\xf7\x85\x17\xf7\x46\xb3\xb0\x4a\xe3\xb6\xdb\xf2\x6d\x26\x6a\x8d\xd3\x39\xf0\x26\x14\x6c\x0f\xae\xd9\x76\xc1\x5b\xcd\x33\x4a\x83\xf9\x6a\xad\xd6\xa1\x57\x73\x5d\xcb\x53\x07\x2f\xbd\x24\xc7\xac\x06\x4a\xbf\xf3\xee\xdb\x6f\xb8\x52\xcb\xae\x4f\x24\x93\x75\xdd\xdd\x07\x56\xcc\xcd\x55\xa9\x72\x81\x5a\x30\x7e\xfb\x79\x4b\x62\x95\x95\xf1\xc5\xac\x86\xa6\x2c\x7e\x3c\x93\xe4\x58\x53\x5b\xcf\x18\xb1\x81\xe7\x34\x63\xeb\x8d\x79\x66\xa6\x7e\xac\xc9\x99\x33\xe5\xfc\xb5\x2b\x67\x34\x2f\x5c\xd8\x3c\xb3\xd3\xcd\xe5\x98\x8c\xb9\x4b\x1b\x60\x16\xbe\xa2\x63\xc5\x89\x03\xd7\xbd\x66\xd4\x86\xc2\x2a\x8a\x62\xaf\x59\xb1\x7c\xc2\xc4\xe6\x49\x2d\xd2\xd2\x71\x93\x2f\xfb\xd9\xa2\xe7\xf7\xed\xdd\x1b\xf5\x60\xad\x5a\xa3\x62\x04\x03\xbe\xcb\x20\xac\x95\xf2\x8a\x66\x5b\x82\x0b\x9b\x67\xac\xec\x86\xd7\x54\x56\xa3\xde\xc1\xb5\x16\x55\x56\x68\xca\xb2\xf5\x46\xba\x2a\x39\x46\xae\x33\x79\x83\x88\xfd\x98\x45\x28\x07\x25\xd0\x26\xb4\x13\x21\x7f\xcc\x6e\xe5\x78\xda\xeb\x09\x52\x81\x20\x10\x51\x66\x81\xf6\xc7\xfc\x76\x96\x88\xc7\xc7\x13\x10\x08\x52\x3c\xf6\xf2\x54\x11\x56\x08\x6e\x62\x76\xb0\x3a\x71\xbe\x3c\x20\x29\x03\x31\xc0\x53\x64\x9b\x9e\x89\x2b\xbf\x3c\x4f\x71\x7e\x62\x80\xe8\xa4\x6c\x60\x25\xc6\x08\xb1\x5a\xe0\x29\xd6\x60\xb0\x1b\xf4\x89\x4b\x6e\xfc\xe8\xfc\x2d\x5f\xff\xfc\x8e\x65\x1e\x15\xcd\x6a\xf4\x4c\xef\x6a\xb8\x14\x6e\x7a\x1a\x6e\xd0\x9a\xac\x9e\xb0\xc9\xac\xb6\x95\x99\x18\x9b\xdb\x51\x62\x29\x06\x96\x57\xa9\x19\x96\xa2\x00\xd8\xae\x50\x70\xbb\xb4\x3b\xc7\x2f\xf2\xfa\x4f\x0b\xa6\x59\x2c\x5a\x5e\xdc\x72\xc5\xfe\x5d\x9d\x89\xca\x96\x8b\xb6\xee\x5d\x1a\xb2\x79\xe6\xb1\xb6\x9a\x48\x8d\x59\x7a\xaf\x64\xc1\xc5\xc7\xcf\x5b\x76\xdb\xe2\xb1\xd9\xe9\x8e\x09\xf5\x93\x67\x3b\xf9\xea\xce\x35\x63\x6b\x58\x36\xcf\x62\x8c\xcf\x18\x57\x91\x68\xdd\xdc\x56\xa8\x36\xa8\x19\xa0\x37\x57\xfc\x6c\x6e\xc1\xef\x8c\xab\x2a\x66\x15\xf2\x1a\x4b\xe9\x8d\x76\x4e\x4d\x61\x8c\x15\xb1\x58\x8c\x8d\xe5\x2c\xa7\x83\xbb\xf3\xeb\x43\x45\x5a\x6d\x9f\x7f\xaa\xd5\xaa\xb5\x57\xcf\x2b\x60\xcb\x67\x5d\xd3\x3a\x7b\x6f\xdb\xe4\xc2\x5c\x35\xde\x31\xd6\x15\xc5\x76\xff\xcc\x78\x4e\xcd\xf9\xab\x67\x56\x84\x26\xb7\x4d\xf7\xa4\x6f\x9d\x5b\x56\x62\xcf\x5e\x52\x5a\x79\x1b\xb6\x96\x2d\x1a\xb6\xf9\x49\x91\x3e\x2a\x4c\x10\x5a\xab\x46\xd8\x84\x0e\xb1\x2a\x9f\xb6\xcd\x1d\xf6\xf9\x33\x9c\x96\xd1\x0c\xc7\x25\x33\x2a\xac\xe0\x4b\xff\x1b\x6b\xf5\x8c\xb1\x16\x91\xe8\xce\x08\x83\xa7\xda\xeb\xe5\xc6\x52\x71\x06\x47\x0a\x30\x8d\xf0\xd3\xa9\x53\x29\x0a\x9d\x45\xc8\xa2\x20\x21\x50\x53\xe4\x34\x7e\xa5\x43\x6e\x7e\x3b\x32\xdf\x8a\x2d\xba\x82\x28\x1c\xe1\x3f\x65\xa6\xd1\x00\xc2\xc9\xd1\x57\x22\xde\x33\xca\xc7\x40\x54\x0e\xc2\x04\xc1\x66\x1b\xd9\x27\x84\xec\xe0\x36\xb9\xff\x3d\x17\xe8\xbf\x29\xd0\x70\xc8\x4e\xa7\xcc\x7c\x5a\x81\x8d\x24\x79\xf3\x00\x62\x52\xa7\x52\x30\xa2\xa3\xa0\x46\xea\x53\xa5\xce\x59\x6a\xa9\x48\x13\xf4\x0c\xa5\x31\xa7\x7f\x47\xa3\xde\xb3\x9e\x59\xf1\x4f\x3b\x77\x41\x35\x9d\x59\x27\x02\x28\xae\xd4\x09\xff\x69\x8a\x33\x91\xb4\xca\xc3\xda\x43\x19\x3b\x74\xc1\x6e\xfd\x3f\x2b\x87\x79\x41\xb5\x43\xf3\xe4\x93\x8a\x8d\xf9\x53\x4f\x29\x56\xe7\x43\xe1\x27\x9f\x54\x0f\xb8\xfe\x67\x45\x73\xfd\xb9\x2f\x37\x1c\x96\xfa\xfe\x77\xe5\x65\x45\x59\xa8\x00\x55\xa2\x85\x44\xa7\xc6\x13\x18\x36\xd4\xcf\x58\xeb\xff\x5f\x15\x10\x23\x48\x48\xe3\xd0\x48\x7d\x4a\xd6\xdf\x07\xe5\x59\xfa\x3b\xfe\x67\xc5\x82\x6b\x24\xa4\x56\x83\x4b\x29\x90\xf7\x41\x29\x91\xf4\x98\xff\x41\x61\xc0\xf0\x98\x37\x2f\xd3\x8e\x00\xe9\x9a\x87\x9c\x11\xab\x13\xd0\xeb\x10\x71\x96\x49\x18\xfa\x16\x1d\x3f\x12\x9c\x3c\x8b\x44\xc7\xc0\xa5\x70\x3f\x2f\x3a\x24\xc5\xe9\x57\xe2\x53\x0e\x51\x59\x57\xa4\x95\xb9\x0f\x51\x1d\x41\xa1\xf8\xf0\x3a\xf9\x10\xf9\x81\x9f\xec\x94\x0c\x2f\x19\xc5\xe0\xe9\xdd\x09\x62\xf6\x39\x1b\xee\x82\x12\xe9\x0d\xa9\x45\x7a\x03\x23\xf9\x61\x0e\x9c\x30\xe7\x9a\xef\x86\x5e\x43\x7a\xbd\x7c\x0b\x7c\x0d\x5d\xa1\x1c\x86\x12\xb8\xab\xc9\x9c\x6b\x3e\x71\x40\x4e\xb6\xe5\x6e\x65\x4d\xd3\x3f\x88\xd8\x3f\x90\x3e\xca\x4f\x30\x38\x64\x09\xea\xf4\x72\xcb\xe9\x1f\x2b\x24\xc0\xf0\x4e\xc5\xe9\xd6\x34\x43\xdc\x20\x0f\x23\x6d\xec\xeb\x1a\xcd\xbe\xdc\x82\x53\xc4\xde\x14\x27\x15\xab\x54\x54\x90\x3b\xf0\x24\x28\x26\xaa\x14\xe1\x49\x3b\xd5\x5b\x90\xbb\x8f\xa4\xc4\x08\x10\xfd\xb6\xc6\xa1\xd9\x97\x2b\x3a\x40\x61\x02\x13\x1d\xc9\xdc\xfe\xf7\x09\xc6\xdf\x41\xf5\x2a\x04\x61\xb9\xfb\x48\x9a\xde\x5e\x65\xbd\x5d\x85\x98\x7e\x82\x2b\x96\xdf\x65\xa4\xec\x25\x73\xc0\x06\xfc\xcc\x10\x62\x3a\x16\x87\x98\xc0\xf8\x63\x8c\x89\x31\xf9\x4d\x7e\x13\x98\x18\x13\xf7\x59\xae\xdd\x9c\x4e\x65\x65\xa5\x6f\x48\xdf\xa0\xe1\x2d\xa6\x5c\xbb\x19\xa7\xb2\xb2\x70\x27\xee\x74\xf5\x67\xe1\x64\x7f\x07\x76\xd1\x7d\xe9\x3e\xe6\x3b\xab\xfb\x54\xca\xea\xe2\x06\x91\x56\xfb\xfd\xf7\x8c\xd6\xea\x66\xe4\x20\x90\xa0\xfe\xa6\x7e\xcd\x17\xf4\xf7\xfa\x7e\xcd\xbb\xf4\xf7\xa7\xd2\xf4\xf7\xef\xf6\x6b\x46\xae\x0d\x9b\x90\x17\x45\x87\xfa\x1b\x0e\x58\x05\x2b\x18\x87\x98\xfb\x1c\x31\x43\x1b\xe1\xf2\x6b\x25\x67\x1b\x23\xbd\xc5\x24\xb9\x38\x95\xde\x62\x82\x3e\x8e\xfe\xf2\x8c\x60\xff\x5d\x2a\x16\x23\xb3\x45\xaf\x62\x25\x64\xb6\xb0\xc8\xa2\x3f\x95\xb4\xaa\x06\x11\x6d\xd1\x33\xbd\x56\x15\xc8\x9e\xd1\x31\xd4\x20\xd2\x58\x4e\x25\xf5\x16\x0a\x90\xc6\xc2\xf4\xea\x2d\x43\xfb\x35\x2e\x4e\x7e\xcd\x39\x64\x40\x02\xaa\x3c\x5b\x51\x65\xc8\x55\xd0\x9d\x01\x96\x61\x89\x29\x66\x3c\xc1\xc5\x83\xa0\x40\x3d\xb1\x22\x9c\x02\xbf\x39\xd3\xf9\x46\x5a\xf6\x8f\xb5\xcb\xef\x97\x4e\x45\x3c\x3a\x2b\x45\x67\x31\x7e\xde\x6d\x70\xf0\x06\xe6\xc0\x9d\xdf\xc0\x2d\xf0\x25\xdc\x82\x1b\x47\xd0\x7a\x2a\xff\x10\x94\x6e\x97\xde\xbd\xd7\x7c\x7f\xa5\x86\x02\x5e\x6b\xb0\x33\x6e\xde\xef\x28\x2f\x1f\x17\x58\x90\xbe\xe6\x01\x08\xdc\x7b\x2f\x3a\xad\x97\x36\x9c\xef\x20\x61\x74\x1d\x65\x1b\x34\xe4\x62\x17\x2d\xbf\x2f\xf9\xc0\xb1\x5c\xac\x0e\xe4\x71\xb9\x2f\x66\x14\xc1\x3a\xfc\x40\x5e\x8f\x18\x88\x8a\x31\x31\x81\xe3\x09\x26\x4e\x34\xa9\xc0\xe7\xa2\x9d\x70\xce\x27\x3b\x29\x75\x4a\x47\x5e\xbf\x66\xe7\xbc\x9c\xac\xe0\x0d\x17\x16\x57\x8d\xaf\x7d\x05\x96\xbe\xfe\x3a\xcc\x90\x1f\x78\x42\xe3\xf3\xd2\xa9\x8a\xb1\x8c\x21\x8b\xa6\x18\xd0\x60\x1d\xe6\xca\x6d\x85\x59\x4e\xed\x91\x5f\x9c\x5e\xea\xc0\xbf\x38\xfb\xb9\x53\x7b\xfe\x72\x65\xf7\x6f\xa6\x84\x3a\x5a\x67\xd4\xad\x16\x59\xd5\x9e\xbf\x80\xf9\x2f\xd2\x9e\x07\xa4\x77\xef\x55\x3d\x38\x8e\x57\xd9\x4c\x40\x1b\x69\x03\xc5\x63\x55\x54\xa8\x0c\x4e\x2a\x98\x0f\xec\xe1\x9d\x5f\xdd\xb7\x7c\xf9\x7d\x5f\x91\xdf\x51\x4d\x23\xe6\x9f\x88\x42\x2c\xd2\x20\xbd\xdc\x4a\x9b\xd4\x60\x82\x6c\x20\x2e\x46\x18\x49\x48\x22\xdf\xb2\x1f\xe6\x43\x20\x7d\x5c\x7a\x87\xda\x92\x3e\x0e\x05\xf4\xad\xb2\x1f\x4f\x97\xde\x95\x63\xc9\xba\xe1\xcc\xc1\x5e\xf6\x7e\x26\x49\xec\xd0\x59\x40\x5e\x0f\x25\x52\xd8\xeb\xe1\x02\x89\x8c\xd5\xab\x59\x99\xdf\xc4\x63\x5e\x0f\x67\x66\xec\xec\xfd\x1a\xe9\x69\xe9\xbf\x3e\xbf\x7a\x49\x49\xcb\xa4\x39\xe6\x35\x53\xb3\xee\x0a\xde\x32\x67\xd1\x26\xa1\xc4\x1e\x1f\x1b\x5e\xb1\x5c\xa5\xdf\x56\x95\xdc\x0a\xb3\xfa\xa9\x53\x7f\x91\x16\x4b\x33\x80\xeb\x81\x7a\x60\x9b\x96\xd8\xae\x2f\xb8\x4a\xa5\xbe\x64\x8f\xf4\xf1\xdc\x1f\x7f\xf2\x93\x39\x7b\x1c\x70\xa5\x56\x85\xce\xe0\xc1\xa1\x90\x86\x30\x6b\xbb\x81\xb2\xb8\x2d\x14\xb0\xe8\x14\xa2\x6b\x3f\xf8\x20\x7d\xd9\x07\x1f\x40\x2d\x93\x3a\x85\xe0\x0e\xbc\x05\x0a\xa5\xb7\xd3\x57\x4a\xaf\xa1\x33\xb4\x2b\x28\x64\x46\x63\xd1\x9c\xcc\xf9\x1c\xe1\xdc\x8e\x07\xe2\x01\x6f\xc0\xcb\x31\x21\x3b\x17\x8f\x04\xf1\x10\x29\x48\xc8\x46\x50\xe6\x36\x77\x34\x10\xc4\x09\x88\x9a\xc2\x71\xaf\x47\x1e\x49\x47\x12\x18\xa2\x04\xa4\x17\x35\xb9\x39\xc1\x9e\x49\x27\xe7\x83\xda\xab\x6b\xcc\xcf\x5e\xb5\x2a\x3b\xbf\x51\xb7\x28\xea\x8a\x4a\x87\x5d\xd9\xf0\x80\xb7\x7e\x52\xc5\xa5\xbb\x3b\x9a\xac\x1a\xfd\x64\xe8\x3d\xc4\x32\x18\xe0\x19\xf1\x8f\x2c\x4d\x53\xba\x1c\x7c\x7e\x8c\x63\xb0\xf4\x95\x30\x4b\xd0\xf1\x13\xe4\xec\xd3\xbd\xee\x59\x1b\xb2\xab\xaa\xb2\x37\xcc\x72\x77\x74\x1c\x73\x95\xd9\xe2\x8d\x7e\x7e\xe3\x45\x93\x52\x2a\x69\x27\xaf\x03\xae\x65\x2e\x0f\x40\xd3\x1a\x06\x76\xa5\x58\x96\x6a\xce\xc9\xc9\xd3\x0e\xfc\x72\xae\x1a\x28\x4a\xc7\x62\xd5\x72\x3b\x67\x95\xae\xe6\xd5\x58\x3d\x57\x79\xf6\x65\xa4\x0d\x2a\x43\x55\x68\x06\x6a\x55\x94\x22\xc8\x86\x8c\x2b\xb3\x09\x93\xa1\x68\xf7\x5b\x12\x20\x30\x04\x5a\x22\xbf\x2b\x51\x3f\x45\x13\x80\x03\xc8\xbd\x0b\xe9\x67\x20\x16\x09\x88\x9e\xcc\xc4\xd4\xc3\xb1\x56\x45\x79\x50\x1c\xa2\x81\xb6\x72\xa8\x3a\xa4\x7b\x53\xda\x2f\x35\x4b\xd7\xbe\xa9\x0d\x27\x36\xcd\x9a\x53\xf3\x1e\x14\x6e\xa2\xb2\x78\x58\x6f\x9e\x54\x9c\x68\x69\xd9\x3e\x4f\x7a\xa8\x13\x4a\xfe\x30\x66\xce\xac\x4d\xa7\x6e\x9b\xb7\xbd\xa5\x25\x51\xdb\x42\x15\x69\xb5\x1a\xa7\xb6\xb0\xa7\xa7\xa7\x50\xeb\xd4\x68\xb5\xc5\xd7\xb7\xb7\xb4\x5f\x6f\xdf\x3e\xaf\xa5\x36\xd1\x82\x1f\x1a\xb3\x28\x3b\x18\xba\x59\xfa\xe1\xc6\x1b\x41\x75\x73\x59\x59\xf6\xe2\x31\x33\x37\xd7\xdd\xa0\xc1\x6a\xbd\x91\x9a\xe1\x2f\x9d\xb7\xbd\x65\x5e\x62\x8a\x54\xa0\xbe\xbe\x76\xb3\xf4\x47\x72\x93\x16\xa9\x43\xeb\xd4\x6a\x34\x45\x05\x05\x45\x1a\x8d\x26\x5f\x5b\x1c\x52\xab\x43\x3f\xc8\x37\x9b\xb7\x9d\xd4\xe9\xf1\x83\x98\x7d\x82\x45\xa8\x1c\x21\x4b\x38\x41\xf9\xc2\x21\x5a\x90\xbb\x34\x27\x95\x80\xb8\x89\xd5\x41\x40\xc4\x01\xd1\x1c\xe7\x81\x73\xc7\x82\x74\x19\xf0\xd4\x78\x30\xce\xb9\xf6\x69\x80\x83\x7f\x84\xb5\xeb\x3a\xfb\x6f\x86\x95\x77\xfd\xfe\xed\x97\x26\x2f\x94\xbe\x92\x6e\xdb\xf7\xd4\x77\x98\xfa\xec\xf7\xe5\x35\x46\x7c\xa1\xca\x95\x98\x3e\xb3\xc1\x6e\xbf\xfc\xc7\xe7\x6f\xc2\x9f\x5f\xfc\xc7\xdf\x1c\x9a\xfb\xfb\xe7\x9f\x18\x7c\x72\xdd\xb1\x99\x2e\xc7\xb8\xb0\x74\x79\x7c\x0a\x8e\x4d\x86\x8e\x5f\x7d\x0b\xb3\x97\xd4\xec\x6a\x9f\x7a\xf1\xd4\x4a\x87\x01\x80\x99\xbe\xf3\xfa\xa1\xfa\x4a\xb0\xf5\x0a\x1b\x7d\x0e\x42\x51\x93\x3b\x33\xa4\x90\x2b\xa4\xdb\xe6\x8e\x0e\x0f\x96\xc2\x6a\xd4\x5e\xff\x43\xb2\xbe\x1d\xa7\x20\x95\x46\x80\xd8\x8e\xfa\xf6\x7f\xa2\xf6\x7a\x17\xee\x48\xf7\xd4\xb7\xb7\x83\x87\x98\xb0\xa4\xda\xeb\xfb\xfa\xea\xdb\x87\xb1\x9d\x4f\x10\xbb\x95\x72\xb9\x7f\xf7\x93\x2d\x39\xb9\x22\x28\x7a\x92\x71\xa2\x26\xa5\x2c\x58\x87\x43\x3e\x35\xb0\xc8\x3d\x42\x70\x54\xa0\xbc\x44\xfe\xde\x09\x3c\xb0\xe5\xef\x4d\xf9\x6e\xdf\x75\x3f\xec\x9f\x73\xed\x0b\x6b\x77\x9d\x6c\x7a\x7b\xad\x74\xf4\xe5\x9f\x48\xef\xbd\x71\xf1\xc5\x6f\x80\xf8\x93\x37\x61\xbd\x94\xc4\xbf\xd8\x24\x35\x4a\x5f\x3f\x3c\xb4\xc2\xfb\x30\xd0\x70\xc7\x45\x47\x03\x1d\x57\xb8\x4a\x75\x9a\xd2\xef\xd7\x6d\xbd\x6a\xff\x0f\x07\xd6\xbe\x70\xed\x9c\x0b\x56\x5f\x74\x77\xef\xc5\x6f\x48\xef\x49\x4f\xcb\x97\x78\x0b\x4f\x90\x7a\xd2\xd2\x7b\xa7\xdb\x4a\xe9\xbb\x93\xd2\xa6\x1e\x20\xe6\x24\x88\x46\xae\x41\xc4\xf6\x65\xf8\x74\x33\x7c\x04\x71\x37\x04\x4c\x90\x0f\x26\x35\x76\x03\x73\x5d\xfa\xa6\x85\xd4\xbc\x53\xbf\x78\x94\x3e\x6a\xbd\x2e\xfd\x17\x58\x28\xe9\x06\xee\x86\x65\x54\x35\xec\xbc\x7e\xe0\xc3\x4d\xd4\x82\x74\x76\xc7\xa2\x81\x9f\xc2\x74\xbc\x63\xe0\x43\x5c\x3d\x54\x36\x29\xe6\x1b\xb2\x9f\x7b\x11\x42\x40\x14\xc9\x87\x25\x6b\x86\xfd\x8c\xc9\x9d\x41\xb2\xb8\x4d\x91\x6a\x08\xe5\x41\x78\xc8\x8d\x0e\xbb\x09\x6c\x0f\x9b\x86\x35\x89\x6d\x0a\x5d\x4e\x2c\x1c\xca\x53\x76\x1f\xbc\x1e\xce\x16\x8a\x39\xf1\x19\xe7\x54\x43\xc8\x66\x52\x5c\x9c\x32\x76\x18\x8d\x1d\x46\x8c\x86\xdc\x74\xaa\xbb\xa7\x3b\x2d\x47\x0f\x7f\x18\x1d\x67\x04\x97\xbb\xc4\xed\x2a\x15\x6d\x53\x8d\xa6\x1a\xce\x38\x21\xc7\x3c\xd9\x52\x10\x02\x23\xa7\x63\x46\xa6\xc5\xc6\x3e\xe3\xe9\xff\xb4\x11\x92\xcd\xdd\xdd\xcd\x52\x2f\xfe\xc6\x68\xec\xc6\xdd\x46\x63\x37\xf9\xb0\x1c\x05\x00\x97\x1b\xbc\x82\xcb\x25\x78\x0d\x26\x8d\xc1\x60\xfc\x9d\x41\x6f\xd0\x5d\x0a\x40\x71\x6c\x77\x26\x61\x7a\x7f\xb7\x51\xd1\x78\x24\x75\xb5\x4b\x61\xc0\x52\x86\x5b\xb5\xe0\xb6\x0b\x4e\x86\x8c\xeb\x87\x48\xde\x94\x99\xa4\xd7\x13\x64\x02\x41\xca\xeb\x26\x80\x1f\x45\xe5\x29\x1c\x92\xfb\x5a\xb6\x1a\x32\x8d\x8f\xdc\x03\x7b\x3d\x3c\xcd\xb1\x9c\x5c\xc3\x05\xd5\x37\x46\xa3\xd4\xab\x52\xa9\x39\xe3\xc0\x4f\xfd\x41\xa3\x29\x5f\xc8\x77\x99\x3a\xcc\x3c\x90\x31\xbf\xd4\xcb\x9b\x3b\x5c\x63\x4a\x82\xb9\x01\xb3\x45\xc8\x2d\x29\xcd\x92\x6e\xb0\x5f\xd5\xd2\x75\xf8\x70\x57\xcb\x55\xf6\xce\xac\xd2\x92\x5c\xc1\x62\x0e\xe4\x06\x4b\xc6\xb8\x56\xd9\x96\x24\xe4\x87\x4e\x2c\xb1\xad\x32\xb9\xf2\x85\x7c\x93\x31\xe8\xa7\x17\xb8\x8c\xf8\x0f\x2a\x51\xd5\xcb\xd0\x1a\x73\x6a\xcc\x2a\xbf\x2f\xe1\xf2\x19\x3b\x86\x2e\x6e\xe6\x3b\xac\x39\x31\xb1\x29\x50\x18\xad\x9a\xec\x99\xbd\xfa\xf0\x1b\x87\x57\xcf\xf6\x4c\xae\x8a\x16\x06\x9a\xc4\x58\x8e\xb5\x6a\x62\x77\x4f\xf7\xc4\x2a\xa3\xcf\x95\xf0\xf9\x57\x8d\x49\x99\xad\xda\x33\xb1\x01\x1c\x32\x21\x37\x19\x93\x10\xf0\x0b\x32\x8a\x5e\xb7\x29\x4c\x7c\xa3\x40\x2d\x17\x4f\xaf\x4c\xa7\x2b\x01\x3f\xb2\x4b\x9a\xfe\xf3\xf4\x4e\x7c\xf9\xb9\xd0\x2a\x89\xee\x69\xa0\x97\xfe\x09\xf4\xa3\x03\x29\xd0\xc3\xca\x73\x6c\x9e\xc8\x6d\xc8\xbb\x6a\xc4\x04\x50\x00\x8d\x41\x53\xd1\x62\xa2\x41\x1c\x60\x87\xf8\x9b\xe2\xb1\x68\x44\x59\xab\xb6\x0b\x72\x73\x1f\x50\xb6\xf8\x09\x02\xee\xb4\x7a\x87\xa2\x11\xe7\x04\x41\x91\x81\x97\x4f\x33\x06\x44\xb2\x44\xe5\x33\x0e\x47\x45\x23\xca\xa2\x94\xc0\xae\x69\x88\x72\x46\xae\x30\x4b\xa7\xcb\xcf\xd5\x08\xdb\x7e\x77\xe1\x65\x9f\xc4\x56\x37\xdb\x4b\x92\x42\xe3\x4a\xf9\xe7\xa0\xed\xd3\xd7\xdd\xf8\xd2\xd5\xfd\x7f\xba\xfb\x9b\x17\x0f\x25\x20\xf1\xcb\x3f\x43\xab\xb0\xe9\xc6\x53\x8b\x85\xc2\x2c\x8b\x43\x67\x9e\x38\xd1\xac\x8b\xd4\x99\x17\x03\xba\x4c\x28\x14\x2c\x0e\xbd\x79\xf5\x6a\xb3\xde\xe1\x48\x98\xe1\xe1\xea\x45\xb6\xd2\xb2\xac\x5c\x4a\x53\xe5\x9c\x38\xe9\xc2\xd7\xb7\x1d\xb8\x20\x77\x9a\x90\x2c\xb1\x37\x1e\x7a\xe3\xd0\xba\x69\x57\xbf\xf8\xd7\xbb\x6f\xfc\xcc\xfe\xe8\x67\xd2\x2f\xff\x98\xfd\xc4\x05\x0f\xee\x77\xeb\x4d\x75\x8e\x4e\xc0\x9d\x8e\x84\x4f\xef\xb8\xba\x41\xca\x7a\xc1\xa3\x37\x27\x1c\xb7\x3f\xf7\xcb\xdb\x1c\x75\x26\xb3\x2e\x07\x61\xe4\x1b\x44\xcc\xfb\x64\x1f\x7e\x2d\x42\x0c\xe9\xf5\xe4\x77\x55\xe1\x65\x64\xe5\xaa\x1a\x8d\x24\xa8\x90\x93\x22\xf0\xdc\x7c\x20\x9a\xa4\x74\x40\x0c\x04\xa9\xe8\xd0\x12\x1b\xe1\xf8\xf2\x16\x41\x90\x26\x16\x5f\x44\xd5\xd4\x49\x09\x4e\x15\xf3\xfe\xc5\x3f\xdf\xb1\xe3\xe7\x17\x9f\xdc\x78\xb3\xfb\xc0\xc9\x35\x8f\x5e\xb8\x24\xe6\xd5\xa9\x73\x4b\x67\x75\xcd\x2c\xc9\x51\x09\xb9\xab\x03\x05\x1b\x0f\x9b\x4b\x63\xed\x6d\x93\x73\x0d\x9b\xae\x5e\x51\x58\xd8\x7a\xd9\x0b\xdb\xb6\xbe\x78\xc9\x02\xd1\x59\x1c\x2b\x31\x61\xd6\xe2\x88\xf8\x82\xb9\x56\x43\x8b\xdf\xdf\xb0\xb4\x48\x23\x36\x5c\x3c\xaf\xe9\xa2\xb6\xc9\xe5\x1e\x8b\x06\xeb\xe7\xef\xd8\x31\x7f\xc1\x8e\x1d\xcf\x18\x1e\x3c\x7f\x4a\x72\x5a\xd1\xb8\xb9\xb3\x67\x86\x79\x4b\xd9\xd8\xb0\xcf\x5b\x56\x1d\xe0\x3d\x65\x39\x4e\x0c\xe7\xcd\x74\x94\x96\x88\xa1\x52\x8f\x9e\x8b\x2f\xd8\x70\x65\xfb\xb4\xfd\xbb\x16\x57\x45\x66\x76\xad\x0c\x07\x27\x17\xe7\x69\x34\x66\x31\x36\x2f\x66\xb4\x00\x24\xa6\xf9\xb3\xc4\x58\x79\x75\x5e\x76\x55\x2c\x19\x9f\x10\x9b\x1c\x1e\x69\x87\xa7\xd8\xaf\x9f\xb5\x7b\xe0\x1f\x15\x1e\x29\xc4\x8d\x7b\xcd\xfc\x20\x99\x7b\x02\xe2\xcd\x70\x66\x28\x35\x5a\x73\xbb\x03\x93\x37\xf9\xf4\xa2\x50\xc6\x0f\x83\xa3\x94\xb5\xe9\x11\xfc\x33\x02\x59\xb5\x41\x68\x84\x35\x3c\x72\x25\xc0\x18\x04\x17\x0f\x46\xbb\x7f\xa4\x56\xda\xc8\xb5\x86\x4c\x18\x97\x9d\x69\xd3\x0e\xb7\x42\xc1\xa9\x03\x07\x4e\x49\xef\x9c\x3a\x70\x00\xbe\x96\xf3\xd0\x7b\x3a\x53\xe4\x8b\x19\x9d\xf1\xfe\x07\x0e\x9c\x1a\x3e\x6b\xda\x19\x59\x1f\xe1\x3f\x63\xfc\x6a\x90\xfb\xf3\xd1\x25\x79\x86\x84\x79\x72\xe4\x15\xa0\xf7\xbf\x2b\xab\xb3\xca\x87\x1a\x55\x3e\xff\xb2\x74\xe2\x23\x6d\x35\xff\x5d\x69\xac\x3d\xfd\x3c\xff\x0f\x45\x30\x1a\x1f\xe5\x47\xb5\x08\xf9\x2d\xc4\xa0\x99\xd0\xab\x83\xc5\x6d\x21\x28\x6e\x05\x04\x3f\xec\x86\xec\x7e\x13\x79\x19\x33\x3d\x6c\xc6\x1f\x73\xd9\xd9\x0f\xbc\x94\xc5\x92\xf7\x63\x2a\xcf\x62\xa1\xbc\x6c\xdb\xdc\x1f\x67\xcf\xa5\x7c\xd9\x80\xc8\xa4\x49\xfe\x42\xd9\x3e\x69\x97\x18\x11\x0f\xbf\x71\x58\x8c\x88\x1f\x43\xe2\xe3\x94\xf4\x42\xae\xdd\x66\xb3\xe7\x42\x15\x35\x71\xe0\x47\x8a\xcb\x72\x8f\x54\xdc\x74\xff\x64\x10\x29\xda\x13\x72\x0b\x35\xe4\x3f\xfa\xf1\xc7\x19\x3b\x3b\xd9\xb1\x11\x86\xa2\x6a\x34\x19\xad\x21\xb3\x78\xb9\x1d\x1f\xc2\xfc\x66\x14\x30\x20\x01\x01\x2a\x08\xbc\x02\xb3\xf6\x0f\xe5\xdc\xae\xbc\x25\xc3\x7e\x4b\x2c\x08\x44\x8f\x54\x08\x87\x62\x40\x79\x09\x6e\x33\xf3\x33\x10\xfc\xac\x97\x0a\x42\xf1\x10\xcb\xbf\xdc\x3e\x93\x5c\x1a\x36\xaa\x26\x05\xfb\x51\x70\x92\x6a\xa3\x41\x0e\xc3\x72\x87\x17\xbb\x70\x61\x44\xfe\xf6\x67\x43\x8f\x18\x11\xc5\x88\x08\xa9\x8c\xdb\xe1\xc2\xde\x48\x21\x76\x61\xaf\x83\xc9\xf6\xf7\x5f\xdc\xb6\x7b\xb9\x65\xef\x82\x3b\x15\xbc\xfa\x9d\x0b\xf6\x5a\x96\xef\x6e\xd3\x8e\x2f\xbd\x53\x74\x48\x72\x44\xe9\x78\x4a\x2e\xc1\x74\x57\xb0\xa6\x26\x88\x0f\x37\x76\x35\x0e\xf4\xe1\x42\x07\xf4\x38\xbc\x74\xa1\x43\xea\xc8\xf6\x24\xa1\x87\xd0\x2c\x74\x90\xe2\x39\xed\xb7\x41\x8f\xa3\x90\xf6\xca\x81\x42\xec\xa1\xdf\x93\x96\xc1\x63\x2d\xeb\xe4\xc3\xeb\x5a\xa4\x89\x70\x4b\x49\xa5\xec\xaf\x44\x18\xb9\x07\x53\xec\x47\x64\x0e\x36\x1d\x21\xb0\x78\x29\x90\xeb\x01\xe5\x0e\x09\x76\xb2\xb8\x44\x11\x34\xa8\x18\xb7\x78\x87\x7d\x72\x2d\x21\xeb\x48\x23\x7c\xb1\x8c\x3e\x7e\x78\xd8\x27\x5f\x81\xfa\x28\x29\x25\x29\xa9\x92\xcb\x92\x1e\x4b\x42\xdc\xa0\xd1\xd0\x95\x8c\x43\x7a\x6c\x06\x97\xd5\x67\xd4\xa8\xa9\x69\xd2\x0c\x2e\xeb\x63\x03\xf1\xbd\x24\x3b\x95\x5c\x16\x4c\x4c\xca\x7e\x92\x12\x26\xce\xe0\xb2\xfb\x0c\x99\x94\x19\x9f\x7c\x1d\x35\x46\x80\x06\x11\xfc\xd0\x97\x35\x88\x74\x3c\xdf\x97\x25\x3d\x9a\xa5\xd3\x19\xa1\x72\xc8\xd5\xe9\x8c\x7d\x59\xa0\x1c\x83\x49\x72\x9c\xf4\xe2\x90\xab\xd3\x29\xf3\xcf\x55\x83\x88\x39\x94\xb1\xd7\x34\x11\x8b\x7b\x81\x33\x09\x1c\xa5\xa6\x4c\x14\xa7\x06\x01\x90\x11\x13\x6b\x4b\x6c\x34\x13\x96\x4d\x6a\xf2\xc1\x43\x87\x0e\xee\x82\xd7\xa4\x13\x10\x92\xca\x07\xdb\x20\x29\xf5\xb6\xa1\x41\xfc\xdb\xe4\xba\x7b\x9e\xfd\xfe\xd9\x7b\xd6\x25\x87\x3c\xf0\xe9\xc1\x43\xd4\xde\x43\x07\x07\x16\xc3\x6b\x10\x82\x10\xbc\x96\x3e\x82\x06\xdb\xa4\x67\xa4\x67\xda\xd0\x20\x74\x4b\xed\xd2\x0b\x2f\x6d\xaf\xa8\xd8\xfe\x12\x54\xc1\x6d\x50\xa5\xf8\x95\x77\xb3\x60\x10\x51\xef\x0c\xe7\x0b\xf9\xe3\x01\x53\x3c\x60\x51\x83\x09\x02\x6a\x88\x83\x09\xf0\xec\xfb\xef\xbf\xff\x7e\x17\x2c\x4b\x7f\x2e\xbd\xbd\x1a\x36\x49\x7b\x57\x43\x21\xce\x59\x7f\xdf\x7d\xb0\xf6\xbe\xfb\xd2\x7f\x93\x6e\x49\x7f\x86\x5f\x90\xde\x59\x0d\x9b\x61\xf3\x6a\xe9\x1d\xfc\x42\xfa\x33\xc5\xae\x26\x83\xf5\x32\x20\x01\x15\xa2\x0a\x84\x86\x57\x8e\x86\x57\x90\x58\xc2\xe6\x67\xb1\x72\xa0\xac\x1f\x46\xe2\x40\x1a\x67\x3a\x73\x84\x41\x4d\x9d\x4d\x4d\x9d\xe9\x26\xe2\xd0\x4d\x1f\x2b\x4c\x7d\x97\xe8\xfb\xfb\x2c\xae\x1e\x87\xa8\xa7\x5d\xc4\x4d\x77\x64\x8e\xbc\x22\xa7\x6b\xa2\x48\xf2\x26\x29\x7f\x88\xd8\xaf\xd7\x6a\x3e\x95\x72\x88\x0e\xab\x99\x49\x39\xc4\x27\x32\xd1\x64\xdd\x88\x1a\x9c\xc8\xa6\x99\xc7\xc8\x2a\x89\x11\x09\x28\x0f\x21\x8b\x1a\x82\x10\xb7\x14\x02\x54\xc8\xcd\x53\x2c\x04\x16\x3b\xcb\xa9\xa1\x42\xf6\x0b\x9d\x54\xd6\xc0\x2d\x66\x9e\x5b\x0e\x27\xf0\x41\xe9\xe1\xf4\x37\xcf\x4b\xa1\xe7\x55\x21\xa6\x7c\x39\xc7\x9b\x07\x6e\xa1\xb2\x48\x50\x45\x25\x06\xd4\xf8\x7c\x7d\xb1\x0d\x22\x03\x6a\xb6\x35\x7d\x0b\x5e\x26\xa4\x2f\x95\x5e\xb1\x15\xeb\xd3\x57\x51\xff\xc4\xcb\x04\x61\xc4\x7a\x5b\x1f\xa2\xc8\xae\x4b\x05\x42\x10\x8e\x7a\x81\xd8\x90\x07\x04\x27\xc4\x09\xc3\x24\x63\x95\xa7\xeb\x0a\x7c\xd2\xa3\x80\x27\x15\xd9\x0f\xb9\xb3\x30\x43\xaa\xa7\x87\x1a\xdf\xb9\xe7\xf2\x1f\x3b\xa0\xe5\x87\x83\x97\x48\x05\x84\xdb\x20\xb5\x74\xbe\x94\x7e\x74\xdb\x89\x31\x96\x26\xcb\x98\x13\xdb\x1e\x95\xd2\xf3\x97\x7e\x03\x47\xe0\x0b\x38\xf2\x0d\xee\xed\x4b\xbf\xb1\xd0\x87\x61\x51\x63\x47\xf3\x62\x80\x8b\xfa\x7a\x9f\xb8\xe3\xbc\x1d\x47\x3e\x5c\xd9\x02\xd0\xb2\xf2\xc3\x23\x3b\xce\xbb\xe3\x89\xd7\x95\xce\x60\x88\xbb\x61\x68\xfd\x44\x99\x67\x59\x50\x01\x2a\xce\xd8\x7c\xdb\xbc\x51\x0b\x51\x22\x73\x9f\xfe\x90\xa5\x7e\x08\x70\xc4\xf8\x24\xd3\xc5\x41\xdc\xcd\xc4\xdd\xcc\x28\xdc\x1e\xa6\x06\x06\x06\xa8\x6f\xa5\x7b\x61\x4e\xba\x03\xf7\xa4\x3b\xa8\x80\x4e\xe5\x92\x2e\xfb\xdd\xef\xa4\xcb\x5c\x2a\x9d\x4e\x45\xbf\xa3\xd2\x0d\xdc\xfd\x98\xd4\x85\xf7\x7c\x20\x75\xe1\x4f\xe6\x26\xfa\x0b\x12\x73\xe7\x26\xe8\x77\x12\x73\xf1\xfa\x54\x0a\x0d\xee\xd8\x21\x41\x2a\x05\x48\xf1\x0f\xdc\x2e\x9f\x31\x88\xee\xbd\x17\x90\x4e\xd5\x5f\xa0\xd2\xe9\xe8\xf6\xc3\x87\x0f\x5b\x4f\x9f\x36\xf7\x0c\xcc\x4a\xbe\xdc\x2b\x41\x66\xc3\x9e\xcd\x07\x27\x25\xd8\x05\x27\x2d\xd8\xe3\x31\x39\x06\x43\x90\xc1\x01\x97\x0e\x9c\x14\x0f\x1c\x6b\x03\x2f\xf0\x38\x88\xa9\x54\x67\xe5\x9e\xd7\x3c\xbe\xf9\x9a\x40\x20\xb1\xbc\x25\x5a\xa2\xa6\x4b\x9a\x37\x6d\xbc\xae\xf1\x46\x80\x50\x34\x77\xea\x2b\xd2\xcc\xa6\xf5\xb3\xaa\xc7\x04\x1b\x03\x60\x82\x67\x21\x7a\xf2\xaa\x99\x4e\x86\xd7\xeb\x61\x5c\xa7\xf4\x47\xfb\x9e\xce\xfb\x0e\x3d\x8e\x5f\xfb\xd5\xcc\x97\x37\x59\x4c\x05\x46\x67\x7e\xf1\xf2\xdd\xed\xb3\x4d\xaa\xd9\x57\xdd\xb3\x73\xb3\xab\x9e\xa5\x3c\x3e\xdb\x18\x08\x49\x17\xd7\xec\x3c\x72\xc3\xfb\xcf\x43\xe8\x8a\x49\xdd\xc7\xef\xfa\xfc\x9e\x4f\xb7\xcc\x9e\x2d\x48\x8f\x41\x1e\xce\xe2\xb1\x6b\x2e\x1a\x81\x6d\x2b\x23\x3b\x58\x44\x61\x1e\x05\x81\xa3\x5d\x7e\x91\x27\x7b\xc9\x3c\x36\x00\x4b\x00\x08\x75\x10\x8b\x87\xed\xf9\x60\x0f\x87\xe2\x09\x28\x83\x20\x0e\xc8\x63\xfc\xcc\x1b\x49\x8f\x9a\x8b\x8c\x66\x29\x1a\x3d\x57\x61\x96\xe9\x4a\x1d\x52\xbf\xf4\xa5\xd4\xef\x28\xd5\xe5\x38\x9e\x5b\x83\x73\x1c\xb9\x6a\x8d\x3d\x5b\xcd\x97\x18\x55\x31\x53\x91\x29\xa6\x32\x96\xf0\xea\x6c\xbb\x46\x9d\xeb\xc8\xc1\x6b\x9e\x73\x48\x8f\x90\x05\x4e\xbc\x67\xdd\x53\x52\xbf\xf4\x89\xd4\xff\xd4\xba\x75\x4f\x01\x03\x4e\x60\x9e\x92\x1a\xa5\x17\xa5\xcf\x4e\x6c\xdb\x76\x02\x72\xa1\x12\x72\x89\xef\xc5\x73\xcd\x7f\xe6\x44\x72\xd8\x44\x82\xcd\x89\x94\xb2\x41\xdd\xad\x1f\xce\x9f\x68\xcb\x2e\xd7\xd0\x85\xd6\x3d\x5b\xb7\xee\xb1\x16\xd2\x9a\xf2\x6c\xdb\xc4\xf9\x1f\xde\xaa\x0b\xb2\xc7\xc8\x72\xea\xfa\x51\x77\x92\x7d\xab\xb7\x9d\x90\x3e\x1b\x75\x43\xa9\xfc\x5c\x30\x34\x44\xa1\x86\x41\xc4\x3c\x91\x29\xe3\x49\x08\x21\x3b\x31\x87\x21\xb3\x1f\x0b\xa1\xb5\x0f\x64\x10\x9c\x81\x58\x1c\x02\x1c\x1b\x04\x82\xc9\x15\xe4\xf2\x37\x80\x1f\x2b\xa0\x69\x2b\x84\xe2\x64\x56\x01\xd1\x48\x5c\x60\x6d\x56\x3b\xb3\xbd\x81\x29\xa1\x6b\x0b\x59\xaa\xa4\x8a\xf2\x5e\x13\x3f\x78\x65\xeb\xab\xd7\x5e\x76\xde\x95\x5b\x6f\x07\xd5\xa1\x5f\xb8\x5b\xc6\x30\xae\xbf\x3a\x1a\x9c\xf0\xa5\x4f\x67\x2a\x7e\x15\x36\x16\x1e\xec\xec\x3c\xb8\x72\xe0\xbd\xae\x05\x7b\x0e\x3c\x75\xb0\xff\xc0\xa6\x3d\x35\xaf\xe2\xef\x27\x94\xa5\xdf\x2d\xaa\x04\x6a\x5c\x09\xdc\xaf\x5a\xbf\xe3\x9d\x5b\xae\x5c\x7e\xd9\xb5\x27\x16\x5e\xb5\x21\x07\x4a\xe6\xfd\xc4\xc9\xd4\xb7\xe4\xbd\x29\x70\x66\xe9\x73\x5b\xd9\xb8\xd0\x97\x56\xb8\xbb\x53\xbe\xcc\xa9\xa7\x6b\xf7\x6c\x3a\x70\xea\xe0\x93\x07\xf7\xb4\xac\xb9\xf6\xd5\xb3\x34\x7e\xa7\x11\x2d\xb8\x51\x1a\xbf\x60\xe5\x31\xc7\x63\x65\xb3\x9b\x44\x27\xa8\x38\xe1\xb5\x20\xb2\x45\x04\xcd\x12\x54\x40\x26\xd8\xc5\x63\xa3\x13\xbb\x12\xd8\x18\x84\x91\xe3\x5b\xaa\x3b\x23\x51\xdc\xc3\x9b\x01\x39\x6b\x8b\x45\x57\x9e\x40\x42\xb6\x9c\x70\x7e\x5e\xb4\x64\x5e\xa4\x32\x90\x17\x56\x1b\xb5\xaa\xd5\x1a\x9a\xdb\xf6\xe9\x25\x7f\xf8\x7a\x94\x28\x3f\x5c\x3b\x7a\x50\xdc\x3c\x74\x45\x33\x7c\x12\x6a\x1e\xe3\xb4\x99\xad\xb9\x06\xb2\x8f\xd7\xe0\xad\xf6\x79\x8d\xfa\x6c\x5f\x7e\x51\x75\x8e\xb5\x4e\xc7\xce\xe4\x1c\x9a\xde\xff\x82\x71\xa7\x05\xf8\xc9\x65\xa5\x47\x46\x0d\xa5\x11\x8d\x02\x83\x14\x33\x9f\xcc\x0f\x13\x68\x3a\xea\x40\x08\x79\x86\x56\x73\xc0\xca\x8a\x01\x08\x82\x01\xd8\x7c\xb0\x50\x04\xab\x41\x66\xc3\x39\xc0\x09\x76\xf2\xce\x05\xa9\x28\x65\x51\x38\x39\xf3\x81\xb3\x33\xf2\x0c\xd2\x2e\xd8\xe5\xea\x11\xf0\x8a\x01\x8a\xf0\xd3\xca\x01\x11\xec\xb1\x3a\x88\x45\xe1\x81\xd4\xc2\x85\xa9\x56\xd8\x5b\x33\x8e\x97\xae\xe5\x78\x9a\xe2\xb4\xdb\xe0\x27\xe3\xb2\x0d\xfa\x50\x34\x2f\x9b\xc2\xbf\x64\xe6\x78\x69\x8d\xd9\xca\x71\x96\x7c\x93\x96\x0e\xfe\x5e\x58\xd0\xe8\x82\xbb\x38\x8e\x02\x4e\x5a\x53\xdc\x9a\x95\xe5\x63\xb5\x65\xde\x44\x81\x1a\x58\xbc\x9d\xba\x2e\x9f\x52\x6b\xad\xec\x06\xe9\x37\x94\x8a\xa2\xb4\xf4\x4b\xad\x63\x93\xad\xad\xc9\xb1\x69\x6f\xc8\x6b\x17\xe0\x61\x1d\x87\x29\x95\x7e\x8f\x74\xab\x14\xef\x2d\x72\xb0\x8e\x6c\x7d\x4d\x8e\x09\xcf\x87\x9e\xdb\x3f\xcc\xf2\x59\xf4\x80\x29\x9d\x35\xcb\x80\xa1\x18\x2e\xf2\x14\xa4\xff\xc9\xe8\x28\xd0\xff\x74\x7d\x5f\x65\xbc\xcd\x35\x21\xc7\xae\x73\x59\x8c\x6a\x58\x24\xdd\x5f\xa1\x62\x30\xa3\x2d\xd4\xdc\x07\x27\x81\xc6\x58\xad\x22\xdc\x67\x14\xfa\x54\x8d\xe8\x5c\x84\x91\x16\x79\x51\x05\x6a\x44\xcb\xd1\x0e\xb9\x87\xa3\x98\x48\xc6\x06\x08\x2c\xc3\xea\x12\x64\x4e\x20\x2a\x72\x6b\xf2\x08\x60\x44\x1f\x01\x56\x9e\xe2\xbc\x09\xaa\x0e\x22\x41\x2a\x10\x76\x52\xf9\xff\x41\x8c\x00\x3f\xdc\x0b\x54\xcb\xf2\x8e\x58\xa4\x75\x75\xfa\x39\xb0\xf0\xef\xf0\x16\xe9\x83\xb8\xc6\x2c\x7d\x67\xb3\xe8\x71\x89\xda\x0c\x4d\xbc\x95\xaa\xee\x7f\x41\xfa\x96\xb7\x5a\x79\xd0\xbd\x08\x37\x80\x21\xb7\xb6\x38\x2c\x56\x39\x8c\x00\xc0\x3b\x2a\xc5\xe2\xc2\x44\x9e\x09\x3f\x06\x86\xdc\xc4\xe9\xf8\xec\xa1\xf8\x87\x33\xe9\x2b\xcf\x8c\x07\xec\x04\xf5\x4f\xe7\x75\x49\xdb\x37\xc0\xcb\x69\x9d\x7c\xf5\xc4\x0c\x83\xcf\x84\xbf\xe3\xad\xcf\x4b\x17\xbf\x6f\xe5\xf1\x3f\x78\xab\xb4\x4c\xeb\x5b\xb5\x78\x4b\x71\xe9\x96\x95\xad\x39\x39\xaa\xbc\xd6\x85\xbb\xaa\xcb\xb6\xae\x98\xef\x70\xfc\x3f\xc6\x2b\xfb\x9f\x4c\x8a\xf9\x16\x4d\x41\x0b\xd1\x1a\xb4\x13\x21\x26\x12\x04\x42\xaa\x4f\xc4\x19\x03\x41\x2a\x20\x46\xe2\x09\x2a\x43\xd8\x4d\xd4\xd2\x71\xc6\xba\x9d\x23\x64\x79\xf2\x94\x50\x38\x8d\x54\x4b\x80\xc5\x23\x46\x94\xa5\x9d\x48\x2c\x24\xd8\xad\x1c\x6b\xf7\xc8\x17\x89\x19\x33\x31\x46\x4e\x89\x48\x80\x51\xcc\x44\x99\x8d\x98\xc3\x2b\x1d\x3e\x0c\x2a\xb5\xda\xe0\x13\xda\xb3\x3c\x7a\x56\xc3\xa8\xc0\xef\x07\x15\xa3\x61\xf5\x9e\xac\x76\xc1\x67\x50\xab\x55\x80\x7d\x8e\x79\x2e\x6b\xb6\x27\x59\x35\xbd\x2e\x2f\x9f\xa5\x2a\x44\xb1\xa2\x32\xa7\x6e\x13\x45\x25\x3d\xd9\x56\xd7\xbc\xa3\x0e\xd1\xe2\xf7\x5b\xc4\x88\xa5\xb1\xd1\xf6\x68\xcc\x6c\xb1\x74\x77\xcb\xa1\xc3\x87\x8f\xc9\x81\x05\x8b\x17\x2f\x90\x83\x6b\x36\x6d\x5a\x73\xa3\xb6\x7d\xab\x9a\x2e\xcd\x51\xf1\x5a\x2d\x63\xb3\xe4\xd1\x29\x29\x45\xe7\x59\x6c\x8c\x56\xcb\xab\x72\x4a\x69\xf5\xd6\x76\xad\xbd\x56\xa7\x32\x9b\xca\xe6\xc4\xc7\xe9\xb8\x55\xef\x49\xdf\xbe\xb7\x6a\x5b\xa0\xd5\x07\x60\x56\xe9\x6a\xa9\x3b\xc5\xa8\xc5\x1f\x8d\x04\x2c\x11\xd1\xd2\xf8\x46\xa3\xe5\x17\x16\x4b\xc4\xb2\x01\x6a\x36\xc8\x11\x87\xa5\x96\xc3\x2f\xca\x11\xad\x7f\x02\xf4\xa7\x56\x39\x6a\x8d\xf4\xa5\xf4\x8a\xf4\x25\xe1\x49\xb7\x12\x9e\xe6\xd4\xf0\x58\x37\x9f\x68\x1b\xc5\x51\x1d\x9a\x48\xf4\xb4\x16\xa1\x15\x68\x1d\xda\x82\x76\xa0\xcb\xd1\x35\xe8\x7a\x74\x94\xd8\xd9\x93\x1d\x15\x5f\xc6\xc5\x19\x77\x74\xfc\xbf\x4c\x37\x6a\x47\xf3\x5f\x85\xff\x9d\xfb\xaf\xce\x07\xac\x30\x17\xdf\x46\x1c\xe5\x1f\xdf\x36\x32\x2e\x7d\xdb\xd9\x29\x7e\x74\x11\x96\x65\xdc\x4d\x1c\xa9\xfb\x1c\x21\x46\x71\xd2\x67\x84\xce\x99\x32\x13\x82\x8e\xf6\xd3\x77\xc0\x8a\x23\xb5\x9f\x1d\x77\x46\x60\x80\xef\x51\xce\x96\xff\x61\xff\xd9\x81\x7e\xc5\xa1\xce\x08\x9d\x2b\xa1\xf2\x9f\xe1\x2e\x63\x07\x58\x34\xcc\x08\xdf\x84\x66\xa3\x95\xe8\x42\xb4\x17\x21\x7b\xa6\xd4\x62\x43\x4a\x99\xc0\xc1\x90\x05\x95\xd2\x5b\x52\xb6\x61\x63\xa9\x18\x91\x55\x93\x5f\x3d\x62\xed\x43\xd6\x1b\xc9\x7c\x6f\xa8\xec\xfd\x4a\x9c\x02\xea\x50\x96\x23\x5d\x76\xbf\xa2\x3b\x27\x0f\x50\x15\xfd\x35\x3b\x63\x1f\xc2\x6e\x66\x22\x94\x79\xff\x17\xe4\x7b\x16\xa0\x05\x83\x08\xee\x27\x01\x7c\x52\x88\xf8\xbc\xf9\x79\xa2\xe1\xe3\xa3\xf2\x4c\xbc\xeb\xb0\x10\xf6\x79\x0a\x02\x3e\x45\x33\x41\x8c\x88\x43\xda\x0d\x69\x92\x1e\x26\x88\x11\x71\x57\xdb\xc2\xdd\x62\x44\x3c\x01\xbe\x13\x70\x15\x19\xcf\x59\xdc\x5c\xc3\x2d\x36\x95\xd1\x14\xb1\x3d\x02\x7e\xb5\x2d\x5b\xab\x2b\x31\x2e\x7c\xd5\xce\x19\x8d\x11\xdb\x9f\x7f\x4a\x16\x1d\x6e\x52\x96\x1e\x4a\x07\xd1\x02\x40\x97\x2b\x01\x54\xbd\xb4\xa5\xac\xd0\x2b\x26\xea\x0b\x8f\x7e\x2c\x46\xc4\xc3\x5d\x55\x8b\xe7\x94\x07\x82\x91\xc5\x71\x45\x45\x45\xce\x53\x46\x18\xe2\x0f\xe4\x14\x82\xf6\x68\xdb\xb5\xab\x4d\x76\x0f\x9c\x38\x71\x8d\x3c\xb4\xb3\x5b\x1e\xda\x6c\x8c\xd8\x6c\x2a\xe3\x95\x97\x92\xa1\xde\xd7\x37\x1b\x23\x36\x3b\x67\xcc\xe0\x70\xa9\x41\xa4\x4a\x67\x70\x16\x2b\xd0\xcf\xc8\x78\x3e\x63\xf9\x4e\x46\xbb\xb1\x78\xcc\x1f\x29\x23\xd6\x35\x19\x71\x45\xb9\xf7\xe1\x89\xe9\x37\x17\x52\x20\xb1\x72\x89\x86\x08\x32\x1f\x8a\x41\x0c\xf8\x15\xa9\x3f\x31\x56\x07\x96\x98\x39\x1e\x73\x82\x7c\x6a\x2c\xa3\x89\xc7\x72\x8a\xd4\xa2\x9f\x10\xf3\x51\xac\x82\x66\x17\x63\xf1\x58\x7c\xe8\xb7\x22\x7e\x65\x8c\x98\x20\x30\x83\xb8\x67\xf8\x40\x38\x13\x5d\x8d\xed\x02\x23\x37\xca\xb4\xaa\x3a\xdb\x94\xf0\x47\x1b\x7d\x1a\x4f\xb9\x3f\x61\xca\xc6\x1b\x87\x7c\xd5\x99\x23\xd2\x5c\x53\x93\x37\x31\x29\x5c\x4e\xe9\xa9\x85\x47\x0a\x4c\x39\x3e\xb3\xcd\x66\xf6\xe5\x98\x0a\x8e\x2c\x64\x8d\xb9\xd2\x87\x7f\xe5\x0d\x05\xa6\x1e\x2d\x6f\x7f\xfd\xa0\xe9\xd0\x05\xf9\xd3\x43\x5c\xfe\x84\xb2\x0b\xf7\x17\xd4\xd1\x4c\x79\xc1\xec\xc6\x60\x74\xe3\x0a\x9f\x83\x3a\x3e\x9c\xc2\xe1\x2d\xcd\xcb\x56\xd2\xd0\x2a\x5f\x7c\x64\x2a\xf3\x7f\x73\x2b\xe0\x73\xc1\x2b\xdf\x0b\x27\x71\xd4\x13\x68\x8c\x56\xba\x55\xf9\x01\x4f\x74\x67\xc6\xc5\x24\x16\xcc\x5e\x87\x29\xdf\x04\xcb\x66\xf9\x1a\x4d\x6a\xb5\xa9\xd1\x37\x6b\x19\xc6\x39\x5b\x39\x2f\x24\x85\x0a\xfd\x16\xd0\xde\x0c\xa6\x65\xd9\x5c\x62\x9a\xa3\x7a\xfc\x6c\x13\x53\x5e\x50\x50\x47\x6b\x4a\x35\x21\x73\xe3\x76\xa9\x57\x4e\x21\x7d\x77\xb3\xf4\xd7\x65\x76\x6f\xbe\x92\x02\xca\x7d\xc3\x29\x7c\xff\xe2\xda\x67\xd8\x1c\x5b\x50\x03\x9a\x86\x16\x22\x04\x0a\x3a\x4a\x74\x0d\xe3\xa4\x42\x76\x45\x9b\x82\x84\xc8\x9b\xc8\xc3\xd0\x7b\xca\x12\xf8\xbf\xf2\x9e\x52\xd1\x48\x10\x40\x18\xb6\xbb\x13\xec\x56\x03\x25\x06\xea\x20\x16\xa2\x5d\xf2\x0b\x22\xbd\x7f\x42\x8c\x88\xbb\x1f\xdd\xdd\x29\xbf\x42\x72\x85\x27\xd2\x26\xbe\x40\x81\xc7\x17\x16\x0e\x77\xc9\x75\xf8\xe8\xc7\x06\x31\x2f\xdf\xeb\x8b\x08\xad\x37\xa7\x9f\xfb\x24\xfd\x94\xce\xa3\xbb\x4b\xa7\x63\x93\x77\xe9\x74\x27\x1d\x13\xeb\x2f\x69\xfd\xad\xde\x83\x7b\x33\xd5\xfd\x40\xa6\xfa\xc3\xa7\xad\x37\xbf\xb9\x59\x0e\x28\xef\x49\x7c\x71\x24\x18\x28\x9f\xb3\xb8\xaa\x8b\x2c\x6b\x1e\x2d\xac\x4f\x88\xde\xc2\xb2\x96\xa5\xd5\x9b\xdf\xbc\x39\xbd\x57\xbe\xac\xee\x2e\x9d\x47\xc7\xb2\x77\xe9\x3c\xfa\x93\xd9\x13\x6f\x5c\xd9\xfa\x5b\xdd\xc8\x35\x7c\x2b\x6a\x21\xaa\x4b\x56\x8e\x07\x85\x67\x3c\xb3\xc7\x13\x0e\xd9\x21\x33\x14\x08\xc8\x43\x79\x79\x48\x80\x89\xed\xbe\x82\x42\xf7\x7a\xa2\x11\xb9\x28\xc8\x1b\x95\x21\x3d\x49\x10\x2e\xf1\x0c\x60\x3c\x7c\x36\x3b\x1a\xb5\x44\xaf\x2d\xd4\x60\x46\x6b\xd5\x8e\x89\x4c\x68\xc8\x15\x72\x4d\xf0\xc5\x34\xbd\x4d\xdf\x7a\x39\xa6\x2a\xbe\xcd\x2a\x69\x3f\x34\xe5\x27\xd7\x65\x03\x6d\xe7\x1b\x4b\x8b\x6c\x79\x4e\x3b\x97\x35\x3e\xdf\x5b\x95\xbd\x62\xde\xcc\x03\xf3\x6d\xac\x85\xa1\xb4\xe7\xaf\x29\x9f\x0e\x14\xa3\x7e\xf4\x0c\xe3\xbc\x74\xce\xb8\xd0\x8b\x21\x2d\x05\x78\x69\xb2\xe5\x3e\x91\x77\x4b\x55\xfc\x85\x8c\x6a\x2a\xb6\x7f\x32\xf6\x24\x6b\xba\xf6\xc9\x45\x07\x6e\x65\xb1\x67\x56\x64\x49\x59\x56\x99\x2b\xdb\x00\x14\x67\xcf\x6b\x98\xe9\x69\x59\xdd\x75\xa0\xd9\x3e\xdf\xae\x63\x6b\xcc\xa0\xc6\x86\x33\xcd\xf4\x10\x46\xfe\x41\xc4\xbc\xc7\x0c\xa2\x6c\xb4\x1c\x21\xc2\x57\xe7\xe1\x58\x6c\xb3\x3a\x71\x38\x64\x4f\xe0\xb8\xdc\x08\x80\x95\xf5\x06\x94\x23\xa4\x14\x29\xaf\x67\x58\x26\xdd\x2a\x57\x20\xb9\x68\xa8\x78\x34\x22\x16\x29\x90\x2e\xa2\xa2\x19\x76\x99\xac\x98\x53\xa8\x81\x9c\x80\xbf\xa4\xf5\x79\x42\x20\xb0\x72\xb5\xc9\x37\xbe\x8c\xce\xd5\x59\x35\xd8\x98\x34\x5a\xf0\xb7\x06\x15\x6b\x6f\x4e\xe6\xdf\xf9\xa8\x81\xd5\xe4\xa9\x84\xf6\x5d\x0f\x75\x5c\x7e\x34\x30\x2f\x26\xde\x0e\xee\x60\xd0\xe5\x76\x95\x36\x47\x8b\xed\x0c\xa7\xd1\x68\xe0\xd3\x53\xe3\x2f\x7c\x6a\x6d\x24\x06\xe7\x37\x31\xd4\xf2\x63\x73\xed\xf9\x96\x6d\xf4\x6f\xb3\xf2\xf2\x0d\xc2\x18\xe9\x9f\x57\x96\xcc\x9a\x56\x06\xc0\xe8\x34\x53\x21\x3a\xb5\x35\x7d\x27\xa7\x07\xca\xa8\x6e\x53\x59\x7c\x7b\xf2\x5b\x8f\xdf\xd0\x7e\xe7\x15\xd1\xd4\xca\x71\xb9\x20\x04\x42\x93\x44\x77\x41\x5d\xdb\xf9\x1d\x45\x6a\x4c\xc1\x77\x9f\xac\xfe\xe4\xb9\x7d\x16\xb5\x74\xc3\x12\xe9\x36\x1f\x55\x95\xd0\x73\xcf\x20\x0a\xc1\x20\x62\x77\x30\xfd\xa8\x16\xcd\x44\x97\x23\x04\xa1\x7c\x79\x4a\x43\x66\xc1\x9c\x1e\x32\x15\xc9\xef\x26\x9a\xaa\xe1\x52\x50\xda\x36\x60\xfc\xc4\x13\x0e\x09\x8c\x10\x52\x0c\xe4\xe4\x09\x12\x27\x94\x61\x6a\x08\xc8\x9e\x0f\x72\x55\xb4\x83\xc5\x6e\x00\xd6\x00\xb1\x32\x10\x49\x3b\xcd\x51\xca\x96\xa2\x1a\x14\xd7\x92\x09\x5b\x04\x27\x49\x14\x8b\x87\xec\x54\x9d\x2b\xe7\xc3\xda\x8a\x03\x05\xda\x49\x6c\x99\x2b\xfd\x37\xa9\x47\x1d\xa8\x8a\x89\x40\x4b\xc9\xc2\x2a\x8c\x6b\x02\xf0\x78\xfa\x9f\x85\x21\x96\xad\xf2\x6b\xe0\x63\xe9\x27\x62\x39\xcb\xc6\xbc\x2c\x0f\xbd\xef\x02\x0d\x82\xc1\xfa\xb8\x97\xcf\xce\xb1\x3d\xfe\x1e\xe3\xfb\x1a\x28\xc8\xd2\xba\xf2\xa7\xe4\x5c\x8d\x59\x70\x99\xa9\x3b\x0c\xb4\xa1\x5c\x17\xef\xc2\x85\x07\xa2\xc9\x0f\x3d\x45\x61\xff\x9f\xb3\x79\x8f\x7b\x6a\x16\x68\xa4\x53\x36\x9b\xdf\xdb\x68\xfd\xdb\x15\x06\x9b\xc7\x3f\xcd\xf4\xec\x72\x95\x33\x0b\x74\xb8\xb2\x30\x50\x49\x2d\x32\x1f\x2c\xa8\xba\x27\x58\x23\x2d\x75\x15\xd3\x95\xae\xca\x02\x7f\x8c\x71\xd5\x14\x06\x22\x90\x64\x92\x85\xde\xd2\x9a\x76\x4d\x9d\xdf\x57\x8a\x3b\xfc\x10\xd4\x5f\x24\xcc\x70\x8b\x2f\x5f\xe4\xc7\x22\xb0\xc0\x40\xfe\xb4\x6c\x41\x9b\x7b\x1d\x30\xb8\x74\x35\xdc\x29\x7d\x3f\x79\xca\x1f\xaa\x73\x63\x89\xb2\x7b\x6a\x8b\x0e\x0a\x7e\xa8\x74\xcf\x10\xec\x46\x97\xd4\x03\x2f\x78\x9b\x2d\xe6\x2c\x8f\xb4\x10\x66\x78\xa7\x99\x2c\x0e\x51\x5a\xfc\x2b\x03\x63\x35\xf6\x15\xd6\x40\x95\xd2\x06\x3a\x39\xc4\x2c\x41\x33\x51\x1b\x5a\x83\xba\x11\xf2\x2b\xe2\x05\xd1\x48\x82\x8d\xc7\xfc\x62\x34\xa2\xd8\x9a\xc4\xc2\x2e\x24\x8f\xed\x15\x13\x6d\x32\x7d\xc7\x84\xf2\xdf\x01\x4a\x30\x00\x2c\x67\x47\x36\xab\xd7\x23\x96\x01\x45\x04\x0b\x2c\x56\xbf\xe0\xb3\x60\x3f\xa1\x69\x40\x72\x8d\xb7\x67\x5a\x52\xd1\xeb\xf1\x07\x04\x98\x8e\xe9\xb9\x77\x54\xd9\x68\x5a\xc3\xf1\xac\x19\x3f\x0a\xba\xb5\xa6\x4d\x3a\xb3\x66\xfb\xc2\x65\xa0\x81\xdf\x5e\x67\xb5\xb6\x0e\x5e\xbf\xd6\xb4\x49\x6b\xd1\x6c\x4f\x4a\x0d\xdc\x98\x42\xea\x87\xaf\xd5\xfa\xea\x2a\x4a\xaa\x0c\x14\x67\xc1\x76\x2d\x7f\x25\xdd\xd5\x57\xe2\xc1\x2e\xee\x67\x54\xa4\x02\x4c\xc7\x7f\x2e\x9d\x1c\x37\xa9\x5d\x5a\x9b\x6b\x9d\xbb\x2d\xb7\x20\xf7\xa1\x8b\xad\x30\x53\xcd\xfd\x1c\x57\xfd\x6c\xa1\x33\xa0\xb6\x1a\xad\x3a\xbb\x4a\xa0\xfa\x37\x3c\xaf\xb7\x68\x92\xc6\xcf\x2d\xd2\x57\x5f\xe6\x37\xe5\x5f\xfd\x51\xf2\x79\xbd\x55\x9d\x34\x7e\xbe\x85\x8a\x70\x59\x02\x23\xc5\xa4\x49\x14\x87\x29\x8e\x9a\x9c\x5b\x50\x9c\x1e\x47\x6b\x4a\xd8\x5f\xc3\x91\x68\x94\x2a\xd1\x49\x8f\x69\xce\x6b\x5d\x07\x66\xb0\x75\x27\xef\x5e\xd8\xf5\x14\xae\x2e\xc8\xdd\x36\xd7\x9a\x9b\x6b\xbd\xf8\x21\x13\xcd\x0d\xe1\xc8\xae\xa7\x25\x66\x25\xca\x47\x65\x44\x2f\x57\x6e\x4d\x15\x78\x29\x69\x04\x04\x96\xcb\xc0\x71\x5d\xf2\xcc\x29\x16\xb7\x07\xac\xd8\x00\x9e\x40\x82\x8e\x46\x02\xf6\x80\x4d\x0c\x38\xc1\xe2\x09\xc8\x43\x03\x1e\x38\xa5\xf9\x95\x1b\x52\x45\x58\x89\x76\x5c\x77\xf0\x8b\x2f\x0f\x5c\x77\xc5\xb7\xd7\x75\xcc\x75\x71\xf5\x53\xef\xfc\xf4\x63\x98\xd9\xe7\xaa\xaf\x2a\x7c\xe5\xe8\x51\x3e\xcf\x3d\x6b\xc7\xa4\x52\x03\x15\x8f\x4f\xbe\xb4\x65\x4d\x7a\xd6\xd4\xf7\x26\x59\x70\xd1\x2f\x57\x79\x3d\x8e\xe0\xba\xea\xf6\x9c\x29\x59\xae\xf5\xf0\xc0\xdb\x47\x7f\xf2\x93\xa3\x6f\x5f\xf7\xcf\x03\xf9\x89\x64\xee\xf7\x77\xdd\xf3\xd5\x57\xf7\xcc\x9f\xaa\xf7\x2d\x69\xec\x95\x4e\x2c\x03\xc6\xb5\xef\xae\xdf\x3d\xd8\x3a\xde\xd3\x73\x1b\x7e\xeb\x93\xea\x41\xe9\xb1\xc6\xad\x3b\xfc\x96\xf6\x6b\xb3\x63\xd5\xfe\xd9\x8e\x12\xa7\x71\xce\x98\x95\x07\xd7\xd4\x4e\x5d\x35\xc4\x8f\x45\xfa\x0e\x07\x2a\x44\x41\xd4\x80\x66\x13\x06\x0f\x02\x1f\x63\x33\x74\x01\x42\x2c\xae\xa8\x24\xbb\x62\x14\x11\xbc\xe2\xec\xd5\x10\x33\xc9\xbd\x45\xc0\xce\x44\x08\xe2\x80\x88\x1c\xca\x4f\x9c\x19\x8a\x8d\xea\x2c\x68\x47\x6e\x61\x89\xfd\xa6\x2f\x6f\xbe\x65\x63\xb4\x94\x16\x6a\xc6\xde\xf4\xdb\xdf\x42\xe4\xb7\x0f\x61\x4d\x7e\x68\x5e\x95\xcd\xa6\xf9\x83\x48\x37\x8f\x59\x08\x97\x84\x0b\x67\x8d\x6f\xce\x9a\x72\x69\x1e\xbd\xaf\x21\x32\x26\x3c\xcd\x66\x82\xc9\x23\x3b\x07\xf8\xeb\xb4\xf1\xd9\xea\x50\x72\xf3\xb1\x63\x9b\x37\xde\x6d\x29\x2e\xb1\xbd\x2b\xbd\xfc\xc6\x9b\x90\xce\x2a\xab\xdb\x7a\xed\xc6\xc5\x76\x6a\x0f\x18\x37\xad\x69\x7e\x24\x70\x4b\xe1\x79\x93\xe6\x0a\x96\xf1\x63\x0b\xfc\xa6\x65\x63\x23\x5b\xc4\xc8\x94\x68\xd1\x37\x67\xf5\x09\x43\xcf\x3f\x9d\xe0\xe6\x22\x43\xef\x10\x56\x46\xe8\x5e\x4f\x20\x96\xe9\x16\x39\x56\x01\x0c\x28\x3f\x3f\x31\x10\x64\x49\x9c\xdc\x7b\x10\xa9\xe0\x70\x88\x60\xab\x48\xd7\x79\xe6\x76\xef\xa0\x7d\xdc\x79\x79\x5c\xa0\x2c\xe0\xb7\xea\x0a\xb4\xb4\x8a\x31\xf9\x2e\x9b\xf3\x42\x93\x89\xa1\x35\xba\x02\x8d\xcd\x1b\x28\x0b\x70\xc9\xcb\xec\x57\x62\x95\xc1\xa8\x0b\xf3\xde\x64\xc9\xc4\xc2\xe2\x49\xc5\x49\x2f\x1f\xd6\x1b\x79\x15\xbe\x12\x60\xf4\x6a\xd8\x6e\x3b\x63\x68\x49\x5a\x58\x83\x5d\x97\x67\xb7\x64\x1b\xf1\x22\xcb\x74\xef\xb4\x79\x77\x78\xa7\x5b\x16\x61\x43\x96\xd5\x96\xa7\xb3\x1b\x58\xcb\x55\x79\x8c\x3d\x68\x67\x8a\x2c\x6a\xa7\xd7\xe9\xf4\x3a\x55\xd6\x02\xc6\x0e\xfd\xa3\xd7\xc1\x00\x19\x06\x53\xec\x7a\x26\x45\x4a\x21\xa6\xe8\x80\x29\x40\x26\xa2\x3b\x48\x08\xb8\x84\x8c\x3c\x18\x56\x70\x4d\x19\x7b\x26\xa5\x98\x94\x62\x53\xaa\x7a\x2c\x1a\x09\x62\x85\x68\x22\x1c\xca\x88\x97\x53\xcd\x97\xbd\x59\x95\xa3\xe6\x79\x73\xbd\x39\x2f\x56\xd7\x58\xa7\xf3\xef\x9a\x9e\x1b\xc9\xfd\x03\xa7\xb2\x0a\xd6\xd9\x76\x7f\xb6\x2b\x11\x4b\x2c\x88\x45\xe6\xd7\xc6\x12\xf9\x0e\x7f\xd6\x2c\x53\xb6\x55\xc5\xfd\x21\x37\x92\x3b\xed\x52\x9f\xae\xae\xa9\x2e\x92\x67\xa8\xb7\x9a\x79\x75\x4e\xf2\x1d\x26\x05\x7b\x2e\x1c\x73\x41\xd9\x7e\x2e\xc7\x97\xeb\x2a\xb1\x04\x72\x0d\xb9\x33\xaf\x70\xeb\xb4\x6c\xde\x04\xb7\xb6\xd2\xaf\x67\x18\x6f\x61\x41\x4e\x4e\x41\xa1\x97\x61\x0c\xfe\x31\x5a\xf7\x84\x3c\x56\xab\x73\x5d\x35\x23\xd7\x90\x1b\xb0\x16\xe7\xe7\xf8\x1d\xdc\xd5\xe5\xdb\xc6\x5c\xb9\x6d\x54\x1d\x58\xf4\x7f\x5a\x07\x46\x33\x18\x30\x48\xa9\x07\xc1\x80\xdf\xaa\x2d\xd0\x91\x7a\x70\xe9\xdc\xe7\xa7\x9a\x59\x0d\xa3\x2d\xd4\x58\xbd\x81\x20\xa9\x07\x57\x61\x15\x6f\xd4\x87\xf5\xde\xb1\x4a\x3d\x18\xeb\xd5\x47\xf4\x06\x83\x0a\xae\x02\x74\xc6\xcb\xb0\xdb\xce\xf0\x2d\x63\x79\xed\x70\x25\xa8\x8b\x4c\xf3\x4d\x9b\x77\x87\x38\x55\x6c\xc2\xc6\x6c\xa5\x12\x68\x79\xb9\x12\x94\xc9\x95\x40\xa3\x54\x02\xb5\xa5\x98\xb2\x53\xda\x51\xef\x02\x28\x98\x44\x16\x91\x56\x8f\x67\x94\xe1\x0f\xc7\x72\x3e\x86\xe5\x12\x50\x07\x09\x2a\x1e\x63\xc8\xfc\x89\x62\x03\xc4\x02\x98\x0d\xe2\x32\x88\x44\x23\xe1\x50\xdc\x8c\xc2\x21\x27\x23\xc4\x13\x74\x3c\x41\xa9\xd1\xf8\xee\xfa\xa8\xdd\x4e\x69\xc2\x82\x61\xc2\xd8\x66\x55\x59\xa7\x74\xaf\xf4\xd1\xc2\xdf\x97\x4d\x33\x1a\x26\x3e\x3a\xeb\xd2\xa6\xc7\x41\x00\xb5\x96\x65\x9f\x33\xb8\x52\x9f\x1c\x90\xd0\x15\x33\x2f\x6b\x2e\xd2\x01\x7b\xd5\xc9\x5e\x58\xf3\x12\x63\xa9\x8a\x4e\xa8\x8c\xf0\xe7\x61\x31\x3c\x71\x71\xa4\x7e\xfb\x96\x7a\x16\x05\x17\x4e\x98\x5c\x54\xc6\x9a\xbf\x0a\xe6\xd5\x89\x25\x6c\xfe\x8b\xfc\x7d\xd1\x8b\x8d\x4e\x8e\xcb\x69\x74\xf9\xf5\xf9\x22\xc5\xda\xb5\xd2\x9d\x79\x5c\xd6\x7c\x0c\xb9\x41\x8f\x09\x00\xd8\x38\xac\x85\x1a\x50\x1b\x3c\xa5\x93\x83\xc7\xe9\xa9\x1d\x17\xee\x1f\x3b\x73\xcb\x14\xf7\x08\x1e\xac\x09\xa8\x05\xb5\xa3\x65\x04\xdb\x66\xe5\x02\x02\x3b\xf2\xe3\x09\xc4\x39\x71\xe4\x27\x1a\x89\x0b\x81\xd8\xc8\x4f\x38\x24\x70\x71\xfb\x19\x9f\x08\xf6\x79\xc9\xe4\x43\xae\x0e\x3e\xb3\x85\xe0\xb2\x4d\x0a\x3c\x9b\x7c\x31\x45\xcc\x5f\xfa\x2c\x81\xb7\x8e\x97\xd4\x1d\x59\x51\x3b\x7d\x3a\x2f\x36\x89\xfc\xb4\x29\xf5\x2b\x8e\x54\x57\x3c\xf4\x56\xc0\xd2\xf7\x15\xc3\x7c\xfd\xb1\x9c\x20\x58\x7b\xeb\x8a\x71\x93\xa7\xea\x7d\x01\x51\x49\x71\x6b\x6d\xf0\xf8\x9b\x7e\x5b\xdf\x57\x8c\xf3\x88\xf4\xf7\x5b\xb7\xbc\x73\x64\xe1\xc2\x23\xef\x6c\xb9\x15\xf4\x47\x26\xa7\xd7\xa5\xd7\xe1\x6b\xf1\xaf\xd2\x35\xe9\x1a\xe6\x57\x69\xa2\x5f\x80\x53\xa5\xf9\xfc\xb4\xc9\x0d\x2b\x6e\xad\x2d\x7b\xe8\x6d\xbf\xfd\xb3\x6f\x58\xf6\xeb\x4f\x2c\x05\x6f\x3f\x54\x3c\xf6\xd6\xce\xf1\x93\xa6\xf3\x45\x1e\x6f\x11\x3f\x7d\xf2\xb8\xce\xa3\x72\x8a\x80\xa5\xef\x2f\x2c\xfb\xd5\xc7\x96\x82\xb7\x1e\x2a\xab\x3d\xda\x99\x98\x3e\x8d\xcf\x0f\xf6\x80\xe1\x48\xdb\x91\xf7\xb6\x6e\x79\xef\x48\xdb\x11\x30\x60\x67\x1a\x4b\x97\xc0\x0e\x2c\xc1\x8e\x1f\x7f\x03\xb7\x50\x71\xb8\x59\x5a\x3e\xf0\x12\xd5\x3a\x90\x92\x92\xd0\x4b\xa5\xa0\x77\x18\x67\x49\x6c\x89\x0a\x51\x0c\x21\x70\x73\x19\x3c\x8c\x60\x0f\x0f\x91\x29\xfb\xc3\xc0\xb3\x5c\x34\x46\x16\x22\x21\x6c\x01\x93\x3b\x16\x77\x9b\x22\x62\x20\xee\x04\x98\x85\xff\xcb\x91\x5e\xb1\xf6\xc8\x05\x6d\x42\x63\xe9\xde\x17\x5e\xa0\x3e\xfa\xa7\xe4\x14\xbc\xf1\x68\xd3\xac\xd5\x89\x63\x55\x56\xab\xf4\xe9\x67\x4f\x50\x73\x07\x3e\xf7\xab\xf0\x4f\x97\x36\x67\x2f\xbf\x88\x11\x27\xdd\xba\x76\x20\xbd\xe8\x90\x85\x99\xf4\xe2\x5e\x8a\xda\xfb\xe2\x7b\xa7\xbe\xad\x9d\xb3\xae\x69\x46\x85\x1b\xff\xd2\x71\x4b\x24\x1a\x8b\xe0\x0f\xd2\x8f\xc0\xb7\xfd\x77\xc7\xcd\x34\x3f\x67\x6f\xde\x38\xcf\x7f\xa1\x21\xae\xf7\x0c\x96\xcf\x8a\xdc\xa8\x14\x55\xa1\x56\xb4\x16\x6d\x45\xfb\xd1\x1f\x4f\x5b\x1b\x50\xd1\x88\x98\x61\x1f\x0c\xc5\xe2\xe7\x0e\x9c\xe9\x07\x36\x43\x93\x1d\x67\x6d\x56\xb3\x30\xcc\x2c\x37\x44\x35\x6a\x0e\xc8\x13\x32\x56\x9e\x84\xc5\x15\x46\xb5\x78\x4c\xe1\xa7\x23\x67\x67\x40\x7c\x43\x47\x48\x8b\xcc\x25\x80\xb1\x62\x8e\xa5\x0d\x43\xaa\x57\xc4\x8e\x3d\x40\x66\x24\xa4\xc5\x8a\x8b\x01\xd2\xfa\x92\x96\x8c\x22\x9d\xb8\x3c\xa3\xc3\xca\x68\x9d\x4c\xea\xe4\x86\x9d\x50\x52\x72\x76\x25\x82\x9a\xed\xa9\xf4\x78\x2a\x77\x16\xd6\x14\x14\xe6\x39\x0b\xef\x2b\xa8\x29\x2c\x74\xe6\x15\x3e\x50\x58\x53\x58\x58\x33\xe4\x80\x6e\xb6\xf4\xce\x83\x17\xbe\xb9\x7f\xa6\xad\x73\xe7\x56\x67\x6d\xa5\xd3\x15\xaf\x74\xba\xd6\xba\x9c\x95\xb9\x15\xfa\xee\x9d\x57\x4f\x32\x39\x17\xc5\x3e\x71\xce\x7a\xe8\xc0\xba\xa5\x7a\x69\x42\x72\x49\xb2\x6e\x59\x1d\xde\xdc\x78\xfd\x92\xa9\xfb\xe3\xe5\xad\xe7\x45\xe7\xfb\x4c\xe1\x28\xdd\x38\x07\x84\x71\x35\x63\xa4\xaf\x5b\xe9\xea\xe2\xcc\x05\xe2\x2e\x67\x65\x59\xe5\x82\xd5\xe7\xb7\xc5\x22\xeb\xc7\xbb\x02\xf3\x1b\x7b\xcb\xb3\xcc\xa5\x63\x57\xd7\x57\xdb\x2d\x02\xb6\x52\x1a\x47\x96\x71\xde\x8f\x57\x78\x73\xaa\xe7\xcd\xaa\x62\x74\x7a\x0b\x98\x44\xe3\x91\x82\x6c\x6f\x69\x7c\x01\xfd\xe5\x98\xb2\xb2\x31\x65\xa7\x66\x6f\x70\x16\x17\x3b\x37\x38\x4b\x4a\x9c\xff\xad\x0f\xbf\xdc\xf3\xc2\x8a\x7b\xfb\xb6\xb6\xcc\x7d\xf0\xed\xdb\xa4\x37\x96\x57\x85\xc8\x5f\x7e\x76\x3b\x58\xfe\xab\x91\xb5\xfc\x7d\xee\xf9\x3b\x0e\x1e\xfe\x60\x42\x39\x7e\x28\x34\x7d\x7a\x28\x3c\x7d\xba\xd4\xd7\xf1\xd3\xd5\x13\xaa\x8f\xae\xe9\xec\xb2\xb0\x95\x11\x87\xb5\xe1\x97\x1b\xd6\x49\x7f\xae\x4f\x1e\x71\xc0\x86\xe2\xa4\x72\xfe\xb8\xf2\x86\x66\xb0\xe4\x77\x70\xc1\xde\x0d\x95\x9d\x55\x57\xde\x72\xf1\xec\x48\x5e\x36\x65\x65\x0d\x41\xd1\xba\x6e\x37\x9d\xac\x62\x38\xc6\x64\xb0\x00\x9b\xa5\x63\x2d\x57\x7d\xe3\xac\x68\x1e\x39\x87\xcf\x46\x7e\x82\x12\x88\x04\xdc\xb6\xf0\x30\x80\x56\xc8\x8c\xc0\xc2\xa1\x98\x3f\x1c\xf5\x46\xbd\x36\xaf\x2d\x6c\x0b\x9f\xb1\xe7\x76\x88\x95\x0e\xbf\xab\xbb\xa8\x79\xe9\xde\xbd\x4b\xdb\x6a\x3a\x57\x1f\xea\xe9\xeb\xeb\xb9\xe3\x37\x30\x7f\xcd\x9a\xb5\x6b\xd7\xae\x05\xf3\xa8\x21\x04\xde\xe2\xce\xdf\xdd\x34\xff\x9a\xe7\xaf\xa9\x5e\xbe\xec\x63\xe9\xb9\x8f\x7f\xb7\x65\x2d\x49\x78\xfe\xe8\xd1\x81\xdc\x37\xf8\x33\xed\x65\x80\xa8\xd4\xc9\xb5\xd5\xe7\xf5\x70\x26\xaf\x29\x98\x21\x09\xb4\xb2\x04\xfd\x4c\x16\xde\x14\x16\x4b\x16\x55\x3c\x70\xfb\x64\xe9\xd3\x39\xb7\x9f\xe8\xa9\x6b\x4a\x3d\x9c\x6a\xaa\x7b\xfa\xc6\xa5\x4b\xf9\x5f\x46\xa6\xb6\x68\xaf\xb2\x3a\x44\x1a\x0d\x3c\x56\xce\x47\xaa\xcb\xa5\x07\x98\x96\xec\xee\x86\xd6\x54\xaa\xb5\xa1\x3b\xbb\xa1\xc4\x80\x0b\xcd\x58\x14\x95\xf1\xe9\x0c\xa2\xd3\xc1\xa0\x2a\x34\x17\x2d\x44\x07\x11\x32\x87\x62\xa2\x87\x65\x82\x4c\x40\x11\x89\xab\x83\x20\x66\xbd\x1e\x03\x78\x4d\xa1\x98\x93\x12\xc8\xe6\xb7\x3d\x16\xb7\xc7\x13\x10\x20\x5d\xb1\x28\x84\x4d\xde\x80\x58\x0c\x1e\x03\xb0\xf2\x50\xa6\x0e\x62\x4e\xe0\x9c\x8a\x7a\x19\x4d\xae\xa7\x74\xd6\xca\xc2\x09\x0f\x01\x1e\x82\x10\x80\xe1\xce\x3b\xc1\x56\x43\x48\x88\x55\x43\xc8\xc9\x0a\xee\x90\xfd\x86\x66\x97\xab\xd9\xc5\xaa\x35\x55\x8e\x90\x37\x68\xbf\x68\x56\x7f\x73\x15\x8c\x39\x6e\x1f\xe3\x6f\xd2\x2e\xac\xbf\xf5\x66\xc6\xa5\xcb\xe1\x6d\x2a\x28\xdc\xd8\x3d\xad\xac\x6a\x9d\x69\x4a\xd4\xea\xc2\x1a\x77\x71\x43\x3e\xb7\xbb\xa3\xed\x48\xfd\x8a\x3b\xe7\x57\xbd\x9e\x9b\x53\x7c\x59\xc9\xb3\xd9\x55\x7e\x8d\xb1\xd9\x9a\xb7\x4a\x1b\x01\x44\x2e\x0b\x2a\xd1\x21\x4d\xcb\x59\x3b\xc1\xbd\x28\x5e\x74\x51\x7d\xcd\xee\x0b\xd7\x95\x4b\x1f\x4b\x37\x11\x60\xd6\x1d\x7c\x7d\x5e\x75\x51\x4d\xd2\xb7\x79\xe9\xcc\x99\x4b\xef\xf4\x26\x2b\x62\xde\x70\x4e\x9c\x87\xa5\x0e\x11\x52\xc9\x64\x92\xd5\x4f\xf1\x24\x8b\x22\xc2\xde\x76\xba\x63\xfc\x43\x0d\x27\xb4\x5a\xc0\xf5\xb7\xa6\xfb\x00\x28\x56\xab\x92\xde\x5f\x57\x66\xad\xac\x62\x43\xe6\xb8\xa0\x29\x4a\x4e\xcf\xc2\xe8\xe7\x4d\xe3\xfe\xee\x9e\xed\x0e\xe3\xd0\x7b\x02\x15\xce\xb7\xb4\x64\xf9\xf6\x18\xea\xa7\x24\x93\x49\x8c\xd2\x29\x87\x38\x76\x96\xa6\x7c\x9c\x2e\x5a\x45\x7b\xb4\x81\x86\x32\x70\x88\x0e\xdc\xe3\x10\xf9\x86\xdc\x88\x90\xab\xad\xac\xd4\x99\x7c\x8e\x68\xfe\x58\xe3\xff\x47\xdd\x9b\x80\xc7\x51\x1c\x8b\xe3\x5d\xdd\x73\xec\x7d\x1f\x3a\x57\xf7\xae\x25\x4b\x2b\x69\x4f\xc9\x58\x92\x75\x1a\x7c\xca\x27\x60\xb0\xe5\xd5\xee\xac\xb4\xd6\x6a\x77\xbd\x87\x65\x39\x1c\x02\xc7\x98\x23\x98\x9b\x70\x63\xc2\xe9\x10\x5e\x42\x20\x10\x6e\x43\x12\x20\x24\x24\x0e\xf7\x83\x84\x00\x21\xc9\xcb\x05\x4e\x42\xf2\x02\x58\xe3\xff\xd7\x33\x23\x59\xb2\x4d\x92\xf7\x7e\xdf\xef\xfb\xfe\x3f\x83\xba\xab\x7b\xa6\xba\xba\xab\x6a\xab\x7b\x66\xaa\xbb\xdc\xf3\x7c\x2e\xea\xa4\x55\xc4\xb1\x05\x50\xb8\x93\x0b\x77\x12\x9f\x0b\x3b\x5d\x9c\xd3\x01\xb5\xb2\x77\x02\xf0\x1c\x6f\x20\xd5\x5e\x2c\x79\x66\xc8\x4e\x0c\xac\x8b\xf1\x75\x12\x1e\x6d\xe9\xf9\x6c\x49\xcf\x16\xad\xaa\xd3\x3e\x30\xb0\xeb\xee\x14\x3b\xd4\x32\xb8\x68\xd0\x77\x36\x97\xba\x7b\xd7\xc0\x80\xbd\x53\xa5\x9d\xfe\x31\xf0\x6b\xb5\x44\xe5\x56\x95\x68\x7f\x9b\x61\xb7\xb4\x0e\x2e\x1a\x6c\xdd\xc2\x3e\x7e\xab\xb6\x44\xe5\x56\x11\xed\x5a\xe0\x35\x83\xbe\x55\x2b\x97\xad\x5c\xd3\xb2\x96\x64\x8f\x78\xa5\x90\x2c\xaf\x18\xd5\x7c\xd8\xbc\x28\xb8\x79\x72\x90\x39\xb5\xaa\xae\xae\x7a\x80\x1d\x9c\xdc\x1c\x5c\x64\x0e\xf3\xea\xe9\xfb\x9e\xe9\x50\x15\x6b\x03\x5a\xa2\x3a\xb0\x86\xd0\xab\x55\xa7\x92\x8b\xf2\x2a\xa2\x0d\x68\x8b\x55\x1d\xcf\xa8\x16\x57\x37\x39\x1c\xcd\x95\x5d\xf3\xfd\x1e\x5b\xd1\x20\x7d\x02\x07\xe5\x0c\x18\x03\x59\x88\xe9\x90\xa4\x93\x2c\x94\x88\x80\x2e\x72\x0a\xf6\x75\xe2\x70\x6d\x38\xe4\xb0\x9a\xdd\x1e\x77\x9d\x97\xde\x25\x7d\x6a\xe7\x39\xfe\xc4\x08\x04\xe1\x10\x0a\x77\x52\x24\xca\x31\xec\x74\xb0\xcf\x79\x54\x44\xb3\xf0\xde\xf3\x18\x4f\xc3\xea\x65\x75\x00\x75\xcb\x56\x35\xba\xd9\x9d\xf7\x7a\xb4\x44\x55\xa7\x2a\xd5\x6e\x79\x8d\x5d\xd9\xd8\x5f\x04\x50\xd4\xdf\xb8\x92\x05\x1c\xd6\x96\x3c\xbf\xa9\xff\x2c\xf1\x0d\x32\xd8\x30\x40\xab\x07\x1a\x06\xc9\x9b\x3f\x5c\x14\x34\xf0\x56\x3d\x2b\x47\x1b\xa0\x0c\xae\xff\x12\x3c\xcf\xd5\x7a\x57\x2e\xa7\x6d\x2e\x5f\xe9\xad\x5d\xf8\xc1\x07\x67\xd4\xe3\xb4\x5f\x5b\xac\xaa\xbe\x20\x42\x2a\x2b\x7d\x4e\xa7\xaf\xaa\x82\xd9\x7c\x81\x4b\xe2\x0d\xa3\x3e\xed\x4e\xa6\xb3\xa2\xba\xba\xa2\x93\x79\xbe\x51\x45\xa6\xdd\x64\xff\xba\xb6\x65\xbf\xc1\x3d\xae\x9a\x1a\x57\x0f\xbe\xe7\xf6\x56\x9f\x8e\x3f\xb2\x55\x6f\xb5\x92\x07\x8e\x48\xbb\x69\xc9\xfe\x36\x77\x16\x22\xac\xab\xa6\xb5\xa8\xa8\xb5\xc6\x55\xfb\x8d\x47\xd6\x52\x75\x41\x5a\x64\x3f\x8a\xd8\x3f\xcc\xd9\xdf\x51\x82\x5c\xa8\x1a\xb9\x91\x17\xf9\xd0\x0e\x84\xea\x9c\xcd\x00\x75\x1e\x16\x9c\xc4\x03\x75\x84\x05\x67\x33\xd8\x1c\x9c\x11\x9c\x0e\x60\x49\x1d\x84\x79\xa7\x54\x1d\xf6\xf0\x92\x1f\x46\xd8\x88\x3d\xbc\xcd\x08\x5c\x33\x38\xa5\x9d\x0a\xee\xa0\xc7\x4d\xdc\x5d\xe0\xf6\xcc\xa4\xe1\x3a\x9f\x93\x75\xd8\xad\xd2\x46\x6f\xbb\x33\x1c\xaa\x80\x70\xa0\x0b\xa4\xa3\x36\xe8\x83\xac\x11\x38\x58\xf6\x52\xf5\x5b\x60\x01\x8b\x56\x7c\x4d\xfc\xe8\x57\x2d\x7f\x83\xc5\xd0\x61\x10\xf7\xc3\xe5\x43\x78\x04\x63\x66\xd5\x06\x7e\xba\x0b\x50\x9f\xf8\x3b\x26\x6e\xfc\x0d\x9e\x7e\x1f\x0a\x56\xf1\x4c\x72\x93\xed\x03\x7c\x25\x87\x79\xc0\xae\x87\x6c\xd6\xa5\x2a\xe6\xf7\x3c\x3f\xcc\x33\xe2\x3b\x0c\x56\x7d\xc8\x84\x31\xdf\xb1\x05\x4e\xc5\xaa\x2d\x7b\xf0\x56\xac\x86\x07\x59\x02\x1d\x9c\x8d\xdb\x71\x1e\xcb\x4e\xb2\xdc\x7a\xc2\xfe\x84\x63\xff\xc6\x60\xa3\x8d\x79\x86\x83\x37\xfe\xf8\xba\xe8\x7f\xfb\x6f\x6f\xc2\x45\xaf\xc3\xd2\x1f\x4f\x7f\xf0\x06\xf4\xbd\x28\xde\x39\xf8\xf1\x6a\x30\xaa\x49\x60\x80\xc3\xb7\xbd\x08\x3f\x7b\xe0\xf3\x87\x7e\x7f\xd7\x61\xbc\xfd\x39\x78\xec\xce\x23\x4f\xfc\x6e\x5f\x62\x88\x61\x27\xce\x7e\x77\xea\xc3\xaa\xd6\x02\x4b\x9e\x60\xd9\x75\x77\xb0\xe4\xf7\x18\xc3\x5f\x18\x30\xf3\x4c\xdd\x46\x0e\x86\x78\xb6\x29\xa6\x82\x57\x34\x64\x2f\xdc\xc8\xb0\x62\x2b\x4f\x3a\x36\x60\xee\x4b\xcb\x18\xa6\x2d\xc5\x91\xf3\x08\xd9\xcb\x70\xd9\xbd\x84\xc5\x37\xb2\x73\xd7\x70\xe5\xc8\x83\x36\x48\x6f\x4d\x49\x8d\x81\xa1\x0f\x7e\xd5\xf2\xdb\xd0\x2a\x5f\x88\x1c\x5b\xac\xd8\x95\x23\x12\xe6\xc7\xdc\x3a\x76\x78\xc2\x3c\x88\x79\x50\x5b\xd1\x32\xe8\xe7\xc2\x2e\x7f\xb3\xb7\xd9\xef\x0a\x73\xfe\xc1\x96\x0a\xed\xfa\x0e\xbc\xa4\x63\xfd\x03\x37\xbe\x71\xe3\x8d\x6f\xdc\x88\xcf\xb1\x18\xb6\x6e\xe9\xf9\x7c\x89\x14\x31\xe3\x60\xcf\x16\x39\x2e\xd8\x6c\x0a\x0d\xed\x31\x61\x69\x13\x53\x65\x2a\xd2\x68\x8a\x4c\x55\x4c\xd3\x52\x21\xd6\x7e\x5a\x24\x82\x6f\x4e\xde\x70\x43\x72\xec\x86\x1b\xc4\xd5\x07\x0d\x96\xf7\x28\x3a\x2b\x85\xdd\x78\x4f\xf2\xf4\x9e\x52\x52\xe5\x7b\x82\x34\x46\x35\x5a\x88\xce\x44\x09\x69\xff\x9c\xe2\x05\x42\x7c\x2e\x66\x66\x38\x81\x4e\x72\x0a\xb8\x58\x5f\x27\x73\x92\xb1\xcc\x1e\x0e\x71\xc2\xc8\xed\x27\xc4\x68\x63\xe4\xa1\xb5\x78\x4f\x6b\xae\x34\xf1\xab\x7b\xa6\x0f\xf6\xac\x56\x97\x35\xad\x09\xb2\xbc\xcf\xde\x54\x5e\xef\xae\x2f\x6f\xb2\xfb\xf0\x43\x56\xfd\x56\x29\x80\xb2\x92\xce\xe3\x82\xde\x7a\x14\x59\xf5\x9f\x4b\x51\x45\x98\x83\x7a\x2b\x39\x67\xec\x86\x1b\xc6\x92\x37\xdc\x20\x7e\xb7\xba\xe3\xb4\x33\x57\xd4\xf7\x8e\x8c\xf4\xb6\x9c\xb5\x6d\x65\x80\xa9\xd0\x3a\xd5\x6a\xb5\xda\xa9\xad\x00\x46\x6f\x9d\x92\x22\x33\xcb\xe9\x5c\xae\xd0\xc6\x58\xe9\x68\x9f\xcf\x68\xa3\x4a\x9c\x1c\x95\xbc\x26\xa9\x42\xad\xa8\x1b\xad\x41\x05\x84\x50\xc0\x8b\x67\x35\x00\x4b\x23\xc2\x33\xc1\xb2\x95\x70\x29\x33\xe7\x71\x9b\xff\x45\x59\x9e\x1e\x82\xf2\xa1\x01\xd2\x56\xb7\x19\x68\xce\x9b\x23\x64\xa9\x1f\x6c\xe7\x5a\x4a\x1b\x1b\x1a\x1a\x1a\x4b\x5b\xb8\xf6\xc1\x7a\xcb\xb2\x10\x46\xa1\x75\x7b\x9e\xdc\xb3\xe7\x49\xa6\x7a\xae\x2b\xbd\xdd\x38\xfd\xa2\xd1\x6e\x37\xe2\x36\xa3\x7d\x9e\x8b\x3d\xda\xd2\x23\xee\x9f\x7b\x00\x87\x28\x85\x66\xe1\x0e\xf6\x6c\x81\x0d\x53\x63\xd1\x76\xa6\xcc\x68\x53\xab\x6d\xc6\x32\xa6\x3d\x3a\x36\xb5\x01\x77\xd1\xc6\xf7\x88\xbf\x99\x3d\x80\x02\x2c\x6d\xb4\x65\x9a\x80\xf6\x58\xed\x2a\x2a\x93\xb9\x3a\x29\xcb\x67\x8b\x1c\x1b\xf0\x44\xfe\xed\x91\x9e\x24\xa8\x92\x04\x3a\xb1\x5f\x9a\xea\xc2\x3e\x17\xe0\x99\xef\xc9\xc7\x9d\xc7\x11\xfc\x17\x65\xeb\x3c\xdd\x3a\xc9\x11\x0b\x27\x89\x6b\xc3\xa0\x65\x21\x11\x85\x96\x9d\xc8\xd8\xcb\xfe\x07\x2c\x9d\xb2\xea\x3f\x5d\x22\xc7\xfa\x9e\x7b\x3e\x03\x6c\x95\x66\x96\x4f\x97\xcc\xb2\xf7\xf5\xa9\x0d\x27\x70\x18\x9e\x90\xd8\x3b\xbd\x75\x96\x91\x1f\xcd\x72\xf7\x6f\xb3\x75\x47\x7c\x8c\xa4\x90\x54\xcb\xe7\xb2\xd8\xca\xbc\x7c\xec\x97\xb0\x05\x1d\x17\xdb\xc7\x89\x16\x20\x54\x27\x1d\x42\x5a\x2d\x07\xc9\x95\xd6\xc8\xf2\xa1\x92\xc8\x34\x73\x32\xe3\x8c\x8b\xe3\x5f\x1d\xbb\x27\x7a\x1f\xfb\xc9\x63\xbd\x13\xbb\x1d\xdb\x60\x19\x9c\x07\xcb\x2e\x51\xbc\x8d\xf1\xfb\xfb\x3e\x16\x1f\x7e\xf4\x91\x79\x0e\x83\x3f\xb8\xf9\x65\xd3\xb2\x75\xeb\x96\x99\x5e\xbe\xf9\xfa\x6f\x7e\x13\x7f\x5b\x8e\x06\xfe\x3e\x84\xc4\x6b\xc5\xef\xfc\xf9\x38\xc7\xc2\x63\xfd\x32\xa1\x5a\xd4\x28\xed\xd5\x70\x58\xec\xb6\x63\x6e\x96\x10\x0a\x06\x94\xc3\x03\xed\x36\xa7\xc5\xef\xa8\x0c\xfb\xdc\x4a\x67\xf1\x4b\x72\x4b\x97\x1f\x16\x1f\x16\xaf\x16\x1f\xfe\x78\xdf\xbe\xc3\xcc\xf8\x75\xc7\xdc\x1a\xaf\xeb\x39\xbc\x1b\x92\xbb\x0f\x1f\x50\x3a\xcc\xa1\x7d\x87\xc5\x87\x1f\xf9\x8e\xf8\xf0\xe1\x2b\xf6\xfd\x19\x96\x4b\xe8\x9f\x2f\x7d\xf9\xb3\x5b\x64\x5f\x4b\xf1\xc3\x5b\x3e\x7b\x19\x96\x4e\x4d\xdd\xa1\xf4\x7a\x7e\x3c\x96\x0a\x79\xb7\x0d\xcc\x33\x79\xe1\x19\x07\x06\xbb\x0d\x49\xbd\x0a\x99\xac\x3e\xda\x69\x0f\x57\xe9\xe1\xa4\xaf\x88\xcc\x83\xcd\x1b\x36\xf7\x34\xbe\x78\xf9\x91\xaf\x5f\xfe\x62\x63\xcf\xe6\x0d\xcd\xab\xd7\x5c\xfa\xd4\xa1\xa7\x2e\x5d\x23\xde\xae\xf8\x62\x2f\x3c\xe3\xdc\x5b\xaf\xb9\x4a\xbc\xf0\xaa\x6b\x6e\x3d\xf7\x0c\x7c\xd8\xd0\x32\xbc\xe7\xd5\xdd\x37\xbd\xf3\xce\x4d\xbb\x5f\xdd\x33\xdc\x62\x38\xf7\x9a\xd1\xa7\x2e\x5d\xb3\xe6\xd2\xa7\x46\xaf\xc1\x56\x65\x30\x9f\xbd\x7f\x45\xfc\x63\xb0\xf1\xe7\x9f\xcf\x8b\x7f\xfc\x38\x7e\xc5\xec\x79\xd3\xac\x7c\xde\x42\x31\xaa\x41\x1d\xf3\x7e\x4d\x0e\xdf\xbc\x9f\x92\xb9\xea\xa4\x81\x9d\x66\xa3\x69\xce\xfb\x29\xac\x69\x1b\x7c\x6b\xb0\x6d\x4d\xfd\xc5\x7b\x9f\xde\xbb\xf7\x69\xb8\xe3\x08\xb2\xea\x89\xbc\x4a\x3a\x22\xe9\x1a\x55\xf3\x83\x54\xbf\x7b\xb6\xc0\xc6\xa9\x8d\x1b\xa7\x92\xb1\xf6\xe5\xcb\xdb\x63\xf0\x98\xa4\xca\x9f\xef\x67\xb7\x7e\xb6\x5f\x6f\xb5\xb2\x2f\x7f\xb6\x64\xc6\xac\x2a\x16\x01\x21\xd5\xac\x2d\xb0\xa2\x52\xb4\x10\x9d\x82\x96\xa3\xb3\x90\x40\xed\xa9\xf4\x1d\x92\xab\xf6\xc8\x9f\xab\x69\x77\xbf\xc8\x9c\x1e\x5f\xae\x9b\xb5\x97\xf2\x88\x4e\x30\xaf\xb3\x51\xe3\xab\x8e\xff\x76\x3b\x65\xac\xee\x6b\x5e\xf2\xdd\x25\xcd\x7d\xd5\xc6\xae\x46\xf8\x7a\x63\xd7\x94\xe4\x0a\xc3\x64\x2c\x86\x69\x39\xd0\xe5\x41\x83\x45\x9c\x9a\xd9\x1c\x09\xd2\xa1\x2b\xca\x16\x29\x79\xcb\xd4\xec\x5d\x9f\x4e\xf1\xc8\x62\xf8\x74\x89\xc1\xc2\xcf\xff\xe1\xf7\x85\x36\x9f\xee\x5b\xb2\xc4\x77\xfa\xe6\x50\x78\xe5\x4a\xb8\x53\xf2\xb5\x11\xdf\x3b\x66\x3b\x67\xcf\x73\x99\x93\xcc\xa9\x84\x94\xc4\xbf\xb9\x3f\xf5\x7f\xc6\xc7\x59\x95\x55\x14\x01\x7f\x91\x4d\xad\x3b\xae\xcc\x1e\xe7\x01\x7b\xa2\x8d\x3d\xb9\x22\x51\x3e\x76\x35\x8a\x1b\x1b\xbb\xe6\x70\xf3\x7f\xcf\xc7\xa9\x4f\x91\x55\xcf\x1d\x3c\xde\x7c\xf6\x85\x57\xae\x0c\xcf\x72\x12\xde\x90\xb8\x38\x7d\xec\x60\xa4\xbf\x9c\x84\x89\xc7\xea\x8e\x7c\x9b\xd9\xfa\x39\x55\xcb\xf9\x26\x13\x4b\x67\x94\x7d\xc0\x21\x54\x22\x45\x67\x34\xe1\x9a\x6a\x6c\x36\x59\xfc\xbe\xb0\x97\x91\x9c\x9c\xa5\x37\x53\xe0\x77\x18\x48\x0d\x7d\x96\xe1\xe4\xd3\x6c\x03\x96\x50\xad\xbc\x25\x12\xf3\x92\x87\x0d\xf3\xdb\x57\xde\x7f\xf7\xd0\xa1\x77\x97\xb5\x3b\xaa\x43\xc1\xd3\xea\xbd\x55\xad\x89\xfb\xbf\x7c\x6f\x6f\x2f\x5c\x54\x20\x9a\x85\xa7\x5d\x7e\xf6\xd2\x89\xb3\x7b\xaa\x22\xc9\xeb\xc5\x5f\xfd\x62\xef\xde\x77\xa1\xfc\xba\xc9\x3f\xbc\x70\xe3\xc6\x3b\x2e\x6d\xde\xbc\xa8\xa3\x07\xff\x09\x3a\xa1\x5d\x7c\x5e\xfc\x9e\xf8\x7d\xf1\x87\xe6\x85\x8b\x07\x16\x96\x9b\x22\x67\x25\x85\xeb\xc4\x3d\xa5\x83\xa9\xb3\xba\xdd\xcb\xd6\x86\x4b\xf3\x3f\x84\xfa\x03\x5f\x87\x85\x2f\xe5\x4f\xfd\xca\x53\x9f\x5e\xf2\xb4\xf8\x83\xb1\x81\xd3\x96\xcf\xd8\x03\x41\x8d\xd8\x9b\x51\x25\xf2\xa2\x1b\xd1\x33\xd2\x1e\x4f\xc9\x6d\x0a\x9b\x4d\x56\xe9\x35\x84\xf2\x92\xde\x24\xf9\xfc\xd7\xcd\xee\x7c\x95\xe4\x67\x3b\xe6\x26\x31\x73\xaa\x9e\xdd\x26\x9f\xbe\x17\x0c\x84\xe6\x3a\x44\xd8\xa5\x8f\xff\xb2\xf7\xa4\xdd\x26\x39\xfd\x28\x3e\x13\xd2\x2b\x36\xbf\xcf\xe9\x62\x9c\x36\x17\x2b\x79\x96\xb8\xa5\x32\xb0\xa6\x63\xfe\x03\xe1\x90\x59\x8a\x2f\xe4\x65\xe5\x6f\x6a\x0e\x8b\xd3\x01\x3f\xa8\xb4\x83\xae\x2b\xfa\xfe\xeb\x9e\x8c\xdb\x5a\xd9\x35\xdc\x3a\xf1\x25\xdf\x46\x5c\x6c\xb0\xa9\xd9\xae\x9a\xf2\xcf\x5f\x28\x71\xd7\x94\x33\xed\x25\xee\x37\x7b\x8b\xcf\xf4\x98\xb4\xbc\xc9\xed\x75\xd7\x94\x9b\x89\x71\xa1\xb3\x87\x68\xf4\x8b\x1c\x2c\x43\x2a\xdd\xa1\xa0\xbb\xa1\xdc\x67\x02\xb0\x70\xa5\x13\x37\xb4\x2e\x1d\x68\x2d\x2e\x2f\xb5\xd6\xfb\x16\xd7\x2f\xf6\x94\x99\x54\x1c\x51\x69\x74\x66\x8d\xb3\x6c\x81\xa6\xb4\xe7\xd4\x0e\xfc\xea\xa5\xd6\x45\xab\xd6\x57\x9a\x5c\x8b\x56\xab\x1f\xad\x0f\x2c\x4a\x60\x87\xd6\xaa\x55\x55\x5a\x07\xce\x1b\xde\xaa\xc3\x82\xbd\x8a\x18\xcf\x85\x32\xb8\x18\x36\x80\xd9\x9f\x28\xb5\x96\x76\xc5\xd7\xbe\xf0\x99\xf8\xdb\x57\x36\x9c\x41\x4a\x4c\xc5\x8e\x73\xca\x3d\xee\x92\x72\x8f\x1b\x9f\x76\x51\xd4\xbd\xc6\xa6\xd1\x71\xea\x06\xdf\x06\xef\x8a\x50\x03\xab\x6b\xd6\x3b\x4a\x56\x18\x17\x19\x8b\xed\xc5\xed\xc0\x30\xb8\xc5\x55\xd7\xe9\xf5\x76\xd6\x0d\x77\x2e\xb4\xb1\x2c\x26\x26\xed\xc2\x67\x77\x85\x27\xc7\x93\x13\x81\x60\x7d\x8b\x49\xad\xb3\x95\x5b\xfd\xfe\x65\x4b\x5a\xa0\xca\x5c\x65\x77\x68\xcb\x9c\xc5\xeb\x6d\x03\x2b\xf6\xef\x15\x3f\xfa\x75\xe5\xe0\xe6\x8e\x0a\x93\x71\xe9\x3a\xed\x6f\xa0\x69\xf7\xa1\xb1\x89\x71\x62\xd7\x39\xcd\x36\xb5\xb5\xea\xc0\x6e\xf1\xc3\x6f\x34\xcc\x7d\xdf\x50\x24\xcd\xfa\xd6\x90\x9b\x07\x03\x38\x2a\x00\x42\x4e\x07\x0f\xed\xc0\xfb\xba\xc0\xe9\x38\x61\x13\xf6\xdd\xd7\xa8\x3d\x95\x47\xf6\x97\xdb\x4d\x45\xbf\xc0\x60\xd7\xf2\x5a\x31\x62\x72\x3a\x92\xef\x2d\xc1\xc9\x93\xec\x47\xf8\x35\xfe\x4e\xa3\x5b\x27\x3e\xa4\x2d\x2b\xe6\xfb\xa1\xd7\xa0\x62\x35\xe2\x25\x1f\x3a\x46\xef\xae\xc5\x37\x9f\x6c\x43\x01\x37\x7b\xb6\x93\x5e\xfa\x92\xec\x97\xe2\xa0\x22\xc5\xf7\x2f\x14\x36\xfb\xcd\x2e\x70\x06\xdc\x1e\x65\xe3\xa0\xa4\x62\x95\xa1\xb0\x4d\x3a\x27\x3c\x2c\x6d\x84\xb4\x9b\x1d\x56\x65\xe7\x0d\xfd\xc3\xd4\xb2\x0c\x2c\x9a\x5a\x34\x30\xd5\xb7\x38\xb3\x3f\xb3\xb8\xef\x09\xd0\x3c\x31\x25\x3b\xf9\x4d\x49\xf0\xd4\x41\xe9\xdf\x60\x26\x33\xb8\x38\x66\x27\x97\x1d\x29\xd8\x63\x8b\x57\x5e\xd4\x44\x10\xad\x9a\x46\x4d\x17\xad\xdc\xf3\xc4\x13\x7b\x1e\x13\x3f\x05\xfe\xb1\x47\x76\xe3\x17\x68\x69\xba\x7d\x37\x5c\x2a\x6f\xae\x91\x36\xd8\xfc\xff\xa2\xef\xf8\xb2\xe9\xff\x67\xfb\x0e\x97\x89\xff\x57\xfa\x1e\xf4\xdb\xff\xaf\xf7\xfd\xb2\xcb\xfe\x37\x3d\x9f\xdb\x77\xb5\x34\x2f\xcb\xbd\x9f\xed\xbb\xcf\xf1\xbf\xe8\x77\x66\x7f\xe6\xdf\xe9\xf5\xea\xed\xdb\x57\xff\x8f\x7b\x6c\x9a\x8d\xc1\xe4\x46\x5e\xe9\xb4\xfa\x01\xb4\x0a\x6d\x44\x5b\x50\x1c\xa5\xd0\x0e\x74\x1e\xba\x08\xed\x43\xd7\xa3\xdb\xe4\x13\x2f\x60\xe6\xac\x40\x2f\x84\xe5\xd8\x72\x55\x66\xe5\x20\x95\x90\xc3\x19\x0e\xf9\x9c\x58\x39\x92\x9a\x51\xf6\x01\x85\x66\xca\x33\x79\x40\xae\xa9\x3d\xbe\xfe\xf8\xfb\xbf\x00\x7f\x06\x8f\x3b\x2e\x67\x6f\xd4\x68\xa6\xf7\x69\x4a\x34\x6b\x35\x9a\xc6\x53\xad\x6d\xcb\xe2\xdb\xae\x3f\x8a\xe8\x42\x7a\xdb\xd3\x4b\xb7\xfc\x64\x6d\xa3\xa6\x44\x53\x25\x3b\xea\x6e\x92\x32\xd9\x91\x77\xfa\x1e\xc5\x79\x57\xf6\x08\x46\xf3\x2a\xe7\xde\x28\xbe\x3d\xb7\xa0\xdc\x20\xef\x40\xde\x34\x27\x65\x79\x4d\x09\xed\x87\x66\xad\xa6\x44\xd3\x78\xd6\x7f\x45\x97\x5e\xbf\xed\x73\xc4\x22\xba\xaa\x5f\xbb\xcc\x53\xde\xdd\xa8\xd1\x88\xf7\x4a\x78\x9b\x4e\x48\x03\x52\x13\x53\x5f\x70\xf5\xed\x13\x6a\xdc\x27\xd4\x20\xf3\x9c\xb3\xfa\xea\x50\x93\x14\x31\xb5\x1f\xad\x44\xe7\xa2\x3d\xe8\x72\x74\x1d\xba\x15\xdd\x8d\x1e\x40\xdf\x41\x4f\xa1\x1f\x48\x3b\x9e\x8e\x05\xdb\x97\x36\xaa\xcf\x96\xdc\x1d\x80\x8e\xf3\xf6\x76\x2b\xb9\xe3\xb8\xb2\xfb\x24\xab\xcb\x53\x40\x89\x87\xe7\x90\x5e\x2b\x3a\x78\xe0\x9a\xc1\x3d\x57\x6d\x7c\x0e\xf4\x05\xed\x7c\x51\xfb\xc7\xd7\xcf\x94\xb9\x29\xf9\x70\xc4\xae\xee\x69\xd4\xdd\x65\xd5\x2f\xd1\x5b\xa7\xf0\x12\x4b\x99\xc5\x52\xb6\x56\x4a\xbd\x52\x7a\xf5\x1c\x58\x4e\x99\xb5\xf2\x6a\xdd\x62\xd8\x7a\xfd\xb6\xe4\x0a\xef\x68\xbd\x43\xab\x6d\xd0\x6a\xc5\xe7\xa5\xcc\x51\xab\x2e\xab\xf3\x07\x97\xb3\xef\x19\x2c\x47\xa6\x4e\xc0\x7e\xe5\x9f\xd6\xc8\xd4\xe0\xe0\xc1\x03\x85\xe7\x28\x85\x1d\x0e\x47\xca\xec\x74\x9a\x1f\x2f\x1c\x38\x08\xff\x41\xaf\x59\xbc\x73\x52\xcb\x09\x35\xd3\xb3\x8f\x07\x78\x6a\xdb\xf5\xab\xac\x86\xca\xf9\x9d\xf3\xe6\x7d\x35\xcb\x83\xd3\x53\x16\x38\x78\x02\xee\xda\x7f\x5a\x23\xff\x2f\xad\x19\x81\x3e\xef\xb2\x22\xd2\xa3\x25\xe8\x54\xb4\x5d\xf6\xf1\xe2\xb9\x4a\x79\x29\x57\x09\x36\xc4\x73\xd2\x59\xc9\xf4\x3f\x4b\x30\x80\x6b\x79\x03\x91\x56\x6c\x74\x0d\x09\x4e\x07\xe7\xf1\x02\x0e\x87\x2c\xa1\xda\x70\x88\x71\x58\x66\xb7\x55\xd8\xe4\xb3\xf2\x3c\x6e\x69\xc3\x9c\x57\x76\xc2\x95\xf6\x83\xf1\x06\x90\xfc\xc1\x71\x38\xe4\x02\xf2\x81\xb9\xa2\xc8\x21\x1e\x71\x14\x55\x98\xe1\x20\x76\x89\x9f\xbc\xa5\x32\x00\x4f\x18\x0c\xaa\xdb\x9f\x7d\x44\x7c\xf1\x3b\xe7\x7c\x70\xc7\x10\xc0\xf7\x6f\xe7\x31\x21\xa0\xc2\x60\x54\x5d\xfb\xc1\xa4\x8a\xdf\xf1\x0c\x90\x2b\xee\x82\xe6\x77\x76\x4f\x7f\xb0\xfb\xf1\xdd\xbb\x1f\x87\x3b\xc7\x36\xab\x4c\x98\x73\xf2\x9a\x45\x3d\x85\xe7\xb7\xef\x39\xa8\xd7\xf4\x76\x6b\xf8\x22\x16\x9b\x54\x43\x63\x98\x7c\xf9\xdd\x0b\xaf\xfc\xc7\x55\x70\xc6\xc6\xf4\x9b\xc3\x9b\x36\x0d\xbf\x99\x3a\xfd\x3e\x40\x87\xc5\x73\x36\x12\x9d\xba\xc5\x52\x69\x54\x93\x35\xe0\xfb\xee\xc3\xd0\x74\x9f\x86\x4f\x3e\xf0\xdb\x73\xbf\x2b\xfe\x74\x35\x51\xdb\x8b\xd4\xcd\x3a\xb5\x8e\x59\xf4\x4b\x68\xbd\xf7\x0a\x60\x9f\xdd\xa5\xd6\x6c\x3f\x24\xbe\x53\x47\x69\xee\x3e\x8a\x76\xbd\xbe\x94\x53\x69\x02\x0b\x34\x9a\xd0\xd5\x6b\xd3\x8f\x47\x74\xc6\xef\xef\x39\xfb\xbe\xc5\x1a\x4d\x7d\x40\xad\xe2\x96\xbd\x7d\xee\xee\x0f\x2e\xe1\xf8\x8b\xfe\xac\x9c\x4d\x2e\xef\x2b\xb6\x22\x54\x27\x45\x73\x3f\x2e\xca\x32\x62\xd1\xe7\x88\x53\x3e\xf7\xc8\xcf\xcd\x53\x04\xc1\xd6\xb9\xcf\x2b\x20\xb7\x03\x53\xc8\x88\xd0\xf1\xcf\x6f\xfc\x3c\xdc\xf7\xa4\xd7\x99\xca\x8b\x21\x32\x7b\xbe\x03\x41\x3a\xe4\x46\xa8\x1e\xcc\xf5\xd8\x5c\x65\x96\xdf\xcb\x2a\x51\xb8\x8e\x75\x67\xb6\x4f\x04\x4d\x23\x06\x61\x34\x8d\xb6\xf6\x6c\x21\x68\x4b\xcf\xf4\xfe\x99\x17\x01\x78\xab\x7c\xc8\x39\x46\x04\x1d\x45\x5b\x7a\x30\xa2\xf5\xe2\x6c\xc0\x7f\xd8\x2a\xd3\x3e\x36\xf6\x1a\xe4\x47\xa8\x2e\x1c\x0a\x34\x83\x94\xb8\xab\x8d\xe0\x71\x4b\xdf\x22\x2b\x60\x36\x0a\x8a\xd3\xe1\x3b\x9e\x37\xcc\x57\xaf\xd6\x68\x7e\xf7\x3b\x8d\xe6\x6a\x4d\x09\xcd\x4b\x34\xc7\x95\x71\x6e\xee\xd0\xdf\xfc\xa2\xdb\x94\x32\x63\x9d\xcb\x53\x32\xa7\x7f\xf2\x7b\x9f\x7f\xfb\x5c\xdc\xe3\x7a\xf9\x3b\x4a\xe7\xc0\x01\x99\xce\x81\x03\x32\xdd\x39\xe5\x23\xfa\x13\x45\x0c\x07\x4e\x7e\xef\x6c\x59\x7c\x99\x41\x5b\xe7\x3f\xb3\xce\xd8\x78\x49\x97\xd4\x50\x05\x27\x2c\xeb\xbd\xe0\x9b\xce\x8a\x3f\x61\xb7\x9e\x64\x0d\x0f\x71\x1c\x98\xfe\x31\x1c\x3a\xd9\x7a\x9d\x97\xda\xc6\x92\xef\x87\x15\xd5\x20\x2f\xea\x45\xdf\x47\xaf\x21\x04\x6e\x03\x38\x1d\x9d\xc0\x72\xf2\xd6\x38\x9f\xd3\x61\x73\xce\xb2\x48\x66\x8c\x67\xe6\x9a\xc3\x56\x27\xfd\xcc\xa5\xa8\x3d\xbc\x01\xac\x21\xe9\x13\x20\xdf\x09\x15\x10\xf2\x74\x82\x14\x47\x24\xe4\xf6\xb8\xa9\x39\x70\x81\xd3\x0b\x1e\x77\xd8\xed\xa9\x96\xbc\xab\xe8\xb3\x26\xc7\x87\xc2\x9c\x0b\x9c\xf4\xba\x11\x28\x65\x27\xc7\x73\x36\x47\xb8\x13\xc2\x5e\xcc\x77\x32\x7e\x87\xe4\x27\xe3\x90\xaf\xb3\x0e\xa7\xdb\x63\x60\x1c\x4e\x47\xc8\x22\xf9\x98\x3a\x1d\xe1\x13\x62\x8f\xb0\x5a\xe3\x02\x9d\xd6\x10\x30\x89\x9b\x54\x4e\x5e\xa5\xe2\x9d\x2a\xfe\xb6\x1a\x5d\x8d\xde\xad\xd3\xc9\xd9\x24\xad\xe2\x55\x0e\x13\x5c\x56\x7d\x4d\xc8\xed\x65\x96\xad\x5c\xe2\xc6\x0e\xde\xca\x19\x08\x4b\xf8\xef\x11\x67\x65\x35\xb7\xe0\x8c\x7e\x6b\x83\x4e\x87\x6b\x39\x20\x64\x61\x1b\xa7\xd9\xb6\x7e\x71\xb2\xcc\xc5\xd7\xfa\x2b\x9a\x36\x1a\xca\x16\x9b\xf4\x3e\x8f\xd5\xab\xd7\xeb\x35\x4d\xad\x7a\x8c\x79\xa8\x73\x15\x3b\x6a\x84\xea\xaa\x4d\x8f\x98\x40\x63\x34\xda\x17\x36\xd4\x9f\x6a\xc5\xea\x4a\xb3\xb3\xad\xa8\xc2\xae\x37\xa8\xf8\x05\xdb\x58\x28\xd3\xeb\x19\x97\xa3\xc2\x6a\xc4\xea\x1a\xec\x28\x6e\xb0\x1a\xf4\xd6\xa6\xe7\x1f\xad\xd8\xb8\xa3\xb4\x79\x6c\xb4\xcb\xf3\xf7\x7d\x87\xc5\x87\xc4\x6b\xc5\x87\x24\x89\xad\x84\x24\xac\x3c\xcc\xd4\x9a\xcd\x0b\x2c\x66\xb6\xf6\x35\x95\x4a\xe5\xa0\x43\x72\xac\xad\xd1\xeb\xdd\xfa\x6a\x7d\x8d\x4e\xe7\xd1\xd5\xec\xa0\xf5\x2a\x95\xc9\xb1\x69\xc9\x42\x77\xd9\xca\xe1\x8d\x36\x57\x2d\xb6\x73\x76\x8d\xdd\xe8\xb0\x15\x89\x16\x5b\xb9\xc1\xa6\x59\x1a\x36\xe9\xb5\x00\x4d\x4d\xb6\x7a\x8d\xa6\x68\xad\x6f\xfd\x1e\x0d\xef\x6f\xf5\xc7\x96\x85\x8c\xcc\x92\xb6\x64\xd6\xae\xb5\x16\x95\x00\xf8\xca\xec\x46\x47\x39\x43\xca\x86\x2e\x0b\x1a\x1c\xa6\xf1\x66\x6f\xf5\xa3\x4b\x4d\x5a\x9d\xa5\x78\x91\xc3\x6c\xed\x70\x61\x4e\x0d\xac\x91\xe5\x81\xaf\xaf\x0b\xc6\x5b\x46\xf2\xe5\x0d\x1c\xc7\xfb\xea\xbb\x4e\xe9\xed\x71\x85\x4a\x8a\x5c\x21\x77\x63\xa5\xb6\xf8\xdb\xa0\xde\x1a\x38\xbf\x6d\xf3\x86\x75\x04\xc3\xe4\x49\xf7\xa0\xc3\xec\x7b\xd8\xa5\x08\x81\xd9\x21\xed\x2f\xef\x02\x3f\xb1\xd6\x48\x1e\x89\xca\x4b\xa8\x4e\xa6\x0b\xfc\x1c\xe6\xbd\xe0\xa9\xa9\x62\x83\x54\xee\x56\x8b\xc7\x0b\xcd\x10\x64\xab\x7c\x61\xaa\x18\xf4\xfe\x9a\xaa\x6a\x0e\x73\x23\x0f\xd6\xd5\xf5\x35\x99\xab\x46\x0c\xfc\x48\xb9\x71\x71\xe8\x74\xf1\xbf\x4f\xdf\x04\x42\x4d\x6b\x47\xb3\xaf\xc1\xb2\xf9\x4c\xce\xcf\x5e\xfd\x87\xa6\xc6\xe9\xaf\x88\x17\x9f\xdf\xdb\x0a\x2a\xa2\xc5\xcd\x7d\xe7\xc3\x4e\xfc\xf4\x65\x7f\xe0\x4c\x0c\xbb\xb9\xb2\x62\xe3\xc0\xf4\xcf\xcb\x8c\xec\x69\xd3\xdb\x81\x25\x04\x37\x9d\xba\x4f\x7c\x5a\x7c\xf6\xfc\x3e\x1f\xa8\xa6\x5f\x5b\xb5\x9c\xd1\x16\x7b\x3a\x1b\xde\xaa\x13\xd7\x76\xb0\x1c\xe8\xe2\xc5\xfa\x96\x30\xde\x0d\x57\xff\xb5\xc3\xab\x2f\x8a\xeb\x4a\xfb\xa6\x37\x9f\x7d\xce\x64\xc1\xac\x7c\x0f\x91\x7c\x5c\xcc\xa8\x11\xb5\xa0\x4e\xb4\x4e\x79\x73\x67\xb7\x39\x0c\x4c\x8d\xd9\xe7\x22\x65\xc0\xd2\x02\x96\x1c\xae\x17\x13\xba\xc4\x96\x2a\xfd\xe6\x1a\xf0\x9b\x6b\x78\xb7\xa7\xc6\xec\x37\x5b\xfd\x56\x36\xe0\xf1\xb2\xd5\x35\xd5\x0b\xc1\xec\xf3\x3b\x42\x1e\x37\x1b\x94\xf7\x73\x04\x6b\xcc\xfe\xf0\x49\xf7\xab\xdc\x04\x80\x59\x95\x41\xad\x36\xa8\x58\x0c\x8b\x01\x18\xad\x4a\xcd\x32\x84\xe1\x58\x4e\xc5\x12\xf8\xfc\xdd\x5d\xbb\xe0\xdb\xdb\x6e\x2f\xb3\xe9\x6e\x1b\x6b\x5a\xb1\x10\x0e\xb0\xc4\x64\xa9\xb4\xd7\x9b\xed\x2a\xe6\x2c\x5b\xed\x81\x36\x02\xd0\xc1\x18\xab\xcb\xbd\x15\x85\x14\xef\x6a\xf6\x55\x3e\x3c\xf7\x93\x1c\xfe\xd5\x23\x8c\x43\x65\xe2\x55\x04\x82\x58\x45\x4c\xac\x23\x3a\x09\x4e\x95\x91\x53\x6b\x6e\xc6\x1a\x5e\xcb\xa9\x08\xe1\x38\x2d\x6b\xf8\x08\xde\x12\x17\xc0\x5b\xbf\xb8\xf6\x34\x71\x01\xb4\x89\x2f\x42\x97\xa1\xd7\x69\x2a\x36\xe9\x58\x22\x2e\x00\xff\xcd\x9d\xb7\xef\x29\xaf\xac\x31\x56\xdf\x24\x2e\x70\xd5\x76\x10\xcb\x71\xdf\x3a\x58\xd4\x72\x14\xab\x96\xb3\xff\x40\x3a\x64\x47\x25\x68\x1d\xba\x02\x21\xd6\xed\x91\x4e\x2d\x73\x20\x6a\x56\x9a\x81\xe3\x1d\x56\x6a\x4d\x20\x80\xa5\x93\x1e\x79\x8e\xef\x24\x15\xe0\x22\xbc\xdb\x80\x79\x17\x76\x3a\x3a\x71\x97\x1c\x89\x80\xe7\x58\xce\xe3\x22\x52\x08\x42\x8b\x95\xe3\x39\x2c\x6d\x74\xe7\x6a\x2a\x11\xa9\x76\xd7\x70\x2e\x5c\x01\x0e\xa7\x97\x34\x83\x97\xf3\xb8\xb0\x53\x59\x18\x51\x53\x56\xcb\x38\x1d\x16\x66\x82\x63\xf5\xde\xf3\xc6\x0a\x15\xe6\xdb\x7a\x60\xad\xb8\xf9\xbe\xe2\x4a\xc2\xac\xaf\x63\x77\x2d\xac\x6e\x74\xb1\xfb\xcf\x79\x55\x7c\xf7\xf6\x6b\xc4\x4f\xb6\xb9\x8c\x8b\xef\xf9\xea\xde\xfa\x05\x55\x0b\xd4\x0c\x39\xef\x47\x77\xee\x1a\x60\x8c\x6d\xd5\x5f\xfa\xf4\xe1\xab\xea\xea\x1c\x35\x25\x8c\x21\x78\x48\x9c\xde\xfb\x48\xfd\xa5\x17\x9f\xeb\xf1\x5c\xb1\xf3\x7b\x1f\x2d\x33\x94\x0c\xfc\xf2\xa7\x2d\xd5\xa7\x9e\x55\x5b\x27\xfe\x5a\xec\x5f\x06\x1c\xe6\xcc\x35\x75\x7a\x83\xca\xbb\x74\xcc\x57\x4e\x30\xdb\xbe\xa0\xa7\xd5\x5f\xad\xb2\x76\xdd\xb9\x04\x6b\xd7\xd5\xef\x2d\x0b\x1a\xab\x2b\x6f\x83\x1a\x68\xbf\xfe\xe7\x1f\xfc\x00\x88\xca\x15\x1b\xbf\xff\x74\x52\xfd\xba\xf8\x06\x3e\xa5\x6c\xc5\xa3\xa1\xe0\xda\x7d\xdd\xb8\x65\xc9\x7a\xaf\x43\xbc\xed\x0e\xa8\x7d\xed\xdc\xc4\xd6\x45\x71\x7f\xb7\x9d\x63\x08\x94\xd7\xd5\x69\xb4\xf6\x9e\x95\x8b\x6b\xb7\xff\x75\x11\x57\xdf\xd3\x57\x5c\x64\x52\x5b\x8b\x23\x45\x91\x3a\x1b\xb3\xf5\x8e\xcd\xdd\x5a\x9d\xd3\x1d\x85\x73\x40\xbd\x77\xe5\x21\xf1\x0f\xb9\x2a\x6d\x89\x86\xc0\x26\xd0\x83\xef\xdc\xc4\x59\x25\x25\xba\x01\xf7\x25\x57\xec\x6e\x68\xc0\x76\x63\x49\x51\x69\xa9\x4e\x53\xb1\x58\x55\x79\xdd\xe5\x2f\xdd\x99\x8b\x96\x55\x1b\x97\x2d\x76\xaf\xca\x89\x03\x88\x45\x75\x47\x75\xdc\x5b\xec\x27\xc8\x89\x5a\xd0\x12\x74\xba\x74\xe2\x54\xc8\xed\x51\x42\xa3\xb9\xb0\xd3\xc5\x87\xc0\x80\x99\x5a\xba\xca\xec\x24\x61\xae\x04\x74\x50\x1b\x0e\xf1\x36\x6c\x93\xce\x10\x92\x3e\xc8\x00\xeb\x85\x46\xd0\x01\x87\x9d\x6e\xdc\xc9\x48\xf1\xe5\x49\x08\x79\xaa\x3d\xee\xb0\x8b\x31\x10\xbe\x93\xb0\x1d\xe5\x4b\x37\x2e\xda\x2b\x58\x74\xc6\x1a\x67\xc5\xa2\xd2\xda\xae\x85\x75\x45\x36\xbd\x56\x03\xdb\x03\xcf\xfe\x51\xfc\x8b\xf8\xd9\xe1\x87\x47\x58\x30\x6a\xdc\x8c\x7f\xf4\x2f\xb0\x1e\xb6\xc2\xa6\xbc\x0d\xff\x75\xcd\xc5\x4f\x1e\x7a\xf2\xe2\x35\x72\x06\x99\xee\xdf\x8a\x7f\x12\x7f\x24\xbe\x23\x8a\x8f\x0c\xba\x5a\xd9\x15\xfb\x9e\x7a\xff\xe3\xbf\x7f\xf0\x93\xe5\x55\x8b\x16\xeb\xc4\x37\xff\xa1\xc2\xb8\xe4\xdc\x57\x2e\xde\x6a\x77\xc6\xae\x7a\xff\xe2\xe4\x13\x77\x0c\xe3\xc3\x8d\xf7\xb7\x7b\xca\x6d\xa5\x4e\x0d\x4b\x18\xa3\x46\x5f\x57\xb7\xa0\xb6\xaa\x48\x0f\xd3\x3f\x3a\xff\xf1\x48\x91\x7f\xf7\x41\x70\xde\x55\x7f\x7a\xfd\x4e\xfd\x21\xf1\x22\x51\xbc\x49\x77\xc7\x5d\xa5\x7a\x06\x57\x1c\x7a\xfa\xd2\x35\x6b\x2e\x7d\x5a\xce\xb8\x6b\x0e\x45\x55\x6b\x1e\xfc\xbb\x78\xd7\x0b\x77\x40\xd3\x27\xaf\x7c\x55\xa8\x77\x6e\xb8\x2b\xe7\xdb\x27\x5e\xf0\x09\x9c\xd1\xc7\xb2\x84\x39\xfb\xda\xa7\x7e\xf6\xd3\x27\xaf\x3e\x13\xbb\x62\x57\xff\x54\xf6\x27\x91\x6c\x8c\xf4\x1d\xb0\x02\x35\xa3\x2e\xc9\xa7\x3b\x8d\xce\x47\x57\xa0\xdb\xd1\x37\x11\xb2\xda\x6b\xaa\x3b\x80\xfe\x05\x4e\x81\x60\xc0\xff\x7f\x5a\x3e\x7e\x2d\x04\x76\xdb\x42\xe9\x2f\xe8\xf7\x95\x83\xdf\x17\xfc\x3f\x2c\x1f\xcc\x98\x5a\x4c\xa6\x16\x53\xe6\x5f\xe4\xcc\xb7\xda\x16\x1c\x39\xb8\xa0\xad\x6d\x01\x59\xb2\xa0\x0d\xd0\xbf\x81\x22\xe5\x80\xa6\x4c\x26\x53\xa5\xc9\xf4\x6f\x43\xfb\x3f\x5b\x42\xc9\xb0\x94\xd8\xe7\x2a\x5a\x33\x65\x32\x1d\xfe\x17\xb9\xec\x43\xd8\x7c\x14\x71\x6b\x38\x84\xae\xa4\x6b\x4d\x79\x1f\x6e\x33\x7d\x9a\x72\x7b\x48\x9d\xd9\xe9\x02\x03\xb8\x9b\x41\xda\x77\xd2\x41\xaf\x49\x47\xac\x98\x59\x62\xa0\x8f\xd0\x33\xae\x7e\x52\xfc\x14\x27\xdb\x04\xac\xb4\xeb\x60\xa6\xa6\x02\x3c\xee\x90\xc3\x69\x65\xcd\x72\x80\x15\x25\x74\x71\x39\x84\x3b\xc1\x05\x9c\x11\xcc\x75\xd6\x4e\x70\x18\x41\xde\xdd\x6b\x04\x89\x5c\x4d\xb5\xa7\x4e\x0f\x75\x21\x17\x70\x9c\xeb\xde\xc7\x9d\x7a\xbd\xc1\xe7\x7c\x3c\xac\xf7\x2d\xd5\xc7\xc5\x3f\x1f\x32\xe1\xa2\xaa\x7a\x53\xc6\x1d\x70\x67\x4c\xf5\x55\x45\xd8\x74\x48\xfc\x73\x5c\xbf\xd4\xa7\x0f\x3f\xee\xf4\x19\xf4\x7a\xe7\xe3\xf7\x96\x97\xa8\x1b\xca\x21\x24\x05\x86\x7c\x89\x51\x97\x56\x33\x25\xa5\xb4\xa1\x92\x80\x43\x69\x07\x8c\x27\x69\x07\x8c\xc7\xb5\x53\x5a\xc2\x54\x97\xaa\x19\xf1\x25\x29\xa6\x65\xa8\xbc\x41\x5d\x02\x77\x56\x8d\xe9\xfd\x4e\xa7\x5e\xbf\x6d\xbf\xdb\xaf\xa9\x83\xc6\x5b\xc4\x17\x3e\xb2\x34\x54\x58\x55\x96\xa9\x37\x4a\xdc\xee\x92\x37\xa6\x2c\x2a\x6b\x45\x83\xe5\x23\x68\xbf\x45\x7c\xad\x4e\xe3\x77\xef\xdf\xa6\xd7\x3b\x9d\x7e\xfd\x58\x15\xe7\x6d\xae\xe2\x3a\x6f\xbd\xb5\x13\x6a\x1b\x1b\x58\xda\x92\xd7\x60\x90\x1b\x12\x5f\xbb\x05\xda\x4f\xde\x90\xf8\xc2\x2d\xd0\x38\xbf\x21\xb6\xa1\xb1\x16\x68\x43\x5c\x55\xb3\x17\xcd\xf3\xf1\xb3\xd0\x27\x2a\xa0\x8b\x5c\x3a\xa9\x70\x74\x56\xa9\xb5\xa8\xc1\x61\xe1\x39\xcc\xf0\x2c\xb8\xe9\x33\x72\x6d\x38\x54\xcb\x3e\xcb\x0f\x5e\x7d\xa8\x90\x7f\xe7\xee\x04\xcf\x0f\x5e\xfd\xb3\xc2\xcd\x60\xfb\x06\x2c\x15\xef\xdc\x39\xa9\xd1\x3e\x22\xbe\xf6\xc8\x91\x62\x38\x4b\x82\xa1\xe9\x91\x7b\xf1\x4d\x78\x68\xc7\x7f\xde\x21\xf0\xfc\xaa\x2b\x7e\x5a\x90\x20\xf5\xc5\xe8\x28\xd3\x21\xde\x55\x10\x5f\xba\xe7\x51\xf1\xc5\x17\x8a\xbf\x0c\x67\xe5\x21\x7c\xcf\x77\xa1\xed\x85\x62\xc7\x19\xf2\xfb\x47\x25\xfe\x9f\x01\x59\x90\x03\xb9\x25\x8f\x73\x6b\x8d\x16\x6a\xac\x9e\xb0\x93\x07\x96\x34\x81\x93\xf7\xd4\x39\x79\x0f\xf3\xaf\xc2\xf5\x3d\x7c\xa7\xff\x9b\xf7\xb7\x3e\xb4\xca\x7e\xd8\x2e\xf6\x43\xcb\x85\xe2\x21\x78\xfb\xf0\xc8\xc7\x70\xfe\x33\x6b\x9f\xc6\x1d\x74\x42\x13\x9f\x13\xdf\x7d\xf5\x9c\x73\x5e\x85\x6a\xe8\x84\xea\x57\xff\x78\xb2\xe7\x8d\x23\xe2\xa3\xb0\x45\xfc\x1a\xec\xa8\x6a\x8d\xfb\x70\xe2\x42\xf1\xd0\x85\x13\x23\x1f\xc7\x37\xad\x79\x7a\xcd\x16\x09\xeb\x9c\xb9\x2d\xe1\x89\x93\xac\x0a\x75\xc8\x7d\x14\xf8\x4d\xec\x51\x74\x06\x1a\x46\x49\x34\x81\x2e\x40\xf7\xa3\x47\xd1\x73\xe8\x65\xf4\x16\xfa\x10\x7d\x84\x10\x78\x89\xc7\xdd\x09\x1e\x39\xa4\x30\xa9\xf6\x82\xc7\xcb\x49\x8f\x18\x44\x3e\xef\x8a\x37\x10\x3b\x27\x3d\x42\x48\x4f\x09\x4e\x87\xfc\x56\x22\x24\xbd\x8c\x70\xfa\xa4\xf9\x9e\xce\x3a\x21\xc6\x21\xbf\xbe\xe8\x04\x70\x18\x40\x02\x1c\x48\x79\x6f\x01\x4e\x07\xad\xf4\x42\x28\x1c\x72\x58\x1d\x98\xe7\x3c\xf4\x16\xe5\x7d\x87\x17\x87\xc2\xf4\x67\x27\xc5\x2b\x0d\xb9\x08\xef\xc2\x1c\x28\xad\xc9\x08\x52\x7b\x52\x58\x23\x5a\x2d\x37\x03\xb3\xf4\x1c\x73\x6f\xf6\xc8\x77\x74\x82\x83\x0d\x31\xcd\x81\x26\xc2\xae\x58\xc6\x1a\x46\x9a\x5c\x84\xc1\x3c\xe1\x59\x9e\x10\x1d\xa7\x55\x69\xb5\x9c\xab\xb6\x14\x4c\x6a\xbb\x4e\x1b\x72\xd5\x6f\x73\x9a\x7c\x75\x0b\x1d\x6b\x06\x5c\xf5\x16\xfe\x4a\x96\xab\x30\x94\x72\x78\x18\x38\xff\x80\x8d\x59\x37\xc8\xd9\xec\xe5\x0c\x3e\x9f\xd7\xf9\x5a\xcd\x7d\xcb\x7d\x47\xba\x39\x93\xd1\x50\x4c\x88\xa9\x0c\x9f\xae\xe3\xab\xeb\x75\x5a\xbe\xba\x7e\xda\x5e\xdb\x55\x52\xa2\xb3\x58\xba\x4a\x4a\x58\xc6\xaa\x6b\xeb\x76\xeb\x4a\xcb\xba\xbf\xdc\x1f\x4c\x6e\x1a\xb7\x5d\x70\x5b\x87\x0e\x46\x3e\x59\xea\x23\xeb\x26\x1a\xdc\x9d\xb5\x4c\x70\x5b\x5f\xe5\x45\xb7\x3f\xb8\xf4\xd4\x8b\x27\xcf\x68\xe6\x02\x03\xf6\xca\xcf\xb3\x06\xb5\xcd\xda\xaa\x97\xd2\x6f\x30\x96\xea\x32\x86\x58\x4d\xe6\x32\xe6\x6e\xc6\x6e\xb3\x56\xab\xec\x36\x5b\xd5\x74\xd2\x64\x2c\x2b\xed\x30\x99\x8c\xa1\x4e\xfc\x19\x63\x32\x1a\x69\x37\x8c\x86\xe2\x27\x8d\x6a\x87\x23\xe4\xd2\x34\x06\xc1\x5b\x64\x83\xa2\x92\xe6\xc7\x1e\xf4\x08\x18\xcc\x18\x03\x01\xc2\x10\xac\x67\x35\x2c\x47\x80\x35\x39\xc1\xc8\xeb\x31\x2e\xd5\x5b\xbc\x0d\x65\x97\x9f\x73\x25\xf4\xc7\x18\x5c\x52\xa5\x87\x82\x4a\x6b\xe0\x8d\x6e\xcb\x5f\xb5\xee\x3a\xa7\x5b\x75\xdf\xed\xea\x72\x70\x9b\xc4\x4f\xcb\x82\xb1\x22\xb5\x9e\x54\xdc\xe7\x92\x89\x95\x70\xe2\xdb\xe6\xfa\x22\x95\x99\x26\x24\x14\xd2\x59\x2d\x4b\x4a\x4a\x75\x16\xeb\x34\x94\xf5\xba\x75\x6d\x3d\x36\xab\x0e\x2f\xd9\x2e\x7e\xba\xa2\x8b\x0c\x6e\x61\xc3\x6a\x58\xda\x34\x7a\xda\x59\x86\xed\x57\xdc\xb1\x68\xf1\xc5\xd9\x75\xea\x0d\xe7\xb5\x3b\xc3\x76\xbe\x7b\x68\xef\x69\xa6\xb5\x5b\x47\x70\xc6\xd6\x6a\x30\xa8\x6d\x52\x0a\xac\xa9\x5c\x65\x35\x9b\xcb\x18\xc6\x7a\xe4\x14\x5b\x35\xc3\xd8\x17\x54\xb3\x8c\x93\x6c\x2b\xed\x32\x99\x8c\xa5\x65\x9d\xd5\xa6\xe9\xf5\xc6\x62\x86\x98\x0d\xc6\x12\x42\x4c\x1f\x38\x42\x26\xa3\xa6\x31\x54\xa9\x41\x08\x15\x81\x5b\x3e\x71\x1a\x21\xd4\x8c\xb6\x2a\x30\x20\x2d\xba\x4f\x81\x31\xe2\xd1\xf7\x15\x98\x20\x33\x3a\xac\xc0\x0c\xd2\x42\x89\x02\xb3\xc8\x02\x2b\x14\x98\x43\x5a\x98\x50\x60\x1e\xad\xc1\x1e\x05\x56\x21\x1d\xbe\x46\x81\xd5\x48\x83\x1f\x51\x60\x2d\xb2\xe3\x3f\x29\xb0\x01\xb9\x48\x37\x22\x08\x18\x35\x42\x48\x7e\xa3\x44\x61\x40\x0e\x74\xa5\x02\x63\x64\x40\x0f\x2b\x30\x41\xd5\xe8\xc7\x0a\xcc\x20\x07\x60\x05\x66\x51\x2d\xb8\x15\x98\x43\x0e\x18\x52\x60\x1e\x7d\x0d\x76\x2b\xb0\x0a\x15\xe1\x49\x05\x56\x23\x1b\xde\xaf\xc0\x5a\xd4\x80\x9f\x55\x60\x03\x5a\x4c\x08\xea\x45\x69\x94\x41\x93\x28\x8b\x12\x68\x04\x8d\xa2\x3c\xaa\x44\x7d\x28\x82\x76\x20\x01\x55\xa2\xa5\x28\x82\x52\x28\x86\x26\x51\x25\xf2\xa1\x16\xd4\x8a\x42\xc8\x8b\x2a\x51\x37\x4a\xa2\x24\xaa\x9c\x83\x95\x93\x4a\x02\xca\x21\x01\x65\x25\xec\x18\xf2\x22\xd4\x9b\xce\x4c\x66\x13\x23\xa3\xf9\xca\xbe\xc8\x0e\xa1\x72\x69\x24\x15\x9b\xac\xf4\xb5\xb4\x86\xbc\x95\xdd\xc9\x64\xa5\x74\x29\x57\x99\x15\x72\x42\x76\x87\x10\xf3\x22\x34\x80\xd2\x28\x85\xf2\xa8\x1b\x4d\x48\xad\xa5\xd1\x38\x12\x10\x1a\x48\xa7\xf2\xdd\x13\x42\x2e\x3d\x2e\x20\xb4\x16\x09\x68\x04\x15\x50\x12\x45\x50\x16\xa1\xb5\xc2\x48\x21\x19\xc9\x52\xdc\xd5\x68\x15\x5a\x8f\x56\xa0\x6e\xd4\x83\x16\xa1\xd5\x68\x3d\x1a\x40\xfd\xe8\x0c\x34\x88\x56\xa3\xb5\x68\x3d\x42\x03\xab\x57\xad\x5f\xd1\xdd\xb3\x68\xf5\xfa\x81\xfe\x33\x06\x57\xaf\x5d\xff\xef\x51\xdc\x28\x8d\x2a\x87\x12\xd2\xbd\x95\x28\x80\xbc\x28\x8c\xbc\xa8\x65\x0e\x5f\xd0\x46\x21\x9b\x4b\xa4\x53\x95\x01\x6f\xd8\xdb\x22\x0d\xf2\xdf\x6b\x7c\x10\x25\x91\x80\x22\x12\xeb\x64\x26\xc6\x25\x72\x95\x28\x8f\xd2\x52\x3a\x2a\x5d\x39\x99\xa8\x28\x4e\x14\xe5\x67\x3b\x16\x47\x69\x05\x53\xc6\x89\x2b\xf4\x69\x4d\x16\x45\x50\x0c\x09\x68\x5c\x62\xdb\x18\xaa\x44\x11\x94\x97\xea\x13\x68\x18\x15\xe6\xb4\x92\x42\x69\xa9\x14\x95\xfa\xec\x45\x68\x30\x29\x44\x72\x42\x65\x56\x88\x0b\xd9\xca\x7c\xba\x32\x3f\x2a\x54\x1e\x13\x6d\x4e\x88\xe6\xe9\xc0\xe3\xe9\xac\x74\x25\x9e\x4e\xe5\x2b\xf3\xd9\x48\x4c\x18\x8f\x64\xc7\x2a\x23\xf9\x7c\x36\x31\x5c\x90\x6e\x49\xa5\xf3\x89\xa8\x90\x53\x04\x9d\x95\x7a\x76\x02\x6f\xb2\xf9\xca\x59\xe6\x9c\x4c\x17\xd1\x31\x5d\x42\x12\x1f\xf2\x28\x83\x16\xa1\x66\xd4\x3c\x3b\xde\xc8\xbc\x36\xbd\xd2\xc8\xd0\x68\x3e\x9f\x59\xd4\xdc\x4c\xbb\x17\x91\xdb\xf7\x26\xd2\xff\x93\x16\x9a\x51\x52\xe1\x4a\x4a\xe2\x7c\xf3\x17\xb4\xd9\x9c\x4c\x44\x85\x54\x4e\x68\x56\xd6\x38\xff\xec\x1f\xfe\x9e\x64\x93\xe8\xaf\x7b\x1f\xba\x0c\x5d\x8a\x2e\x47\x57\xa2\xab\xd0\x57\xd0\xd5\xe8\x0a\xa0\xe6\x9a\x01\x16\x38\xe0\x41\x05\x6a\xd0\x80\x16\x74\xa0\x07\x03\x18\xc1\x04\x66\xb0\x80\x15\x6c\x60\x07\x07\x38\xa1\x08\x8a\xa1\x04\x4a\xa1\x0c\xca\xc1\x05\x15\x50\x09\x55\x50\x0d\x35\x50\x0b\x75\xe0\x06\x0f\x2c\x80\x7a\x68\x80\x85\xd0\x08\x4d\x40\x1f\xeb\x5b\xa0\x15\x7c\xe0\x87\x00\x04\x21\x04\x61\x68\x83\x76\x58\x04\xa7\xc0\x62\xe8\x90\x5e\x16\x2d\x81\x6e\xe8\x81\x5e\xe8\x83\x7e\x18\x80\xa5\x70\x2a\x9c\x06\xcb\x60\x39\xac\x80\x95\xb0\x0a\x56\xc3\x20\xac\x81\xb5\xb0\x0e\xd6\xc3\x06\xd8\x08\xa7\xc3\x19\x70\x26\x6c\x82\xb3\xe0\x6c\xd8\x0c\x5b\x60\x08\xb6\x42\x04\x86\x91\x01\x7d\x8c\xf4\x10\x85\x18\x08\x10\x87\x11\x18\x85\x04\x6c\x83\x31\x48\xc2\x38\xa4\x20\x0d\x19\xd8\x0e\x59\xc8\x41\x1e\x0a\xb0\x03\x26\x60\x27\x4c\xc2\x2e\xf8\x12\x9c\x03\xe7\xc2\x79\x70\x3e\x4c\xc1\x05\x70\x21\xec\x86\x2f\xc3\x1e\xb8\x08\xf6\xc2\xc5\x70\x09\x5c\x0a\x97\xc1\x57\xe0\x72\xd8\x07\x57\xc0\x95\x70\x15\x5c\x0d\xd7\xc0\xb5\x70\x1d\x5c\x0f\x5f\x85\x1b\xe0\x46\xb8\x09\x6e\x86\x5b\xe0\x56\xb8\x0d\x6e\x87\xfd\x70\x07\x7c\x0d\xee\x84\xbb\xe0\x6e\xb8\x07\xee\x85\xfb\xe0\x00\x7c\x1d\xee\x87\x6f\xc0\x03\xf0\x1f\xf0\x4d\xf8\x16\x3c\x08\xdf\x86\x87\xe0\x61\xf8\x0e\x3c\x02\x8f\xc2\x77\xe1\x31\x78\x1c\x9e\x80\x27\xe1\x29\x78\x1a\x9e\x81\x83\xf0\x2c\x3c\x07\xdf\x83\xef\xc3\x0f\xe0\x79\x78\x01\x5e\x84\x1f\xc2\x4b\xf0\x23\xf8\x31\xbc\x0c\x3f\x81\x9f\xc2\x21\xf8\x19\xbc\x02\xaf\xc2\x6b\xf0\x3a\xbc\x01\x6f\xc2\x5b\xf0\x9f\xf0\x36\xbc\x03\x3f\x87\x5f\xc0\xbb\xf0\x4b\x78\x0f\xde\x87\x0f\xe0\x57\xf0\x21\xfc\x1a\x7e\x03\xbf\x85\xff\x82\xdf\xc1\xef\xe1\x0f\xf0\x47\xf8\x13\x7c\x04\x1f\xc3\x61\xf8\x33\xfc\x05\xfe\x0a\x9f\xc0\xdf\xe0\xef\xf0\xdf\xf0\x0f\xf8\x14\x3e\x83\xcf\xe1\x08\x4c\x83\x08\x47\x31\xc2\x80\x31\x26\x98\xc1\x2c\xe6\x30\x8f\x55\xa8\x1a\xab\xb1\x06\x6b\xb1\x0e\xeb\xb1\x01\x1b\xb1\x09\x9b\xb1\x05\x5b\xb1\x0d\xdb\xb1\x03\x3b\x71\x11\x2e\xc6\x25\xb8\x14\x97\xe1\x72\xec\xc2\x15\xb8\x12\x57\xe1\x6a\x5c\x83\x6b\x71\x1d\x76\x63\x0f\x5e\x80\xeb\x71\x03\x5e\x88\x1b\x71\x13\xf6\xe2\x66\xdc\x82\x5b\xb1\x0f\xfb\x71\x00\x07\x71\x08\x87\x71\x1b\x6e\xc7\x8b\xf0\x29\x78\x31\xee\xc0\x9d\xb8\x0b\x2f\xc1\xdd\xb8\x07\xf7\xe2\x3e\xdc\x8f\x07\xf0\x52\x7c\x2a\x3e\x0d\x2f\xc3\xcb\xf1\x0a\xbc\x12\xaf\xc2\xab\xf1\x20\x5e\x83\xd7\xe2\x75\xe8\x15\xbc\x1e\x6f\xc0\x1b\xf1\xe9\xf8\x0c\x7c\x26\xde\x84\xcf\xc2\x67\xe3\xcd\x78\x0b\x1e\xc2\x5b\x71\x04\x0f\xe3\x28\x8e\x61\x01\xc7\xf1\x08\x1e\xc5\x09\xbc\x0d\x8f\xe1\x24\x1e\xc7\x29\x9c\xc6\x19\xbc\x1d\x67\x71\x0e\xe7\x71\x01\xef\xc0\x13\x78\x27\x9e\xc4\xbb\xf0\x97\xf0\x39\xf8\x5c\x7c\x1e\x3e\x1f\x4f\xe1\x0b\xf0\x85\x78\x37\xfe\x32\xde\x83\x2f\xc2\x7b\xf1\xc5\xf8\x12\x7c\x29\xbe\x0c\x7f\x05\x5f\x8e\xf7\xe1\x2b\xf0\x95\xf8\x2a\x7c\x35\xbe\x06\x5f\x8b\xaf\xc3\xd7\xe3\xaf\xe2\x1b\xf0\x8d\xf8\x26\x7c\x33\xbe\x05\xdf\x8a\x6f\xc3\xb7\xe3\xfd\xf8\x0e\xfc\x35\x7c\x27\xbe\x0b\xdf\x8d\xef\xc1\xf7\xe2\xfb\xf0\x01\xfc\x75\x7c\x3f\xfe\x06\x7e\x00\xff\x07\xfe\x26\xfe\x16\x7e\x10\x7f\x1b\x3f\x84\x1f\xc6\xdf\xc1\x8f\xe0\x47\xf1\x77\xf1\x63\xf8\x71\xfc\x04\x7e\x12\x3f\x85\x9f\xc6\xcf\xe0\x83\xf8\x59\xfc\x1c\xfe\x1e\xfe\x3e\xfe\x01\x7e\x1e\xbf\x80\x5f\xc4\x3f\xc4\x2f\xe1\x1f\xe1\x1f\xe3\x97\xf1\x4f\xf0\x4f\xf1\x21\xfc\x33\xfc\x0a\x7e\x15\xbf\x86\x5f\xc7\x6f\xe0\x37\xf1\x5b\xf8\x3f\xf1\xdb\xf8\x1d\xfc\x73\xfc\x0b\xfc\x2e\xfe\x25\x7e\x0f\xbf\x8f\x3f\xc0\xbf\xc2\x1f\xe2\x5f\xe3\xdf\xe0\xdf\xe2\xff\xc2\xbf\xc3\xbf\xc7\x7f\xc0\x7f\xc4\x7f\xc2\x1f\xe1\x8f\xf1\x61\xfc\x67\xfc\x17\xfc\x57\xfc\x09\xfe\x1b\xfe\x3b\xfe\x6f\xfc\x0f\xfc\x29\xfe\x0c\x7f\x8e\x8f\xe0\x69\x2c\xe2\xa3\x04\x11\x20\x98\x10\xc2\x10\x96\x70\x84\x27\x2a\xa2\x26\x1a\xa2\x25\x3a\xa2\x27\x06\x62\x24\x26\x62\x26\x16\x62\x25\x36\x62\x27\x0e\xe2\x24\x45\xa4\x98\x94\x90\x52\x52\x46\xca\x89\x8b\x54\x90\x4a\x52\x45\xaa\x49\x0d\xa9\x25\x75\xc4\x4d\x3c\x64\x01\xa9\x27\x0d\x64\x21\x69\x24\x4d\xc4\x4b\x9a\x49\x0b\x69\x25\x3e\xe2\x27\x01\x12\x24\x21\x12\x26\x6d\xa4\x9d\x2c\x22\xa7\x90\xc5\xa4\x83\x74\x92\x2e\xb2\x84\x74\x93\x1e\xd2\x4b\xfa\x48\x3f\x19\x20\x4b\xc9\xa9\xe4\x34\xb2\x8c\x2c\x27\x2b\xc8\x4a\xb2\x8a\xac\x26\x83\x64\x0d\x59\x4b\xd6\x91\xf5\x64\x03\xd9\x48\x4e\x27\x67\x90\x33\xc9\x26\x72\x16\x39\x9b\x6c\x26\x5b\xc8\x10\xd9\x4a\x22\x64\x98\x44\x49\x8c\x08\x24\x4e\x46\xc8\x28\x49\x90\x6d\x64\x8c\x24\xc9\x38\x49\x91\x34\xc9\x90\xed\x24\x4b\x72\x24\x4f\x0a\x64\x07\x99\x20\x3b\xc9\x24\xd9\x45\xbe\x44\xce\x21\xe7\x92\xf3\xc8\xf9\x64\x8a\x5c\x40\x2e\x24\xbb\xc9\x97\xc9\x1e\x72\x11\xd9\x4b\x2e\x26\x97\x90\x4b\xc9\x65\xe4\x2b\xe4\x72\xb2\x8f\x5c\x41\xae\x24\x57\x91\xab\xc9\x35\xe4\x5a\x72\x1d\xb9\x9e\x7c\x95\xdc\x40\x6e\x24\x37\x91\x9b\xc9\x2d\xe4\x56\x72\x1b\xb9\x9d\xec\x27\x77\x90\xaf\x91\x3b\xc9\x5d\xe4\x6e\x72\x0f\xb9\x97\xdc\x47\x0e\x90\xaf\x93\xfb\xc9\x37\xc8\x03\xe4\x3f\xc8\x37\xc9\xb7\xc8\x83\xe8\x5a\x76\x24\x19\xc9\xe5\xd8\xf1\x42\x2e\x11\xe5\x72\x42\x24\x1b\x1d\x55\x09\xa9\x1d\x42\x32\x9d\x11\xd8\x51\x21\x92\xcd\x33\xb9\x7c\x24\xab\xa1\xc9\x90\x30\x9e\xc9\x4f\x32\x85\x9c\x90\x65\xe2\x89\xe4\xb8\x2a\x3f\x3a\x94\x8c\x64\x47\x04\x9c\x1f\xe5\x29\x9c\xc8\xe5\x71\x7a\x8c\xcb\x0a\xe3\xe9\x1d\x02\xbf\x2b\x9d\x1e\x1f\x4a\xa4\x54\x52\x9e\x2e\xe4\x49\x3a\x1e\xe7\x72\x89\x91\x54\x24\x49\xa2\xe9\x11\x36\x9f\x8d\xe4\x46\x99\xd1\xf4\xb8\xa0\x8a\x27\x92\xc2\x50\x24\x99\x67\xf2\x89\x71\x81\xc9\xa6\x23\x31\x5d\x2c\x3d\x91\x4a\xa6\x23\x31\x5a\xad\x9a\x29\x70\x85\x0c\xcd\xd8\x44\x6a\x38\xbd\x53\x9b\x49\x46\x26\x87\xa2\x89\x6c\x34\x29\x70\x59\x21\x23\x44\xf2\x7c\x56\x88\x67\x85\xdc\xa8\x8a\x76\x45\x6a\x30\x99\x8e\x8e\x31\xf1\x64\x64\x44\x33\x2a\x44\x62\x99\xd1\x74\x4a\xc8\x69\x76\xa4\x93\x85\x71\x61\x28\x1d\x8f\x6b\x15\x90\x12\x50\x2b\x70\x21\xc3\x6d\xcf\x46\xd3\x31\x81\x1f\x8e\x48\x39\xc9\x47\x46\x98\x7c\x64\x24\xc7\x0c\xa7\xd3\x63\x2a\x9a\xd0\x19\x9e\xcd\x64\x13\xa9\x3c\x17\x8d\x8c\x0b\xd9\x08\x43\xa7\x42\x66\x38\x9d\x8c\x71\x89\x7c\x24\x99\x88\x6a\xf3\xc2\xce\xfc\xd0\xa8\x40\x97\x0a\x1a\x09\x9e\x48\xc4\xf2\xa3\x9a\x48\x32\x31\x92\x1a\x4a\x0a\xf1\xbc\x4e\x06\xa3\x42\x2a\x2f\x64\xb5\x72\x41\x5a\x59\xe8\x65\x78\x5b\x21\x97\x4f\xc4\x27\x19\x3a\x16\x6d\x22\x15\x13\x52\x79\x19\x4f\x81\xa5\x7b\x0d\xf1\x48\x54\xa0\x5c\x1b\xda\x91\x88\x09\x69\x3e\x93\x88\xe6\x0b\x59\x81\xcb\x08\xa9\x68\x22\xa9\x19\x8f\x64\x86\x68\x5f\x85\x2c\x17\x89\xd1\x06\x99\x7c\x22\x95\x67\x84\x58\x22\xcf\xe6\x46\x23\x59\x81\x8d\x8e\x0a\xd1\x31\x86\x0a\x4c\x9f\xcb\x0b\x99\xa1\xe1\x48\x74\x6c\x22\x92\x8d\xe9\xe3\x91\x5c\x7e\xb6\xa4\x9a\x01\x18\xca\x74\x36\x13\x29\xe4\x04\x26\x97\x4f\x67\xf8\x78\x3a\x4b\xeb\x75\xd2\xed\x33\x05\xa9\x25\xa5\xc0\x0a\xdb\x84\x68\x5e\x17\x1d\x15\x76\x64\xd3\xf2\xc8\xf5\x33\x05\x69\x08\xea\x4c\xb2\x90\x1b\xa2\x8a\xa1\x19\x4f\xa4\x14\x50\x2b\x2b\x91\x04\xf3\xe9\x31\x29\xd7\x6f\x2f\x08\x39\xba\x9e\x92\x4a\xea\x44\x2a\x9e\x96\xd1\x72\xd1\xac\x20\xa4\x72\xa3\xe9\xbc\x5e\x41\x93\xb5\x42\x9d\x1e\x53\x20\xcd\x70\x24\x35\x03\x46\xb2\xd9\xf4\x84\xd4\x0f\xad\x0c\x4a\xbd\x50\xc9\x70\x21\xa3\x5c\x97\x34\x42\x62\x11\xd5\x23\x6d\x56\xc8\x25\x76\x09\x43\xf1\x42\x32\xa9\x53\xe0\xdc\x78\x24\x99\x34\x09\x3b\xa3\xc9\xc8\x78\x64\xb6\x5b\xcc\x48\x22\x9e\x67\x92\x42\x24\xce\xc4\x13\x59\x41\x25\x4c\x0a\x43\xe9\x8c\x90\x52\x53\x20\x9a\x4c\xe7\x04\xdd\x44\x24\x9b\x4a\xa4\x46\xa4\xdb\xd9\x4c\x32\x92\x12\x54\xd1\x48\x52\x48\xc5\x22\x59\x2e\x1b\x49\xc5\xd2\xe3\x7c\x34\x3d\x3e\x2e\xa4\xf2\xdc\x78\x64\x24\x25\xe4\x35\x33\xfc\x2a\x64\x66\xf9\x48\xfb\xc7\x67\x85\xfc\x84\x20\xe4\xf5\xb9\xd1\x74\x26\x43\x9b\x8c\x46\xb2\x79\x5d\x3c\x9d\x8c\x09\x59\x99\x98\x56\x29\xd0\x2e\x18\x95\x8e\xef\x10\xb2\xf9\x44\x34\x92\x34\x2b\xe5\xd1\x74\x36\xb1\x8b\xae\xe4\x92\xea\xe1\x48\x76\x28\x3a\x4a\x1b\xc9\x4f\x24\xf2\x79\x21\x2b\x33\x9e\x2a\x19\x55\x7b\xa9\xa4\x93\x35\x7e\x28\x2b\xe4\xb3\x69\x32\x26\x4c\x32\xd1\xf4\x48\x4e\xa5\x74\x39\xa7\xcf\x8f\x16\xc6\x87\x73\x43\x85\x0c\x65\x9c\x51\x29\xd1\xee\xd2\xb2\x5a\x32\x24\xa3\x91\x64\x5c\x2b\x59\x17\xd9\xa6\xf0\xb4\xdd\x74\x21\xaf\x4f\x26\x52\x63\x42\x2c\x21\xb3\x92\xcf\x14\x72\xa3\x99\x44\x4a\x2f\xec\xcc\x0b\xd9\x54\x24\x39\x44\x2f\x4b\x26\x24\x91\xe2\xf2\xd9\x74\x66\x74\x52\x3b\x92\xc8\x8f\x16\x86\x65\x3d\x90\xad\x03\x25\xc3\x26\x85\xf1\x74\x8a\x95\x7e\xef\x5a\x49\xc5\x65\x42\x86\x99\x1f\xaf\x5c\xd4\x48\x37\xc8\xc4\x94\x01\xab\x66\xc6\xca\xc9\x2d\x73\x85\x14\xb5\x21\xda\x68\x96\xfe\x68\x28\x83\x63\x24\x9b\xcb\x91\xd1\x58\x4c\x35\x5c\x48\x26\x47\xd3\xd9\x14\x33\x2c\x24\x93\xda\x28\x65\x6b\x3c\x11\x8d\xe4\x05\xcd\x68\x24\x15\x53\xb4\x5b\x02\xa9\xb6\xf1\x12\x54\xc8\xc8\x35\x94\x21\x66\x59\x23\x87\x8e\x69\xa4\x65\x5e\x8d\xd4\x80\x71\x5e\x55\x21\x33\x1f\x89\x36\xc3\x8e\x24\xd3\xc3\x02\x37\x91\x15\x52\xd1\x51\x36\x1f\xc9\x8d\xe5\xb8\x78\x22\x99\x17\xb2\xea\xe1\x6c\x42\x88\x47\x23\x39\x41\x43\x35\x57\xfe\x9d\xb0\x23\xd9\x74\x21\xc3\x50\x5e\xb2\xd1\x64\xba\x10\xe3\x86\x85\xc8\x98\x90\x25\xd1\x42\x9e\x89\xa6\x33\x93\x9a\x4c\x24\x23\xe9\x4f\x22\xc3\xe4\x22\x3b\x04\x0d\xe5\xcf\xd0\x70\x32\x92\x1a\xe3\xb3\x42\x3a\x1b\x13\xb2\xb8\x90\xc4\xe9\xa4\x3e\x97\xcf\x26\xc6\x84\xfc\x68\x36\x5d\x18\x19\x55\x17\x52\x31\x21\x9b\x4c\xa4\x04\x36\x1f\x19\x4e\x0a\xec\x78\x64\x24\x11\x65\xf3\xd9\x42\x74\x4c\x9d\x49\x50\x2b\x27\xe4\xf2\x86\x59\x48\x62\xbb\x69\x24\x9d\x1e\x49\x0a\x43\xb3\x36\x40\x3b\xa7\x82\x1d\x4f\xa7\x84\x49\x4d\x34\x92\x15\xf2\xd2\x48\x55\x32\x58\xc8\x28\x75\xd2\x8f\x58\x06\x25\x5e\xf1\x51\x6a\xc2\x53\x39\x26\x97\xce\xe6\xd5\x34\x91\x7f\x27\x12\x54\xc8\xe8\x66\x66\x36\x69\x52\x99\xd1\x35\xa6\x90\x8a\xa5\xd9\xa4\x30\x12\x49\xaa\x63\x91\xdc\xe8\x70\x3a\x92\x8d\x69\x15\x75\xa6\x77\xea\x66\x54\x5b\x9a\x51\x86\xd3\xc9\x3c\x9f\x4b\xe4\x85\xf1\x48\x46\x55\x18\x1f\xce\x0a\xc9\x64\x84\xcd\x44\x72\x79\x41\x93\xa4\x9d\x18\x1a\x2e\x24\x87\x55\xc2\xce\xe8\x68\x24\x35\x22\x18\x24\x16\x0f\xcd\xcc\x60\x3a\xb9\x28\x6b\x2a\x4f\xa7\xd2\xa1\xf1\x98\x36\x97\x17\xf2\xa3\xe9\x5c\x34\x9d\x11\x54\xb9\x42\x22\x4f\x25\xa6\xa2\x4a\x45\x29\x72\xd1\x74\x3c\x2e\x08\x4c\x3c\x9d\x8e\xe9\xa5\x99\x52\x9a\x4e\xe8\x10\x86\x0b\x89\x64\x2c\x91\x1a\x51\x8d\xa6\x73\x19\x3a\xef\xa8\x23\xe3\xc3\x85\x64\x24\x15\x15\xb8\x71\x21\x36\x96\xc8\x6b\xe3\xb4\x4b\x42\x76\x68\x9b\x90\x67\x86\x05\x21\xcb\x8d\xca\x66\x2a\xde\x12\x17\xcc\xb1\x74\x61\x98\xaa\x52\x8a\x72\x5c\xd2\xbf\x79\x35\xb2\xfe\xcd\xab\x2a\x64\xe6\x23\xd1\x71\x69\x8e\xe1\x6b\xe7\x20\xaa\x66\x30\x34\xc7\x6e\xe5\x63\x42\x6e\x2c\x9f\xce\x70\xc9\x48\x86\x66\x92\xa2\xe4\x75\xe3\xe9\x61\x3a\x2e\xe9\xd7\xa8\x53\xf4\x5b\xd2\x37\xcd\xf6\x42\x3a\xaf\x34\x2d\x83\xb2\x9c\x73\x99\x44\x2a\x25\x64\x39\xf9\x5e\x36\x2b\x64\x92\x93\x1a\xc5\x14\x44\x92\x79\xd3\x5c\x13\x28\x99\xa1\x39\x66\x90\x96\x35\xc2\xce\x0c\xfd\x15\xca\xd2\x4d\x26\x23\x19\xf9\x3e\x36\x37\x9e\x48\x0a\x6c\x3c\x9b\x9e\x48\x91\x71\x61\x94\x1f\x89\x8c\x0b\x99\x48\x4c\x35\x26\x4c\x4a\x7a\xa1\xa2\x6b\x09\x7a\xa7\x41\x02\x24\xd3\x22\x64\x85\x98\x2a\x2f\x64\xc7\x13\xa9\x48\x92\xa1\x2b\x06\xb5\xd4\xa1\xa1\x48\x32\x69\x9c\xb5\x77\x8a\x01\x4a\xa6\xa3\xf2\x64\x21\xfd\x7e\x99\x68\x36\x9d\x51\x53\x14\x3a\x5d\x8e\x51\x63\x93\x48\x8d\x31\x43\xbe\x70\xbb\x76\xce\xcc\xa2\xcd\x15\x32\x42\x36\x17\xcd\x26\x32\x79\x75\xae\x30\x2c\x43\xcc\x90\xaf\xcd\xaf\xcb\x14\x76\xed\xa2\xbc\x4b\x08\x51\x41\x33\x9e\xa0\x0d\x52\x36\x1a\x8e\x81\x43\xd2\xc2\x6b\x34\x21\x24\x63\x86\x99\x89\x46\xee\x8d\x99\x4e\x51\x43\xc2\xce\x7c\x22\x35\x52\x48\xe4\x46\x85\x2c\x97\x4d\x47\xc7\x04\x3a\xf1\xec\x8c\xc6\x52\xe6\x99\xd9\x26\x37\xb3\x68\xb1\xcc\xab\x51\x0c\xd4\xdc\x2a\x6a\xa0\xe6\x96\x25\x03\x35\x9a\x1f\x4f\x06\x99\x68\x2e\xe7\xe7\x22\xa9\xe8\x68\x3a\xab\x91\xad\xaa\xa2\xc4\xc9\x64\x4e\x98\x14\xac\x42\x32\x99\xc8\xe4\x12\xb9\x39\x13\x92\x79\xb6\x6e\x66\xd2\x62\x86\xfc\x2d\x7e\xb5\xb4\xf4\xa3\xed\x73\xf9\x04\xed\xaf\xe1\xd8\xca\x41\x9a\xae\x65\x93\x2f\x55\xaa\x92\xc2\x0e\x21\x49\xd5\x50\x06\x24\x8d\x95\xaf\x4b\xcb\x08\xc9\xac\x4b\x3f\x89\x21\x7f\xab\x4f\x23\x4f\xf9\xd2\x8c\x10\x4d\x8f\x67\x22\x39\x3a\xb3\xc9\x0a\x72\x4c\x53\xf2\xe9\x0c\xbd\x3b\x4c\x84\x42\x96\x8c\x0c\x67\x48\x21\x17\x23\x89\x54\x96\x6c\xcb\x4c\x92\x6c\x61\x98\x8c\x65\x27\xc8\x70\x3e\x4a\x97\xc9\x82\x7a\xf6\x37\x6b\x92\xec\xd0\x30\x55\x8c\xcc\x68\x64\x58\xc8\x33\x43\x7e\x5f\xbb\x65\xb6\x56\x79\x63\x24\xe4\x1c\x27\x56\xd1\x61\xe9\x67\xaa\x25\x1b\x6c\x9e\x57\x92\x6c\xd3\x90\xdf\x1f\xa0\x49\x50\x37\x99\x2e\xe4\x0b\xc3\xca\x40\x94\x02\xb3\x33\x91\x1a\x51\xef\x9c\x59\x7a\xcc\xde\x43\x99\xc9\xc7\xb2\xe9\xcc\x70\x7a\xa7\x3e\x97\x8f\x44\xc7\x66\x8c\x97\x3a\x91\xca\xe5\x23\x23\xd9\xc8\x38\x17\x4f\x26\xa2\x63\x59\x12\x89\xa5\x98\x78\x6b\xb8\xd5\x30\x9c\xc8\x0f\x17\x28\xeb\x15\x31\x14\xc6\x87\x93\x59\xad\x9c\x49\x55\xc6\x64\x3a\x35\x32\x67\x96\xd2\xcf\x29\x17\x32\x73\xaf\x52\xbd\x32\xcd\x29\xcb\x3f\xf1\x89\x44\x2a\x96\x9e\xc8\xf1\x91\x54\x2c\x9b\x4e\xc4\xd8\x64\x22\x55\xd8\xc9\xc7\xb2\x89\x61\x3a\xb7\xe4\xc6\x26\x33\x82\x26\x9e\x2e\x64\x73\xdb\x0b\x91\xac\xc0\xe5\xa9\x1d\x4e\x73\x71\x61\x3c\x92\x14\x18\x9a\xd0\x09\x3c\x9f\xc8\x90\x5c\x81\x8a\x36\x14\xe2\xe9\xc3\x4d\x62\x87\x40\x86\x0b\x23\x78\xc7\x18\x3b\x21\x24\x86\xd3\x5c\x56\x48\x65\x05\x7a\x43\xd8\x67\x90\xc6\x3e\x34\x33\x78\x5a\x17\xb0\xcb\x5d\x9a\x99\x73\x93\xf2\x9c\x43\x2f\x85\x0c\xb1\x74\x7e\xce\x05\x5a\xd7\xa6\xdb\x91\x18\x17\xd2\x43\x72\x9f\x98\x21\x7f\x5b\x8b\x5e\x9e\xd9\xa4\x8a\xa1\x34\xad\xf2\xd1\xc4\x4f\x13\x2a\xab\xb6\x20\x4d\x42\x34\x09\xd3\xa4\x8d\x26\xed\x7c\x21\x95\x18\x68\xed\x6e\x61\xe2\xad\x91\x56\x66\xc8\xdf\x4e\x91\xda\xfd\xb4\x48\x91\xda\x29\x52\x3b\x45\x6a\xa7\x48\xed\x14\xa9\xbd\x9d\x19\x0a\xb4\x48\x18\xc3\x14\xf2\xd1\xc4\x4f\x93\x80\xdc\x5a\x4f\x2b\x2d\x84\x68\x12\xa6\x49\x1b\x4d\x28\x52\x6b\x0b\x4d\xe8\xd5\x56\x8a\xd4\x4a\x91\x5a\x03\x34\x09\xd2\x84\x62\xb4\x52\x8c\x56\x8a\xd1\xaa\xf4\xad\xb7\x45\xc9\x29\x9e\x8f\xe2\xf9\x28\x9e\x8f\xe2\xf9\x28\x9e\x8f\xe2\xf9\x28\x9e\x8f\xe2\xf9\x28\x25\x3f\xa5\xe4\xa7\x18\x7e\x8a\xe1\xa7\x18\x7e\xa5\x7b\x7d\x4a\x83\x7d\xad\x4a\x2e\xdd\x41\x51\xfd\x0a\xc9\xbe\xa0\x92\x87\x94\x9c\x36\x1e\xa0\x6d\x04\x28\xd5\x00\xa5\x1a\xa0\x54\x03\xd2\x05\x8a\x1a\x50\x50\xfb\x29\xe1\x20\x25\x1c\xa4\xcd\x06\x29\x52\x90\x22\x05\x29\x52\x90\x22\x05\x29\x52\x90\x22\x05\x69\x57\x43\x14\x23\x44\x31\x42\x14\x23\x44\x31\x42\x4a\x57\x07\xa4\x6b\x14\x29\x14\x66\xe2\xad\x71\xe9\x1a\x45\x0a\xd3\x0b\x61\x8a\x14\xa6\x48\x61\x7a\x21\x4c\xc9\x84\x29\x99\x70\x88\xde\x1c\xa5\x10\x25\x13\xa6\x18\x6d\x14\xa3\x8d\x62\x50\xbd\x08\x50\xbd\x08\x50\xbd\x08\x50\xbd\x08\x50\xbd\x08\x50\xbd\x08\x50\xbd\x08\xb4\x51\x8c\x76\x8a\xd1\x4e\x31\xa8\x52\x04\xda\x29\x46\x7b\x80\x89\xfb\x24\x31\xb6\x87\x28\x24\x5d\xa0\x18\x54\x29\x82\x2d\x2d\x34\x69\xa5\x89\x8f\x26\x7e\x9a\x04\x68\x12\xa4\x49\x88\x26\x61\x9a\xb4\xd1\xa4\x9d\xdd\x21\xa4\x0a\x39\x66\x28\x48\x55\x22\x48\xdb\x0a\x52\x95\x08\x52\x95\x08\x52\x95\x08\x52\x95\x08\x52\x95\x08\x52\x95\x08\xb6\x52\x22\x3e\x4a\xc4\x47\x31\xa8\x32\x04\xa9\x32\x04\xa9\x32\x04\xa9\x32\x04\xa9\x32\x04\xa9\x32\x04\xa9\x32\x04\xa9\x32\x04\xa9\x32\x04\xa9\x32\x04\xa9\x32\x04\xa9\x32\x04\xa9\xf9\x0a\xfa\x29\x86\x9f\x62\xf8\x29\x06\xd5\x81\xa0\x9f\x62\x04\x28\x46\x80\x62\x04\x28\x06\x15\x7d\x90\x8a\x3e\x48\x45\x1f\xa4\xa2\x0f\x52\xd1\x07\xa9\xe8\x83\x01\x8a\x11\xa4\x18\x54\xee\x41\x2a\xf7\x20\x95\x7b\x90\xca\x3d\x48\xe5\x1e\xa4\x72\x0f\x52\xb9\x07\xa9\xdc\x83\x54\xee\x41\x2a\xf7\x20\x95\x7b\x90\xca\x3d\x48\xe5\x1e\x0c\x51\x8c\x10\xc5\xa0\x42\x0f\x86\x28\x46\x88\x62\x84\xda\x99\xb8\x2f\xd4\x42\x13\x8a\x11\xf6\x51\x88\x62\x50\xa1\x07\xa9\xd0\x83\x61\x8a\x11\xa6\x18\x54\xe8\x41\x2a\xf4\x20\x15\x7a\x90\x0a\x3d\x48\x85\x1e\xa4\x42\x0f\x52\xa1\x07\xa9\xd0\x83\x54\xe8\x41\x2a\xf4\x20\x15\x7a\x90\x0a\x3d\x48\x85\x1e\xa4\x42\x0f\x52\xa1\x07\xa9\xd0\x83\xed\x14\x83\x5a\x82\x20\xb5\x04\x41\x6a\x09\x82\xed\x6d\x4c\xdc\x17\x16\x24\x35\xf5\xb5\xb5\x28\x79\x2b\x33\x14\xa2\xa2\x0f\x51\xd1\x87\x14\x7b\xe0\x6b\x0b\x2a\x79\x88\x56\x86\x69\xd2\x46\x93\x76\x66\x28\x44\x75\x29\x44\xe5\x1f\xa2\xf2\x0f\x51\xf9\x87\xa8\xfc\x43\x54\xfe\x21\x2a\xff\x10\x95\x7f\x88\xca\x3f\x44\xe5\x1f\xa2\xf2\x0f\x51\xf9\x87\xa8\xfc\x43\x54\xfe\x21\x2a\xff\x10\x95\x7f\x88\xca\x3f\x44\xe5\x1f\xa2\xf2\x0f\xf9\xe4\x9f\xa5\xaf\x5b\xe9\x61\x77\xab\x92\xfb\x94\xdc\xaf\xe4\x4a\x57\xbb\x95\xae\x76\x87\x94\x3c\xac\xe4\x6d\x4a\x3e\xd3\x5e\xb7\x92\xf7\x28\x79\xaf\x92\xf7\x29\x79\xbf\x9c\xf7\x28\x74\x7b\x14\xba\x3d\x0a\xdd\x1e\x85\x6e\x8f\x42\xb7\x47\xa1\xdb\xa3\xd0\xed\x51\xe8\xf6\x28\x74\x7b\x14\xba\x3d\x0a\xdd\x1e\x85\x6e\x8f\x42\xb7\x47\xa1\xdb\xa3\xd0\x55\x8c\xa6\xaf\x57\xa1\xdb\xab\xd0\xed\x55\xe8\xf6\x2a\x74\x7b\x15\xba\xbd\x0a\xdd\x5e\x85\x6e\xaf\x42\xb7\x57\xa1\xdb\xab\xd0\xed\x55\xe8\xf6\x2a\x74\x7b\x15\xba\xbd\x0a\x5d\xc5\xb6\xfa\x14\xdb\xea\xeb\x53\xe8\xf6\x29\x74\xfb\x14\xba\x8a\x85\xf5\x29\x16\xd6\xd7\xa7\xd0\xed\x53\xe8\xf6\x29\x74\xfb\x14\xba\x7d\x0a\xdd\x3e\x85\x6e\x9f\x42\xb7\x4f\xa1\xdb\xaf\xd0\xed\x57\xe8\xf6\x2b\x74\xfb\x15\xba\xfd\x0a\xdd\x7e\x85\x6e\xbf\x42\xb7\x9f\x6a\x4a\xbb\x42\xb4\x5f\x21\xda\xaf\x10\xed\x57\x88\xf6\x2b\x44\xfb\x15\xa2\xfd\xfd\xf2\xa7\x25\x38\x7a\x14\x61\xe9\xeb\xb3\x01\x21\x54\xa4\x7c\xf1\x06\x04\xf8\x39\x04\x88\x99\xfd\x36\x25\x7d\x9f\xfe\x71\xc7\xd7\x24\xb7\xb7\x1f\xad\x5e\xdc\x42\xf3\xd7\x5a\x47\x1f\xfb\xff\x02\x00\x00\xff\xff\x5c\xbc\x44\xc5\xac\x86\x02\x00") + +func uiAppLibFontAwesome470FontsFontawesomeWebfontTtfBytes() ([]byte, error) { + return bindataRead( + _uiAppLibFontAwesome470FontsFontawesomeWebfontTtf, + "ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.ttf", + ) +} + +func uiAppLibFontAwesome470FontsFontawesomeWebfontTtf() (*asset, error) { + bytes, err := uiAppLibFontAwesome470FontsFontawesomeWebfontTtfBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.ttf", size: 165548, mode: os.FileMode(420), modTime: time.Unix(1, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _uiAppLibFontAwesome470FontsFontawesomeWebfontWoff = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x6c\x92\x53\x70\x25\x0c\xb0\xad\x77\x6c\x3b\x13\x4c\x6c\x4c\xec\x89\x6d\x4e\x6c\xdb\xb6\x6d\xdb\xb6\x6d\x27\x3b\xb6\x6d\xdb\xb7\xfe\xba\xe7\xbc\x9d\xae\xfa\xaa\x1f\xfa\xa1\x57\x7d\xb5\x5c\xe5\x44\x45\x01\x20\x00\x00\x00\xc4\xe7\x14\x80\x00\x00\x00\x40\x43\xaa\x00\xe0\x00\x28\xc0\xff\x31\xa2\xa2\xca\x32\x00\x00\x08\x23\x00\x00\xc0\xfb\x0f\xcb\x1e\xb1\x76\x31\x61\x11\x51\x00\x00\x44\x1a\x00\x00\x10\x02\x00\x80\xdf\xa0\xb7\x00\x70\x39\x25\x06\x26\x00\x00\xc4\x0a\x00\x00\xf0\x01\x00\x00\xbd\x30\x26\x0f\x7e\x43\x6b\x7d\x3b\x00\x00\xa4\x0a\x00\x00\x31\x07\x00\x40\xef\x61\x7b\xb9\x7c\x4d\xf5\x1d\xed\x00\x00\x30\x6c\x00\x00\x00\xfd\x1f\x3f\x3f\x00\x30\x53\x2b\x77\x13\x00\x00\xec\x37\x00\x44\xd7\x1d\x00\x2a\xdd\x15\xfb\x52\x23\x63\x66\xac\x6f\x04\x00\x31\xc8\x02\x00\x00\xcc\x00\x00\x80\x0d\x39\xfc\x88\xce\xcc\xcc\x58\x1f\x00\x62\x30\xfb\x3f\x7f\x49\x91\xc0\x60\x9b\xcd\xac\x9d\xdc\x00\x20\x06\xb7\x00\x00\xe8\x23\x00\x00\x7b\x2b\xe2\x8e\x1d\x6c\x65\x6b\xa8\x0f\x00\x31\x3e\x04\x00\xa0\x30\x01\x00\x38\x64\xd0\xa7\x02\x2d\x6b\x7d\x37\x3b\x00\x88\xd5\xe7\xff\x66\x06\xa3\x05\xc5\xb3\xd1\xb7\x36\x06\x80\x58\xe3\x01\x00\xa0\xc2\x00\x00\x78\xc8\x41\x6a\x64\x95\x9d\xad\xa3\x13\x00\xc4\x56\x0f\x00\x40\x0a\x06\x00\x70\x9d\x6b\x63\x33\xf3\xff\x33\xf5\x9f\x8b\x29\xde\x82\x99\xff\xf6\xa4\x1c\xcf\x7f\x3e\x00\x8b\x7f\xcc\xda\xdd\xb2\x0c\xf5\x8c\xf4\xf4\x76\xc1\x0c\x60\x20\x91\xf5\x0c\xf4\x8c\xf4\x8c\xb8\xc0\x49\xd5\xfb\x78\x20\x01\xf0\x6d\x80\x17\xc0\x7f\x77\x93\x49\xa3\xac\xbe\xbe\x89\xbe\xbe\xf9\x41\x83\xa9\xbe\xbe\x59\xc8\xfc\xf4\x08\x1c\x6c\xec\x4e\xec\x5b\xbf\x80\x89\x02\x03\x48\x28\xc8\xe0\x5a\x78\x2b\xf8\x1f\x7f\x2f\x36\x48\xd1\x38\x46\x92\x04\x54\x08\x48\x51\xc0\xec\x24\xb4\x0d\x00\xe0\x96\x35\x9d\xb0\x23\xb9\x6f\x8f\x3c\x7c\x62\x6a\x61\x7c\xfc\xc6\xd7\x47\x7c\x0e\x26\xdc\xed\x37\xc6\xe7\x07\xed\xb9\x20\x12\x26\xf7\x9b\xcf\xff\x15\x7c\x1f\x2d\x2c\xf5\x17\x2d\xf1\x9c\xf3\x98\xce\x65\x31\xb4\xa6\xa6\xe6\xdb\xe0\x96\xc5\x87\xad\x63\xc9\xd3\xb2\x6e\xaf\xcc\x69\xc1\x05\x19\x17\xa3\x29\x07\xe3\x14\x54\x08\x4a\x3c\x44\xfa\x0a\xd4\x9d\x20\xd6\x0d\xbd\xf4\xb6\x63\x8c\xc7\x60\xdd\x4a\xd1\xef\x3f\xea\xa9\x51\x56\x52\x6a\x2e\x47\x99\x78\xc6\x8e\xed\x4e\x35\x05\x54\x32\x96\x3a\x91\x1a\xcb\x15\xcb\xcd\xe5\xd6\x57\xe7\x31\x88\x8b\x2b\xe1\xc0\x34\x83\x0c\xcb\xa9\xc6\x31\xa6\xca\xaa\xc6\x71\xb6\xce\xcd\x03\x3f\x3e\x8a\x2c\xf5\x89\xf9\x94\xd6\x82\xe4\x6a\x0b\x67\x4b\x8d\x8d\x8e\x16\x53\xb0\x07\x6b\xa6\xe4\xdf\xd0\xe3\x38\x6f\x9f\x11\x94\xe7\x2c\x95\x10\x74\xe6\x22\x96\xeb\xb3\x29\x2e\x4d\xa5\xde\xf8\xe7\xff\x92\x05\x47\xe1\x57\xd4\xf5\xc2\x31\x96\x57\xf5\x22\xf1\x9f\x57\x4f\xe2\x0c\x2b\xc2\x39\x27\x35\xfa\x25\x55\xeb\x33\x58\xab\x8c\xf1\x2f\xd4\x77\x42\xd8\xbe\xc5\xe0\x81\x01\xd5\x7a\xcc\xaf\xe8\x5e\xf0\x6c\x9f\x95\x73\x5f\xa7\x91\x9a\xce\x12\xa9\x76\x93\x36\xe3\x74\x1d\x6d\x91\xed\x65\x9a\x76\x28\xd2\x77\x58\xb1\x8c\xc8\x11\x50\xd2\x76\xb1\xdc\x9b\xfb\x90\x2b\x6d\x03\x64\xdf\xbb\xa0\x27\x1c\x83\xb6\x9f\x03\xd8\x7c\xa2\x1c\xc3\x30\x31\x77\x68\x62\x1c\x43\x48\x78\x7a\x84\x3b\x6a\xbd\xc0\xda\xaf\x96\xfb\xfd\xfb\x80\x27\xe2\x7c\x11\x1d\xa4\x29\xdd\x3d\x5e\x4a\x02\x29\x5a\xd1\x44\xa9\x49\x9a\x1f\xf7\x1b\x34\x83\xb7\xc1\x87\xff\x5f\x77\x90\x9f\x1f\x00\xa8\x5b\x56\x57\x37\x8c\x9f\xf2\x52\x32\xe3\xe7\x75\xb7\x6d\xb9\xb7\x67\xb3\xb3\xb3\xb3\xab\x8a\xda\x52\xe5\xb9\xcd\xa9\x8d\x85\xb5\x07\x5d\x46\xb6\x8d\x0b\x38\xf8\x10\xa6\x48\xbc\x88\x80\x00\x32\x96\x24\x11\x75\xd8\x2f\xca\xfd\x6d\x33\xe1\x71\x26\x43\xcc\x07\x32\xd1\xac\x89\x92\x44\x11\x03\x54\x03\xb6\xde\xb7\x75\x52\xf2\xf4\xb6\xa8\xc4\x43\x76\x94\x0e\x82\x9d\xf6\x17\x15\x15\x35\x76\x84\xd3\xa9\x4f\x42\xa7\x6e\xd7\x97\xa7\x4d\xcf\x19\xce\x97\xac\x07\x8e\x29\xeb\x63\x0e\x03\xb4\xbd\x7e\x09\xbc\x54\x98\xf5\xc0\x21\x82\x26\xa4\xfc\xae\x8c\xad\x28\x28\x76\x38\x7f\xa5\x4c\x91\x6b\x74\xb1\x1f\xa2\xeb\x04\xe6\xac\xd7\xa8\xb8\x03\x8b\xbe\x83\xa4\x38\x5e\x6c\x57\xee\x61\xf9\x3a\x1d\x89\x12\x34\x01\x6e\x45\xc5\x71\x9b\x24\xe8\x11\xcb\xf8\x57\x69\xa5\x3d\xfa\xa4\x27\xaa\x08\x5b\x0e\xb1\x5c\x4a\xcd\xb6\x4a\x2a\xbc\x07\x68\x4e\x39\x5a\xda\x29\x68\x01\x27\x7f\xa5\x04\xd8\x4f\x14\xc4\x1b\x33\x58\xf7\x0a\xe7\x0e\x0b\x0d\x28\x28\x67\x3b\x79\x31\x34\xb7\x4b\x59\xb8\x1a\xdb\x91\x71\x9b\xac\x30\xcf\xcb\x01\x33\x5b\xa6\x6c\x81\x33\xe1\x4d\x3a\x87\x85\x65\xed\xe6\xfd\x0a\xe7\x85\x5d\xd6\xbb\x73\xe3\xe0\x39\x9d\xe2\x14\x23\x99\x96\x7f\x99\xc8\x1c\xbc\xd8\xb9\x2b\x87\x0e\xac\xd3\x9d\xa0\x3a\x0a\x5a\x4f\x3e\xf9\x85\x4c\x7e\x5d\xaa\xa9\x8c\xbf\x63\x6c\x0f\x18\x2d\x85\x10\xd7\x7f\xdb\x0b\x9c\xb6\x46\xc3\xcd\x12\x06\xd4\x2c\x8b\xa1\xf0\x0c\xc0\xb6\x70\xce\xef\x01\x6e\x5c\xda\xf4\xb0\x37\xbd\x64\xbf\xfe\x75\xab\x7d\x61\x4b\x9c\x72\x11\x3f\x51\x2c\xe8\x3f\xad\xaa\x6d\x77\xc8\xf1\x7a\x7f\xae\x5b\xc6\x92\x80\x2c\x11\xef\xbd\x36\xb3\x17\x1a\xa3\xc0\xc3\xc4\x15\x91\xa9\x3a\x8e\xfb\x40\xd0\x75\xbb\x93\x0e\x37\x8f\x2e\x2d\xbc\x74\x3f\x61\x3c\xfd\x0b\x02\x42\xba\x92\x53\xd8\x83\x8e\xbe\xb5\xd1\xdb\xd0\x8f\x8a\x5c\x16\x0c\x49\x61\x6e\x82\x93\xf8\x15\x48\x0a\x87\xaf\x67\xdb\x60\x5f\x34\x75\xa3\xb1\xa3\xa5\x81\xcd\x1d\x3d\xb6\xf1\x36\x7b\x41\xc5\xb8\x26\x4a\x73\x2d\x44\x33\xb9\x58\x3b\x28\xba\x70\xf1\x32\xca\xb7\xf3\x0b\x7f\x6d\x24\x86\x5f\x96\xa8\x06\x69\xb0\x1b\xa3\xc9\x55\xf8\x46\x82\x1b\x35\xc6\xb1\x4f\x8a\x23\xcb\x74\x28\xa9\x37\x7a\xdd\x6a\xda\x86\x5d\x3d\xa5\x9b\x50\x08\x02\x8f\xa5\xbd\x3b\x5f\x47\x5a\xe7\x53\x0f\x55\x5f\x72\x26\x9e\x6b\x74\xb6\x68\x0e\x3d\xd5\xa0\xa0\xb1\x6a\x78\xeb\x4b\xcb\x9d\xe7\x8b\x96\x4b\x78\x29\x2c\x06\x21\x80\xb4\x93\x5e\xf0\xdc\x8f\x2e\xd9\x02\x71\xd3\x33\xb6\xbc\x9f\x55\x8c\xe3\x58\xf6\x1c\xc4\x3d\x12\x03\x8d\xa1\x99\x04\xd8\x1c\xd9\xa5\xed\xee\x1a\x21\x6c\xa3\x4d\xb6\x9c\xc0\x19\x7b\x1e\x78\x73\xe6\xdc\x00\xcc\x11\xcb\xfa\xd2\xcc\xbe\xa0\xf9\x3f\x64\xb1\xe4\xf8\xc1\x1f\x08\xf9\xdf\x40\x4c\xe7\xb2\x8f\x16\x4b\xac\xa0\x41\xb8\x9a\xee\x6a\x4f\x71\xef\xd2\x5b\x7e\xa0\xbf\xda\xe9\x40\xaa\x8e\xfd\xcd\x62\xeb\xf7\x1c\x0b\xf7\x2f\x44\x53\x53\xf6\xaf\x83\xea\x9f\x2f\xd9\x3d\xf7\xea\x4b\x86\x81\x4d\x04\xfb\x27\xdc\xa8\x09\x79\xbc\xec\xd6\x30\x80\x1c\x60\x36\x4a\xba\x9f\x05\x2d\x7e\xc1\x3e\x96\xb6\x2f\xed\x75\x31\x34\x85\x38\x55\xc9\xa5\x9c\xd7\x02\x49\xba\x0c\x8e\x41\x85\xb0\xca\x42\x88\xb0\x9b\xce\x75\xc2\xb6\x30\x76\x7d\x2c\xda\x26\xf7\xbd\xc8\x22\x61\xaa\x06\x77\xc1\xf3\x26\xdd\x42\xab\x00\xe2\x0b\xa1\xba\xdc\x45\xe4\xb1\x71\xce\x12\x01\xe1\xfc\x70\xcd\xa3\x83\xcf\xae\xdd\x86\x37\x58\x87\x37\x02\x5b\xdf\x42\x42\x98\xb2\xf9\x60\x73\x7a\xb7\x35\xaf\xad\x63\xff\xd5\xde\x19\x22\x62\x46\x94\x7b\x2e\xfa\x94\x75\xb9\x26\xc4\x91\x1d\x8e\x5b\x41\x88\xbd\x43\xa5\xbb\x5b\xf3\x2b\xb8\xe3\xbe\x79\x25\x2c\x7f\x71\xea\xd5\x5d\x43\x62\x23\x0d\xed\x74\xb5\xf3\x94\x3a\x06\x9d\x88\x14\x06\xec\x06\xd1\x68\xbf\x39\xa8\x31\x1c\x64\x38\x05\x11\x7a\x93\x6e\x32\xf4\x6f\xeb\x27\xa6\xe7\xc3\x94\xf5\x57\xe7\xdc\xc8\xd6\xd7\x86\x09\xdb\xc6\x8c\x9d\x6d\xe5\x8e\xcf\x87\xf5\x62\xb7\xeb\xc2\x41\xac\x6d\xc7\xe9\x9e\x18\x9b\xcc\xcc\x51\x89\xad\xc7\xa1\xfe\x3d\x1d\xdd\xa7\x35\x36\x14\x89\xf6\x5f\x54\xed\xbf\xaa\x35\x31\x96\x7b\x1e\x6d\x6f\x9b\xc5\x9b\xcd\x9b\xf4\xd7\x7c\xd7\x54\xd7\xb9\x9c\xb2\xe2\x64\xc9\xe4\xca\x0c\xcb\xbf\x4b\x3b\xc1\x40\xa0\x75\xfb\x62\x2f\x25\x82\x05\xdc\x50\x0e\xe7\x56\x5f\xe5\xd2\xbf\x05\x9f\xa2\xb5\x39\x28\x4b\x5f\x57\xe9\x5d\x62\xa0\x66\xa8\x7a\x40\xc5\x78\xc1\x73\x06\x37\xc5\xa3\xe4\xe3\x95\xa6\x55\x4a\x3a\xe4\xd3\xeb\x0e\xf9\x4c\x22\x45\x83\x44\x12\xe9\xc4\xf2\xc5\x46\x1d\x31\xbd\xd2\x30\xaa\xe6\x29\xfe\xa2\xfa\x78\x0c\x49\x50\x27\x96\x1d\xa4\x28\xee\x79\x9d\xa1\x57\x6a\xea\xc1\xa5\x94\xf6\xd1\xa9\x02\x29\xb6\xd2\xc5\xa2\xe5\x31\x70\x99\x0d\xb0\xc2\x28\xb4\x7c\x15\x8f\x12\xbe\xbe\x24\xa6\x72\x48\x6c\x12\xb8\xd5\xe0\x8f\x4f\x53\xd6\x72\x85\x1f\xc3\x7d\x95\xf7\x70\xbe\xe7\xda\x0d\x38\x5a\x18\xd7\x74\x1c\xd9\x68\x1d\xc6\x8a\x9b\x2b\xe0\xcc\xab\x1b\x62\xef\x62\xa3\x7f\x72\x9f\x63\xab\x91\x1c\xad\xff\xb0\x12\x5a\x5a\x46\xe6\xd3\x7a\xc7\xb4\xd9\xd7\xcc\xab\x8d\x65\x73\x5f\x27\x96\x56\x39\x15\x02\x1c\xe7\xa1\xde\x8d\xd7\xd4\xb1\xed\x13\xec\x85\x18\xd2\xf2\x0a\x18\x01\xf9\xf6\x27\xfb\xbe\x5e\x98\x7c\x6f\x65\xb0\xc8\xcc\x53\x03\xd0\x41\xd9\xc7\x40\x7c\xb5\xb3\x6f\x86\x98\xa5\xb2\x7c\x3f\xc7\x73\x51\x20\xf1\xf6\xb8\x6f\xba\x63\x20\x12\x10\x4a\xa2\xca\x56\x40\x5c\xe2\xf9\x37\x07\xca\xe3\x6d\x99\xd0\x7e\xf6\xf7\x40\x50\xe7\x27\xdc\xa7\x6b\x79\xe8\xa7\xcf\x39\x3f\x6c\x4f\xee\xfb\xb8\x2e\x66\x1d\xe5\x8f\xb6\x19\xef\xd3\xc7\xd7\x79\xed\x2d\xd8\x6e\xb0\x43\x2d\xe7\x83\xff\xee\x2e\x92\x1d\x51\x0c\x1c\x77\xb5\x78\x55\xec\x39\x0a\x9d\xa6\x84\xc9\x63\xe1\xa4\x2b\x37\x19\x2f\x2a\x5e\x95\xd1\xd3\xca\x79\x6d\x73\x42\x1c\x68\x8d\x81\xb5\x38\x55\xca\xb7\x25\x34\xaf\x6d\x55\xaf\x56\x44\x48\xa7\xd9\x87\x08\x34\xb0\xdf\x7c\x1d\x9e\xdd\x1c\x89\x8b\x8e\xc8\xda\x86\x4b\x4f\x33\x44\x6c\x53\x3b\x70\xf7\x52\x4c\x84\x36\x92\x1b\x2b\x65\xd8\xb1\xc1\x5d\x9c\x0d\x2c\x82\x09\xfc\x74\x24\xcc\x11\xfd\x7a\x29\x95\x0b\xeb\x3a\x38\x14\x38\x21\x91\xed\x5b\xc6\x3f\xa6\xa3\xb5\xe3\x8a\x18\x54\xd5\x20\xa7\x0a\x1c\x6c\xce\x81\x68\xce\xad\xfa\x0a\xe6\xa9\xc6\x30\xfd\xab\x5d\xa9\xee\xf9\xd7\x5e\x2a\xd2\xb4\x4b\x3c\x55\x13\x2c\xb5\xe0\x1f\x32\xe6\x1b\xa0\x89\x3c\xd9\xc9\x68\xde\x26\x56\x33\x89\x76\xf6\x5d\xa3\x0f\x8d\x48\x3c\x9c\x8d\xa4\x0f\x83\xd7\x06\x6a\xab\xb1\x19\x3f\x63\x7f\x91\x5b\xae\xac\x57\xed\x47\xe5\xeb\x2b\x3c\x5b\x0c\x91\x45\x5b\x1b\xab\x8e\xad\x66\xad\xce\x6e\xe7\x8e\x3d\xe6\x46\xb3\x4d\x5f\xa6\x90\x55\xbe\xb5\xe7\xae\x2f\x5e\xb0\xc6\x57\xfb\xef\xe7\xde\xe6\x01\xcb\x11\x10\x6d\xec\xe7\x75\x45\xfe\xa6\xc4\xaf\xb8\xfc\xee\xbc\x2f\x8b\xdd\x56\x0b\x6a\x9c\x68\xa5\xe3\xd7\x4e\x16\x5a\x5b\x47\xfd\x38\xea\x6a\x51\x4f\xc0\x09\xfa\x2a\x64\xf4\x1a\x24\xc2\x4f\x10\x13\x1f\x47\x03\x83\x5d\x3c\x53\x9b\x19\x3f\x6a\xbd\xa5\xcf\x7a\xcf\xdd\xe7\xa9\xa0\x0f\x50\x7f\x5c\x13\xef\xd2\xdf\x21\x17\xc8\x2b\xef\xc0\x51\xa3\x94\x8e\x66\xbc\xf7\x96\x0a\xea\x68\x78\x2e\xba\x82\xb0\x90\x1a\x3c\xfb\xfb\x31\x55\x69\x8a\x44\x7e\x66\xcc\x8b\xd1\x63\x1f\xf7\x96\x22\xd9\x63\xee\x2c\x46\x09\x3a\xe0\x89\xaa\x3f\x8a\x43\x5f\x54\xb0\x4e\x54\x04\xe6\x7b\x41\x75\xd0\x21\x5a\x12\x3d\x2e\x89\x52\x04\x0d\x24\x35\x34\xcf\x44\x18\x0a\x0c\xd3\xae\x04\x3d\xc3\x4f\x25\x0b\x52\x2b\xf7\x09\x19\xb3\x89\x02\xcc\x8c\x45\x1e\x04\x3d\xb8\xe5\x37\x4c\x80\x05\xc8\x35\x62\x36\x8f\xd3\x29\x29\x9f\x11\xb3\xb7\x90\x4b\x88\x09\xce\xe3\xd2\x4b\xa7\x4c\x8a\x37\x9a\x86\x95\x49\xf9\xf1\x0e\x2d\xfd\x61\xee\xa2\x5d\x6c\xbf\xc5\x9f\x6d\xdc\x64\xa7\x65\xf5\x18\x8b\xc9\x1f\xa6\x0d\xab\x91\x54\x5a\x95\xfa\x72\xc8\xee\x1b\x90\xd6\x35\x1e\xae\xbb\x6e\x8f\xca\x35\x27\xcd\x34\xb2\x67\x75\xa2\x3f\x2e\x0b\xb8\x88\xf9\x32\x3f\x26\x0e\x86\xbe\x5c\xa8\xba\x36\xf7\x38\xc4\x2f\xe7\xec\x1e\x55\xae\xc3\x5f\x2e\x0f\x2b\xd6\x35\x08\x1e\x07\xce\xe6\x81\x6b\x46\x4e\xd5\x55\x11\x72\x15\x23\xf4\xcc\x52\x1b\x9b\x3c\xee\xf9\xe3\x46\x8c\xa1\x37\xcc\x56\x65\xd2\x56\xab\x39\xb3\xea\x4d\x43\xd5\x3e\x97\x06\xa6\x50\xbb\xd5\x24\x1c\xe2\x50\xec\xc9\x9d\x92\x83\x42\xd4\xa6\xea\x6d\x7e\xba\x90\xeb\xcb\xea\x52\xe6\x8b\x36\x41\x01\x8c\x1d\x02\x0a\xa8\xd8\x45\xc9\x28\x29\xf2\xe6\x32\xa6\xd8\x74\x70\x86\x63\x40\xe4\xd0\xe0\x69\x2a\x9e\x59\xce\xcd\xf6\xbd\xac\x61\x49\xf1\x94\x7f\x74\xc1\x20\x49\xb6\xc9\xf0\xe7\xae\xf0\xa8\xed\xcb\xfa\x38\xff\xb6\xb8\xe1\x5f\x17\x01\x60\xd9\x8b\xf0\x17\x3c\x1e\x03\x53\x8d\x40\x7e\xaa\xc8\x40\x70\xea\xbe\x31\x07\x44\xd7\xfc\x14\x2f\xe7\x36\x42\xbd\x6d\x82\xbd\x13\xab\x05\xc3\x2a\x5f\xe8\x80\xd0\x0f\xac\x9d\x36\xeb\x3f\x6f\x5c\x95\x5f\xed\xe2\x4c\x38\xee\xc0\xfc\x6a\x5f\x42\xf8\xd5\x64\xd0\x3d\xa3\x96\x6f\xf5\x95\xbc\x03\x91\x4f\x9a\x62\xb1\x6b\x78\x80\x46\x58\x36\xbc\x02\xac\x65\x52\x02\xa4\x3c\xf5\xf5\x28\x7d\x27\x14\x1b\x46\x9f\xdc\xd2\x26\x4e\x5f\x3b\x40\x6d\x98\xb7\x0d\xea\x2b\xd7\x26\x3b\x3d\xcd\x39\xf8\x5b\xb0\x77\xdc\x68\xd9\xf9\xa2\x0e\xe4\x87\xa3\x8e\xe7\x96\xbd\x85\xc5\xc7\xb0\x8f\x23\x0f\x92\xd2\x40\x0a\x45\x9b\x25\xc8\x2d\xc8\xa7\x9a\xda\x6d\x02\x8f\x37\xe5\x36\x69\xa0\xf7\x14\x79\x79\xe6\x8f\xf2\xc5\x2d\x53\xee\x8d\xd8\x4e\xbe\xb7\xd2\x8a\x77\xf4\xfc\xe7\xfa\xb6\x64\xe9\xbf\x90\x94\xc1\x76\x08\xf9\x0b\xdc\x40\x7e\x0f\x52\x4f\xf9\xf0\x81\xf4\xc2\x27\x62\x33\x2c\x9d\xe7\xd1\x75\x83\xd2\xd5\x74\x49\x87\x7a\x90\x1f\x82\xa6\x41\x3d\x45\x5d\xe6\xfc\xc9\x25\x10\x7e\x2f\x0e\x9f\x58\xdf\xdf\x2e\x5c\x62\x07\x22\x1c\x9d\x86\xdf\xe6\xe7\xda\xac\xe4\x2c\x6b\x4e\x13\xfd\x83\x6b\x31\x90\x38\x4a\x81\x49\x2b\x25\x68\xcf\xd7\x30\x24\x69\xd5\x2d\x37\xe8\xfd\x21\x8d\xac\x85\x7e\x10\x6b\x16\x0a\xbf\xa7\xd7\x18\x2f\x4b\xea\x9a\x07\x81\xb2\x7a\x89\xb3\x2e\x41\x44\x08\x78\x90\x48\x59\x8a\xbe\xee\xe7\x7d\xfe\x4a\x94\x2e\xb0\xda\xae\x82\xde\x92\xda\xd5\x7c\xce\xfb\xe0\x1d\xf0\xbc\xd1\xf4\x24\x42\x16\x38\x36\x94\xb4\xe8\xca\xe2\xce\x79\x69\x60\xba\x1a\xe9\x8f\x43\x30\x6c\xb1\xf6\x7d\xa9\xc7\xfd\xcf\x66\x50\x66\x27\xf2\x11\x2c\x24\x92\x25\xe2\x43\x64\x16\x4e\x31\xcc\xe0\x8b\x32\xe8\x01\x54\xcd\x24\x28\x28\x65\xd9\x1e\xab\xd8\xc8\xc1\x9b\x1e\x1d\xed\x75\x46\x4e\x27\xd0\x73\x7f\x84\x6d\x7c\xd2\xb1\x38\xa7\x19\xd2\xb3\xc7\x22\xf1\x4a\x7a\xd3\xf1\x5e\x0b\x8f\x05\x97\x2f\xf9\x65\xa1\x55\xff\x06\xd9\x51\x38\xa4\xc1\xad\x99\x10\x72\x15\xc0\x71\xcf\x19\x40\xd7\x0b\x8e\x29\x88\x1b\x04\x93\x9a\xd5\x33\x57\x09\x89\x79\xad\xce\x90\xb8\x30\x95\xbb\x6f\x1b\x35\x82\x58\x53\x65\xa2\x18\x83\xa5\xcd\xf4\x39\xba\x74\x64\xba\x4e\xf8\xac\x55\x5d\x65\x9a\xd8\xe5\xf8\xd4\x76\x0a\x8b\x85\xa1\xc3\x34\x39\xa0\xd4\xc0\x31\x26\xed\xeb\xfc\xf3\x98\x2c\x2c\xd9\x3a\x88\x79\x99\x5d\x0a\xdd\x44\x1d\x36\x8c\x4b\xc8\xb7\x22\x47\xf8\xad\xf5\xac\xa7\x35\xcb\x21\x2e\xae\x5f\x5b\x08\x40\x84\x97\x10\xfa\xdb\xde\xf8\x75\xf7\xdc\x39\xfb\xab\x9e\xed\x29\xf3\x99\x8b\xf5\x42\x9c\x7b\xd1\x2a\x7b\x6b\x3b\xcc\x8f\x45\x28\xe9\x75\x1f\x37\x96\xbc\x59\xeb\x11\x09\x42\xf4\xb6\xa7\x73\x7d\x17\x69\xe3\x97\xc5\x62\x15\x6d\xa1\x97\x8c\x10\xfa\x11\xce\x56\x52\xb5\x1f\x06\x03\x96\x09\x87\x5f\xe3\x66\x0d\x53\x59\xdb\x25\xcc\x2a\x7d\x44\xdf\x7c\xb4\x15\xac\x2e\x08\xc3\xa7\x9f\xc0\x57\xca\x9c\xa5\xf2\x83\x6a\x36\x30\xdb\x14\x0e\xea\xdb\x47\x39\x24\x1d\x0c\x0a\x18\x80\xcb\xa3\xc7\x54\xbe\x33\x7f\xa1\xb0\x4c\xce\x8d\xb3\xf9\x6f\x51\x00\x2a\x46\x8d\x7f\xfd\xae\x91\xdf\x34\xab\xc5\xc2\x33\xab\x05\xc7\x82\x16\x3a\x02\xa6\xc0\xb1\xd5\xd9\x59\x04\x0e\xa1\x0c\x2a\x23\xba\x61\x39\x37\xa7\xb5\x1c\x89\x6b\x49\xa0\x65\x1c\x81\x83\x96\x1c\xed\x7c\xee\x62\xa9\x0b\xc1\xdb\x2b\xa7\xc4\x00\x12\x0d\x1d\x82\xb1\x31\x99\xd0\x4a\x54\x01\x95\xd4\xce\x0d\x82\xb7\x7f\x0c\x9a\xc5\xc8\xc8\x9a\xfd\x79\xcc\xc6\x01\xd2\x99\x38\x40\x16\x93\x4b\x6e\x00\xce\x59\x27\xa2\xc1\x8d\xff\x2e\x3b\x20\xba\xe2\x1c\x4c\x68\x42\xac\xa1\x27\x69\x2f\x90\x3a\x8b\x4c\x34\x8a\x4f\xd9\xfa\x76\xe2\x6f\xf5\x32\x13\xfd\xa1\x6d\x67\xa7\x5d\x55\x45\x4f\x4f\xc5\xed\x64\x4d\xc4\x9f\x06\x87\x25\x2d\xe5\xc1\xc1\xb5\x7c\x29\x1a\xe9\xc1\xd5\x2c\xc3\xb5\x87\x40\xff\x81\xb8\x25\x9b\x46\x08\xd0\x7e\x2e\x3c\x8e\x9b\x82\xd1\x19\xa0\x7d\x99\x7b\xb7\x6c\xcc\xae\x96\xb0\xcb\x98\xc5\x77\xe8\x89\xe6\x53\xd9\x66\x89\xb0\x3b\x43\x04\x35\xaf\x38\xcc\x92\x26\xe3\xae\x55\x38\x07\xef\xcd\xc1\xa3\x5e\xaa\x70\x4f\x94\x11\xf9\x3e\x4f\xd6\x97\xdf\xba\x3d\xba\xe2\xaf\xab\xe7\x0e\x6f\x24\x9f\xde\x20\x2f\xeb\xbf\x9c\x9a\x0d\xea\x08\x9e\x4f\xe2\xad\x12\x5f\xfd\x58\xa2\xf2\xcd\x81\xe2\xdb\x76\xdc\xfc\x6d\x7d\xe5\xea\xb9\xa8\x91\xcb\xd7\x1b\x9a\xc2\x77\xcb\xda\x16\x7d\xef\xde\x1d\xd4\x83\x39\x50\x66\x92\x8b\x21\x9f\x14\x2e\x3a\x9d\xcf\x6c\xff\x84\x93\x5f\xa5\xd3\x32\xc7\x55\x41\x8e\x03\x9e\xf4\xf9\xff\x89\x3e\x5b\xe6\xf1\xec\xa6\x45\xa7\xc6\x27\xce\x0f\xc8\x36\xd4\x24\xdd\x65\xd1\x1f\xee\x06\x54\x5d\xd9\xa9\xfe\xa0\x18\x2f\x39\x9f\x43\x41\x2d\xfe\xac\xda\x65\x66\x15\x2d\x40\xd0\xc8\x6d\x73\x3f\x54\xa6\x6e\xdd\x95\xe2\x8c\x88\x02\xc4\x1a\xb5\x44\x3e\xa0\xf2\x67\xbb\x0d\x76\x2d\x4d\xdc\x61\x3d\xd0\xc7\xa1\xe2\x1c\x07\xaf\xe2\x10\x10\x60\xfe\x7d\x65\xbe\x27\x5b\xd6\x74\xc9\x2c\x47\xc8\x27\xdc\x6f\x6f\xab\xb7\xea\x9a\xf6\x0e\x90\xa0\xa5\x9b\x84\xc6\x79\x7b\x36\x03\x1a\x83\xa4\xcd\xe8\x9d\x64\x54\x29\x29\xcf\x81\xe3\x0c\xbb\xb3\xd8\x51\x2c\xce\x20\x3f\xff\x3a\x58\x9c\x41\x7a\x79\x42\x2c\xc9\x72\x87\x83\xe7\xa1\xfd\x1d\x79\xdd\xc2\x08\x4d\x08\x06\xc6\xa2\xee\xb6\xe2\x4e\xd1\x1f\xe4\x6b\x6e\x28\x7b\xe8\x71\x29\xb1\x5e\x56\xec\xb5\x82\xef\x40\x69\x0a\xd0\x82\xda\x43\xcd\xbd\x3f\x37\x25\x43\x18\x34\x0f\xba\x46\xe4\x6a\x0b\x2d\x79\x44\x5c\x3d\xd5\xc8\x62\xc3\xe6\x03\xec\xbe\x15\x25\x67\x11\x26\xd3\x0b\xaa\x48\x35\x89\x3b\xc0\xc4\x43\xd9\x48\xb4\x7f\x2f\x8b\xb6\x7d\xbe\x0b\x85\x2e\x57\x0a\x41\xb4\xe8\x1a\x86\x01\x7d\xf1\xcf\x16\x7d\xbd\x78\x77\x44\xf7\x98\x34\x8b\x48\x2e\xb5\x42\xfa\x8d\xdd\x07\x03\xaf\xe8\xab\xf5\x03\xd1\x2b\x6d\x46\xf2\x3d\xa2\x91\xa4\x56\x38\x87\xd3\x41\x8c\x65\x87\xce\x9a\x41\x17\x73\x8c\xf1\x27\x9e\xab\x6f\xd0\xee\x55\x96\x7a\xdd\x9a\x2e\x52\x54\x5c\x67\x80\x95\x84\xeb\xd6\x7c\xc5\xc0\xa5\xef\x6d\x76\xb6\x2e\xa7\x4a\x54\xb9\x9b\x0e\xa3\xfa\xb5\x52\xe8\x4d\xda\xa3\xa6\x60\x97\xac\x9f\x48\x26\x9a\xa5\x95\xd6\xea\xdf\xca\x2a\x9a\x2d\xb2\xe2\xb2\x1c\x79\x6a\x5e\xaf\x48\x20\xb1\xc5\x26\x62\x9e\xa1\x9b\x69\x56\xca\xd8\x5b\xba\xfb\xc5\x4f\x73\x98\x1a\x7f\x7e\x7f\xd7\xcc\x71\x58\x20\x7c\xea\x09\x14\x25\x60\xb7\xe0\x5e\x3a\x2c\xcf\x1d\x74\x45\x65\x24\xeb\xc1\x9b\x81\xc3\x77\x53\xa3\xa6\x19\xd4\x2c\xbc\x21\xbc\x6c\x1f\x91\xac\x9e\x4e\xfd\x3a\x2f\x5d\xea\xca\xfb\x16\xfc\x6a\x78\x8f\xc4\xb2\x28\x59\xda\x61\x74\x24\xb5\x79\xd3\x79\x61\xcf\xca\x76\x85\xcf\x27\x3d\x17\x1b\xcf\xe7\xbe\xed\x29\x44\x92\x85\xa5\xdf\x46\xc6\x16\xe0\x03\x63\xe6\x96\x49\xad\x71\x47\x0e\x8f\xfd\x5b\x93\xe3\x61\x37\x5d\x5c\x02\x4c\xf7\x47\x29\x62\xa9\xd3\xb7\xb7\x9b\x0f\x14\x23\x14\xdd\x5e\x71\xbd\xf6\xd2\xfe\x4a\x5c\xae\x05\xec\xbd\x12\xf5\xed\xad\xf6\x40\x8c\x1a\xe0\xb8\xec\xe5\xd9\xa3\x71\x54\x1a\x3f\xd1\x9c\x53\xb5\x20\x45\x9a\xd1\xd3\xaa\xf8\xdc\xb2\x68\xef\x99\xd1\x07\xc9\xb3\x38\xd6\xb4\x40\x52\x75\x81\xbf\xe2\xd1\x58\xee\xbf\x16\xdb\xaf\x0b\x33\x8d\x38\x37\xa4\xd7\x5d\x80\xcd\xb4\x39\xe7\x6d\x8a\x30\xc3\xab\xe6\xee\x57\xd7\xbe\xcc\xe7\xee\x37\xe2\x9a\x44\x29\xd5\x9f\x73\x74\x6d\x30\x08\x57\x68\xb3\xd6\x54\xa4\x6c\xa7\x50\xbb\xa9\x89\x05\x59\x40\x76\xd4\xed\x78\x83\x1d\x5b\x91\x5b\xce\x58\xd9\x0c\x96\x9a\xa3\xe1\x95\x0f\xcb\xbb\x50\x80\x3d\xb2\x91\x6c\x8f\x8c\x80\x04\x43\xf9\x9d\xd6\xed\x51\x92\x8d\x4d\x52\xf1\xd9\xc7\xce\x8a\xe4\x6e\xd8\xb2\xa9\xd0\xcc\xb1\x9d\x64\x0d\x47\x9e\x70\x6c\x14\x44\xcc\x58\x6d\xc7\xf2\x95\x7e\x4f\xc1\xeb\xe1\x26\x9f\x17\x1d\xdf\xca\x7c\x3c\x6f\xa1\xdb\x40\x52\x44\x7e\xae\x51\x10\x06\x47\x79\x08\xd2\x39\x41\x47\x30\x9c\x57\xd5\x97\xe4\xbe\xbd\x33\x9b\x5b\x46\x33\xc3\xce\xee\xdc\xb1\xb2\x96\x5f\x6b\xc0\xfc\xd1\x47\xb2\x3d\xae\xf4\xa2\x89\x47\x18\x8e\xb7\x2e\xae\x85\xed\xca\x61\x24\x55\x1f\x4f\xc7\x8e\x97\xd3\xcf\xd9\xfe\x83\xab\x6f\x9a\xcc\x89\x94\xd5\xe6\x6c\xb7\xdf\xda\xc7\x29\xb6\x52\x41\x93\x94\xb0\x87\x15\x44\x68\xd0\x14\xc1\x2b\xbe\xe3\x77\xbd\xa1\xf0\x07\xcf\xac\x55\x79\x8c\xa0\x01\x4a\x3b\x1c\x7d\x3e\x61\x55\x01\xf1\x3b\x1e\x2f\x4e\x27\xe9\x32\xef\xef\xc0\xdc\x09\x4e\x4d\xdc\x81\x23\x27\x6e\xf5\xf1\x6a\x27\xe0\x07\xe2\x75\xee\xf7\xc0\x9c\xd5\x20\xf4\x95\xe0\xb0\x17\x0b\xe6\x89\x32\xa6\xec\xdb\x14\x72\x98\xba\x20\xae\xb4\x2f\x5e\x27\x14\x6d\x36\x82\xe9\x0b\xc9\x04\x2b\xc6\xc7\xbc\xc0\xdb\x41\x78\x1c\x2f\xd1\x0f\xbb\x0f\xef\x2d\x03\xf2\x3f\x6d\xb5\x17\xf0\x4f\x67\xd7\x1d\x0d\xb5\x95\xc1\xef\x9c\xd3\x33\xff\x5e\xcd\xb5\x9d\xf3\x9c\x9c\x83\x4a\xb5\x05\x23\x5e\x5e\xc1\xeb\x45\xeb\x81\x9a\x9f\xf9\x58\x60\xa4\x4b\xc9\x5f\xd2\xae\xc9\xe7\xd3\x0c\x58\x02\x11\x14\x12\x50\xd8\x02\xe9\x70\x22\xf6\x89\xc1\xe3\xd5\xd6\x9c\x5e\xa2\x82\x8e\x82\x71\xe5\xa2\x38\x45\xc5\x2f\x09\x96\xb4\x09\xaa\xd7\x50\x94\x6d\x71\x92\x8f\x45\x2b\xea\x02\x2e\x12\x94\xcf\x42\x71\xfa\x60\xc8\xc4\x2f\xaa\xe2\xb8\x98\x14\xbb\x85\xd0\x22\x84\xe1\x0e\x45\xac\x0a\x99\x59\x41\xff\xf7\x40\xde\xf8\x91\x60\xd4\xdc\x3c\x0c\xca\xd1\x80\xc1\xe9\xe6\xd3\x69\xe8\xe8\xc9\xe2\x10\x3e\x81\x8f\x04\xda\x59\x5d\xa8\xf4\x3c\xa6\x4f\x30\xb2\x62\xd6\x4c\x3b\xc8\x3e\x77\x9b\x20\x36\x86\xbd\x9a\xdd\x16\xd0\x21\x50\x19\x83\x7c\x27\x2c\xda\x13\x69\xd4\xe5\x9a\x84\xb3\x11\x2b\x1c\x9a\x47\xce\x65\x10\x85\x02\x31\x03\x6d\xea\xe3\x44\x61\x24\xee\x63\x10\x84\xd8\x0e\x88\xf8\x76\x4f\x79\x0d\x1c\xa2\x23\xea\xcf\x7d\x95\x3f\xad\xef\x3d\x5e\x5f\x49\x7b\xcd\x8e\x37\x0f\x9e\x5b\xc4\x01\xcc\x28\x99\x5a\x05\xa6\x01\x31\xd0\x69\xaf\xe1\x95\xf1\x62\xa8\x33\xa1\xee\xed\xc1\x62\x5c\x51\x74\x36\x0a\xa6\xec\x93\x40\xbd\xc5\x58\x74\xe6\x6f\x37\x20\x68\xeb\xbb\x80\xdb\x31\xd9\x60\xac\xca\xaf\x68\xc8\x1b\xc4\xfb\x7f\x32\x1a\xa1\xe4\xe2\xff\x38\xbf\xf8\x6c\x1b\x76\x41\x1c\x31\x6e\x40\xc5\xf4\x91\xf1\x2e\x80\xb0\x7b\x17\x14\x33\xb8\x3d\x44\x9d\x56\x83\x5d\xe5\xd9\x5e\x8d\x22\x6a\x74\xb8\xd9\x4b\x90\xc6\x81\x06\x61\x67\x51\x4f\x06\x6e\x8e\xdd\x3d\xea\x8c\xa1\xe0\x3b\x6c\x22\x58\xf3\x17\x59\x7c\xd9\x54\xa8\x51\xaa\xed\xf1\xe2\x8f\x99\x27\xf0\x3b\x75\xde\x1d\x4b\xaa\xbc\x85\x40\x31\x9f\x03\x44\x75\xcb\x49\xb3\xc8\x0c\x06\xee\xe6\xce\x8d\xd0\xe0\xfd\x6e\xc6\x08\x4f\x16\x7a\x80\x61\xe0\x19\x8e\x96\x99\x1e\xc8\x09\x6b\xef\xce\x01\xac\x68\xa1\x40\x7b\x05\x6b\x11\x50\xd9\x34\x44\x93\xa5\x77\x92\xe4\xf0\xf1\xb8\xe5\x5d\xc9\xb7\xd6\x96\xf9\x02\xf4\xd4\xdd\xd9\x3d\xee\x1d\x82\xf7\xf5\xa9\xb8\x9b\x87\xc2\xc2\x33\x1e\xc6\xec\x5b\x36\xc6\x72\x96\x0d\x6d\xe4\x05\x26\x85\xff\x8f\x21\x43\x43\x15\x2b\x3c\x9d\x32\x57\x4e\xa4\x9e\xfa\xe8\x3f\x74\x74\x6d\xbf\x2d\x53\x6c\x9f\xc0\xc7\x9a\xe0\x19\xf3\xa0\x32\x2b\x82\x79\xbb\x54\xa2\xc6\x2e\x63\xbe\xdd\x3f\x6e\x8c\x6c\xbb\x7f\x2f\x63\x8d\x4f\x6c\x05\xf0\xb6\x1c\xd7\x0d\x02\x21\xa2\x9f\xa7\x2a\xc0\x4c\xdc\xe3\x0c\x98\x03\xf9\x05\x91\x80\x3b\x01\x60\x49\xea\xf6\xab\x7f\x91\xb9\x07\xad\xa9\x26\x40\xcc\x58\x1c\xe3\x2c\xfd\x08\xe4\xe3\xe1\xfa\x0a\x23\xc7\xfa\xa0\x41\x55\x4c\xd4\x30\xde\x66\xd9\x98\x3e\x02\x0d\x47\xf9\x38\x44\x43\x28\x27\x9c\xa8\xc5\x72\x85\x60\xdc\xad\x61\x1d\xcb\x9b\x1d\x0a\xec\x96\xa0\xff\xa6\xc3\xe3\x15\x4a\xdc\x5d\x0a\x5d\x84\xaa\x73\x81\xce\x74\x92\x4f\x67\x71\x9e\xd5\x2c\x70\x2a\xa7\xa8\x63\xef\xd1\x59\xb6\x6d\x82\xa6\x91\xa1\x42\x0d\x51\x15\xf2\x5f\x79\x89\x8a\xe2\x87\xa1\x9a\x21\xa6\x71\x52\x47\xf8\x51\x12\x2a\x3a\x2d\x81\x0d\xcc\x48\xf9\xbd\x8e\x76\x06\x2b\xa3\x22\xb6\x86\x41\xff\x93\xa1\x93\x90\xa7\x27\x8b\x46\x17\x22\xfe\x7e\x3b\x09\xf8\x9b\x43\x4b\x33\x19\xe2\xeb\xc7\xdb\x5d\x0d\x33\xfc\xc8\x77\xff\x5c\xec\x74\xf8\xb4\xeb\x0f\x79\x31\x8f\x5b\xaa\xb2\x6d\x8a\xa1\x10\x9b\x71\xa5\xf6\x83\x77\xe4\x4a\x12\x0b\x2c\x66\x87\xdb\x8a\x8c\x5b\xbf\xd2\xbc\xb8\x91\x7f\x87\x19\xb8\xfa\xd9\xae\x89\x8c\x83\x38\xa4\xb0\x60\x8f\x85\x1b\x64\x9f\x4a\x8d\x82\xe4\xd4\x08\x5d\xd9\x4b\xc4\x94\x40\x98\x52\x22\x6c\x6f\xfa\xf6\x6d\x95\x63\x51\xb7\x14\x16\xc1\xbc\xec\x9a\x0e\xc8\x10\xf4\x01\x01\xea\x05\x4a\x98\x72\xdf\x5b\x07\x6c\x2c\xbd\x54\x6e\x3a\x23\xe6\x2d\x17\x78\x84\x2a\x99\x52\xcd\xcf\x5d\x5e\x3a\xf4\x23\xfa\xe2\x8c\x8a\x6c\x86\xfb\xf1\xe2\x58\x43\xae\x4b\x05\x00\x39\x87\x35\x84\xb1\xaf\xa1\xb5\x07\x59\xa2\x9e\xd6\xc6\x31\x7d\xd8\x77\xc2\x15\xd9\xc4\x37\x02\x28\xc3\x21\xc7\x2d\xc2\x27\xcd\x89\x50\x01\x48\x5d\x82\x56\x46\x76\x0b\x59\x3a\x4d\x85\xf9\x1e\x1e\x37\xc5\x8d\x1b\xa6\x1f\x28\xa2\x5c\xf5\xf6\xe7\x05\xd9\x96\xa8\x57\x6a\x56\x57\xd1\x0c\xb3\xf9\x03\x37\xf5\xce\xbe\xff\x98\x22\x40\x1d\x1e\xf6\x94\x1d\x05\x77\x57\xf2\x76\x6e\x9e\xab\x6e\xa7\x5e\xa7\xa6\x2b\xd7\x03\xd0\x52\x9d\x4a\x09\xbc\xbd\x47\x5a\x4a\x73\x74\x59\xf7\x82\x61\x2e\x96\x2c\xab\x40\x58\x7e\x3a\xb6\x61\xb2\x05\xb8\x6d\xc5\xb3\xa5\xcf\x5b\x66\xda\xc1\x7b\xa9\xde\x3c\x5a\xe8\xd3\xed\x9d\x43\x77\xf0\x7e\x04\x0a\x3c\xba\x6b\xdd\xdd\x1e\x2c\xb6\x2d\x59\x97\x44\x3f\xe9\x6a\xda\xf8\xb7\xad\xe6\xd3\x9f\x40\x63\x31\x0d\x71\xde\xd6\x53\x37\xe7\x53\xb5\xd8\xda\x79\x77\x11\xba\xdf\x67\x31\xe4\xb4\x39\xb7\x18\x3a\x58\xd7\x93\x4a\x2f\x1a\xb3\x0f\xb4\x9c\xe4\x02\x9b\x4f\x85\xe6\x94\x99\x63\x4c\x28\xcd\x61\xb5\x4b\x5c\xe1\x50\x1f\xe5\x87\x6e\x8b\xf0\xcc\x15\x2a\x4a\x33\x5d\xc3\x80\x8d\x5b\xbc\xbe\x92\xcd\x3b\x51\x2e\x35\x62\xdb\x35\xee\x0d\x78\x9f\xa5\x9a\xeb\x9a\x2b\xdb\x07\x58\xb4\xcd\x2f\x22\x4e\xe4\x0a\xb1\x95\xb6\x4d\x86\xad\x83\x01\x71\x5f\xee\x06\x6c\x6c\x38\x96\x2d\xef\x2f\x32\x52\x5e\x5f\xcb\x91\xa4\xea\x2d\x41\x1e\x64\x59\x43\x23\xf2\xc9\x6b\x94\x71\x95\x75\x3a\xc8\x8f\x1c\xb8\xec\xc2\x55\x0e\x52\x75\x5b\x9f\x7a\x7b\x57\x64\xef\xac\x91\xf4\x0d\x5c\xaf\xe7\x30\x38\xfb\x43\x31\x28\x6e\xbc\x10\xd6\x35\xc7\x36\xfe\x6b\x91\x9d\xd5\xeb\xd6\xd8\xda\x93\xb3\x35\x04\x57\xe4\x51\x4c\x62\xc8\xc5\x20\x94\x74\xfc\xa9\x0a\xec\x90\x6e\xce\xcc\xc8\x18\x64\xfc\xe3\x76\x4d\xe9\xb3\x3e\xb3\xdd\xab\x07\x4e\x7d\x78\xa9\x00\xbc\x09\x38\x25\xec\x10\xed\x80\x98\x30\xde\x70\x2a\x01\xb1\xbd\x2c\x94\x0e\x4c\xf8\xb5\xab\xfd\x5f\x02\xa1\x0f\xaa\xa6\xdc\x9f\x78\xfd\x10\x70\xd4\xbc\x84\x3f\xa4\xd6\x1e\x08\xc7\x74\x5e\xba\xd8\x22\x43\x1a\x85\x93\x05\x96\x87\xd9\x3c\x98\x05\xac\x2a\xac\x43\x26\xa2\x05\x12\x29\x16\x75\x5f\xf7\xaf\x5d\x7e\x04\x77\x01\x7a\x61\xbc\x84\x98\xe2\xde\xbd\xef\x1f\x54\x8c\x89\x43\x3e\x77\xa2\xb5\xb4\xc4\x53\x68\x07\x83\xfd\xf8\xb2\xed\x6c\xa7\x96\x4d\x87\xc4\x3d\xa5\xde\xb7\x58\x7b\xed\x09\x96\x69\x07\x33\xca\x83\x9f\xc4\xa4\x69\xd1\xd0\xd6\x04\x1a\xf2\x86\x7b\x14\xb4\x73\x33\x99\x31\x4e\x1e\x01\x28\xfb\x6f\xc1\xe9\x4b\xc1\xb5\x04\xf5\xda\xdc\x34\xa7\x16\x0d\xc3\xf0\x98\x34\x03\xb2\x62\xa0\x67\x95\x60\x7c\x52\x24\x1d\x66\x74\x1e\x76\x57\x6c\x5a\x57\x77\xdc\xee\x89\x2b\x06\xdb\x3e\x18\xcf\x9c\xb3\xf4\xd6\x51\x30\x07\x50\x5a\x23\xbc\x43\xf6\x0e\xf6\x78\x83\x5d\xa3\xbc\x26\xc8\x4a\xb0\xf8\xe8\x6c\x61\xce\x94\x47\x45\x93\xbb\x78\x07\xab\xd1\x89\x7e\x60\xcc\xfe\x0d\x73\x24\xe1\x65\x69\xc8\xdd\x8c\xfe\x47\x0b\xf0\x60\xd9\xb0\x5c\x5b\xb2\x1e\x9e\xa0\x4a\x45\x00\x02\x99\x53\x6d\xe2\xaa\x3e\x3d\x45\xff\x2e\xb8\xe6\xfa\x6c\x7f\x7a\xa1\xcd\xe7\xbc\x52\x07\x3d\x3a\xc8\xce\x59\x15\xcf\x8b\x80\xe8\x68\x0f\xf0\x48\x9b\x4d\xfb\xe4\x47\x70\x18\xa7\x21\xb7\x83\x41\x04\xdf\x46\x73\x43\x9a\xc5\x0c\x2e\x66\xf5\xed\x93\x83\xc6\x74\xd9\xc4\x35\xea\x38\xfd\x18\x68\xd5\x87\x55\xf9\x9c\x10\xd8\x4e\xbd\xa9\x3f\xfb\x0a\x79\x06\x63\x27\x40\x7e\x13\x14\x43\x9d\x7f\x69\x9c\x59\x53\x5d\xef\x8f\x55\x77\xa1\x9b\x2d\x4f\xb9\x37\x9f\xa0\xf1\x16\x4e\xf3\x59\xea\x70\x0b\x01\xe5\xeb\x66\xeb\x3d\x31\xd1\x6f\xe5\xcc\x73\x30\xe6\xfb\x16\x8e\xf1\x8f\x41\x65\x34\x5a\x58\x03\x1c\xca\x58\x2e\xd1\xbf\xc6\xcc\xbd\x56\x14\x78\x10\x5c\x3a\x9f\x77\xda\x0d\x53\x39\x86\x5f\xfe\x24\x62\xa2\x44\x26\xd0\x95\xa6\x3b\x85\xf7\xa5\x55\x46\xdc\xa0\x3f\x84\x6b\xfd\x89\x29\x3e\xdc\x4b\x27\x44\x61\x6b\xbf\x07\x05\xfe\x88\x5d\x2d\x0f\xa1\x49\xd4\xac\xda\x1c\xa3\x49\xce\x73\x4d\x85\xfe\xf8\x9a\xbd\xfc\xc3\x09\x86\x7b\x13\x6b\xed\x74\x68\xa2\x19\x7d\xef\xe5\x99\xff\x91\x5b\xf7\xd2\x7f\x29\xb5\x7a\x70\x77\x73\x36\xb4\x8d\xbd\xc2\xba\x8d\x85\x62\x3f\x89\xec\x95\xdf\x41\xa1\xc8\xc4\xb1\xf0\x8c\x09\x85\xbe\x2b\x4d\x13\x03\x1c\xbe\xa0\xbb\xd6\xa4\x39\xb6\x87\x4e\x14\xe7\x5f\x8c\x3a\x22\xfe\x34\x5f\x1e\x8e\x22\xe0\xff\xfd\xd5\x19\xf9\xd7\x52\x9a\x95\x8f\xa5\xfb\x44\xdc\x02\xb5\x35\xd7\x85\x05\x88\x9b\x9d\x65\xd5\x72\xba\x44\xd4\x4d\x00\xf1\x88\xd9\x48\xeb\xf7\x63\xb8\x2c\x14\xcf\x7a\xc4\xe2\x79\xbf\x56\x7f\x1d\xcf\x62\x14\x16\xa1\x38\x7b\xe9\xf3\xde\x66\x37\x43\xcd\xcd\x69\x43\x18\xd9\xe5\x1b\x9d\x2b\x44\x66\xf4\xdd\xe9\x8d\x97\x87\x6f\x94\x25\x00\xc7\xa2\xc0\xf1\x6c\xde\x19\x26\xf7\x6a\x0e\x93\xd1\x06\xdd\xa6\xfc\x55\x7a\x5a\x30\x62\x6a\x74\x3f\xe8\x6c\xf5\x8d\x8d\xa1\x72\xae\x14\xde\x56\x23\x10\x66\x9f\x4e\x4a\x6f\xc1\xa6\xc2\xbd\x28\x33\xda\x82\xd5\xb0\x11\x8b\xbf\x11\xf3\xb0\x11\x9b\x1f\x18\x63\x91\xc8\x29\x99\x2e\x1c\xed\x22\x20\x0a\x15\x9b\x62\x10\x63\xed\x8b\x89\x0f\x00\xef\x90\x96\x93\xc0\xe5\xd5\xdb\xb3\x68\x37\xe1\x4a\x48\xe2\x93\x18\xf5\xaf\x92\x24\xc2\x1e\x83\x4d\x61\x53\xae\x72\x1b\xa9\x6b\xb6\xb7\x79\xd8\x3d\x9e\x0e\xfc\x3c\x56\xe2\x4c\xc2\x1f\xf2\x93\xf1\x9a\x7a\x27\x9a\x8f\xe7\xf8\x47\x05\x31\xbe\x61\x36\x30\x1d\xdc\x95\x31\xdd\x58\x44\x09\x08\x1c\x85\x8c\x0a\xa5\xf5\x5f\x88\x4a\x9e\x3e\x89\x64\x8a\xf4\x6b\xed\xa5\xb1\xda\x15\xce\xbb\xaf\x68\x83\x1e\x85\x60\x56\x18\x4f\xb6\xcb\x27\xd5\x3b\x83\x96\x77\xca\xd3\xf4\x7b\x0c\x79\x5e\x43\xf9\x4d\x18\xd6\xe0\x0f\x82\x26\xfc\x4b\xb5\xa7\x93\x29\xd4\xd6\xee\x57\xd1\x80\x2d\x99\xdb\xbe\x06\x55\x34\x64\xe8\xc3\xb9\xdf\xad\xcd\x61\x19\x97\x1d\x4b\x96\x2c\xd5\x8d\xe8\xef\xa5\x10\x3c\x1c\xa7\x05\x65\x48\x76\x99\x27\x30\x67\x3d\x8e\x58\xc8\x3b\x79\x6a\x07\x74\x04\xbe\x4a\x4a\xdf\x18\xcc\x3b\x39\x9d\xc4\xaf\xdb\xa8\x63\xa7\x7f\xc8\x47\xe6\x94\x51\x77\x32\x2c\x44\x08\x4e\x94\x65\x7c\x66\x17\xe9\x4b\x86\x2a\x48\x90\x73\xe0\x8f\x3c\x19\xfc\x11\x0d\x18\x9b\x25\x38\x83\xa5\x01\x11\xa8\xa4\xfb\x51\x32\x14\x73\xe0\x4f\x87\x94\xed\xa8\xe9\x92\x61\x2b\x8d\x9d\x15\x0a\x58\x8b\x9b\x81\x8f\x35\xe1\x3c\x1c\xc7\xaa\x16\x7e\x33\x16\xec\xf2\xaf\x7f\x67\x7a\xb8\x17\x5f\x9f\xb2\xe2\xa0\x32\x42\xef\x75\xfd\xd7\x89\x14\x8a\x73\xf2\x9f\xe8\xcd\xbc\xb8\x04\x6f\x26\xa8\x16\x12\x00\xc9\x68\x50\xe0\x31\x6e\x9b\x69\x8e\x05\xb8\xad\xba\xfb\xfe\xcb\x0f\x60\x46\x9c\x1f\xcb\x2f\xfa\xb2\xbc\xe5\xf4\x6a\x72\xf4\xe8\xad\x5a\x5e\xd1\xba\x84\x72\xe4\x4e\xdf\x96\xf4\xdb\xc4\xf4\xc2\xed\x76\xc8\xac\x10\xcc\x04\x99\xd3\x89\x30\x6c\xf9\x7a\x1c\x4b\x2b\x2f\xfb\x12\x18\xef\xce\xf7\xfe\x1b\x4f\x33\x9b\x5f\x95\x52\x16\x17\x17\x96\x0c\x6f\x4b\x5b\x33\xa7\xae\xe6\x17\x2a\x9f\x50\x8f\x4a\xe0\xd8\x99\x53\xce\x8e\x8d\x79\x2a\xeb\x56\x0e\xb0\x53\xc5\xdc\x81\x87\x73\x79\x32\xc6\x7a\x55\xca\x6d\xf9\xf7\x82\x10\x29\xe4\x79\x1f\x36\x03\x25\x5a\x01\x30\xa6\x4c\x76\x46\xa3\xcb\x83\x9a\x50\x8c\x58\x75\x95\x72\x1b\x60\x2e\x4d\x1e\x7b\xf5\x57\x83\xf0\x13\x12\x2d\x14\xd6\x64\x43\x2c\xe3\xfb\xb7\x6d\xa1\x38\xd8\xa8\x80\x3f\xde\xcb\xb8\xbf\xf8\xfd\x07\xfc\xb8\x86\x6a\x35\x8a\x11\xab\xef\x19\x00\x0e\xf8\x08\xfc\x7f\xac\xc1\x38\x74\xe9\x4b\x6f\x0f\xd4\x9a\x14\x5b\x08\x2b\x13\xac\x5c\x28\x45\xd1\x59\x05\xe2\x96\xba\x5b\x33\xf2\xd1\x7f\xf9\x68\xe3\x53\xf3\x2b\xac\xf6\xc2\x42\xa8\xbe\xe5\x27\x41\x1c\xdd\x99\xbe\x1c\xca\x6c\x46\xd4\x37\xb4\x24\xee\xe3\x72\xc9\xc4\x96\x4e\xe4\x28\x68\x4c\x1d\xa4\x34\x7f\x4c\xd2\xa3\xc3\x8a\x17\x5c\x9a\x54\xe6\x48\xae\xb8\x4a\x3d\x86\x04\x4b\x40\x09\xa4\x06\x6b\x95\x47\x6e\xe2\x34\x5e\x66\x6e\x98\x20\xb3\xa7\x7a\x9c\xdc\x7e\x58\x35\x5c\x78\xb3\x8e\xaa\xfe\xe4\x79\x7c\xbe\x5f\xa1\x85\x8b\x8d\x6e\xc0\x43\xbe\x1c\x8e\xc4\x1d\xc2\x3a\x4f\x75\xba\xec\x44\x5e\x40\xe9\x4f\xde\x8e\xd7\x25\x1e\xc4\x69\x50\x3e\x29\xb1\xa9\xc1\xf5\x78\xf4\x2c\x4e\xb2\x1b\x07\xae\x59\x2e\x9c\xcd\x69\x5a\x20\x3e\x47\x8e\x7c\x5e\x77\x9f\xc3\x11\x90\xb0\x69\x9e\xd7\xe2\xae\x2e\xb0\x99\x8f\xf7\x05\x0c\x2b\xad\x17\xda\xb4\xf4\xf3\x27\x18\x95\xdf\x74\xea\xd5\x68\xa6\x1d\xe6\x79\x77\x99\x17\x6b\xf3\x78\x1a\x9c\xc9\x92\x5b\xbe\xdc\x15\x16\xe3\x89\x75\x68\xe6\x28\x04\xa6\x87\x15\x9e\x2c\xea\x61\x8a\x9c\x10\x86\xfa\x9e\x5f\x3d\x55\x44\x76\x6d\x5b\xee\x46\x93\x7a\x51\x74\xd5\xdc\xed\x2f\x9d\xb7\x8a\xc9\x15\x83\xa4\x96\x2a\x06\x97\xb3\x20\xe3\x73\xc1\xb8\x77\x9f\xe6\xfe\x83\xac\x7d\xff\x63\x54\x1c\x6c\xe6\xc1\xac\x4c\x90\x33\xd1\x2a\x4d\x97\xc3\x1c\xb5\x24\xbc\x26\x46\x06\x02\x3a\xa2\x01\xdb\x91\x65\x70\x96\x54\x9c\xc9\x7c\x20\x91\x5c\x73\x96\x1e\xa5\x18\xa7\x63\xe8\x8e\x4c\xfb\xc2\x9c\x95\x05\x8e\x87\x21\x4f\x74\x5c\x84\xc4\x1f\x05\x30\x37\x96\xc5\xb1\xbf\x2c\xf0\x13\x55\xa2\xf0\xe6\x67\x29\x98\x0b\x1b\x8c\xf5\xe9\x78\xbc\x3f\x5d\xa7\x7e\x05\x28\x23\x51\x4e\xbf\xca\xcf\x5e\x9e\x62\xab\xd3\xa4\xf2\x66\x13\xfd\x4d\xf4\xe6\x6b\x9f\xad\x39\xa1\x29\x3a\x7a\x1a\x78\x6a\x18\x77\xa5\xbe\x60\x1e\x7f\x55\xe9\xce\xaf\x2b\x08\x72\x04\x1b\xe9\x1e\xc8\xab\x9d\x45\x32\xc7\xd5\xfc\xe6\xac\xd0\x0f\x9f\xc7\xa9\xd7\xda\x58\x73\xde\x57\x33\xde\x51\x67\x6d\xcd\x2d\x84\x89\x5b\x3d\xa4\x69\x6a\x6c\xb9\xa4\xbd\xef\xac\x18\x31\x97\x6a\xd0\x7a\xd8\x9f\xc8\x30\x7e\xe3\x69\xee\x3f\x8d\x41\x9f\x79\xf7\x68\xac\x93\x5a\x15\x6a\x26\x7f\x14\x37\xda\x32\xb0\x74\xda\x2a\x67\xe7\xe9\xcf\x13\x33\x7b\xda\x9d\x84\x6d\x36\x29\x95\x1b\xfb\xc8\x32\xb1\x0b\xa6\x31\xe2\x89\xe4\x98\x52\xbf\x7f\x1d\xf8\xb7\x44\x58\x43\xf9\x36\xd3\x04\x08\x71\x4c\xe6\x23\xe2\x16\x7c\x52\x56\xe4\x97\x84\x71\x91\x7a\xca\x52\x89\xe4\x88\x30\xc0\x55\x01\x8a\xeb\x28\xfc\xe2\x96\x6b\xb7\xcc\x31\x40\x22\x5b\xd6\x54\xc8\x10\x0f\x45\x84\x0c\x2b\x95\x4b\x47\x24\x84\xc7\xc7\xe7\x3c\xad\x0b\x8f\x29\x07\xe9\x9d\xc0\x63\x74\xb8\x65\x7c\xbb\xad\x84\xf4\x6e\xff\x44\xcd\xca\x52\xe9\x19\xe5\x7b\x9f\x48\x52\x65\xd5\x89\x2e\xec\x3f\xdc\x6c\x0e\x3c\x38\x1d\x03\xec\x15\x42\x7a\x1b\x1b\x8a\x56\x87\xcf\x59\xe3\x6c\x84\x39\x5c\x25\x3f\xc5\xd4\xd8\x4b\x8b\x58\xf5\xe4\x43\xa2\xc0\x10\xf7\x49\xb0\x8e\x8e\xaf\x97\xf4\x99\x80\xa9\x4c\x41\x57\x8f\x32\x81\x1a\xa2\x3f\x07\xa9\xd1\x94\x40\xc8\xd1\x22\xd4\xd7\xde\x42\xc9\x60\x4a\xde\x65\xfb\x97\xb2\xe5\xc4\xe6\xb8\x27\xfd\xa5\xfe\x04\x61\x24\x97\x8d\xdd\xca\x78\x74\xb3\xff\x5b\xf0\x8b\xca\xb7\xee\x96\x2f\xc5\xf8\x8d\x32\x1b\x86\x90\xff\x8d\xb0\xcf\x5e\xf9\xd8\x57\xd5\xad\xf7\x96\xcf\xd1\x42\xe0\x36\xcf\xbc\x89\x49\x8d\x3f\x5d\x0d\x73\x92\x47\x0a\x39\x1b\xb3\x03\x3b\x62\xfe\x7e\x42\x1e\x96\x06\x0f\xb6\x0f\xca\x1c\x61\x0a\xec\xa7\x19\x9c\x65\x8f\x72\xb5\xf4\x25\x14\x6f\xe9\x1a\x06\xe2\x2a\x03\x36\x76\x92\x60\xf1\xd1\x0d\x55\xa0\xb3\x64\x2a\xb1\x61\x10\xe6\x8f\xa4\x07\x85\x5c\xe7\xd4\xc8\x17\xfc\xc5\xdf\x79\x1e\x69\x46\x5a\x6e\x55\x2f\x0a\xcd\x28\x4e\x6e\x24\x0b\x2e\xcd\x94\x72\xc1\x9c\xb2\xd5\x1a\x45\x4b\xa0\x8d\x50\x30\xfd\x6c\x5b\x33\xa6\xf9\x76\x7d\xb3\xf2\x73\x6f\xf8\x56\x36\xb9\x26\x32\x06\x96\x59\x7e\x02\xab\xea\x08\x6d\xa3\xe2\x67\x0b\xa2\xc4\xe5\x99\xec\x90\x27\xb6\x2d\x9a\xa8\x97\xf2\x2f\x9b\x78\x5d\x2f\x85\x14\xb5\xb1\x25\xbe\xf3\x5b\x95\xc0\x87\x4b\xe4\x26\x4f\xe9\x8d\xd9\xc4\x13\x29\x1d\x78\x01\x0a\x20\x27\x1b\x01\xf9\x89\x88\x26\x9c\x19\x47\x5e\x72\x55\x35\xc1\xba\x24\x75\xeb\xbf\x39\x3e\x7f\xd7\xaa\x20\x77\xb5\x95\x2f\xcc\x1c\x1a\x7c\xc4\xa6\x1c\x55\xff\x0b\xbc\x41\xc3\x23\xea\x8b\x2f\xc4\x32\xf5\xee\xf7\x56\xf9\xe6\x41\xa4\xa0\x29\xa2\xf4\x92\x4c\xe6\x12\x84\xe4\x7b\x9d\xab\x4d\xf8\xbe\xb4\xd1\xf3\x68\xb2\x4c\x14\x64\x28\xe2\x5f\x8d\x05\x7a\xd0\x59\xe3\x09\x10\xc9\x8a\x7d\x6f\x99\x67\xc7\x83\x86\xc2\xfc\x93\x4c\x07\x9b\xcd\x62\xa9\x5f\xac\xa6\x4f\x97\xf1\xd2\x6c\xde\xd4\xff\x72\xad\xae\x22\x9b\x9f\xb5\xa6\x89\x33\x03\xfc\xdf\x9f\x3b\xa8\x93\x7e\x2d\xbc\xf7\x37\xd8\x71\x7e\x97\x1e\x85\x62\x7e\x6d\x5e\xb4\x09\xb2\xc8\x3c\x78\x24\x0a\x14\xaf\x5d\xed\xb0\xb1\x4a\x17\x1e\xd1\xaf\xed\x65\x2c\x32\x95\x5a\xd2\x32\x46\x3d\x86\xcf\xeb\x5c\x15\xf3\xad\x89\xf1\xc7\xde\xb5\x4f\xf2\x8b\x8f\x38\xb9\x27\x0d\x11\x9e\xd4\xc1\x27\x81\x6b\x40\xb1\x98\x1b\xdb\xa9\x39\x21\xe7\x2e\xbd\x0a\x40\x1f\x9a\xd1\x72\x2c\xf2\x78\x72\x8e\x75\x07\x0e\x23\x8f\xb6\x8e\xb4\xb8\x82\x23\x6a\xa4\x5d\xcb\xa9\x63\x15\xe1\x88\x4c\xf2\x60\xc1\x25\xa0\xa2\x83\x14\x7c\x6b\x1c\x52\x55\x86\x3b\x91\x44\x33\x80\xdd\x1d\x35\xc5\xd5\x6a\x89\xb2\x4f\x24\x2d\x08\xf2\x51\x06\xfe\xec\x93\x77\xc4\xb1\x41\xc4\x58\x19\x4d\x9a\x1f\xc4\xf7\xad\x02\x9c\xba\xf7\x3b\x19\xee\xaf\x51\x8e\x79\xef\x6d\x0e\xf9\x70\xff\x92\x03\x1c\x4f\x26\xb4\x11\xf9\xd1\x80\xd9\xdd\xd8\x8c\x1a\xf4\xcc\x43\x45\xab\x9c\x32\x77\x62\xf3\x6c\x23\x04\xff\x90\x25\xae\x24\x0b\xc4\xb3\xff\xe9\x1f\x71\x2d\x9c\x24\x08\x65\x79\xf7\xed\x32\x5f\x6e\xc1\xc5\x82\x41\xbe\xb3\x45\xdd\xf5\xfa\xf0\x8d\x0b\x3f\x7e\xdd\x31\x27\x7f\xa9\x9c\x60\xc9\xf1\x69\xba\x68\xe8\xfa\x7b\xaf\xe4\xef\xe7\xdb\xcb\x12\x4d\x04\x9e\xc3\x76\x74\xf9\xd2\x4d\xaa\x0d\x7c\xfc\x2e\xc8\xfc\x4c\xbe\x07\x3e\xc0\x2a\x7d\xc3\xdf\x8f\x89\xeb\x53\xa9\x63\x66\xbc\x2c\x52\x58\x9d\x98\x72\xf0\x9e\xe8\x79\xf4\x8f\x53\x1a\xb8\xba\x80\x26\x56\x82\xe7\x05\x84\x98\x73\x31\x89\x44\xe3\x13\xd5\x55\xe9\xad\x71\xbb\x5d\xbd\x20\xd1\xe2\xd7\x0c\xf8\x76\x3f\xa8\xff\x2e\x0c\xee\x03\xae\x2c\xed\x94\xff\x54\x7c\xc7\xc0\xf2\xf6\xa7\xcc\x86\x58\xe8\x8c\x76\xc6\x6e\x2a\xd4\xe9\x74\x5d\xf6\x21\xe9\x8e\xf8\xaa\xbb\xeb\xbd\xf6\x97\x2a\xc4\xbe\x57\xbc\x6b\x92\xeb\xab\x47\xae\x2b\x20\x38\xcf\x39\x32\x7a\x92\x43\x58\x9f\x06\xc6\x53\x9f\x23\xd6\xaf\x2d\xbd\x5a\x50\x45\xd7\x8f\x28\x37\x20\x0b\x55\x95\x90\xc2\xa9\xa3\x2b\x24\xf1\x51\x87\xc8\xaf\x62\x86\xef\x76\x9e\x79\x8b\xe7\x16\x94\xf5\xf6\xbf\x1d\xa2\x67\x4d\x16\xbf\x2f\xea\x86\xb2\x87\x7c\x10\xd9\xfc\x45\x53\x5d\x2d\xa5\x74\x4c\x7a\x8a\xcb\x93\x1b\x14\x53\x14\xec\xf9\x97\x3b\xb2\x61\x20\xc6\x40\xfd\x50\xd6\x14\x6e\x80\x9e\x1f\x17\x8b\xde\x22\x92\x18\x4e\x99\x14\x4b\x1c\x6c\xe5\x30\x91\x44\x0a\xac\xec\xf5\x7f\x4f\x36\x92\xec\x77\x15\xb3\x63\xc3\xcf\x9f\x3e\x0d\x84\x95\x2f\x62\x80\x68\x26\x81\xb0\x08\x85\x0f\xb6\x76\x12\x3a\x51\x64\x1c\xf1\x16\x4c\xb1\x98\x2a\x54\x1c\x9d\xf8\x17\xeb\x72\x8b\xd5\x29\x81\x92\xca\x47\x19\x6e\xc1\xfb\x95\x81\x31\xcc\x05\x2a\xb2\xd7\x29\x94\xee\x14\xa4\x9a\xca\x25\xa7\x69\xa6\xc9\xba\x49\xec\x7c\x2c\x52\xc6\xac\x36\xff\x44\x8f\x60\x52\xaf\x69\xbc\x59\xc9\xd1\x22\x4f\x75\x65\x0c\x9b\xc3\xa8\xb8\xe8\x9f\xf4\x6d\x44\xbf\x16\x8b\xce\xe5\xe3\x8d\x92\x15\xda\x56\xed\xc4\x43\x15\x5b\xca\x80\xaa\xe0\x8b\x60\xb8\xb5\x23\x77\x22\xe8\xdf\x23\x26\x66\x07\xe4\x09\x7e\x21\xa6\x13\x3b\x2a\xa7\x03\xc5\x33\x00\x16\xd4\xb8\x33\xc7\x18\x9c\x56\x92\xa4\xd5\xa5\x9e\xb2\x26\x2b\xca\x0b\x59\x12\x78\x1a\x4d\x66\x5c\xc7\xfd\x5e\xad\x66\x4b\x34\x6a\x48\xd0\x2e\x2f\xbd\x7b\x09\xf5\x9b\x18\xc0\x03\xa9\x90\x2e\x36\xc2\xda\x97\x76\x3e\x8b\x6c\x41\xa8\x99\x96\x46\x13\xf2\xa8\x5c\xa8\x79\xe9\x97\x50\x77\x7c\x6c\xe6\x9e\x15\x88\x08\xe7\xa7\xb6\x59\x74\x5f\x2f\x68\x1e\x3a\x20\xe8\x07\x4a\x4d\xc6\x8e\x97\x37\xe7\xa1\x6e\x8b\xb4\x62\x45\x9f\x3d\xab\x05\xbe\x2f\x7d\x18\xcb\xa4\x61\x56\xf4\x12\x3e\x0d\x16\xf4\xc6\xb8\x95\x69\x7e\x51\x3b\xff\x82\x2f\xfb\xf9\x2e\x00\xa7\xf3\xd8\x19\x9d\x4f\x0d\x76\x30\xf7\x10\xe7\xcb\x1c\xdf\x9f\x87\x8f\xdb\x1e\x65\x22\x4d\x2e\x80\xcf\x7d\x9b\xe2\x1d\xd0\x0d\xbe\x68\x7e\xce\xae\xc4\x3f\xb1\x60\x4f\xf4\xfc\x55\x4a\x74\x62\xc6\x0e\x8c\xd9\x40\xf6\xb2\xdb\x34\x71\x24\xe3\x94\x16\x58\x50\xa0\xad\x19\x65\xaa\x4b\x51\x13\xc7\xf1\xa3\x14\x11\x71\x36\x85\x4a\xfb\x26\x5f\x62\xc8\x87\x25\x9d\x0a\x84\x34\xb4\x26\x65\xd4\xa1\x94\xd2\xad\x82\x13\xd2\x16\x2e\xcc\x1f\xb9\x0d\x37\x6f\x2f\x4d\x4f\xa3\xc9\x65\x48\x51\x56\x44\x5d\x32\x93\x93\xfc\x5b\x9c\x26\x1b\x85\x81\xd8\x73\x1a\xb6\x9d\xf9\xdb\xa2\x82\x1b\x6d\x0f\xfe\xd2\xbf\x71\x86\x24\x69\xe3\x97\x84\x92\x35\xa3\x02\x6a\x10\x21\x8b\xda\x47\x43\x4f\x65\xc6\x52\x2c\x76\x51\x25\x21\xab\x2e\xc4\xf7\xb9\x89\x11\xa0\x14\x33\x18\x7e\x9d\x98\x11\xbd\x70\x31\x76\x96\xf0\xf7\x2b\x6e\x98\x8f\xb0\x77\x76\xb9\x22\x05\x81\xff\xad\xe5\xef\xef\x39\x31\xa9\x3f\x94\xfd\x4d\x8d\xba\x0c\xa3\xca\x39\x50\x49\xa2\xe9\x63\x45\x1c\xf8\xc5\xf8\xbe\x55\x88\x7c\xf1\x89\x0a\xb8\x00\x8e\x8a\xaa\xe0\x5d\x4c\xeb\x49\x7a\xeb\xb7\xd7\x49\x44\xc7\xed\x4b\xa7\x81\x41\x7f\x7c\xc8\xc0\x23\xba\xc8\x7e\x3d\x57\x8d\x1e\xfd\xf8\xe0\x7a\xb7\xb1\xb3\x1f\xb7\x61\x62\xee\xe9\xda\xb4\x6c\xa6\x0e\x54\x5b\xa6\x70\xae\x6c\x33\x6a\x3c\x96\x7f\xd5\xc5\x9d\x74\x66\x6a\x29\xcc\x8e\x36\x79\x29\x27\xf2\xb4\xe3\x39\xb0\x1d\x97\x35\xc4\xdb\xa9\x7a\xec\x53\xb2\xae\x1c\xe3\x71\x27\xc2\x5a\x0b\xbf\x2a\x17\x61\x16\x28\x69\x4d\xce\x82\xb2\x81\x30\xd3\x8f\x12\x9b\x32\x90\x4b\x5e\xab\xb9\x2f\xa1\x4b\x2d\x37\x9b\xe7\x96\x01\xe9\x83\xbd\x56\x91\xac\x6f\x36\x6f\x2e\xf0\xdd\x00\x37\x74\x69\x06\xe9\xd2\x10\x19\xef\xaf\x84\xad\x4e\x86\xb5\xd9\xe4\x49\x67\xeb\x3c\xfa\x47\xe7\xc8\x83\x4a\xeb\x53\x23\xbe\x5a\x59\xb3\xca\x8a\x1a\x72\xcb\xd8\xc5\x66\x3a\xb3\xc0\xde\x0e\x92\x40\x74\x04\x9a\xfe\xa4\x12\xfb\xb6\x8f\xe2\x2d\xc7\x5c\x6f\x17\xfa\x2e\x3c\xdc\x5c\xe9\xf9\x4b\x8e\x29\x43\xaf\x23\x79\x5e\x06\xa6\x6f\xda\xbc\x1a\xe5\x53\xda\xac\x3c\x2d\x93\xf8\x05\x37\xbf\xb0\x73\x24\x79\x22\x2e\xea\xb4\x8a\x33\xef\xf9\x49\x67\xe9\x23\x97\x0e\x77\x0b\x4f\x21\x00\xde\x09\xdc\xb9\x66\xef\x06\x4c\xe5\xe4\x45\x85\xce\xd5\x66\x64\x51\xed\x5b\xdd\xbe\x95\xea\xce\xd7\x74\xa6\x10\xd2\x75\x23\xc1\xed\xaa\x46\x46\x87\x65\x06\x6e\x45\x5d\x4c\xdc\x35\xe7\x96\x4f\x95\xee\xf3\x2d\x4d\x26\x93\xee\xd7\x44\x2a\x61\x04\x6e\x01\xf0\xbd\x8c\x7d\x1d\xad\x0e\x85\xac\x5c\xcb\xe7\x52\x36\x15\x4b\x35\xcb\xb5\xd9\xeb\x81\x8b\x54\xa7\xc3\x44\xfc\xeb\xb9\x24\x9a\x6e\x20\xcb\xca\x97\x6d\x71\x4c\x53\xb8\x11\x3d\x23\xd3\x26\xf5\xcd\x3c\x44\xf8\xfc\x3d\x97\xaf\x99\xf7\xb2\x0e\xd5\x9b\xc5\x20\x6c\x9d\xf7\x5d\xc5\xb3\x25\xc5\x0d\x6f\x56\x28\x3e\xd0\x39\xd1\x6f\x89\xeb\x39\x64\x78\x9c\x6d\xab\x2c\xf4\x0f\x07\xc4\x6a\x3f\xef\x9c\x46\xce\x36\x59\xf4\x66\x62\xf6\x1e\xf9\x34\x21\x76\xda\x5f\x73\xea\x58\xd5\xcb\x9d\x4e\xe2\xc2\x37\x8f\xf0\xe3\x5f\xb4\x52\xb5\x0f\xf7\x5d\xbc\xa9\xb4\x39\xac\x96\xc6\x06\xbf\x43\xe5\x07\x13\xaa\x5b\xbd\xf5\x65\xa8\x8c\x9e\xae\x86\xe3\x88\xe9\x05\x46\xb3\x4b\x99\x8e\x05\x6c\x50\xab\xa4\xc8\x60\x3b\x7b\x46\x90\xb0\xc8\xd8\x01\xdc\x99\x70\xd1\x0a\xc0\x22\x37\x4e\x2e\x38\x90\x18\x49\x8a\xa2\xbd\x2b\x14\xc7\xd0\x9d\xb3\x79\xf0\xda\x8e\x6d\xce\x4f\x9c\x47\x00\x57\x38\x01\x65\xd7\xa9\xeb\xf6\x3d\x86\xef\x54\xaf\x63\x79\xa2\x95\xd3\xb5\x5a\x61\x70\x6f\xd9\xdc\x97\xec\x89\xcf\x23\x8d\x95\x40\xef\x7a\x6c\xe3\x8d\xb5\xa6\xeb\x01\x7b\xd9\xc4\x2d\xbb\x8d\x56\xeb\x55\xf7\xca\xcf\xbb\x1a\x0f\xe7\xf1\xcf\x04\x9d\x6c\xef\x4e\xbb\x53\xe9\xfb\x82\x79\xfe\xdf\xb2\x1b\xe2\x17\xee\x7c\xf3\x7c\xd7\x38\xcd\xaf\x07\x6e\xe9\x5a\x17\xf9\x02\xa6\x35\x8f\x9a\x88\x8b\xfd\x12\x07\x2c\x90\x43\xd3\x0c\x14\xcb\x0a\x43\x2b\x6e\x92\xa6\x6c\x91\x6b\xea\xa2\x3c\x03\xac\xa6\xe1\x7e\x8e\x05\xea\x62\x1e\x1f\x1c\x33\xa2\xc3\x63\x9c\x8f\xf4\xd0\x44\xae\x2c\x85\x02\x1c\xfe\x26\xfb\x85\x2e\x63\xcb\x3c\x86\x99\xbd\x6e\x92\x6e\x7e\xd7\x82\xa7\xf3\x8a\x4a\x0a\x1c\xbc\x92\xec\x16\x98\x97\xaf\x13\x87\xd2\x07\x94\x47\x6a\x26\xdd\x2e\x26\x6b\x3b\xe8\x1e\x3b\xeb\xb8\x55\x62\xb9\xed\x98\x2e\xae\x24\x57\x51\x53\x3c\xc5\xd6\xaf\x8d\xac\xc4\xd3\xf3\x5f\xb5\xbe\x35\x27\xf3\xbe\x39\x9f\x5f\x9e\x1e\xf7\xbf\xcc\xfe\xaa\x60\xe8\x32\xcf\x4f\xff\xc4\xdd\xde\x05\x9c\x1d\x45\x5a\x33\xe7\xad\xf6\x50\xf5\x6e\x6a\xae\xe8\xbe\xd0\x37\xac\x31\x34\xa6\x1b\x85\x46\x21\x58\x5c\x6c\xdd\x0c\xcd\x89\xa1\xbd\x4c\x95\xcd\xd0\x7f\x0e\xd0\x78\xe2\x11\x76\x7d\x26\x5f\xb0\x9b\xf6\x7a\x95\xb3\xb9\xb2\xad\xe6\xf2\x19\xdd\xa2\x17\x21\xb3\xa6\x7c\x73\x7b\xca\x11\x8f\xd1\x25\x17\xf3\xa0\x74\x5f\xee\xd2\x5c\x5b\xe8\xab\x31\xfd\xda\x61\xca\x88\xec\x4c\x48\xb7\xcb\x0f\xeb\x2e\xfc\x46\x57\xdb\xd1\x8f\x0d\x82\x36\xbd\xc9\x9a\x73\x07\x67\x23\x5f\x13\x24\x34\x43\x7a\xcf\x97\x60\xc2\x25\x8b\xcc\xf8\x93\x36\x7d\x18\xac\xd4\x9e\x93\x93\xf1\xfe\x8e\x4b\xdd\xa3\x89\x85\x88\x35\x53\x14\x3d\x20\x5a\xf1\x02\xb5\xd1\x8a\x31\x4e\x66\xe3\xaa\x1c\x8b\x7d\xd2\x09\xa3\x50\xef\x5b\x81\x3c\xd4\x42\xc4\x3b\xbf\x49\x00\x92\xd2\xc5\xc8\x48\xb4\xe1\x6b\x24\x5f\x77\x42\x8a\x26\x57\x55\xf0\x7e\x63\x41\x44\x96\x06\xf5\x88\x69\xb5\x44\x48\xc8\x66\x60\x04\x68\x0d\xeb\x8d\x0e\x9b\xd0\x84\x66\x3b\xa6\x65\xfb\x1c\xd3\xf3\xd5\xc1\x16\x3f\xfe\x88\x45\x37\x19\x4f\x01\x41\x41\x61\xc6\x55\x85\xdb\x69\xd1\x84\x7c\x5c\xe5\xf0\xd2\x6a\x48\x97\x49\x3d\x53\x80\x45\x39\x9c\x5b\xb3\x1a\xc9\x52\x77\xb3\xa8\xfb\x2b\x25\xd7\xc0\xbc\x8e\x3f\xbc\xd6\x30\x4b\x46\x75\xfa\xb6\xf9\x84\x77\x42\x25\xe9\x20\x36\xd2\xa5\x50\xdc\x3b\xd5\x45\x75\x3d\x8a\x71\xc6\x64\xb8\x4f\x5c\x18\x44\x30\x79\xa8\x53\x37\x90\xe2\xc7\x1d\x0a\x7a\x8e\x8c\xcb\xaf\xce\x5a\x8b\x18\xe3\x7c\x40\x74\x0c\x9c\xa3\xd8\x33\x0b\x3b\x56\x85\x12\x53\x36\xff\x2d\xc3\x89\x57\x3f\x0f\x4a\x12\x4f\xb9\x92\xcb\x33\xcc\xb2\xea\x58\xe9\xd9\xd8\x5d\x19\xff\x1c\x80\x5c\xbd\xcd\x9f\x62\x3c\x69\xa2\xa0\x87\x3d\x21\xe6\x7e\x85\x90\xcf\xe1\x07\x2a\x7d\x9e\x8c\x4b\x88\xfd\x4d\x2c\x25\xc8\x7c\x48\x13\x70\x92\x63\x02\x29\x07\xee\x86\x38\x7b\x11\x0c\x72\xb5\xa6\x5b\x64\xa8\xc7\x0b\x27\xc4\x3f\x6c\xd4\x46\xa7\x5c\x2a\x67\x71\x4c\x33\x84\x2e\xe9\xba\xaa\x0d\x1d\x96\x61\xf2\x27\x03\xb8\x78\x1f\x9e\x57\x22\xe9\x87\x77\x34\xf6\x1b\x0f\xa2\x2e\x88\x2e\x19\x15\x51\x3a\xad\x56\x93\xb6\x74\x24\xd6\x05\xe8\xbc\x42\x8e\xea\x8d\x16\x92\xe6\x71\x41\x25\xb0\x58\xe9\xee\x91\x8b\xff\x6f\xa7\x85\x78\x8d\xf0\x46\xa6\x45\xcd\x15\x3d\x51\x9e\xee\x34\xa1\x83\x50\xc6\x21\xc4\x32\x7b\x65\xed\x14\x81\x65\x85\x45\xfa\x4a\xc3\x65\x3c\xc6\x5c\x03\xc7\x10\x54\xaa\xfd\xb5\x43\x85\x41\x76\x6a\xca\xa2\x4c\x9f\x36\x44\x3f\x32\x37\x05\xf4\x02\x8e\x88\x58\x9d\xe7\x69\x5a\x7b\x4e\xaa\x67\x62\xbf\x9c\xa0\xe0\x9d\xae\xa1\x3b\x29\xaf\xa5\xb1\xb4\xdd\x53\xe9\x26\x02\x1f\x2e\x85\x3c\x80\xf6\xa1\x0c\x99\xee\x6d\xec\x0b\xce\x2a\x14\x9d\x15\x22\x08\x5c\x35\x89\xb2\x8f\xa0\x44\x58\x49\x52\x23\x3f\x34\x2f\x2e\xff\x18\xa5\x03\x45\xa5\x28\xb1\x0d\x69\x89\xe6\x9b\xad\xf0\x46\xe5\x69\xb1\x88\xea\xd9\x22\x07\x7a\xcc\x4f\xe6\x9f\x85\x33\xab\x9b\x65\xb4\x5c\x97\xdb\x4d\x68\xd9\x8f\xa5\xaf\x50\x6c\xa2\xc9\x53\xe3\x79\x2d\x5f\xed\xc7\x49\x39\x26\xbe\x0b\x37\xb2\xed\x41\xf5\x50\x80\x33\x95\x9c\xe6\x43\xd5\xea\xb0\x38\x8f\xd3\xc7\x87\xee\xbf\x8f\xb7\x39\x16\xdf\x00\xf3\xfb\x8e\x2c\x78\x1a\xea\x6c\xa3\xba\x9f\xc5\x04\x37\x76\xaa\x5c\x2b\xac\xc3\x63\x5f\x39\xde\x02\xa0\x62\xac\x97\xdc\xc2\xa6\xd9\x99\xd6\xe2\xe6\x6a\x57\x59\xa3\xc8\x83\x22\x98\x30\xb5\xe1\x6f\x45\xc2\xbf\x13\xa1\x0f\xed\x37\x95\xb5\x5d\xaf\xc4\xe7\x5f\x3d\x23\x06\xd2\xcf\x34\x36\x39\xae\x4a\x82\x61\xf7\xa1\xb5\x78\x12\x1a\xe9\xd5\x63\x84\x3a\xfd\xed\x43\x85\x5e\x7e\xf7\x0e\x24\x8a\xc5\xc6\xf1\xf3\xf8\x4b\x02\x23\xb8\x7c\x91\xbf\x3e\xdf\x1b\xc9\xae\xaf\x1b\x1d\x24\x47\x6e\xc6\x1c\xf2\x35\x64\x93\x5f\x07\x85\xf6\x15\xee\x6d\xc2\xff\x7a\x2d\x5f\x65\xbb\xc5\xdd\x85\xce\xec\x43\x1e\xe8\x0a\xe2\x34\x55\xa1\xa3\x53\x5b\x46\x9d\x99\xaa\xe7\xe3\xda\x24\x05\x32\x73\x09\x36\x57\xb1\xfc\x52\x9b\x2e\x42\x73\xce\x57\xc8\xa8\xcd\xd8\xf6\x8d\xdb\x7a\x4f\xa5\xdf\x57\x5c\x97\xc9\x12\xad\x66\x1a\x24\x18\x42\x2a\xe2\xeb\xae\x44\xe3\xa8\x10\x2b\x65\x96\xe4\x81\xd4\x18\x88\x68\x70\x28\x8d\x6a\x50\x1d\x4e\x1d\x55\xcf\xf4\x91\x1f\xe0\xac\xcc\x70\x6d\xe1\x5e\xe2\x41\xa0\x39\x34\xc7\x5e\x6a\xa7\x39\xf2\x63\x05\xfe\x12\xee\x3c\x15\x0e\x34\x43\xb6\xa3\xe5\x9e\x68\xdf\xb2\x00\x5e\x17\x0f\x98\x8c\x74\x81\xf0\x1e\x36\x57\x72\xc6\x42\xd5\xff\x4e\x62\x3e\x7a\x1a\x89\xa7\x3d\xe7\x87\xf8\xa1\xa4\x30\xe3\x5a\xbc\x5a\x1c\x89\x24\xb7\xee\xc7\xda\x51\xb6\x94\x47\x3d\xc5\xb7\x5f\xe3\x20\x1c\x7c\x28\x6b\xaa\x5f\x26\xda\x1e\x2c\xa2\x4f\x3b\x42\xbc\x27\x79\x7e\x57\x98\xf5\x7c\xe7\x6d\x4c\xc5\x2b\x79\xe0\x85\x67\x29\x99\x56\x8d\xee\x7d\x24\x89\x9e\xb3\xae\x6c\x48\x73\x83\xb9\xd3\xbd\xa7\x92\x30\xb9\x12\xfa\x20\x71\x4f\x7e\x10\x1d\x03\xca\x06\x56\x27\x47\x34\x7c\x44\x21\x38\x27\x82\x27\x80\xb4\xae\x29\x9c\x28\x16\xcd\xe3\xcb\x2b\xec\x4c\xbb\x3f\x7f\x29\x20\x1c\x38\x1f\x3e\x57\x71\x65\x6b\x37\x9b\xce\x50\x83\xcb\xf1\xb4\x59\x20\xe1\xd0\x32\xfe\x1d\x5f\x30\xd5\x93\x7b\x93\xd5\xd2\x80\x3c\x1a\xd3\x2a\x14\xbd\xb2\x3c\x71\x90\xd8\xca\x96\x24\x53\x90\x81\x21\x25\x13\x4b\x65\xa0\xab\x54\xd2\x35\xf3\xa8\x7a\x71\xea\xe1\x53\x09\xc5\xf4\x8b\x9c\x59\x2e\x5d\x34\x1c\x7c\x5b\xa2\xe8\x58\xf4\xc5\x94\xaf\xdf\x07\x7c\x9a\x2c\x05\x2f\x56\x87\xa7\xf7\xac\x77\x20\xaf\x23\xd9\x2e\xf2\xb9\x9d\xd1\x3a\x57\x8e\x6d\xbc\x45\x8c\xc8\xeb\x20\x86\x3e\x10\x27\x56\xef\x61\x23\x47\x77\x4f\xe0\xb7\xb7\x0d\xbb\xff\x33\x32\xac\x31\xa7\xa9\x51\x7f\xd3\xa5\x38\xf3\xa8\x6e\x0b\x3e\x6a\xbf\x2f\xae\x64\xf3\xa1\xa4\xb1\x27\xad\x5d\x52\xe9\xe0\x26\xf0\x54\xe2\x79\xd7\x71\xdb\x04\x15\xb3\xf1\x1e\xdd\xbc\xc7\xb4\x75\x8e\x74\xf9\xe7\x44\xf6\x45\xce\xac\xd7\x46\xcf\x65\x2a\xd0\x59\x12\x8c\xd1\x44\x71\x49\x46\x08\xec\x87\xee\x93\xdb\xfd\xee\x07\x61\xb4\x20\xa8\xe0\x17\x39\x72\x0d\xf1\xdf\xe7\xca\x0e\xc4\xbf\x41\x9f\xed\x82\x88\xb1\x30\xca\x2e\xa9\xb4\x0f\x32\x9d\x9b\x30\x5e\x3b\x4b\x86\xe4\x51\x16\x12\xe4\xf5\xb3\x99\x4f\x45\x85\x08\x5a\x14\xb2\x27\xe8\xa3\x39\x8b\xbc\x3f\xf3\x33\x0a\x2f\x99\x59\x47\x6f\x6f\xa1\x5a\xa8\x28\x91\xbe\xd1\x68\xbe\x24\xdf\x6b\xd9\x01\xd6\xaa\xaf\x25\x74\x18\xb8\x44\x6f\x5c\x3a\x5a\xa7\xb5\x3c\x81\xe4\xbe\xf4\xfb\xae\x7f\x6e\x7d\x59\x52\x80\x58\x6f\xba\x59\x7d\x30\x26\x5a\x12\xbf\x5d\x8d\x8e\x25\xaa\xbc\xaf\x6a\x0d\x6f\x7a\x2e\x34\xe0\xaa\xaf\x7b\xa8\x77\x5d\x75\xd0\x2b\x07\x7f\xb4\xa8\x3b\x79\xcd\x10\x37\x05\x54\xe5\xb4\x7f\xd5\x1b\x4a\xe1\xbd\x87\x43\xc7\x1e\x72\xb1\x9d\xd3\xb3\x48\x3f\x29\x45\xa4\x7a\x3c\x0b\x93\x0b\xb7\x46\x48\x4b\xea\x7b\x3d\xc7\xd1\x28\x34\x34\xc5\xef\x86\x9a\x7d\xa7\xea\x56\x7a\x97\x1a\xaf\x03\x73\x2e\x6e\x3c\x8e\x75\x7f\x9a\x6f\x09\x10\x0c\x88\x61\xe4\x39\x74\x3e\x4b\xa1\x36\xd6\x67\x63\x9f\x02\xa1\xf8\x7e\x4a\x07\xb0\x9a\x3b\x58\x50\x0d\x87\xc8\x11\x87\x2b\xcb\x42\xd4\x99\x57\xb4\x8b\x1e\xa9\xeb\x9e\x9d\x24\xd6\xa9\xd3\x60\x1d\xd8\xc8\x7e\xaf\x6f\x82\x9c\x93\x0b\x00\xd0\xca\x15\x83\x75\x98\xbb\x20\x9b\x48\x31\xee\xed\x9a\x86\x69\x7d\xf5\x99\xc4\x06\x43\xcb\xbc\xe5\xf8\xd4\x58\x2e\xd9\x3f\xd9\x96\xc2\x02\x6d\x10\x7d\xd9\x35\xdb\xd4\xa7\x9e\x8a\x65\xed\xcb\x7b\x7a\x92\xa0\xe5\x3e\x8d\x7b\x0d\x9d\x19\x78\x27\x0d\xad\xb9\xc8\x53\x58\x3e\xaf\xf0\x2a\x84\xb6\x6c\x17\xa6\x78\xa6\x7c\xbf\x43\xbc\xdb\x37\xcd\x53\x04\xf2\xe4\xd8\x4e\x1a\x87\x02\xa3\x64\xb3\xd5\x93\x7c\x0b\x16\xa6\xc6\xac\xd7\x21\xb8\xfa\xa7\x1a\x4c\x98\x63\x24\x73\x88\xc1\x64\x12\x87\xa4\xb8\x06\x44\x2c\xe3\xd2\x13\xb8\x8c\xe9\xe4\x1a\x32\xa1\xd8\x27\x11\xa2\xe1\xd8\xb0\x76\x0e\xb9\x2d\x2f\xdf\xcd\xbc\xd1\x70\xdc\x26\xff\xd6\xfe\x39\x66\xd0\x7a\x1e\xb8\x33\xd5\xf1\x85\x18\x86\xca\x75\xf7\x66\xef\xf0\xf2\x63\x59\x81\x5a\x5e\x9d\x86\xb4\xef\x4f\x88\xa4\x48\xc4\x82\x64\xb7\xd5\x99\x5d\xfd\x6d\x4b\xdf\xa3\x02\xec\x21\x07\x84\x82\x19\xc5\xb0\x02\x1f\x0e\x4a\x5d\x7a\xbf\xa7\x7e\x47\xf4\xde\xbf\x33\x8f\xea\xca\xe7\x62\xff\x96\xb1\x1b\x5b\x5b\xc1\x1e\x6a\x8f\x54\x7d\xb4\xb0\x02\xbf\x8e\x52\x99\x80\x21\x1c\x80\x5f\xd3\xd7\x71\xb1\x1f\x6d\x5f\xd8\x0c\xd3\x4a\x5d\xfe\x7b\x9a\xde\x7d\x59\x51\xf7\x70\xc0\x15\x9b\x9f\x2b\x67\x7b\x5c\x3a\x30\x86\x64\xc0\x24\x20\xcd\x14\x86\xfa\x56\xc7\x39\xeb\xf1\xcf\x25\x38\x02\x4c\xe1\xee\xb7\x2a\xa6\x8a\xfd\x73\x9f\x0e\xc8\x91\x25\x19\x7f\xe5\xe5\x4f\xf6\x14\xe9\x68\x5e\x18\x5e\x00\x49\xbe\xad\x77\xee\xb3\xb2\x23\xe6\x97\xa1\xa8\x9a\x77\x26\xa9\x7b\xcb\xa4\xe8\xe0\x53\x7c\xda\x1c\xa9\xbb\x0e\x13\x57\x5c\x69\xcf\x1e\xe4\xb8\x15\xcb\x26\x03\x4e\x87\x35\xc1\x82\x7e\x60\x71\xd6\x62\x77\x20\x79\xb5\x6d\x85\x74\x05\xf3\x5c\x51\x89\x6c\xe5\x28\xb4\x84\xfd\x35\x51\x22\x49\xff\xcd\x50\x87\x4f\xe4\xc2\x59\xd3\xe3\xc5\xad\x2c\xdf\x1e\x23\xef\x63\xdc\x5a\xce\xee\xdb\x75\x8b\x81\x70\x81\xc0\xa1\xeb\x2d\x4c\xe7\x5b\xbe\x5c\x66\x8f\xd9\xc4\x29\xbc\xd0\x00\x88\xdf\x9b\xf2\x5c\xfe\xf6\x0f\x42\x60\x54\x57\x7e\xc8\x72\xb9\x68\xb7\x44\xc5\x16\x7d\x75\x9c\xcc\x2f\xcd\x2e\xd5\x41\x12\xc8\x95\xe1\x84\x6b\xe6\x25\x8f\x40\xe3\x1c\xcf\x80\x7d\x11\x17\x43\x63\x45\xed\x2b\x84\x79\xd8\x50\x63\x43\x47\x11\xc5\xec\xb9\xe5\x1b\x9b\xea\x17\x3d\x4f\x7d\xb3\xde\x69\x0d\xed\xe6\xe2\x08\x0a\x66\xb5\x4e\x46\x97\xea\x1c\x09\xb7\x5b\x55\x4d\x6b\x64\x85\x83\x7c\x14\x0e\xbc\x36\xf0\x02\x13\xb6\x5d\x1c\x16\xa0\x92\x21\x19\xe1\xb7\x9a\x43\xf2\x91\x28\x36\x3d\x9e\xbe\x62\x2d\x5b\xbc\xfe\xe0\x14\x1e\xb2\xb4\x0b\x2a\xe3\x9e\x4d\x4e\x3d\xf4\x29\x2f\x34\xad\x34\xcc\x6d\xb0\x46\xbc\x20\xae\x8a\x56\x4c\x44\x3e\x40\xbb\x5e\xdf\x4f\xf2\x5f\xe7\xa2\xf4\xec\xe4\x39\xfb\x8f\xf1\x59\x44\x26\x21\xc2\x68\xb8\xc2\x88\x5f\x93\xa1\x7f\x98\x38\xf4\x86\x85\x56\x48\xe6\x8d\x37\x8e\x8c\x58\x6b\xc1\x59\xdb\xc3\x76\x26\x42\x0d\xae\xe6\x3f\x7e\xe2\x25\xb5\x20\x23\x59\x25\x9e\xcf\xd3\x69\x9a\x94\x8a\x9f\xb7\xaf\xe7\x75\x12\xca\x96\xa7\x14\x6e\x9e\x56\x7c\x62\xd7\x4a\x5f\x1f\xdb\x5a\x6b\x77\x69\xa4\x24\x8a\x78\xe1\xf8\x54\x68\x8c\x0d\x3b\x11\x83\x6d\xf5\xbf\x5b\x3e\x2f\x9e\x9e\x2f\x98\xcf\xd7\xaf\xe3\xb4\xb6\xb4\xfb\x8a\xc2\xe0\xf1\x5d\x94\x92\x43\x06\x42\x09\x7c\x2d\x9b\x2d\xa1\xba\xf5\x46\x4b\xa1\xae\x53\x57\x99\x6f\x26\x38\x37\x26\x1d\x8e\xd9\x9b\x25\x28\x96\xcc\x61\xdb\x31\xe4\x0b\x8f\x3e\x3d\xd2\x30\xfd\x28\x88\xbc\xc5\xa4\xe4\x8f\x95\xbf\xfa\xfd\x85\xdc\x8d\xea\x88\xb3\xad\x8c\xeb\x72\x57\x83\xce\x7e\x47\x5f\x96\x3a\x29\x28\x4e\x84\x9f\x67\xf1\x83\x52\xe3\x56\xa7\x17\xed\xc5\x02\x23\x2b\x03\xc1\xd6\x40\x72\xd9\xe7\x77\x81\xb7\x92\x4b\x41\x76\x42\x8b\x98\xd0\x69\x24\xac\x74\x39\xaa\x7b\xa6\x9d\xb6\x53\x70\xcd\x44\x62\x13\xe6\x08\x2c\x47\xe4\x67\x18\x7d\xb2\xbd\x76\x72\xaf\x09\xfe\xb6\xdb\x4d\x4b\xd5\x88\x73\x5f\x68\x9c\x03\x96\x1b\x14\xee\xbc\x92\x4a\x2c\xf5\x87\x31\x38\xd5\x0c\x55\xdc\x55\x6b\x55\xfd\xed\x43\x9b\xcf\x84\x2e\x55\xea\x57\x9d\x7b\xcc\x32\x39\xe6\x82\x3c\x71\xb0\xc1\xf8\xc1\x59\x94\xea\xce\x2e\x3c\x1f\x9c\xba\xd5\xd6\xcf\x59\xfc\x5e\x1e\x2a\xa9\xf8\xd5\xb0\xba\x3c\x14\xd8\x39\xdc\x4b\x47\x3a\xdc\x2f\xd7\x24\x68\x99\x06\xde\x54\x59\x52\x4f\xee\xae\x2f\xc5\x15\x36\x9b\x0b\xd8\xe9\x0d\xb6\x1b\x64\xa9\x84\xc7\x13\x6c\x69\x69\xb4\xe6\xec\xc5\x74\x34\x2e\x4d\x94\x99\x96\x6c\x04\xe6\xd1\x86\xc4\xea\xe0\xd6\x43\xe0\x15\x27\xa1\xbc\x4e\x24\x6a\x8a\xca\xe9\xc9\x39\x61\xc5\xd6\x31\xe1\xd1\x8a\xbf\x34\x8f\x0e\xa0\xf2\x42\x6c\xf4\x13\x2a\x79\x8a\x8e\xee\x2c\x60\xff\x65\x53\x89\x95\xa9\xfe\x6b\xa4\x6d\xfd\x30\x15\xac\x2c\x2d\x26\x37\x40\x04\xb7\x9a\x0b\xb9\x0d\xa2\x0e\x9e\x69\xfb\x45\xac\x43\x08\x4f\x89\x1b\x36\x33\x89\xaf\xf3\x22\x68\x49\xe9\x34\x9a\x20\xdc\xc4\x67\xf2\x38\x51\x8d\x6f\x39\x78\x0e\x65\x35\x0b\x7a\x5d\xdd\xae\x56\xb3\xdd\xf5\x13\x59\x96\x48\xf9\x2e\xd1\x55\x62\x54\xee\x90\xaf\x32\xb6\xad\xc2\xca\xab\x53\x2a\x6c\xb2\x61\xe1\x8d\x45\x97\x11\x7d\xc5\x55\x49\x8a\xe9\x10\x63\x47\x89\x11\x06\xb7\xc0\x23\x93\xdb\xde\xdf\xea\x21\x33\x8a\xb4\x71\x32\x52\xcb\xe5\xf5\x46\xc6\x2e\x9d\xc9\x47\x86\xaa\xd5\xe8\x56\x4e\xc3\xe7\xda\xaa\xf6\xab\x75\x35\x08\x46\xee\x1a\xe3\xb8\xc6\xb9\xb3\x04\x88\x00\x65\x8a\x65\x1f\xc0\x90\x40\x5b\x38\x0e\xa2\xc6\x35\xd9\xc1\x30\x1e\xd3\xbc\x4d\x03\x9f\xfd\xbe\xbd\x76\xec\x4e\xb3\x42\xbe\xe4\x9b\x2d\x6d\x4b\x95\x09\x53\xb8\x78\xc6\xbf\xac\x09\x8d\x97\xc9\x8f\x66\x1c\xe1\x76\x8c\x9d\x39\x6e\x50\x63\x7e\xde\x57\xe1\xcc\xbd\x0c\xbc\xe7\xea\xc0\xdf\x56\xb7\x74\xad\xd2\x64\x65\x6c\x3e\xcb\x74\xe3\xca\x79\x76\xb8\xce\x1e\x00\x8b\x71\x5c\x55\x22\xd7\xfd\xe7\xf6\x70\x69\xa2\x69\x70\xad\xdc\xbb\x71\x95\xcb\xc5\xae\x6f\x99\xe3\xfd\x30\x70\xd2\xab\xee\x06\xd6\xda\xf5\xc9\xc3\x5a\x71\x89\x3d\xb3\xe9\x80\x43\x81\x05\x56\x97\x3a\x44\xc9\x87\x65\xdf\x41\xd7\x86\xba\x62\x87\x01\x16\xe1\x90\x71\xd5\x96\x92\x64\x3b\x35\x31\xde\xf4\x8b\x29\x6b\x50\xbc\x2e\x43\x85\xbc\x58\x82\x4e\x0a\xa3\x3b\xe9\xc5\xbf\xec\xc8\xba\xd3\x6c\x77\x3c\x4f\x0b\xbb\x20\x20\x4c\x5d\x34\xed\xf0\xac\x59\x5d\xcf\x0f\xa9\xcd\xcb\x44\x86\x51\x9b\x8d\x79\xe6\x7c\x5b\xb0\xc5\x95\xf5\x98\x8c\x24\x86\xc2\x1c\x53\x1c\x8f\x72\x9d\x03\x1a\xd0\xa0\x89\x4d\x7d\x06\x62\xd9\x46\xdf\x2c\x02\xe1\x64\x48\xae\x8f\xd4\x0f\x1c\x95\xb5\xbe\x52\xf5\x93\x54\x58\x94\x0a\x57\x1e\x93\xe9\x9b\x46\x34\x58\xf9\xc7\xf2\xf8\xf5\xf7\xfb\x8e\x84\xc5\xf0\xe2\x32\x3d\x51\x61\x94\x96\xe7\x23\x16\xca\x65\x93\xf5\xd7\x4f\x7c\xdc\x5f\xc9\x65\x20\x8c\xe6\xdc\xb8\xe4\xa2\x23\xc5\xf7\x7a\xe6\xb8\xf9\x42\x42\xf8\xd9\x42\x68\xae\xd0\x0b\xdf\xfb\x61\x4b\x73\x77\xf0\x97\x59\xec\x3e\xb4\x8c\x07\xa8\xae\x6e\xb8\x35\xd3\x36\x7b\x63\xba\x41\x11\xd3\x93\xb8\x10\xc5\x25\x7c\x6e\x1e\xc2\x6f\x4c\x0b\x58\x5a\x49\x6c\x88\x24\xd9\xd5\xc8\x21\xfc\xe2\xd7\xcb\x3a\x38\x04\x90\x10\x28\x5f\xec\x53\x69\x67\x7b\xd0\x0d\x99\x32\x8d\x53\x35\xf6\xf7\x24\x0a\x7a\x86\x4c\x1d\x69\x9d\x6f\x70\x02\x61\xe9\xa6\xc0\x35\x32\xa5\x1f\x18\xe8\x39\xdc\xc4\x6e\xdc\xee\xc2\x57\x9b\x77\x82\x63\x16\x2e\xb9\xa3\x1e\xb5\x92\xde\x53\x1d\x5c\xfc\x99\x6f\xdb\x68\x93\x9d\x56\xc5\xd9\x5e\xab\x60\xfb\x2e\xcf\x5e\x94\x78\xad\x29\x5c\xf9\xb1\x94\xa3\xd8\x74\x77\x16\x6a\xb7\x77\x41\xfd\x4a\x97\xaf\xd0\x97\xde\xdf\x96\x05\x11\x6e\xfc\xd3\xa9\xe0\xf6\xea\x03\x09\xc8\xf4\xcc\x63\xe2\x98\x0a\xf9\xa2\x29\xb1\x5b\xa0\xf3\x5e\x8f\x5c\x0e\x43\x23\x49\xa1\x03\x67\x9c\x7a\xf2\xba\xd7\x4a\x8a\x20\xd2\xa5\x65\xd5\xc8\xb0\x6c\x06\x11\x5e\x16\x02\x36\x3e\x3c\xc8\xc2\x2b\x84\x1b\xb2\x18\x6b\x38\x53\xc4\xcb\x68\xce\x65\xd0\x8d\xc3\x8c\x7d\x8f\x84\xf8\x84\xe8\x0a\x05\x71\xd5\x7e\x5a\x59\x2b\xbf\xd5\x4a\xfd\x9d\xd3\xb7\x4b\x1b\x6e\x4c\x6c\xd8\xba\x6d\xc5\x41\x9e\x4e\x62\x8a\x02\x64\x61\x64\x29\x52\x95\xb8\xfb\x91\x3b\x5f\xa9\xa6\x03\x5d\xc4\x06\x5c\x8c\x2d\xe4\x8a\xc6\xfe\x49\xaa\xc8\x0f\x9f\x42\x39\x02\xed\x46\xdf\x6e\xb2\xf6\x8e\x37\x1d\x79\x5a\x5f\x73\x56\x5a\x59\x4a\x92\x32\x6a\xca\xbd\x37\xf0\x52\xf4\xd3\x12\xac\xbd\x95\x3a\x2d\x92\x94\x0f\x52\x56\x6e\xd4\x37\x31\x85\x40\xcc\x70\x8c\x9d\x21\x0d\xac\x5f\x73\x4a\x7d\x99\x18\x6f\xde\x62\x21\x7d\xee\x9d\xa6\x1f\x28\x1c\x98\x6f\x76\xb8\x74\xc5\xd9\x17\x67\x64\x8a\x4e\xaa\xb2\x6a\xd4\xd3\xd2\x7b\x1c\x64\xb9\xfe\xb4\xf6\x10\xd1\x4d\xed\x78\xfc\x4c\x69\x55\xc9\x1c\xe8\xcf\x4f\xca\x7b\x07\x03\x41\x8b\xad\xce\x01\x39\xe4\x76\xf6\xd7\x6c\xd7\x20\xd4\xba\xbf\x54\xca\xd4\xc1\xaf\xd2\x25\xc4\x22\x7d\xe4\x70\x3b\xfa\xb7\xa7\x74\xa5\x54\x38\xb2\x70\x70\x13\x44\x95\x3d\x07\x8e\x9c\xfc\xd0\x80\x94\x70\x25\xad\x98\xb3\xfa\x2e\xc4\x42\x82\x26\x7e\x11\x40\x5d\xd1\xf1\x59\x6e\x85\xb4\x13\x9b\x4b\xfb\x85\xc6\x51\x41\x52\x19\x95\x5f\xd4\x0e\x51\xc1\xa6\xb4\x77\x09\x3a\x7e\xb9\x62\x00\x3c\x61\xd4\x21\x4c\x5a\x89\x30\x71\x2e\x76\x51\xe1\x45\x98\x7d\x49\xab\xc5\x87\x5b\x4b\x36\x9c\x8e\xba\x5f\x86\x14\x3d\xda\x0b\xce\xaf\xd7\x85\x88\xdc\xa8\x47\x87\x41\xe4\xd9\xa5\x04\x70\xa2\x06\x4d\x61\x31\xa2\x89\xd5\xe6\x82\x7d\xc4\x6f\xe4\xd3\xe9\x18\x32\xee\x96\x87\xe9\x2a\x3d\xcf\x5f\x57\x23\xf2\xbd\x5a\x07\x32\x6f\x99\x0d\xda\x92\xd0\x6b\xf8\xb1\x3e\x58\xf6\xc9\x1f\x10\x1a\xbf\x25\xe5\x5b\x49\x59\xa5\x82\x56\xce\xa0\xff\x86\x9f\xfc\x61\x40\xa6\x25\x81\x91\xe2\x92\xc8\xa2\xba\x13\x0e\x20\xb4\x6d\x54\xcf\x1f\xe6\x22\x90\x31\xad\x20\xa2\xc8\x55\xfa\xe9\x25\xad\x4f\x4f\x90\x09\xfb\xed\x9d\x5d\x3b\x18\x01\x5e\x28\xbb\x5f\xb9\xe5\xd3\x4b\xda\xd2\x36\x5c\xb1\x78\xc4\x7c\xdc\xea\x3a\x83\x52\x69\xcd\xd6\xa9\xed\xb0\x12\xe1\xd8\xb1\x71\x22\xa7\x93\x02\xbb\xf1\xda\x61\x65\x85\xc0\xb6\x26\x8e\x8a\x73\x97\x9d\xec\xa9\x38\xee\x22\x98\x33\x8d\xbf\x01\x05\xb4\xed\x8d\xc5\x59\x97\x36\xa5\x6c\x33\x7f\xb9\xd0\x40\x6f\x36\x53\x35\xea\xcf\x9e\x0c\xd8\x39\xd1\x4e\x75\x25\xaa\xb9\x70\xc0\x7a\xe7\x61\xde\x5f\x11\x0f\x66\x28\x3f\x3c\xc2\x89\xc1\x65\x17\x72\x87\x9a\x52\xef\x91\xe5\x0c\x45\xe9\x6d\x51\x6f\x5c\x5f\xbf\xe5\xaf\x6a\x92\x36\xf4\x2b\x3f\x36\x56\x9f\x5e\x4e\x99\x51\xdf\x83\xef\xdb\x25\xbd\x76\xf0\x00\x32\x2d\x19\x45\x20\x35\x58\xea\x95\xa4\x20\x05\x61\x2c\x71\xb8\xfc\x89\x47\x34\x95\xf8\x93\x45\xcc\x18\x13\x85\x66\x19\xe2\xd3\xd4\x44\x5b\x38\x62\xb8\x40\x0a\xd9\xdc\x04\xdf\xb4\xeb\x04\x89\xee\x9e\x3a\x6c\xc6\x74\x0a\x0f\xa9\xc3\x30\xe3\xe8\xf2\x5d\x5e\x78\x56\x51\x6e\xed\x59\x0a\x7f\x99\xa1\x7c\xf4\xdc\xd1\x9d\xaa\x22\xe3\xe3\x79\x1f\xa9\xb6\xf5\xfc\x70\xd5\xfe\x35\x18\xbb\xf5\x19\x38\xde\x6b\x1d\x58\xb7\x66\xb9\xa5\xb2\xb7\xd6\x5e\xfc\x40\xf0\xf5\x0c\x04\xfe\x6d\x99\xfc\x02\x06\x3b\xee\x82\xb3\xe8\x67\x82\xf5\x72\xed\x5d\x9f\x6b\xfc\x08\xe7\x9a\x16\x73\xef\xf3\xbf\xab\xc6\xae\x64\xe7\xb0\x7c\xec\xfc\x1c\xb4\xac\xea\x05\x9a\xae\x05\xe1\xba\x6a\xbb\xed\x33\xc4\x3d\x5c\x9b\x2e\xd9\xe6\x00\xa5\xcb\xca\xdb\x5d\x5a\x5c\xdb\x29\x5c\x8a\xf6\xd6\x73\x73\x5f\xd7\x93\x62\x6a\xdc\xab\x43\x9a\xa5\x78\x68\x78\x4c\x6a\xf9\xfa\x46\x73\xca\x92\x82\xf3\x3a\x7c\x64\x45\x33\x41\x79\x81\x71\xec\x31\xf4\x14\x3d\x66\x5d\x61\x6b\x29\xc5\xde\x03\x4e\x1b\x54\x2e\x33\x4a\x52\x2c\x0b\xea\x8b\xe1\xe5\x21\x21\x71\x8e\xb8\xda\x96\x6a\xb5\x15\xb2\xcf\x8b\x74\xb3\xb5\xe9\x9d\x52\x5f\x7a\x3e\x96\x61\x8b\xb8\xf8\x8a\x05\x74\x3a\xcd\x55\xeb\xc4\x9c\x82\xa2\x64\x7a\x64\xac\x29\xe3\x4a\x14\xbf\x48\xb1\xce\x7f\xae\x75\xb4\x6c\xcb\x97\xb9\xd7\xf7\xb3\x65\xa5\x64\x48\x74\x59\xdd\x43\x78\x84\x48\x29\x55\xbb\xab\xa8\xb7\x53\xe2\xf0\x46\x34\x50\x2d\xb2\x63\xf1\x3a\x8f\x6b\xe6\x18\xca\x2e\x24\x54\x6b\x35\xba\x97\x8d\x9d\x50\x51\xe6\x65\x6a\xf6\x7f\x59\xd2\x02\x81\x6e\x99\x42\xba\xd6\xe5\xa3\x9e\xbd\x1b\xb1\x5a\x09\x20\x13\x2d\x8b\xc8\x96\xfc\x7f\x42\xf0\x14\xcf\xe0\x69\x36\xe2\x8e\xe8\x8b\xd2\x46\x90\xa2\x4e\x43\xab\xbe\x5b\x51\x30\x12\xae\x46\xc1\x6b\x9c\xae\x67\xdb\xfa\xe3\xa1\xaf\x36\x97\xad\xd2\xc2\x32\x78\x85\xb8\x27\xdc\xe2\xbc\x74\x0c\xc9\xdb\xf5\x11\x79\x5d\xef\x86\x4f\x39\x17\x38\xab\x33\xec\x4a\x31\x9c\x4e\x0b\x22\x17\x9f\x06\x22\x1e\x36\xd8\x71\xf6\xea\xa7\x0f\x53\xfe\xe0\x25\xc4\x2a\x76\xa2\x3f\xde\xe7\xe2\xfe\xe1\x37\x06\x01\x9c\xa3\x03\xba\xf5\x5b\xf2\xfc\xef\xf7\x78\x9a\x41\x99\x57\x5d\xd9\x0a\xa3\x91\xa4\x2d\x72\x28\x61\x7d\x5a\xfb\xd7\xd1\x6d\x18\xa5\x1a\xc6\x65\xe8\x7b\x5b\x11\x32\x45\xca\xf5\x15\x03\xfb\x25\xc2\x56\xd4\xae\xfe\x60\x6b\x2a\x4d\x2f\x80\xf7\xd3\x72\xda\x51\x64\x7c\xaa\xd7\x2f\xcd\xc9\x63\xb4\xc8\xf0\x9d\x3a\xc4\xae\x2d\xa7\xe0\x20\xe4\x58\xe4\xa6\x22\x97\x82\xdc\x4b\x15\xe0\x98\x5e\x77\x66\xb5\xc9\x34\x18\xd9\x40\xb3\xab\x23\xd8\xf4\xfe\x96\xb5\xca\x41\xdf\xdd\xaa\x09\x4c\xb4\xde\xab\x80\x14\xab\x7c\x55\x7f\x6a\x96\xbd\x8c\x9b\x0a\x60\xac\xe6\x14\x21\x57\xbb\x96\x0a\x9b\x30\x08\x97\xda\xf5\xca\x1d\x6a\x8b\xa8\x7b\xae\x83\xb8\xc3\x2d\x96\xbc\xa9\x6f\x56\xc3\x72\xf0\x5c\xdd\x6a\xcd\x7c\x41\xbf\xb2\x54\xf8\x36\xd4\xd0\x62\x7a\x52\x5c\xfc\x59\xcd\x3c\x97\xeb\xcd\xfb\x3e\xd9\xc8\x2f\x69\xd5\x6d\x7b\x37\xd3\x9e\xdd\x59\x6c\x7b\xdb\x6d\x72\xef\x7e\x20\xdf\x0c\x53\xed\xa9\xe0\xf6\x19\xfd\xf6\x97\x01\x8b\xaf\x64\xd8\x5b\xa9\x4e\xb7\xb9\xdb\xa9\xc1\xe4\x7b\xd5\xcd\x24\xd8\x7d\xd9\xd3\xa4\x47\x8b\xca\x61\xb0\x3e\xc0\x60\xda\xdb\x1e\x9e\xfc\x20\x78\x8f\x10\x80\xd9\xb1\xff\x94\x5c\x39\xbc\xf0\x84\x8f\xe2\x6b\x7b\x94\x8e\xf9\x84\xdb\x95\x89\xfa\x99\xe6\x08\x12\x40\x2d\x78\x36\xb9\x5c\xd7\xfe\xf5\x96\x4a\x91\xe2\x52\x20\xae\xac\x22\x97\xb5\x07\xec\xba\x1b\x0e\x1c\xd8\x59\xf4\x9d\xca\x70\xd6\xfa\x32\x16\x88\xfd\x89\x31\xe8\xf5\x39\x73\x8e\x39\xe3\xca\x75\x8f\x99\xbe\x40\xb5\xc1\x70\x85\x68\xf5\xef\xcc\xd9\x18\xdf\x02\x6e\x15\x4b\xac\xb5\x65\x65\x91\x5a\x68\x2a\x34\x65\x96\x2e\xe2\xe2\xa5\xa9\x52\x1b\x6c\xc1\x9f\xfa\x87\xda\x88\x0c\x09\xcd\x81\x53\x83\x04\x68\x00\xc6\xab\x45\x92\x6c\xc1\xff\xce\x07\xae\x92\x43\x59\xf2\x26\x3b\x8d\x1d\x91\xb4\xde\xf3\x4e\x48\xc5\x1e\x17\x29\xdf\x38\x98\xec\xe3\xe0\xaa\xa1\x6e\x2a\xf8\x3e\x94\x5a\x10\x4a\xca\xea\xb8\xaf\x25\x85\xbc\xc5\x87\x7f\x3f\x29\x1c\x25\xa8\x31\xd4\x17\xd7\x3c\xc8\x45\x4d\xd9\x8e\xe9\xb4\x38\x38\x2c\xee\x5a\x5c\x65\xef\xc7\x73\x67\xc9\xa6\xca\xb0\x48\x24\x74\x8e\xeb\x31\xba\xce\x64\x9c\x3f\xff\xd6\x7d\xca\x5d\xdc\xc9\x6a\x0b\xc3\x86\x0f\xc2\x7e\x24\x92\xb0\x45\xde\xc3\x5a\xbe\x70\xf6\xe8\x26\xa9\x61\x4e\x77\xf2\x68\x34\x87\xad\x07\x89\xb6\xcc\xb6\x68\x5d\xb3\xbe\x5a\x35\x39\x00\x93\x46\x3d\xa5\x28\x5d\xb2\x3c\x81\xd5\x81\xe2\x5c\x75\x5e\x13\x9e\xcb\xcc\xe9\xfd\x28\xb8\x9a\x54\xb5\x99\x1b\xed\xd2\xc9\x9d\xc1\x4e\x2b\xdb\x69\x70\x58\x7b\x8e\xb4\xd1\x8d\x7b\x8e\xd8\x2b\x87\x14\x52\x12\xfa\x3d\x82\xd6\x3d\x4c\x0c\x1d\xc2\x16\x2b\x66\xfe\x87\x24\x47\x6d\xf9\x1e\xb1\x96\x11\x8b\xd7\xee\x9d\xe2\xb4\x61\x4f\x3b\x81\x1f\x9c\xc3\xc3\x3b\x40\x81\x01\x56\x34\x90\x38\x7d\x2a\x61\x17\xee\x22\x8a\x9c\xf7\xd3\x4a\xd4\xdf\xf5\xa1\xc0\x68\x44\x94\xd9\x05\xe7\xcf\xdd\xb9\xe8\x96\xb3\xb0\xa8\x7a\x89\xea\x69\x11\x85\xe8\xc6\x45\xfe\x2a\xb6\x1e\xbd\x81\xec\x5d\x3f\x8e\xf3\xe9\x61\xbe\x7f\x7c\x2c\x3c\x40\x15\x68\x75\x1d\xe7\x25\xb1\xe2\xb7\x7e\x38\xde\x3a\x4c\x5d\x45\xe0\x13\x98\x71\x48\x75\x77\x19\xb9\xa3\x51\x4e\xbd\x4e\x44\x73\x57\x32\xe9\xdc\x8e\xbd\xa8\xe0\x12\x9a\x7d\x26\x34\x2b\xc3\x90\x58\xe0\xb2\x18\x40\x6f\x1f\x76\x6d\x98\x91\x50\xad\x8e\xe9\xd8\xb0\x46\xeb\x0b\x3f\x03\x32\x74\x84\x9c\xd4\xd9\xe1\x2a\x5c\x8d\x19\x10\x1a\x32\x75\x6f\x2e\xcb\x76\xe0\x3f\x90\xa7\x5e\x72\x3c\xef\x90\x21\x1d\x95\x77\x06\x80\x2a\x57\xd9\x69\x80\xac\xd3\x34\x74\x98\x37\x0c\xb2\x67\xa5\x82\x42\x53\xcd\xdd\x20\x4a\x32\x64\xc4\x22\x08\x67\xfe\xc3\xfd\x98\x21\xc8\xb8\x1d\x65\x2c\x36\x9d\xad\xa2\x7f\xa9\xda\xfb\x26\xab\x32\x6b\xfc\x02\x13\x48\xd9\x75\xd4\xc1\x5d\x8f\xc3\x8d\xff\xfd\xe1\x85\x62\xf4\xde\xf0\xce\xfd\x94\xa2\xab\x1c\x9c\x85\x48\x28\x40\xfc\xfe\x97\xc1\xfb\x41\xa6\xc8\x1c\xa6\x72\xe7\x81\x5b\xbb\xbf\xc2\x75\xd6\x89\x1d\x51\x6d\x4b\xfd\xa0\x2e\xf3\xa6\xcb\x26\xf2\x7d\x79\x61\x49\xd6\xb4\xec\x1c\xcb\x8c\xbd\xe2\xad\x01\x47\xa4\xe2\x1a\x4c\x70\xfc\xf3\x98\x5d\x57\x31\x50\x84\x57\xa9\xc6\xad\x55\x75\x94\x55\x1e\x3e\xf4\x97\x63\xef\x31\xce\x87\x75\xba\xde\xf8\xa7\xc3\x70\x8f\xba\x7e\x75\x4a\x6b\xf3\x63\x4b\xd3\x63\x01\xe6\xb3\x47\x85\xa2\xfe\x9b\x53\x96\xef\x27\xcc\xb6\x25\xce\x77\xe4\xf0\xe4\x83\xee\xbc\xe8\xfa\x33\xef\x47\x05\x7c\xbd\x91\xea\x5a\xaf\xa9\x50\xea\x93\xc5\xda\xe9\x4e\x28\x59\xe0\xa4\xf2\xd2\x87\xf7\xa3\x66\xe3\x96\x0d\xfd\xa6\x06\x69\x7c\xa3\x8a\x7d\x17\xd7\xd2\x46\x26\x35\x0f\xbe\xa9\x69\x9f\xcd\x88\x98\xd9\x71\x02\x3c\x2e\xa5\x0a\xf4\x5f\x7a\x03\x7f\xde\xd9\x80\xdd\xb4\x96\xdf\x1e\x35\xa5\xcc\xc6\x96\x27\x20\xb0\x2c\x43\x40\x18\x17\x9d\x29\x05\x55\x49\x5f\xc5\x6e\xe5\xad\xe5\xed\x49\x1a\xd9\xb9\x3f\xe5\x22\xe5\xee\xcf\x70\xd3\xf3\xc2\xed\x19\xd8\x97\xdc\xea\xd9\x42\xa7\x34\xa7\x4f\x46\xbe\xb2\xdd\x02\x5b\xa1\x36\xa4\x9c\x23\x2f\x32\xcf\x85\xc9\x02\xee\x4f\x21\x66\x76\x92\x05\x85\xf9\x2d\xbc\x3a\x5b\xa7\xed\xd5\x0f\x21\x64\x9a\xf3\x95\x9e\xe5\xd1\x73\x5a\xbe\x0e\x1c\xd2\x3a\x8a\xbe\xeb\x79\xdf\xc5\xf1\x77\xd9\x0d\xa6\x1c\xf1\xdb\xc5\x38\x20\x3e\xa5\x00\xfd\x1c\x23\x0e\x15\xde\x62\x53\xf9\xb8\x46\x8a\x4c\x90\x3f\x7d\xf4\xbf\x48\xac\x56\xa1\x60\x4f\x91\x17\x78\x81\xf1\x73\x55\x1e\x8a\x6c\x09\x81\x36\x76\x87\x3e\x9a\xa3\x22\xfe\x95\x26\x58\x36\xc8\x59\xe7\x62\xd5\x34\x04\xee\x67\xf1\x18\xd5\x5e\x04\x5c\x09\xc1\x10\x25\x26\x89\x5f\x77\x22\x93\x9d\x05\xbe\x3e\x22\x2b\x2d\x79\x32\x2f\x13\xb9\x85\xda\x93\x58\xdd\xc8\x6d\x65\x83\x26\x99\xde\x18\x16\x22\x68\x75\xcc\xf5\xf6\x32\x72\x33\x19\xd1\xe1\x03\x9e\xe7\xe3\x46\x7f\xb5\x9d\xbf\xc6\x47\x54\xa0\xfe\xbe\xa4\x76\x22\x91\xf4\x33\x70\x9f\xdd\x3b\x4e\xf8\x3c\x3d\xee\x75\xfe\xdc\xb7\x07\x56\xae\x66\x8c\xfa\x49\x55\x0c\xd0\x45\xb1\x81\x4d\x08\x36\x35\x50\x60\x9c\xa5\xa6\x4d\x35\x0f\x49\x57\x2d\x98\x22\x19\xe6\xcf\x9b\x92\x57\xf3\x5e\xa4\x2d\x89\xbd\x3f\xb6\x35\x53\x4c\x23\xbc\x05\xfb\x7b\x37\x43\x2a\x5d\x1e\x25\x95\xd7\x94\xec\x15\xab\x0a\x05\x4a\x54\x38\x6e\xbb\x97\xf6\xd6\xf7\xcf\xbe\x2b\x0a\xc9\x64\x53\x3d\x39\x4c\x19\x95\x6d\xb1\x93\xab\x08\x4d\x67\xbb\x2e\xb3\x44\xc9\x06\x3a\x1a\x36\xe8\xb3\x4f\x9b\x58\x61\x8f\x2f\x9f\x12\x6a\x3b\x05\xf6\x2b\xbb\xbe\x6c\x35\x8b\x0e\x96\xb1\x1c\xd9\x26\xcc\x39\xe7\xec\x2f\x47\x1f\x95\x32\x95\x0b\x56\xf0\x91\x60\xd8\xb2\x53\x06\x22\x3f\x77\x4b\xfa\x58\x84\x8b\x50\x62\xe2\x54\x88\xc8\x6c\xa3\xd6\xcc\xd1\xc9\xf3\x24\xae\xd8\x78\x07\x18\xdb\x54\xd8\x39\xe9\x74\xc5\xd5\x22\xac\xe8\xf0\x2c\x6c\x5c\xb0\x8e\x9a\x4c\x57\x65\xf3\x31\x23\xa7\x3d\x4d\xbc\x60\x12\x30\x38\x28\x28\x10\xf2\xef\x0f\xaa\x11\x1e\x04\x46\x25\xbe\xa7\x1f\xe4\x5e\x51\x36\x28\x80\x41\xc6\xae\xa8\x58\xdf\xed\x53\x11\x39\x56\xf5\x14\x8b\xb5\x1f\xe1\xb0\x77\xe4\x27\xa4\x9f\x67\x65\x69\x6c\xb2\x34\x5f\x5c\xc3\xd4\x5c\x0e\x04\xab\x24\xc2\xb5\x5b\xb5\x24\x84\xaf\xe7\x76\xbc\xdb\xbd\x18\x45\x07\x72\x75\x0b\x19\x82\x9f\x1b\x77\xee\x9c\x53\x38\x32\xd5\x88\x6c\xad\xcd\xe2\x73\x97\x3a\x13\x1c\x53\x8f\x50\x40\x74\xee\x62\xc6\x44\x92\x5e\x66\x68\x13\x3f\xe7\x66\xc0\x1b\xb2\xf8\x47\x7a\x57\x21\xb8\x20\x45\x78\xb8\x0b\x7b\xec\x8c\x97\xbd\xd8\xb0\x84\x44\x19\x28\x8b\x22\xcd\xd3\x1b\xb0\x28\x92\xa0\x2c\xca\x63\x51\xc7\x9c\x94\x63\xe0\xf8\xb0\x21\x43\x07\x95\x38\x8d\x58\x38\x7d\x56\xa5\x0d\x47\x1a\x85\x6e\x14\x67\xba\xff\x81\x57\x23\x22\xcc\x5d\xc9\x15\xf6\xc6\x35\x4d\xee\xb5\x5a\x4b\x50\xd3\x15\xb8\x60\x51\xac\x64\x28\x46\x74\xf6\x7a\x4e\xd6\x7e\xe9\xf1\x93\xc7\x82\xb9\x1f\xad\xf1\x79\xbd\xe5\x72\x0a\xfc\x48\xd7\x4c\xca\x49\x79\x4f\xe3\x64\x81\xf0\xa4\x5b\xa2\xaf\x1d\xf5\x03\x2d\xef\xc1\x03\xba\x1f\x44\x0b\x74\xd7\x31\x5e\x40\x0e\xfc\x2e\x73\xeb\xf8\x7f\x00\x03\x40\xfc\xbf\xa6\x36\x2d\x4e\x4d\x76\xce\x4d\x24\xfb\x19\x63\x35\x30\x67\xb6\xcd\x1b\xb8\x68\x51\x36\xab\x14\x07\xb6\x00\xe3\xd4\x31\xfd\xb1\xfd\x42\xff\x95\x6e\xd7\xe4\xee\xc3\x57\x5f\x75\xb8\x73\xda\xce\x3b\x42\xd9\xee\x45\xae\xcc\x1c\x02\xe3\x67\x97\xf5\x7d\x5c\xa5\xfd\xff\x22\x5c\xf1\xa5\x61\xa0\xa6\x1a\x9a\x51\x3d\xbb\x23\x96\xec\xda\xcd\xa7\x9d\x99\xef\xd5\xbe\x76\xc7\xfe\xb3\xa3\x8d\x31\xea\xc5\x8a\x53\xaf\x59\x28\x52\x2e\x69\xed\x5b\x81\x8c\x39\x02\xf8\x0b\xc5\xfa\x4a\x64\xe7\xd1\x51\xd3\x9c\x3c\x0b\x12\x30\x40\x42\x8e\x4e\x79\x61\xfc\x29\xbf\x6a\x04\x30\x56\x68\x9f\x32\xec\xac\x84\xc7\x73\x01\xed\xd2\x4f\x00\x9d\x65\x50\x1e\x35\x3e\x49\xae\x93\x7e\xaf\x91\xea\xa9\x31\x21\x00\xc6\xfb\xa1\xff\x2d\xbc\x06\x41\x38\x61\x67\xc4\x6a\xca\x4e\x71\x5e\x37\xac\x36\xea\xc3\x65\xab\x13\xb0\x2f\x89\xec\xbe\x87\xdd\xb3\x52\x75\xd4\xa2\xc1\x5a\x26\xfd\x55\xa1\x45\x4a\xa9\xb8\x6c\xb6\x70\x9e\x59\x6f\x9e\x3c\x32\xe9\xb9\x22\x15\x5f\x9c\xec\xf4\x14\x3a\xd9\xe9\x39\x37\xde\x39\x66\xb2\xd9\xda\xe9\x98\x8e\xb3\x00\x88\xb3\x2e\x04\xb5\x21\x0d\x68\x49\x17\x1b\xda\xc2\x34\x0d\x52\x6b\xa5\xf3\x43\x6a\x11\xae\x47\xd3\x42\x75\x0c\x2b\x62\xfa\x98\x99\x74\x51\xf5\x50\x12\x9d\x75\x08\xd1\x2f\x0c\xd0\x90\x31\xfa\x99\x54\x18\x5a\x35\x1c\x97\xe5\x95\xf4\xdb\x01\x87\x56\x3a\x1c\x2b\xd1\x7a\x70\x82\xe3\x38\xfa\x88\x6a\x84\x8e\xa7\xb1\x79\x5c\x53\x54\xa4\xe9\x21\xa9\x7a\x08\x72\x81\xe3\xf8\xf9\x75\x38\x59\xdb\xb8\x24\xfd\xf8\x13\xd5\x85\x84\x46\x95\x75\x46\x59\x13\xdd\xf1\x0c\xca\x54\x6a\x1c\x0a\x02\x2b\x5b\x6b\x8c\x6a\x60\x18\xe2\x47\xc5\xa6\xa2\xf5\x2b\x91\x79\x6c\xd3\xd6\xa6\x59\xeb\x8b\x8d\xf1\x8d\x34\x14\x52\xab\xe7\xd4\xd3\x2c\xb6\x2b\xaa\xe9\x68\x22\xad\x29\x3d\xa8\xac\x55\xcb\x3e\xce\x10\x1e\xad\xaf\x79\x56\xcf\xcb\x95\x21\xcb\xd8\x56\x5d\xc9\x5a\xeb\x38\x47\x5f\x0a\x17\x6a\x57\x0b\x1b\xae\xb2\x70\xa8\xa6\x48\xea\xf4\x20\xd6\xac\x51\x36\x50\xa8\x1e\xe9\x38\x3d\x77\xb0\x51\x39\xbb\x5d\x57\x8c\xcc\xf2\x38\x30\xc0\x9d\x39\x9f\x1e\x9c\x11\xfd\x12\x7b\xb9\xd1\x7a\x0f\x16\x24\xc5\x35\xeb\xce\x70\xbe\x2b\x94\x8d\xd2\x83\x44\x25\xea\x94\x92\x8a\x18\x2d\x91\xe4\xf5\x16\x14\x52\x60\x35\x43\x62\x4a\x69\xa5\x95\x68\x82\x45\x49\x40\xa7\xb9\xdc\xf4\x78\xa0\x51\x40\x87\xb9\x2d\xd8\x4a\xb3\xc3\x7f\x89\xfe\x68\xea\x6e\x94\xa2\xd7\x90\x21\x37\x93\xfb\x87\x23\xd7\x9d\x8e\xba\x59\x0a\xd1\xa3\x58\x10\xad\xa1\x9e\x16\x99\xa6\x05\x32\xec\xcf\x4d\x8d\xe9\x89\x6e\x89\xd2\xc6\x94\x18\xa4\xd2\xcd\x69\x26\x82\x23\x69\x85\x78\x32\x6e\x8f\x42\x85\x02\x80\x7e\x8c\xd2\x23\x9d\xf2\x7d\x32\x6e\x29\xcd\xb0\x13\xda\x2e\x77\x06\xb6\x14\xc9\x03\x6f\xb1\xc8\x14\x42\xe0\xa1\xc6\x1e\x19\x1f\x28\x93\xd6\x0c\x59\xc7\x6b\xa1\x22\x16\x1b\x8a\xbb\x35\x6e\x11\xb3\xf7\x47\x19\x0d\x50\x54\x46\x8b\xa3\x84\xb8\x3b\x93\x4e\x89\x51\x40\xf7\x28\xe3\x9a\xe5\xa5\xa3\x24\xba\xea\xe9\x25\x6c\x37\x51\x18\x3f\x8e\xca\x6c\x52\x1a\xbe\x1b\xb1\x50\xe4\x66\x42\x12\x21\x77\x9a\xd2\xa4\x4a\xc6\x9d\x61\x95\xc3\xae\x47\xdb\xd9\x8d\x00\xf1\x4a\xa6\x20\x83\x76\x4b\x1b\x8d\x67\xea\x01\x57\x4f\xd3\xac\x94\xbb\x4c\x5f\xe9\x24\x9b\x90\x74\x88\xb1\x9b\x61\x8c\xe8\x5b\x21\x69\x26\xfe\x1e\x4d\x17\xed\x3e\x4a\x16\xe2\xa1\x4c\x42\x66\xdd\x52\x81\x04\x16\x9e\xba\xa0\x25\xb5\x0c\xdb\xa3\x36\x21\xe1\x6f\xac\x06\x0b\x99\x86\xad\x22\x16\x04\x24\xda\x2c\x4a\xbd\x1d\x7b\x08\xf1\x12\x6c\x32\x22\x51\x6f\xc1\x06\x83\x88\xb0\x15\x23\x42\x04\x51\x27\x21\x22\x12\x11\x13\x23\xb1\xda\x0c\xa2\x9e\x48\x02\xb2\x3a\x89\x2e\x09\x6f\x09\x99\xfd\x3c\xf1\x01\x39\x2a\x61\x24\x0a\x3c\x31\xca\x94\x2f\x2d\x0a\xe1\xaa\xa0\x28\x4a\x26\x82\x89\x1e\x99\x24\x12\xb2\x0a\x66\x5e\x6f\x90\x05\x0b\xd1\x9b\xf4\x3c\x6f\xb2\xea\x0c\xc8\x6e\xd3\x21\xbd\xa0\xd3\x11\xbf\x41\xae\x96\xaa\x45\x01\x19\x0d\x66\x6c\x11\xb1\xd9\x00\x35\x0a\x82\x8e\x48\x01\x03\xef\xb5\x0b\x3c\x8f\x08\x6f\x21\xcd\xad\xa2\x28\xd8\x70\xbd\x4e\xb0\x88\x12\x74\x48\xc2\xbc\xd5\xa2\xb3\x89\x07\x2e\x96\x04\x1e\x03\x61\x2e\xa2\x26\x19\x13\x33\xb2\x21\x22\x49\xd0\x3a\x4c\xec\x66\x73\x10\x5a\xee\x30\x41\x95\x3a\xec\x41\x88\x20\x52\x45\x10\xe6\x45\xec\xb3\x62\x22\x60\xac\x83\x5c\xc4\x60\x71\x62\xd1\xa6\xd3\xbb\x45\x41\xc4\xd8\x6c\x72\x12\xa1\x5a\x67\x30\xd9\x05\xab\x5f\x0a\xcb\x58\x30\x4a\x58\xf0\x09\x90\xd0\xa9\xb3\xd4\x39\x04\x82\x31\xaf\xc7\x22\x42\x4e\x2c\xb8\x05\x62\x86\x71\xc2\x48\x2f\x62\xa3\x49\x96\x10\xbd\xf2\xaf\x97\xcc\x32\x15\x26\x30\xf1\x98\x36\x1e\x86\x11\x49\x4d\xa2\x55\x12\xb0\xe0\x25\x55\x02\x81\x9e\x09\x06\x6c\xd4\x49\x3a\x44\xff\x59\x25\x83\x01\x59\xec\xbc\x4b\x94\x78\x04\xc3\xad\x97\x04\x41\xd0\x9b\x74\x92\x50\x47\x24\x4c\x78\x37\xb6\x13\xe2\x30\x1b\x6c\xc4\xa4\x27\x76\x6c\x75\xdb\x8f\x9f\x78\x80\xc8\xc4\x21\x22\x49\x6f\x23\xd8\xc0\x1b\x45\x89\x4e\x15\x46\x2e\xab\x60\xd2\x1b\x45\x01\xc3\x62\x12\x88\x55\x6f\xe1\xcd\x18\xe6\x0e\xcb\x98\x27\x92\x5c\x8d\x79\x9b\x0d\x9d\xa5\xa0\xa4\x7e\x0f\xd9\x91\xc1\x84\x24\x9d\x28\xea\x64\xec\x46\x00\x16\x6e\x64\x33\x03\x48\x61\x18\x7a\xbd\x97\x08\xd0\x13\x49\x14\x0c\x06\x8c\x10\x8c\x2b\x46\x82\xc8\x23\xde\x26\xf2\x7a\x1d\x16\xf4\xbc\xa8\x97\x89\x68\x11\x24\xbb\x59\x67\xe3\x75\x2e\x91\xdd\x03\xc0\xd8\x58\xab\x04\x9d\xde\x6c\xd6\x0b\xc8\x62\x25\xa2\x87\x4e\xac\xd5\xc4\x5b\x05\x2f\x8c\xa5\x81\x2a\x57\x38\xa0\x02\x00\x07\xe4\x01\xb8\xab\x42\x56\x9d\x05\x99\xac\x30\x66\x92\x5e\x82\x40\x03\x8f\x60\x5e\x79\x27\x2f\x54\xf1\x7a\x82\xa0\x05\x3a\x68\x06\x0c\xb7\xd5\x07\x4d\xd0\x23\x8b\x24\xd8\xf4\x3c\x11\x45\x93\x48\x2c\x30\x92\x0b\xee\x95\x10\xb2\x41\x17\x8c\xc8\x6f\xe7\x61\xce\x2c\x30\x8d\x28\x10\xe5\x91\x69\x22\x21\x31\x1d\xc2\x94\x5f\x12\x12\x45\xbf\x1e\x36\x33\x9a\x07\x3b\x1b\xab\x78\xc1\xc5\x13\xa8\x4d\x72\xd9\xdc\x58\xac\x76\xe9\x75\x61\x51\x32\x8b\x06\x0c\x83\xce\x43\x5f\xeb\x79\x59\x87\xcc\x0e\x23\x11\x1d\x22\x2f\xe8\xbc\x98\xd4\x58\x83\x48\x0f\x70\x23\x39\x78\x9d\x97\xe8\x31\x40\x31\x40\x00\xe0\x0a\x36\xb3\x09\x5a\x20\x13\xab\x8e\x10\xcc\xeb\x1a\x6d\x86\xa0\xdd\x86\xad\x04\x51\xfb\xa5\x00\x8d\x44\x2f\x1a\xcd\xc8\x2e\x54\x3b\x08\x4f\x00\x7c\x89\x60\x31\xc4\xc0\x65\x37\x4a\x3a\xbd\x5e\x47\x1c\xb2\x1e\x09\x3a\x5e\xb6\xe9\xa1\x26\x23\xb1\x61\x93\x41\xa7\x93\x24\x11\xc3\xa8\x0a\x3a\x64\xe4\xb1\x19\x7a\x00\x2b\x0d\x61\x83\x28\x0c\xdf\x1e\x7e\x04\xea\x01\x64\xc1\x44\x5b\xab\x83\x69\xa6\x90\x46\xa0\x02\x58\x56\x58\x14\x00\x8a\xab\x44\x58\xb9\x46\xac\x27\xbc\x0d\x3a\x43\x0c\x71\x73\x9d\xbd\xca\xea\xe6\xa5\x6a\x1d\xd3\x8e\x70\x9d\x71\x89\xb7\x32\x9a\xc9\x45\x35\x21\x4b\x28\xbe\xbe\xa8\x91\x4b\xe5\x57\x6b\x01\xcc\x99\xc4\x04\x67\xe3\xd8\xb7\x28\x9c\x92\xe0\xf2\x68\x9f\xa3\xd0\x50\x2b\xfc\xb9\xc2\x52\xaa\xa3\xba\x5e\x51\xf0\xb1\xe8\xc3\xf8\x2d\x4f\xcb\xbb\xf7\x68\xca\x40\xed\xbb\x26\xd8\x6c\xea\x6f\xbe\x25\x3c\x78\x93\xde\x6a\x2f\xde\x85\xfc\x1e\x92\x47\x36\x52\x2d\x56\x7c\x6c\xcd\xc3\x68\x7f\x74\xea\x1d\xcf\x69\x4c\xa5\x60\xad\xb1\xde\x78\x6c\x68\x03\x59\x39\xd3\xc9\x55\x7e\x93\x53\xd3\xe3\xa8\x86\xd3\xb5\x03\x28\x97\x60\x2a\x88\x4a\xbf\x0b\x7c\xcb\x75\xac\x9f\xe7\x28\xee\xaf\xe6\x78\x6e\x18\x5c\x54\x9a\x10\x7f\x22\x4b\x90\xcc\x4c\x3f\xfc\x0d\x67\x4b\x6c\x2f\x6a\xfe\xe2\x0f\xe7\xf2\x50\xda\x5b\x00\xda\xfb\x26\x81\x63\x72\xaa\x6e\xa9\x6c\xe6\x8e\x2a\x1c\xb3\x6f\x45\xc5\x85\x9b\xec\x75\xaa\xcc\xac\xdb\x9d\xe1\x64\x55\xa6\x1f\x81\x12\xb8\x46\xfe\x57\x0d\x35\xaa\x5c\xf0\x31\xc3\x76\x9c\xec\x43\x7f\x40\xef\xd7\x34\x50\xa5\x62\xbe\x7c\xcf\x4d\x98\xdc\x65\x0b\xfb\x5e\x49\xc5\x18\x04\x5d\x25\x9b\x53\x21\x57\x90\x7d\x87\x60\xec\xd5\x2a\xa6\x5f\x10\xe0\xf8\xe2\xb7\x55\xe8\x15\x3c\xfd\x10\xfa\xc0\x19\x28\xfb\x63\x6e\x75\x2f\x1a\xd0\x58\x78\x68\xa0\x77\xb5\xc0\xe5\x0a\x9c\x1a\xd0\xd8\x29\x83\xb4\x6b\x83\x30\x04\x54\xf1\x24\xd7\xbb\x5a\x33\x0a\x5e\xfa\x5e\x76\x91\xa7\xcf\xe9\x31\x65\x13\xb8\x46\xbe\x0c\xa4\x67\x27\x50\x89\xf1\x94\xa6\x4a\x41\x52\xe9\x23\x46\x9a\xcd\x2c\x2b\x04\x45\xb5\xf1\xa0\x19\x59\xac\x40\xd4\x27\xd0\xe5\xf7\x43\xa7\x4b\x1f\x0c\xba\x5f\x7d\x42\x7d\xe2\x7e\x3a\x40\xc5\x8f\x01\xdd\x8f\x2e\x87\x00\xd9\x67\x32\xc5\xe8\x1d\x1a\x4b\x83\x2e\x87\x4c\xec\x4b\x5a\x79\x9f\xc2\x2c\x80\x91\xdf\x8d\x9f\xaf\x36\x3a\x26\x17\x35\x00\x46\x73\xd1\x14\xac\x6e\x96\x82\xd6\x2d\xc8\x9a\x5c\x25\xc7\xec\x9c\xdb\xb9\x49\xdc\x64\x6e\x0a\xb7\x98\x5b\xc9\xb8\xf9\x94\x40\xb1\x69\x9c\x84\x0c\x35\xac\x5d\x96\x69\x17\xa8\xf4\x8b\x76\xf3\x24\x94\xb8\x74\xa5\xaf\x57\x33\xd3\x11\x4c\x5c\x89\x09\x10\x43\x5e\x5c\x4c\x81\x17\x3e\x7d\xd5\x1d\x8b\x36\xdf\x2c\xf6\xed\xe8\x98\xda\x2b\xf0\xb9\x03\x37\x0e\x1f\xba\xf1\x80\xe4\x0a\xa4\x67\xac\xed\x32\xf4\x2e\xb8\xe3\xae\x3b\x16\xf4\x1a\xba\xd6\xce\x48\x07\x5c\xd2\xb0\x66\x97\x8f\x2c\x2d\x4a\xc7\x92\xe0\xe6\x45\x77\x5c\xf5\xf4\x42\xa1\x77\x6a\xc7\x8e\x3e\xf1\x66\x4d\xf8\x11\x03\x14\x2e\x9c\x87\x2e\x6b\x6c\xf2\x44\x6a\xee\x2e\x58\x76\xdc\x7d\xf7\x8e\xd4\xda\x6d\x57\x5c\x3a\x35\xd6\x94\x6a\x82\xbf\xd8\xd4\x4b\xaf\xd8\xb6\x56\x88\x33\xd9\x42\xb5\xae\xf8\xa9\xec\xc2\x53\xf3\x16\xde\x24\x6c\xbb\xbb\x26\xe2\x69\x6a\x44\xeb\x59\x64\x49\x4f\xed\x7e\x71\xb3\xf0\x21\x17\xe4\xa6\x72\x57\x17\xad\xa5\x00\x29\x5c\xcb\x33\xb2\x0d\x48\xb1\x11\xc3\x2e\x69\x54\x32\xfc\x52\x0a\xcb\x94\x44\x83\x88\x27\xcd\x69\x9a\xf8\xda\x3e\x13\x2d\xda\x00\x28\x2a\x8f\x51\x1e\x8b\x87\xb9\x84\x17\xfc\x6f\xf8\x63\x8d\xb5\x24\x60\x94\xa5\xb6\x98\xb5\xca\x67\xaa\x23\x41\xff\x89\xea\x86\x98\xff\xa0\xbf\x30\xc5\x7f\xc2\x1f\x8b\xd6\x1c\xf4\xfb\xdf\xa8\x6e\x18\x9b\x8a\xec\xba\xe8\xe0\xe2\x1d\x37\x2e\x3e\xb1\x78\xf9\xf2\xa5\x3b\x77\x2c\x79\x63\xc9\x18\x3f\xca\xc6\xa0\xf4\x00\xa9\x33\xf9\xaa\xac\xb1\x36\x49\x36\x82\xbb\x31\xe6\xff\x71\xb5\xef\x80\x1f\xff\x09\x1c\xfe\xea\x03\xfe\x28\x24\xaa\xae\x1b\x9d\xa8\xf0\xf6\x87\x8b\x0f\x2c\xbe\xe8\xc7\x8b\x77\xdc\xb4\x74\xf9\x72\x28\x79\xb4\xb7\x68\xe3\x32\xc7\x6c\x7b\x73\x1a\x5c\x70\xd4\x40\x0b\x35\xa9\x48\x3f\x88\xa5\x5d\xc3\x4a\xb5\x48\xca\xbd\xfd\xd4\xe9\x3c\x6c\x97\xf7\x6e\xc5\x68\xc2\xc9\x27\x11\xea\x98\x31\xb0\xfe\x50\xc3\x6d\xcf\xa3\xdc\x53\x6f\xc3\x1e\xba\xe7\x37\x69\xbf\xf5\x24\x9a\xf0\xc2\xbd\xdd\x87\xd6\xf7\xf5\xd4\xfe\x04\xe8\x8d\xeb\x61\xcd\x99\x99\x7e\x7d\x90\x5a\x7d\x67\x50\x97\xd1\x24\xfb\x8b\x92\x36\x4d\xf4\x18\x08\xa2\x68\xca\x1e\xb2\xbb\x84\xbf\xb7\x4d\x5f\x7f\x3a\xb7\x7e\x7a\x1b\xfa\x7b\xb6\x64\x5a\x4b\xf1\x65\xd5\xf7\xd4\x0f\xf1\xbf\xaa\x1f\x3a\x73\xcb\x2f\xde\xb5\xeb\x62\x52\x85\xee\x2b\xca\xa4\x6d\x99\xa6\x2e\x46\x5f\xac\x8b\xa0\xfb\xd4\x2d\x11\x6d\xdb\x41\x45\xd9\x4c\x89\x9b\xc7\xad\xe2\xd6\x73\x3b\xb8\x3b\xb8\xfd\x5c\xd9\xe6\xbf\x80\x18\x7f\x91\xed\x71\x0c\x39\xb7\x14\x97\x3a\xc3\xd9\x13\x4c\x30\x97\xc9\x68\xd6\xb3\x6f\xc8\xb0\xeb\x68\x86\x6d\x53\x21\xe1\xe2\xa4\x53\xe6\x62\x9a\x99\xe1\x66\xe4\x44\x22\x4e\xba\x99\xc9\x20\x28\x8b\xfa\xa8\xb5\x15\x28\x84\x59\x71\x47\x12\xe4\x8a\x22\x97\xc4\x8c\xf9\x83\x3b\x43\x6b\x25\x1a\xe3\x0c\x6d\x44\xa7\xfd\x44\xa8\xcd\x99\x6d\x76\x4b\x61\xde\x35\x3a\x1e\x70\xe2\x35\x8b\xf7\x3c\x70\xd7\xd2\x15\x46\x69\xcd\xa2\x3d\x07\x16\x4f\xd3\x9b\x77\xee\x34\xeb\xa7\x2d\x3e\xb0\x67\xd1\x1a\x49\x68\x68\xba\x68\xef\x03\x7b\x16\xaf\x91\x20\xa5\xee\x1a\xfc\x65\x8b\xdd\x66\xce\xd5\x0a\xc4\x7f\x7a\x55\x73\x7c\xe1\xaa\x2b\xe6\x44\xb5\x57\xf3\xc2\x78\x73\x74\xce\x15\xab\xb4\x17\xb2\x0c\x04\x2d\xf3\x7d\xc4\x22\x00\x9e\xf4\x8b\x01\x3c\x04\x3b\xe6\xa0\x1e\x70\x3e\x0b\xef\x23\x03\xb9\xc2\x3f\xbe\x84\x8d\x58\x3b\x24\x7d\xea\x75\xce\x70\xc8\x96\x05\x94\x6f\x77\x2f\x8f\x26\xb5\xce\xbd\x27\xb5\x64\xde\x92\x9b\xfa\xef\x4d\x2d\xa9\x33\xeb\x67\xcf\xd6\x9b\xeb\x96\xa4\xee\xed\xef\xd8\x18\x9d\xbf\x24\x79\xef\xdc\xd6\x49\x88\xef\x45\xbb\x75\x52\xd6\x16\x0a\x3b\xf7\x35\xee\x49\x74\x84\xe9\xa3\xd0\x91\xd8\xd3\x18\x66\x0f\x3c\xd8\x6e\x0c\x3b\x75\x2d\x3e\x62\x03\xb4\x08\xfd\x7b\x00\x67\xb3\xea\xc2\x2d\x03\x3a\xcc\xf3\x36\xde\xa7\xe6\xb3\xe8\xf0\x3e\xc2\x6b\xf7\x30\xda\xb9\x51\xc7\xd5\x73\x11\x2e\x41\xbf\x2c\x31\xea\x1e\xa6\x78\x42\x96\xb4\x55\x5c\xf6\x74\x42\x42\x41\x3d\x0a\xca\xf4\x10\x29\x7e\xa2\x33\x99\x2e\x7b\xc4\xc1\xd2\x8d\x50\x61\x88\x7e\x11\x02\xd1\x4f\x42\x50\xbb\x02\xd3\x3a\x73\xea\xcf\x51\x53\x81\x3d\xbf\x8b\x3a\x55\x66\x99\x00\x73\x31\xf2\x4b\xcd\xc9\x97\x4d\x0a\xa0\x40\xf1\xdb\x13\x90\x19\xca\x50\xbf\x1e\xfb\xb9\xfa\x73\xfc\x79\xf5\xe7\xea\x67\x51\x27\xd5\x29\xa2\x5f\xad\x40\x5c\x6c\x60\xf8\x1f\x7c\x4e\xf3\x31\x9e\x36\x7f\x66\x8f\x70\xb3\x70\x33\xb3\x02\xed\x2c\x59\xd5\xd0\x2c\x77\x14\x05\xf4\x8b\x5a\x1b\x88\x31\x9b\x92\x15\x7e\xd7\x98\xf4\xc2\xcd\x4f\x6e\xbb\xf3\x8a\xe1\xbf\x6f\x79\xeb\xa9\x27\xaf\xc7\x97\x18\xba\x6c\x66\x43\xe1\xe9\xf9\x57\xae\x3f\xd0\x4f\x74\x3d\x8b\xb2\x4b\x7a\x0a\xdf\xf4\xd5\xd7\x28\x55\xe8\x51\x43\xb7\xcd\x64\x50\xaf\xec\xb9\x6e\xd1\xf2\x2e\x3c\xfd\x8a\x87\xb7\x3d\x79\x05\xd1\x5d\xff\xf8\x53\xff\xb6\xa5\xf0\xb4\xc1\x64\xeb\x32\xe0\x4b\xe7\x1e\x5a\x7f\x75\xff\xf0\xdf\x7b\x96\x64\x17\xf5\xe0\xe9\x5e\xa5\x26\x50\xad\x5e\x09\x71\xdd\x06\xf4\x68\xd7\xf2\x45\xd7\x41\x61\x6b\x46\xc9\xf6\x51\x1d\xed\xe9\xda\x37\x3e\x98\x3c\x1f\xfb\x7e\xcc\x88\x5e\xbf\x3d\x51\x62\x79\x8d\xd5\x41\x1d\xab\x73\xe7\xa1\x58\x1a\xfd\x20\x10\x47\x72\x39\xa7\x41\xfd\xa3\xa1\xd5\xaa\xdd\xc8\xe5\x60\xb8\x09\x0c\xb7\x9a\xab\xd0\x0c\xce\x95\xbf\x4d\xca\x86\xdf\xeb\x8f\xb1\x8f\x13\xe5\x2c\x93\x0c\xa8\xca\xe0\x2c\x29\xf6\x9f\xe6\x34\x4b\x11\x98\xab\xb8\xdd\x91\x87\x59\xac\xc0\xbe\x5a\xaa\xfe\xc9\x3f\x30\x4a\xf7\x64\x5c\x3b\x7c\x95\xd7\xeb\xfc\xc0\x68\xb5\x15\xed\x7e\x8e\xdd\x6b\x69\xf6\x8e\x3f\xb5\x65\xef\xd1\x76\xfe\xce\xe5\xae\xb0\xde\xfd\x87\xf1\x9c\xec\x8c\xcf\x4b\xd4\x0e\x83\x76\xbf\x16\xe5\x32\x14\xa3\x29\x69\xb0\x39\x4a\xb7\x86\x63\x6a\xe7\xce\x11\x7e\xb6\x55\x69\x76\x6f\xa8\xfd\x09\x1f\x56\xde\xb4\x9d\xca\x8d\x13\x58\xe9\x7e\x83\x65\x43\xf7\x6b\x06\x86\x07\xcb\x86\x94\xc9\xef\xc6\x86\xa0\x11\x4b\xd3\xda\xb0\x5a\x99\x6e\xe9\xdf\xb9\x5a\x58\xf1\xfd\xb0\x6b\x6f\xe4\x6e\x86\xed\x80\xad\x82\x8c\xb6\x3a\xa4\x68\x37\xce\xa4\xea\xc5\x10\xfb\x90\x15\x9c\x47\xb2\x2b\xc8\x98\xae\xda\x7d\x49\xb4\x9b\x5d\x0e\x53\x66\x6e\x22\x75\xb6\x21\xf2\x60\x2a\x91\xa4\xd8\xa6\x28\x45\x33\x09\xfb\x05\x07\xe1\x96\x4d\x0b\xd7\xf7\x4e\x9e\x34\xb9\xa6\xe9\x6a\x9f\x6e\x52\x58\xb6\x4d\xb1\xad\x47\x73\x2f\x4d\x74\x62\xf5\x90\xd8\xd2\xdb\xdb\x52\x53\xd5\x1c\xba\xc8\x7b\x69\xfb\xec\x2b\xa6\x2d\x9a\x8e\x76\x09\x7f\xd6\xc6\xc1\x61\xd1\x06\x4a\xfd\xd2\x06\x84\x75\x8d\x33\xef\x5a\x2f\xbc\x57\x19\x53\x39\x5a\x4b\x16\xac\xea\x5d\x3e\xb1\xc6\x9f\xd5\xb5\x19\xa6\x36\x38\x10\x4e\x1d\x5e\x7e\xbd\x69\x0e\xce\x3e\x15\x76\x24\x96\x24\x9b\x26\x78\xaa\xaa\xdb\x3b\x12\x93\x17\xcf\x8c\x2f\x6e\xce\x54\x75\xaa\xdf\xd2\xc6\xcc\xe2\x90\xc9\x0d\x97\x5f\xde\x70\xa4\xc1\x64\x8f\xf4\xef\x52\x37\xaa\xb7\x94\x23\xc6\x8c\xeb\xc8\x5d\x8a\x95\x4b\x71\x6b\xd9\x5e\x3a\x4a\xb8\x31\xa2\x29\xc7\xa4\x35\xa3\xb0\xda\x07\x24\xa8\x32\x0d\x3b\xd8\xca\x97\x03\x24\x58\xb4\x96\x5b\xba\x8d\xd3\x14\x5a\x28\xde\x9c\xca\x68\xd2\x4a\x9e\xa2\xad\x37\x2a\xfd\x25\x32\x45\xe5\x8f\x99\x14\x23\xfa\x8e\xdf\xd3\x7a\xc7\x67\x10\x1f\xdf\xd6\x7b\xad\xc1\x68\x11\x4c\x4b\x2c\xf1\xd4\xf2\x9d\xd7\x4d\x9b\xda\xdb\xfb\xf3\xe9\xeb\xda\x23\xef\xa1\xc7\xa4\x06\x4f\x6b\x64\xd6\x82\xd9\x0b\x6e\xba\x6e\xe1\xfe\xc9\x56\x1d\xa5\x1b\xaf\xb4\xd6\x5a\x85\xd0\xc4\xa6\xee\x8e\xd9\xd9\xbe\xb9\x13\x5b\x16\xd6\xe3\xdc\xc8\xb7\xf7\xb2\xa1\x89\x6b\x56\xbc\x98\xdb\x25\x9b\xc2\xca\x82\x9b\x3a\x1d\xd5\x40\x53\x3e\xd4\xb6\xb2\xa3\x7d\xf9\xec\xa9\x53\xbb\x9d\xcd\x7e\xef\x19\x2e\x9a\xba\x76\x6d\x5b\x6b\xa8\xb9\xd5\xe1\xf2\xc4\x6c\x26\x9d\xc5\xbc\xb1\xb5\x56\x89\x4c\xc0\xf5\x73\x14\xdd\xe4\x48\xd8\xe5\xae\xf6\x75\x76\x4d\x5b\x32\xbb\xa6\x82\x2f\x7a\x39\xd5\xb6\x97\x95\x16\xcd\x10\x2e\xeb\x53\x3c\x23\x79\x5c\xa2\x36\x20\x6e\x97\x47\xae\xe8\xad\xd6\xe3\x66\x6d\xc8\xac\x08\x40\xcb\xe3\xce\x78\xca\x83\x45\xd3\xbb\x65\xf7\xc8\xc8\x69\x77\x58\xb0\xe1\x44\x95\xb1\x76\x0d\x5b\x23\x3a\x62\xae\xee\x4c\xee\xa9\x5f\xba\x68\x6b\x6d\x5b\x2d\xc2\x9d\xd9\x4e\xd9\x8c\x90\x45\x9c\x18\xea\x5a\x7e\xf1\xba\x65\x6d\x4d\xad\xf6\xb0\xdd\x25\x59\x81\xe6\x96\xeb\x9b\xae\xb0\xe0\x25\xaf\xf7\xef\x00\x5a\x7f\x62\x74\xb6\x68\x25\x3a\x8b\xe8\xb2\xfa\x94\x39\x7d\x1b\x36\x1d\x78\x6e\xdb\xf6\xce\x2e\xb7\xcd\x5e\x25\x2c\x75\x58\x46\x3e\xa3\x2e\x04\x31\x5e\x8e\x78\x89\x00\x8d\x6f\xc9\xea\xf5\x55\x96\x1b\xcc\x51\xf1\x1d\xf5\x4f\x37\xcf\xeb\x08\xb6\xf8\x1d\xc1\xb0\xbf\xad\x7d\xf6\xe3\xf3\xd7\x1c\x5c\xda\x31\xd5\x15\x42\x98\x2c\x35\x10\x33\x56\xcc\x92\xd7\x84\x8c\xa2\xd5\x27\xc5\x8c\xb2\x7a\xe7\x77\x36\xf5\x37\x4f\x69\x9f\x1c\x08\x36\xb7\xf4\xf5\x6f\x5f\xf0\x04\x9a\xfb\x72\x55\xf8\xd4\xed\xa5\xb9\x71\x70\x9c\xa1\x2c\xc3\x31\xf6\x9b\x02\xf7\x71\x4f\x69\x16\x23\x2a\xfb\x6e\x1f\xe3\x1f\x3b\x36\xff\xd3\xfe\xb1\xf5\x8d\xfd\x46\x28\xfd\x4e\x79\xc5\x27\xea\x2b\xdc\xa3\x63\x54\xee\xdc\x71\x9f\x3c\x65\xa5\x9b\x92\xbb\x4c\x16\x41\xa0\x22\x71\x65\x9b\x86\xe8\xde\xb2\x53\x1d\x71\x12\xcb\x78\xa1\x17\x4c\x50\x51\x18\x9a\x57\xf9\x85\x51\xba\x0f\x57\x9f\x79\xac\x68\x8f\x42\x66\xfa\x92\x4d\xd4\xc2\x07\x10\xbe\x28\xcc\xe4\xbd\x5b\xca\x76\x4c\x23\x9e\xff\xcb\xdb\x9b\x00\xb6\x51\x9c\x7d\xe3\x3b\xb3\x97\xce\x95\xb4\xab\xcb\x92\x2d\xeb\xb0\x24\xc7\x67\x6c\x59\x92\x6f\x2b\xb1\x73\x38\x71\x12\xe7\x4e\xc8\x65\x72\x3a\x0e\x90\x9b\x40\x42\x82\x08\xa1\x90\x70\x85\x00\xe1\x26\xe6\x2a\xd0\x90\x42\xb9\x79\x09\xad\xda\x02\xa5\xdc\xe1\x85\x52\x5a\x68\x4d\x4b\x79\x0b\x2d\x47\xdb\x97\x02\xb1\xb5\xf9\xcf\xcc\xae\x0e\x1f\x21\xbc\xef\xff\xfb\x3e\x88\xb5\xb3\xbb\xb3\xbb\x33\xb3\xb3\x33\xcf\x33\xcf\xf3\xfc\x7e\x78\xa4\x68\x03\xe0\x34\x5b\xe6\x87\x20\xb8\x41\xfe\x3d\x2c\x13\x4f\x9e\x14\x63\xe2\x8b\xa2\xc8\x72\x78\x7b\xf2\x95\x95\x2b\x3d\x1e\xf4\x07\x2e\x7a\xfe\xf9\xe6\x66\xf4\x47\xff\x41\x3d\x92\xbe\x53\x4d\xd0\xcf\x92\x6b\xdf\x89\xe1\x6b\xd1\xa5\x31\x7c\xad\xf8\xe2\x75\xe4\xa4\x67\xa5\x3c\x44\xae\x6b\x7e\x3e\xbd\x5c\x3d\x02\x3d\x6a\x82\xac\x3d\x24\xb2\xf2\xbf\x99\x72\x52\x33\xf2\x2c\xec\x18\x0b\x1a\xab\x78\xd9\xb0\x1c\x8b\x55\x60\x42\x01\xc5\x21\x82\xfc\x22\x01\x4c\x51\xfc\x90\x20\xd3\x4a\x63\x40\x28\x02\x8f\x11\xc9\x05\x7b\xcb\xaf\x82\xe4\x9d\x46\xed\x2f\xb5\xac\xe2\xda\x0f\xba\x34\x92\xe0\x33\x84\x69\xac\x94\x62\x4d\x36\x41\x87\x0d\x3e\x41\xd2\x20\xc5\x1d\x30\x5a\xc9\xf8\xa2\xd4\xe6\xee\x0f\xb9\x18\xa4\xc9\x28\xb1\x00\x10\x09\x8b\xe8\x7a\x63\xfa\xc7\x64\x97\x49\x0d\x51\x26\x87\xa0\xa5\x01\xc0\xbe\x12\xf8\x0f\x00\x5a\x2b\x38\x4c\x18\xd3\x54\x13\xb3\x57\xbb\xfd\xe8\x26\xae\x94\x02\x20\x90\x93\x61\xa6\x51\x19\x1c\x06\x3c\x10\x61\xd5\x1e\x87\x18\x11\x90\x22\x1a\xc7\xff\x2a\x46\x08\x95\x05\x53\x11\x29\x31\x87\x5e\x54\x8d\x7d\x75\xd0\x9c\x03\xe3\x35\x60\xeb\x0e\x87\x2d\x71\x27\x36\x6e\x68\x92\xb4\x95\xd6\xbe\x96\x0b\x7f\xda\xbb\xe3\x4f\xd7\xac\x7f\xf2\xe2\x25\xe5\xdd\x33\x3c\x1a\x68\x80\x9c\x25\x72\xe2\xc1\x9b\x1e\xdc\xbf\xa1\x65\x9a\xa0\x09\x3a\x62\xb5\xad\x0b\x0a\x56\x59\x98\xd7\xe5\x0c\x7a\xe8\x6c\xb2\x4e\xeb\x5d\x36\xc5\xff\x93\x70\xc3\xfe\x2f\x0f\x6f\x79\x69\x4f\x63\xcf\xee\x1f\xb4\xf7\xde\xe9\x35\x78\xf9\xf1\x9c\xc3\xda\x72\xd6\x4d\xef\xdd\x7b\xe9\x8f\x3e\x5f\xd8\x12\xd8\xbe\xb8\xb8\x76\xe2\x96\xf9\x9d\x35\xf2\xf2\xc9\x1b\x96\x80\x8b\x3e\x39\xa1\x58\x81\x72\x75\xeb\xca\x93\xfb\x33\xb5\x13\x15\x72\x30\xb5\x72\x64\xf0\xfd\xce\xca\x65\xf0\xa6\x94\xf8\xe1\x74\xf9\x7c\x87\xb6\xc2\xb6\xbe\xf9\x89\xbf\x4c\xde\xf5\x64\x5f\xef\x13\xbb\xcf\x2a\x9f\x35\xc3\x68\x63\x74\x2c\x67\xa9\x7d\xe3\xfe\x1b\xef\xbf\xbc\xaf\x19\x57\xce\x1e\xad\x69\x99\xef\x5c\xe9\xb4\x3c\x95\x1f\x63\xbc\x73\x91\xff\xe1\x70\x3d\x08\xff\x69\xde\x1d\x17\x76\x36\xf4\xec\xba\x6c\xe2\xda\xdb\xbd\xac\x4e\xa8\xb0\x38\xa4\xd6\x45\x87\xdf\xb9\xfb\x92\x07\xfe\xbe\xb0\xd9\xbf\x7d\x61\x71\xcd\x84\xcd\x73\xa7\xd6\xc8\x2b\x57\xdf\x9a\x0d\x44\xce\xd9\xb6\xdc\x44\x5e\xc3\xd8\x89\x3e\x5b\x44\x50\xe1\x04\x6a\x1d\x71\x5c\x6a\x33\x16\x74\x82\x91\x68\x20\x8a\x64\x1c\x5b\xc4\x16\x19\x29\xa1\xd2\x37\x72\xf2\xe1\xf7\x68\xf7\xf8\xf9\xb1\x55\x57\x5d\xb5\x6a\x69\x4b\xef\x39\x37\xf6\x0f\x0c\xf4\xdf\xf7\x0a\x58\x7c\xee\xb9\xe7\xa1\xff\x80\x98\x2f\xc3\xc2\x1d\xae\xd0\x3e\x67\x5d\x2c\x70\xcd\x4b\xd7\x34\xad\x59\x8d\x57\x5f\xde\xda\x81\xb3\x9d\x07\x2f\x1b\x26\xdd\xe2\xf9\xef\x1e\x2d\xc5\x2e\x53\xb1\x80\xad\x30\x8f\x14\xdb\xeb\xe0\x89\x2b\xb7\x95\xf4\x30\x3a\xee\x8b\xfa\xec\x41\x1b\x16\xc3\x02\xd1\x48\x34\x62\x63\xef\xf8\xb1\xfc\xd3\x37\x6f\x94\xbf\x7c\x7e\xdb\xb6\xe7\x81\xf9\x46\xe0\x79\xed\x57\xdb\x1f\xde\x75\x62\xe7\xce\x13\xbb\xe6\x5e\x79\x56\x7b\x31\x87\xf4\xaa\xc7\x0d\xf4\xaa\x13\x6f\x9d\x38\xf1\x16\xdc\xf8\xa6\xfc\xec\x53\x38\x23\x28\x03\xe6\xe7\xb7\xa5\x7e\xb6\xf9\xa2\x77\x86\xde\xb9\xa8\x6a\xd2\xa2\x99\x81\xa1\xb6\x36\x9c\xe7\xc4\x89\xec\x1a\x22\xc6\x68\x30\x50\x85\x54\x05\xd1\x04\x09\x75\x29\xef\x88\xe1\x20\xa3\x12\x24\xea\xf9\xab\x60\x5d\x2b\xac\x45\x3a\x85\x45\xf9\x82\x71\xd8\x8e\xcd\x57\x37\x6a\x44\xc7\xd1\xf3\xc9\x2d\x37\xcc\x28\x33\xe2\x75\xc5\xb2\x19\x7b\x0e\xef\x99\x51\xa6\x6c\x60\x59\xdf\xe1\xc1\x24\xfe\xee\x98\xe4\xe1\x4f\x43\xae\x6f\xc9\x8a\x03\x8f\x01\x85\x93\x3d\x20\xb5\xbf\x3b\x68\x95\x07\x3e\xbe\xea\xe0\x45\x33\x67\x5e\x74\x50\xd9\xc8\x65\x90\xc2\x17\xc8\xe4\x97\x4e\xe4\xf8\x82\x42\x2a\xd6\x00\x83\xf4\x1b\xca\x98\x89\x92\x21\x78\x06\xa8\x18\x0c\x25\xc9\x09\x8c\xd6\x99\x90\x08\x59\x12\x7d\x16\x49\x4b\x20\x25\xd5\x65\x70\x1e\x90\xda\x48\xd1\x09\xe5\x5a\x52\x05\x15\x01\x01\x03\x90\x0c\x11\xcc\x81\x14\xc6\x1c\x48\x01\xe2\x2b\x21\x29\x0e\xf9\xca\xb5\x09\x2a\x09\x31\x42\x80\x31\xcb\xac\xab\x42\x1b\x60\xcd\x3e\xf7\x20\x26\x91\x7f\x1f\x29\xc3\xa7\x9c\x84\x09\x26\xaf\xcc\x0a\x90\xa0\x03\xc0\x04\x29\xb3\xf2\x2c\x1c\x7e\x93\x29\x7c\x48\x7d\xee\xf0\xd8\x9a\x22\x8a\x8a\xf8\x88\x6f\x64\x10\xf3\x41\x8e\x9e\x5b\xfb\x61\x4f\x3a\x29\xb1\xe7\xa6\x93\xb0\x47\xa1\xce\xce\xce\x77\x4c\x72\xb0\xdf\x28\x79\x99\x9e\xc1\xa4\xc4\xbc\x96\xcf\x43\x82\xfb\x67\x8a\x51\xb0\xe7\xdc\x23\x5b\x55\x1c\xd1\x4e\xc3\xdb\x38\x34\xa2\xd9\x7e\x97\xd7\x12\x63\xb4\x21\x79\x0e\x7a\xdc\x19\xdf\xdd\xb0\x1b\xa9\xd7\xd2\x94\x5a\xc6\x33\xbc\x3b\x7a\xe4\x73\x73\xf1\xc4\x2e\x8c\x46\x92\xfb\xee\xed\x0e\xc6\xe1\x81\x4d\x90\xd8\xbe\x83\x31\x0c\x1d\x46\xf1\x02\x53\x0e\x49\x60\x41\x09\xb1\xe2\xaa\x34\x51\xca\x42\x79\x45\x03\xe8\xbb\xbc\x61\xca\xf9\x11\x00\x22\xe7\x4f\x69\xf8\x11\x98\xda\x50\xbe\xb2\x53\xbe\x62\xa9\x6e\x42\x79\x4b\xcc\x81\xa6\xe7\x58\x4b\xf9\x04\xdd\x12\xf9\x47\xfe\xd6\xf3\xe6\xce\x60\x53\x13\x56\xd0\x8d\x43\x1f\x13\x2f\x7c\x57\x4d\xe8\xdf\xab\xca\xaa\x6b\x6a\xaa\xcb\x76\xfd\x21\x0c\x16\xcc\x3a\x18\x91\x07\x13\x7c\x75\x51\x89\x28\x96\x14\x55\xf3\x89\xcf\x9c\x65\xd7\xb7\xcd\xec\x5d\x4e\xde\xf9\x23\x68\x3c\x3b\x87\xc4\xfd\x95\xab\xf8\x16\x76\xc5\x55\x17\x7b\x13\x92\x15\x7d\x85\xa2\xde\x66\xf1\x89\xe6\x6a\xe0\xb3\x05\x48\x88\x25\x58\x26\x3f\x09\x56\x80\x75\xf3\xe0\x9c\xd5\xeb\x7e\xb8\x9a\xb9\x56\x7e\x6a\xf6\x82\xb6\xf9\x36\xbd\xfc\x14\x12\xfb\x41\x27\xb4\x96\x4d\x59\xd7\x76\xf4\x4d\xfa\xda\x21\x1f\xfd\x47\x50\xdb\xb9\x72\x65\xe7\xb4\xb3\xcf\x1e\xfa\x20\xfd\x12\x14\xd7\xef\x98\x14\xf1\x44\xd2\xef\x82\x6b\xc1\x97\xe3\xc7\x1f\xf4\x8e\xaf\x2f\xfe\x73\xe6\xbd\x29\xe3\x6b\x1d\x99\x13\x71\x38\x76\x49\x38\x84\xc3\xff\x23\x78\xd5\x0d\xfb\xf4\x90\xb9\x83\xe3\x47\x2c\xf3\x63\x80\x3f\x06\xa9\xe6\x3b\x5f\x97\x3f\xba\xfd\x21\xf9\xe5\x73\x79\xa0\xd9\xaf\x33\x99\xf9\xce\xb7\x77\xf4\x3e\x77\x60\xf6\xec\x03\xcf\xf5\xae\x7c\x7c\xf2\xfe\xbc\x95\xf9\xbd\x1b\x80\x74\xfd\xed\xa0\xf0\x75\xba\x50\x7e\x49\xfe\xe8\xf5\x9d\xd7\xed\xd3\x15\x68\x0e\x68\xa1\x6e\x45\x2f\xca\xfe\x26\xba\x6a\xca\xc4\x03\x79\x2b\xf7\x97\xac\xd9\xb8\xf3\x75\x54\xc6\xd2\x53\x36\xee\x6f\xec\x6f\xb1\x4f\x9b\x6f\x18\x68\x2d\x0e\x4e\xf5\x70\x38\xde\x97\x55\x8f\xb5\x32\x24\x1c\x9a\x75\xa8\x5d\xa8\x8a\xc3\xc8\x01\xac\xba\x76\x24\x30\x24\xb4\x84\x0d\x63\xec\xdb\x0c\x16\xec\xdf\x82\x1b\x08\xef\xee\x8d\xa1\xf2\x53\xd4\x1e\xa1\x54\x80\x36\xc6\xcc\x68\xe8\x42\xda\xad\x77\x89\x2e\x63\x69\xa1\xdc\x5b\xa8\xd5\xda\xf5\x1e\xda\x13\xd2\x99\x2d\x3a\x0b\x67\x85\x82\x00\x96\x8e\x95\x15\xdc\x3c\x46\xd6\x3d\x80\x2a\xc7\xab\x54\x1b\x82\xd1\xe0\x39\xc1\x20\xc0\x96\xb1\x72\x80\x9e\x25\x40\x2b\x87\x32\x99\x75\x21\x74\x81\xde\xae\xd5\x92\x95\x32\x23\xba\x95\xde\x8d\x6e\xaa\x41\x37\xb7\x41\xf4\x18\xf4\xac\xd1\x59\x51\xa9\xc6\xc8\xba\xe7\x14\x55\x8e\xea\x12\xce\x61\x78\x28\xfe\xc4\x98\xbd\x15\x5b\x36\xa6\xe7\x62\xab\xb3\xc2\x9c\x14\xab\x02\x38\x8a\x9d\xf8\x7b\x60\x2e\xe1\x92\x11\x39\x32\x1e\x71\xc0\xcc\x2b\x76\x1f\x4b\x86\xf9\x1d\x24\x09\x0b\x32\xd0\x2b\x9b\xaf\xd7\x70\xee\xda\x2a\x7e\x4d\xf3\x72\xb3\xb5\xfb\xd6\x03\x56\x73\x05\x5c\x49\xce\xa4\x5f\x21\x1b\xa8\xe6\xbb\xf2\x6a\x29\x70\xf2\x07\x01\xe9\x6a\x8c\x66\x05\xce\x01\x5d\x5f\x5e\x03\xc8\x99\xe9\x50\xa5\x47\x3e\x02\xf6\xb8\x2a\x05\xb7\x4b\xde\xcb\xce\x68\x9e\x71\xa0\xb4\x7b\x46\xf3\x16\x41\xc9\xf1\x0a\xd9\x6c\x57\xf2\xa5\xe4\xc1\x3f\x14\x15\x7d\x00\xb8\x27\xf1\x4d\xae\xf9\x52\x7e\x3c\x33\x2e\x28\x98\x5b\x76\x3c\xff\x51\x48\x50\x43\xb2\x0f\x86\xa4\xe7\x63\x0a\x1a\x7d\x49\xcc\x1c\x62\x72\x60\x5c\x18\x7e\x60\x38\x1a\x17\x01\x89\xee\x92\x7b\xe5\x3b\x4e\x5c\xbb\x77\xa1\xdb\x59\x75\xf3\xae\xf2\x86\x49\x2d\xaf\x82\x55\x27\x4e\x80\xd9\x79\x18\x5d\xac\xc9\x39\x0a\xa4\xeb\x4b\x70\x3b\xf8\x2b\xb8\x9d\x49\x5e\xf9\xf7\xfd\x9b\x5e\x99\x56\xdb\xb3\x64\x76\xdb\x39\x21\x4e\x73\xe5\xdf\x81\xf8\xf7\x5f\xe5\x80\xbb\x6c\x96\x31\x70\xbb\x7e\x0c\xc2\x47\x8f\xe6\xd6\x20\x70\xec\x46\x23\xb5\x3a\xbf\x16\xd9\x3a\xd4\x85\xf0\x5b\xf8\x0e\x14\x05\xf0\xdd\xf8\x09\x48\xfc\xa3\x17\xcb\xaf\xcb\xff\xbe\xa3\xaf\xe7\xec\x80\xbf\xb0\x22\x3a\x73\xfa\x2d\x40\x77\xc7\x1d\xe9\x3b\x31\x6e\xc2\xf1\x33\xa0\x2b\xb0\x8d\xdf\x0b\x55\xe1\x1a\x26\xd9\xfb\xe8\xda\x39\x37\xd7\xd7\xcf\xb3\x4a\xc5\x3a\xa1\xf7\xd1\x57\x1f\xfd\xeb\xfe\xbf\x9f\x01\x6a\x61\xf0\x9b\x33\xa3\x2c\xec\xba\xe0\x04\x1a\x1f\xc0\x29\x8a\xbe\x08\x8d\x61\x3e\xc5\x0e\xab\x18\x20\xe2\x12\xab\x18\x27\x54\x67\x78\x34\x4a\xd0\x41\x1c\xf0\xb2\x5d\xd4\xa7\x3f\x32\x16\x31\x3a\x8b\x85\x79\x41\xee\x63\x34\xa2\x51\x64\x7f\xcd\x38\xcd\x60\xaa\xe4\x62\x8f\x82\xab\x34\x8c\x44\xbf\x6c\x75\x0e\xee\x2a\x80\x6c\xa1\x99\x2e\x5d\x03\xf4\x26\x27\xdd\x20\x88\x05\x16\x8d\x4e\xae\x59\x09\xf3\xb9\x3f\xe6\x0f\x5f\x0f\x45\x4a\x0f\x92\x4f\x47\x92\x23\x8f\x79\x8c\x18\x6e\x03\xb9\x09\x5e\xc1\xf3\xb1\xf9\x54\x14\x41\x9e\xaa\x2f\x55\x42\x0a\x7b\x64\x8a\xac\xc8\x8e\xb9\xd7\x55\x07\x95\x7d\x12\x78\x58\xda\x03\x31\x72\x5f\x69\x7d\x7e\x38\x62\x2a\x95\xc9\x3d\xc6\x5e\x5d\x57\x2a\x73\x2d\x3e\x9a\xea\xaa\x4b\xd5\xe7\x64\x93\x14\xd2\x66\x67\x51\x8b\x55\xb9\x28\xe3\xf0\x8e\x91\x73\x2c\xb1\x5a\x65\x95\x11\xab\x4d\x5c\xc6\x14\x84\xbd\xc9\xc0\x88\x5d\x32\x99\x29\xb8\x04\x31\x0a\xcf\x1a\xd8\x24\x04\x6c\x21\x3f\x4f\x6e\x47\x27\x6f\x7e\xf3\xe6\x50\x5d\x68\xe6\xea\x99\xbe\x56\xda\x27\x19\xf5\x86\x9a\x45\x8d\x1d\x17\x94\xf3\x36\x46\x6f\x11\xf5\x8c\x8d\x2f\xdf\x71\xc5\x0e\xb2\x2b\x5a\xc8\xee\x05\x1d\x8d\x8b\x6a\x0c\x7a\xa3\x04\x2a\xa9\x53\x60\xfe\x4f\xaf\x02\xc6\x81\xfb\x7c\x20\x4d\x95\x55\x94\x61\xdf\xdf\xe7\xd3\xc7\x7b\x6f\xbe\xb9\x17\x8b\x30\xb5\x33\x67\xd6\xc2\x0e\x7d\xc8\x28\xe9\xaa\xaa\xa6\x35\xeb\x4a\x38\x8b\x85\x2b\xd1\x35\x4f\xcb\x4f\x57\x55\xe9\x24\x23\x0b\x9f\x02\x96\x2b\xba\xaf\xff\xf3\x01\x08\xdf\x5a\x09\xe1\x4a\x2c\x94\x32\x59\xbb\x8a\x06\x69\xc4\x6e\xac\x81\xb0\x3e\xc5\x96\xe2\x1b\xb5\x58\xe2\xcb\xc6\x70\xb7\x0c\x27\x45\x21\xab\xf7\x34\x92\x6c\xf1\xba\xbb\x9c\xc4\xec\x8c\x69\xb2\x9a\x09\x53\xa8\x0e\x14\x28\x97\xdf\x81\x54\xce\xd8\x52\x5f\xca\xa0\x94\xcd\x84\xe7\x82\x24\x5e\xca\x07\xfd\xc0\x9b\xc5\x8a\x4d\x9f\x8b\xf2\xcf\x4f\x93\x77\xde\xaf\x2c\xd3\x63\xd3\x8a\xd1\x84\xe6\x83\x9e\xac\x5c\x49\xb8\x60\xcc\x54\x29\xb5\x94\xd8\x26\x49\x58\xb9\xaa\x33\xa1\xe6\x57\xa3\x1a\xac\x0a\x53\x76\x24\x46\xf4\xdd\xb8\x15\x7b\xb8\x65\xa1\x31\xb0\x66\x48\x02\xb6\xc8\x9b\xcb\xfc\x61\x77\xf2\x28\x51\x1d\x20\x1c\x90\x5c\xd2\x39\x75\xb8\x5c\xb5\xab\xa6\xf7\x4f\xda\x78\xf9\x81\xcb\x37\x4e\xea\xd0\x8d\xd3\x25\x8d\x1f\x19\x93\x68\xdb\x91\x5c\x57\xd9\xd4\xcc\x54\x17\x14\x54\x1a\xdb\xaa\xac\xdd\xcb\xbb\xad\x55\x6d\xc6\xca\x82\x82\x6a\xa6\xb9\xa9\x72\xdd\xe2\xeb\x9e\xfa\xe9\x53\xd7\x2d\xa6\xc9\xca\x6b\x55\x2d\xba\x9b\xb7\xab\x6e\xea\x45\xb3\x2a\x2b\x67\x5d\x34\x75\xcd\x2c\x7d\x85\xfe\x96\xeb\xae\xbb\x05\x6d\x66\xad\xb9\x6d\x73\x4d\xd7\xd6\xda\xc2\x58\xd0\xed\x0e\xd6\x15\x39\x9c\x55\xb5\x15\x75\x75\x15\xb5\x55\x4e\x47\x51\x1d\x3e\x16\x2b\xac\xdd\xda\x55\xb3\xf9\xb6\x55\x47\x37\x4f\x98\xb0\xf9\x28\x19\xff\x15\xec\x59\x17\x89\x41\x21\xcb\xd4\x39\xdb\x90\xc2\x23\x49\xdc\x25\xcc\x79\xb8\x94\xa1\x5c\xa0\xba\x02\x67\x66\x3c\xd9\x2f\x19\x0d\x06\xf9\xe7\x5a\x2d\x48\x10\xaa\xc8\x1e\x4c\x86\x48\x50\x26\x4f\xf6\x13\x94\xdf\x1e\x05\x45\x12\xf4\xa0\x5a\xa0\x7f\x3a\x94\x0f\x33\x2e\x26\x30\x42\xa4\x04\x7d\x19\xb0\x48\xb2\xb4\x9c\x85\x84\xcc\x60\x04\x12\x6e\xa2\x28\x89\x01\x2e\xcf\x59\x80\x32\xb6\x2c\x4c\x10\xc8\x7e\x87\x5d\x99\xa5\x44\x61\x80\xdc\x78\x00\x93\x51\xf6\x60\x32\xca\x15\x3a\x98\xb1\x36\x5f\x75\x3e\xb6\x36\xdf\x0e\xe8\xa6\x29\x2b\xfa\x0e\x8f\xdb\x7b\x3f\xec\x11\x44\xd0\x43\xec\x3c\xfd\x84\x01\xb3\x1f\x55\x6b\x85\xe1\x6d\x62\x83\xde\xfb\x7e\xdc\x63\x7c\x1b\x54\xfc\xf8\x60\xeb\xe1\xbe\xae\xd6\xe2\x13\xa3\xcb\x18\x26\x8e\xcb\x0a\x3e\x45\xd6\x0f\x37\xa2\x22\x42\x9c\xb6\x8c\xf8\x31\xa8\x15\xee\xd2\xe5\x15\xf6\x3b\xca\xd8\x2f\xe0\x9a\xa0\xfc\x06\x83\x20\xca\xa4\x8d\x41\x8f\x24\x7f\x76\x9a\x42\x66\xfa\xbb\x1a\xff\xb5\x88\xea\xc9\x59\x74\xd8\xac\xaf\x06\x1d\x47\x5f\x29\x01\x29\x50\x40\x09\x70\x14\xa6\x37\x8e\x3a\x00\xfe\x7a\x33\x68\x66\x61\x32\x1c\x0d\xdb\x0f\x85\xeb\xb0\x0f\xa6\x87\xc9\x3a\x76\x28\xa6\x5e\x26\xa4\xb8\x6d\xe8\x83\x8d\xbd\x1d\xf6\xc6\xc9\x9b\xfa\x37\x4d\x69\x28\xd8\x07\x26\xef\x2b\xe8\x3b\xec\xad\xef\xae\xf7\x76\xf5\x76\x91\xed\xa4\x26\x00\x18\x9d\xa6\xa3\xb7\x31\xa8\x97\x53\xaa\x1b\xc7\xef\x88\x09\x7b\xf7\x85\x07\x0e\x5c\xd8\xb1\xe7\xf0\xd6\x25\xa6\xba\x8e\x57\xac\xab\x5b\xba\x37\x6d\xea\x6e\x59\x6d\x7d\xa5\xb5\xb8\xb7\xb7\xb8\x35\x71\xb8\x6f\x71\x51\x19\xfe\xb8\xcb\x8a\x16\x63\xbc\x8c\xdc\x5e\xc7\x0e\xbf\x6e\x42\x71\x5d\x99\x64\x5a\xb2\xf5\xf0\x1e\xfa\xb7\xaa\x43\x47\x36\xb6\x5c\x69\x8b\x19\x39\x49\x2f\x8e\xd4\x1f\x8b\x95\xf1\x96\x60\xc2\x12\x95\x62\x94\x98\x7d\xc8\x17\x81\xde\xa5\x37\xa6\xf8\xe2\x93\x35\x21\xe5\xed\xe1\x70\x61\x9b\x72\x86\x48\x12\xb5\xd9\xb0\x85\x29\x0d\x0a\x7c\xf4\xbd\xef\x87\x5c\x9c\xce\xd2\x1c\xc0\x6e\xef\xbe\xe2\xe3\x40\x73\xbc\xd8\x87\xd3\x81\x66\x8b\x8e\x73\x85\xde\xbf\x17\x1f\x6a\x98\x82\x5a\x87\x56\x9c\x0e\x12\xad\x2b\x6d\xf2\xf6\x23\x1f\x7e\x78\x64\x9f\xf5\xb7\x07\x09\xa4\x86\xa7\x04\x49\x71\xa2\x7c\x1e\x59\xbd\x3b\x24\xa2\x9d\x12\x0f\xc4\xfc\x60\x07\x7f\x6b\xdd\x47\x0e\x5e\x69\x5b\xd9\x8a\x9a\x46\xe5\xfa\x54\xec\xaa\x58\x9b\x0d\x2a\xbe\x51\x6c\x0e\x1e\x1d\xe9\x4e\x91\xac\x2b\x94\x8a\xa1\x1e\xc9\x78\x44\xc9\xfd\x04\xd5\x91\xe9\x1f\xa2\x92\x8a\x0b\x14\xa4\xf6\x2d\x4d\xa0\x83\x4c\x12\x83\xc6\xed\x5b\x4a\xa3\xf4\x20\x92\xb7\x14\xcf\xa7\x81\xa1\xd4\xd2\x7d\x2c\xb5\x0f\xb5\x69\x2e\x46\x2c\x32\x22\x42\xec\xfb\x47\x85\xd1\x89\xef\x19\x08\xf6\xbd\x02\xbf\x14\xd9\x30\xa1\xca\xf6\x7e\xf2\xa6\x49\x65\x81\x4f\xe9\xf4\xa8\xc3\x96\x8f\xe0\x5b\xe5\x92\x9b\xba\x13\x89\xee\x6f\xbf\xe4\xa9\xc3\x7d\x83\x54\xdf\x61\x3e\xf1\xe1\x91\xc4\xbe\xa5\x18\xed\x12\x2f\xc2\x1c\xa1\xc7\xf7\x6f\x92\x93\xe9\x14\x7a\x3e\xa3\x45\x7d\xca\x8b\xdb\x0b\x0e\x60\x76\xae\x1c\x16\x7a\x25\x35\x51\x91\x06\xf8\x6c\x84\xa9\xd2\xa5\x48\x97\xb1\x2b\xd8\x2b\xc3\xd3\x6c\x36\x67\x9e\xb4\x03\x93\x53\x1a\x08\xf0\x7f\xc3\x94\x7c\x18\x05\x1c\xc5\x42\x91\xe3\x68\x98\x38\xbe\x0f\xbb\xda\xb1\xa9\x74\x12\x7d\x16\x43\x5f\xe1\x8f\x80\xd6\xa3\x0f\x05\x2a\xf0\xb0\x3d\xc4\x19\xaf\x7f\x64\xfa\x5b\xc2\x99\x01\xd1\xe8\x4d\x7b\xf7\x1d\x57\xec\xbe\x4a\xfc\x8a\x84\x66\x03\x05\x03\x77\x2e\x61\x34\xb0\x8d\x34\xb2\xf3\x16\x1f\xe6\x44\x05\xea\x0c\x6f\xc9\x01\xe4\x2a\xf9\xd8\x11\x56\xc0\x91\x56\x41\xf6\x38\xf6\x73\x50\x2d\xef\xc9\xd2\x9e\xc2\x7d\xe0\x02\x9d\x41\xfe\x95\x01\xac\x22\xee\x0d\x14\x06\x1d\xce\x40\xce\x08\x22\x1c\xc8\xa4\xf2\x8f\x8a\x02\xb3\xaf\xb0\xa7\x74\x30\x89\xef\xc2\x11\x2b\x7c\x87\x7c\x45\x91\x01\x34\x18\x4e\x8a\x0c\x85\xc5\x81\x93\x14\xdd\x93\x31\x1a\x09\xfd\x39\xeb\xde\x29\x2a\x97\xc6\x11\xdf\x59\xfc\xfa\xd1\xb6\xa4\x87\xa9\x9f\x51\x6f\x50\x7f\xa4\xbe\x40\x12\x94\x09\x14\x83\x4a\xd0\x32\x9a\xb7\x3a\x3a\x62\x9f\x1d\xb1\x3f\x32\xff\x48\xde\xea\x91\xe7\xcf\xb4\xff\xff\xfa\xfa\x33\xe5\x1f\x59\x5f\x8c\x08\x6e\xc9\x78\x5b\x8e\xc2\x62\xc2\xbc\xd2\x59\x31\x2d\x87\xd7\x4d\xe5\xd2\xa7\xf2\xd2\xf4\x69\x8e\x9f\x2e\xfd\x7f\x23\x3f\x3c\xcd\xf1\xe1\x65\xc6\xf8\xa9\xb8\x6e\x04\x18\x8b\xca\x67\x7f\x1f\xc8\xd6\xf4\x5f\xa3\x2b\x9e\x77\x2c\xfd\xaf\x31\x0e\x8e\x95\xfa\x3f\x95\x51\x1e\xeb\x60\xee\xe7\xe4\xf5\x18\x74\x74\x40\x11\xe0\xf2\xdc\x81\xf1\x0a\xe4\x77\x7c\x33\x4f\x51\xbf\xa7\xbe\xfa\x7f\xff\x95\xfc\x6f\x7a\x69\xd6\x2f\x23\xaf\xbf\x16\x80\x0c\xdf\x40\x20\x3a\xdc\xdb\xa8\x05\x44\x6c\xa3\xf1\xed\x23\xbe\xac\x06\xf3\x7f\xa5\x77\x7f\xdf\xde\x77\x0a\x6b\xc2\x68\x1c\xc4\x69\xa5\x17\x92\x53\x79\xe5\x49\xaa\xf7\xcb\xf4\x4d\x90\x40\xa3\x24\xe6\xc1\x49\xfc\x1f\xeb\xa3\x67\xe8\x51\x43\xd7\x33\x49\x2f\x1e\xb0\xbd\x83\x49\xd2\xaf\xe8\x94\x52\xd0\x9e\x9e\xac\x63\x95\x92\xae\xcc\x7d\x3e\x80\x5c\x21\x0f\x84\x90\xd0\x91\xc8\xf2\x98\x63\xdb\x6b\x33\x46\x06\xca\xb7\xbe\x12\x08\xd7\x8c\x38\x27\x91\xd7\x97\x65\x8f\x08\x64\x28\x24\x6c\xd9\xb7\x59\x1b\x53\x00\x20\x86\x19\x68\x43\xc4\x3a\x1b\x53\x6c\xb3\xd9\x69\x98\x2c\xbb\xc9\xaf\x80\xe4\x9d\x82\xe6\x97\x3c\x64\x29\x72\xe0\x15\x24\xad\x13\x53\xb7\x82\x9d\x9f\x49\x62\xae\xca\x54\xc6\x5e\x4b\xbe\x1b\x97\xf4\xa2\x94\x70\xf5\x2b\x56\x1c\x75\x09\x0f\x69\xb8\x90\xff\xa5\x41\x97\x3e\x46\xf6\x69\xef\xa8\xfb\xe0\x24\xac\xc2\xe6\x9f\x8c\xe5\x16\xfb\x74\xf6\xbb\x12\xe8\x6e\xc4\x5f\x3d\x94\xc1\x96\x50\x70\xeb\xc3\x54\x0d\xfa\x16\x3b\x95\x28\xca\x33\x56\xfd\x7b\x49\x85\x44\x7b\x1a\xa3\x8a\x69\x45\x5a\x4c\x12\xe9\x87\x49\x0d\xa6\xfa\x73\xd2\xa2\x17\x1d\x04\xfd\x63\xd7\xe6\xf3\xef\x14\x22\x33\xf8\x1c\x04\x17\x1e\x5b\x2a\x38\x23\xe0\x03\x8a\x08\x5e\x4e\x47\x23\x96\x00\x1f\x08\x63\xab\x60\x34\x1c\x8d\x63\x43\x66\x34\x1e\x71\xa0\xa3\xd1\x26\xa8\xf8\xfa\x82\x88\x83\x45\xda\x3a\x9f\x04\xf2\x87\x72\xff\x40\x42\xfe\xfd\x24\xdc\xfc\x3d\xfd\x89\x44\x7f\xaa\xc7\xeb\x4d\xa6\x52\x49\xaf\xb7\x27\x85\xf7\x89\x30\x34\x09\x04\x13\x03\xa0\x27\x79\x50\x03\x13\x5e\xf4\x3f\x52\xc3\x04\xad\x17\xf4\x0f\x78\x53\x5e\x8d\x33\xe9\xd4\xa0\xed\x00\xe8\xf7\x6a\xb1\x22\x98\xf0\x16\x8e\xd7\x11\xfd\x21\xa1\xfa\x9f\x70\xa8\x17\x12\xeb\x04\x16\x73\x6d\xbe\x68\x9c\xb4\x67\x38\xee\x8b\xfb\x90\x98\x84\xf1\xb6\xa7\x47\x19\x34\x31\x24\x93\x47\x3e\x4c\x78\xc1\x80\x97\x4e\x79\x13\x38\xde\xe2\x14\x15\x9d\x2e\x27\x52\xa9\xd4\x87\x47\x40\x22\x91\x4c\xa6\xbc\x43\x03\xc3\x38\x53\x31\xf3\x49\x8e\x2e\x75\x84\xdf\xa3\x02\x0f\x42\xf0\x0f\x47\xe1\x00\x11\x3f\x3e\x99\xca\xf1\xd6\xc2\x0c\x73\x6a\xbe\xed\x36\xa5\xd8\xae\x30\x05\x46\xc6\x86\x85\x07\x04\x19\x7b\x01\xd0\xff\x31\xc2\x37\x71\x44\xb9\xbe\x0f\x97\xeb\x58\xe5\x92\x53\x4a\xd9\x52\xca\xb3\x94\x52\x25\x46\x96\x4c\x21\x73\x4d\x28\xa5\x1b\x7e\x01\x6c\x1c\x5e\x30\x88\xe4\xec\x19\xf4\xbf\x98\x08\x92\xe2\xc6\x61\x8d\x76\x24\x17\x2e\xaf\x05\xcc\x58\x07\xe1\x56\x5d\xad\xce\xa5\x93\xab\x74\x3a\xf0\x16\x4a\xd4\xea\x74\xf2\x0e\xb0\x1f\x1c\x18\xf3\xf0\x31\x92\x22\x47\xd0\x8f\x92\x65\x87\xbc\x43\x37\xf6\x61\x52\x2e\x23\x2a\xd7\x7f\x66\xca\x45\xe5\x7c\x5b\x72\x9c\xba\xcc\x58\x07\xe1\x5c\xfc\x70\xe5\xbe\xfb\xd1\x13\xc8\x4d\xc1\x5b\xa8\x5c\x63\x1d\x86\x33\x94\xb2\x92\xbd\xfd\x60\xbf\x5a\xe2\x2a\xdd\xd8\x87\x71\xb9\x66\x50\x57\x33\x11\x66\xee\xb0\xf6\x1a\xce\x0f\x21\x8e\x75\x90\x89\x9c\xa9\xd6\xc3\x0e\x7f\x36\xaa\xa8\xf8\xf9\xe0\xfc\x31\x0f\x53\x4a\xb9\x8e\xa1\x72\x6d\xcd\x6f\xaf\x11\x1c\x13\xe2\x58\x07\x51\xb9\x4e\x5b\xdd\x31\x0e\xc3\x63\xa3\x5f\x2e\xca\x81\x0b\x36\xc6\x61\x3c\x16\xa1\xfe\x05\xb7\x92\xf7\x88\x4b\xa5\x05\x23\xe9\x96\x51\x47\x52\x73\x0f\xeb\x37\xf4\x67\x63\x37\x16\x19\xdf\x50\xdf\x80\x73\xb3\xf7\xfc\xde\x9d\xe0\x74\x6f\x9b\xdc\x73\x06\x30\x32\x11\x7a\xae\x72\xcf\xff\xc1\x0b\x04\xe7\x9e\xee\x9d\xe0\x7b\x56\xa2\x7b\x6e\xcd\x95\xf3\x7b\x36\x3e\x5d\x79\x9a\xe6\x54\xed\xd0\x8a\xdc\x58\xad\xe0\xa5\xe6\xa3\xf4\x28\xb6\x7c\xab\x27\xab\x91\xd7\xb5\x82\x68\xde\x18\x82\x97\x1a\xbf\x25\x22\x02\x97\x20\xb6\xfd\xf4\x80\xd7\xab\x90\xa4\x7b\xbd\x69\x02\x91\xc4\xe1\x60\x2e\x2f\x4d\x64\x8a\x21\x9c\x95\x9e\x81\x5d\xd0\x82\xb3\x5b\x8c\x78\x0c\x11\x9a\xbb\x43\x39\x77\xb4\x3c\x1f\x10\x13\x89\x58\xc7\x63\xdb\x70\x4b\x43\x00\xe4\x61\xcf\xe1\xb2\x62\x11\x50\x95\x19\x23\x6c\x6d\x1d\x1a\x01\xad\x11\xd0\x9f\x75\x72\x9b\x38\xd8\x2f\x19\x19\xf2\xf8\xc1\x14\x5e\x08\xed\x57\x60\x9b\xfa\xe9\x4d\x66\x73\xbf\xd9\x0c\x28\x05\x3d\x54\x41\xbf\xa5\x7b\x72\x0b\xdc\xd2\xd0\x5c\xb2\x58\xdd\x83\x66\xa9\xac\x3f\x38\xa3\xc8\x3a\x0e\x34\xb3\x67\xe5\x9c\xe0\x98\xad\x96\xbf\x64\xa0\xe0\x3c\xfc\x50\x6d\x01\x23\xad\x34\x56\x0e\x0b\x6f\x2d\x59\x40\x18\x50\x56\x94\x87\x70\x09\xe8\xd7\x86\x39\xea\x31\x4a\x01\xc8\xba\x89\x43\xf1\x46\x3f\xdd\xd3\x21\x69\x82\x26\x30\x92\xc2\x00\xbc\x49\x00\x91\xa8\x53\x48\xaa\xa3\x48\x1d\xd1\x6f\x0a\x37\x41\x3f\x18\xdf\x55\x27\x53\xca\xea\x43\x5d\xd7\x0a\x05\x37\x89\x34\x81\xb2\xde\x4f\xcf\xf0\x7a\xbd\x43\x24\x03\x83\x7f\xf3\xe7\x1f\x3d\x2a\x0f\x45\xa9\x4c\xb5\xad\x40\x31\x4e\x66\x59\x9e\x6f\xc8\x92\xd2\x1e\x3a\x34\x8a\x96\x96\xe9\xcf\x23\xad\x7d\x6e\x2c\xac\x07\x75\x4e\xf7\x11\xf6\x9f\x5c\x7d\x5a\x61\x13\xc8\x10\x1d\x67\x69\xc8\xf2\xe9\x7e\xc6\xce\x40\x53\x9b\xba\xe5\x64\xf7\x26\x6c\xe2\x27\xb3\x59\xa2\xef\x70\x7d\xe9\x40\xf7\x26\x3a\x79\x9a\x13\x30\x81\x0f\x6f\xea\x86\x29\xec\x1a\x40\xa6\xbe\xc3\x7d\x48\xf8\x55\xb2\x8f\x71\x9c\x1a\xb3\xdc\x02\xcc\x53\x73\x90\xac\x47\xe6\xe9\x7c\x9a\xa2\xef\xce\x40\x53\xa3\x0a\xb6\xa9\x1b\x24\x71\xb9\x4f\x73\x82\x49\xa5\x13\x23\x4b\x0c\x48\x89\x4f\x73\x1c\x17\x59\x83\x64\xf9\x04\x59\x2f\xd4\x52\x16\x82\x8a\x86\xbf\xbf\x26\x35\xd6\x40\xc1\xd1\xa9\xcd\x46\x0c\x66\xa2\x0b\xac\xca\xf2\x6b\x2e\xde\x60\xec\x1c\x8a\xd7\x1e\x14\xa6\x47\xeb\xba\xa6\xf7\xc1\x16\xc5\xb8\x7e\x25\xd9\x30\x69\x42\x15\xd0\x37\x7d\xa8\x79\xf9\xbe\xe5\xcb\xf7\x31\x5f\xaa\xa6\x77\x05\xd0\x6c\xef\xbe\xa5\x98\xf5\x71\xe9\xbe\x5f\xf6\x4d\xc7\x19\xe5\xff\x52\xa4\x75\xc5\x90\x9e\xbe\x06\xdf\x70\xfa\x74\xfa\x1f\xf8\xd2\xe5\xe9\x7b\x94\x93\x4a\x48\x82\xbc\x45\xb9\x32\x23\xc7\x66\xfb\x2c\x95\x8f\x74\xc1\x8d\x44\x25\x51\x7d\x1b\xf3\x3a\xe3\x30\xfe\x5a\x60\xa5\x31\xa4\x82\x0a\x62\x8a\xfd\xc1\xd9\xf2\xe1\xfe\x57\x36\x4b\xc4\x2b\xa1\xd1\xf1\x62\xda\x64\xe0\x0d\x66\x93\x85\x65\x03\xad\x2b\x37\xdf\x72\xdb\x4a\x4c\x5a\x2b\x53\x12\xd6\x21\xd1\x07\x0f\x7f\x7d\x77\x14\xf4\xff\x50\xfe\x33\xef\x77\x69\x2d\x56\x93\x36\xc0\x75\xc4\xd7\xf4\x6f\x9f\x1f\x2b\x36\xe0\x98\x5d\x92\x0d\xff\x60\x14\x57\xf9\xdc\x1f\x64\xb1\x64\x29\xf2\xdd\xd5\x50\x8b\xf0\x4c\x20\x00\x7f\x15\xa8\x23\x2c\x7b\x79\x69\x87\x82\x2a\xe5\x0f\x2b\xfe\x91\x1e\x1a\xd3\x95\xd1\x92\x95\x17\x98\x80\xbf\x8a\x09\x67\x2c\x63\xca\xba\x39\x5e\x56\x27\x8b\xbf\x30\x59\xd0\x32\xaf\xa5\x00\xff\xc0\x5b\xb2\xc9\x67\x0e\x9c\x3f\xee\xd6\x29\x0f\x4d\xb9\xb9\xfc\xfc\x03\x89\x95\x87\x7e\x30\xe7\x81\x39\x3f\x38\xb4\x32\x31\xd0\x12\xba\xfc\xfa\x9f\x1f\x5e\x3a\x33\x79\xff\x81\x2b\xfa\x7c\xad\x57\xb8\x23\xe7\xdc\xbb\xe1\xfa\xbb\x6f\xd8\xb7\xfe\xde\x0d\x11\xf7\x15\xa0\xb7\x7b\x5e\x47\xc7\xbc\xe1\x3f\x17\x5d\xf0\x80\x4d\xaf\xb7\x3d\x70\xc1\xa2\x4b\xa7\x57\x0a\x42\xe5\xf4\x4b\x81\xe6\x8d\x8b\x66\x6c\x6a\x0e\x68\x39\x69\x5c\xeb\xea\x09\xbb\xde\xfc\xec\xc8\x9c\x45\xdb\xd6\xce\x9a\x17\xf0\xce\x99\xb9\x76\xdb\xc2\xd9\xfd\xc3\xbf\x2b\x07\x7e\x0b\xea\xb8\x87\xbf\x9a\xef\x1c\x7d\x15\xb6\x24\xa4\x8a\xa7\x13\x39\xf3\x33\x26\x8d\x1d\x45\xa0\x34\x00\xc9\xb9\x44\x16\x52\x10\xfe\x75\x24\xa3\x92\xc2\x63\xb9\x9d\xc5\x3c\x96\x61\x1c\x21\x05\xea\x14\x10\x3b\xd4\xc2\x04\xb4\x17\xc4\x82\xbe\xe8\xc8\x82\x21\xc5\x95\xcd\x31\x2f\xe5\x97\x8b\x58\xcc\x1d\x76\xee\xab\xe8\x60\xaa\x74\x89\x4b\xfe\x9d\x18\x65\x12\xa5\x4b\x0b\x40\x48\x1c\xbc\x92\xa6\x32\xd8\x85\xb8\xd0\x80\xaa\x38\xc8\x36\x54\xc9\xef\x95\x1f\x6a\x1f\x4c\x65\xcb\x8d\x34\xbb\x54\xec\x2c\xbb\x09\x2e\x0b\x94\x17\xcb\x37\x3a\xcd\x81\x8a\x62\xb0\xc1\xfe\x78\x7f\xae\x2a\x47\x41\x53\x74\xd2\x3d\xad\x8d\xf2\x8d\xd1\x49\xb9\xca\x2c\xed\xaf\xa9\x22\xf3\x1a\x9b\xc7\x47\x5e\x48\x95\x50\x75\x84\x65\x88\x98\x50\x43\x04\x6e\x84\xe0\x41\xb7\x02\x0f\x18\x09\xea\x47\x99\xab\xa0\x57\x80\x66\x0f\x44\x23\xbf\x98\x4f\x52\x7e\x5e\xf0\x65\xf9\xe5\xa0\xc6\xe9\x2a\xa8\xd6\x14\x5c\xfe\xc0\xe5\x05\x9a\xf1\xb5\x4e\x59\xa7\xf8\xd2\x4c\x57\x7c\x69\xa6\xaf\x3d\xfa\x99\x3c\xf4\xd9\xd1\xb5\x68\x0b\x98\xcf\x8e\x7e\x3c\x92\x68\xfd\xb5\x0b\x6f\xb8\xe1\x42\x74\x03\x74\x9b\xee\x55\xab\xba\x5d\x4e\x73\x35\x78\xa3\x4f\xb9\x9a\x7c\xfa\x32\xbe\x6c\x6d\xee\x36\x68\xb8\x1e\xf1\xdd\x8e\x5d\x37\x3b\x81\xf1\x53\xec\xfd\xd8\xe3\x02\x7f\x2e\xff\x83\xba\x69\x9c\xb5\xe3\xd5\x5a\x55\x17\xb8\x9c\x1a\x5c\x57\x39\xfe\x3f\xab\x5b\xa4\xa0\xda\x9c\xa9\x96\x06\xdd\x06\x55\x15\x6a\xff\xb7\x75\xd3\x13\xdf\xfd\x72\x6c\xe5\xcf\xf8\x21\xe2\x2e\xf6\xfd\xab\x94\x0c\xb9\xd2\x44\xdf\x84\x49\x97\x1c\xfa\x9f\xd5\x44\x31\x0a\x82\x27\xfe\x47\x85\x57\xe5\x3c\xb4\x51\x66\x99\xf6\xef\xb7\x42\xc2\x8c\xf0\xef\x2a\x31\x53\x01\x7f\x38\xc0\x29\x10\x10\xbe\x5a\x3a\x21\x0a\x29\x51\x48\x0a\xa2\x12\xf1\x90\x49\xc2\x84\x5a\x19\x75\x23\xbf\xfd\x76\xea\xd0\xfb\x87\x52\x6f\xcb\x6f\x83\x8a\xb7\xe9\xe4\xdb\x20\x35\xea\x1a\x9c\x5c\x47\xaa\xa3\x7a\x78\x11\x9c\xf2\x64\x12\x54\x80\x07\x00\x66\x31\x37\x65\xd7\x45\xf0\x58\x8c\xfd\xa8\xf1\x5c\x39\x97\x5a\x41\x6d\xa0\x76\x50\x97\x92\x95\xd7\x7b\xa8\xc7\x88\x15\x1f\xd5\x09\x0d\x07\xa8\x1e\xf1\xbc\x74\x38\x2f\x8d\xf2\xa0\xf7\x86\xd2\xa8\x16\xc1\xd3\xe7\x39\xe3\xf1\xd3\xa5\xd9\xfc\xb4\x25\x9b\x8e\xe2\x7d\x89\xb0\x93\x8d\xb4\x09\x98\x7b\xcc\xe8\x5f\xd2\x3c\x60\x46\xff\xd4\x3d\x86\x32\x0f\x21\x81\x91\xee\x31\xa7\xb3\xe7\xc9\x06\x8c\xbd\x9b\xd9\xca\x94\xba\x9f\xdb\xa2\xdb\x6e\xc2\x17\x7c\x8b\xa6\xd5\xe9\xd1\x6f\x09\x76\x26\x46\xd0\x04\x9b\x48\x8e\x2f\xf3\x7e\xd3\x5f\x8e\x3a\x24\x8f\xb1\xa3\x6e\x80\xb2\x51\xff\xc9\xfd\x24\x9f\x19\xc7\x9f\x0e\x25\xf1\x1f\x7e\x10\x8d\x7f\x15\x91\x3a\xa1\xae\xd5\xd9\xa9\x32\x6a\x01\x96\xd6\x32\xbe\x41\xbc\x85\xf0\x84\x10\x6c\x00\x30\xc2\x6c\xa8\x5a\x07\x33\xd1\x71\xd8\xd1\x94\xc9\xa2\x47\xc4\x89\xdb\x6b\x26\x62\x0c\x0d\xee\xc9\x07\xf7\xcf\x69\x5b\xfd\xc0\xf2\x63\x1f\x7f\x75\x3c\x7e\xf6\xaa\x78\xbc\xb0\xa2\xe1\x82\xc1\x73\x03\x45\xc4\xde\x55\x14\x40\x7d\x8b\x4d\x05\x74\xfc\xef\x6e\x5a\x34\xb9\x30\x31\x79\x53\xe3\x5a\xf9\xab\x15\x26\xd1\x6c\xf6\x16\x07\x16\x5e\x7d\x6f\xe7\xa6\x5f\x6c\x0a\x45\x76\x1e\xb7\x6b\x8b\x8b\x8b\xc1\xdf\x60\xef\x12\x6f\x4d\xfc\xe2\xf4\x83\x9b\x4d\xc1\x02\xb7\x60\xa7\x37\x07\x1a\x2d\x83\x02\xb1\xbf\xfd\xd3\xd2\x88\x8d\xda\xdb\xd3\x6c\x58\x64\x99\x6d\x01\xc1\xe7\x29\x5c\xd4\xa8\xd5\x48\x41\xf8\x71\xc0\x6a\x2b\x6f\x09\xb5\xc6\xa5\x4d\x06\xd6\x2c\x5a\x71\xec\x4f\xa6\xee\x2c\xea\xc1\x65\x54\x2d\x35\x99\xda\x82\xbf\x43\x8e\xb7\xc5\x24\xf2\x8b\xd2\xe1\x28\x1a\x2a\xb5\xa8\x39\x6c\xa4\x52\x0e\x1b\xaa\x17\x3a\x89\xea\x6a\xb3\xff\xff\x6a\x16\x3a\xf1\xc4\x2b\xaf\x3d\xf6\xd0\xdb\xef\xd2\x9f\xfc\xed\x46\xab\xc4\xd6\x1b\x6b\xa5\x2a\x57\x45\xa0\xc2\xee\x70\x49\x6b\x9f\xd8\x20\x59\xcb\x6a\x2e\x38\xf6\xe0\xfe\x4a\xdf\x0d\x83\x0f\xfd\xaf\xda\x0a\x3a\x53\xe6\x35\xcf\xf4\x80\x47\x5e\xd0\x9c\xff\xdc\x46\xb9\xfe\xe9\x6d\x95\x03\x9c\x96\x2e\xe4\x9c\xbc\xc4\xe9\x19\x86\xfe\x43\x63\x54\xcb\x1d\xb7\x40\xfe\xb9\x25\x9a\xe7\xcb\xc0\xe7\xff\xbb\x86\xc4\x6b\x4b\x48\x2e\x21\xeb\x07\x25\x0a\x1b\xe7\x88\xf5\x03\xbb\x75\x64\xfc\x29\xec\x1c\x6b\x41\x41\xc7\x54\x8a\xc2\x10\x31\x84\xd2\x78\xd4\x1a\x37\xf6\x2a\x8a\x5c\x99\x17\x79\x87\xfb\x70\xe5\xa9\xeb\xf9\xb9\xcc\x67\xe4\xf9\x0d\x2a\xc7\xe8\xf0\xe5\x35\xbb\x55\x8b\x66\x74\x4c\x92\x86\x03\xe9\x31\x84\xf5\x98\xc5\x84\xeb\xc7\x5a\x6d\xd3\xc1\x49\xf2\x95\x8c\xc3\xd0\x6a\x34\x32\x60\xbb\x92\x80\x57\x8f\x59\x81\xfd\x63\xaf\x44\x31\xbe\x93\x5f\xa1\x8b\x2d\x8c\xc3\xc8\xea\x95\x44\xba\x77\xec\xca\xe5\x7c\xe3\x9f\xa5\x6c\x18\x53\x07\xd8\x32\xf0\x34\xb8\x42\x18\xb7\x92\x00\xd6\x61\x22\x0a\xc5\x4f\x52\xc4\xee\x7a\x23\x32\xd9\xd0\x13\x90\x28\x4b\x10\x6c\x14\x71\xbb\x68\x5c\x58\xde\x2a\x49\x9c\xd1\x5f\x1e\x2d\xe4\x34\x56\x8e\x2e\x80\xe5\x37\x26\xde\xb9\x6b\x78\x1e\x70\xdb\xf1\x07\xc1\x8b\x93\x31\xba\x8a\x2a\x7b\x63\x47\xf0\x49\xf2\x16\x1c\x09\x30\xa3\xf1\xa6\xdd\xbb\xeb\x0d\x16\xa0\x71\x81\x83\xf7\x4d\x99\x65\x1c\x1c\x91\x4f\x3e\x59\xf8\xf3\x63\x8a\xac\x0a\x4f\x1d\xe3\xf6\xb0\x03\x94\x8e\x2a\x45\x75\xa8\x44\x6d\x4f\x5b\x1c\x2c\x1d\xd6\x02\x89\xe0\xb7\x06\x09\xe7\x11\x66\x3c\x8a\x61\xc2\x23\x24\x81\x4b\xac\x07\x30\x77\x03\x20\xdf\x3e\xd1\x73\xa4\x09\xb4\x36\x1b\xc0\x57\xf2\x8d\x0b\x58\xbb\xc3\xe2\x90\xdb\xe4\x36\xb4\xb1\xb3\x0b\xe4\x1b\xbc\x62\x25\xf8\xf7\x87\xd6\xa2\x42\xdb\x87\xe0\xdf\x95\x22\x6c\x3f\x59\xa7\x6b\x06\x13\x87\x5a\x8a\x1f\x00\xab\x26\x82\xa8\x7c\xa7\x6c\xf0\x05\x0d\x7f\xff\xbb\x21\xe8\xc3\x5c\x49\xde\x38\x8f\xa9\x92\xc6\xc9\x0d\x9d\x7c\x9c\xca\x60\xef\x26\x89\x8f\x31\x95\x03\xd5\xf7\xf9\x31\xe0\x1b\x50\xb0\x2f\xd8\x0b\xd3\x49\x4b\x29\xab\xb3\xbb\xd3\x29\x7b\x40\x27\x5a\x59\xca\x68\x76\x8b\x26\x9e\xb9\x67\x90\x0a\x40\x36\x60\x87\x09\x77\x45\xa9\x0e\x26\x79\x49\x18\x97\xc1\xda\xc4\xb2\x39\x44\xa3\x49\x3d\x41\xf0\xd7\x02\x9f\x62\x01\xcc\x9a\xf9\x7c\xaa\x2f\x85\xa2\xe8\xe6\x48\xa8\xe3\xa8\xf7\xe1\x75\x3c\xe2\xf4\x52\x09\xe7\xa6\x93\xe8\xef\x18\x93\xcc\x98\x2a\x86\xfa\x87\x59\x2e\xe8\xb9\xff\x46\xfd\x45\xab\xfd\x9a\x18\x76\x50\xd6\xdf\xa1\xbf\x9e\x3c\xeb\x06\xdd\x93\x67\xe1\xf8\x5a\xab\x45\xb9\xff\x3d\x74\x4c\xa4\x54\xfe\x22\x26\xc7\xa3\x32\x3d\xb7\x8e\x22\x8e\xf0\x19\xc7\xbe\x47\x0a\x47\x4c\x11\x20\x0b\x60\x44\xdd\x8b\x67\xc6\x39\x1b\x1e\xfb\x90\x58\xcc\x46\xd5\x03\x00\xfb\x4d\x65\xfe\xc1\xa7\xc9\xe6\xe6\xba\x0a\x38\xd0\x7e\x45\x72\x6e\x45\x1d\xd2\x46\xeb\x2a\xd4\x4d\x6c\x75\x7c\x42\x57\x59\xd8\x42\x76\x9d\xe4\x12\xe6\x69\xb2\x99\x4a\x7e\x7b\xea\x16\x17\xc8\x1f\x5e\x1c\x2a\x2f\x6d\x9d\xe4\x2a\x58\x5c\x87\x15\x77\x74\x88\xae\xcb\xa5\x65\x93\xab\xd8\x52\x10\x2c\x6b\x9e\xa5\x1e\x54\xb0\xee\x93\x24\x96\xd3\x88\xb4\xf7\x20\x92\x74\x97\x52\xbd\xd4\x36\x6a\xaf\xca\x10\xac\xae\x3c\xda\xad\x0e\xc5\x27\x96\xf8\xb8\x84\xf2\xe4\x45\x36\x1b\xa3\x10\xc6\xe0\x5a\x68\x50\xc0\xce\xff\x71\x3b\x1a\x19\x00\x9f\x05\xcb\x71\x00\x3e\x44\x9c\x11\xdb\xd4\x40\x04\x26\xef\x16\x20\xef\xd6\xec\xb0\x87\x82\xa7\x4e\x51\x7a\xa7\x5e\xab\x05\x14\x7e\x79\xfd\x0a\xd3\xd2\x40\x5e\x2c\x2c\x0b\x15\x08\x1c\xf9\x51\x9b\xed\x0b\x60\x71\xcf\x71\x5f\x5f\x58\x28\x7f\x2e\x06\x6c\xa0\x7b\x5e\xfa\xa6\x2f\xe4\x2f\x54\x38\x1d\x20\xa2\x63\xf2\x23\x2a\x62\x0e\x98\x69\x83\xd7\xe4\xdd\x26\xfd\x4f\xe5\xd6\xe0\xa6\x61\x0f\x04\xda\x53\x14\xe9\x09\x80\x6c\x22\x79\xe1\xb8\x03\x24\x7f\xff\x05\x18\x26\x07\xcc\xb2\x05\x44\xf9\x73\x37\x50\xc0\x75\x80\xf4\x85\x0d\x3d\x6a\x01\x5c\x2e\x02\x51\x05\xdc\x91\x3f\xff\xd2\x86\x8a\xb4\xe0\x7c\x72\x81\xfc\x13\xdb\x7a\x85\x34\x8a\xca\xbb\xe5\x7d\xc3\x1e\x86\xc7\x83\x1e\xf4\x91\x0c\x91\x75\xcd\x66\xc5\xaf\x73\x98\xe5\x1b\x8f\x66\x42\xfe\x51\xe2\xe8\xae\xc2\x42\x93\xb9\x14\xc4\x45\x1f\x76\x5e\x4d\x39\x91\x34\xe3\x24\x3f\xa0\xb9\x38\x3c\xa5\x22\x3c\x2e\x8e\xf6\x4c\xb6\xbd\x33\x9b\x6a\x97\xb5\x4c\x28\x0f\x4c\x35\x8a\x06\xe3\xbd\x46\x56\xd3\x0f\xc6\x77\xdf\xbd\x77\x0e\x70\x66\x2e\x70\xc2\xa9\xb1\xe5\x4d\xcd\x6e\xbb\x63\x5e\x81\xa5\x38\x28\x55\xce\xbd\x3e\xe0\x6e\xac\x2e\x4b\x14\x15\x9c\x65\xd6\xec\xd6\x79\x8c\x40\xd7\xda\x7b\x53\x46\xd7\x86\xf8\x7b\xf6\x60\x1e\xad\x7c\xe4\x0b\x85\xa6\x37\x33\x91\xd9\xf0\x37\x4b\x8f\x9c\xdd\x92\xca\x1a\x70\xc8\x95\x48\x64\xa8\xb0\x51\x22\xa9\x70\xd1\x28\x40\x64\x59\xd8\x0b\x90\x54\x0d\x63\xe9\x54\x88\x59\x4b\x0c\x4b\x4a\xe0\x2b\xa4\x56\xa2\x1f\x4f\x96\x77\x64\xc4\x43\x24\x5a\xd1\xa7\xc3\x74\x48\x8d\xe1\xce\xbf\xbd\xa7\x10\x84\xf1\x6e\x18\x14\x82\x20\xb6\xcc\x06\x81\x77\x00\x9f\xc4\x3f\x0c\x97\x26\x19\x69\x02\x88\x86\x47\x2c\x8a\x95\xd9\x0d\xe8\x9b\x99\x86\xeb\x1a\xc0\xd1\xfd\x84\xe2\xd0\x04\x7c\xd1\x88\x44\x07\xa2\x3e\x02\x79\x10\x89\xb5\x41\x9f\x2d\x40\x4b\xc0\xe6\x23\xee\xc4\x4c\xe6\x1d\x85\x15\x0e\x1b\x12\xa9\x13\x89\xd2\x97\x7c\x73\xc4\xa9\xa1\x69\x40\x33\x40\x67\xba\x4d\x96\x93\x2f\x3c\xb3\x1f\x58\xaf\x84\x36\x74\x90\xd6\x14\x5c\x05\xc0\xee\xa7\x5f\x85\x9f\xa6\x65\x9a\xa9\x9b\x79\xd6\xcc\xba\xa6\x71\x91\x2a\xc1\xbe\xde\x15\x9c\xbb\xfe\xbc\x2b\x6a\xa6\x2f\xea\x8a\xd3\x7f\xbd\xff\xfe\xa1\x32\xad\x81\xe6\xb5\xd0\xea\x3c\x79\x3f\x08\x00\xf3\x03\x1f\x31\x21\xad\x41\x6b\x28\xfb\xe8\x01\xf9\x2b\xf9\xb7\xf0\xfe\xd7\xdd\x85\x62\xa2\xaf\xbd\xad\xaa\xd5\x17\xaa\x09\xeb\xdd\x4b\x83\x45\x13\x76\xac\xaa\x5f\xde\xd4\x58\xde\xec\xeb\x56\xe6\x21\x16\xfb\x90\xd1\x7b\x51\xdd\x3a\xbf\x5f\xdd\xd8\xd3\xd7\x8d\xfe\xfe\x75\xfb\x7b\x5a\x66\xe8\xe1\x75\xeb\x3e\xe7\xbc\x2b\x26\xad\x5a\x3d\x8d\x39\x73\xd5\xde\x7b\xdd\x5d\x09\x46\xd7\x6c\xe2\xfa\xf6\xc6\x8e\x70\x37\xa9\x17\x40\xba\xd7\xc5\xac\x82\x37\x47\x05\xb1\x0f\xbb\x1d\x2f\xc3\x90\x1e\x11\x22\xf3\x18\x5e\x39\x4d\x82\xee\x34\x25\x3f\xc2\x7d\x65\xd2\x17\x0c\x25\x43\x8d\x69\x2a\xd4\x66\x46\x69\x1a\xa5\x69\x94\x26\x38\x7b\x4c\xd4\x3f\xbd\x70\x88\xaa\x18\xe7\x47\x5b\x06\x6d\x95\xf5\xbe\xf7\xc9\x58\xda\xab\x60\x64\x11\xf4\x6c\x8c\x27\x6b\xf3\xf3\x98\x14\x26\x14\xad\xcb\xc5\x1e\x63\x62\x1f\x35\x6e\xa0\x1a\xf8\xc3\xfe\xa8\x05\x63\x64\x60\x41\x17\x07\x30\x67\x02\x96\x09\x2d\x12\xa6\x8a\xb1\xe1\xe6\xc7\x58\x1b\x0a\x01\x10\x52\x10\x16\xcf\x1a\xd7\x59\xd9\x11\x3c\xcf\x0b\xec\x7a\xff\xc5\xbd\x55\x2d\xf3\x02\xe3\x02\xe7\xcc\x9e\x77\xbe\x27\xe8\xa9\x0a\x76\xaf\x38\xac\x0d\x6a\x8d\x00\x42\x58\x1c\xa4\x0f\xaf\xe8\x0e\x56\xa1\xe3\xe7\xcf\xef\x3e\x07\xe5\x9a\xd7\x92\xf8\x6b\x35\x60\x59\xe0\x0c\x54\x54\xda\x1b\x6a\xba\xcb\xe7\x2c\x01\x4f\xce\xc6\xa7\x2e\x0a\xdf\x1c\x66\x91\xd8\xa1\x8b\x36\x04\x3b\x2a\x3b\xc7\xcd\x5a\xbc\x64\x4e\x79\x77\x4d\x83\xbd\xb2\x22\xe0\x84\x0c\x84\x00\x30\xd4\x88\x4b\xd5\x92\x34\x44\x3d\x23\x9e\xa6\xca\x65\x4c\x92\x70\xd9\x45\xc8\xf7\x48\xf1\x36\x5f\x86\x2d\x9d\x38\xa0\x87\x28\xfc\x75\x92\x95\x77\xca\xab\xa6\xf1\x94\xe0\x25\x53\x82\xd7\xce\x24\xe5\xf7\xde\x23\x30\x84\xea\x7a\x03\xa0\xde\x93\xdf\xc3\xcb\x07\x04\x64\x11\x25\x4e\x51\xc7\xe5\x6f\x8e\x63\xff\x5b\x3a\x91\xfc\x40\x7e\xc6\xb9\x4f\x71\xae\xdc\xe7\x04\x53\x3e\x50\x86\x0c\x05\xbf\x91\xa0\xe4\xac\x95\xa9\x7d\xc7\x8f\xef\x83\xf8\x17\x7b\xd7\x22\xb9\x66\x2b\xf1\x77\x6d\xc7\x33\x3b\xba\x61\xb6\x38\x5a\xa0\x78\xd1\xf3\xa8\xd1\xf3\x0a\x39\xaa\x02\x61\x3e\x1f\xf3\xc0\x6e\x0d\x02\x05\x04\x1d\x98\xd6\xe0\x10\x0d\x66\xbd\x7c\xd3\xf1\x7d\xf1\x58\xcf\xd9\xe7\x3c\x43\xca\x3b\xaa\x3e\xbb\xcf\x93\xd1\xb8\x3f\x47\xa7\x63\xde\x22\x5b\x79\x67\xfa\xfa\xe3\xfb\xd6\xde\x07\x67\xad\x59\xb7\x51\xa9\x40\x14\x7a\xe4\x9b\x92\xfb\x8e\x4b\x3d\x11\xb5\x22\xae\x61\x55\x35\x76\xc8\x3a\x74\xa5\x0b\xdf\x02\x6f\xd1\x1d\x70\x0d\xcf\xcf\xfa\x49\x2b\x3c\x49\x7e\xc5\xcf\x01\x7d\x9d\x92\xc5\x2a\xb0\x84\xf0\x32\x8b\x45\xce\x24\xe4\xc4\x8e\xe5\x7f\x4b\xb5\xaf\xda\xbf\x6d\x4f\xd4\x6c\x28\x34\x98\xa3\x7b\xb6\xed\x5f\xd5\xae\x38\xbc\xc0\x04\x4c\x0e\x5e\xdb\x36\xed\x69\xfa\x91\x34\xb5\xe0\xc1\x4b\x2f\x9a\xd3\xe9\xc2\x8c\x6d\xae\xce\x39\x17\x5d\xfa\xe0\x02\x65\x60\x54\xe5\x25\x2a\x8b\x0f\x11\xc0\xb6\x00\x87\xcf\xe2\x0b\x8e\xf0\x7e\x18\xbd\x3f\x22\x62\x48\x15\xf4\xb2\x29\xd4\xa2\x68\x72\x39\x89\x3e\xbf\x9c\xe3\x27\x9d\xe7\x04\x8a\x09\x2f\x4e\x12\xb6\xc5\xe4\xf2\x89\x98\x41\x4f\xd9\xa0\x23\x48\x7a\x4b\x01\x2f\x01\xd1\x20\xf2\x5d\x5e\x7a\xe6\x20\x31\x51\xb1\x38\x92\x88\x30\xe7\x29\xbf\x5d\xa4\xdd\x68\x22\xf3\x0e\x20\xb9\xaf\x2b\xe7\x5f\x1e\x54\x61\x1d\x83\x55\x38\xd4\x69\xb8\x63\x6d\x3c\x8a\x91\x07\xd4\xcf\x1a\xc7\xa5\x65\x1d\xa4\x7d\xe8\x64\x90\xc0\xc5\x40\xc5\xb3\x9c\xfe\xa1\x41\x63\x60\x68\x39\xa1\x17\x4e\x51\x1b\xaf\x53\x26\xbf\xdd\xab\xbc\x4d\x9b\xa6\xb4\x58\x19\x4b\xa9\xd9\xe8\xb0\x18\x58\xa9\x7e\xc2\xfa\xfa\x82\xe5\xfb\x96\x0b\xa0\x4a\xd0\x83\x14\xcd\xa0\xab\x58\xe5\x9d\xf7\xc8\x29\xb3\x96\x07\x3d\x50\xd4\xaf\x75\x3c\xb2\x75\x88\x4c\x55\xb4\xb7\xef\x41\xcf\xc6\xea\xa6\x69\x3e\x4d\x80\x37\xd4\x3a\x75\xde\xe9\x13\x26\x89\x65\x15\xb8\x56\xbe\x62\xbd\x08\x7b\x00\xaf\xc5\x75\x2b\x39\xe5\xe5\x14\xbb\x64\x65\xae\x6e\xc0\x8a\xa5\x57\x1a\xb3\xf0\x11\x04\x1f\xa4\x6a\x64\x53\xb8\xfc\xf1\x58\x09\x36\x3e\xf5\x13\x41\x15\x38\x6f\x7a\x74\xf6\x16\x2b\x14\xe4\x24\xaf\x35\xe8\x13\x46\x76\xbe\xfc\x5f\xf2\xdf\x69\x4e\xd0\x26\x2c\x86\x01\x9d\x19\xec\xea\xe9\x3e\x0e\xe6\x01\x56\xb0\x32\x8a\xc4\x0a\x92\xdf\xca\x37\x3e\xd6\xdd\x23\x5f\x66\xd6\x0d\x30\x5a\xfc\xd2\xac\xa0\x60\x3e\xd0\x26\x24\x2b\x48\x0a\xd0\xba\x65\xf6\xb3\xd7\x48\x19\xff\x21\xee\x84\xa2\x6f\x00\xda\x87\xb9\x92\xca\xf1\xd6\x87\xfe\x68\x1f\xc1\xb7\xe6\x4e\xdc\x2b\x3f\xfa\xa8\xb1\xd0\x5d\xff\xe0\xab\xf2\xa3\xaf\xca\x7f\xc2\xbf\xb7\x30\x43\x6b\x7e\xd2\xd4\x5c\x06\x07\xd3\x2c\x9d\xa8\xf7\xfa\x86\xa6\xd0\xcf\xe0\x3f\x30\x65\x76\x67\xe7\xcf\x86\xfb\xc1\xe0\x01\x87\x0a\xc6\x63\x75\x48\xc3\xca\x60\xd5\x73\x24\x1a\x25\xdf\xd4\x43\x5f\xbd\x56\x92\xe4\xd7\x40\x44\x92\xd6\x62\x8d\xae\x51\x92\xc0\x8b\x52\x1d\xfc\xc1\x88\x55\xcd\xab\xf1\x59\x10\x41\xf9\xea\x24\x7c\x45\xa3\x92\x19\xbe\x7b\x5a\x7c\x75\xe5\xf9\xe8\xd1\x61\x15\x90\xde\xa1\x55\xc1\xdf\xf3\x9f\x0f\x5f\x43\x8f\x53\x6e\x87\x6e\x0b\x22\xf2\x6b\xa4\x20\xf4\xe4\x91\xcf\xc7\xa5\xc2\x45\x53\x8a\xf9\x1a\xca\x87\xaf\x38\xd3\xf3\x41\x3c\x96\x89\x76\x51\x20\xf0\xb5\x23\x9e\xcf\x5c\x9d\x57\x1b\x29\x57\x49\x30\xb2\x01\x80\xd2\x02\x23\x0b\x0b\x46\x16\x60\x8c\x77\x90\x69\x7e\x6d\xa6\x21\x46\xbe\x83\xca\x51\xf5\x52\x5e\xc2\xc8\xa5\xe5\xcf\x48\x23\x8c\x7c\x61\x70\xc7\x18\x6d\x90\x20\xb1\x23\x16\xd2\xc3\xe2\xa8\x67\x61\x48\x9a\x80\xc4\x46\xa2\x41\xc9\x17\x06\x3e\x9a\x0d\x32\x7d\xe6\xa1\xab\xaa\xe1\x6a\xfb\x0b\xcf\x1b\x1f\xb6\x83\x3e\x06\xac\xab\x4d\x5f\x64\x92\xeb\xd9\x64\x32\xfd\xd3\xf4\x2f\xe8\xa3\x0f\xa7\x3f\xfd\x28\x1a\xbd\x4a\xfe\x74\x35\x58\x05\xbd\x4f\x80\x77\x4e\xae\xbc\xfb\x6e\xd2\x7f\x0d\xa7\x12\xdc\x7f\xab\x18\x72\x3e\x2d\x94\x7c\x3c\x8b\xee\x2b\xf9\xe2\x3e\x20\xb1\x1f\xca\xff\x1e\x7a\x3f\x3d\x79\x0a\x18\x57\x04\x7e\x08\x3e\xee\x18\x9c\xda\xc8\x3c\x13\x1a\x9c\x8a\x86\xb7\x57\xe4\xaf\x80\x1e\xac\xbe\xfe\xae\xbb\xc0\x5c\x30\xee\x67\x6a\x5b\x99\x79\x85\xb3\x63\x7e\xde\xb7\xaa\x8c\x43\xd5\x80\x43\xad\x14\x1e\x85\x43\xeb\x01\x8e\x3c\xb5\x39\x4f\x01\xb5\x45\x32\x56\x6e\x4b\x2b\x88\x67\xc0\x6a\xe9\x94\x32\x2a\xad\xb5\x6a\x18\x83\x7e\xd9\x0e\x79\xb3\x5c\x27\x6f\xde\xb1\x4c\x2b\x30\x1a\x2b\x1a\x31\x7b\xec\x1a\x8d\x69\x75\xfb\x57\x37\x2a\xc2\x76\xe3\xe4\xc3\x6f\x1f\x9e\xdc\xa8\xec\xdc\xf8\x55\xfb\x6a\x93\x46\x63\x07\x3d\x82\xc8\x7c\x4c\xc6\xa6\xa1\x7e\xb9\xdf\xae\x81\xda\x65\xd7\xde\x7f\xff\xb5\xcb\xb4\x50\x39\x69\x95\xcc\xab\x97\xec\xb6\xc2\xcb\x89\xf4\x7e\x8f\x7f\xfb\x64\xec\x0d\x39\x79\xbb\xff\x1e\x72\x20\x7d\xa1\x75\xf7\x92\xd5\x66\xc9\x2a\x2a\xdf\x3f\x91\x1b\x02\xa3\x38\xb6\xb0\x3f\x27\x61\x22\x55\x91\x04\x08\x5b\x2f\xe3\xcd\x91\x7a\x79\x55\xc9\x40\xa5\xfb\xca\x99\xc4\x08\x16\x70\x82\xf0\x79\x3d\x83\x4b\x8e\x9f\x2e\xa7\x86\xdb\xb3\x14\x1d\x9f\x48\x2b\x39\xa4\xdb\x90\x97\x33\xdb\xbd\x94\x99\x52\xff\x4e\x67\x13\x51\x20\x6c\x81\x5d\x8d\x7d\x02\x67\x2b\x44\xa5\x64\xf9\xff\xa1\x33\x18\x45\xe0\xa7\x0a\x64\xed\xd9\xa0\xf5\x43\x7c\x3d\x9c\x97\xbd\xb4\x22\xbd\xe7\x8c\x96\x1d\xb2\x9e\x82\x44\xf7\x24\x9d\xc1\xd3\x1a\xa5\x31\x8e\xf4\x9d\x1e\xe5\x4b\x9d\xac\x2f\x25\xed\x94\xc2\x1e\xa0\x63\xa7\x69\x6f\x26\x35\xe6\x4f\xd6\xe7\x05\xe4\x70\xbd\x46\x95\xc3\x72\x86\xfd\xfc\x72\x8c\xf5\x03\x72\x65\x00\xbf\x1d\x2b\x99\xcf\x39\xcd\x53\x6e\x2a\x8a\xad\xae\x59\xdf\x17\x4c\xb4\x49\xec\x44\x84\x23\x01\x10\xd9\x23\x04\xab\x40\x09\x66\x71\x20\xc7\xed\x8c\xa8\x9c\x18\xcd\xd0\x08\x15\x97\x61\xf0\x23\xa3\xfc\xcc\x27\x82\xd5\x62\xbc\xf5\x7d\x3d\x10\x8d\x49\xa3\x15\x5c\xcc\xae\xfd\xc9\x27\xf2\x87\xb7\x0a\x5a\x9d\x68\x7c\x15\x2c\x3d\xc1\x93\x13\x3a\x3d\x28\xce\xf7\x8c\x54\x22\xfa\xfd\x9f\x80\x29\x46\x60\x45\xe7\x45\xa0\x7f\xff\x56\xa3\xc5\x6a\xbc\x15\x14\x7f\xf2\x93\xb5\x2c\xd0\xe9\xc8\x51\xfe\x84\x7c\xef\xab\x46\x51\xa7\xa5\x5f\x1b\xe9\x2f\x99\xb3\xe1\x61\x9c\x93\x7c\x06\x0c\x32\x94\x13\x72\x1e\xa2\x4b\x8c\x62\x49\x78\x14\xbb\x58\x15\xfb\xbc\x5e\xb3\xd9\x62\x1a\x85\x9c\x9f\xbe\x49\x9c\x26\x82\x84\x24\x4a\xc1\x74\x32\x28\x69\xb4\xe8\x5d\xc6\x4e\x45\xb9\x57\xd8\x97\x89\x2c\x87\xde\xa5\x96\xcd\xcd\x16\x78\x90\x56\x96\x84\x63\xa8\x6d\xf9\x70\x46\x02\x26\x2b\x61\x0e\xbb\x15\x29\x0a\xcd\xe9\xe7\xe5\xe7\xc1\x7a\xd8\x87\x06\x64\xcc\x3d\x92\x3e\x8c\xc6\xed\x3e\x31\x46\x5f\x39\xb4\x3d\xb8\x21\xb8\xa7\x7e\x53\x7f\xfd\xee\x60\x90\xbe\x12\xed\xec\xc6\x3b\x7b\x82\x4c\xb3\xfc\x7c\x1a\x63\xad\xe2\xab\xea\x70\x6e\x7c\x55\x1d\xbe\x1e\x5e\x3b\xb4\x2d\x88\x2e\xea\xdf\x84\xf2\x6d\x08\xd2\x07\x82\xe8\x22\xb4\xb3\x3b\xb8\x61\x58\xbb\x28\xba\xff\xc8\x90\xe5\x31\x7c\x59\x15\x87\x59\x7a\x94\x5f\x2d\xf1\x5e\x55\x96\x18\x86\x7b\xab\xe6\xf8\xf7\xf2\xfa\xf6\xb0\x15\x86\x33\xf8\x75\xe1\x05\xca\x21\xb2\xe6\x43\x2b\x48\x6e\x39\x87\xae\x64\x3e\xef\x29\x1c\xc8\xae\xd7\xcb\xb5\x84\x16\x55\xc9\x49\xef\xcd\xa7\x40\x45\xe3\x24\x2a\x11\x7d\x92\xbd\x98\x2a\xc4\x7e\xd6\xe5\x20\x07\x56\x8e\xbd\xc1\x03\x39\xfa\x5f\xfa\xa4\x58\x9a\xc2\x41\x57\x36\x8d\xc6\xd0\xaf\x35\x83\x44\xaa\x54\xb4\xb8\x40\x42\x6c\x45\xaf\xdc\x4d\xdf\x17\xc4\x2b\xa6\xa2\xd5\x94\xd2\xc3\x64\x30\x58\x0c\x92\x76\xbb\x9c\xf4\x92\xb9\x0c\xc9\xc1\xe8\x19\x14\xee\x6d\x52\x66\xfd\x46\x75\x25\xc4\x54\x82\x16\x1f\x91\x10\x63\x5e\xec\xfe\x95\x2a\x2d\x71\xcb\x29\x74\x53\x39\xe5\xb2\xa0\x47\xca\x29\x41\xdf\x6f\xd4\x6a\x59\x4a\x12\x86\xee\x9a\xe6\x95\xd1\x7d\x41\xb2\x38\x14\x84\x49\x7d\x4a\xb0\x4a\xc3\x65\x81\x92\x3c\x59\x00\x84\x73\xb2\xc0\xa8\xcf\xf0\x18\x5c\xab\xce\xee\x95\xff\xa9\x8a\x03\x58\x26\x5a\x9b\xff\x16\x3f\x83\x6b\x55\x59\x00\xe5\x51\x32\xdf\x2a\xd1\x3f\xc8\x7f\x9f\xb9\x71\x9f\x43\x23\xbb\x4d\x7d\xa7\x0e\x1e\x3b\xa5\x13\x78\x05\xd2\x7e\x5a\xda\x02\x54\x32\x23\xd3\x68\x1f\xb9\x1b\x6e\xae\xab\xef\x01\x6f\x09\x16\xf9\x03\x8b\x51\xb0\x80\x80\x45\x1e\x84\x5e\x79\x20\x3d\x40\x27\x97\x16\x16\xde\x5c\xd8\x5d\xb8\x14\xf6\x0f\x63\x65\x7d\xe8\xe6\xba\x9e\x7a\xf0\x1f\x46\x7c\x89\x60\xc4\x97\xa4\x13\xd0\x0b\xd0\xb7\x29\x0f\xc0\x9e\xa5\xe8\x8a\x9b\x0b\x0b\x97\xf6\x9c\xee\xbb\x2f\xc0\xfe\xb5\xaa\xdf\x25\xcf\x15\x67\x18\x83\xe2\x40\x59\x40\x18\xd3\x6b\xdb\x4b\xe0\xe1\xd3\x9f\x2a\x0d\x01\xed\x07\x45\xb7\xc1\x18\x1e\xd1\xed\x7b\x00\x52\x22\xc2\xe3\x8a\x70\x3e\xd2\x72\x28\x9f\xc4\x5a\x60\x59\x7e\x49\x72\xe5\x08\xe2\x58\x69\x6d\x66\xd0\x29\x02\x7e\x81\x55\x96\x28\xe2\xb1\x30\xc4\x24\xc6\xca\xde\x28\x84\xb2\xcf\x40\x0f\x7a\x29\xfd\x9e\x70\xe9\x8e\x5f\x5c\x7a\x76\xbd\x4f\x77\xbf\x5e\xe0\x39\x3b\x5d\xd1\x57\xf5\xc0\x55\xa5\x06\x83\x0b\x86\x86\x35\xd7\x63\x28\x3f\x1a\x09\x7a\xb0\xb9\xa4\x3f\xdc\xb6\xa2\x67\xe7\x9a\xe6\x27\xfe\x68\xa0\xb5\x4e\xb0\x72\x47\x5d\x75\x7f\x99\x85\x85\xa9\x61\x8d\x95\x1b\xff\x21\x7a\xb3\x22\xe5\x21\xf6\x14\x60\x01\x16\x34\x79\x03\xd5\xf3\x70\x18\x0d\x15\x0e\xe4\xc0\x41\x37\x32\x45\x7b\xf3\x5c\x0c\x47\x39\x20\x82\x54\x32\x09\x66\xa5\xff\x74\x8a\x42\x1a\xf9\x07\xc4\x49\x51\xc9\x0d\x57\x8c\x98\x92\x73\x78\x6e\x18\xf1\xaa\x52\xc5\xeb\x50\x3e\x1a\xd4\x0c\x23\x47\x8a\x91\xad\xc4\x5c\x28\x3a\xe4\x94\x34\x51\x92\x53\x0e\xd1\x52\x0a\x93\xa5\x37\xab\x7e\x9e\x46\xec\xf3\x39\xfc\xcd\xd1\xcb\x02\xc5\x72\xc2\xed\x06\xa9\xe2\x40\x20\xed\x1d\xe6\x14\x3a\x62\xfc\x1a\x51\x26\x65\xb8\x50\x07\x89\x33\x97\xc9\x52\x9a\x4e\x96\x5a\x44\x07\x9a\x25\x26\x4a\x20\xe1\xd8\x7e\xfa\x32\x81\x7b\x02\x81\x40\x31\x48\xb9\xdd\x72\xa2\x58\xfe\xdd\xf7\x2f\x13\xf1\x53\x56\xec\xbf\x31\x07\x38\x63\x99\x12\xf8\xfe\x01\xe5\x59\xbf\xcf\xb7\x85\x8e\xe8\xdc\x77\xe5\x35\xa5\x05\xb7\x6d\xfa\xef\x34\x19\x89\xc9\x15\xf4\xeb\xc3\x79\x8e\xb1\x20\xf3\x2f\x54\xa6\x1e\x34\x22\x39\xec\x9c\x09\x08\x7c\xc0\x4f\x85\xb3\x22\x75\x28\x9e\x4d\xc6\x28\xc2\xd6\x8d\x84\x6e\x62\x2e\x65\x31\x08\x88\x22\x84\xa3\x82\x72\x0e\x25\x89\x17\x9e\x09\xc6\x14\xd3\x86\x8d\x8d\xf4\x9b\x01\xda\xa0\x67\x19\xa3\xe4\x74\xa3\x17\x20\x7d\x2a\xdf\xdd\xb6\x02\x37\xd0\x44\x48\xb7\xe3\x42\xad\x6c\x07\x67\x0f\xac\x5d\xaa\xd7\x72\x74\x39\x6d\x37\x32\x8c\xc9\x5a\xe0\x2e\x16\xf6\xbc\x54\x0b\xde\x36\x6b\x75\xb4\x93\x75\xcb\x4e\x9a\x06\xaf\x98\x90\x84\xe0\x84\xa2\x5e\xde\x3d\xfe\x95\x8b\xc5\x92\xe2\x42\x9b\x99\x61\x8d\x46\xc3\x5f\x8e\x18\x6c\x98\xa6\x85\x63\x59\x96\x81\x80\xfd\x40\x32\x6e\x36\x4a\x0d\xe3\x45\x61\x8b\x20\xbe\x05\x28\x07\x7a\xbe\xf1\x08\x36\xcf\x02\x9a\xa1\x69\x98\xdc\x64\x30\x08\x5b\x5c\xc1\x0e\x83\xc1\xb4\x49\x6f\xda\xbe\x9f\x66\xd0\x85\x00\xb2\x3c\xaf\xea\xe3\xf4\x10\x6a\x8f\xb6\x9c\x57\xed\xf0\x95\x7d\x05\xe5\x05\x1b\x02\x71\xf8\x16\x47\xa8\xb0\x39\xd5\x61\x4d\x81\x5c\x57\x57\x72\xe8\x21\xd4\xe4\x1d\x82\x28\x19\xcf\x5e\x81\x6b\xba\xe2\xeb\x9f\x3d\x73\x18\xa9\x08\xeb\xb4\x46\xa3\x8e\x2d\xeb\xa9\x9c\xdf\x0b\x6a\x48\x20\xd9\x1b\xe0\x4e\x51\xb8\x1b\xbd\xc8\x6b\xe5\xeb\x70\xce\xc3\xa8\x8b\x5d\x2c\x19\x2f\x15\xc4\x3f\x1e\xfd\xc3\x6e\x4d\x81\xee\x62\x3d\x80\x5a\xb6\xb0\x64\x79\xd7\xbb\xa2\x70\xa9\x51\x92\x2f\x7b\x42\x01\x35\x06\x54\xdd\x29\x8a\x7e\x0b\xe9\x0f\x2b\x15\x9e\xf5\xac\x88\x89\xbd\x18\xdb\x30\xf0\x93\x63\xbc\x02\xd1\x8b\xd7\x5b\xe9\x70\x95\x06\x1b\xea\xb2\x6b\x4d\x98\xa5\x5b\xad\x86\x4a\x25\x89\xa1\x85\xe8\xb7\x7e\x75\x44\x14\x2e\x37\x4a\x13\x77\x75\x77\x14\xb0\x16\xd3\x3a\xde\x6c\xd2\xc2\xcd\x7b\x83\xc1\xd9\xbb\x3c\xc1\xee\xba\x58\xb8\x72\x66\xf5\xc4\x71\x55\x05\x96\xe7\xef\x90\x8c\x97\x0b\x62\xc3\x86\xf6\x66\x91\xb3\x18\x66\x6b\x4c\x82\x91\x76\xc4\x5b\x17\x96\xad\xb8\xc0\x52\x16\x9c\x5e\x55\x1d\xad\xef\x89\x4f\x0a\xba\xc0\x8a\x5b\x3e\x70\x3d\x8c\x5b\xe3\x61\x6d\x45\x65\xc4\x89\x9e\x75\xb9\x0e\x42\x3d\x5c\xe5\xd2\x2c\x98\x55\x58\xeb\x1f\xe7\xb0\x99\xc5\x80\xbb\x62\x5c\x43\xd3\xb4\x71\x07\xde\xf4\x3c\x8e\x61\xa2\x1f\xe1\xfc\xbe\x32\x33\x27\x5a\x0f\x99\x00\xad\xa3\xc5\x40\x91\x63\x41\x87\xab\x22\xec\x0e\x48\xa2\xd5\x51\x1d\x6a\x9d\xb0\x48\x7d\x67\x7b\xd1\x3b\x6b\xcd\xc8\xe0\x02\xe0\xed\x2a\x53\x70\x98\x0a\x67\x9d\x87\xe3\x59\x01\x26\x94\x91\xc3\x33\xa1\xe0\xe5\xc0\xee\xc0\xd6\x9a\xbd\xa2\xf0\x80\xe3\xed\x1f\xdd\x0f\x4a\x04\x9d\xc6\xf6\x4b\xb3\x56\x7e\x1d\x63\x7d\x6c\xda\x77\x97\x5d\x9e\x4f\xd6\xd4\xee\x68\xf8\xcf\xeb\x70\xd1\x68\xf2\xfd\x7d\x52\x6d\x39\x8a\xb4\xc1\xb2\xb5\x82\x78\xf0\x71\xeb\xa3\xf2\xad\x66\x51\x34\x80\x8d\xaf\x6a\x8d\x17\x1b\xa5\x05\x73\x44\x01\x9d\xd8\x2c\x19\x2f\xc3\x79\x51\xb2\x65\xae\x48\x40\x0d\x91\xa8\x81\xca\x8b\xa4\x75\x5f\x40\x05\xf2\x57\x61\x4a\xb2\xdd\x4d\x11\x39\x6a\x31\xc2\x32\x52\x5f\x25\x92\x46\xe3\x6a\x24\xd3\xcd\x6c\xb9\x0e\x67\xe5\xe0\x92\x87\x50\xa7\x20\x31\x8a\xc0\xab\x6c\x7f\x23\xff\x4c\xa3\xd1\x89\xbf\x90\x74\xef\x4a\x41\xdd\x38\xfe\x67\x1a\xdb\xcf\x2c\x3a\xad\x46\xfe\xd5\xbb\xa4\xcf\xfd\x01\xf8\x95\x2d\xaa\x0a\x98\x26\x0a\xeb\x8c\xd2\x7c\x51\xe8\x35\x4a\x70\xa2\xd9\x6c\x16\xe5\x85\xa1\x85\xce\x45\x16\x70\xaf\x64\x16\x2c\xe9\xe7\x24\x63\xaf\x20\xce\x97\x8c\xeb\x04\x51\x7e\xd2\x28\xa9\xbc\xf7\x8a\xde\x51\x4f\x74\x75\xdc\xf1\x31\x57\x4a\x7e\xc9\xb2\x9d\x31\xf7\xe9\x64\x53\xca\xa8\xc6\x48\x7b\xfb\x70\x54\x57\x1f\xd8\x98\x7e\x49\x7e\x08\x7c\x4b\x16\x2c\x79\xc9\x78\x7f\xc6\x44\x9d\xb1\x5b\x43\xf7\x4b\xf4\xba\x97\x2e\x92\x13\xe0\x2e\x79\xcf\x7f\x9f\x3f\xd2\x91\x0d\x1d\xb8\x11\x95\x7d\xbb\x20\xe6\xf1\x0f\x69\x28\x03\x92\x76\x0a\xd0\x68\x7b\x1e\xea\x19\x52\x40\xb2\x5b\x1d\x75\x31\x29\xee\x73\xf8\x22\xe1\x00\x3e\x80\x94\x20\xe5\x80\xa2\x23\xd2\xa4\xc7\xd0\x01\x5a\x61\x92\xa6\xb3\xa5\xcd\x8d\x87\x74\xe6\xbd\xf8\xa4\x61\x5b\x3b\x4f\x67\x17\x1c\x78\x6c\xab\x87\xb3\x8f\x4c\x07\x00\x6c\x0b\xc8\xef\x7b\xc1\x5d\x57\x06\x26\x83\x23\x33\xef\x9e\x8d\x8e\x6c\xf4\xc9\xef\x12\xfc\xee\x77\xee\xe5\x9d\x47\x9c\xfc\x0f\x4f\xdc\x8f\xb6\x7a\x0b\xec\x7f\x13\xd7\xe7\x61\xdf\x35\x78\x73\xee\x62\x56\xa7\x33\xef\x77\xb1\x67\x81\x75\x67\xf3\xce\x3d\x4e\x7e\x25\x38\x77\x19\xeb\xda\x6f\xd6\xe9\xd8\x25\x1b\x71\x96\xeb\xfc\x8f\xa1\x31\x63\x3e\x28\x47\xea\x33\x83\x19\xbe\x1e\x4a\x26\x93\x69\xa4\x4a\xcb\xef\xa0\x1d\x74\xe8\x58\x32\xe9\x45\xbd\x34\x7d\xb3\xd3\x09\x7b\xd1\xaf\xa0\x83\xbd\x44\xd6\x56\x56\x96\xc1\x22\x93\xd1\xe0\x94\x6f\x06\xbd\x4e\xe5\xd7\x60\x34\xc9\x0f\xa8\x19\xb0\x7e\x5b\x7f\x8a\x62\xfe\x8a\xda\x31\x42\x4d\x25\x98\x43\x76\x4c\x7c\x22\x30\xbc\x2d\x10\xf5\x87\x6d\x01\x8b\x1f\x7d\x46\x71\x24\x05\x59\x22\xa1\x80\x05\x3b\x28\x3a\x6a\xe3\xd1\x88\x2d\x86\x81\x50\x3d\x34\x5d\x57\xc5\xf8\x09\x08\x69\x6d\x2b\x87\x77\xd0\xd4\x80\x76\x5a\x39\xe6\x5a\xf1\xc6\xed\xdb\x8c\x7c\x64\xe6\xb6\x8b\xe7\xdc\xda\x5d\x76\xab\x38\x55\x7a\xa9\x78\x63\xad\xc6\xcc\xe9\x8c\x5d\x1b\xdf\x4e\xf8\x6e\x9d\x53\x7a\xeb\xac\x9d\xbd\x2d\x27\x3c\x15\x53\x9a\x17\xd5\xce\xd2\x68\x1a\x43\x1d\x35\x13\xaa\x6a\x3c\xd2\x94\x82\x92\xe6\xda\xce\xf2\x09\x3c\xdb\xe4\x9f\x58\xd1\x14\x2a\x11\xe9\xe4\x93\x5d\x85\x87\xaf\x9c\x72\xce\xe4\x6a\x3b\x73\x6a\x10\x0c\x51\xa7\xc0\x53\x11\x70\x08\x80\xe2\x8e\x7b\x01\x18\xfa\x1a\x7e\x35\xc4\x17\x37\x9d\x9d\xbe\xa3\xa4\xbe\xa4\xc0\xc0\x41\xf9\xc7\x80\x66\x0d\x66\x97\xbf\x0a\x7c\xe3\x8b\xf8\x1c\x3a\x0e\x00\xf9\x35\x34\x3d\x68\x04\x47\x71\x95\x82\x8b\x41\xb0\x25\xd4\x78\x49\x6c\xe4\x77\xb0\x4a\xcc\x60\xde\x94\xcc\x50\x76\x01\xdc\x2c\x08\xe9\x07\xea\x4b\xa1\x37\x0b\x11\xe1\x45\xea\xe0\x6f\x05\x41\xee\x15\xec\xde\xd2\xfa\xc1\x81\x0c\xe2\x83\xc2\xe7\x91\xbd\x6f\x29\xfa\x6e\xa6\xe2\x36\x75\xf8\x2c\x18\x54\x7e\x78\x8c\xb6\xd5\x2e\x9d\x01\xa6\x7b\xe4\x3e\x7b\x1c\x3d\xb3\xd4\x2e\x74\xe4\x17\xa5\xfe\xa5\xb1\xa0\x28\x46\xa6\x99\x12\xc1\x8e\x8b\x9c\x7e\x3e\x57\x5a\x8c\x59\x95\xf6\x66\x75\x33\x20\x8c\x95\xc4\xf2\xa7\x1f\xd5\x69\x37\x87\x51\xce\x4b\xa8\x89\xd4\x1c\x54\xa3\x08\xa6\x06\x0a\xf0\x68\x32\x02\x0a\x0e\x53\x46\x7d\x52\x26\x1d\xa2\x55\xb1\x98\xe8\x2a\xd6\x06\x30\x85\x01\xf6\x82\xc1\x2c\x06\x00\x09\x1f\x36\x9c\x31\x2a\x61\x86\x82\x70\x80\x8f\xe0\xad\x14\x91\x98\xfb\x7f\x32\xd5\x80\xa9\xf0\x98\xf4\x97\x3a\xf9\xe7\x3a\xa3\x41\x2f\xa7\xf0\x4a\x5c\x8a\xf8\xb2\x60\xb7\x97\x8e\xf4\xd3\x60\xb3\x41\x8b\x49\xd3\x0c\xe2\x5f\x2f\x80\x71\xf9\x5a\xce\xa4\x17\xb4\xb6\x6f\xde\x92\x07\xa6\x57\xff\xab\x7a\xba\xfc\xe1\xe4\x8f\xef\xfe\x98\xe9\xfd\x5d\xb5\x99\xb1\x02\xbf\x61\xd0\x93\x01\x81\x32\x4b\x56\x96\x40\x6f\x9c\xec\x17\x2f\xfb\xe4\x2c\x68\x11\xb5\x5a\x1a\xd0\x5b\xff\xb2\x38\xfd\xb9\x46\xd4\x43\x08\x77\xd0\x97\xf4\xf5\x1d\x3c\xd8\xd7\x07\x0f\xa7\xfb\x14\xdb\x4f\x7e\xbd\xeb\x70\xbd\x83\xb9\x7a\xb3\xa7\xad\x37\x18\x51\x33\xfa\x3b\xdb\xe1\x7b\xd4\xfb\x8e\x61\xb5\x93\x4e\xdb\x0a\xd9\x6a\xff\x69\xac\x5a\xcb\x43\xb9\xea\x31\x17\x8f\x6a\x02\x1d\x92\xbf\x76\xa0\xfe\xeb\x57\x71\xd3\xb0\x5e\xd6\x40\x75\x62\x0c\xb9\xe0\x77\xbc\xe2\xe1\x2b\x06\x23\x1d\x21\xce\xb4\x0f\x07\xc6\xae\x32\xe3\xcd\x5f\x59\xc0\xaa\x7e\x92\x74\xe4\x24\xd9\x91\x49\xe7\x04\x29\xb2\x73\x8a\x22\x3b\xe8\xb7\x67\xac\x5a\xe7\x41\xbf\xff\xf3\x0c\x49\x65\xba\xcb\xd4\xdf\x94\xab\xff\xc8\x5a\x9e\xbe\x3d\x46\xad\xa0\x9c\x61\x9f\x19\x56\x01\xd9\x3b\x76\x6b\xc0\xfe\x11\x75\x1e\xd6\x1a\xb9\x76\xf2\x66\xab\xb2\x65\xac\xa6\x00\x5b\xce\xdc\x00\xa4\xcf\xb3\xaf\xab\x7d\xbe\x1d\x7b\x04\x07\x89\x91\x9f\x58\xee\x4f\xdf\xe7\x83\x56\x0c\xed\x1d\x0e\x85\xe3\x8a\x1c\x1a\x0f\x60\x5e\x42\x35\xea\x09\x7f\x00\x18\xc0\x00\xc9\x08\xd8\xed\x02\xf3\x91\xb0\x13\x17\x35\xd5\xb5\x76\x76\xd4\x4e\x4e\xdf\x79\x9a\x4a\x7f\xee\xaa\xef\xde\x3e\xa9\xb5\xca\x29\x86\x4d\xe6\x60\x68\xde\x1a\x33\xb4\xcd\xae\xe8\xfb\xc1\xc1\x73\x77\xdd\xeb\x91\xcb\xef\x07\x90\xd7\x88\xad\x73\x52\xbb\xfe\xd8\xd6\x37\x6d\x4b\x57\x6c\xc1\x58\x75\x8e\xb7\xee\x38\x77\x4e\x8d\x59\xc3\x6f\xe6\x19\xe3\xf6\x85\x8e\xc2\x6b\xd7\xac\x3f\xf4\x1c\xac\xde\xb2\x05\x3c\xc2\x3b\x59\xb3\xc1\x28\x36\x2e\x78\x26\xbd\x85\x1a\x55\xf7\x38\xf1\x86\xce\xd5\xfd\xbb\xc7\xb9\x11\xd5\x93\xbe\xab\x39\xbe\x47\xdd\xdf\xcc\xaf\xdf\x2f\xbf\xa3\x21\x18\xb5\xf2\x83\x3f\x1a\xab\xf6\x43\x23\xab\xc9\x46\xc6\x6c\x8f\x0c\x6e\x64\x42\x5d\x87\x5d\x9a\x00\x00\x40\xff\xbf\x79\xeb\x8a\xc3\xc6\xc8\x75\x3f\x16\xa3\x0c\xda\x79\x3b\xe1\x12\xe3\x78\x8c\xcd\x0c\x08\x6d\x2f\x31\x1b\x13\x48\x42\x0c\xc7\x0a\x15\x44\x5f\x9b\x15\x93\x82\x41\x1e\x2f\x2f\x51\x21\x97\x3b\x18\x74\xbb\x42\xfd\x21\x97\x4c\x6c\xbc\xc0\xeb\x0a\x31\xfd\x71\x13\x5d\x65\xb1\x98\xc2\xda\xc6\xc4\x65\x25\x5d\x96\x89\xb7\x2f\x9c\xb1\x2b\xe0\x0a\x95\x14\x38\x7b\x6b\x3a\x7c\xa2\x4b\xab\xe5\xf5\x85\x56\xc9\x55\xd5\x59\xed\x33\x69\x81\x24\x89\xb4\xa0\x61\x80\x6d\xe6\x16\x62\xb5\x41\xf7\x84\xee\x6c\x00\x07\xfa\x5d\xd0\x56\xe1\xed\x6a\xa9\x6f\x69\x08\x6e\x9a\xd4\x05\x8b\xdd\xae\x72\x00\x82\x2e\x78\x49\x41\x10\xc2\x2d\x89\x85\x3e\xb1\x39\x58\x16\xae\x68\xb6\x4a\xb6\xe2\xda\xd2\x66\x8f\x33\xd4\x55\xe1\xe7\x9c\x56\x61\x8b\xba\xe6\x8f\xc6\xfd\x04\x89\x31\x73\xab\x38\x8c\xd9\x97\x37\x52\x83\x0f\xda\x6d\x44\x1b\x86\x0e\xec\x04\x43\xe0\x8c\x31\xf9\x2f\x54\x68\x8c\xd5\x26\xc1\xed\xd1\x44\x63\x0e\x35\xf2\xc7\x5b\x4f\xd7\x10\xeb\xe3\x60\xf3\x4c\xf9\x6f\x8c\x46\xa0\x45\xd1\x0a\xb4\x26\x5f\x75\x67\x95\x4b\xb2\x16\xea\x79\xad\xd6\x25\xfa\x3a\x6a\x7a\x9d\x05\x25\x21\x57\x60\xd7\x8c\x85\xb7\x4f\xb4\x74\x95\x5c\x96\x68\xd4\x86\x4d\x16\x4b\x15\x4d\x67\x5a\x22\xfd\x17\xa5\x0d\x48\x7b\x3c\xdc\xb2\x68\xe6\x16\xc1\xea\xe4\x82\xa5\x33\x42\x4e\x4f\x73\x69\x6d\xb1\x4d\xb2\x36\x57\x84\xcb\x82\xcd\xa2\x6f\x61\x62\x0b\x84\xc1\x02\x78\x89\x2b\x08\x40\xb9\xcb\x5d\x0c\xbb\x26\x6d\x0a\x36\xa0\x86\xeb\xf2\x62\x14\xfa\xcc\x5a\x86\x96\xd8\x91\xca\xa9\x16\xd4\x1a\xab\xa9\x8b\xa9\xab\xa8\x3b\xa9\x47\xa9\x5f\x10\x5e\x13\xec\x19\x8f\x57\xc9\x22\x18\x5a\x2d\x88\x04\x46\xf4\x7f\x94\x45\x7f\xaa\x11\x2f\xa2\x2e\xdf\x5b\x58\xd5\x47\x08\x65\xc1\xe2\x23\x5e\x65\xb0\x59\x33\x2c\x31\x68\x40\x24\x4e\xb0\x45\x20\x60\xb3\xa2\xdc\x75\xb1\x3a\xcc\x69\x84\x83\x34\x6a\x41\x1d\xa1\xa5\xf3\x79\x09\x3a\xa9\x0a\x7e\xe9\x25\xfd\x0c\x89\xf7\x7c\x38\x40\xc0\x30\x6d\x11\x4c\x74\x4a\x3c\xb6\x90\xb8\xa4\x2c\xdc\x61\x20\x0e\x8b\x5a\x8e\x80\x5a\x8e\x51\x0b\x78\x37\x15\x59\xcc\x66\x4b\xd1\xd3\x13\x27\xa6\x5f\xe8\x9e\x36\x13\xfc\xa4\x3d\x1c\xf4\x69\xb9\x89\x00\x08\x56\x3b\x68\xe3\x0d\xe3\x02\xbe\xf6\x76\x6f\xc9\x38\x03\x3f\x08\x69\x83\x3b\x5a\x57\x64\xb3\x16\xad\x75\xdb\x2e\xf3\x3b\x39\x20\x5f\x92\x48\x40\x9b\xa4\x9b\x58\x7e\x85\xfc\x77\xf9\xb3\x2b\x2a\x26\xe8\xac\x56\xdd\x84\xf2\xfd\x30\xb4\xbf\x1c\xa5\xd3\xc6\xb3\xa6\x47\xa2\x33\x79\xaf\x26\xa0\x9f\x06\x7c\xb6\xa2\x9a\x88\xdb\x66\x73\x47\x6a\x8a\x6c\x4f\xb4\xb7\x13\x38\xeb\x76\x4e\x8f\xee\x0e\xbe\xce\x5f\xe0\xf9\xe4\x8e\x5a\xf3\x80\xf9\xa8\x3f\x12\xf9\xeb\x64\x79\x31\xb8\x7f\xf2\x1e\xf9\xba\xd2\xca\x42\x4b\x10\xf8\xe5\x7f\x3a\xa1\xa9\x18\x38\x37\x1e\xaa\xb3\x95\x8d\x2b\x01\x9f\xdd\x55\x5a\x66\x7b\x52\x5b\x24\xd8\xc5\xd2\x90\xbb\xe9\x92\x26\x77\x28\x54\xd4\xd0\x35\x21\xe2\x02\x06\x9b\x9e\xae\xbf\x3d\x12\xb9\xbd\x2e\x4d\xff\x64\x6e\x45\x13\x6b\x32\xb1\x4d\x15\x0b\x8f\x3d\x32\xaf\xbc\x19\xa7\x9b\xcb\xe7\xd1\x4d\xa0\xf4\x97\xbf\x74\x2c\x75\xac\x8b\xff\xfa\x82\xbd\x8d\x45\xe8\xda\x46\xb2\x71\x37\x83\x2d\xf2\x5f\x8a\xcd\xd0\x09\xcc\xf2\xef\x83\xa2\xbb\x12\x68\x86\xaf\xe1\xa2\xaf\x03\x8d\x97\x7f\x21\xf1\xb2\x99\xfe\xb1\x84\x5a\x45\xed\xa6\xf6\x53\xb7\x51\x0f\x13\x3d\x1d\xa3\x14\xa2\x77\xcd\x22\xa1\xa7\xae\x36\x18\xc1\x78\xba\x96\x88\x6f\x8c\xd7\x92\x79\x79\x51\xd4\x3b\xa2\xe4\xe5\x05\xa3\x01\xd2\x61\x5a\x40\x64\xd4\x8b\x8d\x63\x86\x1b\x3f\xda\xad\x25\x0c\xb8\x3c\xe7\x25\x5d\x04\x43\x86\xa3\x5e\xe1\x25\x3d\x04\x44\x68\x74\x77\x0c\x9e\x1c\x91\x32\x7d\x4f\xe9\x67\xb8\xef\x05\xc7\xe8\xa1\xf4\x2b\x61\x87\xdd\xee\x08\x83\x39\x67\x9d\x35\xd4\xb8\x41\x7e\x69\xfd\x6a\xe0\x5d\xbc\xd8\xe3\x16\x69\xb0\x58\x63\xa8\x1a\x1f\x03\xc7\xb4\x96\x58\x6d\xf9\xe2\xc5\x95\xe3\x63\x16\x2d\x98\xb3\x04\x0d\x6b\x55\x8f\xb9\xc3\xed\x1d\xe1\xc2\xa2\xf0\xa4\xa9\x48\x51\x81\xe9\xfe\x05\x0b\xe0\x1b\x2e\x61\x51\xe3\xd3\x69\xd7\xd3\x8d\x8b\x8d\x2e\x94\x6e\x7a\x0a\x7e\x4c\xd2\x43\xae\xb5\x17\xae\x16\xaa\x83\x85\x7d\x53\xc0\x93\x85\xa1\x8e\xf6\x50\x61\x61\xa8\xbd\x23\x54\x08\x66\x2d\x89\xd6\x56\x19\x35\x4b\x00\x2d\xba\x3d\xa0\xe4\x3f\xdb\xed\xa0\xd2\xde\x51\x55\xd5\x71\x78\xf9\xf2\xf4\xaf\xc0\xe7\xf2\x0f\xca\x6c\xb4\x17\x9c\x23\x5f\x58\xe3\x0c\xb6\x2c\x7f\xa1\xd3\x55\x1f\x7b\x2f\xbd\x7e\x7c\x3c\xee\x9e\x6b\x8c\xe8\x4a\x26\x2d\x5c\x37\x2b\x18\x89\x04\x67\x1d\x43\x9b\xa8\xdb\xad\xa5\x7f\xf1\xd6\xa4\x49\x6f\x4d\x4e\x2f\xfc\x74\x5b\x53\x37\x67\xb3\x71\xdd\x4d\x9b\x3e\xc7\x69\xde\x6a\xe5\x51\x9a\x11\xe4\xcd\xf2\x3f\x80\x69\xda\x81\x75\xf3\xe4\x6f\x27\x3f\x3c\x1b\x5d\x1d\xea\x7e\xb8\x1b\xdf\x64\x8e\x6c\x8c\xb7\x06\x9d\x11\x70\x40\xbe\xce\x07\xed\xe5\x60\xb7\xe2\x4b\x89\x79\x73\xff\x4d\x49\x38\xfa\x1f\x70\x8a\x06\x1d\x97\x6a\xc3\x19\x85\x19\xaf\x0a\xdb\x32\x8b\x32\x20\x06\xf0\x41\x38\x5f\xf7\xb5\x3b\xf4\x85\xcd\xaa\x4b\x03\x70\x97\x41\xaf\x75\x7c\x51\xea\xa2\x5f\xd6\xeb\xd3\x5f\x82\x6e\xbd\x4e\x67\xff\xa2\xcc\x29\x1f\x13\x21\x28\x08\xff\xc3\x4e\xaf\x11\xe5\x69\x55\x7e\xcc\x5b\x80\x5e\xa1\xc9\x54\x09\x56\x9b\x6d\x43\x67\x81\xf4\x2d\x56\x8b\xa9\x12\x9e\xe7\xa5\xaf\xa9\xcc\x8c\xd1\xca\xd8\x24\x65\xf9\x45\xf0\x7a\x0f\xb6\x20\xd8\x68\xce\x81\xbd\xb0\xe2\x80\x1c\x01\x76\x40\xf6\x62\x61\x80\xc4\x70\xc7\x28\xe3\xcb\x1e\x5b\xf1\xd3\xa2\x86\xd7\xec\x7e\x5e\xab\xd5\x98\x9f\x29\x96\xe8\x38\x6f\x79\xd6\x23\xc9\x6b\x90\xba\x6d\xf5\x3e\x2d\xf2\x1a\xad\x3c\x04\x6e\xd1\xfc\x7e\xd8\x22\x35\x0d\x3e\xf0\xeb\x0d\x96\xdf\x02\xf9\x87\x82\x60\x2c\xa1\x67\x1b\x02\xe9\x30\x94\x7d\x01\xa4\x60\x83\xf7\x01\xfc\x4f\xf3\x15\xa3\x31\x6b\x28\x1d\x4f\x31\xff\x46\xa9\x4e\xb2\x86\x2f\xd5\x32\xc5\x00\x83\xde\x2b\x6c\xf6\x45\x00\x53\x73\x9a\x80\x80\xf4\x04\x5f\xa8\xa4\x1a\x2a\x33\x09\xea\xd9\x2d\x20\x44\xf8\xe6\x5b\xb9\x48\x0c\xfe\x0a\x7c\x24\x17\x3e\xf3\x00\x68\xe8\xec\x04\x5e\xc1\xe7\xf4\x7a\x04\x4e\x0a\xa3\x52\x02\x20\xf1\x25\x82\x20\x78\xbc\x4e\x1f\x1a\x21\x06\xe5\x2b\xde\x90\xdf\x18\x5f\x53\x52\x12\x9c\xe0\x1c\x9d\x43\xf0\x82\x41\x70\xf3\xc9\x34\x58\xa7\x65\x19\x9a\xe6\x74\x66\x87\x89\x2b\x58\x1a\x4f\x5c\x37\xae\xf4\x8a\xeb\xae\x8b\x2f\x46\x13\xb2\xc3\xa4\xe3\x68\x5a\xc2\x2c\xd5\x0c\xab\xf3\x16\x8c\x3a\x6f\xc6\xe7\x45\x4a\xc1\xc1\xe2\x52\xec\x01\x62\x5b\xc5\x0c\xc8\xc5\x68\x58\x60\x6c\xc0\x16\xe6\xa3\x20\xea\x40\xff\xe2\x36\xad\x01\x29\xec\x9f\xcb\x3f\x92\xed\x6c\x85\x6c\x47\xfa\xb8\xe3\x7a\xb0\x00\x00\xb0\x30\x3d\x1b\x2c\x90\x45\xf9\xc7\x6c\x15\x98\x23\x3b\xe4\x07\xc1\x42\xf0\x89\xfc\x63\x59\xa4\x5b\xe4\x37\xe4\x3f\x83\x36\xf9\xa3\x73\xe4\xdf\x13\x3e\xf6\xe0\x39\x3d\xa0\x10\xb3\xa5\xc9\x1f\x31\xbf\x95\xff\x2c\xbf\x09\x04\xf9\x9f\xf2\x3f\xe4\x9f\x83\x22\x7a\x8f\xfc\x73\xf9\x9f\x60\x3c\x12\xde\xf5\x68\x5c\xfa\x8a\xf8\x98\xe8\xd1\xc8\xa4\x94\x07\xe3\x3f\x07\x2c\xe8\x2f\x18\x67\x79\x4c\x49\x8a\xff\x68\xc0\x6b\xb1\xe7\x1b\xab\x1d\xbc\xbb\x9f\xbd\xb3\x7f\x68\x8e\x8f\x36\xf9\xd2\x8b\xda\xe1\x3b\xed\xe9\xff\x5e\x0b\xd7\xae\x7d\x0f\x7c\x90\x94\x03\xe9\x47\x69\x6f\x0f\x18\x48\x27\x61\xb2\xe2\x8e\xfb\x6e\x87\xae\x43\xf2\xb1\xeb\xe0\x93\xbb\xd2\xa7\x76\xd1\xbb\xd2\x17\xf7\xc0\x4b\x4e\xde\x75\xe4\xc8\x18\xbe\x17\xb3\xa8\x75\x39\x2f\x97\x0c\x18\x6d\x06\xe7\xb6\xc4\x1f\x42\x72\x11\x96\x8e\x68\xbb\x95\x53\xfa\x80\x87\x8e\xd5\xda\xb1\xf4\x04\xe2\xad\x74\x88\xa0\xd8\x62\x39\x82\xa6\xcc\x79\xe3\x9c\x39\x37\xcc\x65\xdc\x34\xbc\x1f\xcb\x4f\x7f\xfc\x31\x98\x0a\xe6\xc4\xba\x62\xb1\x2e\x79\x8a\x70\xe5\xd4\x0b\xe7\x17\xd5\x76\x59\xf5\x26\x16\xb7\x1c\x6b\xd2\x5b\xbb\x6a\x8b\xe6\x5f\x38\xf5\xca\xd3\x9f\x82\xe7\xb1\xba\x8f\xde\x5c\x24\xc7\x16\xbd\xf9\x91\x8e\x25\x69\xf0\x32\x4e\x43\x3b\x71\xe8\x00\xf7\x2a\x4f\xf9\x98\x3c\x24\x96\xfc\x9e\xb7\x1d\x7e\x4a\x3e\x6f\xf4\xfd\x49\x7a\xd8\x77\x6d\x22\x38\x1f\x23\xfd\x65\x22\xd9\xc8\xd7\x4c\xb4\x0a\xa1\x3a\x52\xbe\x34\x70\xeb\x45\x8f\x5c\x74\xd1\x23\xf0\x11\xb2\xc9\xf0\x18\x29\x5f\xe0\xd0\x03\xf8\x98\xfa\x2f\xff\x39\x10\xcd\x5e\x98\x07\x5c\xf2\xb1\x11\x2d\x88\xc4\x7d\xc3\x5c\xb5\xa8\x5f\xcb\xe7\xc1\xd8\x72\x39\x2a\x47\x97\xf7\x42\x1d\x18\x1c\x89\x94\x70\x48\x7e\x7d\x00\x3e\x96\x9e\xd1\x0f\x6a\xc6\x8a\x4f\xee\x66\x2f\x61\xef\x41\xfa\x04\x8e\xae\x6c\xc7\x7d\x01\xd8\xb9\x30\x8e\x33\x8a\xa1\x77\x57\x85\xc9\x72\xd1\x4b\x44\x6f\x53\x42\xef\xb9\x84\x45\xbd\x01\x3b\x4e\x23\x69\x51\x22\xf1\x10\x48\x86\xa4\xd1\xfc\xd5\x06\x90\xb8\xe3\x01\x9c\xc4\x11\xdc\x85\x20\x3a\xcc\xe0\x33\x98\x33\x23\x5e\xc2\x62\xdf\x0f\xba\x5a\xb3\x3d\x1a\x2e\x2a\x0c\x95\x74\xc6\x37\x0a\x2f\xae\x6c\x9b\x4e\x33\xd7\x2f\x5d\xb2\xf3\x23\xeb\xd4\x8a\x1a\xf9\x03\xf9\xb3\xf2\xaa\x84\xe8\x59\x1a\x6f\xfe\xe8\xfd\xb6\xe8\xd2\x05\x1a\x93\xb1\xa2\x64\xc1\x1b\x2f\xac\xab\x9a\x32\x27\x61\x2d\xf0\x72\xe2\x1f\x61\x7c\xc0\xc6\x99\x9f\x70\xcd\x67\x2b\xca\x7d\x43\xf2\xad\xdf\x1c\x32\xd9\x8c\x2c\x0f\xb5\x01\x9b\x4b\x4b\x17\xf9\xeb\x4b\x3c\xbb\x8f\x83\x5d\x60\xdc\x6d\xcd\x66\x00\xef\x6b\xeb\xf2\x5a\xe6\xcc\xb1\x88\x86\x26\xcb\x86\x2d\x15\x85\x17\x4e\x5a\x92\xd4\x68\x6e\x86\x3b\xdd\x01\xad\xa6\xba\x86\xd7\xf9\x5d\x85\x01\x2d\x5f\x54\xa8\xd1\x04\x86\x44\xd7\x9a\xf6\x4e\xeb\xf8\x6a\xda\xa2\xb1\xfa\xa3\x81\x9e\xe7\xcd\xda\x1b\x6e\xe0\xfc\xf5\xf4\xd3\xf7\xcb\x4e\x4f\x5d\xa1\x65\x4f\xc8\xbd\xc9\x50\x34\xce\x5d\xa7\xad\x7d\x69\xd7\x43\x53\x5d\x95\x1e\x8f\x49\x5f\x25\x06\x17\x56\x75\x59\x5b\x09\x0e\xac\xf2\xae\x34\x64\xb4\x6f\x44\x3a\x39\x61\xb7\x0e\x11\x2a\xe2\x58\x9c\x84\xb3\x93\x50\x7d\x09\xb7\x0f\x1e\x33\xb1\xf2\x81\x46\x55\xa9\x2e\x16\x0a\xa3\x8f\xc6\x04\x08\x87\x21\x6e\xd8\x18\xe6\x53\x60\x39\x5e\x69\x6b\x0f\x8d\x8e\x33\x58\x57\x11\x47\x09\x86\xdd\x73\x4a\xca\x41\x79\x78\xde\x34\xcd\xa2\x7d\x7d\x34\x8c\x57\x4e\xbe\xf6\x49\x6b\x7b\xb8\xe2\xb6\x07\x2b\x42\xed\x36\x63\x95\xdf\xf3\xe2\x5b\xbe\x92\xda\x7a\x3d\x6b\xba\x4b\xee\xbd\xdb\xc0\xba\x4c\xd5\x77\x7c\xfb\x98\xdf\x63\xba\x5c\x6b\x29\xdf\xf4\x5b\xf9\x1f\xfb\x96\x87\xca\x23\x8c\xc6\x5e\xc2\x01\x0d\x27\x1a\xd7\x3f\x06\xe8\x27\x9c\xc5\xc5\xcc\x78\x50\x3a\xcc\x9a\x77\x6b\x79\x95\xdd\xba\x5e\x74\xc4\x5a\x26\x9e\x67\x58\xda\x5e\xb3\xc8\x5a\x3c\x07\x34\xda\x5c\x1c\x6b\xb5\x72\x7c\x81\x55\x72\xf2\x48\xb1\x60\xf9\x82\x34\xcd\x87\x0b\x98\xbe\x3e\xce\x70\x6b\xfd\x6c\x77\xd5\x2a\x69\x42\x1f\xfc\x55\xd4\x1e\xf7\xb5\xb9\x0d\x7e\x93\x75\xbc\xa7\xe3\xaa\x97\x4b\xd8\x3a\xab\x5f\xdf\x6d\x2d\x5c\x62\xb4\x86\x6c\x40\x0f\x6a\x47\xcc\x43\x80\xea\xc0\x31\x60\xa8\x59\xfd\xd8\x1e\x88\x87\x95\x2a\x1a\x49\x62\x51\xd4\x9f\x08\xc2\xa0\xcf\xe6\xb3\x58\x3d\xa8\x05\xe9\x47\xba\x1d\x8f\x2c\xee\x3d\xb6\x69\xa6\xef\x81\xa9\x5b\x3a\xc6\x5b\x59\xc0\x33\xff\x0d\x66\xc8\x8f\x1a\xbd\xed\xe3\x67\xbe\xf1\x59\xa0\x15\xc0\xfa\xa5\x17\x5c\xd0\x08\xbd\xef\xba\x16\x2e\xdb\xb8\xb0\x92\xe5\xe5\x45\x43\xe9\x93\x9e\xba\xa8\x07\xc0\x7c\x3b\xbf\xc2\x20\x1b\x46\x53\x5b\x15\x8c\x5a\x7c\x51\xec\xd0\x81\x06\x3e\x1e\x09\x84\xf8\x59\xad\x60\x94\x2d\x74\x53\x6b\x45\x53\x49\x5d\x81\x0e\x80\x53\xd4\x71\x0d\x60\x0b\xa2\x6b\x3a\xf6\x96\x2f\xbc\x6d\xd5\xa4\xcb\xc1\xdd\xf9\xed\x37\xfd\x29\x3b\x70\x94\x8e\x73\x80\x6b\x7e\x01\x26\xeb\x2a\x16\xf4\x2e\x28\xb8\x4f\x5e\xde\xb0\xad\x6f\x02\x04\xe3\x99\xea\xe1\xb6\x50\xfa\x54\x02\xa6\x51\xdd\x31\x6a\x8f\x7d\x6c\x95\x1e\x7e\x65\x36\xca\x77\xeb\x8c\x82\x4e\xbe\xc3\xa8\xd1\x5a\x55\xbc\x40\xa4\xb4\x99\xe5\xa4\x4e\x07\x92\x66\x49\x62\x88\xcd\x62\x30\xe3\x53\x42\xc1\x34\x9b\xc2\xf7\x54\xfd\x56\xb2\xb0\xc9\x71\x35\x48\x0c\xa6\xb3\xf7\xb1\x99\x8d\x60\x39\xbe\x3b\x58\x65\x64\x24\x69\x90\x38\x70\x33\x03\x21\x33\x40\x37\x97\x93\x66\xe5\x1d\x25\x00\xcd\x53\x74\x9a\xdc\x33\x83\x82\x9f\xc1\xc0\x77\x28\xe0\x19\x3c\x85\x4b\x30\xa2\x50\x70\x60\xf8\x33\x56\x0a\xa4\x06\x8a\x1f\x32\xa0\xb9\x94\x7a\x4f\xc5\x2e\x3d\x1c\x3d\x1f\xb3\xea\xa4\x70\x11\x46\x94\x0a\x5e\x8a\x9a\xe2\x4e\x41\x93\x5f\x05\xd4\x40\x59\x7f\xfc\xcd\xa8\x3d\x43\x24\xea\x51\x55\xe7\xb0\xb0\x1e\xf0\xd3\x30\xaa\x4a\xdb\x58\x66\x27\x1a\x9f\xc2\x11\x0a\x32\xdc\xaa\x0a\xd1\x9d\xc3\x6a\x67\x37\x87\xe7\x5d\x92\xac\x59\xb2\x60\x42\xcb\xec\xd9\x91\x9b\x6f\xbc\x7e\xf3\xe6\xa3\x53\xd7\xf7\xfa\x2b\x57\xae\x9d\xb2\x63\x79\x5d\xdd\xac\xc0\x84\x03\xf2\x87\x45\x9e\xb6\x58\x2c\xd8\x4e\x4f\x9f\xf6\x08\xa0\xd1\x0c\x33\x61\xf7\xee\xe7\xbd\x5e\x9f\x1f\xed\xb0\xff\xfc\xe8\xd0\x41\x8f\xc7\xef\x9f\x50\x92\x68\x8f\x2c\xdf\x7c\xd1\x8b\xcc\xce\x96\xe9\xd3\xdb\x62\xa2\x9e\xbb\xf1\x9c\x0d\xe3\x68\x33\xcd\x18\xb2\xfe\xfc\x04\x8b\x5c\x91\x0e\x28\x60\x09\x5a\x08\x9b\x93\xba\x85\x3f\x4a\x2f\xc0\x7f\x5c\x72\x68\x3b\x76\xed\x82\x62\x7a\xfb\x72\x58\x09\xff\x2b\x7d\x2e\x8c\xa6\x77\x0c\x7d\xbe\x1b\xde\x48\x9f\x37\xf4\x31\xbc\x03\xbb\x75\x2b\xb8\xb3\xec\x1e\x32\xdf\x17\x22\x49\x74\x06\xd2\x81\x28\xaa\x36\x46\xe6\x27\x46\xdd\xb2\xca\x2c\xa6\x74\x6e\x05\xca\x92\x04\x54\xb6\x60\x75\x97\x2c\x2e\x84\x89\x8d\x10\x07\x5a\x62\xef\x7a\xec\xc9\x5a\x8c\xdd\x18\x70\xa0\x38\x4f\xbe\x0c\xf5\xc3\xa8\xb5\x83\x0f\xbc\x0e\x87\xd7\x0e\x8e\x7b\xed\x76\xaf\x63\x68\xb0\xac\xb9\x69\x41\x73\x33\x33\x2b\x51\x39\xbd\x79\x41\xf3\x81\xe6\xf2\xb2\x66\x30\xad\x2a\x01\x7f\xbc\x21\x39\xb4\x2a\x79\xce\x14\xde\x60\xe4\xa7\xae\x78\x7b\xc5\x54\xde\x68\xe0\xc1\x61\x7c\xbe\xb9\xac\xbc\x99\x29\x72\xe0\xfb\x28\xff\xde\x68\x2e\x93\xe7\x94\x37\x37\x97\x83\x1f\x97\x35\x4b\xe9\xb5\x55\x89\x3f\xe3\xbd\x3f\x2b\xbf\x89\x2a\x78\x2b\xb8\x31\xfe\xc2\xf6\xed\x2f\xc4\x2f\x35\xf2\x9c\x61\x5f\x59\xd9\x3e\x03\xc7\x1b\xd3\x37\x66\xae\x2a\x6f\x6a\x42\xf3\x28\x96\xbb\xbe\x25\x9c\x1b\x26\xca\x0f\x34\x48\x15\x08\x82\x08\xe8\x04\xff\x20\x78\x2a\x01\x4c\xe9\x54\xeb\xe0\x42\x3c\xaa\x14\x08\xe1\x71\x87\xe7\xf0\xf8\xdd\x4a\x37\x83\x10\x12\xe0\xb1\xc0\xa3\xc8\x3b\x78\x99\x04\x9d\xc4\x92\x0f\x99\xe9\x42\x31\x75\x39\x05\x0f\xf2\x68\xd4\x8f\xc7\xea\xa2\xe8\x30\xe7\xb0\x06\xaa\x50\x37\xc6\xc4\xf4\x1c\xe6\x40\xc2\x9a\x21\x4f\x02\xa0\x1c\xb5\x76\x8e\x04\xaf\x92\x29\x96\xc6\x63\x3f\x8d\xa7\x04\xa0\x70\x9c\xa0\x59\x22\xa4\xcc\x08\x68\xfa\xc4\xc1\x23\x02\x5e\xb1\xc1\xde\x86\x56\x01\x92\x21\xd1\x8e\xb3\xe0\xf7\x40\x4a\x49\xbc\x2b\xc9\xd5\x1e\x68\x8b\xa1\x19\x06\x0d\x58\xe8\x6a\x12\xc8\x8f\x33\x10\x03\x6e\x0c\xcf\x41\x91\x56\xa4\x70\xe0\x02\xd9\xec\x8e\x5a\x9e\x43\xba\x2f\xae\x12\xa3\x4c\x55\xe1\x3a\x34\xe7\xfb\x71\xd2\x61\x45\x17\xd7\x61\x61\x2e\x20\x60\xb1\x1f\x4d\xfb\xf8\x0e\xb5\x31\xe0\x81\xb8\x38\x80\x40\xb3\xd0\x04\xbc\x08\x0d\x93\x61\xa5\x29\xf0\x03\x70\x23\x60\xe9\x10\x44\x49\x11\x71\xe1\x68\xde\x8a\x1a\x92\x94\x10\xaf\xbb\x91\xd5\xb8\x10\x3e\x49\xd6\xe1\x50\xbd\xe3\xca\xfc\x18\x21\x60\x36\xbc\x9a\xd7\x4e\x24\x4f\x72\x5b\xd4\x46\xb8\x59\xd5\x1b\xab\x2d\xed\x61\xe1\x4d\x7a\x2d\xc3\x4a\xec\x52\xc6\xa4\x73\x6a\x68\xf9\x36\xa4\x05\xd0\x34\xaf\xd3\x32\x16\x06\x40\x08\x20\x3d\x3f\xce\xf0\x34\x0d\x79\xa0\x05\xba\x69\x01\xa7\x6f\xa1\x4f\x1f\x2e\x36\x01\xbd\xd6\x26\x1a\x8d\x40\xf0\x17\xd8\x19\xc6\xaa\x0f\x9b\x9a\x38\x0d\x67\x2f\x08\x16\xea\xf4\x22\x92\x2a\x2c\x05\x76\xf3\x06\x11\x68\xc7\x15\xd0\xc0\x5f\xe8\x2e\x82\x40\x6b\xe1\x75\x1c\xa3\xe7\x2d\x00\x58\x9d\x16\x2b\x00\x76\xad\x26\x0c\x8c\xac\x4e\xb0\xeb\xdc\xf6\xea\x38\x2c\x73\x7b\x59\xad\x9e\xa5\xb5\x06\x6b\xa7\xb6\xc2\x55\x10\x43\xd3\x82\xb9\xa0\xcc\x12\xf2\xfb\xdc\x76\x23\x84\x1c\xa7\xe7\x8d\x74\xe1\xac\x98\xdd\x56\x66\xa7\x81\xa7\xc8\x28\x3a\x66\x69\x20\xe0\x34\x36\x2f\x03\x39\x86\x85\xb0\xa4\x8a\x2d\x65\xac\x0f\x68\xcd\x74\xb1\x47\x53\x26\x54\x85\x19\x23\x07\x68\xab\xae\xea\x82\xcb\x2a\x1c\x7a\x03\x44\xcf\xe4\x6c\xb4\x03\x42\x0b\xb4\x9b\x4a\x40\xfb\xcc\xf4\x5d\xb4\x9e\xd3\x42\x5a\x47\xd3\x7a\x1a\xdc\x03\xb5\x16\x8e\xd5\xb2\x1c\xa4\x85\x32\x51\xab\x7f\x5c\x67\xa0\x39\x86\xa1\x05\x46\x03\x63\xac\x91\x36\x69\xb5\x2c\x0d\x81\x0e\x32\x8c\x46\xd0\x00\xb3\x00\xe3\x56\x3b\xe4\x9d\x8e\xa0\x2b\xa4\x09\xad\x28\xb4\xac\x0d\x89\x0e\x9d\xdf\x53\xb1\x40\xea\xb2\x56\x4c\x29\x89\x14\x16\xdd\x9b\x90\x12\x25\xe5\x4e\x56\xe7\x07\x00\x0d\xe1\x3a\x61\x81\xc5\xe3\xb4\x45\xbd\x11\xbf\xd6\x28\x42\x03\xcb\x00\x3f\x4d\xfb\xad\x97\x04\x9c\xab\x27\x38\xca\xcb\x69\xd1\xaa\xbb\x70\x7c\x47\xa5\x9e\x41\x83\x9f\xe8\xe1\x35\x41\x7b\xc8\x7a\x9e\x60\x60\x60\x5d\x77\x78\x42\xb4\xaf\xa4\x61\x12\x8b\xe4\x84\x55\xf1\xc5\x26\x24\x6e\xe8\x75\x6e\x77\xcc\x2f\xba\x45\xad\x00\xed\x21\xd1\x6c\x95\x74\xf5\x67\x95\x36\xb5\x74\x46\xc7\xeb\xc3\x5e\x9f\x8f\x16\x80\x60\x72\x99\xdd\xcc\x1a\x20\x01\xce\x80\x76\x4d\xb4\xde\xc8\xc9\x73\x80\xc6\xc2\xb2\x1a\x3d\x6a\x5f\x1d\xad\xc1\x2f\x1c\xca\xb7\x8a\x4e\x53\x81\xdb\x5c\xa4\xf3\xf3\xe5\xec\xf8\xf3\xac\xd6\xb6\xbb\xb7\x95\x42\xa6\x72\x67\x55\xb8\xb9\x58\x34\x80\xd6\x39\x9e\x12\xbb\x6d\x82\x5f\x43\x7b\x00\xa8\xad\x03\xf4\xc4\x02\xc9\xc4\x33\x09\xd6\x53\x6a\xd3\xd2\x9a\x3d\x26\xa4\x40\xf2\x0d\x13\x01\x68\x28\x36\x55\x14\x43\x5a\xaf\x05\x45\x92\xdd\x03\xca\x4a\x18\x93\x60\x70\x00\xc1\xc5\x6a\x1c\x26\x3d\x80\x16\x60\xd0\x5a\xb4\x02\x87\x4a\x42\x73\xc5\x8c\xc4\x20\x09\x94\x61\x4c\x0e\x00\x0c\x66\xc9\xa4\x65\xb4\x90\x65\x19\x8e\xe6\x81\xd0\xec\x32\xe8\x5b\x8b\xb5\x34\x5f\xd0\x36\xbe\xa3\x88\x7b\xa0\x41\x5c\xab\x71\xda\x8a\xdb\x0a\x0b\x25\x00\x98\x09\x6b\x0c\x5e\xc6\x71\xb9\xd6\x54\x55\x4a\x9b\x9a\x6a\xaa\x9c\x1d\x1a\xb3\x06\xb2\x5a\xbe\xce\x6c\x9a\x1a\xd2\x70\x55\x05\xed\x48\xdd\x96\xb6\x79\x6d\xeb\x17\xbb\xc4\xa0\x57\x4f\x97\x59\x5c\x10\x6a\x59\x60\xb2\xfe\x42\xc3\xd3\x0c\xad\xe3\x78\x00\xcd\x71\x06\x88\x03\x7a\x8b\x06\x30\x0c\x60\xdc\x34\x0b\x3f\x85\x9c\x06\x9a\x80\xd1\xc8\x31\x46\x96\xa3\x51\xbb\x01\xe6\xe4\x4b\x86\x02\x87\xdd\x6e\xb1\x1a\x45\x46\x9a\xe6\x36\xf3\xa2\xb6\xc8\x8e\x7a\x32\x7a\x4b\x85\xde\x02\x00\x9a\x8d\xa8\x67\x1b\x2c\x7a\xc7\x42\xbd\x79\x7c\xb0\x44\x6b\x60\x74\xa2\xdf\xdf\xe9\xb3\xb2\xb4\xd1\x54\xc6\x39\x0d\x76\xbd\xa9\x43\xb0\x68\xb9\x02\x0d\xe7\x15\x68\xae\xa2\x6e\x42\xd8\xf2\xd3\xba\x69\x7e\xad\xd3\x6c\x2f\xc2\x74\xde\x6b\x63\x1d\xd6\x6b\xeb\x36\xbd\x78\xd6\xae\x72\x1b\x28\x72\x97\x1d\xe9\x58\xb1\x63\xf3\xfa\xa6\x37\x17\xd6\x4c\x29\x85\xd0\x1f\x44\xad\xae\x91\x0c\x45\x6c\x50\x98\x17\x9f\xbc\x7b\xc2\x14\xd6\x57\x13\x28\x40\xd5\x2a\xd0\xeb\xa7\x4d\x31\x14\x47\x3c\x6e\xbd\x49\x8d\x8f\xc7\xb2\x98\x40\x79\x91\x1c\x5d\x45\xd5\x52\xad\xd4\x02\xec\x55\x14\x0c\xd1\x01\x6c\xf4\xc7\x1c\x63\x74\x28\xcc\xf8\xf0\x2c\xed\x50\xe8\x80\xd1\x58\x82\x06\x0a\x2f\x1b\xe2\xf1\x20\x07\xfc\x7c\x8c\xc5\xf3\x3b\xda\x61\xa4\x50\x18\x5f\x45\x46\x93\x56\x50\xeb\x61\x1c\xb1\x61\x11\x04\x65\x2b\x21\x34\xc7\x6e\xd8\x73\x45\xc0\xf4\xf4\xa7\xfb\x5a\x6c\x5e\xf9\xd7\xf2\x61\xb0\xa8\xbb\xf6\xfa\x03\xbb\x42\x41\x46\x5c\x77\xc1\x45\x07\x52\x5e\x50\x45\xbf\xff\xd6\xaf\x16\x8e\xdb\x78\xc3\xd0\x3f\xd0\xa4\x0e\x67\x3d\xf3\x4d\xd7\xac\x4b\xb7\x4e\xda\x39\xa5\xd9\xf4\x11\x7d\x08\x68\xad\xed\xd3\x77\x4f\x2a\xc0\xab\x10\x25\x33\x26\x77\x34\x47\xcb\x3d\xba\x9d\x23\xf4\xb0\x12\x7c\x25\x67\x9b\xb1\xf0\x9a\x19\xfa\xc3\xf0\xfa\x9a\xd6\x65\xbc\x70\xd1\x87\x8b\x17\xdf\xb6\xbc\x43\x30\x02\xf6\x37\xef\xdc\x37\xe1\x9f\x37\x7d\xd1\x5c\xfc\xc5\xc7\xd3\xff\x42\x9f\x0b\xc0\x75\xf7\x4a\x3f\x7a\xdb\x35\x29\xd6\x6c\x93\xfd\x7f\x7d\x14\x18\x0a\x12\x0d\x9d\x85\xd1\x32\xd6\x89\xba\x17\x8d\xb4\x03\x16\xbe\x34\x16\x1e\xa3\xda\x7e\xad\xd4\x72\xac\x7f\x54\xd1\xd5\x00\x73\x27\x47\x6a\x3d\xb4\xe2\x7b\x85\x99\x88\x21\x8e\x87\x2d\x06\x84\x5b\x1e\xc7\xcd\xd2\x19\x3b\x4a\x2b\x54\x88\xb7\x38\xc2\x34\xab\xa0\xcf\x61\xa9\x28\x86\x09\x19\x45\x8c\x3d\xc7\xdc\x18\x6e\x5c\x34\xa3\xa6\xd7\x53\x58\x26\x9a\x0e\x96\x77\x94\x96\x54\xb8\xaa\x1b\x36\x3d\xd4\xd3\x91\xdc\xd8\x1e\x9a\xb6\xa0\xf9\xd0\x59\x76\x6f\xf7\x84\xc8\xec\x9a\xb2\xda\xa2\xda\xc8\x7f\x3f\xd8\xf9\x83\x8d\x13\xc1\x86\x0f\x8f\xec\xed\x9d\xd1\x79\xad\x3c\xf8\xdc\x46\x73\xb7\xba\x03\x58\xbc\x03\xde\xab\x9d\x1b\xab\x70\xea\x9d\x3c\x6f\x36\xbb\x2c\x33\x9c\x3e\xbf\x33\x51\x19\x5f\x5c\x55\xdc\xb6\xb1\xb3\x65\x49\x73\x50\x28\xb1\x0b\xd6\xd2\x70\xc4\x5b\x59\xe9\x6d\xae\x5c\x7a\x69\x70\xf2\xf6\x83\x47\x3e\xec\x36\x6f\x7c\x0e\xb0\xd7\x76\xce\xe8\xdd\xab\xec\xc8\x83\x78\x87\xe8\xe7\x15\x48\x77\x78\x85\xc4\xb2\xb4\x51\x1d\x24\xe2\x2a\x63\x0f\x89\x13\x7c\xf2\x5a\x42\x53\x1c\xca\xb3\x72\xc6\xe2\x9c\x0e\xbb\x94\x10\x07\x5f\x80\x09\xed\xb2\xf0\xa9\x74\xcc\x05\xe8\xbf\x06\xd9\x42\x5b\xba\xde\x51\xcc\x81\x80\xc3\xe3\xfb\xc2\xee\xa1\x9d\x46\xa6\xd8\x26\xff\x0e\xaf\x46\x83\xb3\x44\xff\xc7\xa6\x19\xad\x0c\xc7\xd9\xdd\xb5\x3e\xf9\x1f\x46\xad\x46\x5e\x6e\xef\x34\xc4\xbb\xe6\xd0\x17\xac\x48\xd8\xef\x64\x5a\x67\x30\x33\x7f\xe1\xf0\xfb\xad\x83\x8f\xa1\x07\xf4\xb8\x4c\x45\xa6\xbd\x2d\x36\x74\x6d\x59\x51\xd0\xfd\x79\xa7\xbc\x5b\xfe\x95\xc5\x6e\xab\xb0\x5b\x75\x5a\xd9\x5d\xc0\x6b\xed\x5d\xec\xde\xf8\x8a\xbe\xbe\xa1\x4f\x2d\xa0\x01\x5c\x4a\x8d\x58\x77\x50\x34\x95\x51\x9e\x9a\x67\xc0\x38\xc5\x76\x69\x22\x33\x83\x01\xd5\x62\x9b\xdd\xeb\x0f\xb9\x4e\x12\x93\x0c\x8b\x7e\x53\x0c\xb1\xf7\x0e\x51\x84\x98\x1c\x12\x4b\x2e\xb1\xe7\xd2\x42\x2e\x53\x28\x13\x57\x86\xfd\xaf\x06\x08\xff\xa3\x62\x85\x0a\xd3\x01\x9b\x64\x27\x7e\x4c\xc3\xc8\x59\xea\xe2\x52\x34\x40\xab\x6c\x6d\x24\xf6\x1b\xc9\xf2\x99\x98\x1f\x96\xaa\x2f\x8d\x14\xfd\xb9\xf2\x6b\x6d\xc8\x95\x9a\x58\xd5\x5f\x35\x31\xe5\x0a\x69\xbf\xae\xfc\x73\x51\xa4\xb4\xde\x0c\xa8\xce\x75\x20\xb9\xae\x13\x50\x66\xb9\xe7\xd2\xff\xb8\xf4\xd2\xff\x00\x03\xa5\xf5\xe5\x60\xfe\x3e\x79\x8d\x49\x74\x85\xe4\x2f\xab\x26\x4e\xac\x02\xe6\x90\x4b\x34\x81\xdb\xf6\xc9\x47\xcb\xeb\x4b\x8b\x9c\x20\xb9\x61\x83\x9c\x74\xd2\x3d\xf8\x82\x4b\x95\xb2\x32\xb8\xac\x41\xe2\x89\xab\x0a\xbb\x81\xd3\x6c\x95\x36\xcb\xe2\xb3\x51\xf5\xdd\xf5\x89\x89\x4b\x27\x92\x3f\x94\xde\xd4\x0d\x93\xdd\x9b\xe4\x01\x52\x1a\x3a\x21\x2b\x3c\x79\x3d\x43\x9b\x48\x49\xde\x94\xc7\xe3\x2d\x7d\x50\x26\x18\x7f\xa0\xbf\x7b\xd3\x26\xf0\x5a\xae\x1c\xca\x7b\xb4\x61\x56\xc1\x20\xea\x92\xa1\x70\x28\xc3\x6a\x87\x17\xdb\xec\x8e\x92\xfc\x05\x1e\x16\x2c\x37\x5b\x8a\xaa\x4b\x17\xb4\x38\x4b\x9a\x9b\x4a\x9c\x2d\x0b\xc6\x55\x15\x59\xcc\xcc\xa2\x11\x03\xcc\xa7\xe0\x3d\xfb\xb4\x9e\x62\x17\x92\x57\x4a\x4b\x0b\xfd\xc0\x55\xdc\x33\xcd\x7e\xcd\x18\x63\x44\x05\xd2\x2f\xde\x66\x4f\xa1\x7e\xd4\x89\x57\xfe\x08\x61\x1b\x1a\x10\x6a\x5b\x41\x10\x0d\x2b\x38\xce\x2d\x1c\x24\x31\xd6\x2c\x71\x0b\x0e\x86\xb0\x0b\x27\x96\x33\xe3\x41\xe2\x23\xcc\xc6\x09\xd9\x3c\xc1\xf0\x61\x89\x23\xae\xc3\xce\xa6\x96\xdc\xf6\xce\xa7\xef\xdc\xb6\x44\xd9\x80\x8d\x8c\x59\x7e\xdf\x68\x12\xe4\xf7\x1f\xd7\x79\x75\x8f\xcb\xef\x0b\x26\xa3\xfc\xbe\x99\x61\xb5\x8f\x3f\xae\x65\x19\x33\x28\x41\x27\x41\xc9\xe3\x5a\xbf\xf6\x71\x50\x82\x4e\x82\x12\xf5\x24\xd4\xe7\x6e\x83\x36\x51\x13\xdb\x23\xbf\x6e\xd6\xe9\xb8\xe5\xdf\x18\x8d\xdf\x2c\xe7\x74\x3a\x33\xa8\xed\x61\x4d\x16\xc3\x37\xdf\x18\xcd\xe8\x2c\xa8\x55\xce\x1a\x0c\xca\x59\xf9\x75\x74\xd6\x6c\xfc\xe6\x1b\x83\xaa\xfb\xfd\x94\xbd\x98\x12\x51\x0f\xa5\x82\x78\x5c\xc3\xc3\x1a\x47\x46\xc0\x48\x6d\x49\x90\x63\xd4\xa1\x4e\x8c\x95\x10\x49\x19\x43\x7c\x60\xc7\x61\x22\x89\x33\x9f\xc7\xea\x9f\x94\x5f\x7e\xbc\xf7\xd7\xa7\xd6\x1e\xfd\x6c\xef\x41\x34\x5f\x86\x96\xcb\x97\x0d\xdc\x8e\x29\x66\xb7\xbe\x00\xc4\x5b\x2a\x2c\xa2\x6f\xc1\x92\x43\x27\x6f\x38\xff\xbc\x71\xc5\x02\xff\x09\xaa\x4d\xec\xc9\xd4\x7d\xcd\xf2\x8f\xdf\xdd\xfb\xd9\xd1\xb5\xbb\x7e\xf9\xca\xbf\x76\xbe\x0e\x0a\x6f\xbf\x05\x38\x5e\xdd\xcd\xc1\x71\xe3\x8a\x67\xbe\xb1\xf5\x86\x93\x87\x22\x62\xb1\x50\xaa\x60\x9b\x71\x29\xd5\xa6\x5d\xae\x7a\x30\x12\x73\xbe\x6f\x94\x1f\xff\xa8\xd8\x96\x44\x1e\x9a\x06\x5c\x9b\xff\x05\xa3\x33\x27\xc9\x19\x0e\xf3\x60\xfd\x50\x81\xff\xa3\x86\x08\xd2\x07\xb1\xc2\x82\x1f\xe6\x70\x38\x08\x8e\x87\xf7\x54\x3f\xd7\xc3\xa6\xa8\x89\xd8\x1b\x8c\x22\xfc\x0e\xbc\xc3\x6e\x25\xdd\x00\x8d\x8b\xe8\xb3\xf0\x57\xc1\xea\x0c\xf5\x62\x1b\x50\x49\x1f\x9a\x80\x25\x8c\xbf\x8f\x62\x82\x10\xa4\x02\x04\x01\x1f\x06\x12\xe0\x7a\x42\xae\x81\xf6\x37\x25\x49\x8c\x89\x2f\xb2\xd6\xc4\xc4\x95\xe3\x93\x91\x35\x9d\x4d\x82\xe9\x29\x6b\xa1\x53\x92\x68\xcb\xcb\x8d\x0a\xdc\xc7\x31\x29\x54\x27\x1d\xa3\xbb\x8e\x49\x75\x21\xe9\xd8\x80\x4b\x9e\x9c\x4e\x3e\x0b\x74\xcf\xc2\xb3\xea\x42\x47\x77\x9c\x90\xea\x24\x49\x7a\x81\x35\x8f\xf3\xba\x30\x38\x9c\x3b\x1c\x36\x0a\x6f\xd8\xcc\x62\xd4\xfa\xe7\x2d\xfd\xb8\x62\x21\xe5\x42\xe5\x36\xf2\xef\x20\x75\xd9\xb3\xcf\xa2\x0f\xfc\xd4\x29\x0a\xf0\xbb\x99\x29\xd4\x65\xc4\x67\x10\xaf\xa7\xe1\xa5\x4b\xac\x59\x40\xa4\xea\xb1\x5c\x08\xcd\x8d\x34\x1a\xf5\x1d\x56\x42\x81\x81\x97\x7d\xf0\x11\xa4\x66\x11\xe0\x1c\x24\xb2\xe0\x39\x12\xff\x7a\xe8\xda\x78\x2b\x43\xb0\x23\x88\xc2\x85\x7b\x0a\xd2\x69\xac\x04\x0f\x86\xac\x8a\xe3\xd5\x3c\xc5\xfe\x01\x1d\x41\xa4\xc3\xf0\xbb\x1d\xc7\x9c\xe3\x4a\x3d\xc5\xbc\x54\xe5\x67\xc0\xd5\xb5\x34\xcf\x6b\xca\x42\xa7\x28\x67\xc2\x6a\xf5\x74\x37\x4c\x70\xd2\x3a\xa7\x64\x02\x3c\xc3\x88\x81\xad\x53\x0e\x6f\x5e\xe6\x2c\xd0\x05\xce\xe9\xbd\xba\x99\xa3\x19\x53\x19\x10\x0d\x76\x96\x35\x6b\xac\x75\x26\x73\x51\xac\xbc\xb4\xd0\x08\x39\x51\xab\x63\xa1\xc0\x73\x05\xcd\x46\xd1\x6c\x8f\xfe\xc7\x9c\xa8\xd5\x2d\xf0\x10\x09\xf4\x9c\x45\xd0\x88\xfe\xb2\xd6\x60\x73\x35\x83\x44\x72\xc8\x59\x75\xc0\x1b\xae\xe5\xe8\x6f\x12\x1f\x7b\xa3\x91\xb2\x06\x77\x19\x12\x69\xe1\xa5\x67\xb1\xa6\x90\xa7\x80\x61\xad\x06\x83\x6d\xc1\xa4\x6a\x0d\x60\x9d\x81\x49\xe5\xa6\x02\x8e\x95\x68\x66\xdc\x84\x76\xa7\x53\x57\x7a\x4d\x3f\xe0\xae\x36\xdb\x59\x4e\x42\xb2\x26\x43\xeb\x6d\xb5\x1b\x0a\x8b\x9a\x17\xd5\x14\xb2\x40\x53\xd2\xd8\xdb\x59\x3a\xd1\x68\xf0\x6b\xa1\x5d\xd2\xbb\x20\x30\xb0\x96\x62\x5f\x63\xdd\xe2\x90\xbe\xd5\x5f\x5d\xac\x85\x8c\xab\x7c\x49\x6b\xef\x85\x3a\x13\x06\x1f\xa1\x01\x64\x4d\x5a\xc2\x15\xfc\x23\xee\x6b\x76\x3a\xa5\x23\x23\x5e\x35\x35\x9f\x5a\x4f\x5d\x8c\xbe\xc6\xac\x4e\x8c\x67\x63\x92\x44\xfa\xa7\x23\x83\xf7\x89\x1a\x35\x58\x05\x4a\x78\x8e\xc1\x1f\x62\x3c\x56\x12\x44\x7a\x2f\x1a\x15\x71\x6c\xad\x88\x76\xb1\x3a\xe8\xc1\x4e\x6b\xd8\x28\x8f\x3e\x5b\xa2\x5a\x42\x0f\x50\x01\x43\x63\x48\xbb\x54\x54\xca\x20\x39\x46\x0e\xa1\x13\x58\x65\xc7\x2a\x3a\xbc\x07\x9b\x7e\x67\xda\xec\x62\xc7\xec\x6d\x1a\xad\x51\x28\xe2\x2d\x1e\xc1\xf3\x44\xe5\x9f\x36\x6e\x98\x5d\x5d\x7d\xa2\x6f\xe3\x0a\xa4\x23\xf6\xcb\xa7\x0e\xfd\x51\xfe\xbd\xa0\xed\x07\xe0\xd0\x1f\x41\x10\x84\xa6\x1d\xfc\xb9\x9c\x96\x3f\x96\xff\xfb\x9d\xbd\x57\x26\x1f\x04\x8b\xa7\x4d\xa8\x64\x38\xc1\xc4\x71\x57\xfe\xa6\xaa\xb2\x12\xb2\x82\xce\xd0\xb0\xb4\x63\xdb\xbc\x02\x49\x53\xee\x40\x05\xb3\x2e\x6a\x73\x96\x31\xac\xcb\xd9\x0c\xe6\x2f\x8c\x84\xb5\xb5\x31\x97\xa6\xb0\xa4\xb5\xf5\xa1\x85\x85\xe3\x0d\xc5\x85\xbb\xfe\x39\xe4\x9f\x6c\x12\x5c\x3e\xff\x24\xaf\xfb\x36\xa3\x9b\x65\xf5\xc6\x62\x81\xd5\x2f\x5f\xdb\x53\xe2\x7f\x66\xc5\xb2\xa5\xee\xa2\x27\x9a\x7b\x6e\x98\x2c\x38\x3e\x3b\xa4\x6c\xae\xe9\xb8\xf6\xd2\xde\xd6\xf6\x1d\x4f\x9d\xb3\x15\x30\xc9\x07\x7f\x30\x2d\x71\x9d\x60\x40\xbd\x00\x36\xb5\xb4\x6d\x35\x0a\x7a\xd4\xa1\x1a\xd7\xc3\x15\xcb\x77\xd5\xa3\xa7\xa3\x32\xb4\xf5\x18\xd1\xd3\x9d\xe3\x58\xe3\xac\x9e\xf4\x56\xb7\x4b\xac\x75\xcf\x79\xbc\x63\x52\x54\xe4\x8a\xeb\xab\x39\xd7\xf4\x7c\xd9\x62\x0b\xa5\xa5\x24\xcc\x17\x4f\xf8\x6d\x91\xa6\xed\xc1\x6b\x9e\x90\xc7\xa4\xcc\x25\xc0\xcc\xa3\x81\xd2\x62\x67\x44\xe6\xdc\xa3\x2f\x3c\x7f\xf4\xc0\x2f\xfd\x81\x5f\xca\xb7\xa5\x5f\x7d\xe2\x7e\x50\xc2\x44\x9f\x78\x35\xfd\x18\x28\xb9\xdf\xbf\x7c\xf9\xc2\x6f\x0e\x1e\xfc\x86\x6d\x91\xdd\x43\xf2\xd9\xab\xde\x05\xce\x67\xc1\xa4\xdf\xa4\xcb\xe4\xbf\xbe\xbb\x0a\x1c\x19\x02\x7f\xf1\xfc\x46\x7e\x56\x59\xeb\x43\xb2\xc3\x4e\x24\xa7\x6d\xc0\x6b\x2f\x34\x16\x55\x39\x8a\x27\x28\x1f\x68\x2c\x16\x20\x36\x1f\x00\xf4\x71\xc5\x70\x9a\xc5\x69\xb6\x18\xc4\xa2\x55\x2c\xd2\xfb\x19\x01\x69\x38\x68\x78\xc2\x6b\x23\x02\xfe\x90\x39\x9c\x64\x77\x7a\x17\x2d\xef\x5d\xb5\x7c\x56\xb3\xd9\xb2\x59\x3e\xf2\xa6\xe4\x72\x49\xc7\x40\xf9\xda\x92\xa9\xcb\x17\xad\x5c\x30\xd7\xb7\xe5\xa5\xcb\xb7\xb4\x15\x44\x5d\xbc\x7d\x4a\xc7\x8a\x39\x0b\x12\x95\xdc\xe4\x8b\x57\x2e\x68\x89\xf8\xec\x2c\x63\xd0\xb8\xa7\xd4\xd7\x09\xa1\x48\xe7\xb9\xcd\x25\x2c\x67\x15\x35\x3c\x52\x8f\x84\xea\xd8\xa2\x15\x97\x74\xc0\x70\xcb\xcc\xf9\xf3\xba\x9a\x2c\x16\x47\x2d\xe7\x9c\xde\xbd\x63\xdb\x35\xe0\x27\xdd\xdb\x5a\xbc\xb4\xe0\x29\xd0\xe9\x3e\x92\xbf\x05\xae\x50\x01\x78\xe7\xb8\x20\x6a\x8c\x15\xd3\xf6\xcc\xad\xb6\x06\x66\x76\x55\x5c\xda\x0f\x68\x48\x5b\x8a\xea\xa7\x6d\x9d\x5c\x68\x91\xc6\x35\xb5\xb5\xd5\x98\xcc\x3b\x3b\x39\xeb\xa4\x69\x9b\x36\x5f\xdd\x51\xd0\xd9\x7d\xd6\xa2\xb9\x93\x63\x26\x13\xb3\xd4\xc5\x3b\xda\xa2\x8d\xc5\xd0\x31\xf3\xe2\x39\x2d\x1e\x11\x7d\x3e\xf4\xf5\x57\xf0\x8e\xa6\xaa\x10\xac\x41\x62\x8b\x0d\xc9\x2e\x7f\x63\x29\xe2\x49\x6e\x25\xf1\x55\x44\xc2\x02\x8a\xcf\x3e\xb0\xf9\x2c\xf8\x2f\x68\xcb\x30\x32\x31\x7f\xdb\x3a\xbb\x41\x1e\x4a\x7f\x31\x7b\x2b\xf3\x9b\xc1\xb2\xcc\xdf\xd6\xd9\xf4\xcc\xd9\x5b\x81\x7b\xe2\xfc\x1d\xf2\xbf\x80\x71\xc7\xfc\x89\x60\xf2\x29\xea\x14\x98\x8a\x7e\xae\x6a\x6f\x9f\xb7\x63\x47\x9e\x9c\x89\x11\xca\x6a\xd4\xf8\xa0\x31\x69\x4c\xed\xa7\x09\xee\x62\x92\x2a\x91\x69\x86\x64\x53\x21\x32\x7d\xf0\xbb\x02\xbd\xe0\x35\x63\xf0\x99\x1e\xfd\xae\x80\xaf\x61\x32\xb1\x5a\xd6\xe1\x6c\xac\xf9\x64\xac\xe2\x69\xcb\x8a\x39\x4b\x71\x01\x73\x54\xac\x98\xc9\xb4\xff\x3b\x0b\x3b\xa0\x16\x11\xb4\x61\x66\x54\x85\x91\x55\x3e\xf5\x9d\xa5\x1d\x25\xbf\x2b\x6b\xa6\xb9\x62\x8e\x94\xdf\x47\x59\x1b\xa8\x90\xcb\x6a\x51\xc2\xce\x2c\x56\x1c\x43\xfb\x1d\x01\x6a\x29\xec\x5b\x65\x50\xc3\xc6\x0c\xa1\xa1\x17\xbf\x47\x3c\x18\x8f\xbe\xfd\xe2\x5c\x1c\xbe\x78\x1a\xc6\x00\xd5\x9e\x5b\xf6\x5d\xbc\x01\x6a\x74\x3d\xf0\x7e\x27\x7d\x80\xea\xe3\xbe\x0c\xc9\xe4\x36\x2a\x86\x23\x41\x89\x38\x86\xa5\xb1\xb8\x03\xcf\xad\x54\x04\x0b\xa5\x0e\x32\x1a\xd1\x0a\x90\x58\x9c\x90\x8b\x62\x4b\x83\xe4\xb3\xf9\x70\xb4\x97\x44\x9f\x5a\xdb\x28\xbf\xf9\xec\xed\xf2\xd7\xb7\x9d\xf8\x91\x65\xe7\x21\xc0\x3f\xb3\xe7\x9d\xed\xd0\xdd\x78\x8a\x32\x9a\x4b\x2d\x5f\xc8\xa5\xce\x20\xdd\x03\x35\xc2\x82\xd8\xc4\xe5\xbd\x1d\x41\x70\xbf\xbc\xde\x0c\x7e\x55\x6a\xf9\x08\x2c\x7b\xf5\xb1\x3f\xdc\x06\xb4\xb7\x3f\x01\xca\x5a\x2f\x8d\xfd\xf1\xb2\x67\xe4\x6f\xf7\x7e\xe0\xda\x92\xe4\x03\xe0\x03\x9f\x93\xd6\x5b\x0a\x22\x6d\xcb\x27\x4e\x3a\x9b\x97\xff\x98\x4c\x06\xe4\x86\x61\x3a\xb6\xc2\xeb\x13\x0b\x87\x68\xf4\xfa\x78\xec\x3e\xa9\x2c\x6a\xe2\xa5\x51\x87\x12\x9b\x85\xed\x0a\x92\x38\xca\x3b\xd1\xa0\x3b\xfa\x5f\xb3\x2b\x42\xf3\xf5\xcc\x55\x81\xf2\xb0\xd1\xeb\xd9\xdb\xb4\xde\x7d\x8e\xbb\xae\x4b\xdf\x50\x6b\x6a\x36\x75\xf4\xdc\xf1\xa7\xf7\x4f\x0e\x7b\x9f\x7b\x7f\xcb\x69\xe4\x7f\x49\x3d\x0d\xef\x3f\x18\xfb\xf5\x73\x06\x7e\x99\xb3\xc7\xd9\x5e\xf7\x58\xfc\xf7\xf1\xc7\x40\x08\xb8\xc1\xc5\xc3\x2c\x68\x2a\x9e\x03\x2a\x23\xd6\x7f\xad\x90\x51\xd4\xb0\xac\x83\x51\x1b\x88\xe6\xa7\x33\x61\x58\x48\x70\x29\x42\x72\x1f\x6b\xcb\x24\x2c\x31\x4a\x3d\xc9\x24\x9f\x93\x8f\xff\xac\x5f\x10\xdf\xa5\x39\x9d\xd6\xe8\xf8\x24\xb3\x15\x05\x74\x10\xec\x30\xb9\x1c\xf2\x0e\x75\x73\x1c\x30\xe4\x28\x4c\xfd\x4c\x3e\xfe\x9c\x28\xc0\x55\x13\x01\xa7\x33\x27\x1d\x9a\x29\xcb\xb2\xa9\x93\x58\xab\x7c\x62\x1b\x6b\xc5\x7b\x17\x2e\xcb\x24\xe4\x02\x23\xb0\xfe\x14\x7b\xfa\xe6\x62\xbf\x03\x2a\xfa\xb4\x4d\x0d\x33\x52\x2a\x93\x1d\x8c\xb2\x56\xb1\xef\x19\x0f\x2e\x2b\xac\x96\x72\x3f\x51\x7e\x7b\x94\x18\x94\x9e\x33\x46\x87\x8f\xca\x4f\xee\xf4\x5d\xd1\xe2\x6a\x5c\xac\x06\xe3\x78\x86\x09\xe3\x5f\xb7\x62\x7d\x8b\x2a\x4a\x70\x15\x50\x68\x8d\xb1\x8f\x3d\xea\x2d\x3e\x22\xc1\x10\x57\x54\xc0\xc7\xd1\xe4\xe6\xc0\x91\xbe\x3e\x8e\xf7\x23\xf1\x14\x08\xa0\x1c\xd0\x91\x5a\x3a\x20\x61\x88\x5e\xe0\x61\x22\xac\x2f\x04\xcf\x39\xef\xce\x24\xfa\xa4\xf9\xc6\x19\x33\x1a\x79\xc9\x98\x48\xde\x79\x1e\xb3\xb8\xec\x12\xf3\xe2\x9d\x95\x95\x3b\x17\x9b\x2f\x29\xe3\xa2\xd1\xd9\x1d\x1d\x83\xf3\xe9\xaf\xdf\xfb\xa2\x61\x93\xbb\x50\x1e\x70\x2d\xae\xec\x59\x56\x74\xc7\x1d\x45\xcb\x7a\xaa\x16\xb9\x80\x97\x11\xaa\x6b\x3b\x4b\xc0\x4b\x43\xda\x6d\xa0\x3f\x91\xa8\xf6\x39\x0b\xa0\xc5\x69\x81\x05\x4e\x5f\x75\x22\xc1\xdb\x69\x53\xa4\xa2\xa4\x22\x62\xa2\xed\xfc\x50\xc9\xa6\x12\xcf\xf8\x1b\xc6\xcb\xbf\x09\x95\x8d\x77\x3a\xb1\x57\x28\x78\x13\x0c\x80\x37\xb1\x87\x28\x63\xf4\x15\xd8\xba\x13\xea\xf7\x81\xb1\x44\xe6\x10\xff\x64\xfc\xb1\x62\x0d\x51\xb1\x22\x21\xa5\x32\x97\xcc\x10\x34\xb4\x01\x3a\x97\x0c\xab\x6e\xac\x48\xc3\xcc\x25\x55\x78\x3b\xd4\x10\x52\x3c\x06\x82\x34\xcb\x7e\xd1\x3a\x77\xd9\x43\xf5\xfc\xbc\xa6\xea\x19\xa6\xb8\xfc\x72\x5c\x33\xaf\xb9\xba\xcb\x14\xbf\xa5\xc8\xd6\x32\x3b\x5e\x71\xfb\xfa\xdb\x5d\xf6\xe6\x39\xf1\x8a\x3b\xa2\xca\x89\x18\x88\xc5\x34\xf3\x71\xe6\xe8\xdd\x36\x7b\xf3\xfc\xe6\x8a\x3b\xd6\xdf\xeb\x1c\x1a\x02\xb1\xf5\xf2\xcb\xf0\x9b\xd9\x2d\x67\xfb\x9a\xee\xb7\xb9\x9a\x16\xc4\x2a\xef\xeb\xbb\xd7\xe9\xc0\x89\x7b\xa2\xda\xee\x16\x74\xed\xff\x47\xdb\x77\xc0\x47\x55\x65\xff\xbf\x7b\xdf\x7b\xf3\xa6\xb7\x37\xbd\x66\xfa\xa4\x27\x33\x99\x99\xf4\x4e\x80\x90\x84\x10\x7a\x68\xa1\x77\x09\x20\x1d\x61\x68\x62\x03\x15\xa5\xa8\x28\x51\x11\x1b\x76\x2c\x28\xba\x59\xfb\x5a\x50\x17\xb7\xe0\xcf\x82\xbb\xb8\xbb\xb6\xb5\x17\x20\x73\xf9\xdf\xfb\xde\x4c\x08\xc8\xfe\x74\x3f\xff\xff\x3f\x30\xef\xdd\xfa\xca\x7d\xb7\x9c\x73\xcf\x39\xdf\x13\x03\x65\x71\xe9\x08\x72\x95\xd8\x3e\x8b\xb9\x72\x74\x3c\xbf\x67\x6e\x0f\x29\x92\xc8\xbb\x3d\x21\x19\x5e\x91\x3f\x54\x13\x47\x2f\x96\x4a\xd1\xe9\xb9\xa0\x62\xfe\x85\x7b\x35\xd9\x82\x26\xd5\x05\x3a\x22\x40\x97\x76\x64\x5f\x06\xd2\xae\xec\x43\xe9\x1e\x9b\xe9\xc0\x69\xbc\x0c\x49\xa4\x9a\x4d\x04\xaa\xc1\x40\x25\x12\xfa\x84\xdb\xe3\x7d\x29\x36\xad\xbe\x7e\x5a\xe1\x73\x85\xca\x1c\x79\x69\x98\xae\x0d\x97\x26\xb2\xfb\x7a\xc3\xa5\x55\x81\xc2\xc7\x43\xb4\x43\xed\xe0\x2d\x46\x83\xd1\xc2\xe3\x10\x0d\x14\xbe\x9a\xf3\x75\x4d\xce\x9c\x00\x87\x7c\x06\xd3\x3a\xff\xa0\x41\x59\xab\xb2\xa4\x41\x29\x6a\x21\xce\x14\x66\x66\x97\x97\x86\x03\xc3\xad\x59\x4b\x6c\x90\x97\xe9\x64\x44\xe9\x05\x9f\x78\xf8\xa0\x79\x38\x95\x91\x25\x0a\xb6\x07\x2c\xee\xcd\x83\xa9\x11\xd4\x54\x6a\x31\x45\xf1\x78\x05\x0b\x42\x01\x21\x93\x16\x44\x3f\x41\x8d\xb8\xa7\x41\x78\x27\xbe\x3f\xc9\x1b\xf4\xc5\xfd\xc4\x85\xb7\x68\xe2\x89\xa9\x7d\x96\x37\x99\x85\x35\x10\x7f\x5b\xc8\xf1\xf1\x58\x09\x95\xc5\xe0\xa5\x1a\x12\x90\x9d\x20\x5e\x6e\xe2\x54\x96\x3f\x8e\xe3\x41\xe2\x03\x04\xc7\x4d\xeb\x1b\xc0\xa2\x17\xff\xcd\x4a\x59\x8d\xd4\xce\xb4\xa0\xcf\x0a\x72\x78\x35\xcf\xbf\x39\x6c\xbd\x52\x27\xa1\x35\xca\xf6\x95\xf7\xa0\x7f\xa5\xd3\xb8\x2c\xf9\x5c\x30\xf2\xe5\x1b\x80\x62\xae\x3c\xd1\xcc\x30\x4a\x89\x1e\xf7\xe6\x1a\x24\xf9\x12\x30\xeb\x36\x74\xcf\xa5\xd7\x4c\x79\xfb\xa1\xcf\x2b\xfa\xee\x00\x0b\x40\xcb\xd7\xdb\xb7\x7f\x8d\x0e\xa1\x1b\xd1\x21\x12\x02\xa3\x41\x27\xa8\xfa\xe4\x8a\x2b\x3e\x41\x2f\xa0\x03\xe8\x05\x12\x82\xc9\x3b\x77\xf5\xf1\x53\xc0\xa5\x40\xca\x87\x2a\x1d\x9d\xaa\xb3\x14\x5d\x4e\xb3\xd0\xe3\x04\x72\x20\x03\x4a\x3d\xaf\x06\x52\xf4\x14\x92\xd2\xb5\x99\xd4\x9e\x67\xe6\x75\x8d\x48\x28\x2d\xbc\x5d\xe3\x52\xfa\xd9\xf9\xc7\x52\xab\x24\x6c\x5e\x16\xd3\xf1\xe0\x0b\xef\xa0\x7d\xb3\xe0\x81\x7b\xe7\xe7\xc0\x92\xf3\x6e\xdc\x22\x3c\xcc\xa9\x27\xaf\xf8\x04\x54\x5d\xf0\x0c\x99\xb5\x47\x68\x7f\x3d\xd1\x17\x03\x3a\x36\xe8\x27\x63\xc4\x9f\x30\x4a\x18\xa3\x81\x31\xeb\x00\x1f\x48\x04\x43\x31\xc6\xcc\x54\xa3\xaf\x4f\xa2\x6b\xfe\xfc\x07\x30\xe9\xf8\x71\xf4\x29\x88\x7d\x46\x3f\x10\x48\x7d\x77\xc3\x8a\xdb\x81\xf1\x0d\xe2\xa2\x34\x69\xd8\x9f\xda\x71\xcd\x4f\xfb\x6d\x07\x83\x27\xae\xdd\xf3\x0f\x17\xdb\x8e\x6a\xd0\xea\x25\x23\x9b\x9c\x07\x3d\x6b\x33\x3a\xe6\x82\xdf\x29\x25\x15\xa4\x8a\x08\xf2\x80\xd1\x97\xee\xc2\xbe\x18\xf0\xe8\xa2\xba\x01\xbf\x73\xd8\x71\x6c\x26\x18\xa5\x7b\xe9\xde\x64\xb6\xe3\xb4\xdc\x91\x9d\x04\x78\x4d\x4a\x66\xfe\x57\x38\xb2\x4f\xe1\x8c\x0a\x09\x0e\xfc\x8c\x03\x12\x0a\x25\x45\x04\x90\xb3\x54\x0a\xdf\xf8\xdc\x4f\x84\x27\x25\x1e\xed\x92\x19\x5f\xd1\x49\x99\x68\xbb\x4e\xe8\x05\xde\x24\x74\x94\x04\xcf\x9a\x22\x89\xb4\xbf\xad\x00\xb1\xba\x35\x1a\x38\x3e\xad\xe3\x89\x73\xc9\x64\x1b\x4f\x04\x32\x7e\xbd\x24\xff\xd6\x33\x07\xd1\x9f\xd1\x7e\xf4\xe7\x83\x8c\x1e\x56\x9b\x4a\x4c\x4c\xbb\xe9\x4c\x0f\xa3\x64\x52\x97\xe6\x96\x4a\x6a\xca\xcb\xa1\x5c\xa6\xe9\xd5\xc8\xe4\xb0\xbc\xbc\x4e\x31\x16\x3d\x66\x32\x31\x5d\x38\x9b\xe9\x82\x47\xd0\x8b\x83\x96\x0f\xc2\xff\x41\xe5\xe3\x1c\x07\xb5\x05\x52\x84\x79\xc3\xa3\xde\x5b\x66\xfa\x87\x0e\x0a\xa2\xe1\x6a\x05\xfe\x53\x83\x47\x82\x83\x86\x06\xdf\x5a\x33\x47\x5a\x20\x05\x5d\x00\xa0\x1e\xfc\xfe\x0b\xcf\x26\xd9\x1b\x44\x9d\x16\xc0\x13\x01\x05\x1f\xa4\x20\x91\x67\x60\x36\x4b\x6f\xae\xa6\x13\x24\x58\x4c\x00\xed\xe8\x09\xaa\xea\xdc\xec\x5a\x55\x18\x9d\x7d\x78\x52\x79\x24\xaf\xa1\x66\xdb\xef\x73\x02\xd7\x77\xae\x2c\x8c\xc7\x4a\xcb\x1d\xb5\xbe\x36\xf9\x0e\xd8\x90\xaa\x52\x28\xe0\x0b\x83\xc0\x4b\x20\x7c\xb5\x46\xb3\xe8\x4b\xfc\x64\x55\x9f\xde\xf0\xe6\x58\xb5\x3a\x34\xbd\xfc\x72\xdd\xcf\x69\x9f\x38\xec\xc7\xc2\x1a\x4a\x01\x0f\x19\x65\xe2\x7e\x17\x1e\x59\xfe\x68\x96\x99\xc3\x4f\x21\x10\x79\x98\xce\xa2\x13\x1e\x9a\x82\x7f\x52\x3e\x81\x1e\x7a\xef\x56\x74\xf2\xe8\xaa\x55\x47\x81\xe3\x56\x90\xf7\x97\x77\xd6\x3c\xb9\xe1\x7f\x92\xc9\xff\xd9\x30\x76\xc7\xe4\x26\x8f\x04\xb5\xc0\x7f\x37\x54\x1d\x47\xf7\xf7\x92\x02\xa0\x1c\x38\x8e\xae\xfa\xc3\x1f\x56\x6c\xfc\x08\xfd\xfc\xd1\xc6\xa2\x21\x13\x3b\x02\xa2\x5e\x99\x38\x4f\x10\xbb\x57\x2f\xd5\x26\x48\x23\x4c\x44\x39\x30\x28\x28\xd1\x93\xfd\xb5\x88\x3f\x0d\xd8\x1c\x61\xd3\x14\xa7\x29\x41\x80\x6d\x82\x21\xde\x4c\x3c\x7c\x0b\xd8\xa6\x98\x9e\xa2\x25\x5c\xda\xd0\xc3\x8c\x0f\x4c\x34\xe2\x8f\x95\x60\x6e\xd0\x3f\x60\x96\xc0\xb3\x83\x89\x19\xac\xd5\x56\xa3\x7f\x57\x6b\xb5\x12\xbd\xa4\x68\xd5\xca\x62\x89\x1e\x1d\x2b\x69\x8e\xc5\x9a\xc1\xef\x62\xcd\x25\x38\x74\xa6\x69\x86\x7f\xe3\xe3\x35\xaf\x92\xc4\x40\xdc\xf6\x01\x2f\x19\x74\x68\x83\xaf\x24\xd2\x14\x70\x4b\x80\xe5\xa5\x97\x81\x85\x73\xf9\xc1\xac\x8b\x8c\x47\xb0\x58\xab\xa9\xae\xd6\x68\x25\x92\xe2\x62\xc9\xbb\xf8\x62\xb8\x2f\x75\x06\xc8\x35\x4b\x3a\x8a\x9b\xfc\x9d\x12\x60\xcf\x0f\x94\xc4\x9a\x63\x91\x62\xd6\x88\x5e\xe5\x3a\x03\x4d\xc5\xbe\x72\x8d\xdd\xb9\xfd\xb5\xd7\xb6\x67\x59\x35\x65\xcf\x5c\x70\x41\x1c\x3a\x1f\x07\x4b\x23\x78\x73\x22\xf3\xa9\xd0\x4e\xde\x74\x3b\x91\x66\x0a\x64\x9a\xc9\xc4\xf6\x87\x12\x42\xe3\x04\x43\x09\x33\xf9\x76\xff\xa1\xa9\x44\x6b\xfb\xd0\x2f\xf5\x96\xe8\xfb\x55\xaa\xd8\x17\x31\x95\x8a\xd5\xb2\x39\x47\x73\x58\x2d\x42\x05\xd5\x05\xf9\xb5\xf9\xa0\x43\x3c\xff\xa5\x32\x37\xc7\xbd\xf8\xe6\xf8\xfd\x20\xdf\x4d\xe4\x2e\x45\xc6\x67\x75\x4c\xe5\xcd\x8b\x5c\x79\xb9\x95\x59\x36\xf6\xeb\x7b\xef\xfb\x5a\x62\x75\x83\xe8\x79\xf8\x13\xbb\xf1\x45\xf1\x35\x25\x92\x9c\x1c\xc9\x2e\x77\x41\x81\x50\x33\x7d\x1e\x9c\x53\xe9\x6e\x63\xbe\x0b\x65\xe5\xe1\xab\xe7\xe6\xb0\x7a\xf4\xbd\xa4\x35\xab\x32\xc7\x15\x51\x59\xcd\xab\x1f\x78\x60\xb5\xd5\xa2\x2a\x06\x27\x2f\xce\x97\xb8\xf0\xec\x43\x10\x99\x13\x69\xf0\xb1\x7e\xb5\x14\xe1\x05\x45\x95\x13\x27\x60\x63\x69\x45\x95\x2a\xc0\x85\x8c\xa4\x03\x9d\xa7\x26\x39\xad\xf3\xd2\x9e\x4b\x1d\x41\xfb\xee\xa5\x1d\x23\x96\xda\x0d\xbc\x1d\x5c\xb9\x8b\x9c\x3a\x2b\x2f\xbd\x63\x29\x18\x71\x21\xff\x72\xd8\x5e\x3d\xbc\x7b\xd1\x70\xf4\x89\xc1\x6e\x37\xac\x5c\xdd\xb1\x64\x71\x3b\xc0\x8b\xa9\x83\x8f\x7f\xb4\x7a\x9d\xc1\xee\xe0\xd7\xd8\x1c\x6b\xda\x97\x2c\x01\x0f\x5c\xc8\xd5\x90\x39\xea\x4e\x2e\xc9\x4e\x12\x9e\x5b\xc0\x45\x12\x1f\x5a\x34\xb1\xef\x77\x5e\x2f\x3c\x34\xc7\x7a\x32\x39\xe6\x84\x98\xc5\x04\x2b\x47\x55\xf6\x3d\xf2\xe8\x19\x30\x04\x07\x52\x0f\x3d\xdc\xf7\x02\xb8\x16\x0c\x39\xf3\xe8\x23\x7d\x9b\x5e\xc0\x29\x74\xe9\x72\xa2\x1e\x93\xda\xfb\xd0\xcf\x67\x1e\x05\x72\x74\x3a\xb7\xa2\x22\x17\x2e\xb8\xff\xdb\xef\x0f\x5e\x51\x7e\x3b\xfa\xf1\xd1\x33\xa7\x1e\x06\xca\xaa\x72\xf4\x6d\x4e\x45\x45\xce\x40\x7e\x85\xe0\x7d\x50\x01\xe2\x66\x5c\x74\x8f\x7a\x11\xfa\x98\xed\x4d\xd5\xa2\xac\x49\x9b\x60\x2f\x38\x31\x69\x53\xed\xc0\xef\xdb\x03\x4e\xc0\xde\x4d\x93\x50\x56\xaa\x76\x13\xe3\x3c\x5f\x61\x4f\x8a\x7f\x36\x29\xc5\xfc\x03\xf7\x68\x19\xbe\x8f\x4e\xb0\x76\x0f\x08\xb8\x39\x64\x79\xf0\x58\x81\x4f\x07\xf0\x4a\x41\x1b\xa3\x31\x9e\x60\x53\xe0\x7f\x01\x1d\x4e\x1b\x18\x1e\xf2\x46\xea\x0b\x30\x64\x0d\xb8\xe9\xcd\x37\xdf\xec\x80\xc6\xd4\xe7\x60\x08\x7a\x8a\x24\xdc\x0c\x0d\x38\x67\x30\x3a\x0c\x06\xaf\x61\xfe\xd1\x97\x0d\x0f\xe3\xbc\xc5\xe8\x5a\x5c\x66\x30\x3c\x0c\x5c\x6f\xbc\x81\xfe\xd6\xd7\x71\x67\xc7\x7e\x31\xb1\x3f\x38\x60\x7c\xc9\x04\x6c\xd4\x22\xe2\x5b\x88\x12\xd8\x6e\x62\xf3\x31\x20\xa4\x4d\x03\x79\x73\xba\x04\xb1\xed\x80\x42\xdc\x27\x46\x7e\xc1\x88\x9b\x5a\x62\xb9\x76\x47\x4e\x0c\xfd\x90\x0e\xc0\x75\x0f\x5f\x66\xe0\xcd\x89\xb1\x6b\x8f\x45\xeb\x2f\xbb\xfb\x91\xcb\x9a\x1b\x9e\x3e\x96\xa8\xba\x8c\x36\x9f\xa7\x44\xd9\x98\xec\xd4\x00\xa3\x0e\x8c\x48\x4e\x20\xe7\x54\x31\x50\x3e\x47\xb7\x95\x4f\x91\xa4\x36\x67\x1f\xe5\xe1\x5c\x1c\xf5\xf7\x3d\x85\x83\xe0\xe7\xf3\xdb\x57\x4e\x65\x9f\x95\x71\x6f\xe2\xf9\x74\x23\x75\x84\x7a\x8d\x3a\x4a\xbd\x4f\xfd\x9d\xfa\x27\xf5\x29\xf5\x25\xf5\x15\xe1\x41\x5d\x34\x51\xd0\x57\x43\xae\x80\xf5\x11\x4d\x52\x17\xe7\x06\x26\x1c\x0d\x8a\x06\x24\x25\x89\x6a\x88\xa7\x07\xc2\xa2\x0a\x9a\x37\x8c\x48\x6c\x93\x25\x11\xcf\xfb\x02\x47\x6d\xce\x50\xd8\x50\x92\x46\xe9\x20\x82\x92\x10\x99\x40\x04\x1b\x39\x73\x42\x4d\x9b\x13\x05\x5c\xa8\x00\xe6\x10\xd7\x2b\x98\x2c\x75\xc1\x1a\x60\x34\x63\xe2\x4e\x5a\x23\xea\x2c\x11\x85\x55\xcc\xa5\xd1\xe4\x82\xf8\x89\x04\xca\x2e\x61\xe6\x80\x08\x4c\x1d\xaa\x86\x51\x3c\x34\x49\x26\x1f\xc5\xa9\x31\xa3\x06\xd4\x40\xe6\xe5\x61\x57\x4e\x9f\x5d\x97\xeb\x99\x50\x39\xa8\x68\xd5\x5e\x7f\x5e\xa5\x3d\x54\x30\x7d\xa8\x5c\xc2\xc8\x24\x79\x9c\x9b\xd5\xd3\x12\x00\x00\x27\xd5\xd1\xbe\xcd\x59\x21\x0f\xa4\x61\x45\x02\x8f\x44\xff\xee\x2a\xeb\xcc\x6e\x87\xc4\x88\x5c\x6e\xad\x45\xa7\x06\xff\x90\x2a\x8c\xbc\x9d\x65\xcc\x12\x8d\x8d\xbb\x53\xa6\xb3\xea\x34\x4f\x00\x70\x97\xa9\xf0\xba\xc2\x44\xa1\xbc\x31\x97\xed\xa8\xce\x4b\xe4\x18\x8c\x72\x8b\x32\x42\x87\xf3\x7d\xa0\x8a\xd5\x71\x6a\x89\x9c\x93\x31\x9c\xc6\xa6\x2f\x54\xaf\x9b\xa0\x0d\x37\xd6\x38\x07\x4b\x95\x59\x59\x26\xa5\xe9\xa7\xb5\x8e\xbc\x6c\xab\x57\xed\x53\xe4\x4a\x39\x98\x3d\xbc\xef\x90\xba\x34\x4f\x47\xe7\xfe\x14\x3a\x1c\x97\xd9\x9d\x66\x2b\x5c\xb5\xa6\xaa\x16\x9d\x2a\x5a\x38\x14\xdc\x4e\xfb\xca\xa2\xa5\x0c\x67\x1c\x5e\xe7\x40\x83\xba\x24\xf2\x7c\x25\x7f\xcc\x2d\xcf\xa6\x57\x01\x48\xfe\x4d\xa1\x0b\x9b\x56\x4c\x1d\x52\x3a\x2f\x51\xe5\x4a\xd4\x68\x03\x7b\x1f\x38\xb2\x73\x2a\x64\x58\x19\x1b\xe0\x9c\x4a\x97\x35\x60\xf2\xd8\x6a\xb2\x5b\x70\x9f\x90\x6b\xdd\xcd\x26\x55\x59\x95\x11\xda\x62\x93\xd6\xdd\x64\x60\x6c\xdd\x26\xad\xc6\x4c\xcf\x53\x9b\x54\x72\x86\x85\x40\x95\xa5\x0b\x98\x74\x1a\x13\x1d\xd6\xda\x9e\xec\x29\xf6\x7b\x69\x83\x45\xab\xe7\xf3\x86\xda\xb2\xb4\xb4\x5a\xe5\x77\xd7\x3a\xac\xe1\x30\x54\x68\xfe\xcc\x1a\xa5\x1a\x09\x26\xe0\x21\xcd\x80\x5c\x97\xc7\x56\x60\x1f\x29\x93\xe5\x3b\x00\x5e\x81\xa6\x4c\x31\xfa\x43\xe6\x7c\x5d\x19\xdf\xa2\x91\xc5\xc6\xdc\xf5\x72\x2e\x2d\x93\xcb\xf8\x38\xa7\xe8\x1b\x65\xcb\x75\xc7\x0b\x4a\xd9\x7c\x05\xed\x57\x3e\x52\x84\xde\xd6\x00\x4e\xa3\x90\x72\x20\x17\xaa\x38\x78\xa9\x41\x07\x94\xa9\xb5\x23\x95\x92\x62\x00\x84\x2b\x8b\x3c\xae\x1e\x8f\xb1\x7f\x53\x66\x4c\x93\x4d\xa2\x36\xe1\x65\x2d\x98\xde\x0d\x21\xfa\xb3\x64\x23\x5f\xb0\xb6\x14\xd4\x9a\xc5\x51\x26\xa8\xd4\x71\xb8\x93\x08\xba\xe5\x71\x50\x42\xd0\x6b\x88\xfa\x1d\x91\xc7\x00\x41\x99\x8d\x28\x23\x08\x5a\x71\x82\xc6\x97\x21\xbd\xd6\xc7\x4a\x70\xbf\x13\xba\x6c\x22\xcd\x1f\x31\xd7\xb2\xbc\x6b\x49\xf3\x86\x5a\x56\xaa\xd0\x70\x40\xea\x9d\x3f\x2d\x92\x3d\x36\x97\x53\xe6\xf1\x06\x73\xac\xd0\xe2\x2c\xb6\xa9\x65\x3a\x33\xad\x91\xa8\x65\x5a\x35\xaf\xb0\xfb\x14\x52\x39\x2b\x37\x83\x4e\xb9\x39\xdf\xe5\x49\x6e\xf4\xdb\x87\x0e\x1f\xd7\x9d\x58\xba\x1f\xc2\x16\x67\x43\x53\xd9\xae\xe5\xab\xb3\x6c\x6d\x75\x83\x0d\xbe\xc2\x2c\x87\x33\xb6\xf6\x6d\xf4\x39\x7a\x1b\xfd\xe3\x4f\xc9\x50\x45\xc7\xb0\x8e\x42\x5e\xdd\xec\xab\x72\xf9\xf3\xa4\x1b\xca\xf2\x0e\xe6\x1a\xfd\xa3\x1b\x46\x26\x42\x11\x5e\x6d\xf2\x16\x63\x0e\xc3\x20\xcf\x72\xd0\x34\xe3\xb1\x73\xca\xcd\x85\x6a\x8d\x5c\x99\x67\x31\x48\x39\x03\x54\x31\x72\x46\x42\x43\x8d\x5a\xa3\x93\x30\x4a\x50\x68\xca\xcf\x77\x8c\x1c\x05\xc2\xe5\xe5\x61\x00\x6e\x99\xd9\x5d\x62\xd0\xd5\xb5\xd6\x02\x50\x35\xb4\x1a\xd0\xde\x82\xec\x95\x47\xf7\xa3\x7f\xfe\x6e\xc1\xd2\x57\x80\xa3\x67\xfc\xdd\x6b\x17\x0f\xab\x75\xca\xa5\x01\x43\xd8\xe2\x18\x3f\xe2\x96\xa0\xb3\xcd\xae\xb2\x0c\x1a\xb2\x7c\xdd\xfd\xd4\x40\xec\x2d\x17\x5e\x25\x3b\xa9\x95\x78\x3e\xd0\x40\x35\x08\x65\xec\x79\x13\x41\xcc\x55\x9b\x39\x89\x01\x93\x13\x35\x34\x6d\xc6\x84\x82\x57\x62\x70\xd3\x5c\x21\x2c\x00\x89\x02\x11\x47\x08\x8f\x7f\x93\x68\x44\x1a\x22\xdb\xe9\x09\x33\x21\xc0\x0a\xe9\x84\x9b\x48\x54\x5c\x80\x36\x48\x38\x93\x60\x39\x4c\xb4\x45\x35\x74\xa8\x06\x56\x13\x85\x1a\x5c\x91\x29\xe8\xd9\xed\xaa\x7b\x60\xb4\xb6\x7b\xe8\xe8\x95\xe3\x07\x99\x0a\xea\x94\xbb\x15\x81\x40\x60\x4e\xc0\xb5\xfb\xf6\xe7\x94\x7b\x94\x81\x39\xcd\x01\xe7\x9e\x9e\xdd\xb7\xef\x76\x35\xe6\xd9\x9b\x3a\x57\x8e\x6e\x59\xaa\x1c\x75\x3f\x3d\x7b\xe5\xe8\xe6\x25\xea\x31\xcf\x34\x2a\x76\x0b\x65\x5c\x7b\x7a\xf0\x3f\x67\x6d\xa1\xb1\x65\x26\x9c\xd5\x62\x2b\x68\x50\xe2\x8c\xe6\x39\x42\xc6\xed\x7b\x9c\x0d\x4f\x8d\x51\x2c\x6d\x1b\xbd\x12\xbc\xd5\xb3\xc7\x55\x5b\x60\x6c\xea\x5c\x35\x7a\x48\xb7\x76\xcc\x83\x75\xca\x3d\x8a\xc0\x9c\x60\x80\x14\x84\x7a\x72\xc7\xe6\xb9\xe4\x8e\xf8\x9f\xab\xe1\xf0\x58\x0d\x7e\xb0\x55\xd3\x9a\x0d\x85\x67\x76\x8e\x5e\x35\x79\xb0\x23\xaf\x51\x28\x32\x27\x7d\x43\x57\xed\x03\xa3\x15\x4b\x19\x73\xeb\xa5\x8a\xd1\x4f\x36\xa4\x9f\x37\x9d\xd5\x90\x6f\x1b\x36\x6b\x95\xe8\xb7\x43\xc4\xcc\x18\x44\x8d\xa3\x26\x50\x53\xa8\xd9\xd4\x3c\xea\x4a\xea\x4e\xb2\x9f\x13\x2c\x14\x5c\xd5\x85\x44\x65\xce\x50\x5a\x43\x31\x11\x24\xd3\xa1\xc4\x20\x2a\x72\xe2\x7f\x82\xd1\x31\xd1\xbd\xc4\x63\x81\xc8\x85\x04\x1d\x4f\x51\x65\x93\x16\x14\x34\x7d\xa4\x54\x42\x90\x86\x25\x22\xac\x39\x04\x02\x3a\x16\x98\xe9\x10\x9e\x76\xcd\x80\xd5\xe1\x4f\x48\x6e\x21\x20\xc2\x88\xfb\x22\x42\x5d\x62\xba\x8d\x07\x17\xd0\x09\xa2\xec\x50\x49\x48\x27\x68\xb7\x24\x74\x6c\x24\x0f\x67\x1a\x75\x70\x3b\x30\x1b\x0c\x79\xb9\x5c\x23\xd3\xd0\x30\xc2\xc2\xb8\x69\x49\x8b\x71\x83\x5a\xd7\x08\xa5\xb3\xa4\x21\x17\x84\x80\xb5\x99\x2d\x7a\x39\x03\x24\x01\x45\x79\xe1\x0c\x28\xaf\x57\xc8\xac\x0c\x03\x69\xab\x83\xb6\x96\xd4\x2a\x2f\x63\x19\xd5\x5b\x34\xa7\x0c\xba\x5c\x36\xb3\x9a\x01\xb4\xc7\x50\xe4\xe7\x75\xf0\xb9\x9a\xab\xcf\xfc\x0c\x9f\x48\x35\x33\xc7\x67\x3d\x3e\xe3\xaf\xb3\xf2\x8f\xa1\x02\x58\x85\x4e\xdf\x16\x0f\x6f\xdc\x51\xee\x19\x35\xfc\x9b\x1a\xa9\x5c\xca\x38\x3c\xcc\xd0\x07\x06\x4f\xb9\x6e\xb4\xc6\x1d\x90\x83\x9d\x7d\xa7\xd5\xa9\x02\x4e\xc5\x12\x85\x68\x0d\x66\x7f\x0b\x20\x66\x74\x2b\x18\x03\x78\x8d\xe6\xa4\x32\x83\x93\x8d\xc1\xd9\x6d\x53\x34\x90\x81\xcc\x38\xcb\x13\x76\xd7\x95\x32\xe0\x85\x0a\x29\xd1\xbb\x93\xb3\x1c\xc7\xe8\x24\x3a\x28\xa1\xb5\x5a\x1f\xf4\x31\xb4\x1c\x00\xa5\x11\x46\xca\xd8\xc8\x08\x87\xa4\x04\x82\x62\x70\x42\xa3\x32\x6b\x94\xb4\x59\x63\xc3\xc3\x90\x51\x2b\xe1\x8e\xbf\xe7\xa4\x6e\xfa\x17\x23\xfd\x34\x15\x77\xc3\xeb\xdd\xa9\x7f\xb9\x2f\xa9\xa3\x2b\x9e\x02\x6b\x4f\xeb\x54\x3d\xf5\x23\xad\xca\xb6\x02\x4e\x86\xa7\x0e\x3d\x0c\x14\x3b\xfd\x9c\x0e\x33\xd2\xc9\x33\x7f\xf8\x51\xf2\x9d\x0a\x40\x26\x2e\x03\x12\xd6\xaf\x06\xc9\x97\x2f\x99\x6f\x44\x93\x05\x7b\xe3\x0c\xf6\x02\xb1\xe9\x1b\x4c\x8d\xc5\x3d\x61\x05\xb5\x95\xda\x4d\xdd\x4d\x3d\x49\xf5\xf6\xef\xf4\xf4\x3b\x87\x65\xcf\x87\x2c\x27\xf4\x03\xf1\xed\x64\x3c\xe7\x46\x4f\xc4\x63\xd7\xfd\x4a\xfc\xff\x77\x79\x5e\x04\x16\xf3\xe8\x40\x16\xd9\xcf\x4c\x92\x03\x7b\xa2\xbc\x69\xd7\xbc\xbe\x9e\xfa\xc9\xa5\x61\xd8\x13\xee\x72\xec\x71\x84\x53\x59\x02\xd0\xd1\x7f\x3c\x00\xea\xff\x2e\xbf\xab\x27\x5c\x9a\x4a\x32\xc9\xc9\xf5\xe7\xbc\x2b\xdf\xe9\x5d\x3e\x28\x45\xcd\xdb\x35\xb9\x5e\x42\x85\x4b\xc3\xf8\x31\xba\xc2\x67\x92\xfd\xd5\x80\xfa\x62\x41\x74\xd1\xd4\xff\xa6\x00\xd8\x0e\xa8\xd2\x70\x0f\xa2\x88\x37\x6f\xa2\x43\x2f\xa1\xd2\xb2\x9b\x1a\x6a\x38\x9e\x03\x16\x51\xeb\x05\x0f\x82\x0f\x51\xbf\xa3\xde\xa2\x3e\xc2\x94\xd8\x59\xa0\x01\x6e\x50\x08\x6a\x2e\xb2\xe3\xd7\xef\x24\x51\x6c\x77\xdd\x7f\x19\xa7\xff\xcb\xef\xf9\x5b\xfa\xc7\x85\x40\x3e\xff\xb7\xd7\xfb\x7f\xf9\x7c\xac\xa0\xac\x72\x46\xd4\x52\xe9\x3d\xe7\x76\xe0\x7f\x3f\x24\x7f\x6b\xc1\x73\x07\x48\x0d\xf0\x4c\xf4\x9b\x6b\x01\xea\xbf\xbf\x93\x84\x0a\xda\x4e\x09\xfb\x5c\x12\x7c\x44\x03\x20\x67\xbf\xfd\xb5\xe0\xa3\xfd\xc1\x8b\x43\x20\x5d\x3c\x78\x46\xc0\x4c\x11\x0e\xf0\xbf\xa8\xd6\xf7\x5f\x94\x3d\x0f\x86\x09\xf3\x9a\xb5\x67\xb5\x4c\x2f\xdb\x85\x47\x49\x88\xec\x18\x5e\xa0\x54\x47\x64\x9d\x19\x65\x21\xb3\xc9\x90\xb1\x32\x65\xf6\xa3\xf7\xd3\xba\x75\xe8\x7d\x87\xc3\x39\xdc\x71\x12\x74\x9f\x74\xb4\x3b\x1c\xa8\x47\x54\xb0\x7b\x1f\xbd\xdf\xf7\xaa\xa0\x5a\x97\x44\x49\x41\xb5\xae\x14\xf8\x49\x01\xc7\xc9\x93\xa4\xc2\x27\xa2\x6e\x1d\x9b\xf6\xbd\x4c\xf6\x53\x9c\x82\xd4\x68\x04\x91\x7f\x89\x7c\x0f\xa6\x1d\x09\x5f\x02\x44\x5f\x31\x20\xbd\x84\xb2\x11\x46\x4f\x2c\x2a\xf0\xec\xe7\xf3\xe2\x0c\xe2\x34\x26\x30\xa0\x34\xc1\x06\x09\x08\xbe\x61\x44\x72\x0a\xd3\x67\xca\xe0\xb8\xaa\x96\xb5\x95\xf8\xd8\xba\xa6\x12\xdd\x37\xaa\xb5\x65\x53\x93\x70\x00\x57\x2d\x07\xfa\xa7\xbc\x35\xf5\xb9\x8d\x5f\xd5\xd4\xa7\x9a\x9f\xec\xbe\xfb\x6d\x30\xa4\x6a\x5c\xb0\x72\x4d\x2b\x39\xae\x05\x33\x5a\x47\x35\x6d\x6a\x21\x07\x26\x5c\x39\xbf\x6d\xe9\xde\xa1\xe4\x78\x4b\xea\x58\xfb\xf2\x45\x7b\x9b\xdb\x57\x2c\xba\xb5\xf0\x05\xf4\xe9\xd2\x82\x2a\xa7\xa2\x73\xfc\x8e\x31\xc7\x1e\x5c\x7e\xac\x6d\x7e\x65\xf3\x2d\x4b\xf1\x71\xe8\xde\xa5\x73\x56\xb4\x37\xef\x5d\xb4\xbc\xbd\xf9\xd6\x45\xc4\xfe\xea\x2c\x05\x89\x2f\x70\xa3\x88\xb9\xc8\x9b\xd2\xc6\xee\xe2\xc3\xe3\x67\x87\xbd\x4b\xa6\xe4\x43\xbf\xad\xd7\xe6\x87\xf9\x53\x96\x8c\xde\x75\xdf\xae\xd1\xf4\xd7\xd7\xbf\x14\xe8\x7b\x5d\xd0\x04\x8b\x05\x5e\xba\x3e\xf9\xdd\xad\xb7\x7e\x77\x0e\x53\x24\x63\x77\xe4\xc6\x54\x3c\xd0\xb1\xa1\x7c\xa0\x22\x1f\x51\x44\x52\x4d\x63\x85\x08\x9b\xa8\x98\x6a\x49\xc2\x64\x2a\x59\x0b\x9f\x4e\x35\xa5\x9a\xd8\xd3\x7e\x77\xaa\xd6\x51\xef\x48\xd5\xba\xfd\x05\x41\xd8\x6b\xca\x33\xc1\xde\x60\xc1\x24\x30\x09\xae\xfd\x74\x31\x42\x08\xa6\x28\x5f\xa5\x0e\x25\xb5\x5a\x90\xd4\x55\xfa\x68\x2a\x5c\xaf\x06\x94\x54\x7a\x96\x52\xd7\x8b\x50\x79\xf8\xfe\x52\xd1\x8f\xc9\x39\xab\x68\x9c\xc5\x06\x84\xe7\x60\x41\xfa\x1c\xca\xc4\xc9\x73\xb1\x64\xc7\x17\xd3\xac\x62\x20\xfd\x80\x01\xe1\x80\x9f\x52\x58\x7c\xf1\x01\x0a\x4e\x84\x6a\xc1\x8d\x68\x01\x5a\xc0\xbe\x3b\x20\x92\x27\x86\x0f\xa3\xc1\x68\x30\x7b\x2a\xe8\x41\xb5\xd6\x5a\x2b\xaa\x65\x68\xc8\xa6\x83\x9e\x60\xae\x0f\x3c\x8a\x7f\xbd\xe6\xb8\x19\xf4\xfa\x72\xc1\xa3\xfe\x9c\xae\x5e\x50\xbe\xbf\xfb\x81\x07\x1e\x48\x6d\xcb\x84\x56\xde\x05\xe4\xfb\xbb\x9f\x7d\xf6\xd9\x54\x15\xea\xf2\x57\x6b\x4f\xa8\xd5\x27\x20\xfe\x23\x67\x6d\xb5\x1f\xf4\x04\x6b\xb5\x4f\x83\xeb\xf0\xb1\x57\x2e\xef\xd5\xd6\x06\x51\xf7\xd3\xda\x5a\x51\xa6\x82\xa4\x14\x0b\xf1\x7b\xcb\x70\xbb\x07\xa9\x02\xaa\x8e\xec\xd6\x1a\x3d\x34\x41\x36\x0d\xd2\x98\xc2\x8b\x42\x8f\x17\x33\x3f\x94\xd8\x23\x39\x8f\xc1\x14\xf0\x44\x62\x25\x3e\x4f\xcc\x43\x78\x75\x9f\x27\x40\x3c\x8f\xe1\x1c\xa1\xc3\xd2\x3e\x0f\x57\x8a\x00\x38\xdb\xd7\xd9\x2d\x01\x7b\xf4\x07\x6a\x96\xeb\x3e\x98\x81\x0e\xff\x39\x05\xd8\xa3\x57\xbd\x39\x13\xa6\x2e\x59\x7a\x26\x0e\xc2\x6f\xbe\x82\xfe\x08\xac\x6d\x13\x9e\x43\x7d\xe8\x73\xd8\x31\xf6\x8a\x65\x35\x07\x97\x5c\x5a\x3c\x72\x49\xb2\x29\x75\x2b\xf3\xc0\x5a\xf4\xc7\xb9\x9d\x2f\xa4\x9e\xac\x4d\xa0\x37\x81\xf4\x2f\x6f\x03\xfe\x8a\x0f\xaf\xd4\xb9\x16\xad\x8a\xdc\x7d\xe8\xb9\xa1\xad\xd7\xfd\xc5\xd1\xb0\x6e\xc2\xe3\x1d\x59\x07\x56\x0d\x5b\x33\xaa\xdc\x96\xfe\x86\x99\xfd\x4c\x17\x15\xa0\xf2\xf0\x9b\x0c\x16\xfc\xfc\x5c\xb0\x1a\xf2\xc2\xee\x13\xd9\x5b\x20\x1b\x0d\xb4\x2f\x86\x29\x55\x43\xfa\xc4\xe2\x32\x9e\x78\xec\x1c\xba\x0f\x81\x26\xa2\x23\x66\x1f\x1e\x7a\xb8\x51\x06\x4a\xc2\x8e\xa1\x6d\x60\xdd\xb2\x9e\x6b\xe7\x87\x9a\x47\xb5\x3e\x7c\xe7\x8a\xa9\x87\x9f\x5d\x0b\xe5\x8d\x43\xc0\x2d\x60\xe7\x86\xe4\xfe\xdb\x2e\x7f\xb3\xfa\x2a\xc5\xd0\xe2\xc5\x0a\xc4\x34\xcd\x03\x35\xe8\xf7\xe7\x4b\xc1\xd0\xf5\x7d\x5f\x2e\x5d\x7c\x5b\x4e\x49\x77\xd9\xf0\x1c\x1d\x7a\xfe\xa9\xce\xc9\xe8\x91\xe3\x8b\xe7\x64\xb5\x0c\x92\x1b\x36\x3f\x72\x70\xe3\xd6\xfd\xbf\xf3\x86\xc1\x25\xab\x4b\xeb\x81\xbc\x35\xc3\x6b\x71\x19\x9c\xfb\x10\x41\x67\xed\xf7\x5a\x20\xec\xc1\x9a\x33\xfa\x67\x21\x42\x99\x83\x01\x08\x45\x09\x03\xe5\x03\xc2\x1c\x52\x88\xc7\x95\xa0\x3e\x43\x80\x6c\x29\x49\xc1\xb5\xaf\x5d\x7b\xed\x6b\xa9\x6d\x3b\xe6\xd8\xed\x73\x5a\xeb\xdc\xee\x3d\x2d\xc6\x0e\x43\xd6\xf2\xc1\x73\xe8\xb7\x1f\x5b\xb7\xfe\xb1\xc7\xd6\xaf\x7b\x6c\x17\xfa\xe1\x08\x1a\xa6\x7c\x7e\xf3\xaa\xa7\xad\xff\x00\x5b\x86\x4f\x56\x99\x08\xc6\x80\xe2\x99\x23\x40\xc1\xb8\x49\xfd\x6b\xcf\x3c\xf7\xf6\x0e\x49\x8e\x7b\x77\x4b\x6b\xad\x5b\xea\x91\x56\x0e\xa5\x3f\x5a\xf7\x18\xae\xff\xe8\xa3\xeb\x9f\x45\x3f\xa2\xdf\x6f\x78\x74\xcf\xa5\x13\xc1\x03\xb7\x16\x41\xb0\xfb\x19\x20\x45\x3f\x50\xe7\xf1\x8e\x52\xfc\x3e\x0d\x54\x6b\x1a\x09\x80\x6c\x9f\x52\x22\x37\x28\x98\x2f\xc7\xf1\x43\xc7\xcf\x6d\x84\x55\x65\x18\x8f\x40\x24\xfd\x9d\x38\x9a\xbc\x7d\x20\xb3\xbf\x2c\xb6\x09\x61\x0e\xdf\x5b\xd2\xb3\x78\x71\x0f\xd2\x5e\xda\x51\x3a\xd9\x5a\x52\x50\xb9\xd2\x6a\x89\x56\x75\x98\x0c\x1d\x74\x9f\xf8\x25\x0e\x1a\x6e\x98\x32\xe7\x66\x39\x18\xbf\xeb\xd8\xb1\x5d\x37\xfe\x11\x7e\x2c\xe3\x87\x55\xa3\xbf\x88\x1f\xe8\xa7\xed\xaf\x6e\xdb\x36\x63\xe6\x36\x3a\xbb\x67\xf1\x92\xe1\xed\x8b\xd1\xab\x07\x96\x96\x17\x19\x0c\xf8\x1a\x95\x2b\x2d\x1e\x16\x2e\x14\x3f\xe6\x4d\x83\x26\xae\xbc\x66\x76\xdf\xb1\x9d\xbb\x8e\xbd\x73\x23\x7a\x0e\x04\x56\x80\x77\x71\x3a\xea\x99\xb1\x6d\xdb\xab\xdb\xb7\x11\xb4\xf1\xb3\x63\x24\x5f\xb1\x67\x29\x15\xee\x97\xf9\x98\x4f\x1e\x26\xa0\x26\xd1\x5c\x40\x10\xbe\x62\x06\xca\x64\xc7\x1c\x33\xad\x01\x34\xd1\x6e\x8d\x27\x42\x80\x58\x1b\x01\xcc\xa1\xd1\x3c\x69\x01\x20\xa1\x03\x21\x9e\x68\x25\xb2\x44\xea\xc4\xa9\x59\x2e\x88\x53\x12\x74\x20\x41\x14\xd7\xd8\x38\xa6\xea\x4d\x74\xa3\x06\xa2\x89\x78\xec\x2b\x38\x8d\xcc\x0b\xdb\xf2\x0e\xdd\x50\x33\xb5\xc8\x4d\x33\xcf\xe9\x20\x27\xf5\x0d\xbf\x46\x92\x3c\xa2\x2c\xe6\xf5\x83\x6f\x94\xfe\xe3\x18\x77\xdf\xdf\xca\x52\xa1\xc2\xf7\xd0\x0b\xfc\xc7\x86\xf6\xb0\xa5\xd8\x57\x64\x29\x82\xbb\xdf\xd5\x2b\x4c\xaa\xb0\xbf\xca\xd3\xa4\xf0\xfe\x13\x94\xad\xdd\xfe\x3e\x9a\xb4\xdb\xdb\x31\xa8\x52\xa7\x03\x3b\xdd\x71\xa5\x22\x04\x16\xa1\xeb\x4c\x4e\xba\x2c\x60\x2f\x6d\xf6\x4f\xe4\x94\xb0\x1c\x6d\x99\x38\xe4\xfa\xb9\xa3\x8c\x46\x30\xd3\x56\xa9\xd3\xd7\x5c\x36\x26\xf5\x19\xba\xc9\xe9\xa3\x19\x8e\xdd\x0f\x16\x81\x79\x0f\x68\x4d\x26\xfa\xd1\x1a\x74\xcd\x33\x4a\x30\xc3\xed\x60\xa0\xc1\x94\x67\x8d\xa3\x97\xd0\xce\x40\x9b\xcf\xe0\x35\x99\xe4\x7a\x7a\x08\x58\xf0\xc2\x97\x23\xd1\xd5\x86\x31\xe3\x6f\x9e\xd4\xa0\x52\x01\xda\xae\xd1\x54\x89\x7d\xa4\x56\x2a\xf6\x79\xb2\xaf\xdb\x70\x0e\x2d\x82\xf7\xe0\xd6\x22\x44\x24\xd7\x9f\x32\xd0\x70\xd4\x93\x31\x20\xcd\x38\x12\xc1\xed\x47\xba\x87\x99\xa8\x30\x80\x13\x93\x37\x4f\x9e\xbc\x79\x23\xfd\xf3\x78\x68\x91\xa5\x28\x99\x05\xb2\xb4\x90\x84\xf4\xea\xae\xee\x9e\xee\x3e\x0a\x1f\xba\xd4\xfa\x4d\x93\x1c\x73\xcd\x77\x4c\xa3\xa9\x69\x77\x98\xe7\x3a\x26\x6d\x02\xeb\x48\xa1\xc9\xe0\x04\x98\x29\xe5\x79\x69\xca\x2a\x46\x29\x84\x49\xf6\x24\x71\xbd\x99\x14\x8f\x98\x9e\x4b\xe2\xd2\x77\x4e\x5e\xbf\x7e\x32\x9a\xb4\x49\xb4\xab\x95\x92\xe9\x36\x4a\x55\x60\x3e\xbe\x75\x00\xaf\xf6\xbf\x3c\xb0\x88\xb3\xec\x49\x7b\xc4\x32\xf3\x19\xbb\x59\x70\xee\xdd\xd3\x29\x5c\xd6\xa4\x4d\x17\x7d\xf4\xa4\x88\x8a\x97\x24\x2f\x70\xea\xb4\xf8\xb8\x33\x06\xbc\x37\xe3\x11\xd2\x60\x72\xd3\x24\xf2\x12\xb5\xe4\xf1\x6b\xc5\xe3\xb9\x97\x38\x41\xc8\xac\x13\xe4\x55\x50\x96\xd0\x4c\x60\xa3\xd8\x00\x7d\xcf\x08\x51\x4c\x0f\x64\x61\x1e\xe5\x84\xf0\x7e\x94\x9f\x0c\x54\x57\x06\xeb\x8f\x6c\x02\x11\xf7\x69\x09\xf2\x66\xfd\x47\xd1\x9f\x30\x51\x22\x14\x8f\xec\x89\xa0\x0d\x45\x80\xdc\x6f\x45\xbd\x56\xbf\x1c\xa0\x88\x2d\xc8\x83\x1d\x9f\x08\xc7\x97\xc8\x31\x49\x60\xe1\x93\x7c\xd0\xf6\x12\xd8\x81\x8f\x9f\x80\x1d\x9d\x25\x41\xdd\xb6\xa0\xd5\xe7\xb3\x06\xb7\xe9\x82\x38\xf7\x86\xfe\x43\x92\xe7\x11\xae\x10\x44\x0b\x85\xc3\x80\xb9\xc6\x48\xe5\x52\x8d\x82\x2e\x4c\x1a\x34\x49\x9c\xe5\xd3\x66\xd8\xf1\x04\x4e\xf5\x0c\x48\xcd\x12\x52\x79\x9c\xea\x17\xf6\x13\xfb\x4b\x33\x82\x7b\x3e\x30\x50\x35\x6d\xb6\xeb\xf7\x68\xcb\xcd\x39\x76\x13\x9b\xb5\x79\xd1\xdf\xee\xe7\xd5\xbc\xa3\xcb\xf7\x25\xfa\xc3\x4d\xbb\x8a\x7c\x56\xce\xb5\x7a\x03\x30\xbf\x63\x51\x5b\x7d\x0b\xc2\xeb\xd0\xa3\x0f\xbf\xd1\x63\x76\x67\xbb\x15\xce\x2d\x0f\xee\x03\xf9\xb3\x8d\xbc\x33\xf7\xcd\x0b\xe1\xe7\x9b\xb2\xf8\xa5\x5e\x59\xae\xc1\x29\xb5\xcf\x56\xd8\xbf\x08\x1b\xb7\xe5\xa8\xa2\x56\x9f\xd4\xb3\x56\xe5\x03\xba\x42\xf3\xd0\x61\x85\x5c\xc0\xe5\xce\x91\x06\x1a\xab\x94\xd9\x13\x2e\x10\x06\x01\xd1\x97\x2d\xfe\x26\x3c\xa1\x86\x89\x5f\x36\x8e\xe6\x30\x8f\x1d\xc2\xa1\x04\x9f\xf0\x30\x14\x7a\xc7\x02\xcc\x88\xcd\xdb\xee\x42\xc7\x40\xa1\x05\x7d\x0a\xce\xe0\x30\xc8\x67\xde\x49\x3d\xed\x46\x53\x5d\xe8\x2b\x17\x28\x84\x83\x5d\x60\x9f\x0b\xe8\x5c\x78\xec\xe9\xf0\xef\x1a\x19\xc5\x5c\x4a\xa9\xf1\x0a\x4b\x3c\xda\x57\x52\x43\xa8\x51\xd4\x34\x6a\x3a\xb5\x18\x73\xa4\xdb\xa8\xeb\xa8\xdb\xa8\x83\x54\x2f\xf5\x2e\xf1\xb6\x45\x7a\xa9\x97\x18\x8d\x92\x19\x1b\x47\x71\x33\x92\xb6\xe5\x68\x83\x39\xe3\x3c\x20\x46\x76\x07\xbd\x85\xc4\xb6\x37\x61\x26\x8a\x38\xb1\x50\xa2\x04\xcf\xf6\xb4\x99\x33\xf8\x84\xf4\x28\xa6\xd9\xcf\x65\xb8\xd3\x8a\x3b\x38\x82\x73\x64\x80\xe7\x0c\x82\x67\x24\xe2\x22\xd9\x94\xb8\x30\x26\x46\x44\xbb\xf0\x32\x40\x93\x6c\xb2\x06\xf2\x44\x8c\x69\xee\x8f\x61\x7a\xd5\xc4\x73\xc5\x42\x0c\xf2\xb1\x78\xda\x18\x5f\xc0\x6f\x16\xa8\x3a\x92\x40\x09\x42\x0a\x5a\x8b\x49\x48\x95\x5c\xa6\x56\xab\x81\x4a\x66\x02\x39\x0a\xa5\x4a\xaa\x95\xaa\x80\x5c\x21\x91\xa9\x15\x32\xd9\x99\x2f\x0c\x06\xa8\x86\x3a\x1d\x54\x8f\xb3\xd9\xa0\x54\x66\x36\xcb\xa4\xc0\x76\xc4\x6a\x55\xc8\xa1\xd1\x08\xe5\x8a\xc9\x66\x33\x54\xaa\x8c\x46\x95\xb2\x0b\xc7\xd5\x12\x99\xc1\x20\x93\xa8\xc1\x06\xf4\x91\xd1\x28\xe7\xb4\x10\xf3\x4b\x5a\x4e\x3e\x99\xe7\x15\x52\x1c\xc2\x71\xa9\x62\x1a\x4e\x33\xf0\x38\xa2\x92\xca\x94\xe0\xca\x97\x35\x1a\x0d\x66\x09\xd4\x6a\x8d\x41\x33\x5d\xad\xd6\x9a\xb4\x40\xa9\x04\x5a\x93\xe6\x4f\x6a\xbd\x4d\x0f\x24\x12\x25\x94\xcb\x14\x52\x4e\x0d\x99\x59\x07\x96\xf5\xfd\x5b\xa5\x77\x8c\xee\x7a\x01\xb8\x74\xb1\xb2\x65\x07\xf6\x7f\x03\x15\x72\xb5\x5a\x9e\xfa\xe1\x1b\xb9\xaa\xe4\x18\x6c\xd6\x4a\x59\x56\xaa\x95\xa4\x9e\x05\x9f\x03\x39\xa7\x90\x71\x2a\xb0\x20\xb9\x4e\x26\x5b\x97\x94\x35\xbd\xf5\xba\x4c\xfe\xda\x5b\x32\x3c\x32\x3f\xff\xe1\x4b\x85\xe2\xcb\x1f\x94\x6c\xdf\xf7\x2a\xd5\xf7\x7d\x2a\xf7\x67\x3f\x6a\x65\xdc\x8f\x9f\x49\x64\xc8\x04\x17\xa2\xcd\x3f\x72\x0a\xfd\x8f\x60\xad\x5e\x31\x1c\xe5\x7d\x2f\x55\xf0\xdf\x83\x77\x79\x45\x16\x92\x7c\x6b\x34\x7e\x0b\x4e\xcb\x54\xaa\x94\x0e\x7e\x86\xe0\x57\x72\x8d\x5a\xf1\x15\x40\x0a\xb5\xda\x85\x0c\x5f\x28\xb4\x5a\xc5\x17\xe0\x0b\xa5\x56\x8b\xa4\xff\x54\xe9\xf5\xaa\x25\xcb\xe0\x5a\x5a\x23\xe3\x58\xa9\x3e\x75\xe3\xb2\xbb\xa0\x5e\x45\x6f\x32\xcb\xbd\xe8\x54\xaf\xe9\x00\x95\xc1\x27\xa0\x04\x1f\xc6\x76\x01\x81\x94\xa2\xb2\xfc\x09\x3c\xd5\x90\x1d\xfa\x2a\x60\xfa\xdf\x63\x8c\x00\x4e\x2d\x46\x4b\xe2\x90\x07\xef\x81\xbd\x2b\x8e\xa2\xdb\x50\x17\xba\xed\xe8\x0a\xb0\xf7\x57\xe2\x87\x41\x0f\x98\x76\x34\x13\x3f\x4a\x53\x63\x46\xdd\x27\xea\x63\xdc\x37\xaa\xef\xbe\x01\x11\x90\x33\x20\xc2\xe4\xe0\x53\x52\x8c\xe1\xd3\x80\xfd\x5c\x9e\xb2\x51\x3e\x6a\x32\x1e\x3b\x97\xe2\xb1\xb3\x15\xcf\x49\xbf\xdc\xaf\x33\x73\x3a\x0f\xf1\xa7\x2c\x28\x5b\x13\x11\x2e\x10\xa4\x65\x64\x13\x57\xc2\x19\xc5\x3d\x73\x0e\x0a\x7e\xfb\x88\x3d\x3b\x20\xd6\x21\x46\xb2\x07\x4b\x6c\x0e\x2a\x60\x44\xb0\xbf\xc7\xaf\x8d\x0f\x98\xb2\x50\x03\x20\x31\xe3\x49\x8e\x98\xbc\xc7\xf0\xbf\x90\x81\xa3\x49\xd1\x10\xb9\x8a\x84\x0d\xfa\xc8\x98\x2c\x61\x8f\x38\xc2\xfd\x00\xca\xc9\x70\x97\x63\x33\x58\x29\x57\xa2\x57\x94\x60\x3a\xb1\x35\x4b\x51\x10\x79\xa2\x15\xe5\x37\xb8\xb4\x6a\x08\x24\x75\x45\x97\xd7\x7c\x70\xff\x4d\xe3\x35\x2a\x0b\x60\xe5\x8c\x6c\xf2\x68\xb5\x0c\x96\x24\x1a\xfd\x16\x95\x4a\xe1\x36\x02\xb3\x52\x2f\x23\xc6\xf0\xca\x04\xb2\x97\x8c\x8e\x0e\x05\x1b\x34\x2a\xfc\x38\x02\x42\x85\x12\xac\xdd\xba\x13\x9a\xd8\x96\xa8\xbd\xd4\x05\x57\x58\x2e\x6d\x29\x52\x33\xcc\x66\x61\x8b\x2d\x03\xc3\x1c\x76\x34\xa2\x2b\x9c\x4a\x50\xa6\x3c\xad\x67\x28\x62\xd0\x76\x9a\x82\x23\x6c\x2e\xae\xd8\x84\x99\x2b\x00\x82\x61\x8f\xa5\x02\x9d\xe6\x94\x80\x91\xdb\xc2\xb3\xf3\x65\x1a\x08\x47\x77\x5f\xb1\xae\xe3\x96\x48\x58\x63\x2c\x94\x40\x9a\x75\xad\x19\xb4\x1f\xd9\x2d\x97\x87\xc7\xd1\xab\x73\x3a\xb9\x00\x1d\x66\x18\x80\xeb\x9a\x70\x7b\xa4\xe6\xc6\xed\x98\x28\x6e\x58\x38\x66\x51\xa9\xc2\xe2\x00\x80\x3a\xaf\x9f\x89\xdf\x68\xd4\x6f\xfb\x36\xbc\x91\x00\x1a\xe3\xd6\x8f\x45\xc9\xe6\x3a\x0e\x0b\x90\x7e\xb4\x44\x03\x7c\x25\x05\xc4\x35\x1b\x01\x56\x27\xb4\x9d\x0f\xb7\x38\x1d\x8d\xfd\x6a\x4b\xcf\x6d\xda\xbf\x2f\xc9\xd1\x90\xa1\x01\x4b\x27\xf7\xed\x6f\x42\xef\x76\x4e\x67\x21\x64\xf0\xd3\x4b\xe0\x75\x4b\xae\x83\x2c\x60\x18\x08\xd9\xe9\x9d\xbf\xa1\xd9\xe8\xe4\xfc\xd4\x7c\xf0\x89\xc1\xa6\x95\x5a\x68\xaf\x0c\xd9\xe1\xce\xf9\xf3\x51\xb3\xc1\x66\x24\xce\x76\xd9\x2c\x19\xf4\xa4\x3e\x92\xb9\x25\x46\xa3\xcd\x00\x9e\x98\xff\xcb\x76\x18\xf9\xdb\xda\x81\x98\x02\xf8\x08\xa8\x27\x91\x06\x43\x37\xf0\x91\x38\x2d\x36\x86\x00\xe1\x46\xc4\x0d\x85\x40\x88\xf3\xf4\xaf\x36\x02\xc8\x07\xd6\x61\xb3\x59\x39\x8b\x5f\x9a\x81\x2c\x47\xcf\x6f\x01\xbe\xc6\xde\x17\x1a\xd0\xa7\xcd\xb3\x19\x25\x8d\x7b\x17\x23\x51\xcc\x6b\x41\x1f\x36\x3e\xfb\xfc\x6f\x68\x86\xcf\xe6\xcd\xbb\x9d\xe3\xa5\x8c\x84\xe1\x64\xcc\xed\xf3\xe6\x01\x1d\xb0\xcd\x9f\xbf\x8f\xe3\x19\x1a\x5f\x47\xb9\x0f\xb7\xc9\xd7\xe8\x93\x8c\x8e\xcc\xc0\xf7\x2f\x15\x74\x81\x7f\x6b\x0b\x60\x8e\x52\xf4\xd3\x8d\x29\x0d\x82\xec\x08\x7c\x3a\x32\x72\x09\xd8\xe2\xaf\xbf\x73\x16\x18\x3c\xe9\xca\x96\x9c\x86\xe1\xcd\x35\x45\x1d\xe8\xba\x89\x80\x5d\xb1\xb2\xc4\x5d\x5a\xed\xfe\x6d\x2f\x78\xb7\xc6\x9c\xec\x18\xb1\xd2\xce\xcf\x4f\xfd\x09\x58\x80\x52\xef\xe9\x18\xef\xd6\x5c\xec\x9d\x72\xa8\xc8\x6f\x9c\x79\x74\x9e\x58\xc2\x0c\x18\x51\x5d\xca\xf0\xab\xaf\xc0\x24\xfb\xa8\x5e\xb2\xf9\xd1\xde\xd3\x8d\x69\xd2\xdf\xf0\xdc\xa0\x17\xf5\xf6\x92\x2a\xc9\x6e\x52\x85\x20\x67\x66\x9e\x35\xb3\x2f\x43\x9e\x37\x41\x35\x0b\x28\xeb\x31\x9f\x91\x8d\xf9\x9c\xe9\xb3\xf1\xd7\xdf\xc1\x47\xc0\xc5\x75\x40\xb0\x10\x16\xb4\xa0\xe3\x7c\x2c\x4a\x9c\x24\xc2\x34\x19\x0d\x93\x44\x49\x90\xfc\xe8\xca\xff\xf5\xed\x92\x49\x44\xc1\x6d\xf3\xa5\xd7\x7f\x78\xbd\xd4\x38\x3d\x39\xdc\xe4\x3d\x22\xf8\x7a\x63\x92\x03\xfe\xc0\xaf\xbd\x71\x32\x89\xa7\xb2\x77\xd0\x9d\x76\xeb\xc8\x85\x0b\x47\x5a\xed\x35\xa0\x35\x99\xb4\x21\x9b\xe0\x9f\xb1\x5f\xe7\x75\xc0\xb7\x2a\xa3\x5a\x04\x6d\xb6\xdf\xb4\x4e\x18\x33\x5e\x23\xfb\x1d\x37\x24\xe2\x04\xe8\x51\x1b\x12\x91\xd5\x4c\x5a\x01\x75\x25\x14\x21\x5e\x41\x0b\x00\x49\x31\x08\x29\xbf\xde\x39\x31\x91\x43\x7c\x47\x1e\xd8\x44\x18\x83\x4d\x07\xb4\xe0\x90\x9b\xdf\xb0\x41\x1b\x37\x18\x59\xdd\x8c\x19\x3a\xd6\xa8\x7f\xd6\x6e\x18\x3b\x56\x1f\x0f\x42\xbe\xa4\x84\x87\xbc\xe1\xb7\xcc\x4e\x05\x52\x53\xea\x04\x71\x25\x79\xb7\xb0\x6f\x7c\xb7\x26\x35\xd8\xb2\x0f\xec\xd9\x67\x94\xe8\x74\x31\xe3\x1a\xf4\xfc\x1a\x63\x4c\xab\xb9\xd1\x30\xa9\x6f\x12\x0f\xfd\x31\x43\xd9\x8d\x65\x86\x98\x5e\x77\x91\x3e\x1d\xfd\xad\xe3\xf4\xc2\xbd\x21\x36\xd3\x6a\x02\x1a\x66\x34\xf2\xeb\x4b\xa1\xe0\x85\x18\x09\x47\x7a\x01\x69\x16\xb5\x0c\xfd\x04\x64\xb2\xdf\xb4\x8e\xd1\xc9\x4c\x5d\x80\x8f\x10\xbf\x7f\x2f\x79\x7f\x20\xef\x04\x72\xd9\x45\xbe\x7f\x82\x1a\x46\xf0\x93\x7e\xd3\x9b\x55\x13\xdb\x51\x40\xb4\xdf\x89\x85\xa9\x60\xbe\xe2\x31\x71\xb4\xe0\xb7\x08\x10\x55\x77\x62\xbe\x88\xa9\x5c\x4c\x28\xf0\x62\x59\x92\x19\xfa\xf5\x8f\xdf\x25\xb5\x29\xa2\x0a\x5a\xfa\xc4\x13\x52\x1a\x07\x6c\xd2\xbf\xa9\xf1\xcb\xaa\xd5\x7f\xbb\x30\x1d\x2d\x57\x69\xe0\x55\xd0\xa4\xaa\x49\x9f\x7f\x53\x8b\xe0\x2b\x04\xf1\x95\xbe\xfb\x0e\x5f\x21\x88\xaf\x04\xf2\x79\xfc\x87\x8e\x5d\x98\x9e\x92\xe0\x2b\xd2\xe4\xd2\x72\x1c\xe8\xfb\x3d\x0e\x60\x9e\x27\x74\x76\x37\x7b\x1c\xb7\x17\xd1\xd0\xc5\xe4\x91\x04\x8a\x8e\x7d\xe4\x98\xeb\x31\xd9\x08\xed\x94\x08\xf6\x7b\x5c\xc7\x83\x80\xa8\x24\x0d\xdc\xee\x63\x8f\xcf\x9c\x5a\xf7\x87\x3b\x0a\xdb\x3b\x1c\x75\x73\x67\x2c\xed\x1a\x6b\x07\x76\xdb\xb8\x55\xab\x87\xdf\xbb\x7c\xfb\x1d\x6f\x1f\x7a\xf4\xb9\x72\xce\xda\x50\x51\xa7\x77\x97\x47\x62\xb5\x7f\xbc\xa3\x1a\xbe\xf4\xb2\xf9\x0a\xf4\xed\xed\xb6\xfc\x22\x5d\x6c\xc9\xb5\x1f\x03\x0e\x5c\xf2\xd6\x7b\x68\x37\xfa\xea\xe5\xae\x7b\xbf\x1c\x02\xc2\x87\x7b\x7f\x38\xd6\xbb\x6f\x3d\x60\x94\xa1\xac\xd9\x23\xc6\x76\x4e\x9f\xf0\xf4\x5f\xd2\x32\x7d\x4e\x9c\xd7\x24\x94\x1c\x73\x53\x7a\xcc\x99\x5a\x09\x36\x00\x0f\x74\x01\x36\x11\x92\x81\x40\x66\xc3\x19\xf3\x6e\x3a\x36\x80\x69\x14\x9d\x21\xed\x54\x8c\xb0\x24\x22\x0b\xfd\x57\x38\x01\x3d\x8a\x1e\xff\xfd\xef\xe9\x28\x0e\x7d\x87\x1e\x6d\x05\x5a\xbc\x78\x7d\x7d\x35\x68\x4b\xdd\xc5\xbc\xf9\x7b\xf4\x38\x50\xa5\xee\xa2\xa3\xde\xbe\x37\x8d\x79\xc6\xbe\x37\xbd\x5e\x3a\x8a\x03\x38\x01\x2c\x42\x97\x80\xd9\x1f\xf9\x37\x6c\xe8\x7b\x1f\xec\x38\xf4\xd1\xe5\x4f\x3c\xf1\xc4\xa4\x8f\xc0\x6c\x74\x09\xfa\x6a\x03\x80\xfe\x43\x60\x07\xba\x29\x37\xf5\x61\xb6\x39\xf5\xa1\x4a\x05\xbd\xe6\x6c\xe8\xcd\x36\x43\x2f\xa6\xe4\x3f\x34\x67\xf0\x5a\xf1\x8b\xb0\x2b\x71\xbf\x1c\x2b\xf6\x49\x61\xd7\xce\xe7\xc9\x85\x82\x84\xa3\x1f\xc0\x83\xe8\xdd\xeb\x71\x26\x10\x98\x67\xa2\xad\x90\xc1\x0b\x77\xb1\xd1\xf4\x2e\x1e\x97\xd1\x01\xf3\x79\x45\xaf\x5a\xd2\x45\x57\x7e\x71\x37\xa3\xa1\xcf\x0c\x06\x90\xbd\xef\x8b\x4b\x26\x2a\xf7\x2f\x9b\xd2\x3a\x0c\x84\x1e\x3b\x00\x2c\x77\x82\xd3\x6f\xdc\xb3\xf6\xca\xd9\xda\x1a\x65\x43\x6b\xa2\xb5\x35\x96\x37\xa2\xae\x6e\xe8\x88\xc5\x75\xab\xee\xbe\x67\xcd\xb5\xd3\x26\xd5\xb7\x94\xb4\x37\x97\xe5\x0e\xaf\xab\x1f\xda\xb1\xa8\x66\xf5\x7d\xb0\xaf\xe0\x95\xd5\xfb\x3f\x05\xf2\x7f\xde\x75\xc9\xd3\xf1\x50\xee\xd2\x3b\xca\x6f\x3e\x72\x3b\xfa\xe2\x4e\x89\x05\x7d\xbd\x7a\xfb\x74\xc3\x50\x75\x5d\x43\x3c\xd6\x98\xd3\xd8\xd1\xd1\x98\x73\xed\x8a\x55\xdb\xa7\x2e\xa8\xad\x8f\x96\x0d\x12\x13\xb6\x9d\x6f\x7f\x20\x62\x6f\x12\xab\x9a\x04\xe1\x3f\xce\x37\x1a\xf0\x67\xe1\x57\x89\x98\x13\x20\x11\x2c\x49\x84\x24\x5a\x2a\x0b\x1f\xbd\x21\x4e\x9f\x15\x17\x7c\xcb\xb2\x66\x3c\x01\x73\x26\x03\x7c\xed\x97\xaa\xff\xb0\x17\x6d\xbe\xff\xf9\x8e\xfb\x3a\x9e\x3f\xf3\xcd\xf3\x0e\xc7\xf3\x9d\xb0\x1e\xac\x15\x13\x5e\x4b\xbb\x8a\xa5\x67\x3c\xdf\xd9\xf9\xbc\x43\x42\x5d\x44\x53\x58\xdd\x49\x2a\xe1\xaa\xa4\xc2\xfd\x68\x73\xea\x39\x21\x01\x04\x3f\x16\x2b\x4b\x9f\xbf\x5f\xbc\x9c\xb0\x5f\x93\x25\x39\xc1\xfe\x85\xa0\x40\x80\x73\x0a\x4e\x7a\xa2\xcc\x4f\x11\x7c\x82\xac\x6a\xb2\xe5\x1f\x8a\x99\x18\xbd\xe4\xc4\x95\xff\x44\xbd\xa8\x07\xf5\xfe\xf3\xca\xe7\x41\xfb\xd1\x0f\xd0\x07\x69\xbf\xb6\xb3\xd0\x07\x1f\x1c\x05\xed\xcf\xc3\xe4\xc3\x24\xf3\xca\x7f\x82\xda\x87\xff\x04\x96\x7e\xed\x3e\x99\x8f\x7a\xfe\xb1\x51\x74\x63\xbb\xf1\x1f\xa0\x2b\xff\xa4\xfb\x6b\xb4\x8d\xe8\x84\xf3\x78\x3e\xfb\x37\x6e\xc3\xe9\xb8\xa7\xc7\xf5\x89\x48\x31\x1e\x85\x8c\xa0\x4c\x22\x18\xb0\x03\x62\xe6\x4e\x36\x35\x13\xc4\x7c\x23\x2e\x68\x03\x11\x82\x91\x64\x0a\x01\xb5\x60\x15\x2f\x1a\xbb\x17\x30\x98\xeb\x89\x9a\x8a\x5d\x52\xb3\x3e\xad\x5b\xce\x4b\xff\xfa\x12\x0b\xa4\xe1\xda\x52\x0f\x3b\x74\x48\x64\x4e\x6b\xb5\x56\x1b\x72\x68\xec\x2a\xb5\x3c\x3b\x3f\x47\xad\x9a\x13\x6a\x33\xf0\x20\x64\x34\xdc\xde\xe3\x09\xd1\x8c\x69\xb8\xc3\x31\x3b\xaf\x83\xe7\xdd\x5e\x43\xa1\x67\xfc\x88\xc1\x26\x63\xe5\x50\x0b\x93\x95\x53\x9c\xad\x56\xa9\x39\x79\x38\x7f\x78\x71\x63\x6e\x91\x83\x07\xf4\x87\xe8\x92\xb3\x87\xd1\xa1\xcf\xb7\xc0\x5d\xc7\xc1\x6a\x3c\x42\xa4\xd1\x59\x2b\xf6\xec\x3c\x30\x38\x12\xd2\xba\x75\xda\xe8\xa6\x25\x33\x5c\x4e\x6b\xb1\xc7\x26\x91\x2c\xd5\x35\xd9\xec\x45\x8b\xb2\xdc\x4f\x3e\x5e\xb0\xd8\xeb\x09\x0c\xd6\xe9\x96\xaa\x87\x38\x9d\xa5\xb7\x1c\xae\xcd\x77\x1b\x3c\x3a\x6d\x6c\xed\x8a\xb5\xdd\xb3\x47\x56\xe9\x74\x2a\xda\xe9\xad\x8f\xb4\x37\xcf\x9a\xb3\x71\x30\x4a\xa1\x19\xff\xb8\xf1\x67\xd0\x21\xd2\x3d\x42\x5f\x53\x62\x3e\x37\x4c\xb5\x53\x93\xa8\x05\xd4\x2a\xea\x4a\xea\x26\xe2\x6f\x23\xe8\x27\x9e\x13\xf0\x7f\xcc\xd4\x71\xf8\x18\xd4\x26\xcc\x12\x8e\xa8\x5d\x13\x2b\x46\x2e\x16\x4f\x84\xe2\x09\x73\x9c\xe6\x88\x21\x97\x84\xa8\xee\x98\x71\x17\x4c\x04\x43\x44\x6b\x9b\x74\x4b\x92\x8b\x8f\x11\x7c\x01\x7c\x19\x3c\x51\xa6\x8b\x85\xe2\x7e\x4a\x8b\x8f\xa2\xee\x25\xae\x90\x20\x55\x84\x5a\xa4\x2b\x50\x03\x8c\x61\x18\xd1\x38\xe6\x3c\x35\x78\x7a\xde\xdb\xe8\xb6\x79\xe5\x00\x00\x40\xff\xbf\xce\xbc\xba\x1b\xdf\xd7\xd5\xa5\xfe\x36\xd2\x64\x2f\x9b\x36\xad\xcc\xc5\x77\xf8\x58\x69\xf9\x3c\x74\xdb\xdb\xa5\x75\xba\xf7\x6f\xac\xcb\x5b\xfd\xa9\x5a\xfd\x2f\x77\xc3\xe1\xb2\xce\xa2\x92\x89\x25\x45\x9d\x65\x87\x1b\xdc\xff\x52\xab\x3f\xf5\xd4\x1f\xae\x18\x57\x94\xb7\x20\xaf\x68\x5c\xc5\xe1\x7a\x94\x53\x57\x4a\x8a\x07\x7d\x65\xf3\x40\x17\xa3\x9d\x56\x66\x37\x8d\xf4\xfb\x3a\x78\x57\x99\xa9\xcc\x17\x24\x37\x29\xad\x7b\x07\x74\x01\xd5\xd6\x93\xe8\x45\x74\x00\xbd\x78\x72\xeb\xd6\x93\xa0\x12\x74\x82\xca\x93\x8f\x5d\x64\x80\xcc\xaa\x97\xbc\x75\xd0\x5b\x1c\x29\xbb\x27\x6f\x8c\x12\xea\x1c\x95\x25\x9e\x43\xe0\xe6\x43\x9e\xd2\x52\xc7\x8c\xee\x85\xe8\x5f\xde\x83\x6f\x49\xea\x81\x72\x4c\xde\x3d\x65\x11\x38\xa1\x3d\x67\x4c\x4e\xfb\xc4\xd6\x3b\x1a\xf4\xdf\xc8\xe5\xdf\xe8\x1b\xee\x68\x9d\x28\x24\x4d\x6a\xb9\xa3\x51\xff\xb5\x5c\xfe\xb5\xbe\xf1\x8e\x16\x18\xac\x87\x8a\x31\x39\xf7\x96\xe6\x94\x7a\x0e\xbe\x95\xba\x1f\xcd\x3a\xe4\x29\xa9\x74\xcc\x5e\xd8\x3d\xc3\x51\x5a\xea\x09\x7a\x70\xc6\xbd\x39\x63\x14\x10\xdf\x1a\xaf\x9d\xe4\xc9\xb6\x0e\x7c\x5a\xb8\xef\x62\xda\xf9\xe7\x64\x59\x1c\xa5\xc5\x54\xdf\x20\x6a\x2e\xb5\x94\x68\x37\x06\x0c\x44\x4a\x1c\x8d\xd0\xe9\xb3\x29\x11\x93\xf8\x32\x6a\xf7\x46\x82\xfe\x4f\x0e\x04\x5e\x84\xb0\x1d\x64\x1a\x16\x38\x90\x50\x9c\x8f\x0a\xab\x86\x8f\xd0\x37\x6c\x4c\xc4\x8d\x8f\x98\xa2\x31\x1f\x49\x23\x6e\x05\xc8\xf4\x1b\x35\xfa\x70\x65\x5a\x10\x1e\x89\x82\x98\xf8\x85\x2e\x50\x61\xd3\xa4\xf9\xd3\x66\xf9\x9b\x5b\x5b\xfd\xc1\x03\x6d\x65\x91\xca\x31\xcb\x2b\xf2\x82\xd9\x8b\xc3\x8d\x2d\xb9\x27\xba\xda\xec\xc5\xc5\xad\x9d\xf2\xc0\xe0\x2b\x21\xbc\x92\x06\xa7\x5d\x78\x9a\x97\xf9\x64\x73\xe9\x6b\x98\x4a\x3f\xa0\xb5\x98\x7b\xd3\xbb\x4b\x83\xb5\xe8\xd5\xa2\x21\xc5\x91\xa6\x62\x38\x63\xa0\x48\xec\x64\x7d\x4d\x2d\xd8\x39\x7a\x54\x67\x34\x70\x99\xd3\xb9\x64\x4c\x64\x8e\x86\xd6\x35\xc6\x2c\x74\x60\x56\x7e\x83\x4f\x7b\xa4\xa1\x56\xcd\xba\x2d\x79\x52\xcd\x25\xc3\x2d\x0e\x19\x9a\x6a\x4f\x80\x4d\x05\x66\x73\x11\x5a\x19\x91\xad\x32\x76\x7c\x0c\x97\x75\x18\x2c\xee\xc2\x65\x34\x80\xc7\x03\xf1\x8a\xa0\x05\xbe\xe7\x4f\xc4\x03\xfe\x58\x7c\xe4\x05\x18\xaf\x12\xaa\x11\xcf\x43\x47\x04\x0c\x6c\xad\xb0\x87\xb9\x80\x5a\x41\xbc\x7a\xf8\xbc\xc4\xbf\x02\x4d\x56\x24\x12\x20\x23\x43\xf0\xa4\x2e\x20\xb3\xb0\x46\xad\xc7\x2b\xa8\x26\xc7\x08\xf3\x10\x4b\xcb\xf1\xcd\x11\xe0\x23\x5a\xf5\xa1\x28\x51\xb5\x0f\x18\x05\x54\xab\x98\x2e\x1a\xf3\x0a\x88\xfd\x04\x9e\x1f\xe7\x44\x8d\xc4\x55\x98\xce\x90\xd6\xfc\x16\xd7\x3f\x38\xf2\xae\xdb\x0e\xee\xae\xa8\xac\x58\xbb\x76\x05\x50\xf9\x73\xb5\x3b\xd6\x86\x43\xf9\x83\xc7\x8c\x19\x9c\x8f\x76\x0e\x5a\x7d\x49\xdd\x13\x0d\x35\x43\xa6\x3c\x77\x4d\x57\xc7\x34\xf0\xc4\x87\x0c\xf3\x21\x03\x27\x0d\x9e\x5d\xdd\x19\x71\x4a\x21\x67\x91\x18\x83\x5d\x92\xbf\x4b\xee\xd7\x94\xa9\x47\x8f\xad\x4a\x7d\xdd\x56\x56\xde\x3e\xbc\xa2\xdc\x34\x63\xce\x4c\x7a\x62\x55\xc7\xf5\x5b\xc1\x9b\xaf\x29\xe5\xb9\xd9\xeb\x1f\x33\x4b\x83\x21\x77\xb6\xd9\xe8\xca\x1f\x59\x86\xde\xb6\x96\xcd\x6f\xbe\xab\x92\xc9\x1e\xbd\xd0\xc1\x58\xee\x1d\x71\xf5\xe1\xc2\xbe\xe7\xf2\xc7\xc3\xa9\x93\xbd\x9e\x09\xa9\x5b\xc6\x3f\xf2\x62\x28\x5c\xd9\x35\xae\x02\x4c\x61\xa0\xe4\xb9\x96\xb8\x2f\x7b\xed\x73\x0c\xba\x61\x13\xa3\xbe\x74\xec\xd8\xf2\x8a\x71\xd4\x2f\xfc\x52\xcb\x80\x8f\xc6\x93\x07\xed\x03\xba\xe8\x2f\xec\x3d\xb2\x81\xbc\xfb\x56\x8b\x21\xe7\x96\x95\x80\x9b\x09\xff\x72\x9e\x52\xba\x01\x7c\x87\xbb\x42\xde\x44\x50\x8a\x78\x74\x84\xbe\xea\x7c\xdf\xb3\x65\x67\x29\xe6\x15\xfc\x8d\x9c\x02\x56\x90\x08\x0e\xc6\x41\x22\x01\x23\xdb\x5e\x41\x11\xb9\x91\x98\xa4\x10\x0b\x71\x01\x1b\x46\x80\x9d\x24\xda\xbb\x22\xb0\x10\xd9\x64\x16\xc0\x8f\x89\x62\x05\x26\x42\xe8\xe6\x25\xc3\x2b\xa3\xd5\xb1\x9f\xf2\x81\xdd\xc8\xe2\x61\xa2\x36\x06\x9b\x1a\xc3\x55\x83\xb5\x8b\x7b\xc0\xbf\xf7\xa2\xef\x6e\xab\x6d\x30\x9a\x59\xd6\x6f\x8c\x96\x4d\x7d\x34\xd9\xd2\x92\x7c\xf4\x79\x7c\x2a\x91\xab\x82\xd9\xf2\xda\x49\x7b\xff\xba\xfc\x36\xa0\x62\x0c\x3d\x8b\x7d\x0d\xc3\xd1\x36\x64\x31\x79\xa0\xdd\xb0\xee\xbb\xdf\x3d\xbe\xb1\xb2\x73\x98\x2f\xa7\x7d\x71\x01\x1e\xd8\xdf\xef\x55\xb3\x01\x7c\x67\x46\x95\xae\x8e\x4f\x53\x97\xcc\x31\x84\x0d\x6a\x7e\xcd\xf6\x15\x7f\xdd\x3b\x71\x2f\x5e\x07\xf5\xe9\x75\x90\x20\x35\xa7\x15\x65\x13\x04\x5a\x84\x58\x6e\x4b\xdc\x44\x6b\x9d\x8c\x63\x60\x4c\x53\x55\x04\x85\xd2\xc7\x11\x78\x4d\xb3\x88\xd6\x94\x76\x29\x23\x28\xda\xe2\xde\x26\x3a\x96\x21\xfb\xe9\x02\x50\x0c\x11\x55\x88\x8d\x14\xd3\x02\xb5\xd4\xa4\x02\x3a\xf5\xe1\xcb\xae\x3e\xbc\x65\x4b\x71\x47\x65\xc4\xeb\x36\x28\x41\x42\x4f\x33\xad\x63\x43\x7e\x99\x51\x67\x54\x68\x01\x26\xb2\x2a\x86\x1a\x46\x26\xa4\x90\x61\x6b\xff\x1d\x5b\x3a\xa2\x56\x23\x55\xd7\x4a\xb3\x1f\xe8\xf0\x35\x2e\x1f\x55\x67\x70\x2b\x2a\x0c\x8c\x1c\xc2\xa2\x95\x2a\x96\x91\xea\x87\x66\x03\x86\xa1\xcd\xf0\x3d\xde\x63\x28\xd7\x9a\xaa\x95\x57\x83\xdc\xca\xfa\x84\x31\x5e\xde\xd6\x34\xbd\xbd\x9c\x1d\xd9\xa0\x2e\x51\x02\x96\x05\x4b\xfe\xb0\x20\x77\x89\xc6\x90\x65\x74\x43\xc0\xdc\x3c\xc8\x10\x28\xc8\x61\x2c\x92\xa9\x7a\x13\xcf\x42\x06\x80\xfc\x30\xad\xb1\xc5\x03\xe1\x90\x13\x9a\x00\x84\x90\x56\x3c\x5b\x4d\x1b\xb2\x1b\x18\x19\x88\x17\x00\x3e\x43\x77\x55\x63\x3a\xf3\x79\x01\x27\xdc\x83\x69\xe4\xa1\x02\x86\xec\x39\xa2\x7d\xa0\xa8\x1b\x5e\x3c\x19\xe0\x20\x43\xfa\x83\x30\x38\x43\x5c\xc2\x4f\x50\x45\x08\xb2\x1c\xd1\x5e\x31\x8b\xa0\x73\x5a\x81\x52\x35\xc1\xc6\x48\x76\x6e\x7d\x7d\x6e\x36\x6d\x8d\x86\xed\xf9\xf9\xf6\x70\xf4\x8b\x62\x31\x05\x1e\x2c\x09\x91\x94\x50\x09\xfa\xd1\x1d\xba\x17\x9d\xbc\xd3\xec\xf3\xd8\x8a\xaa\xed\x1d\xb2\xd4\x10\xf4\xe1\x0b\xa0\xf5\xa5\x87\x41\xd9\x31\xb8\xe8\xca\x65\x89\x57\x76\x35\x92\x02\x77\x02\xc7\xbd\xb7\x03\xc7\xfd\x8c\xbc\x23\x12\x0d\x87\xa2\x68\x8a\x23\x2f\xdf\xee\xc8\xcf\x03\x5f\x5d\x98\x70\x1f\x73\x33\x3a\xb5\xb7\xad\x99\xa6\xe5\x8c\x0e\xae\x7f\xef\x75\xe0\xbe\x17\x38\xee\xdc\xfc\x69\xaa\x66\xd9\x9f\xc6\x3e\xbe\x30\xb0\xed\x5b\xe0\xfa\x76\xdb\xb6\xef\x44\xfc\x12\xc9\x59\xdc\x34\xae\xb4\xaf\x61\x81\x67\x0d\xd0\x22\x44\x52\x0c\xf3\x0c\x04\x39\x4b\xc0\x76\x90\x9c\xf4\x48\xce\x52\xac\x5d\xad\x53\xa8\x50\xc5\xb7\x7a\xb7\x4a\xc6\x9b\xe9\xae\x33\xc7\xd0\xb2\x00\x0d\xbd\x92\xa4\x06\xaf\x08\x3f\x58\xc2\xa7\x29\xa7\x56\xca\x1e\x46\xc7\xcd\x0c\xe7\x31\x80\x49\x8c\xaf\x6f\xfa\x1d\xea\xec\x30\x4f\xf7\xca\xce\xe1\x25\x9c\x65\x7f\xc2\x9c\x68\xd6\x79\x77\x05\x99\xbb\xa6\xef\x09\x78\xc0\xca\xc0\xc0\xfb\xa6\xbe\x41\x7f\xd6\x3b\xd5\x32\xde\x84\xc2\x01\x9a\xf6\x49\x92\x3e\xf4\xfa\x07\xa7\x67\x81\x76\x7a\x0a\xf2\x9e\xbb\xfb\x5f\xd0\x61\xa3\x70\xf7\x17\x7f\xaf\xce\x0e\x19\xe8\x5e\xe3\x69\x35\x9b\xdb\xf7\xd2\x95\x70\x7d\xdf\xdf\xcf\x9b\x77\x4a\x84\x39\x81\xd0\x1f\xf8\xcb\x89\xbc\x6c\xd4\x94\x56\xdd\x17\x34\xfa\xf1\x57\x35\x71\x99\x99\x48\x80\x0b\x16\x3e\x2e\x7b\xbe\x43\x5b\xd1\x7c\x5f\x42\xad\x3e\x8a\x4e\xee\x3d\x88\x5e\x5b\xc8\x01\xe9\x95\x72\x8d\x96\x1b\xfa\xee\x8a\x39\xcf\x5e\x35\x62\xc4\x55\xcf\xce\x99\x76\xa8\xe9\x4a\xe2\x8e\x1a\xd5\xda\x82\xe1\x90\x6b\xe3\x7c\xc0\xdf\xb0\x17\x38\x8e\xa6\x4e\x67\x94\xf7\x4e\x08\x4a\x68\xb4\x03\xbd\x4a\xb0\xb9\xae\xdf\x2c\xb7\x4a\xaf\x92\x41\xf9\x94\x39\xb8\xfa\xdb\xf8\x2a\x83\xeb\xaf\x72\x85\xc2\x44\x97\x90\x78\xe6\xde\x30\x73\xd1\xea\xa3\x7b\x50\xbf\x36\x5f\x57\x46\x7f\xed\x9c\xfe\x8a\x9d\xf0\x15\x6a\xa8\x15\xe8\x70\x6d\x01\x38\xcf\x9a\x6c\x23\xea\x13\x29\x6b\x81\x04\x9f\x75\x3f\xb8\xfe\x02\xc1\x21\x4b\xe1\xcc\x81\x85\xd0\x93\xbf\x90\x0d\x56\xe3\x7b\x3d\x8f\xef\xb5\x05\xd3\x93\x69\xed\x33\x61\x96\xc4\x33\x08\x11\xd3\x09\x60\x84\x46\xda\x60\x76\xd1\x69\xae\x6e\x60\x89\x10\x6e\x37\x82\x3c\x0c\x32\x6e\x9f\xf0\x08\x13\xb8\x37\xa2\x75\x6e\xe4\x89\x68\xcf\x43\xe6\x22\xbe\x24\x54\x00\x2f\x5e\x42\xb8\xae\x64\x47\xde\x23\xf9\x79\x0f\xe7\x59\x6c\xde\xbc\x72\xad\x07\x00\x55\x20\x35\x29\xa8\x02\x20\xa0\xad\x8d\x84\xad\x96\xc2\xc3\x05\xb9\xf7\xe5\x98\xad\xee\xec\xb8\xc6\x43\xb0\x2f\x59\xa9\x5a\xa6\xa9\x2c\xf0\x5b\x2c\x05\x87\x0b\x72\xee\xcd\xb1\x5a\xbd\xb9\xa5\x1a\x1f\xae\x68\x83\xcf\x58\x71\x45\x9f\x7e\x44\xd4\x6a\xc5\x97\xcc\x3d\x98\x6b\xb5\xfa\xf2\xcb\x71\xa6\x57\x5b\x59\xe8\xb7\x24\x39\x2e\xdb\xea\x76\x31\x72\xb9\x71\x05\xd8\x6a\x94\x33\x8c\xdc\x88\xb6\x6d\x37\xc9\x25\xc0\xe9\xb6\xe5\x71\x5c\x8e\xc5\xe5\x62\xe5\x72\xf3\xca\x32\x3a\x9f\x2e\xb0\x47\xbc\x21\x8b\x44\xce\x38\x84\xbc\x3c\x9b\xcb\x0e\x25\x72\xe3\xd5\xa8\xd7\xa8\xa0\x69\x85\x11\xd4\x5e\x8d\x03\xe6\x60\x3a\xd3\x01\x58\xb9\xf9\xaa\xbe\x11\x2b\x8c\x72\x0e\x3a\x5d\xb6\x3c\x01\x63\xc8\x72\x36\xc9\x20\xdc\xc6\x79\x69\xfc\x08\xc1\xfc\xe4\x9c\x82\xb6\xaf\x3f\x44\x94\xef\x45\x3b\xe1\x78\x36\xc1\xbb\x40\x01\x4b\x84\xb1\x49\x68\xbf\x75\x81\xd5\x7f\xad\xcf\xb6\xc0\xe6\xbb\x61\xda\xba\xfa\xda\x71\xe3\x56\x2d\x02\x11\xf0\x91\xd5\xcf\x36\x0c\x75\xd6\x02\x89\x55\x11\x3b\x93\xb4\xfa\xfd\x56\xe6\xf9\x33\xd5\xe4\x0c\xbe\x56\x16\x96\xaf\x5a\xb6\xfd\xc0\xca\xe5\xd9\x01\xbf\xc0\x47\x90\x3e\x45\x0d\xf0\x3b\x42\x34\x88\x1b\xa8\xc1\x98\xda\x31\x7a\x62\x81\x5f\x68\x0a\x7b\x62\xbc\xd1\x17\x23\x67\xfa\xc2\xbc\x0b\xf7\xca\x70\x39\xe2\xa6\x12\x74\xa1\x1e\x28\xb8\xd7\x4a\xe3\xba\xf5\xf4\xf5\x9c\x38\x21\xa1\x52\x59\x27\xce\x25\xd2\xc9\x73\x61\x58\x7b\xe2\x44\x5f\x0f\xd9\x21\x1d\x00\x22\x17\x04\x38\x0e\xa9\x64\xb2\x0f\xff\x98\xf3\x72\x10\x35\x30\x96\x2e\x26\xca\xb7\xd3\xbe\xe9\x89\x36\x05\xf1\x1e\x82\xdb\x90\xe0\xec\xe1\x99\x1c\xaf\xa3\x01\xd2\x39\xb3\x70\x3a\x9e\x9d\x58\xcc\x09\xb1\x71\xa6\x77\xcb\x33\xcf\xa0\x1f\x9f\x81\x68\xcf\xc4\x75\x38\xb8\x65\xdd\x44\x30\x07\x12\xb8\x37\x12\x44\x7b\x20\x04\x73\x26\x42\x8a\x14\x79\x66\x8b\xd2\x74\x68\x0c\xc9\x1a\x73\xc8\xa4\x14\xab\xe1\x90\x05\x27\x9e\x37\x56\x03\x54\x8c\xa2\xfc\xa2\x0d\x6c\x1c\xb3\x4c\xa6\xa8\xb8\x95\x8c\x97\x1a\x2e\xe3\x1c\x2f\x21\x18\xc4\xfe\xc2\x94\x8f\xa5\x2e\x1b\x37\xaa\xea\x1b\x08\xbf\xa9\x1a\x35\xee\xb2\xcb\x1e\x5e\x07\xbf\xa9\x1e\x89\x03\xe3\x46\x56\x7f\x03\xd7\x3d\x0c\x2e\x1b\x48\x2a\xa5\x1e\x5e\x57\xbe\x52\xab\xd6\xae\x2c\x5f\xf7\x30\x2e\xc2\x69\x57\x96\x5d\xf6\xf0\x65\x65\x2b\xb5\xdc\xb8\xcb\xe8\x13\x03\xe9\x26\xae\x9f\x77\xd4\xe1\x6f\x5d\x4d\xb5\x50\xe3\xa8\x19\x98\x7b\xa0\x28\x61\xdb\x57\xd8\xe1\x15\x04\x13\x89\x38\x30\x13\x9c\x3d\x8d\x80\x80\x70\x8e\x91\x8b\x12\x5c\xf5\x88\x1b\xf0\xc2\xe6\x71\x5a\x6b\xd6\x84\x97\xce\x81\xb1\xb8\xd8\x77\x85\xf9\x33\x94\x56\x5d\x11\xa4\xea\x22\xb6\x4b\x89\x08\x8d\x66\x80\x83\x0c\x45\xd6\x05\x07\xf2\xe4\x06\xab\x4a\x91\xa3\xf7\x6e\x18\x65\xa5\x9f\x2a\xf8\xbe\x91\xe7\x6b\xc7\x13\xdc\x54\xf4\x37\x02\xcb\x2a\xc0\xa9\x3e\x71\x7b\x2d\x1f\xe3\x1b\xcf\xc8\x95\x2a\xf9\x04\x99\x4c\x6e\x93\x77\xca\xdf\x57\x58\x14\x9d\x72\xb9\xcc\x2e\x9b\x20\xcb\xd2\xab\x05\xe0\x93\x2e\xf5\x83\x7a\x87\x1e\xff\xdf\x3d\x81\x14\x95\xe3\x62\x36\xb9\x8c\xbe\x39\x62\x90\xe7\x1d\x58\x60\x2d\x92\xb3\xe1\x51\x1b\xbc\x0a\xf0\x40\xc1\x77\x8d\xf8\x82\xb5\xb7\x3f\x71\x6d\xe6\x1e\xc0\x45\x70\x5f\xc7\xd7\xf2\x7c\x23\xc8\x4b\x57\xc4\x57\xb6\x7f\x25\x1c\x65\x42\xca\x33\xc2\xb5\x7b\xd2\xb7\xd2\xeb\x07\x65\xee\x8f\x9f\x28\x8d\x4b\x40\xda\x96\xa1\x0c\xe4\xcb\x83\x00\x4b\x7b\xe0\x05\x5b\x40\x20\x4e\xcc\x80\x79\x73\x30\x64\x66\x03\x09\x09\x97\xe0\x89\x51\xb0\x39\xc1\xf2\x9c\x29\x92\x08\xf1\x01\x38\x15\xb8\x81\x7b\x21\xba\x95\xfd\xe5\x1e\x10\xb3\x70\xe7\xac\xaf\x6b\x2e\xdf\xf5\x55\x0c\x7d\x8c\x3e\x8e\x7d\xb5\x6b\x6b\xf5\xd7\xb3\x76\xba\x40\xd3\xd5\x97\x2e\xfb\x71\xd9\xa5\x57\x83\x26\xf8\xf6\xdb\x6f\xa3\x87\x99\xe4\x45\x18\xdc\x33\x43\x5e\x3f\x43\x8f\x3f\x01\x1a\x94\x47\x5b\xd6\xee\xdb\xb7\xb6\xe5\xa8\x12\x3d\x7b\x62\x3c\x7d\xe6\xf5\xcd\x61\xf4\xe7\x41\xa1\xd0\x20\x90\x13\xa6\x04\xdf\x75\x69\xff\xd0\x19\x9b\x82\xa1\x82\xd7\x10\xb2\xc3\x70\x07\xf5\x28\x75\x84\xcc\x0e\x19\xcf\xd5\x69\x57\xee\x17\xc4\xc1\xaf\xe4\x07\x32\x4a\x4d\xbe\x5f\x2b\xf9\xeb\xf9\x9e\x58\x09\xcb\x08\xc0\x0e\xd5\x0c\x5e\x01\x5d\x8c\xee\x82\x22\xba\x7e\xc7\xa1\x40\xf4\x12\x29\xba\x8a\x3c\x17\x84\xb5\x17\x4d\x4e\x3d\xef\x08\x42\x18\xb4\xc3\xb3\xff\x4d\x2d\x90\x4c\x21\xb4\x11\x6d\x4c\x21\x5d\xb4\x7d\xdb\x63\x40\x05\xaa\x81\xf2\xd0\xb6\xf6\xa8\xee\x5c\x99\xa0\x1d\x25\xed\xc1\x13\xfd\x3a\xf0\x03\xbc\x8b\xa2\x25\x17\x4b\xdd\x11\xb4\x6f\xd8\x60\x0f\xa6\xfe\x8b\x2a\xe0\x2a\x95\x7c\x0e\x04\x33\xe5\x2a\x5d\x49\xcb\xb0\xd6\xf2\x40\xa0\xbc\x75\x58\x4b\x09\x1a\x7b\xae\xc4\x28\x7c\x49\x7c\xe1\x7e\xb9\x5f\x1a\x17\xc1\x20\x68\xef\x94\xa5\x71\xc0\xfa\xe7\x25\x9e\x20\x1a\x11\x41\x5f\x26\x41\x10\x25\x44\xcc\xa0\x1f\xda\x8d\xed\x0f\xc1\xde\xa0\x2d\x68\x43\x78\x42\x3e\xc5\x59\xe0\xbf\x08\xbc\xad\x18\xc5\x33\xf9\x3d\x16\xae\xef\x38\x81\x3a\x02\x59\x04\xec\x37\x13\x62\x7a\x53\x38\x3f\x25\x2c\x15\x90\xa2\xe7\x9a\x53\xb5\xb0\xb7\x2f\x89\xd2\x8b\x02\x5e\x24\x28\x33\x48\xa4\xdd\x9d\x93\xa3\x48\xe7\x0a\xcf\xec\x24\x14\xa7\x81\x23\xda\x42\x4c\x08\xe0\x05\x2a\xa8\xaf\x01\x66\x40\x04\x91\x9c\x70\x96\xfc\x4f\x20\x80\x16\xed\xea\xb9\x13\x55\x1c\x46\xbb\x1e\x07\xf3\xd6\x16\xde\xd9\xb3\x0b\x5c\x17\x9c\xd7\x1c\x40\xdd\x9f\x81\xeb\x83\xf3\x98\x8a\xe0\xdc\x20\xea\xc6\x65\x0a\xd7\x0a\x45\x0e\x83\x97\x48\x99\xeb\x03\xcd\xf3\x71\xdd\xcf\xc0\x75\x01\x41\xf6\x6f\x3d\xab\x94\xfc\x53\xf0\xdb\x67\xa4\xca\x05\xaf\x44\x03\x51\x10\x2e\xe2\xeb\xd2\xc5\x62\xea\x26\x2e\xc0\x7b\xc6\xcd\x11\x17\xac\x66\xf1\xa8\xd7\x8b\xd6\x77\x09\x5a\x10\xfb\xa7\xfd\x25\xf0\x82\xf3\x05\x17\x30\xa7\xd7\x00\xa3\x2e\x11\x37\xd1\x73\xd7\x3f\xba\x1e\xff\x07\x3f\xae\xeb\x1c\xbf\x7e\xfd\xf8\xce\x75\x1f\xd7\x0e\x3f\x73\xcf\xc8\x8a\xdc\x09\x83\x27\x44\xc7\x3b\x46\xc3\x46\xbb\x84\xb1\xf9\xb8\x45\x6c\x8d\xb9\x31\x38\x38\x3a\xb4\xaa\xf9\xe5\x55\x67\x46\xcd\xaf\x5f\x36\xa7\x6d\x0c\x03\xa4\x1e\x0e\x30\x63\x87\xcf\x59\x56\x37\x77\xe4\x99\x55\xd6\x9c\x10\xa3\xa1\x27\x37\x30\x9f\x36\x4c\x36\x86\x72\x68\xc7\xc8\x15\x2b\x46\x8e\x5a\xbe\x7c\x54\xfa\x8c\x7e\x86\xb7\x8c\x1d\xda\x38\x31\x35\xc5\xec\x35\x69\x70\x4d\xe0\x90\xd0\x56\xdb\x04\x82\x9a\x4f\x4b\x14\x5a\xb3\xdb\xb2\x73\x36\xfa\xfb\xa1\xc5\xbe\xac\xc2\xe8\x62\xd0\x04\xa0\x14\xa0\x07\x97\x44\x0a\xb3\xfc\x4b\x0e\x01\xfb\xec\x9d\x81\x12\x3b\x94\xd3\xf0\x89\x21\xb3\x66\x0d\x49\x35\x6b\xec\x25\xa4\xcd\x66\xe0\xf5\x70\x6f\x5a\x4e\x4b\xf0\x24\x70\xcf\x12\xdc\x89\xe9\xf8\x04\xb1\xc1\x37\x26\x80\x0e\x78\x38\x22\x7e\xe5\xe9\xe4\xf5\xd0\x7d\xfd\xf5\xa9\x33\x63\x40\xd3\x71\x4c\x34\xb7\xa1\xa7\x8f\x1f\x47\x4b\x16\x32\x6d\xa8\x0d\x3c\x4a\x7e\x29\x29\xa2\xed\x67\xfe\x79\xfc\x38\x73\x5f\x9f\x02\xb5\xe1\xf3\xe5\xc0\x23\xf6\xe1\xf1\x67\x01\x7b\x1f\x9b\xc2\x9c\x60\x2e\x9e\xb5\xda\xa8\x99\x64\xa6\x82\xa4\xa9\x05\x22\x4a\xe4\x82\x05\x00\xcf\x90\x44\x03\x18\xc1\xae\x31\x88\xe3\x78\x31\x22\x22\x2e\x40\x16\xc0\x50\x90\x16\xc0\x39\xd3\x7e\x1e\x08\xe6\x85\xe0\xe4\xc6\x4f\xbe\xa0\x9e\xc5\x51\x16\x4f\xda\x12\x11\x6d\x55\x50\xa9\xc1\xc5\x68\x16\xb0\xca\x50\xfc\xac\x4f\xc5\x00\x96\xa9\xdc\x0d\x2a\x34\xc5\x56\x8b\x7d\x17\x5d\xbc\x12\x7d\xa9\xf3\xf1\x4a\x56\xaa\xcf\xf1\xa9\x9e\x1d\x9c\x37\xca\x6c\xa5\xcb\xb8\x7b\xa3\x01\x9b\xfa\xbe\x42\x35\xab\xf3\x15\x81\xe5\xaf\xb7\x49\x1d\xa9\x4e\xb6\xa2\xbc\x14\x5d\x2e\xb5\x67\x83\xd6\xf2\xb0\x8c\x0e\xc2\x5b\x68\xa7\x06\xbd\xdc\x60\x01\xe6\x02\xb5\xcb\x05\x9a\x2f\x8b\xc8\x1c\x81\xa2\x5d\x92\xe3\xeb\xd1\xfb\xaa\x2c\xa9\x6c\x72\x8e\xc6\xa8\x54\xcb\x9b\x1f\x6b\xe2\x15\x32\x79\xf0\x64\x42\x13\x1a\x07\xbd\xd6\x48\xcb\xe3\x8d\xb0\xd5\xa9\xf7\xca\x72\xd1\x91\xf8\x9f\x0d\x6a\xa3\x1c\x18\x5b\x8d\x11\x63\xae\x0e\x84\xea\xed\x9c\x09\x8e\x98\x65\xd0\x8d\x83\x63\x7c\xf6\xdc\x49\x1a\xb9\x4f\x9f\xfa\xfd\xab\x21\x83\xbc\x45\x23\x85\x98\x20\x29\x0c\x83\x99\xf7\xd7\x4b\x78\x9d\xf9\x83\x32\xc1\xbe\x5f\x94\xe3\x24\xcf\xb3\x7d\xb0\x53\x3e\x4c\xb7\x12\x9f\x35\xf8\xeb\x09\x54\x9e\x4e\x80\x79\x8c\x9d\xf7\x23\x34\xac\xb0\x49\xe8\xd1\x19\xb8\xf3\x20\x1d\x3c\x31\x86\x42\x44\x92\x9f\x12\x2c\x35\x58\x0a\x61\xa2\xe9\xdc\x0f\x13\x79\xc1\x92\xa0\x24\x79\x9a\x52\xb0\xaf\x63\x9a\xae\xbb\xfd\x54\xb2\xbd\x1b\x50\xa4\xd2\x59\x4c\xdd\xd1\x94\x50\x8f\xea\x97\xc7\x0b\xbf\xbe\x5a\xba\x57\x04\x12\x66\x6a\xcf\xf4\x7a\xdc\x41\xe6\xbd\x33\x82\xae\x2a\x53\x9b\xc4\x55\x73\x28\x15\xf7\x67\x01\x6f\xc1\x8d\xe7\xb6\x11\x98\x2e\x4b\x8f\x5a\xa3\x21\xe1\xc5\xcc\x4a\xda\x8a\x26\x41\xf4\xfd\x04\x20\x30\x01\xff\xca\xe7\x25\xce\x88\x05\xf2\x1b\xaf\x2d\x42\x3a\x8f\x29\x18\x1c\x4e\xe3\x82\x9d\x4b\x67\x0c\xe1\x1d\x97\x75\x5c\x36\x07\xb6\xac\xdf\xb8\x7e\x18\xad\xdf\x2d\x6f\xfb\xe2\x1f\x5f\xb4\xc9\x77\x53\x67\x15\xca\x2b\xfe\xb5\x67\xf4\xfd\xeb\x67\x94\x43\xdd\x2e\xf9\x66\xb0\x12\x24\xc1\xca\xcd\xf2\x5d\x48\xa1\x78\x0c\xad\x47\xa5\x68\xfd\x63\x0a\x85\x6e\xb7\xfc\x19\xc8\x40\x1b\x64\x9e\x91\xef\x56\xdd\x60\xc8\xca\xcb\xcb\x32\xac\x8d\xe0\xbf\x5d\x7a\x95\xbc\x75\xdc\xb8\x56\xb9\x4a\xbf\x0b\x68\xa5\x73\xa7\xe7\x55\x57\xe7\xed\xd2\x2b\xe5\x9b\x77\xec\xd8\x2c\x57\xe2\x44\x8d\xec\xd6\x7d\xfb\x6e\x95\x91\x82\x4f\xbf\xf1\xc6\xd3\xa4\x20\xd1\x82\x13\xec\x66\x84\x7d\xcc\x81\x52\xa9\x1a\x6a\x18\x35\x92\x9a\x4e\xcd\xa7\xd6\xe0\xc1\x79\x81\x4f\x38\xea\xbf\x3c\x13\x6c\x48\x11\xd5\x2e\x12\x1f\x98\x36\x10\xeb\x4e\x3b\x40\x07\x7b\x20\x8d\x0b\x92\xc3\x88\x5e\x04\x78\x5d\x38\x21\xf1\x44\x0f\x1b\x18\xbb\x68\x22\x3d\xac\x65\x4e\x0b\xfe\x8f\x32\xf5\x33\xe6\x78\x2c\x3e\x0a\x49\xaf\xb7\x94\x9c\x16\x24\xe7\x2c\x3e\xc6\xe6\x89\xb5\xc9\x7f\xf0\xba\x70\x42\xaf\x0f\x8c\x5d\x34\x31\x95\x04\xe7\xa4\xf7\xf0\xac\x98\xd5\x2b\xc0\x52\x8b\xfc\x06\xba\x4b\x48\xa3\xa9\xd3\x14\x29\x27\x21\x47\xe2\x11\xef\x2c\xc5\x7e\x25\x21\xb8\x7a\x83\x84\x7d\x10\xe8\xf1\x11\x98\x3c\x02\x1f\x20\x18\x41\x91\x8d\xc9\x0a\x20\xb8\xbf\x11\x26\x10\xa2\x64\x21\xba\x74\x32\xf8\x42\x98\x09\xa4\x85\x26\x4a\x64\x34\xd2\x31\x51\xfa\x95\xde\x34\x16\x79\xf3\xac\x41\x96\x49\x40\x36\x64\x3d\x63\xb4\xd0\x32\x9f\xde\x2f\x63\x83\x9b\xb6\xcc\x7e\xa8\x7b\x56\xcc\xa2\x00\x34\xc3\x0c\xbf\xa9\xa0\xfd\xc3\xc5\x57\x77\x76\xce\xd0\xc3\x91\x40\x81\x8e\x9b\x9c\xf4\xbf\xd8\x7c\x27\x1c\xe3\x5d\x5f\x34\x7f\x31\xbd\x7a\xd4\x4a\xd4\xe8\xb1\xf1\xe8\x80\xc6\xe6\x71\x19\x4b\x4f\x74\x7f\x54\x1a\x80\xe6\xd0\xdc\x29\xbb\x9b\x6a\x24\x34\xa0\x2b\x1e\x9b\xbf\xe1\xd3\x8e\x30\x04\xa0\x4b\x9a\xfa\x51\xee\x31\xb1\xbf\x73\x06\x6d\x7c\xf6\x7e\x32\x87\x87\xd2\x6b\xad\x9c\xd2\xe3\x19\x3c\x4c\xb8\x2a\x33\xc5\x7b\x20\x1d\xc4\xcc\x9f\x84\x83\x74\x3c\xa1\xe7\xf5\x24\x45\x06\xb4\x34\xf1\x6f\x13\x14\x75\x0f\xf4\xe0\xb0\x87\x07\xf2\x2e\x54\xbf\xfe\x6b\xa5\xde\x40\xef\x2f\x6e\x19\xfe\x48\x98\x39\xf6\xf1\xe7\x20\xd7\x87\xaa\xb2\x11\xc5\xcc\x99\xd9\x80\xde\xb7\x8e\x60\x78\x2d\x98\x6d\xf4\xb1\x4b\xe9\x2e\x1b\xa6\x5d\x67\x81\xc3\xa0\x44\xeb\x43\xb7\xbc\xf2\x3c\x88\x03\xc7\x07\x27\xd1\x41\x70\x2d\x3a\x92\xe2\xd1\x62\x78\x13\x1d\x4a\xf5\xa2\x71\x68\x2d\x2c\x82\x0a\x90\x0f\xec\x5a\xab\xcd\x80\x66\x8b\xb2\x11\x99\x68\x37\xa2\xa1\x2c\x94\x03\xf3\x38\x82\x1f\x7a\xe0\x8b\x13\x09\x62\xc2\xcc\xd2\xb8\x6f\x72\x4c\x40\x70\x0b\xc4\x47\x01\x1d\xe5\x7d\xac\x60\x29\x42\xc0\x1d\x8c\xa2\x8a\x30\x67\x8a\x9a\x88\xba\xb7\xb8\x89\x1f\x77\x83\x00\x66\xe1\xe8\x68\x22\x6a\x32\x47\x2f\xec\xc5\xdc\x93\x57\xa9\x4b\x68\x46\x49\x2b\x4f\x6f\x2c\x57\xd4\xa2\xef\x21\x48\x00\xcd\x1d\x3a\xdb\xf2\x21\x5b\x1f\x02\x6c\xe0\xc0\x9c\x03\x70\xcf\xa0\xf6\x35\x7b\x01\xd8\x51\x14\xac\x0c\x8d\x69\x32\x99\x9b\x17\x6d\xbc\x15\x5e\x53\x9c\x57\x5c\xd0\x14\xd7\x80\xde\x64\x9d\xe9\xc7\x07\x7d\xef\xb2\x9a\x9b\x93\x2d\x25\x3f\x0b\xdd\x49\x8a\x8f\xd0\x1b\xd8\x2e\x93\x67\xc9\x13\x2b\x41\x28\xae\x1a\x3e\x11\x35\x8f\x6f\x5a\xe1\x44\x10\x6e\x48\xad\x83\x1b\xb5\xf6\xe5\x93\x67\x0d\x31\xfb\x8d\xae\x2c\x8f\xe2\x3a\x2f\x58\x39\x63\x5e\xa3\xd5\x6b\x34\x79\x80\x55\x7a\x4b\x3c\x75\xa8\xcb\xd4\x4c\x3f\x7f\x46\xb8\x18\x2b\xf4\x4d\x4b\x7f\xdb\x10\x6b\x89\x5c\x2a\x4a\xd5\x62\x4e\x7f\x1c\x9e\x09\x66\x53\x8b\xa9\xd5\xd4\x5e\xea\x29\xea\x15\xea\x13\xea\x14\x50\x00\x2b\x6e\xd3\x4a\xd0\x0c\xc6\x81\x35\xe0\x6a\xb2\x0b\x9d\x71\xce\x81\x99\xc3\x20\xd4\x27\x24\x50\x6f\x8e\xeb\x61\xc8\xa4\x87\x9c\xb0\xa7\x1e\x13\xf6\xd5\x40\x34\xe6\x33\x46\x8d\x15\x30\x46\x7c\x4b\x1b\xa3\x31\x73\x34\x41\x1b\x73\x41\xac\x02\x18\xa3\xa1\x48\x34\x11\x2f\x29\x04\xde\x5c\x1c\x89\x45\xfd\x25\xfd\x42\x7d\x7f\xc4\xec\x63\xc4\xb9\x18\xc7\xe2\xe9\x90\xd7\xec\x0d\x79\x83\x82\x34\x05\x4f\xb3\xc5\x91\x98\xa0\xda\x5a\x6c\x36\x9a\x8c\x9c\x83\xf8\x8b\xf7\x49\x02\x51\x22\xc9\xf2\x72\xa2\xf7\x63\x7c\xd5\x92\x68\xc4\x09\x84\x93\xd1\x1c\x25\x50\x4c\x19\x36\xbb\x06\xe0\x3b\x07\x49\x86\x39\x21\xee\xfc\x0a\xfb\xe8\x98\x1d\x25\xcf\x1f\x17\x36\x79\x89\xb7\x64\x1f\xbe\x0c\x79\x05\xe2\x48\x3b\x63\xe5\x45\xf2\x42\xe4\x4e\xd1\x73\x77\xc1\x57\x31\xa5\x33\x43\xa2\x49\x91\x70\xdd\x0b\x6f\x7a\x5e\x85\x74\x66\x26\x8f\xf3\xfa\xc8\x96\x0f\xd9\x0d\x30\x08\x9b\x93\x09\xc2\x18\x27\x88\x70\x35\x18\x22\xed\x14\xfc\x05\xbe\xcf\x94\xe4\x4d\xb3\x9f\xbd\x62\xc4\x88\x2b\x8e\xcc\xb9\x29\xb9\x69\xf2\x94\x3b\xd7\x4d\x9c\xb0\x7e\xfd\x84\x89\x93\x36\x4e\x99\xbc\x29\x79\xd3\x9c\x23\x24\xef\xd9\xd9\x37\xc1\x99\x9c\x8e\xa3\x9d\x0c\x2b\x91\xb0\xb4\x84\x61\xa5\x90\xa6\x09\x28\x8a\xf0\x07\x01\x1e\xec\x67\x4c\x26\x5e\x6f\x32\xe9\x79\x70\x57\x25\xdb\x04\xb6\x9a\x30\x7d\xc3\xeb\x4f\x9b\xfd\x66\xb3\x7f\x2b\xd1\x99\x24\xe5\xc8\x9e\x3b\x60\xa0\x50\x09\x82\xd3\x47\x5c\x4e\x6b\x96\x46\xed\xb6\x68\x5c\x2e\x8f\xcb\xe9\x71\x1d\x70\x3a\x75\x36\xe2\x68\xc4\xa1\x79\xb4\x50\x6d\xb6\x9a\x0d\x4a\x93\xc7\xe6\x2a\x54\x59\xdc\x56\x83\xca\xea\x71\x7a\x36\x4a\x55\x2a\xbe\xa8\xc8\xe5\x70\x14\x1a\x67\x3a\x83\x21\x97\xc7\xa4\xd6\x1b\xbd\xdc\x4c\xff\x26\xb3\xd2\xe5\x72\xca\xa5\x32\x99\x3e\xe4\x71\xf2\x6a\xbd\x4e\x6f\x36\xeb\x79\xad\xda\xe0\xf0\x1c\x75\xb9\x34\x76\x67\x28\xe4\x74\xa8\xb7\x98\x95\x4e\x27\x29\x26\x5d\xef\x74\x6a\x4a\x43\x21\x87\x53\xdd\x46\x34\x86\x21\xa1\x48\x21\x43\x33\x90\xc4\x84\x27\x24\x4f\x3d\x7b\xe0\x00\x62\xee\x1f\x8d\x9b\x6a\x36\x69\x96\xd1\xf3\x41\x15\xa8\x1c\x39\x1d\x1d\x43\xef\x4e\x9f\x0e\xf2\x40\xfe\x9a\xf9\xe8\x05\xf4\xc2\x3c\x52\x62\xce\x6c\x5c\xa2\xef\x38\x4d\xeb\x0c\x2a\x95\x41\xa3\x52\xa1\x32\x48\xcb\x59\x40\x5a\x41\xc5\xe6\x05\x2d\x56\x3d\x6f\x19\x9b\xe5\x16\x03\x56\xbf\x95\x9c\x9c\x80\x11\x9e\x02\x8a\xed\x43\x94\x6e\xc9\x33\xe0\x87\x18\x8d\xf3\x2c\x16\x83\x76\xeb\x30\xbf\x7f\x18\xf9\x35\x36\x68\x0d\xe1\xea\xb0\xc1\xe2\x95\x40\x46\xae\x51\x58\xd4\x16\x83\x87\x04\x75\x6a\xb3\xce\xa2\xb6\x72\xa6\x2a\x7b\x76\xb6\xbd\x2a\xb2\x3d\xec\xce\x0a\xf1\x26\x8d\x47\x99\x15\xc2\xf5\x5b\x7c\x8c\x83\xc1\x15\xb5\x16\x15\xb0\x04\x2d\x4a\x8b\xf6\xea\xcc\xa5\x56\x67\xb2\xaf\x6e\x5c\x3d\xd8\x90\x5d\x99\x6d\xa0\xc9\x17\x23\x2d\x02\x85\xa7\x20\x7f\xe4\x9b\x43\x41\x97\x1a\x30\x9f\x0c\x9c\x0a\x44\xff\xf4\xc2\x5c\x20\xc7\xb3\x01\xd9\xf9\xab\xa7\xc6\x52\xd3\xa8\x79\x78\x26\xb8\x8c\xba\x8a\xba\x59\xf0\x72\x48\x10\x61\x05\x87\xdf\x06\x21\xc0\x12\x43\x78\x5d\xc6\x39\x3c\x9b\x96\x21\xc7\xcf\x0d\x29\xc1\x51\xa8\x88\x71\x2d\x8c\x2a\x41\x96\x9c\x56\xf4\x89\x65\x06\x05\xd0\xa9\x81\x12\xb2\x9e\x73\xf4\x42\x40\xf0\x44\xcf\x27\xc8\xe8\x4b\xff\x40\x54\xd0\xbc\x22\xb7\x8b\xfd\x42\x6a\x08\xca\xfc\xce\x4a\x9d\xae\xca\xe1\x97\x7c\x5d\xcb\x1b\x6a\x4e\x8d\x9c\x31\x7c\xca\x94\xe6\xfc\x4a\x57\x5d\x1d\xa8\xcd\x4e\x38\x8d\x76\xa3\xd3\xe2\xcd\x2e\xcb\xab\xf4\x17\x04\xa4\xbc\xc3\x54\x64\xce\xc9\x1b\x1c\xad\x05\xa6\x40\x76\x71\x4d\x4d\x41\x6e\x30\x1c\x6e\x9e\x3d\xab\x39\x87\xf9\xa9\x6e\x1f\x7a\x11\xdd\x8b\x0c\x08\x49\x3c\xb6\x60\xdf\x03\xf3\x76\xcd\x9b\xb7\x0b\xc0\xeb\x06\x77\x8e\x1f\xbc\xfd\xed\xa7\x56\x2c\x5d\xba\xe2\x29\xb0\xb5\x7d\x6e\x4b\x75\xe9\xd4\x3a\x19\xf0\xb4\x26\x7e\x96\x26\x5a\x5b\x13\xdc\xcf\x89\x56\xf8\x53\xd4\x63\x7b\xdf\xee\x56\x95\xcc\x5c\xd2\x3c\x09\x3d\x16\x8c\x8e\x07\xad\xff\x0a\xe7\x19\xe4\x7a\xb5\xd6\x68\xcf\x0b\x24\xc2\xbe\x6c\xad\x4a\xa2\x34\x19\xec\x79\xe1\xda\xaa\xec\xd6\x40\x5d\xa4\xa8\x21\xd8\x6a\x98\xb9\x63\x66\xea\x49\xa8\x09\x8f\xdb\xb1\xe1\x9a\xa2\x20\x7c\x91\xdc\x74\x9e\x14\x8c\x39\x71\x02\xdd\x27\x2b\xed\x2c\x6d\x2e\x43\x8f\x5d\xa3\x6d\x2b\x2c\x41\x8f\x6d\x81\xfe\x33\xca\xd2\xb6\xb6\x52\xe6\x7b\x7c\x24\xe4\xb8\xbe\xff\xdb\x41\x4c\x91\xab\x31\x1f\xea\xc0\xf4\x78\x10\x73\xa3\xc3\xa9\x09\xd4\x51\xea\x6f\x78\x06\x67\x81\x0c\xf8\x41\x0d\x98\x46\x51\x7c\x34\x04\x12\x64\x32\xc6\xf3\x5a\xc0\x1c\x33\x97\x90\xe9\x37\x12\x10\x4f\x40\x3c\xb1\xd1\x10\x71\xea\xce\xf9\x42\x46\x5f\xc8\xc7\xf9\x78\xbc\xca\x45\xcd\x09\x60\x50\x33\xde\x20\x9e\x10\x43\x1c\x26\xf4\xcd\x09\x5c\xcd\xe8\xd3\x45\x8d\xe2\xc5\xfa\x8d\xb8\x74\x78\x61\x34\x0b\x73\x3d\x26\xfb\x13\x11\xb2\x17\xe3\x82\xf1\x4c\xa2\xce\x67\x0c\x91\xff\xc2\x54\x48\xd6\x5e\x21\xc6\xf5\xf3\xb8\x42\x06\xfe\x79\x8c\xf8\x73\x93\x1f\x27\xd8\x20\xe1\xba\xb8\xa7\x91\x85\x42\xc4\x49\x4f\x90\x87\x36\x48\x38\x17\x70\x62\x0e\x9f\x74\x0d\xf2\x28\x11\x41\x44\x27\xa4\x95\xc4\x0b\x68\x21\xd1\x4c\x76\x85\x06\x3c\x26\x41\x70\x13\x3b\x30\x41\xbc\x2b\x10\x51\xa5\x8d\x44\x86\x6f\x8a\xbb\x40\xc2\x28\xc9\xe4\x49\x04\x79\x44\x3a\xcf\x05\x68\x5d\xa6\x39\xbc\xb1\x12\x9c\xea\x0d\xaa\x19\x01\xfb\x22\x21\xb4\x4e\x6c\xc5\xf8\x7c\x58\xd7\xdc\x74\xe7\xf6\xed\xa0\x6a\xfa\xb3\xe1\x51\x23\xb3\x81\x27\xa7\x63\x44\x2e\xfa\x8c\x1c\xc1\xeb\xe3\xf3\xfa\x4c\xf5\x93\xcb\x26\x6f\xb6\x6e\xb5\x36\x5d\xda\x75\xc9\xbc\xd1\xad\x70\x8f\x42\xe7\xb0\x84\x2c\xd9\xb2\x75\xed\x23\xcf\x52\x80\x69\xef\x78\x6b\x21\xfa\xe0\xf8\xf1\x3d\x37\xde\xc8\xbe\x2b\xf6\xad\x45\xd6\x84\xf5\x3d\x7e\xb1\x01\x3a\xe5\x72\x60\x36\xd7\x66\x8f\x96\x59\x4b\xad\x7f\xf7\x3e\x71\xc8\x7a\xd8\x7c\x6a\x50\xf8\xa0\xa5\x38\x75\x4d\x6e\xee\xcb\xa6\x7b\xdb\xc4\x6e\xb8\x32\xea\x7a\x24\x61\x46\x2f\xba\x4b\xdf\x31\x37\x7e\x16\x8f\xa0\x3b\xc1\xd8\x44\xc9\x31\x63\x85\xfb\x41\xa9\x94\x81\xba\x32\xf7\x3d\x95\xa9\x7c\x8b\xc9\xaa\xaf\xb3\x78\x07\xd5\xdd\x5c\x54\x8e\x3e\xb7\x1a\x6d\xba\x3a\x80\x99\x56\xb3\xbe\xa9\xf6\xa6\x62\xcc\x97\xfc\xf5\xaf\xbb\x6f\xbc\x11\x7d\x59\x0f\x7f\x9a\xb5\x6e\x9d\xd7\x5b\x1c\xf1\x96\x84\x37\xae\xf0\xfb\x8a\x8b\x7d\x5f\x59\x6a\x2f\xbb\xcc\x63\x0d\xe4\x06\xac\xb1\xf0\x86\xe5\xfe\xf2\xe1\x37\x4e\x5c\xbd\xd9\x76\xb9\x75\xd8\x86\x2d\x35\x5c\x8e\xc6\xad\xd4\x49\xec\x7e\xe7\xc4\xa9\x0b\xa7\x2f\xa1\xc7\x2c\x48\x5d\x3e\x7c\x78\x71\x22\xde\x76\xc9\xf1\x4a\xcf\xa0\xb0\xb3\x0a\x7c\xeb\xac\x0c\x2e\x28\x44\xdf\xbc\x8b\xff\x2a\x2b\x81\x06\x9d\x05\xe0\xa9\xa7\x52\xef\x1a\x5c\x06\x15\x07\xc1\x84\xce\x4e\xa0\x19\x3f\xbe\xaf\x14\x68\xca\x70\xbd\xd4\x3b\x9f\x24\x86\x0f\x4f\xc0\x03\x55\x55\x05\x05\x85\x85\xd3\x81\x7a\x8c\x59\xa9\x04\xb0\xaa\xaa\xbc\x1c\xac\xce\xc3\x7f\x26\xfc\x37\x75\x6a\x5e\xde\x63\x60\x2b\x29\x99\xea\x34\xa5\xff\xca\xcb\xd1\xe5\x15\x15\xe3\x55\xb3\xa6\x33\xd2\xb1\x16\xcb\x19\x73\x58\x26\xf3\x3a\xe3\xf9\x1e\xe3\x74\xa0\x71\x81\x7b\x2c\x38\xee\x71\xc5\x64\x3e\x8d\x49\xce\x4d\x03\x1a\xe0\x4c\x5d\x8a\xef\x5a\x8a\xef\x0a\xef\x45\xdf\x00\x4d\xea\xd2\x31\xe5\x56\xad\x9c\x0b\xfa\x43\x39\x65\x56\xad\x0c\x48\x02\xea\x99\xbe\x72\xab\x4a\x09\x58\x45\xc0\x45\x12\x0d\x8c\x04\xd6\xa3\x6f\x5f\x7f\xbd\xb2\x72\xcb\x55\x15\x78\x76\x95\xeb\x9c\x7c\x30\xfc\x27\xfc\x35\xa9\x23\x47\xc8\xf8\x54\xf4\x8f\x4f\x05\xe6\xba\x7c\x78\x5c\x8e\xa4\x2e\xa1\xb6\x50\xfb\xa8\x07\xa9\xc3\xd4\x1f\xd2\xde\xa8\xd2\xfb\x44\xb8\x4b\xfb\x38\xc2\x11\x10\xc4\x87\x81\xe9\x02\xe8\x08\x47\x4b\x08\xe6\x08\xd1\x67\x13\xa4\x64\x2c\x1f\x17\x92\x07\x58\x6f\xe3\x33\x2e\x41\x09\xc5\x35\x20\x24\x40\x95\x90\xde\x6b\x16\x33\x12\xe0\x37\x5f\xc9\x20\xd6\xe0\x63\x25\x42\x79\x4e\x80\x3b\x49\x10\xd3\x70\xf1\x01\x4d\x17\xce\xc3\xf0\xd3\x68\xc0\xe9\x8b\x04\x1c\x01\x5a\x87\x99\x55\x1d\x54\xe8\x4d\x36\x0b\x98\x12\xf5\x3b\xfd\x24\xf5\xf4\x3d\xad\xd5\x3d\x3c\xac\x03\x52\x49\x8b\x01\xea\x81\x52\xaf\x35\xd1\x63\xa6\x81\x58\x36\x49\x51\xd3\xf6\xc6\x21\x33\x07\x95\x3b\x2a\xf5\x8c\x6a\x10\x0f\x9e\x97\xb2\xad\x0a\x6e\x5e\x1e\xab\x1b\xc6\x4a\x43\xf9\xa0\x43\x85\xa3\xd4\x59\xb0\xae\xb5\x7a\x9f\x41\xb8\x48\x87\x92\xf9\xe5\x45\x6c\x83\xc8\x45\xf0\x7a\x40\x2e\xf2\x81\xaa\x59\x21\x14\xad\xe7\xe1\xa9\xa1\x6c\x0e\x9e\x49\xa0\x82\x0f\xfb\xb9\x25\xe7\xd1\xd5\xcb\x03\xc5\x59\x8e\x40\xd4\xb3\x32\xc7\x05\xe6\x2b\x18\xe3\xbd\xfe\x88\x10\xdf\x5e\x11\xe3\xd1\x1c\x89\x9c\xbf\x44\x2a\xa7\xe1\xd4\xbf\x01\x56\x22\xf7\x84\x17\x0c\xad\x68\xb2\x18\x94\x32\x2d\x30\xca\x65\xf2\xbd\xbb\xb4\x32\x16\x2e\xd9\xcc\x74\x4b\x55\x72\xd0\x5d\x9a\xae\xa2\xba\xf4\x97\x55\x80\x96\xd1\x82\x83\x40\xad\x40\x5d\x90\x95\xf1\x80\xf7\x99\xf0\xed\xcc\xe0\xa3\xf3\x96\x62\xb2\xc7\xd2\xbf\x16\x6b\xa8\x08\x35\x04\xaf\xc4\x13\xa8\x05\xd4\xa5\xd4\xd5\xd4\x2d\xe2\x3a\x8c\x17\x54\x42\xfd\xb2\xbe\xb8\xb0\x0a\x0b\xeb\x6e\x7a\xd9\xe5\xd2\x88\xdc\x84\x96\x0d\x0a\xcb\x6e\x22\x0e\x12\xbe\x98\x86\x8e\xa6\xcd\x28\x45\x85\x2e\x56\x58\x80\xf1\xe4\xab\x8b\x12\x5c\x49\x5e\x58\xc1\x05\x2b\xd7\x50\x1a\x4d\x32\x71\x8e\x81\x17\x32\x24\xe9\xfa\x02\xf9\x1b\x0c\x45\x7f\x81\xc9\x29\xa9\x32\xf2\x1e\xb3\xde\xe9\x28\x03\x4f\x5c\x22\x89\x44\x4f\x7d\x51\xdf\xe8\xcf\x0a\x96\xd7\xeb\x1b\x3a\x5a\x0b\x8a\xea\x1a\x42\xee\x22\x67\x87\x5b\x3f\xa4\x6b\x44\x51\x14\x33\x5b\x5d\x1b\xf4\x05\xba\xea\xbc\xe0\xd0\xac\xc2\x2c\x65\x0e\xb8\x52\xa3\xca\x2a\x94\xcb\x37\xed\xb2\x95\x6a\x0b\x77\xed\x82\x97\xe4\x87\x07\xd7\xc6\xa4\x9b\x77\xf9\xb3\x46\x46\xab\x50\x5e\x41\x7d\x41\x41\x3d\xfd\x70\x51\x64\x72\xd7\xa2\x9a\xc4\xbc\x99\x15\xda\xb2\xc1\xb9\x06\x33\xfb\x33\x3c\x9f\x4b\x5a\x35\x28\xe0\x93\x9d\x70\x8d\x99\xf6\x69\x45\x9d\x55\x65\x52\xdb\x3c\xdd\x59\xc1\x50\x53\x79\x9d\x45\x6d\xd6\xba\xad\xfa\xc5\xd9\x81\x6c\xe0\x5b\xb4\xd5\xb8\x44\x3a\xfb\x7f\x46\xf9\x5d\x8a\xe5\x5c\xe4\x25\xeb\xd5\x74\x96\xab\x14\x65\x83\x88\x1b\x3d\x04\xfe\xf2\xe1\xea\xb2\x92\xd2\xc2\xd4\x1a\xeb\x6e\x45\x69\x1d\x78\x91\xdc\xb9\x10\x7d\xbe\xb8\xa6\x76\xf3\x92\x64\x65\x22\x3c\xdb\xcd\xf3\x85\x6a\xf8\xc8\x79\x1f\x8e\xa6\xd4\x98\x27\xfe\x56\x42\x09\xe3\x9c\x20\x2b\xe9\xcd\xa4\x81\xc8\x7e\x70\x88\x8d\x94\x08\x63\x99\xac\x32\xc0\x44\x60\x4a\x08\x1a\x5b\x9c\xf8\xa7\xaa\x66\x88\x1b\x89\xcc\xe6\x13\x5e\xbc\xcc\x44\xd5\x5e\x62\xaa\xfa\xb2\xa5\x04\xd5\xee\x7a\x77\x27\x00\x94\x56\x5b\x31\x3a\x6b\x36\x13\x95\x02\xf9\xcf\x0f\xcb\xed\xd2\x51\x38\xf0\x34\x1f\xe9\x18\x57\x15\xfa\xec\x39\x69\x69\x7b\xa9\x74\xed\x73\x31\x70\x07\xce\x81\x07\xd1\xde\x57\x4b\x5a\xe6\xed\xda\x39\xef\xa1\xac\xd1\x15\x5a\xed\xd0\xd9\x92\x5a\xb9\x5d\x76\xea\x3e\x29\x94\x77\xe1\x02\xb7\x67\x79\x73\x26\xde\x70\xdf\xb7\x57\xef\x01\xac\x83\x37\x10\xfd\x7a\x03\xaf\xdf\x30\x09\xcc\xc7\x05\x44\x7b\xb6\x73\xef\x61\xc2\x74\x44\x1b\xd9\x15\xea\x7f\xf8\xa8\x0c\xa4\x5d\x33\x6a\x41\xff\xdb\x25\x3c\x41\x3a\xa1\x27\xd6\x03\xbf\xfa\x62\x8c\xf8\x2a\x43\x53\x3f\xd1\x0b\x73\x1e\xdf\x32\xe9\xa6\xce\x22\xa6\x37\xf3\xa2\x3b\xe1\x0f\x07\xaa\x16\x55\x81\x86\x51\xbf\xfa\xa2\x0f\xa7\x5f\x0e\x7c\x0e\x7f\x1e\xb7\xac\x66\xda\x82\x28\x4a\xa2\x5a\xf1\xc5\x37\x3c\x03\xb4\x53\xd1\x5e\xe6\x9e\xae\xdf\xfa\xe2\xfd\x18\xc7\x6c\xb2\x5f\xce\x95\x20\x9a\x43\xc4\x77\xa1\x30\x85\xea\x44\xb4\xa7\x5f\x8b\x03\x0f\x1e\x1a\x1e\x09\xc7\x66\xfc\x0a\x8a\x03\xc4\x97\xf1\x01\x91\x10\xf7\x71\xdc\xc4\xd3\x0b\xa4\x2e\x0e\xd3\x34\x30\x9c\x3a\x01\x7a\x8b\x38\x39\x7a\x41\xce\xd1\x8b\xf4\xea\x2e\xd1\x81\x83\x20\x70\x04\xb1\x26\x4d\x5b\x18\xd4\x86\xdb\x34\x4d\x20\xa6\xd6\xf7\x40\x41\x94\x93\x12\xaa\xfe\x87\x30\xfd\xef\x65\x32\x08\x65\x3b\x71\xb8\xaf\x65\xe4\xaa\x65\x23\xe9\xa7\x84\xdb\xdc\x1d\x28\x29\x09\xdc\xad\x1f\x80\x65\x9c\x27\x68\x3a\x12\x5d\x04\x02\x39\x44\x89\x90\x2e\xb4\x93\x50\x4e\xde\xaa\x81\xda\x52\x19\xb1\x1a\xfc\x4f\x3a\x28\xcc\xba\xa1\x4b\x57\x95\xbd\x89\xbe\x04\xda\xd7\xbd\x23\x67\x77\x94\x6a\x97\x6b\x37\x0d\xb9\xe6\x91\x27\xb7\x37\x5e\x23\x93\xac\x90\xc8\xfb\x7e\x4d\x47\x05\x1c\x5d\x18\x69\xcb\xc5\xe3\xe6\xad\xd7\x81\x56\x66\xcf\x1e\x92\xbf\x50\xab\x6d\xca\x2d\x7e\x72\xc7\xee\x97\x8a\x72\x9a\x38\x99\x8c\xce\xfd\x35\x2d\x96\x81\x72\x78\x35\xf1\xd3\x2a\xbc\x03\xd9\xc4\x10\x6c\xf3\x59\xa2\x6c\xe2\x15\x67\xb6\xf4\xd6\xaf\x5e\x40\x9b\xac\x11\x3d\x71\x9a\x4d\x78\xc5\x24\x65\x71\xa7\xd6\x52\x1e\xaf\xf0\xae\x64\x8e\x24\x70\x1a\x02\x9e\xe2\x00\xb8\x72\x8a\x7e\x63\xfe\xe4\x9a\xd5\xd3\xaa\xe6\x4f\xed\xea\x19\x0d\x4b\x9a\xd7\x5c\x33\x4c\xc2\x73\x53\x0a\x1d\x6c\xc9\xbe\xc9\xb7\x3f\xb2\xf9\x6f\x5b\xc6\x5e\x11\x84\x0a\x20\x63\x97\xb3\x52\x16\xae\x64\xad\x59\x8e\xf2\x71\xf5\x45\x68\x3f\x7a\x3f\xa3\x09\x7f\xf2\x11\x85\x4d\x9a\x2d\x05\x50\x3e\xeb\xcc\x16\xc1\x8f\x9f\xe0\x9f\x0f\x8c\x03\xf7\xc0\x53\x0b\x56\x57\x2d\x38\x30\xb5\x7b\xf5\x96\x57\x74\x8b\x0e\x4e\x8b\x42\x10\xf3\x44\xea\xc7\xfd\xee\xc1\x5b\x81\xfc\x96\xc1\xb5\x7c\xa9\x44\xa9\x60\x15\xa9\x9b\x2d\x96\x90\x0d\xc8\x42\x55\xcb\xdb\x30\xf5\x3f\x31\xd3\x44\xd7\xc9\xa0\xa2\x58\xa9\x54\xc9\x46\x76\x92\x4b\x82\x52\xe0\x38\xba\x1a\x8d\xeb\xd7\xdb\x12\xf6\xf5\x7c\x64\x4f\x8f\x32\x69\x89\x4d\x90\x41\x03\x88\x3c\x9f\x78\x04\x61\x43\x3c\xf1\x8a\x99\x16\xda\x13\x7f\x17\x32\x10\x02\x46\x49\xe3\x91\xc9\x1f\xcf\x91\xcb\xff\x28\xb7\xc9\xe7\xa6\xee\x0a\xc4\x5e\x3f\x4b\xd5\x26\x03\x70\xc2\x5c\x31\x6d\xce\x47\x93\xfa\x5e\x82\xb5\xbd\xa9\x5e\x09\x75\x04\xfd\x34\xe9\xa3\x39\x38\xf1\x8f\x72\xa1\x6c\xb2\x16\x50\xaf\xc7\x84\xb2\x42\xda\x9c\x8f\x27\x9f\xae\x15\xca\xf6\xa6\xf5\xc8\x90\x20\x87\xcc\x4e\xfb\xe8\xe0\xa8\xcc\x5e\x3b\x88\x0b\x8e\x1b\x4c\x94\x8f\x68\xda\x12\x5d\xe4\x44\x35\x23\x19\xde\x34\x37\x1f\x1d\xda\x32\x75\xd5\xba\xc7\x27\xc2\x75\x15\x7d\x4f\x87\xb6\x8e\x04\x0c\xfa\xe1\x2f\x6b\x9e\x5b\x5a\xce\x35\x96\x56\x6b\xb2\xd5\xd6\xba\xe6\x59\x73\x24\xd4\xa4\xa6\x9a\x71\xa9\xab\xd7\x4c\x38\xbc\x3e\x39\x0a\x36\xc4\xcf\xfc\xd8\xb2\xc0\x34\xf8\x4f\xe8\xfb\x49\x77\xbc\xb1\x9c\x8d\x84\xbc\x81\xfa\x49\x15\x7e\xcd\x79\xf2\xd0\xfc\x7e\x34\x3d\x01\xa1\x3a\x22\x60\x68\x8a\x10\x97\x30\x2a\xc4\x20\xe9\x36\x82\x97\xca\x34\x60\xb1\x0b\xf2\x46\xa2\x83\x29\x62\xc7\x72\x02\x84\xd7\xc5\x23\x84\x93\x21\x9a\x66\x9e\xfe\x7f\x22\x47\x23\x6a\x53\x31\xb1\x73\x32\xc5\x5f\x46\x38\xea\x14\x95\xdf\x1e\x74\xb8\x72\x7d\x96\xb0\xc9\xe4\xf4\xb7\x17\xe4\xb7\xfb\x5d\x46\x73\xc8\xe2\xcb\x75\x39\x82\xed\x9d\x62\xa6\x57\x88\xe4\xa7\xcb\xe4\x17\xb4\xfb\x9d\x26\x53\x98\x94\xf9\x65\x15\x21\x17\xd7\xe9\x6e\xaf\x25\x7e\x11\xc4\x7f\xb5\xed\xdd\x67\xa8\x21\xa5\xb1\x61\xbc\xc3\xeb\xe0\x83\x9d\xf0\x3f\x46\x92\x44\xa8\xe3\xb0\x5b\xec\x26\xb5\x96\xb7\xda\x1c\x4e\xab\x95\xd7\xaa\x4d\x38\xc1\x21\xa4\x0a\x21\x50\xdb\x2b\xe6\x3a\x6c\x62\xee\x05\x05\x6d\x56\xbb\xa9\xb7\xbd\x1b\xf4\xa2\xda\xcc\xaf\x9b\xd6\xb6\x8e\x1c\x16\x73\xe6\x59\xb2\xdc\xe5\xc1\x1b\x5b\xfe\x63\x44\x1c\xf3\x82\xbc\x8a\x25\x74\xb8\xc7\x48\xbc\x40\x60\xb6\x1d\xff\xa4\xd4\xcf\x14\x9e\x0e\x00\x75\x2a\x09\x7a\x61\x2d\x0e\x9e\x4e\x32\x54\x5f\x12\xe2\xbe\x97\xea\xed\xf7\x8d\xd2\x2b\xac\x83\x5a\xbc\x12\x52\x98\xfc\x17\xbc\x3e\xe1\x59\x2d\xca\x7b\x88\x1f\x10\xfc\xfd\x19\x3d\x4d\x41\xef\x3c\xf4\xc9\xad\xef\x88\xf3\xcd\x3b\xcf\xd0\xec\xca\x05\xfb\x53\xd4\x3b\x78\xde\x81\x97\xa7\x3e\x5c\xb0\x32\x33\x0b\xa5\xa8\x5b\xd1\x27\xf3\xe0\x1d\x34\x85\x27\xb8\xf3\x9e\xcd\x9d\x79\x36\xb2\x64\x90\x91\x46\x86\x5b\x48\x18\x61\xc4\xf8\x8e\x2c\x19\xc2\xf3\x72\x54\x48\xbb\x2a\xb5\x15\x0f\x94\x4f\x51\x57\x2f\x1c\x4a\x02\xe0\xed\x55\x5a\x9d\x11\x3c\xa6\xd6\x8b\xef\x70\x02\xb5\x1a\x75\x42\xa9\x4c\x21\xb1\x4c\x48\x9f\xf6\xb7\xc4\x51\xcc\x58\xaa\x8b\x50\x92\x04\xb7\x98\x11\x75\x86\x25\x21\xe2\x5d\xb9\x1f\xb4\x44\xb4\x11\xc1\x6b\x17\x14\xd5\xa1\x89\x13\x14\x11\x6d\x5b\x22\x80\xba\x12\x29\xa7\xcf\x05\xcd\x5c\x30\x24\x10\x92\xac\x52\x2e\x77\x95\xf8\x03\x60\xd0\xb1\x9d\x15\x73\xdb\x5a\x22\x65\xae\x62\x45\x56\xc5\xb8\x95\x1d\x5d\x0f\xce\xfa\xd3\xad\x8f\x8c\x28\xb5\x8f\xd2\x38\xc1\x26\x74\xf6\x86\x1f\xae\x18\x7b\xfd\x2b\x73\xc7\x5e\x37\x7b\x6c\x79\x45\x4e\xb9\xad\xeb\xca\x11\x4b\x83\x35\x1d\x63\xc7\x35\x97\x2a\xe8\x87\x16\xb5\x8d\x2e\x02\x4a\x93\x8b\xd9\x60\x73\x98\x9b\x8b\x9b\xe8\x5a\x89\xcf\x99\x6d\x57\xc9\x27\x7c\xb3\xe3\xf7\x81\xf8\x94\xf6\xf5\xc3\x2f\x77\x8c\x98\x3b\x2e\xbc\xe8\xd1\xae\x9e\xaf\xa6\xd4\xc4\xf6\x78\xfd\x60\xcf\x6d\x00\xec\x98\xfb\xda\xee\x89\xc1\xea\x69\x33\x2e\x5f\xba\x23\xfe\xea\xd4\xf6\x9c\xca\x2c\xb7\x39\xbf\x62\x6e\x93\x56\x77\xc9\x7e\x86\x36\xe7\x28\xec\xf9\xec\xf4\x62\x23\x30\xd6\x9f\xb7\x16\x8c\x15\x64\xf6\x44\xf7\x30\x54\x92\xd9\xbe\xf2\x99\x30\x29\x1d\x12\xf1\x48\x0c\x02\xf2\x2d\x5e\xf8\x4c\x82\xe2\x2a\x4b\xda\xc8\x6c\x14\xe7\xfe\x44\x3f\x74\xb1\x30\xcc\xb9\xe8\x45\x70\xea\xf7\x7c\xe6\xf3\x87\x65\x0c\x2c\xf6\xc7\x75\xc0\xc0\x4f\x0a\xc9\x3d\x83\xa2\xed\x6b\xa1\x76\xea\x0c\x67\x38\x62\x07\x23\x2b\xa6\x36\x99\xcb\x42\x83\x86\x27\x47\xce\x7c\x62\x1e\xcd\x4c\x7a\x70\xe1\xd3\x93\x0c\x8a\xca\x9c\x25\xe3\x97\xee\xd9\x3f\xa7\xfb\xd2\x02\xa9\xcf\x94\xed\x4f\x94\xb6\xe4\xcc\xdf\x33\xe7\x3c\x3f\x06\x27\x1f\xa8\x97\xab\x02\x0e\xa8\x52\x40\x7f\xa1\x46\xe3\x1f\x1c\x97\x3b\x0d\x4b\xdb\x39\x6d\xd7\x38\xa7\x54\xe3\xc8\xb6\xb1\xe5\x4d\xd7\x15\xee\x9c\xb5\x62\x48\x71\xf7\x53\x33\xc0\x82\x27\x16\x5f\x62\xb7\x2c\x6c\x1f\xf2\xe0\xb2\xb9\xf7\xcc\x5f\x61\x9c\x52\x3e\xa1\xac\x31\x64\xbf\x1a\x7e\x72\xbe\xc1\x03\x9d\x96\xf1\x8a\x18\xa2\x51\xea\x7c\xcf\xbb\x7e\xb2\xb1\xef\x21\x2a\x4c\x9c\x07\x47\xf5\x5a\x3c\x83\x11\x43\x07\x2d\xee\x25\x1e\x3c\x0d\x32\xc9\xb4\x1e\xab\x78\xa2\x05\xad\x58\xb4\x6e\xc5\xd5\x57\xaf\x00\x1b\xe7\x3c\x7b\xd5\x3b\x64\x6d\x4b\x51\x99\x55\x8e\x26\x21\x68\x39\x57\x21\x73\xea\x44\xdf\xa3\x37\xd0\xf7\x9d\x23\xae\x02\x77\x5f\x40\x1f\x0c\xb0\x27\xa4\x04\xb4\x7c\xca\x02\xc4\xbb\xc3\xf4\xd3\x00\xa6\x5f\xad\x1f\xb3\xbe\xfd\xf7\x99\xd5\x7f\x6f\xe6\xd1\xf3\xee\x08\x50\xfa\xd2\x19\x1a\xe2\xfa\xf3\x1e\x46\x98\xff\x89\x8a\x07\x3e\x11\xeb\x4b\x0b\xa6\x8e\x08\x2a\x17\xfe\xce\x35\x44\x14\x22\xd1\x92\xb1\x11\x8a\x62\x32\x1f\x78\x38\x93\x99\x11\x40\xf9\x89\xed\x81\xe0\x0f\x8e\xd0\x0d\x59\x78\x0a\xc9\x22\x3e\xca\x12\x21\xb2\x8c\x92\x7e\x83\x53\x08\xcf\x26\xb8\xa7\x8d\xe2\xd1\x1f\x4a\x87\x08\xe0\x5a\x34\x02\x4f\xa3\x97\xc3\x3e\xcb\x91\xba\x21\x9b\x8f\x1c\xd9\xbc\xf4\xe1\x3b\x9f\xd6\x97\x81\xc5\x20\x0b\x65\x4d\x9f\x6b\x64\xd9\x23\x9b\x2b\xab\x1e\xd4\xc8\x4d\x1a\xa3\x4f\xff\xe0\xa4\x23\x40\x0a\x2a\xd1\x29\xb4\x1d\x9d\x1a\xde\x54\x87\xf6\xe9\x3d\x2f\x99\xfb\xee\x39\x8c\x4e\x01\xee\xf0\x92\x99\x57\x0a\xaa\x95\x20\x09\x1e\x1b\xfd\xa1\xa8\x18\xe9\x31\x00\xc5\x84\x99\x87\x41\xb2\x29\xeb\x8c\xfb\x08\xfa\xf9\xc8\xf5\x5f\x8d\xae\xb9\x11\x24\x37\xcf\xde\xf9\x22\x90\x1e\xb1\xa0\x3e\x73\x89\x5a\xe1\x04\xcc\x94\x8d\x9b\x8f\x00\xe1\xba\xf8\x4a\x53\x1f\xa8\x99\x86\x72\x6d\xfb\xdf\x07\x1c\x58\x02\xb8\xc4\x93\xc1\x92\x60\x92\x88\xe6\x1d\xa8\x3b\x6f\xa0\x5d\x35\x27\xf4\x9c\x5c\x82\xa7\x47\x5d\x20\x4f\xe6\x33\x60\x54\xb4\x44\x90\x05\xc3\xf3\xfc\x08\xfb\x2e\xc4\xb7\xd2\x95\x10\xc9\x27\x31\x17\x33\xf3\x19\xf9\x30\x23\xca\x6e\x9d\x43\x58\x9f\xb9\x6f\x9e\xd9\xc7\x0e\x61\x83\x2e\x26\xe8\x0a\xfe\xd3\x61\x48\x25\x0d\x0e\x87\x01\x26\x0d\xe0\x20\x29\x9c\xa2\xf0\x21\x69\x9d\x2d\x7b\x04\xd8\xc1\x18\x60\x7f\x44\x36\xd7\x0c\x14\x03\xe4\xbf\x50\x09\x92\x66\xa7\xd3\x8c\x92\xae\x82\x02\x78\x49\xd8\xe1\x08\x3b\x52\x13\x52\x77\x25\x63\xc3\x86\xc5\x92\xe2\x11\x4e\xe8\x5e\x04\x5e\x6e\x5b\x5e\x59\xb9\xbc\x0d\x95\xcf\x12\xd6\x85\x2b\x70\xdf\xfb\x19\xaf\x0b\x05\x04\x5b\x80\x12\x87\xbc\xf0\xed\x30\x0f\x2d\xe2\x58\x45\x3d\x04\x05\x4a\x30\x23\xf0\x88\x82\x2c\x8f\x89\x21\x92\x31\x40\x18\x03\x51\x89\x12\xf7\x81\x90\x38\x7f\x54\x00\x81\xe0\xf4\x13\xe8\x20\x3c\x97\xb0\x4f\x46\xfc\xa9\x7a\x7f\x24\xe2\x87\xcf\xf9\x81\xd4\xdc\x97\x43\xc2\xf4\x35\xe3\xd0\x7b\x0f\x3c\x82\x8e\x3d\x64\xa6\xff\x4c\x12\xfa\x2e\x1d\x07\x42\x0f\x6c\xfe\xf6\xc1\x39\x60\x69\xc4\xbf\x49\xb7\xe9\x7d\xf4\xd6\xdd\x3f\xa2\xf9\xd3\x9f\x25\xb9\x9b\x71\x1c\x14\xdf\xf3\x03\xd8\x39\xfd\x88\x3f\x02\xff\xde\x14\x8d\x36\x45\xc7\x8c\x19\x15\xf1\xf9\x23\xd7\xde\xf3\x10\x7a\xf7\x91\x4c\x78\xf6\x43\xdf\x80\xcd\xbe\xc8\xe8\xd1\x77\xa3\xb7\x3e\xd8\x04\xe4\xc7\x23\x7e\x21\x06\x8a\x3f\xd8\x84\x7e\x3c\x1e\x21\x76\x15\x8a\xb3\x14\xf3\x43\xfa\xdb\xda\x71\xff\x5f\x26\x60\x8a\xd3\x66\x7d\x0c\xf3\x86\x82\xad\x74\x01\x7e\x35\x82\xa5\x64\x26\x10\x7b\x12\x5a\x70\x4e\x4d\x84\x57\x64\x5d\x91\xd0\x69\x91\x56\x5c\x57\x42\xac\x51\xfc\xe2\x46\x85\x8b\x49\x44\x04\xf8\x24\x11\x92\x1c\x8f\x13\x23\x4e\x0e\x86\x24\xbe\xb4\xeb\x35\x4c\xe4\x99\xd2\x0b\x8f\xb0\x5d\x71\xce\x50\x58\x54\x15\xe7\x4d\xe6\x6a\x56\x10\x1b\xd2\x44\x49\x1c\x8a\x68\xfe\x90\x3e\xbc\x64\xd9\x5d\xc1\x32\x74\x8d\x8b\x0e\x78\x95\x39\x3e\xf4\xe6\x3e\x5d\x96\xa6\x72\xd5\xb0\x22\xde\x30\x7c\xf6\x66\xaf\xda\x9c\xa5\x0a\x96\xd5\x3b\x0d\xd1\xdb\xac\x15\xa7\x6e\xfd\xfb\x2d\x7b\xf0\x77\x2a\x45\x7f\x58\x1a\x50\x2a\x73\x1b\xc7\x8e\xeb\x70\x6a\x39\x8b\x56\xc3\x38\x1a\xab\xb2\x6a\xc7\x07\x68\xe6\x4a\x99\xd4\x03\x47\xc4\x3b\xee\xf5\x94\x48\x5b\x4b\x95\xce\x87\x9c\xb9\xf1\x25\xa3\x27\x3b\x56\x57\x39\xb3\xef\xec\x68\xdb\xf4\xbc\x04\x4a\x0a\xb2\x1b\xaa\x87\x07\x06\x77\xec\xab\x1a\x1e\x54\x4f\xbe\xaf\x6f\xcf\xa2\xee\x9d\xef\x31\x97\xa3\xa7\x8c\xe0\x85\x86\xd2\xbe\xee\x76\x69\x8e\x15\x72\x1c\xbd\x65\x1a\x1a\x2f\x67\xc1\x94\xf7\x7d\x7d\x3f\xf8\x0f\x5c\x63\x53\x5b\xda\xb2\xda\xa7\xd5\xc6\xd1\xad\xd9\x35\xd7\xef\xbf\xef\x5e\x00\x73\x8b\x5a\xf4\xc5\x31\x05\xeb\xf2\x96\x38\x78\x86\x81\x3c\xef\x77\xd8\x4c\x96\x82\x2b\x06\xb9\x97\xba\x94\x4a\x28\x3f\x0a\x39\x75\x6c\xe8\xde\x11\x5e\x4f\xad\x72\x8e\x4e\xe9\xfd\x70\x7c\x62\xe6\x5a\x5b\xb3\xab\x7a\xb5\x06\x1c\x9d\xdb\x3e\x33\xf5\x8c\x4e\xa2\x5d\x7f\xc9\xf5\x33\x87\x4c\x1b\xba\x00\x35\x69\xaa\x27\x4f\xaa\xdd\x85\xfa\x9e\xbb\x24\xa7\x0c\xa8\xce\xf9\xfb\x23\xeb\x9f\x8d\x8a\x0b\x38\xf1\x14\x88\x0e\x5c\xcc\x7c\xe9\xd5\x8f\x2c\x74\x81\xff\x98\x13\x0f\x90\xcd\x27\x18\x0a\x7a\xb2\x08\x88\xbc\xf0\x05\x89\x7f\x0f\x13\xe3\xc9\x22\x60\xef\xd5\x80\xc7\x34\x2c\xad\x7b\x4b\x7d\xef\xc6\x3b\x0e\x3f\x7d\xcd\x8d\xf7\xa8\x5e\x67\xab\xa2\x65\x35\x72\x5b\x3c\x34\x05\xfe\xf9\xa8\xfa\x9e\x4c\xfa\x1b\x4c\x75\x84\xa4\xc7\x42\xc5\x09\xb0\xd0\x9d\x2f\xd1\x38\xe0\x98\xd4\xad\xa9\x6b\x47\xb3\x56\x9d\x24\xdf\xe5\xca\x97\xe8\xcd\x92\x3c\xb0\x15\xf0\x70\xda\x58\xd6\xa2\x63\x0b\x5c\xbd\x3f\x53\x50\x7b\xdb\xe3\xff\x7a\xf5\xf9\xcf\x1f\xec\xa9\x6d\x5a\xb5\xac\x68\x48\x83\xff\xea\x0b\x13\x5a\x9e\x78\xeb\xd5\x2a\xa9\x52\x0f\x6b\x6a\x18\x8d\x4a\x5a\xf9\xca\x3b\x6f\xbf\x52\x25\x55\xab\x59\x4f\x56\x1d\xa3\x56\xcb\x2a\x5f\xa6\x5f\x3f\x4d\xa6\xad\xcc\xba\xc2\x76\xe1\x76\x71\x52\x15\xa2\xc6\x63\x1a\x20\x3d\x38\xc0\xa3\xa3\x30\xd2\x05\x8f\xc3\x6a\x90\x59\xec\x33\x9e\x1d\xe3\x99\x08\x7d\x42\xf0\x2d\xd9\xd3\x8d\xbe\x16\x02\x98\x61\x7f\x7b\xeb\xc9\x2d\x20\xb9\xe5\xe4\x56\x54\x44\xe2\x38\x11\x68\xbb\x7b\x84\x00\x7d\x1d\xd2\x0a\x65\xbe\xee\xee\x39\x93\x24\x21\x16\xb3\xe5\x5b\x4e\xfe\x1f\xe6\xbe\x3b\xb0\x89\x23\xfb\x7f\x67\x8b\x56\xbd\x17\x5b\x96\x65\xc9\xb2\x24\x57\xb9\xc8\x92\x6c\x83\x65\xd9\x98\x62\x6c\xc0\x98\x66\xba\xe9\xa6\x9b\x4e\x80\x80\xe8\x24\x40\x42\x4f\x80\x40\xb8\x10\x52\x08\x29\xe4\x9b\xde\x30\xb9\x4b\x42\x0a\x1c\xc9\x41\x0e\x12\x92\x38\xb9\x34\xee\x92\x5c\xbe\xb9\x4b\x0e\x6c\x69\xf8\xcd\xcc\x4a\xb6\x6c\xb8\xdc\x7d\xef\xfb\xfd\xe3\x07\xd6\xee\xec\xec\xec\xec\xcc\xec\xcc\x9b\x37\x6f\xde\xfb\x3c\x50\x13\xd9\x81\x9e\xd2\x2a\x19\x61\x11\x4f\x1d\x69\x61\x5a\x04\x1b\x10\x36\xc1\x06\x24\x48\x34\x78\xa8\x9e\xda\xb1\x9c\x80\x55\xcd\xc7\x01\xab\x51\x5c\xfc\xd6\xad\xae\x9c\xbe\x4e\x45\x1d\x72\x2f\x86\xb7\xde\x83\xa3\x49\x4b\x49\x7a\x27\xc9\x62\x41\x87\x14\x68\xac\xf4\x6d\xac\xb6\x58\xaa\xd7\xf9\x2a\x0d\x01\xc4\xba\x4f\x48\xb2\x18\xfc\x46\x4b\xd2\x24\xc4\xdd\x07\x0c\xf4\xa0\x2a\x1f\xbc\xe6\xab\x42\xc1\xb4\x8a\x53\xbe\xaa\xd5\x5b\x9a\x3a\xce\x37\x6d\xd9\xd2\xc4\x16\x34\x6d\xa1\x9f\x5b\x88\x73\xc1\x07\xd8\xee\xab\x2c\x2e\xae\xf4\xb5\x1b\x8d\x5f\xe3\xb8\xaf\x3b\xcf\x4b\x0f\xf8\x2a\x2b\x7d\x70\xba\xc1\xf0\x4c\x76\x25\x7d\xa8\xeb\xe9\x2d\x89\xbe\x0b\x69\x34\x35\x63\x2d\x42\x7b\x0a\xb0\xe3\xff\x92\x9b\xec\x0a\x77\xc3\x8f\x76\x5f\x05\x01\xf8\x0a\x1c\x00\x5f\x01\x01\xb0\x86\x9e\x75\x7c\x69\x24\xb4\xf4\xf8\xf1\xa5\x4c\xeb\xd2\xe3\xe0\x75\xda\x1d\xb9\x07\x71\xff\x14\x28\xa3\x1f\xea\x8a\x3f\x8e\xbb\x83\xa9\x13\x8f\x71\x10\x35\x82\x9a\x44\x35\x53\x73\xa9\x85\xd4\x72\xb4\x0a\xdc\x40\xdd\x41\xed\xa4\xf6\x51\xf7\x51\x47\xa8\x07\xa9\x87\xa9\xe3\xd4\x93\xd4\x0b\xd4\xcb\xd4\x6b\xd4\x69\xea\x5d\x01\xeb\x98\x21\x16\xa1\x4c\x6c\x17\xd4\x2e\xc2\x3f\x81\xae\x31\xc4\xe0\x96\x11\xd0\x0f\x74\xc5\x38\x4a\x17\xa3\x6d\x76\x3f\xfe\x09\xb0\x13\x3a\x82\xa3\x8b\x8e\xa8\x62\x0e\x80\xee\x00\x12\x6b\x0a\x68\xdc\x22\x1e\xd8\x4d\x4e\x94\x27\x86\x01\xe5\x1d\x01\x06\x98\x40\x40\x67\x07\x7e\xce\x8b\x56\x38\x26\x23\x63\x0f\x00\x15\xf0\xfa\x78\xa3\x46\x8f\x1f\x32\x69\x02\x1a\x13\xc8\x07\xbc\x26\xe0\x16\x39\x1d\x9c\xc9\x20\xa1\x9d\x6e\x0d\xc7\x7b\x81\x49\x97\x4f\xa3\x5e\xc3\xb8\xdc\x12\xda\xc7\xe8\x1c\x3a\xc0\x57\x00\xe2\x8e\x4e\x06\x4c\x7e\x31\x65\xd6\x9f\x65\x92\xf5\xa7\x19\x7b\x52\xb2\x1a\xb6\x68\x8a\x35\x70\x81\xc6\x6c\x4a\x67\x4f\xeb\x93\x99\x73\xfa\xe4\x14\xfd\x5b\x20\xfd\x7d\x36\xdd\x64\xd6\x82\x6d\x6a\xbf\x1a\xdc\xa5\xc5\x77\x7f\x6f\xb2\xf1\x2f\xeb\x92\x23\x6e\xb0\x11\x1e\xbf\x1b\x1e\x07\xcd\xda\xec\xc8\x58\x40\x9f\x57\xbd\xf2\xb2\x42\x4d\x3f\x02\x57\xbd\x46\x67\xc3\x6f\xd5\xb9\xf4\x93\x80\x0d\x69\xac\xc6\x08\xbc\x54\x01\x96\xa9\x2b\xe1\x08\x30\x48\x1c\x69\xe1\xc0\x48\xb8\x95\x45\xa3\x64\x57\x08\xbe\x7b\xe8\xf4\xd1\x47\x58\x20\x7e\xcc\xba\x1f\x64\x7d\xf6\x19\x7b\xf6\x94\x88\x59\xa6\x8e\xee\xbe\x08\xff\x88\xbe\x67\x66\x74\xe5\x16\xf0\x75\xf6\x08\xe0\xfc\x61\x03\x03\x8c\xe2\x4b\x9c\x18\xd6\x02\x7f\xa4\xf5\x28\xfa\xc7\x96\x17\xac\xcb\xfc\x3d\xcd\x3c\xb6\x76\x10\x47\xaf\x35\xa4\xb1\xf0\x3e\x89\x44\x8f\x4e\x4f\x8a\xc5\xa6\x74\xad\x5e\xaf\xb7\x27\x89\xe5\x60\x08\x9b\xa6\x97\x48\xc0\x54\x2e\x4d\x8f\xd2\x80\x46\xc0\x82\x0c\x15\x98\x2d\x15\x27\xd9\x0d\xe8\x9f\x3d\x49\x24\x87\x07\x80\xdd\xa8\x50\xc2\x57\xd8\xb4\xc8\x59\x30\x19\x1e\x56\x33\x16\x56\x22\xe5\xe0\xbd\xa2\xb7\xc0\xd8\xd7\xc5\x34\x68\x3d\x73\x46\xdd\x31\x5c\xc4\x55\x0f\x99\x09\xa4\xf0\x6c\x08\xee\xb0\x00\x3f\x7c\x94\x55\xa1\xd4\x27\x45\x1c\x58\x5e\x05\x2a\x1f\xfa\xe4\xd5\x93\x62\xc6\x07\x68\xa0\x56\x9c\x04\x0a\x19\x7c\xfb\x10\x28\xfb\xee\x53\x31\xbc\x36\xf0\x6d\x5a\xde\xf6\x79\x0e\x7c\x03\x9e\x06\x5e\xd5\x76\xf8\xe5\x27\xb9\x60\x4b\x07\x8d\x1a\xc2\x80\xda\x0b\x2c\x07\x2c\x2c\x84\x2f\x82\x5f\x3e\x83\x5f\x47\xee\x80\x5f\x81\x94\x3f\xfd\xa9\x1f\x98\x29\x65\xd1\x67\xce\x8c\xde\xd7\xc0\x08\xf2\x12\x82\xff\x8f\x31\xef\x28\xd2\xfd\x3b\x07\x03\xfa\xd6\x09\x8a\x78\xcf\xaf\xa7\xbf\x06\x4d\xcf\xaf\x8f\xfc\x7d\xfd\xf3\xec\xf9\xa7\x42\x1e\x68\xf1\x84\x2a\xf3\x98\xc6\xf5\xa7\xc0\xf4\xf6\xaa\x0d\xaf\xbd\xb6\x21\xe3\x19\xf0\x28\xc6\x30\x87\x7a\x4f\x1f\x81\xde\xac\x47\xe3\xed\x76\x4a\x4a\x3c\x7b\x63\x79\x0c\x4b\x31\x98\x71\x41\x7c\x0b\x87\xd8\x5e\x74\x81\x16\x99\x40\x4b\x39\x85\x0b\x0e\x23\xc5\xf9\xa9\x80\x88\x37\x32\x0f\xc1\xdf\xc2\xf4\x65\xfa\xb3\xa0\xe9\x7c\x03\x98\x3a\xbe\x3f\x5c\x19\x7d\x63\xfe\xf8\x60\x0b\xed\x87\x47\x17\xd1\x1a\x30\x25\x53\x09\xaf\xc0\xd0\xb2\x19\xcc\xef\x4f\x3f\xb1\xf9\xe0\x5c\x30\xf0\x3d\x43\x7d\x25\x37\xeb\x36\x98\x0a\x4f\x8f\x1e\x75\x1e\x4c\x3a\x7b\x67\xe5\x98\x05\xd1\xd3\x70\xe5\x80\x31\x60\x1d\x5d\xd6\xd1\x1b\x4c\xa5\xf5\x4b\xc7\xcd\x58\x0e\x83\xf0\x63\xa5\xbe\xa8\x72\xb8\xe9\x2c\xa8\x9d\x77\xef\x86\x27\x63\xb4\x41\x4c\xb1\xff\x20\xba\xbf\x98\x92\xeb\x04\x2f\x3f\x64\x87\x24\x07\xe8\xfc\x88\xcd\xf6\x7b\x6d\x58\xb9\x93\x89\xc7\x33\x78\xa1\x8b\x18\x19\xc1\x39\x1d\x4f\xbc\x43\x99\xfc\x26\x7e\xda\xc1\xf5\xab\xcf\x9c\xfe\x62\xcf\x9e\x2f\x4e\x9f\x09\xaf\xe2\x0e\xb6\x01\xfa\xea\x81\x03\x57\x01\x0d\xff\x7b\xed\xb9\x43\xab\x1e\x7b\xa3\x6d\xdf\xbe\xb6\x37\x1e\x5b\x35\xf3\xb6\xa7\xc6\xbc\x73\xe2\xc4\x4f\x81\x3f\xec\xb9\xf7\xd3\xa7\x8e\x2c\x5c\xf5\xfe\x92\xf7\x8f\x9d\x78\x87\x5d\xde\x21\x2e\x1d\xbb\x67\xcf\xd8\x52\xf6\xda\x9a\x59\xb3\x3a\x1e\x2a\xad\x64\xa2\x83\xb7\x6f\x1f\x1c\x61\x72\x72\x1d\x73\xe6\xa4\x33\x5b\xd9\x7b\x0e\x56\x45\x86\x79\x8b\xa6\xcf\xe6\x04\x3e\xfa\x18\x9a\x9b\xc7\x76\xda\x5b\x8c\xfb\x9f\xcb\xa1\x6f\xba\xee\x02\x58\x4d\x40\x5a\x21\xb4\xc5\x0a\xb8\x2b\x56\xfd\x78\xbd\x95\x1c\xe0\x97\x56\xfd\x34\x1c\x46\x07\x78\xe5\xd6\x61\x6e\xcb\x77\x0f\x75\x64\x3c\xf4\xdd\xea\x99\xd2\xdf\x2c\x98\x3e\x38\x0f\x64\xbf\xba\x37\xb2\x5b\xb9\xf9\xc4\x31\xfa\x13\x83\xd5\x6a\x88\x3a\x70\x42\x5a\x87\x8f\xd1\xef\xf1\x11\x3c\x8e\x8f\x70\x18\x09\xcf\x22\xe1\x7d\xe8\xf8\xd0\x43\xdf\x7d\xf7\xd0\xe2\x37\x8a\xd2\xdd\x0b\x7e\xd3\xe7\xf9\x3f\xef\x8e\xec\xad\x2a\xb1\x7f\x4c\x61\x6d\x49\xea\x46\x50\x24\xd8\xce\x08\x7e\xda\x0c\xc4\x53\x9b\x9d\xf8\x6a\xcb\xa3\x0a\x29\x1f\x55\x4a\x95\x53\x95\x54\x5f\xaa\x06\xd1\xe5\xa1\x88\x32\x8f\xa6\xc6\x23\xea\x3c\x83\x9a\x4d\xcd\xa7\x16\x51\xcb\xa8\x95\x88\x42\x6f\x44\x14\x7a\x3b\xa2\xd1\x7b\xa9\xfd\xd4\x31\xea\x22\x1a\x11\x58\xf4\xe3\x24\x47\x9f\xdd\x80\xad\xd7\x4c\x3d\x7f\x01\x13\x9f\xf8\xc3\x2e\x89\x12\x7f\x00\xe3\x82\xfd\xca\x0f\xdf\xf7\x1a\x02\xff\xe4\xae\x09\xeb\xb3\x18\xf8\x5b\xfc\x9c\x71\x0e\x8b\x80\xdf\x58\x69\xbf\xa0\x8e\xe6\xe8\xd4\xa7\x03\x22\x97\x80\xf5\x6f\x34\x79\x03\x1e\x11\x16\x5e\x8b\xa8\xc8\xb5\xa8\x98\xbb\xaf\xfd\x0c\xbd\x97\x3e\xda\x7e\x66\xa8\x33\xfe\xaf\x42\x35\x53\x95\x86\x7e\x56\x72\x6e\x56\x0d\x99\xa9\x9a\xb9\x1c\xfd\x6e\x8b\x9d\x23\x95\x0b\x81\x7e\x11\x30\x2c\x02\xfa\x85\xe4\x2f\x16\xee\x78\xc1\xb9\xe8\x81\x9e\xf1\x3f\x0e\x5e\xd4\x99\xb1\x33\xba\x65\xed\x0b\x2f\xac\x5d\xf7\xfc\xf3\xf0\xb2\xbb\x77\x75\x6f\x77\xcb\x24\x33\x93\xd6\x67\x62\x6a\xa0\xc4\x11\xa8\x1f\x12\xc8\xca\x34\xa4\xd7\xa8\x10\x37\x9e\x21\xb1\x2a\xcd\x46\x79\x6a\xc0\x67\x17\x51\xed\x3b\xe0\x13\xa0\xa1\x92\x39\x1c\x99\x0c\x3f\xe2\x32\xdf\x7e\x1b\x7e\xb8\x68\xd1\x9e\x84\xbf\xbb\xd3\xf3\xed\xca\x74\x4f\x3a\xfe\x29\xec\x9e\xf4\x74\x8f\x3d\x7f\x82\x27\xdd\x83\x7f\xe3\xf3\xd3\x3d\xec\xfb\x19\x3d\xfe\xc1\x13\x43\x16\x75\x8f\x59\x34\x24\xa3\x5b\x9e\xe8\xcf\xf1\xfc\x3a\xa1\xb4\xe0\xf6\x8c\x2c\x09\x07\x74\x86\x42\x6f\x45\xb6\xd4\x98\x9b\xe6\xc9\xe7\x81\x4c\x6f\x48\x12\x19\x4d\x65\x40\xc5\xc8\x18\x11\x2d\x35\xe5\xc5\xfd\x0b\x2c\x42\xe3\x6f\x3b\xc1\x7b\xc8\xee\xb1\x86\xbd\x95\x71\x5e\xcc\x8d\x2c\x66\x34\x26\xde\xdf\x76\xf8\x70\x1b\x03\x0f\xb7\xdd\x7f\x7f\x1b\x68\xab\xc8\xbb\x76\x29\xaf\xa2\x22\x0f\x3c\x99\x1b\xa2\x7f\x0a\xe5\x82\x27\xf3\x2a\xc0\x16\x7c\xef\x30\x4e\xd8\xb2\xe0\x30\x5b\xd2\xfe\x4a\x6e\x45\x45\x2e\x57\x8d\x8f\xbf\xf9\x0d\x3a\xc6\xf8\xd0\x4c\x44\xbf\x2e\xa3\xf3\x18\x44\xbd\xb8\x38\xdc\x11\xdf\xb5\x3f\x4f\x04\xcd\x18\x1f\x90\x15\xbc\x44\x50\x89\x10\x49\x31\xcd\x01\x9f\xb0\xc9\x11\x57\x65\x17\x1e\xf0\x73\xfb\x00\xbb\xe7\x83\x8f\x0e\x8f\x38\xb0\x62\x61\xf3\x8c\x85\xcb\xef\x1d\x76\xe0\xb7\xe7\xef\x9f\x7a\x69\x04\x67\xb3\x88\x95\x86\xde\xd3\xe0\xcf\x6b\x36\x7e\xbe\x19\xa4\x9c\x5b\x7e\xf1\xf0\xce\x8d\x9b\x8e\x8d\x99\xbe\x71\xed\x44\xeb\x0c\x8d\x3e\x4d\xf3\xc7\xfb\xcb\x66\x97\x17\x89\x55\x86\xe4\x5e\x4f\x4d\x38\x05\xd9\x52\xe6\xc5\xf7\xde\xd8\x75\xe8\xfd\xc0\xb8\xe5\x1b\x36\x2e\x1f\x17\x78\x7e\xff\xa1\x97\x6a\xcb\xd9\x54\x9d\x41\x99\xe4\x6b\x9c\xb3\xf8\xc3\x4d\x67\x81\x7a\xd4\xd6\x87\x1f\xd9\x3a\x6a\xe5\xb4\x89\x61\xa7\x55\xaf\x1d\xac\xbf\xff\xbc\x33\xd7\x69\x50\xe9\x52\xfa\xd4\x74\xbc\xe6\x4c\x55\xc5\x78\x59\xec\x7f\x1c\xdb\x12\xe4\x60\x8c\x28\xa2\xc2\x40\x7c\x52\xa6\x02\xa2\x2a\xd6\x0b\x10\x90\x11\x8c\x45\x12\xc7\xb2\x67\x63\x67\x1d\xf1\xb0\x40\xfc\x0a\xa0\x8f\x10\x27\x75\x41\x10\x60\xe2\x32\x15\x2b\x8b\x97\xe1\x2c\x76\xd0\x8b\xa5\x16\xc4\x87\x2f\x09\x44\xbf\x16\x74\xc8\x05\x55\xf2\x77\x6d\xc9\x1d\xdf\x01\x9e\x4b\x62\xee\xc5\x49\x22\x94\xd9\x65\x74\xd2\x27\xdf\x13\xc4\x26\xea\x64\x95\x8c\xe5\x01\x7b\xd2\xec\x62\xba\xe7\x82\x03\xd1\x44\xc5\x72\xa6\x15\x52\x49\x4e\x66\x05\x9f\x9a\x24\x55\x17\x60\x8c\x3e\xb3\xd2\x5b\xcd\x32\x01\x14\x54\x68\xd3\x8c\x4e\xde\xd5\x85\x6b\x8f\xeb\x2d\xe8\xe3\x0f\x13\x7a\x9b\x2a\xae\x46\x4f\x3c\xa0\x99\x80\xb1\x28\x00\xfe\xd3\x3a\x73\x94\xab\x58\xb7\x1b\xbd\x76\x37\x62\x32\x75\x80\xc2\xd0\xd8\x54\x74\xf7\x7f\x5c\x6b\xdd\x2e\xe0\xc4\x37\xe0\xc7\xbb\x74\x28\xe7\x1b\x94\x0e\xe7\x97\xfe\x3f\xaf\xbb\xe0\x47\x43\xe0\xdf\xb1\x37\x4e\x39\xb1\x35\x43\xb7\x74\x12\xc6\xee\xd6\xd9\x25\xb4\xdd\x69\x67\x08\x43\xef\x14\xb6\xcc\x89\x67\x0f\x8c\x53\x60\x2f\xba\x40\xcf\x87\x17\xc0\x55\x30\x3e\xda\xef\x8e\xf7\x60\x3b\x6c\x63\xa2\x28\xe6\xd5\xc8\xeb\xf4\xf1\xf7\xe0\x0f\xf4\x7c\x30\x06\xb6\xc1\x76\x30\x1a\x84\x95\xb4\x3a\x12\xd2\x96\x69\x23\x21\x35\xad\x04\x61\xad\x9d\x0d\xdb\x19\x2a\x3a\x83\xde\x1f\x89\x30\x2c\xf1\xb7\x11\xf9\x86\xde\x4f\x02\x20\x3c\x1d\x52\xda\x7c\x4d\x84\xd2\xeb\x59\x4a\x93\xaf\xa5\x29\x6c\xc7\x89\x2a\xc9\x7f\x8f\xe6\xa2\x1a\xea\x1e\xc4\xe9\x53\x1c\x16\xcb\xf3\x6e\x02\x45\xfd\xeb\x87\x80\x60\x1c\xfb\x4f\x0f\xce\xc4\x44\x1a\x06\x6f\x9b\x6b\xbc\xd8\xcd\xa8\x01\x43\x80\x62\x1f\x0d\x8c\xa6\x2b\xf5\xbf\x7a\x25\x30\x38\x39\x1f\x9e\x66\x78\x1d\xfa\xc8\xe1\x31\xc3\x86\x69\xfd\xda\x61\xc3\x50\xf8\x9f\x1e\x70\xa2\x5f\xbb\x3f\xac\x3d\x2f\x21\x55\xe8\x03\x8d\xde\x7a\x32\x2c\x6c\x03\x85\x4f\x5a\xf5\x9a\x0f\x74\x89\x39\xfd\xea\xeb\x40\x08\x60\x13\x1f\x88\xfa\x8b\x90\xa1\xee\x9f\xfd\x7e\xe5\xee\x6d\xf8\x6e\x43\x83\x4e\xd7\x10\x02\x4e\x50\x66\x2e\x97\x96\x81\x1c\x6c\x1c\x0e\x2f\x96\x49\xcb\xcd\xf0\x4d\xf8\xb1\x16\xdd\x6c\xf8\xd5\x4c\x58\xb3\x00\xb9\x19\x1f\x7f\x5c\xdc\x97\x4b\x1f\x6a\x29\x45\xd9\x75\xa8\x25\x75\x2a\x00\x62\x4e\x20\xd3\x63\xbe\x20\x05\x37\x8e\x12\xec\x80\x1a\x6b\x67\x31\x28\x20\x16\x0c\xa3\x3b\xc7\x1e\x13\x70\x7b\x31\xa1\x15\x88\x2d\xc6\x67\x31\x16\x11\x90\x16\x40\x80\x5c\x8d\xbc\x97\xb7\x32\x74\xa8\xa9\x09\x37\x44\xb8\x09\x50\x34\x2d\x1d\xd9\x6f\x12\x6f\xe1\x27\xf5\x1b\x29\x25\x7a\xba\x32\xf4\xc7\xc8\x39\x85\x4c\xa3\x35\x29\x32\x3c\x3a\xa9\x42\x26\x97\x29\xa4\x3a\x4f\x86\xc2\xa4\xd5\xc8\x14\x9c\x9c\x91\x91\x54\xe0\x81\x5d\xb7\x45\xf6\xdd\xb6\x4b\x92\xea\x19\xea\x1b\xf3\xa1\x91\x7e\xfd\x03\x4d\xdf\x0c\x5b\xae\x75\x4e\xef\x39\xd6\x5c\x5b\x46\x5f\xcd\x07\xaf\xf3\x29\x1f\x36\x54\x8c\xce\x56\x83\xd6\x70\x08\x9b\x48\x85\xc2\x74\x11\x4b\x8b\x75\x34\xad\x13\xd3\xac\x56\xc2\xf0\x3c\x6b\x17\x9b\xc5\x7a\x5e\xce\xb2\xc9\x8e\xf4\xe4\xe4\x74\x47\x32\xcb\xca\x79\x3d\x8a\xb4\xb3\x3c\xcf\x48\x22\x47\x6f\xbb\xf3\xce\xdb\xca\x17\xde\x31\x6f\x92\xf9\x4a\x28\x24\xd7\x67\x96\x94\x66\x07\x77\x64\x3b\x83\x41\x67\xf6\x8e\x60\x76\x69\x49\xe6\xd0\x21\x9f\xdb\xd7\x1c\xb9\x3b\xb6\x6f\x10\x45\xb4\xac\x0e\x71\xac\x2d\xd8\xda\x45\x49\x63\xab\x0a\x17\xd9\x28\x21\x22\x50\x47\x82\xe0\xdb\xd5\x69\x13\x6e\xa5\x4d\x76\x2f\x96\x84\x06\xc8\x5e\x3b\xee\xee\x31\xa1\x04\x62\xd5\x4d\x78\xaf\x09\x71\xb0\x01\xbb\xe0\x22\x9d\x88\xdb\x33\x81\xff\x26\x19\xbb\x38\x2a\xaf\x5e\xf7\xf2\x8c\xdf\x7c\xaf\x96\x0f\x19\xd2\xbf\x69\x9e\x33\xe5\x06\xd5\xb7\x53\x0c\x5e\x57\x97\xb4\xf2\x59\x62\x0e\x16\x1e\xbc\x69\x4a\x6e\x2a\x4d\x2d\x1a\xf1\xa9\xd5\xc5\xb1\xae\xa4\xa8\x5d\xdf\x6f\xa1\x2e\x65\x1a\xbe\xf9\x5f\x8b\xd6\xef\xb8\xfb\x9d\x6b\x17\x16\x3d\x65\x82\x6f\x3a\xf4\x5a\xcd\xee\xfc\xdc\x0d\xaf\xbc\xc2\x85\x81\xf8\x95\xee\x32\x77\xf0\xf7\x19\xa7\xb6\xd4\xf1\xb2\x2f\x8f\xcc\x7f\xab\xff\xec\xfa\x2f\xd7\xa5\xb8\xe3\x92\xf1\x94\xbc\x79\x88\xd4\xa5\x14\xa5\x1a\xc3\x79\x56\x93\xd5\x32\x73\xa1\x0e\xbd\xd6\xec\x3a\x51\x91\x62\xbe\x1c\xed\xd8\x39\x3f\xcd\x96\x86\x56\x74\x58\xf0\xfe\x4a\x4f\x71\x7b\xcc\xbf\x11\x17\xe6\xda\x10\x8f\x3b\x04\xcf\x84\x76\xbd\x92\xb6\x79\x68\x01\x4f\xc3\x88\x95\x6c\x94\x2c\x6f\x65\xb1\x27\x74\x02\xac\x41\x4c\x18\x19\x41\x56\x95\xa8\x71\xd2\xa9\x97\x17\x9b\x31\xb8\xf0\xca\xb3\x3f\xc3\xf6\x9f\xcf\xae\xac\x5a\xbc\xbc\xbf\x39\x97\xe5\xd2\xcc\x65\x4d\xa5\x99\x2a\xc0\x14\x4c\x5e\x77\xea\xc2\xa9\x75\x93\x0b\x18\xa0\xca\x2c\x6d\x2a\x33\xa7\x71\x6c\xae\xb9\xff\xf2\xc5\x55\x30\xec\x32\x87\x04\x13\x27\xd4\x7a\xb5\x3e\x10\xf6\xd5\x36\x11\x5f\x57\x15\xd3\xca\xd3\xd2\xca\xa7\x55\x14\x0e\xf1\x3b\xe4\x28\x2b\x94\xa1\x34\x25\xc9\xa4\x66\x65\x69\x0e\xab\x5e\x6f\xcd\x48\x93\xb3\xca\x24\x53\x8a\x14\xe5\x84\xf2\x93\x3b\xfc\x43\x98\x21\x10\x3b\x14\x0b\x0b\xfb\x11\xf8\xe7\xab\xad\x05\x8f\x08\x3e\xb1\xe8\x4e\x9f\x35\x29\x44\x7b\xca\x8e\x21\xfc\x04\x0c\x4b\xb7\x1d\x7d\xff\x14\x20\xf8\x72\xd1\x99\x8c\x00\xcd\x79\x18\x98\x56\xc4\xcb\xd0\x8c\x80\x77\x13\xec\x31\x8c\x48\xda\x14\x64\xb0\x00\x9d\x02\x85\x9c\x94\x65\xa2\x3b\xb5\xc5\xda\xe8\x0e\x4e\x0d\x16\x18\x1d\x5c\xbf\xd7\x44\xe9\x46\x43\xba\x68\x57\x89\x96\x76\xcf\x80\x77\xcf\x17\x3b\x74\x79\xb2\xb5\xbf\x13\x39\x72\xd3\xb9\xc5\x70\xf4\x0c\xd8\x16\x5c\x3b\xbf\x3e\x23\xa3\x7e\xfe\xda\x60\x1b\xa4\x29\x91\x84\x61\xa3\x8f\x68\xb5\xf4\x18\x5a\x9b\x62\x00\xc9\xd1\x69\x7a\xb3\x59\x0f\xbe\x6a\x71\x80\x13\x3b\x0f\x7e\xa2\xd1\xd3\x5c\x16\x6c\xa0\x9f\xd0\x9b\x53\x0c\xb0\xe0\xe0\xce\x2b\xd7\x72\x6a\x42\x19\x19\xa1\x9a\x9c\x6b\x98\x87\xa3\x6f\x50\x6c\x98\x8b\x10\xdb\x1a\x0a\xe8\x29\x5e\xe3\x8d\xf7\xea\x4e\x41\x5d\x27\xde\xae\xc6\x03\x68\xe2\x7d\x96\xd5\x66\xe0\xbd\x22\xf4\x63\xc3\xf0\xf2\xe5\xb6\x2e\xd0\x18\x21\xb8\xef\x6f\x6b\xe5\xb2\xad\x9f\x6f\x3c\x0e\xb2\x9f\x88\x50\x42\x8f\xc3\x7b\x3f\x4c\xeb\x27\xf0\x45\xd4\x97\x12\x92\x0a\xea\x44\xac\xfa\x09\xa0\x3d\xb8\xe9\xeb\x5d\x2a\xdd\x2e\xf8\x67\xad\xb0\x9b\x83\x9f\x4a\xdc\x07\xc5\xb6\x80\xdd\x7d\x42\x12\x6f\xc8\x74\xba\x87\x26\x1b\xc0\x26\x10\x03\xc2\xf1\x0a\x65\xa3\xd4\x5c\xab\xd9\x45\x5e\x00\xd7\xad\x1e\x7b\xf0\xe2\x9f\x2f\x1e\x1c\x8b\x4e\x4b\xde\xbd\x0f\xac\x86\x1d\x44\x58\x39\x23\x5e\x34\x78\x9d\x43\x5f\x1b\x0a\x6a\x4b\x22\xb8\xf6\xbe\x77\x97\x08\xa9\xf1\x43\xab\xc1\x6a\x92\x4d\x7b\xb8\xab\x2e\x9d\xba\x28\x2c\xa6\xcd\xe5\x82\xed\x9c\xd6\x80\x9a\xd0\xf0\x2b\x4d\xe8\x73\x51\x44\xe3\x0c\x51\x1c\xac\xb2\x63\xc5\x54\x83\x50\x12\x5e\x14\x2f\x34\x13\xdc\x79\x12\x35\xaa\x80\xd8\x40\x5e\x2b\x04\x2f\xc3\xcb\x27\x77\x1e\xab\x10\xe9\x34\x7d\x0d\xe2\xdc\xd6\xef\x5a\x73\xc5\xa9\xe5\x1a\x9d\xa8\x22\xfa\x60\x57\x25\xd8\xdf\x0d\x80\x7f\x79\x18\xb7\xf2\x86\x84\x47\x49\x70\x43\x12\xe8\xff\xc9\xc3\xc0\x30\xa0\xe9\xa4\x3a\x45\x3f\x6b\xdd\xba\x59\xfa\x14\xf5\xc9\x8e\x2b\x09\x55\x22\xfd\x81\xcc\x35\x55\xd4\x40\xbc\xe7\x1c\x53\x78\x8f\x57\x03\x83\xc7\xfd\x8b\xfa\xe1\x2e\xe2\xa7\x30\x11\x70\xe2\xf1\x1d\xaf\x14\x4b\x61\x9b\xf9\xf8\xd7\x58\x7d\xab\xfa\xed\xfd\xdb\x3a\xb9\x1a\xd8\xde\x5d\x7a\xa5\x91\xba\xb1\x49\xa9\x8d\x6e\x4e\xf8\x36\xa8\xb3\xa0\xaf\x43\xba\xcc\xa6\x1b\x87\xdf\xbe\x75\x05\x51\x27\xd2\x1c\x7c\x0f\xe4\x98\x94\x55\xfd\xa0\x56\xd9\xd1\x94\xf8\xb5\xe8\x4e\xdb\xd2\xd9\x18\x3d\xe4\x3f\xa9\x1b\xfe\x76\x01\x37\xdf\x09\x39\x6c\xe8\x26\x6d\x8f\x4f\x06\x81\x4e\xa4\x62\xbf\xad\x7b\x23\x70\xff\xba\x11\xd0\x47\x5e\x5d\x3c\x4d\x62\x96\x16\x48\x81\x64\xe6\x7c\x72\x07\x11\x21\x1b\xbe\xb9\x71\xd6\xc8\xd8\x8d\x31\xa5\x87\xc1\xae\xc3\xff\x61\x2b\xe1\x6e\xf0\xf6\x61\xdf\x7c\x29\x10\xe7\x8a\x53\xa4\x8b\x5a\x36\x91\x3e\x1f\x2f\xd7\xec\x09\xb1\x1b\x53\x4a\x56\xaf\xbe\xa9\x15\xb1\xec\x87\xc6\xfa\x4e\x5c\x94\x2a\xa1\x82\x54\x2d\xd5\x40\x76\x66\x8c\xb4\xe8\x56\xa4\xc3\xfe\x4f\x88\x08\xee\x21\x68\xd6\x34\x52\x68\x92\x74\x8b\xd4\x4c\x11\x61\x48\x5c\x64\xe2\x05\x1a\x2c\x93\xd3\x80\x22\x14\x46\xf3\x27\x61\x4b\x44\x50\xbe\xf6\x6f\xfb\x12\x28\x06\xa4\x7a\x90\x1b\x0d\x70\x9f\x3d\xf7\xd8\x63\xe7\xce\x02\x77\x64\x37\x62\x5d\x5a\x17\xcd\x38\x70\x60\xc6\x22\x32\xb3\xd2\xd7\xef\x58\xb6\xec\x0e\x3a\xf4\x22\xae\xc5\x8b\xe4\x06\xf3\xd7\x83\xf0\x87\x27\xd4\xdd\x48\xd1\xcd\x04\xe9\x1c\xc8\xd3\x19\x16\x2d\x32\xe8\xe0\x1f\xa2\xef\xac\x07\x73\xd6\xaf\x87\x7b\xe0\x2f\xa5\xc7\xbe\x68\x7b\xb8\x54\x68\x72\xc4\x90\xb3\xaa\x21\x43\x54\x30\x02\x62\xb4\xa1\xf4\xe1\xb6\x2f\x8e\x95\x62\xbe\x0d\xdc\x10\xf1\xb8\xbf\xf5\xa3\xea\xa9\x09\xd4\x9c\x5b\xf5\x39\xc4\x3e\x8b\x28\x5e\x94\xe1\xf6\x30\x01\x61\xea\x74\x76\xea\x61\x76\xef\x9c\xa6\xd8\x80\x02\xc5\x84\x51\x31\x05\x81\x53\x6f\x34\xa1\x56\xa3\x02\x78\xb7\x0b\xd1\x45\x0a\x1b\x16\x92\x4e\x6c\x05\xa2\x6e\x3d\xad\xae\xc2\x98\x06\x7f\x7a\xfe\x03\x78\xb4\xcf\x92\xf3\xbb\xeb\xc5\x92\x3b\xbf\xd8\xbc\xf4\xe3\xd1\xa4\xff\x24\xa6\xeb\x95\xfe\xdc\x2e\x12\x09\x29\xf6\x81\x8f\xd0\x5f\x24\xfc\xe9\x31\x06\x28\xdf\xf5\x7d\xb2\x19\x35\x24\xd3\x8a\x1a\x10\x45\xc0\x9f\x50\x04\xdb\x94\xd8\xd7\x26\xfe\x10\x7e\x0e\x46\xcc\xa9\x1f\x9d\x12\xcd\x38\xfa\xe9\xb2\xcd\x7f\xde\xab\x12\xc6\x60\x28\x31\xd5\xc0\x89\x92\x45\x28\x0e\x1e\xd1\xbb\x92\xdb\x1f\x26\x87\x47\x22\xa6\x54\xeb\x07\xa0\xc2\xb9\x7c\x17\xbc\x1e\xe1\x11\x17\x84\x62\x2c\x69\x1f\xc0\xd3\x28\x06\xb5\xa1\x28\xb6\xaf\x31\x10\xb5\xe1\x38\xaa\xf9\x57\xda\x10\xf5\x99\x7f\x8b\x30\x11\x77\x23\x42\x53\x92\xbe\x47\x58\xbd\x80\x4b\x8d\x7b\x5f\x67\x9f\x53\xa3\x2e\x17\xee\xd1\x84\x36\xf8\x8f\x67\x3f\x7b\x69\xc9\xd6\x9b\xc6\xec\xc1\xeb\xb7\x9b\x92\x81\xe2\xa5\xb6\x97\x76\x3d\xf1\x76\x6c\x54\x52\x61\x0c\x15\x80\xaa\xb3\x64\xda\x81\x03\xd3\x96\xbc\xc8\x94\x0a\x9d\x8f\x5c\x76\x1f\xa7\xa8\xed\x9e\x81\x91\x94\xf4\x55\x83\x55\x37\x0f\x56\xcd\x8b\x20\xfd\x81\x97\x81\x2a\x35\x7d\xd5\x24\x32\x1a\xbf\x89\x75\x43\x30\x1f\x77\xbf\xd2\x87\x41\xeb\xc3\xa5\x91\xce\xae\x07\x43\x0f\x97\x76\xd3\x1d\xea\x45\x90\xe3\x13\xe7\x4c\xbe\x53\x59\x92\xef\x3e\x7b\x06\xba\x34\x26\xff\xe9\x3c\x7a\x71\x9b\x44\xe2\x41\x44\x68\xdb\xe0\xee\xf3\xe9\xe0\x13\x42\xfc\x89\x8b\xbf\x3e\xaf\x7e\xb8\x4d\x6a\x46\x09\x25\xdb\x87\x74\x9f\x5f\x07\x9f\x10\xe2\x4f\x5c\xfc\x27\xf3\x2c\x7d\x83\x25\xf3\x6c\x29\xf1\xe7\x68\xa4\x0c\x7a\x9a\x25\xdb\xba\x5a\x7f\xc0\xd7\xf5\x91\x79\x01\xd4\x49\xa8\x46\xbc\x9e\x5d\xdd\x82\x8e\xd5\x87\x0e\x5f\x06\xee\x27\xe0\x87\xc7\x37\x7e\xbe\x55\x86\x29\x0b\xd9\xfc\x3c\x32\x4e\x28\xc4\x3b\x68\x2d\xf8\x8e\x50\x9f\x71\xc2\x8d\xeb\x5d\xb5\x61\x56\x25\xc1\x17\x3f\x79\x18\xfe\x79\x97\x4e\xb5\xeb\xeb\x4d\x07\x81\xf6\x09\xb5\xf0\xd9\x8e\x8d\x13\x9e\x79\x5b\xa7\x7b\x5b\xc8\x68\xdc\x31\x72\xa3\x23\xdc\x7d\x1e\x42\x2b\x3a\x3e\xcc\xae\x8e\xd7\x85\xa0\xa0\x0b\xa5\x4e\x20\x97\x22\x0a\xeb\xf1\x09\xdc\x96\xd1\xe4\xf5\xc5\x37\x41\xed\x71\x30\xaa\xf8\xb7\xe1\xe7\xea\x74\xf0\x23\x49\x8a\x24\x4f\x2a\x7d\x11\x7e\x14\xa3\xf1\xff\xa4\x8c\xc0\xf5\xa2\x54\x9a\x87\x12\x77\x84\xba\xaa\x44\xcf\x45\x15\x86\x1f\x09\x37\x5e\x14\xa8\x20\x9a\x87\x9e\x00\xd9\x9d\xed\x23\x44\xbe\x28\xbc\x25\xf2\xfd\x4d\xf3\x2a\xf9\x36\x58\x3e\x24\xf0\x90\x9d\x40\x70\x14\x5e\x11\x20\x96\xb7\x93\x0d\xc0\xec\x22\x29\x09\x7a\x41\xec\xe3\x47\xf9\x84\xd6\x25\x0c\x62\xf4\x3e\xa2\x13\x3e\x15\xcf\x54\xb1\x5e\x12\x7d\xb7\xc7\x3b\x11\x81\x0d\xb3\x18\x4f\x18\x83\xb7\xc7\x98\x51\xaa\xb3\x3b\x63\x2d\x2f\x0a\x5e\xef\xe4\x23\x37\x77\xf5\x56\x74\x02\x09\x73\x26\xed\xeb\x8a\x47\x27\x2a\x01\x87\x2d\x23\xc1\xd7\xa6\xc6\x1b\xc0\x8a\xaf\xde\x00\x51\x25\xc4\x00\xc3\x5e\x4d\x27\x70\xdc\x63\x8e\xa2\x22\x07\xbc\xed\x2d\xeb\x57\xf9\xd5\x2b\x2a\x16\x6d\x39\x7a\xe6\x4c\xd4\x8e\xe3\xb8\x70\x91\xa3\xfd\xb8\xa3\x88\x1e\xf6\xed\x9e\x92\x12\xf0\x7b\xc9\x91\x5d\x8f\x7d\x1b\x7d\x1c\xdd\x18\xe9\x28\xa2\x62\xef\xe2\x30\x7d\xab\xc3\x3b\x61\x78\x5d\xc0\x1a\x89\xd3\xd1\x74\x97\x5b\x29\xc2\xc6\x51\xe8\xa5\xda\x40\x97\xd8\x5d\xd0\x05\x67\x89\xd0\x94\x00\x9b\x0b\xbb\xb6\x1e\xa6\x76\xc3\x89\x37\x67\x1c\x06\xea\xe3\xae\x86\xa5\x27\x66\x54\x6f\x4a\x95\x66\xc8\xac\xc6\xec\x22\xa7\x52\xa2\xca\x19\xc3\xdb\x9a\xeb\xcb\xab\x1b\xc7\x84\x02\x13\x2a\x0a\x53\x14\x1f\x3f\x75\x06\xfe\x3d\x39\x35\xd9\x6a\xa4\x55\xde\x21\x39\x46\xe6\xb1\x39\xa7\xee\x6a\x2e\xde\x08\x8f\x34\xbd\x70\x7c\xed\xa0\x50\x89\x7b\x77\xce\x94\x9c\x86\x9a\x22\x4e\x7a\x28\x6d\xdc\x57\x60\x8c\xb5\xb2\x79\xd8\xae\xa1\xc1\xaa\xf6\x60\xc5\xb0\xa2\x91\xcd\x4b\x66\xe6\x3f\x7e\x1a\x46\xdf\xca\x6d\x28\xc8\x91\x58\xc6\x30\xaa\x86\xd9\x73\xe3\x72\xe9\x15\xa8\xed\x36\xa1\xf5\x44\x10\x23\x96\x50\x02\x32\x09\xd1\x3d\x27\xeb\xec\x80\xe0\x8e\xcc\x48\xb4\x11\x01\xa9\x10\xc1\x19\x42\x11\x4c\x22\xce\x2d\x1f\x30\x6a\xe3\x30\x64\x18\xef\x4e\x47\x94\x8f\x98\xf7\xcc\x8f\x72\xb4\x46\x3d\x2f\xbf\x74\xe3\xe4\x1d\x75\x03\x00\xd3\x3f\xc9\x22\x4a\xe2\x75\x2a\xb1\xb8\xa8\x2f\x97\x5e\x5d\x32\x51\x2e\x55\xb5\xac\xb9\xfa\xc8\xd4\xa9\x8f\x5c\x85\xe8\xb4\x7c\xc8\x4f\x87\x11\x59\x07\xa6\x77\x96\x2f\x7f\x07\x5e\xdd\xff\xdb\xe3\x70\xe2\x96\x39\xcb\xdf\xa1\x8b\x1a\x25\x9c\xd4\x9e\xe3\xf6\x05\xf3\x76\xb5\xcc\x1e\x25\x1e\xdb\xc7\xc8\x28\x0c\xfa\x2d\xbc\xa1\x46\xca\x8b\x6b\x42\xbe\x02\x1e\x0e\x89\x65\x82\x4e\x6b\xde\x3d\x76\x75\x50\x33\x37\x1d\x67\x02\xcf\xc1\xab\xef\x2c\x9f\xb0\x09\xec\x7d\xfa\x0f\xfb\x51\xce\xc4\xaf\x4b\x0c\x7f\x4c\xc0\x0b\xd2\x11\x19\xb1\x1b\xb5\x02\x5a\xb1\x04\xec\x3e\xbb\x06\xfd\x3a\x4d\x95\x12\xc2\xda\x4e\x9c\x11\xe2\x8f\x86\xfc\xb0\x8a\x2f\x85\x7f\x22\x5b\x49\x7d\x49\x49\x7d\x7b\x52\xc2\x85\xf0\x77\xef\x75\x0a\xeb\x52\xe3\x5f\x98\x80\xd2\xdc\x4b\x6e\xb0\xb6\x78\x88\x16\x52\x46\x6d\x58\x60\x48\x53\x5d\xc7\xce\x7d\x47\x82\xc5\x9d\x83\x2d\x67\x28\x9b\x4b\x8d\x71\x05\x41\x8c\x85\x4d\xd0\x22\x89\xcf\x03\xf6\xb8\xf6\x08\x71\x70\x6e\x88\x0b\x93\x38\x6f\x7c\x05\x83\x35\x52\xb1\x67\xbc\x89\xf0\xf5\xcf\x31\x3a\x3f\x1d\x02\x4d\x0a\x9d\x4e\x01\x8f\xe8\x14\xad\x0a\x1d\x3c\x82\x2f\x40\x13\xb9\x88\xda\xea\x8a\x01\x55\x3d\x03\x8b\x86\x78\x83\xcd\xdf\x6f\x5a\xb9\x4e\x3f\xe4\x9e\xa7\xef\x19\xa2\xd7\x6d\x18\xf1\x59\x71\x1d\x1d\x8e\x01\xfc\xc3\xfb\x6f\x7e\x5a\xc8\x37\xda\x5a\x5c\xf7\x43\xd1\x9d\xb7\xf9\xa6\x2d\x99\x3a\xb1\x4f\xa6\xa6\x1c\xfd\xd3\x34\xd5\x15\xc7\x75\xa2\xf9\x7f\x90\xfa\x79\xa9\x91\x09\xf5\xc3\x3d\x51\x05\x04\xb4\x0c\x01\x0b\xd0\x57\x5c\x41\x86\x18\x46\x5b\x25\x32\x1d\x7c\xc4\xfd\x95\xe3\x09\xdc\x42\x62\x45\x8d\x36\x52\x4d\xc2\x7c\x75\xd5\xf3\xd9\xeb\x12\xc9\x16\x89\x42\x29\xb9\x7e\x5d\xa2\x54\xa0\x20\x0e\xf4\x88\x89\x1a\x9e\x75\x3a\x87\x19\x4c\xdd\x2a\x7c\x00\x0c\x3c\xa0\xd7\x59\x52\x2d\x66\x67\x67\x7d\xa3\x9f\xfd\xf3\x4c\xba\x62\x9e\x75\xfa\x7d\xce\x61\x4c\x57\xe5\x57\xac\xd0\x88\x52\x3c\x76\xbf\x33\x41\x2f\x56\x4b\x99\x09\xfd\x22\xac\x92\xa0\xa7\x1f\xfb\x84\xf1\xae\x67\xef\xd4\xa4\x01\x94\x08\xcd\xef\x37\xa8\x76\x44\xc8\x89\x10\x88\x0e\xed\xbb\xb0\x6f\xdf\x05\x6e\xe4\xe7\xf7\x47\x43\xe8\x12\x23\xa1\x85\x00\x26\xf3\x04\xeb\x0c\x1a\xf1\xdd\x7d\xa1\xfb\x3f\x47\xe1\x70\x17\x96\x2e\xa6\x63\x46\xa2\xe5\xc2\x78\x0d\x76\xde\x6e\xb0\x4b\x70\x5f\x77\xdb\x7d\x5e\x86\xa8\xbc\xe8\xd0\xac\xd6\xda\x0a\x7f\x08\x80\x1a\x38\x0d\x1e\x44\xff\xa7\x81\x9a\x00\xfc\xa1\xb5\x15\x50\xa0\x0f\x58\x01\xfa\x40\x6a\xce\x25\x11\x05\x43\xad\xe1\xd6\x48\x2b\x83\x4f\xa0\x35\x8a\xaa\x85\xa6\xab\x38\x7d\x11\xde\x83\xe7\x1a\x07\xa6\xcf\x2c\xa6\xcf\x88\xa7\x21\x9f\xaa\x42\x70\xab\x9d\xe1\xd5\xc6\x3d\x8b\xa2\x7a\xb3\x98\xef\xef\x78\xe6\xa2\x5a\x6d\xec\x68\x33\xaa\xd5\x17\x9f\xe9\x40\x7c\xd9\x8f\xc4\x89\x13\xca\x19\xd1\xfa\x97\x37\x46\xc2\xeb\x5e\xe0\xde\x51\x65\x66\xaa\xde\xe1\x5e\x58\xc7\x84\x37\xbe\xdc\xde\x4a\x7c\x36\x81\xf3\x18\xde\xa9\x13\x6f\x2e\xe1\xdd\x39\x82\x34\xe2\xd6\xef\xa7\x13\xde\x4f\xfd\xcb\xb2\x7c\x21\xf8\x2c\x0d\x45\xdb\x18\x28\xb8\x34\x0d\x61\x2b\x94\x5b\x16\x4b\x70\xf5\x0a\x5e\xc7\xc5\x8a\x26\x5e\xc4\xf7\x6a\xee\x44\x74\x68\x29\xf1\xbf\x62\x21\x98\x37\x1a\x32\x41\xc4\xdc\x79\x63\x21\x89\xd1\x24\xa1\xb1\x0f\x79\xb7\x13\xcf\xd5\x12\x20\x44\xd2\x23\x92\x93\x34\x6a\x98\x6f\x48\xd5\xeb\x94\x56\x70\x83\x09\xd1\xc6\xe8\x9f\xd9\xd9\x96\x02\x13\xec\x4f\x27\x47\x6f\xe4\xc2\x15\xa0\x5a\xe3\x50\xca\xe9\x54\x96\x1d\xdb\x31\x3b\xd9\x21\xbe\x2a\xcd\x37\xb1\x8b\xf5\x16\xd5\x0d\x8a\x99\x11\x39\x0c\xa4\x74\xbf\x8e\x2f\x92\xd3\x14\x57\x98\xaf\x98\xc8\xa9\xfe\xf4\x0a\x5a\x65\x11\xc1\x9f\xe8\x6e\xf8\xea\xaa\x9e\xf8\xea\x76\x4d\x4f\x4c\xf5\x76\xaa\x07\x92\x3a\x7b\x5c\xd0\x7e\x4b\xa2\x86\xdf\x10\x89\x1f\xe4\x6e\xc4\xec\x94\xf3\xa9\x6a\x6a\x10\x15\x01\x22\xa0\x05\x29\xc0\x89\xe8\x7c\x6f\xd0\x1f\x0c\x05\x13\xc0\x1c\xb0\x0c\xfc\x17\x78\x1d\x5c\x06\x57\x01\xa4\x15\xe8\xf3\x61\xa4\x34\x17\xc1\x49\x33\x72\x58\xda\x8d\x3d\x31\xbb\x5d\xa2\x00\x09\x13\xa7\x66\x22\x21\x0d\x56\x40\xf0\x1b\x81\x37\x9d\x8f\x81\xeb\xb8\x63\xdb\x99\xc5\x2e\xb4\xd4\xe2\x83\xb4\x15\x00\x23\xe2\x9d\x8d\x42\x8e\xac\x93\x38\xa9\xc6\xd8\xed\x78\x71\x11\x3b\x16\x0b\xeb\x5b\x93\x2f\x36\xed\xe1\xbd\x50\xc4\xc6\xe1\xa9\x2e\x08\xb0\xf8\xc7\x5d\x1c\xf0\xc4\x9e\x43\xab\x3e\xbd\x95\x31\x61\x80\x25\x17\x4f\x30\x96\x3c\xac\x3b\x03\xc3\x2c\x05\xbc\x41\x06\x5b\x77\x99\x04\x91\x2a\xe0\x0d\x58\x0b\x15\x95\x18\x27\xf2\x06\x81\x95\xdc\x21\x28\xa8\x0e\x3d\xef\x17\xde\x69\xc0\xa8\x7d\xa8\x80\x26\x3f\xd0\xe3\x23\xae\x19\x5e\x24\x09\x5e\x14\xd1\x32\x29\xdd\x6d\x34\x15\xa1\xda\x73\x44\xd1\xc2\x45\x7c\x67\x99\x50\xc3\x14\x62\xbb\x32\x00\x03\x40\xfc\xbf\xfc\x44\x00\x71\x1e\x3e\x91\x89\xb4\x93\x15\xcb\x6e\x03\x2e\x2a\xe6\x3f\xc1\x57\xcc\xb8\x78\x9f\xc8\x28\xc4\xbb\x38\xf4\x73\xfb\x44\x0e\xc1\x8d\x89\x53\x44\x3c\x5c\xa3\xf4\x22\x1e\x15\x80\x35\xf9\x33\x50\x73\x14\x07\x41\x39\x30\x90\x37\x13\xcc\x40\xb7\x52\xec\x10\xb9\x95\x0c\x46\xc3\x71\x0b\x31\x78\xc1\x6f\x64\xfc\x18\x59\xd0\xa5\x04\x26\xe1\xf3\x10\x85\x5d\xfc\x14\x62\x12\x8c\x04\x6e\xca\x81\xca\x64\x62\x89\x8b\x7a\x11\x79\xc6\x61\x28\x72\xe2\x6a\xf1\x7e\x9f\x00\x97\x87\x7d\x40\xa2\xac\x38\xbf\x80\x0d\xab\x17\x8a\x09\x3e\x15\xbb\xb4\xc9\x3e\x1a\x34\xa4\xa0\x4a\x15\xf3\x2e\x5d\xb2\x0f\xd0\xc3\x52\x8c\xc6\x52\xc5\xa8\xf4\xbc\x81\x9b\x0b\x32\xf3\xdb\x17\x2a\x46\x0a\x41\x0f\xfd\x36\xc8\x72\xa4\xa4\xfb\x5d\xc5\x16\xae\x65\x48\x7d\x4b\x4b\xdb\x94\xbf\xad\x4a\x99\x7f\xfb\xd2\xa1\xf4\x4f\x62\x1d\x0f\xc6\x86\xfd\x05\x8d\xc6\xe8\xd0\xe8\xef\x4c\xa3\x0a\x47\xbe\x0c\x68\x4e\x27\x16\x25\x2b\x53\x78\x89\xcc\x92\x6a\x55\x98\x2c\x0e\xb3\x56\x2f\xe3\x7d\x8d\x32\x89\x44\x35\x98\x4e\x77\x59\x38\x85\x47\xc9\xd0\xd2\x2c\xa9\x4a\x65\xaa\x06\xc1\x05\x16\x9b\x41\xac\x1e\x68\x2a\x63\x18\x9a\xe5\xb9\x94\xc2\x82\xa2\xcc\x15\xf9\xe5\xd3\x77\xde\xa1\xcf\x2e\xb6\x07\xe5\xf4\x30\xe0\x9b\xdc\x7b\x44\x06\xe0\x78\x96\xa6\x01\x53\x66\xaa\xd1\xa2\x89\xc3\x32\xbf\x77\xff\x24\xa5\x46\x96\x2d\x01\xac\x3a\x57\xc1\x59\x5c\xe9\xf4\x10\xa5\x44\x2c\x6f\xf4\x49\x79\xa0\xd7\x9a\x1d\x16\x93\xd2\x6e\x4e\x91\x49\xc5\x16\x85\x09\xfe\x2c\x69\xb0\xb2\x29\x16\xbd\x6d\xb0\x23\x59\xd1\xc7\xaa\xe0\x98\x12\xaf\x6a\xa0\x55\x99\x2d\x33\x18\xd5\xd6\xeb\xaf\x59\x1b\x24\x76\x9d\x25\x25\x33\xb5\x5a\x91\xec\x70\xaa\xbc\x01\x56\xf2\x92\xb2\x97\x2e\x23\xcf\x63\x4e\x66\x2e\x8b\x35\x0c\xa3\xd0\x64\xe6\x82\x24\xd8\xf6\xed\x43\x0f\x7d\xfb\x90\x7f\xe6\x2c\xc0\x4b\x53\xd7\xa6\x49\x58\x0e\xfe\x24\x66\x58\xfa\x02\xcd\x8a\x44\xb2\xf4\x4d\xf0\x5e\x75\x56\xa9\x4a\xcb\x30\x52\xae\xef\xeb\x8c\x73\x03\x30\x3d\x74\x02\x18\x0e\xda\x19\x40\x6b\xaa\x54\xe6\x12\x6f\x1a\xc7\xf2\x52\x5a\x24\xe1\xe5\x62\xb5\x58\xc7\xce\x2a\x65\xe5\x56\xb5\x45\xc4\xfc\x57\x12\xed\xcf\xcf\x95\x8b\x35\x92\xb2\x54\x30\x94\xd1\x54\xbb\xb3\x6e\x6b\xe4\x1c\xeb\xfc\xde\x91\x0a\x13\xfb\xdb\x37\x26\x1f\x9b\x24\x32\xd1\x69\x12\x79\xae\x54\x07\x68\x46\x37\x82\xd6\xd3\xd3\xe0\x13\x75\xf5\x62\x71\x65\xe8\xfc\x79\x00\xd8\x23\x6c\x92\x52\x07\x18\x95\x2a\x5b\x29\x49\xa3\xd5\xf2\xf7\xfe\xeb\x4d\xba\x89\x6b\x5c\x9e\xed\xea\xab\x61\xa4\x23\xbd\xfe\x75\x5b\xd5\x4e\x5e\x92\xac\x33\x56\x71\xac\xd7\x90\x10\x6e\x4c\xa9\x94\x28\x1c\x76\xcf\x5c\x8e\x1b\x91\x9e\x10\x66\xab\x54\xe2\xbc\x14\x47\x51\x8e\x49\x37\x70\xe6\xcc\x3d\x33\x3f\x9a\x9b\xd7\xa7\x77\x8d\x28\x73\x6e\xfb\x15\x59\x9a\x49\x53\xb2\xa0\x1f\x4d\xe7\x67\x27\x27\x67\x15\xd0\xcc\xc1\x61\x46\x6d\x9a\x4c\x2a\x31\xa6\xa6\x4a\xa4\x4a\xbd\x32\x55\x2c\xb7\xa0\x4f\xa6\xaa\xa1\xa5\x7d\x7d\xae\x9c\xa0\x5d\xe3\x94\x26\x6b\x39\x2d\xc3\x02\x0e\xc8\x44\x99\x8c\x88\xa5\xed\x69\x19\x2d\x25\xab\x7d\x6a\x53\x2a\x30\xab\x93\x94\x8c\x92\xf6\x58\x58\xad\xa7\xcc\x57\xa3\x10\xab\x14\x62\x25\xb3\x1a\xfe\x63\xf8\x9d\x52\x1d\xa3\x4c\x52\x29\x95\x96\x24\x4d\xf1\xea\xd2\x16\x87\xcd\x4e\x4b\xe9\x2c\x4e\x8e\xf2\xe1\x18\x94\x63\x92\xd8\xa5\xb1\x55\x64\x66\xf9\xfa\x49\xe8\xc2\x24\x15\xea\x44\x16\xb9\xc4\xa2\xd6\x2a\x24\x52\x8b\xd5\x20\x66\x9e\x4c\x4d\xb6\x4d\x75\xae\x4c\xd5\xb1\x4b\xb3\x37\x96\x29\x6c\x4a\x65\x68\x9a\x5a\x25\x05\x8b\x56\x31\xd5\x9b\x0a\xa7\xda\x92\x53\xb5\xac\x2e\x75\xe5\xd6\x34\x65\xd9\xc6\x6c\x91\x4a\x3d\xb5\x52\x53\xb9\x6a\x3e\x8b\xda\x72\xf4\x6c\xc6\xed\xda\xae\xd3\xf2\x62\xfd\xfa\xde\x34\xbd\xfe\xd8\xe2\x25\xc7\x8e\x2d\x59\x0c\x5d\xa8\x23\xa6\x2c\x45\x83\x4a\xc6\x0c\xe8\xf3\x12\xdb\xd8\x88\x9a\x5d\x3f\xbc\x81\x53\xd1\x67\x7a\x2d\x4b\x16\x8b\xb4\xea\x3d\xa9\xf4\x3a\x93\x62\xfb\x9b\x81\xc2\xd7\xf7\x2b\x0c\x34\x83\x41\x7c\x68\x1e\x8c\xc9\x46\x43\x52\xac\x28\xe4\xc4\x22\x0e\xbb\xb6\x04\x12\xbd\x46\x27\x63\x68\xa0\x29\xad\x90\x88\x3d\x0a\x45\x6a\x06\x6a\x96\xe8\x06\xa5\xba\xff\x52\x99\xdc\x37\xdb\xef\xab\xa7\xe9\xde\x57\x2a\x4a\x16\x94\x17\x6f\x99\xc4\x4a\x80\x88\xd6\xea\x4c\x32\x85\x6c\x58\x9f\xf4\xb3\x06\xc3\xee\x42\x87\x91\x61\x0c\x96\xde\x61\x90\xef\xaf\x72\xd9\xc1\xa0\x3a\xd4\x7f\x92\xf4\x5a\x96\x63\xc5\xaf\x4d\xe8\xb5\xcd\x3f\xdb\x27\x97\x2d\xeb\xa7\x56\x16\xa2\xe2\xd7\x0b\x3c\x43\x1f\x09\xe0\x5e\x25\x9c\x79\x2f\xe2\xcf\xbb\x9b\x96\x02\xb0\xa2\x76\xf5\x16\x59\x59\x4c\x92\xf8\x20\xe7\x41\xa7\x0c\x0f\xcf\xfd\xbd\x69\xcb\xa4\x49\x5b\xa2\x8b\x26\x6d\x69\x6a\xda\x12\x1d\x53\x3a\x7b\xf3\x1d\xbf\x3d\x0b\xdc\xa0\xf4\xd2\xd6\x3f\xdc\x33\x29\x8f\xc9\xee\x3f\x67\xd5\xa0\x17\xa7\xa5\x4e\x1c\xdf\xd4\xcf\x25\x1f\x72\x00\x9e\x7c\x04\x5e\xb9\xf2\xea\xba\x45\xd5\xd5\xf6\xfc\x1c\xfc\xd0\x24\xf2\xe8\x24\xae\xb0\xf7\xe8\x5a\x6f\xa6\x49\xc9\x49\x4d\xb6\xfc\x92\x01\x43\xa7\xcd\xa9\x3c\x34\xc6\xbb\x78\xe2\xf4\xa1\xf5\xbd\xbd\x69\x6a\x86\x56\x5b\x8b\xbd\x03\x7b\x0d\x0f\x0c\x8d\xeb\x1c\xc4\xfc\x72\xa5\x11\x54\xd0\x5a\x6a\x06\xf6\xe6\x42\x75\xf7\x54\x84\x11\x1d\xbb\xc1\x34\xeb\x8a\x10\x2b\x82\xf8\x76\x34\xcf\x7b\x59\xb2\x58\xe4\x3b\xc5\x09\x58\xf9\x86\xb6\xb1\xda\xb8\xcd\xb3\xce\x20\xe8\xdc\x09\x20\xd7\x88\xeb\x8f\x5f\xb9\x6c\xa2\x9e\x58\x88\x6c\x16\x7c\x02\xbe\xf7\xd9\x86\x0d\x9f\x81\x62\xd0\x00\x8a\x71\x28\x3a\xf7\x66\xa4\xe7\x85\x6a\xb5\x4d\xad\x06\x2b\x67\xd5\x3a\x52\xc9\x12\x3f\xd5\x31\x54\xb0\x6c\x8e\x9b\x4a\x7f\x40\xa2\xd7\xbf\xb4\x9e\x9c\xcf\xc1\x2b\xe7\x98\x26\x97\x39\x12\x8e\x03\xaa\x73\xad\x1b\x3e\x83\xef\xf5\x78\xdb\xef\x6e\x81\x0b\x1d\x1d\xac\x86\xf8\x5d\x6d\xea\x50\xad\xcf\x51\xa6\x59\x88\xe5\x05\x0b\x35\x65\x0e\x1f\x53\xdb\xc3\x30\x1b\xfe\x20\x88\xd3\xc6\xaf\x5f\x3f\x5e\x08\xed\x3a\x77\x2e\x72\x17\x4d\x50\x11\x09\x54\x6f\xdc\x9e\x4c\x22\xe0\xca\x9b\x08\x5f\x87\xd7\x62\x5e\x8d\xa3\x47\x53\xf8\x08\x37\x65\xe8\xa9\x5a\x55\x64\xe4\xc3\xd7\xc3\x3c\x5a\x8b\x69\x95\xd7\x88\x12\x3c\x4f\x6c\xe4\x6b\x7d\x13\xaa\xae\xb5\x56\x4d\x98\x50\xc5\x87\xaa\x26\xf8\x6a\x59\x0a\xf3\xb2\xd1\x56\x10\x16\x04\xfa\x11\xc1\xf6\xfd\x08\x0c\xfb\x6a\x8f\xe0\x64\x0c\x49\x7c\xa4\x96\xea\x51\xa6\x94\xce\x32\xc5\xe4\x11\x3d\x8a\x60\x48\x06\x37\x15\x15\xb1\xf5\x1c\x45\x13\xfb\xa0\xc4\x52\xf4\x28\x22\x2a\x0e\x45\xb7\xd6\xfa\x7a\x14\x21\xda\xd4\xbd\x8c\xc0\xf6\x7f\x51\x1e\x06\x2d\x6d\xff\x7f\x2a\x0f\x8d\x38\xd2\xff\xb3\xf2\xd0\x9d\xe5\x31\xa1\x51\x4b\xfd\x4f\x4a\x22\xfe\xf5\x52\x30\xff\xd6\xfb\xb1\x2c\x89\x63\x57\x22\xba\x61\x21\x28\x9e\xe8\xb5\xba\xb8\xab\x4c\xe2\xd1\xc4\x15\xf3\xfc\x6e\x62\xe7\x12\xf7\x1f\xeb\xde\x96\xea\x93\x4e\x26\x17\xc8\x4e\xc1\x33\x3a\xb3\x5c\x9e\x99\x29\x97\xa7\x68\xc1\xf7\x56\x77\x26\xcc\x40\xd1\xb5\xe8\x36\xf8\x1d\xba\xc7\x69\xb2\xb9\xb6\x6c\x0d\xa7\x13\xf0\xab\x19\x2c\xeb\xc3\x3e\x0a\x6c\x06\x8c\x58\xa5\xd1\xdb\xd1\xd1\xe6\x16\xd9\x1d\x3e\xaf\xcd\xa7\x41\x47\x4d\x31\x09\x9b\xfc\xe8\x0e\x13\x82\xad\xe1\x30\x08\x85\x42\xf0\xc7\x96\x16\xf8\x63\x28\x04\x42\xe1\x30\x6c\x45\x67\x75\x4b\x0b\x50\x87\xb8\x70\x1b\x6c\x0a\x47\xdb\xda\xc2\xbb\x76\x85\xdb\x68\x5b\x18\x1c\x21\x41\xa1\x39\xe3\x76\x0d\x71\x6f\x0f\x39\x04\xf5\xa2\x17\x91\x9c\x62\x5c\x18\xa2\x88\xa4\xc1\x23\x15\x9d\x7d\x76\xce\x40\x9c\x30\xfb\x34\x3e\x87\xc1\x89\x0a\x42\x34\x5a\x51\x29\x89\x3f\xdd\x98\xc1\x3a\x3e\x13\xfb\x75\x83\x18\x8d\x58\x18\xee\xa0\x20\x76\x6e\x1b\xe6\x28\x80\xb1\x7a\xb1\x48\x45\x84\x7e\x1d\xc2\x19\xa2\xd8\x08\x4a\xc5\x84\xb1\x73\xd4\x28\xea\xc1\x37\x50\x7a\xec\x0b\x58\x78\x8a\xa5\x40\xdc\x3f\x6e\x3b\x16\xfa\xa3\x08\xc1\xe7\x03\x0e\x45\x29\xd2\x83\xc2\x34\xee\x45\xf8\x01\x4a\xc0\xce\x41\x15\x43\x75\x4a\xeb\x94\x11\x79\x63\x3e\x2c\x46\x75\xaf\x55\xf7\xba\x69\x1c\xf1\x1a\x82\xc4\x5a\x3a\x0c\x5e\xa7\xbd\xab\xaa\xd8\x7b\xb0\x1d\xfd\x50\x3f\xf3\xd9\x63\x59\xa1\xd5\xb8\x4f\x42\xea\x8a\x6b\x82\xfe\x84\xa2\x33\x58\x74\x84\x35\x9e\x50\xad\xa3\x54\xb8\x1d\x45\x72\xe8\xd7\x81\x6e\xa0\x2a\x08\x7e\x29\x70\x44\xfc\x11\x86\xc0\x18\x0b\xcf\xe2\x1f\x4d\xce\x30\xe6\x1c\x98\x1c\x3b\x62\x4d\x41\x93\xed\x8f\xa8\x70\x07\xb5\x5b\xec\x9d\xb8\x01\xba\xd6\x82\x1a\x8c\xef\x09\x34\x89\xa3\x03\x5d\x88\x4c\x76\xdc\x6b\x79\x96\x8a\x34\x61\x00\x14\x2e\x94\x59\x42\x5c\x14\x83\xdb\x55\x45\x2f\x14\x35\x00\x1b\x6c\x12\x62\x4b\x32\x23\x4d\x25\x03\x1a\x50\xa4\x8a\x4a\xb4\xb5\x11\x11\xbf\xca\x14\x76\x02\x57\x01\xfc\xce\xb8\xf4\x03\xd3\x6e\xec\x70\xb1\x9b\xa5\xd0\xf2\x6b\xa9\xf2\x17\xe5\xf0\x27\x60\xeb\x40\x1d\xbb\x04\x9c\xc9\xb4\xbc\x60\x69\xca\x8c\x50\xf1\x57\x03\xea\x9a\x14\xa5\x38\xc4\xa0\x0e\x01\x6c\x99\x25\xcc\x11\x74\xaf\x09\x25\xca\x8c\x15\x02\xf7\x53\x51\x02\x7e\x56\x12\xfa\xa6\x95\xd4\x70\x6a\x2a\xb1\xba\xec\x04\x24\xf4\x77\x86\x8d\x5e\x23\x47\x9c\xa5\xa0\x31\x69\xc0\xe0\x10\x36\xa7\x0f\xe3\x7d\x17\x93\xf5\x22\x76\x77\xe5\x22\x96\xcc\x01\x62\xba\xe6\x13\x3c\x6e\x63\x3f\xa4\x1a\xfb\xcd\xa6\x4e\xfc\xfd\x69\x26\xb1\x74\xff\x7e\xa9\xd8\xa4\xb0\x9a\x18\xf9\xd6\xad\x8c\x0c\x98\x3a\x66\x7e\x59\xd7\x67\xce\x6d\xbe\x2d\x59\xd9\x60\x00\xfd\xce\x94\x69\x73\x56\xac\x98\x33\x6d\x4a\x41\xb3\xc5\xb2\xe6\xf9\xc9\xb9\xb9\x93\x9f\x5f\x33\x8d\xa9\x19\x59\x55\x1a\x6a\xa8\x42\xec\x24\x2c\x05\x7f\x19\x38\xb1\x3b\x44\x51\x71\xb1\x93\xa3\xb7\xd1\xdc\x93\x45\xe9\x2c\x58\x0b\xd8\x36\x50\x0c\xdf\x2b\xab\xe9\xd5\xa2\x52\x03\x60\x5f\x50\xcc\x8b\x27\xbf\x34\x59\xcc\x7b\x5b\xe4\x2a\x9a\x16\x65\xd6\x37\x2d\x6e\xaa\xcf\x14\xb1\x77\xf9\xfb\x72\x8c\xb8\x8f\x27\x50\xc5\xa0\x75\x77\x0d\xe3\xef\x86\x3f\xc4\x75\xb6\x13\xc6\x3a\x30\x53\x1e\x2a\x88\x7b\x80\x12\xf1\x1f\x19\xa8\x92\x1a\x3f\x45\x3c\x9f\x79\x88\xeb\x4e\x1b\x0b\x88\x21\x37\xb1\x50\xd5\xb2\xa8\xb6\x41\xfa\x26\xab\xa9\x31\xb3\x36\x6c\xa0\x27\x6f\x98\x35\x0b\x8c\x3d\x04\x7f\xba\x7f\xd9\xe5\x43\xe3\x0f\xa1\x6f\x1c\x04\x4a\xda\x32\xff\x85\xbf\xad\x87\x7f\x78\x0a\x5e\x7e\xf2\x09\x90\xfd\x04\xc8\x5b\xfb\xf3\x0b\xf3\x41\x63\x62\x2d\x81\x9b\x7e\x36\xeb\xd5\x3f\xbf\x8a\xfe\xb2\xa2\x03\xb3\xc0\xfb\xf0\x75\xf8\x13\xca\xe1\xf2\xb2\xfb\x81\xf2\xd0\x21\x58\xb7\xf5\xe7\x87\x9a\x1e\x80\x1f\xbe\xf4\x18\xfc\xf8\xf8\xb4\x47\xbf\x63\x44\xdd\x71\xb0\x98\x6e\xbc\x1a\xe2\x2d\xb9\x1e\xb4\xfd\x26\xfc\x68\x83\xa3\xcb\x80\xcd\x48\x70\xfb\xba\xb0\xa9\xc2\x3a\x45\x47\x2b\x96\x6e\xb2\x21\x85\x2e\x3c\xa1\xaa\x83\x90\x7a\x16\x4d\x07\x68\xec\xc4\xef\x1d\x39\x12\x8f\x6c\xc2\xc9\x62\xd1\xec\xa0\xae\xc4\x13\x40\xf0\xc8\x91\xf8\x9d\x70\x2c\x2e\xe6\xef\x55\x8c\x69\x37\xd6\x65\xf5\x51\xe5\xd4\x08\x6a\x2e\x96\xc5\x60\x29\x1d\xc6\x91\xd7\x74\xca\x7f\x3b\xa5\xbe\x68\xf9\xdd\x79\x41\x50\xc6\xe3\x49\xd8\xb8\x4c\x4b\xd8\x71\x21\x8a\x85\xfe\x22\x93\x95\xe5\x7a\x46\x88\x5a\x11\xed\xa4\xae\x63\x0a\x4a\x81\x67\x95\x15\x99\x34\xe1\xc2\xda\xc9\xec\x46\x37\x65\x56\x28\xa1\x81\xcc\x60\x7f\x31\x4c\x5e\x35\xd9\x00\xfe\x42\xb6\x0f\x2b\xaa\xf2\xf3\xab\xf2\xd9\x1d\xe3\xef\xda\xbd\x61\xf7\x5d\xe3\xfb\x2d\x9c\xda\xcc\x6a\xeb\xb4\x6c\xf3\xd4\x85\xfd\x3a\xa8\x5b\xc5\xb2\x21\xec\x7d\x21\x1a\x62\xc2\x28\xcb\xf6\x9f\xbb\xe0\x89\x38\x19\x7a\x29\x09\x95\xf6\xef\x5f\x4a\x02\xea\x7c\x9c\x7d\x64\x52\xcd\xe2\x2a\xbb\xbd\x6a\x71\x8d\x6c\xdb\xfb\xcf\xbd\xc4\xdb\xed\xfc\x4b\xcf\xbd\xbf\x4d\x76\xcb\xd8\x44\x19\x67\x1e\x35\x08\xf5\x5a\x35\xcd\x1b\xb5\x71\x95\x87\x2e\x17\x5c\x6a\x6d\xc0\x45\x6b\x12\x36\xf1\xc9\x6d\x10\x64\x7c\x76\x34\xa6\x4d\x56\x6c\x71\xa7\x64\x0c\x76\xd4\xb5\xdd\x1e\x94\x84\x0b\x5f\x3c\x72\xe4\xa2\xd0\x26\xa4\xc8\x4d\x9d\xd7\x9c\x60\x4f\x79\xe7\xa0\x1d\x8b\xfa\x45\xa8\x7e\x8b\x76\x0c\xd2\x99\x4c\x3a\x7c\xc5\xc6\xaf\xb8\x30\xec\x80\xf3\x67\xcd\x82\xf3\x61\x47\x02\x3a\x13\x07\x76\xa2\x11\xb1\x13\x70\x09\x28\x4d\xbd\x53\xd7\x3c\xfd\xd3\x86\x0d\x3f\x3d\xbd\x26\x95\xb7\x67\xda\xf9\xee\x97\x89\xb2\xd5\x3c\x32\x1f\xfd\xcf\x6a\x98\x03\xec\x7a\x93\x1d\x9b\x4e\xd3\x6e\x07\xaa\xdf\xbf\xac\x56\x5b\x84\x92\x30\x3f\x48\xaa\x17\x6c\xab\xfb\xba\x6e\xdb\x82\xea\x7f\xbf\x26\x55\xc1\xf2\xf6\x3e\xeb\xfe\x7a\x72\x4d\x5a\xda\x9a\x93\x7f\x5d\xd7\x5d\x2e\x8c\xcb\xde\xeb\x3f\x2b\x3b\x83\x7a\xbb\x03\x8d\x83\x7f\xa7\xe8\x23\x98\x91\x23\x4a\xfd\xcf\xcf\xf8\x7a\xc6\xf3\xfe\x7f\xbf\xe4\xe7\x9e\x7e\x3a\xa2\xdc\xfe\x76\x76\xf6\xdb\xdb\xbb\xf7\xa7\xfe\xff\xbb\xfe\x24\xe2\xed\xae\xff\xac\x33\xdd\x31\x9b\x7e\x65\xf6\x1d\xff\xbb\x8e\xe4\xdd\xb9\xd3\x2b\x74\xa1\x84\xef\xa0\xa2\x4a\xb1\x47\x3b\xae\x07\x49\x09\x04\xc5\x01\x8f\xd8\x6d\x57\x8a\x79\xab\xd8\xa4\xeb\x71\x97\x6b\xeb\x2a\xf9\x64\xc6\x9c\x5e\x56\x58\x5f\x3c\x3a\x37\x27\x27\x77\x74\x71\x7d\x61\x59\xba\x99\x61\x23\xb7\x8a\x9d\xdc\xf5\x54\x48\xab\x0c\xe3\x33\x3a\x84\x02\xcd\x23\x1b\x43\xb5\x79\x95\x56\x8b\xc5\x5a\x99\x57\x1b\x6a\x1c\xd9\x1c\xb8\x55\x1c\xd6\x95\x89\x3f\x94\xa0\x3b\x41\xa1\x59\x7c\x16\xfa\x2e\x64\xb7\x37\xe6\x52\x5d\xe3\x16\x02\xa8\xd4\x26\xbc\x4f\x44\x68\x3c\x2a\x7a\x40\xe7\x8f\x01\x8e\x09\x69\xdd\x89\x41\x77\x11\xf1\x05\x4e\x0e\xe8\x41\x02\xd2\x25\x4c\x0a\x40\xa8\x76\x91\x49\x30\xe3\x63\xd0\xe2\xc8\x16\x2a\xf0\x54\x91\x83\x03\xf8\xdd\x2e\x33\x8d\x96\xc5\xd2\x39\x52\x12\x5b\xe4\x56\x4a\xd0\xa9\xb2\x88\x13\x0f\xaf\x2c\xad\xea\xd5\x9c\x9e\x62\x9b\xba\x4d\x31\x57\xd4\x52\x1f\x0d\x0f\x9f\x03\xdf\xab\xdb\x3e\x45\xc6\x89\xb6\x4e\x2c\xf6\x0c\x60\xc3\xb5\xbe\xf0\xf8\x82\x3e\x55\x1e\x38\xcc\x7a\x02\x9f\xdb\xf2\x1d\xf0\x92\xbb\x02\x2f\x7b\x93\xb3\x32\xc0\x33\x19\x59\xbf\xe0\x68\xdb\xed\x99\x95\x62\xba\xca\x13\x5e\xe1\x1d\xc4\x81\x70\x51\xba\xbf\x90\xbf\x7b\xea\x2f\xde\x52\x58\x97\x94\x5f\xdf\xb2\x64\x38\xc8\xac\x99\xde\x36\x65\x3b\x98\xb8\xce\xd0\xb7\x6b\xaf\xa7\x09\x7d\xe3\x42\x0a\x03\x72\xe1\x66\x71\x08\xb6\x20\xc9\x20\x0e\xc2\x08\x48\xcb\xa0\x66\xf1\xc5\xac\x44\x1c\x09\xe7\xce\xb6\xf0\xe3\x25\x12\xcf\x08\x2c\x99\x1b\xc4\xac\xfe\x84\x6d\x0a\x3f\x73\x78\x5c\x95\xad\x6a\x5c\xd5\x01\x57\xc8\x57\x8b\x55\x71\x43\xf4\x53\xe9\x7e\xbe\x8e\xab\x12\xe2\x6d\xcf\x6c\x59\x94\xa6\x33\x4d\xd9\x3e\xf3\x1e\x71\x9d\xf2\xf6\xa1\xd1\xfa\xde\x73\x33\x60\xd8\xbb\x6f\xd6\xe0\xa2\xed\x53\x4c\xba\x34\x2e\x5c\xe5\x89\xb6\xd0\x6a\x6c\x1e\x1a\xfd\xf1\x06\x75\xd6\x5b\xeb\xcb\x49\x87\x94\x37\x37\x1d\xec\xb5\xa5\x80\x9f\x88\xdd\xe8\x8f\xf1\x04\xf4\x0e\xcf\xeb\xfd\xcb\xd9\xed\x53\x34\xa2\x6d\x33\xa1\x32\x33\x07\xce\x19\xd2\x1c\xc8\xa7\xa9\xea\x91\xb3\xf6\xa5\x83\xa7\xa7\x6c\x67\xcb\xe3\xfb\x40\x82\x0e\xb0\x0b\xcd\xa2\x03\xa9\xc9\xd8\x8f\x31\x87\xd7\x57\x82\x98\x25\x60\x17\x54\xc6\x3b\x91\xa6\xb9\x98\xba\x12\xcf\x89\x18\xcc\x7f\x0a\xf0\x45\x78\x43\x86\x74\x19\x9e\x23\x18\xbd\x38\x2a\x08\x18\x67\x1c\x96\x9a\x33\xc4\x30\x47\x02\x78\x7b\x92\x21\x77\x05\x1b\x7f\x3e\xe6\xbb\xa2\x1c\x78\x89\x69\x24\x16\xf4\x70\x6c\xe1\xc9\xa3\x15\xa6\x60\x0d\x07\x3b\x66\xed\xdb\x37\x6b\x41\xee\xc0\xb1\xfb\x66\x79\xf2\xe8\xc5\x68\x00\xef\x9b\x33\x12\x3e\x3e\xee\xee\x83\x47\xad\x19\x55\x1e\xb3\x1e\x34\x14\x56\x80\x10\x0e\xc1\x4f\x2d\xda\x1c\xb5\xba\xa2\x48\xaf\x05\x4d\xd6\x8c\x6f\xa3\x4b\x93\x8c\xbe\xda\x3c\x27\xad\x8c\x92\x15\x29\x6d\xba\xea\x99\x3f\xa7\xa1\x06\x0c\xcb\xf1\xa3\x25\xe8\x7b\x5b\x32\x70\xbb\x97\x16\xf7\xf5\xb8\xe0\x3b\xe1\xed\x85\x3e\xce\xba\xa4\xaf\x4b\xba\xef\xc2\x3e\x8d\x65\x7d\xfd\xac\x7d\x9a\xbf\xee\x9b\x15\x9d\xda\xb8\xd5\x30\xc2\x44\xbf\xd5\x7f\xa0\x32\x60\xf7\x54\x49\x0f\x48\xeb\x8b\x6e\x50\x28\xb0\x41\x21\x36\x1b\x9c\xc6\xa2\x90\xe4\x88\x32\xc0\x68\xae\x89\x6b\x7d\x99\x55\xca\x33\xa1\xda\x59\xb5\xb3\xde\xac\xc8\x99\x1e\xa1\x74\x23\x64\x7d\x73\xe9\xfb\x7c\xb5\xab\xed\x85\xf0\x92\x27\xd8\xcf\x73\xfe\x7c\xbf\x5c\xf1\x50\x5f\xf6\x00\xcd\xf6\xce\xbe\x47\xd6\x83\x19\x04\x1f\x0f\xf5\x24\xd0\xe9\xc4\xaf\x1c\x38\x3b\x99\x15\xfc\x11\xdc\x42\x18\x68\x8a\x51\xd7\x22\x2c\x17\xc6\x98\xc5\xe0\x86\x06\x7b\x0c\x35\xc9\x6b\x27\x5a\x15\xb1\x55\x01\x1e\xd6\xb8\xdf\x9a\x38\x8c\xce\x1c\x13\x7e\xad\x29\x9f\x97\x41\xf7\x5e\xda\x52\x0f\xc3\xf5\x2d\xf0\x8b\xe8\xa7\xf5\x2d\x8f\x2e\x03\x0f\x66\x47\x1b\xa6\xee\x16\x57\xb6\xd4\x8b\x5a\xc7\x47\x7f\xeb\x0e\x45\x2a\xcd\x2e\x46\xad\x91\x7a\xd3\x98\x50\xa4\x15\x85\xc5\x03\xf2\xe8\xf0\xd8\xcc\x12\x2e\x24\x2d\x4a\x83\x7d\xab\x26\xa0\xb1\x5c\xa8\x56\x80\xf2\xa4\x54\xac\x54\x6e\x76\x89\xa8\x92\xc2\xc8\xdf\xee\x3f\x03\x0f\x61\x8f\x2f\x27\xef\x6e\xa9\xb7\x2d\x7b\x34\xbc\x79\xca\x90\x19\xb6\xfa\x96\xeb\xad\x60\xca\xa1\x35\x8c\xa2\xd8\x65\xb6\x39\x3c\xfa\x34\x97\xcd\x65\xce\x55\xe6\x96\x95\x64\xaa\x54\xad\xa9\xce\x09\x55\x36\xb3\x8b\x3f\xac\xf0\xa4\xbc\x41\x04\x58\x02\x26\x1e\xe6\xed\x8a\xa8\xc5\x98\x66\xa1\x35\x3f\x1a\x4d\xe4\xe0\x8f\x41\xbc\xa5\x80\x18\xd4\x1b\x36\xa8\x65\x62\x90\x24\xd8\x64\xc9\xc1\x60\xed\x74\x07\x13\x07\x93\xd2\x25\x04\x51\x83\xe9\x70\x33\x15\x05\x80\x60\xa8\xc7\x73\xbe\x62\x33\x08\xc4\xc1\x4e\x18\x87\x0e\x07\xc1\xbb\x83\x6e\xd3\x4d\x53\x70\x8b\xf9\x55\xe3\x35\xeb\x47\x0d\x5b\xa7\x1f\x36\x43\xbf\x6e\xd8\xe8\x8d\xca\x71\xcb\xf9\x95\xd2\x80\xb1\x20\xbd\x30\x79\xe6\xbe\xd2\x22\xc8\x55\x8f\x28\x74\x95\x4b\x1e\x5c\xb3\x53\x52\xee\x2a\x08\x31\x1b\xcc\x53\x24\x41\x57\x7e\x15\xb3\x98\x67\xc5\x53\xc5\xc5\x76\xfa\xb9\xec\x74\xd0\x51\x52\x5b\x8c\x86\xea\xd9\xd0\x00\x86\x0d\xe5\xbb\xcb\x25\x8b\xcd\xfb\x98\x8a\x1b\xd4\xc4\x5a\xb0\xb3\xd4\x9b\x67\x04\x9f\xa4\x58\xc7\x6f\x91\x8e\x98\x33\x63\x28\x7c\x10\x9c\x18\x3a\x63\xd1\x28\xe9\x9d\xe3\x93\x1c\x90\xe2\x73\xd4\x56\x99\x6c\xcf\xcc\x60\x8b\x0b\x6e\xf0\x8a\xc2\x05\xae\xe8\x48\x7a\x8c\xab\xa0\x2a\x5f\xa5\x88\x7e\x02\xee\x75\x7a\xab\x3c\x4a\x39\x4c\xb7\x2c\xb6\xc2\xf9\xb6\x2c\x33\x58\x99\xd3\xa7\xb8\xc6\xfc\xf5\x9f\x58\x20\x07\x99\x0a\xad\x2c\xbf\xba\xc0\x05\xad\x74\x8b\x52\x59\x50\x1d\xdb\xf3\xc5\xed\xea\x25\x08\x24\x53\x08\x12\xd7\xad\x29\x5d\xb9\xe0\x64\xdc\xe1\x4b\x98\x07\x84\x00\x1a\xb5\x6e\x42\xee\xbc\x64\x26\xe8\x9a\x08\x6e\x26\x7c\xba\x98\x97\x29\xfc\xc3\xb2\xbb\x7b\xb2\xaa\x8a\x07\x0a\xc4\xef\x9c\xd1\xc1\x8d\x4b\x2a\xa9\x2f\x11\xa6\x88\x81\x7e\x34\x59\x0c\xf4\xcf\xde\x6b\x94\x4e\x19\x98\x5f\xbc\xa0\x7f\x4a\xea\x84\x75\x96\x71\xea\xe6\xaa\x68\x91\x40\x08\xf7\xce\xec\xdf\x6b\xdf\x9f\x6d\xc0\x86\xff\x38\x34\x1f\x40\x0a\x86\xdf\xf1\xd7\x15\x13\x22\x98\x62\x00\x2d\x4d\x93\x2f\x67\xf5\x2e\xc9\x2c\xc7\xf3\x40\x68\x4c\x60\x48\xad\xaf\x89\x2e\x0b\x0c\x09\x1f\x9c\x7d\x85\xee\x6b\x18\xc5\x6f\x9e\x70\x79\xf1\x5c\xb8\x23\x34\x54\x20\x83\x33\xef\x71\xd0\x8e\x59\xfb\xda\x63\x76\x68\xc2\x2f\x61\x5f\xdc\x49\xbc\xd8\x4e\xa2\xd6\x11\x4f\x2b\x89\x55\xf4\x69\x98\x98\x0a\x53\x1a\x10\xb0\x56\x31\xa0\xaf\x91\x4f\x17\xa9\x08\x14\x21\xe9\x44\xa6\x74\x25\x13\x43\xb0\x14\xa6\x0e\xd4\xaf\x50\x17\x34\x60\xfd\xf8\x40\x7c\xfa\x10\xba\x26\x88\xb5\x38\x43\x50\x5f\xdc\xc2\xba\xda\x4f\x16\x56\x2a\x80\x97\x5e\x9c\xb8\x77\xfe\x76\xd3\x08\xc3\xd6\xc6\xe8\xd4\x59\xfb\xfe\xaa\xd9\x37\xab\x7e\xbd\x45\x83\x08\x55\x8a\xa1\xef\x92\x97\xec\x01\xe5\xc0\xfe\x81\xa2\x7a\x44\x9b\xaa\x9e\x34\x3a\x0d\x66\xb1\x62\x83\xb4\xca\x83\xa2\x8f\x48\x42\x1d\x95\xe2\x6b\xd3\x73\x2a\xde\x44\x54\xa9\x36\x74\x46\x59\x95\xe9\xab\x65\x2d\xb9\x7d\x65\x23\x74\xdb\x35\x03\xb2\x7d\x43\xc5\xb9\xfd\xce\x9f\xf7\xf4\x0b\x7a\xe0\xa5\x42\xfb\xea\x5a\x1f\x73\x9b\xa9\xe2\xe8\xc9\x09\xe3\xe0\xe3\x23\xe7\xec\x43\xbc\x12\xbd\x38\xcf\x33\x6b\xdf\xd8\x81\xb9\x0b\x30\x21\x86\x1d\x5c\x4d\x20\xc3\x7a\xf4\x60\x45\x21\x68\xd0\x9b\x3d\x55\x9b\xd5\xea\x1c\xad\x05\x7e\x8a\xc3\x19\x56\xd0\xa4\xd5\x17\x55\x80\x19\xc6\xa4\xe8\xd2\xbe\xf3\x3d\x57\x69\x13\xa6\xbb\xd1\x30\xad\x74\xe6\xd5\xb6\xff\xc5\x9f\x03\x86\xd5\x34\x8c\x85\xef\xb8\x3c\x7d\x8b\x4b\xf1\xac\x97\xb1\x05\xbe\xe7\xab\xed\xc4\x81\xe1\x9f\x61\x29\x2a\x99\xf0\x8f\x86\x5b\x6b\xee\x14\x19\x39\x9d\x91\x27\xb1\x6e\x19\xc6\xf5\x4a\x47\x27\xe2\xd8\xc7\xed\xf2\xe9\x04\xe0\x50\x1d\xd9\x94\xd6\x09\x98\x30\xa3\x75\x0a\xf8\xa1\x56\xb1\x59\xa1\x83\x7f\x54\xe8\xb4\x4a\x26\x59\xa1\x63\x95\x83\x80\x44\xaa\xd8\x24\xd7\x02\xcf\xab\x62\xc3\x72\xbd\xe4\x95\x3c\xa0\x95\x6f\x56\x48\x25\x83\xd1\xf9\x2e\xbd\xe4\x8a\x54\xca\x28\xd8\x4f\x24\xfa\xed\x0a\x2d\xd3\xb6\x44\xa1\x8d\x5c\x20\x0f\xe7\x6a\x15\x4b\x94\x5a\x9d\x34\x52\xa1\x90\x49\x35\x72\xba\x0e\x8e\xd2\xe9\xc0\x63\xd1\xa7\xe5\x1a\xa9\x54\xc9\x9c\x96\x6b\x74\xd1\x6b\x49\x29\xbc\x43\x42\x8b\x75\x9a\xb8\x0e\x83\xb0\xa6\x96\x50\xd9\x54\x99\x60\x87\xe0\x16\xdc\x38\xf8\x4d\xb1\xba\xb8\x99\x2e\x6f\xb3\x02\x20\x99\x30\x0f\x1a\xe9\x1e\x9b\x24\x54\xc2\x06\x09\xde\x30\x61\xb5\xbd\xed\xc3\x57\x3e\x50\x35\xa0\xf8\xac\x58\x22\xd6\xdd\xab\x17\xbf\x7e\x50\xab\x14\xf4\xa0\x5d\xe1\xe0\x88\xc9\x23\x6a\x44\x79\xf0\x02\xfc\xf1\x8d\x25\x4b\xde\x00\x6a\x90\x0b\xd4\x24\xf4\xd1\x2d\x76\x21\x98\xca\x46\xbb\x16\x7e\x33\xf0\x32\xdc\xaa\x51\xaa\x35\x60\x2e\x7c\x00\xe7\x83\x61\x70\x92\xd2\xee\x9b\x3e\x6e\x77\x86\x94\xf1\x2f\x79\x03\xfe\xd8\x23\x3f\x58\xdb\x23\x23\x14\x4a\xac\x77\x1e\xa2\x35\xc4\xd3\x15\x28\x0a\xf8\xf3\xb1\x91\x1f\x9a\xa0\xb8\x4e\x78\xa3\x34\xec\x8a\xa9\x02\x71\x87\x1e\x56\xe0\x15\xec\xff\x5e\xb2\x9b\x9a\xa6\xc7\xfe\x11\x3d\x7e\x7f\xb3\x52\x96\x27\xd2\xaa\x65\x2c\xab\xd2\xa7\x58\x9d\xba\xba\xc9\x4d\x03\x9d\x7d\xd5\x6a\x99\x4a\x2d\xf6\x29\x54\x8c\x3a\xd7\xd7\x90\xb7\xe7\x77\xaf\x33\x72\x94\x54\x9a\x27\xd6\xfc\x8b\xa4\xbb\xdf\x78\xdd\x7d\x73\x63\x46\x1f\xbc\x79\xf3\x08\xe4\x37\x6b\xb5\x0d\x0a\x96\x56\x30\xac\x5c\xa5\x94\xf3\x53\x07\xd5\x4d\xb1\x28\x95\x32\x40\xcb\x07\xeb\x75\xac\x3a\x2d\x59\x7f\x7a\xc7\xae\x53\x38\x95\x92\xf9\x57\xa9\xd8\xc2\x5b\x34\x3b\x30\xdc\xe2\x1b\xe2\x71\x14\xba\xd1\xc6\xb7\x72\x36\xa2\x53\x42\x49\x58\x13\xef\x96\x80\x80\x84\x71\x07\x4c\x12\xc0\xa3\xff\x74\x1b\x26\x74\xd1\x26\xfa\xc8\x23\x4d\x03\xa0\x0d\xb4\x9d\x86\x9f\xd1\x47\xe8\x23\xd1\x26\x74\x0d\xda\xa0\xed\x34\xb0\x37\xc1\x30\xdd\x86\x85\x9c\xf8\x06\x49\x86\xa3\xd3\x70\xa2\x58\x32\xfc\xd8\xe7\x4d\x20\x4c\x75\x93\x1b\xe1\x77\xba\x11\xe9\x44\x6f\x32\xf1\x12\x60\x0a\xb8\x25\x5c\xc0\x1d\x90\x00\x37\xdf\xb3\xeb\xd2\x67\x81\x0a\x5e\x6d\x6c\x6d\x82\x57\x81\x29\x73\xd4\x1a\x58\xc6\xe4\x82\x37\x61\x19\xfc\x6f\x60\x42\xb1\xc0\x04\xaf\x66\x8e\x62\xea\x6e\x51\xc9\xe7\xb0\x31\x4a\xe3\x29\x94\x04\x3f\x18\x46\x8f\x54\x81\x37\xd1\xa3\xff\x8d\xb2\x3b\x85\xb2\x43\x0f\x36\x82\xeb\xb7\xe8\x94\x58\x56\x7d\x45\x42\x71\x19\xa8\x9c\x3a\xca\x12\xf3\xb2\xd9\x97\x1a\x86\x7a\x68\xb8\xbb\x57\x80\xf8\xae\x2a\x17\x53\x2f\xf3\x13\x27\xc2\xc4\x57\x0a\x49\x85\xa9\x7e\x46\x2c\xe4\x15\xd4\xec\x95\x80\x00\xb0\x01\x0c\xcd\x55\x64\xa5\x0d\xc5\x41\x3a\xae\xc9\xab\xb3\x2b\x89\x7a\x3a\x96\x06\x62\x8d\x0e\xb4\x34\x27\xf0\xc5\xb4\x8f\xa8\xcd\xd8\x89\xf3\x73\x7a\x6b\xc0\xe5\x0e\x04\xdc\xae\x00\xbb\x2e\x30\x38\x10\x18\x1c\x71\x2f\x38\xb2\x00\xfd\xb1\x6b\x17\xd4\x0f\x59\xb8\xe0\x48\xa4\xef\xd1\x45\x8b\x8f\x3e\xf8\xf5\x51\x76\xdd\xd1\xc5\x8b\x8e\xa2\x8b\xc8\x67\xf0\xbf\x4f\xdd\x7e\x61\xd5\xaa\x0b\xb7\x9f\x62\x1e\x83\xf0\x03\x78\x1a\x2e\xb9\xb0\x7f\xec\xa8\xbd\xe7\xe8\xa1\xf0\x27\xb8\x0e\xbb\x54\x00\xab\x59\xb0\x26\x37\x28\x99\x77\x00\x5e\x3b\xb8\xf1\xdb\xfa\xfc\x06\xd9\x08\x5b\xfd\xd5\x8d\x07\xe1\xb5\x03\xf3\x24\xc1\x5c\x30\x77\x2f\xb8\xef\x8b\x36\x70\x27\x9d\x22\xbc\x3e\x40\xe3\xb7\xfb\x27\xe0\x77\x2e\x58\x00\x48\x19\x5a\xc9\x8b\x8f\x02\xf4\xfb\xfa\x28\xcc\x04\xab\x81\x6a\xd5\xc5\xf6\x8b\xab\x58\xd9\xfc\x79\x63\x0f\x5c\x58\xb2\xe8\xfd\x7b\x27\x44\x79\x1c\x8d\x3e\x03\x7a\x2d\xcb\x7a\xd7\x78\xef\x79\xe9\x3e\x78\x6d\x7f\xcb\x94\x92\x95\xc6\xdb\x9c\x53\x16\xec\x07\xe2\xfb\x5e\xba\x07\xc5\x4f\x5d\xd0\x82\xfa\xcc\xf4\x1b\x14\x7b\x80\xd0\x45\x1d\xd6\x17\x26\x60\x8d\xe8\x60\xd0\x77\x29\xe7\x00\x2b\xc0\x1e\xc9\x79\x53\x4c\xf9\x1d\xad\x3e\x63\xca\xe5\x01\xac\x75\xe4\x61\x04\x3d\x24\x2b\x8b\x68\x29\x56\x2c\xb2\x02\xa6\x37\xdc\x02\x7f\x01\x52\xb0\x1c\x48\xe1\xbe\x17\xd6\xaf\x7f\x61\x3d\xc8\x55\xb0\x8a\xcc\x3c\xf7\xa2\x33\x35\x40\x66\xb5\xca\xd3\x46\xa6\xf5\x39\x03\x7f\x4e\x1b\x89\x82\x69\x40\x36\xe0\xdd\x85\xee\xbc\x4c\x94\x44\x9a\x51\x10\xb2\x73\xfa\xaa\x01\x2d\xa5\x63\x1f\x72\xba\xec\xa1\x82\x0c\x7a\x09\x90\xbe\xfc\x0a\xca\xe9\x97\x57\x5e\x06\x07\xd7\x8f\x1f\xb7\x7e\xfd\xb8\xf1\xd1\x87\x53\xf2\x32\xb2\xec\xc9\x35\x86\x01\x24\x17\x85\xd5\x5a\x7d\x06\xfe\xdd\x8a\x02\x23\x71\x7e\x86\x9a\x64\x7b\x56\x46\x5e\x8a\xde\xaa\xd4\x9a\x59\xa5\xc3\x6c\xf4\x26\x27\x9b\xb5\x4a\x6b\x02\x7e\x18\x4f\xf9\xa9\x20\xd1\x56\x8d\xef\xda\x7b\x80\x88\x57\xd2\xe9\xae\x7c\x12\xc2\x9a\x47\x26\xac\x24\x84\x9d\x64\xa1\x19\x15\x5d\xa2\xa3\xbf\x38\x9f\xc6\xfc\x2f\xad\x76\xd9\x44\x6a\xa3\xed\x26\xf1\xf1\xfd\xe3\x37\x8c\x1f\xbf\x01\x78\xa5\x19\xbd\xd2\xa4\xae\x55\xeb\x96\xa6\xa4\xa4\xf5\xca\x90\x1a\x33\xfb\x0c\xbb\xdb\x7b\x57\xa1\xd1\x28\x31\x96\x1b\x4f\x2d\x1c\x84\x8e\x12\xa3\xf1\x54\xf1\xf6\xe1\x7d\x32\xfb\xbf\x06\xff\xfe\xda\x6b\x40\x4e\xaf\x48\x84\x3a\x65\x20\xce\x69\x7c\xf4\x17\x7d\x12\x97\x2c\x4e\xca\xcc\xd0\x6a\x93\xb9\x24\x7d\x5e\xaf\x5c\x9f\xb2\xf8\xae\x82\x58\x06\x8b\xea\x84\x2c\x5f\x2b\x56\xfa\x72\x7b\x01\x2d\x90\xbf\x86\x73\x03\xdf\x76\xc7\x37\x15\x64\x10\x2f\xa0\x7a\x6b\x05\xbf\x75\x78\x91\x43\x34\xa1\x11\x39\x88\x39\x2f\xef\xe4\xc8\x25\xa0\x93\x15\x15\xa5\x56\x8e\xd9\xf2\x15\x3c\xfd\xe4\x53\xf0\xf4\xd7\x5b\xc6\x85\xe8\xd3\xf9\x0e\xb0\xc7\xd9\xb7\x10\xad\xfd\x5f\x85\xaf\x3a\x3c\x85\x7d\x33\xc0\x5e\x3b\x17\x1e\x5b\x19\xbd\xfe\x14\x6c\xfd\x7a\xf3\xe6\xaf\x41\xe8\x29\x9a\x0f\x8d\xeb\xb8\x64\xc7\x00\x8b\x85\x7d\xed\xf0\x1d\xe0\xb7\xf7\x2d\xf4\xa6\xc3\x55\xf6\x98\x8e\xfa\xbd\x88\x06\xcc\xc0\x7d\x8e\x03\xd8\xd4\xc6\xe5\x73\x51\x18\x10\xba\xd8\xe5\xb3\x1b\x94\xb4\xc9\x48\x99\xb0\x92\x3a\x8d\x7a\x9b\x8f\x33\x08\x0a\x5c\x44\xbd\xce\x5f\xec\x2b\x42\xab\x0e\x14\xc5\x33\x46\xad\x09\x78\x68\x94\x00\x7f\x26\x8a\xe7\x3e\x84\x97\x93\xe1\xcf\x95\xc0\xd7\x00\x8f\x8d\x34\x8c\x5d\x9c\x0b\xe8\xfe\xee\xa1\xc5\x6a\x33\xb8\x3d\x2f\xed\x23\xa3\xee\xc3\x54\xd7\x51\x1a\xf4\xee\x63\xb0\xcf\xb1\xcd\xab\x48\xaa\x9e\x08\x42\x17\x77\xeb\x82\x0b\xed\x17\x15\x5f\xf1\xe0\x45\x65\xff\x5e\x66\xf0\x1e\x00\x5b\x83\xd1\x9f\xec\x33\xe8\xe7\x0b\xa3\x37\x36\x02\x00\x4e\x33\xfa\x77\x8a\x16\x8d\xe4\x5c\xe2\x22\xda\x52\xe6\xe8\x15\xd9\x31\xb5\x1c\x1c\xcc\x76\x83\x2f\x7d\x7d\xe9\x22\x90\x4f\x7b\x3c\xfd\xfe\x5a\xfd\xe1\xde\x40\x21\xcd\x67\x88\x00\x28\xa4\x83\x45\xb0\x9f\x3d\x0a\x35\xcc\x75\x57\xa1\x12\x20\xaa\x92\xcb\x6e\xef\x08\xd5\x26\xe0\x69\x4b\xa9\x24\x6a\x21\xe2\x6a\x77\x25\x50\x3c\xbc\xf2\x54\xb2\x3c\x08\xb2\x4e\x3d\x8f\xb1\xb1\x51\xfb\xa3\x5a\x92\x55\x41\x1a\xd9\x6e\xc5\x80\x38\x04\x32\x1b\xd1\x2b\xb2\x5e\x52\x61\x3e\x3f\x80\x31\x09\xd1\x45\x3e\xf1\xec\x87\x39\xdd\x7c\xb2\x2e\x10\x11\xf7\x6d\x56\xec\x0f\x18\x0d\xe5\x0a\x34\x30\x05\x0d\x8f\xc4\x19\xbb\xdb\x6c\xc0\x3c\x6b\x4f\x36\xbb\xd2\x8b\x50\xb6\x13\x24\x4b\x36\x6d\x9d\xc8\xc0\xa3\xfc\xf2\x0d\xdb\x26\xd0\x77\x36\x33\x96\x64\x56\xd1\x6b\xe0\x27\xeb\xd5\x88\x21\x10\x01\xf5\x80\x81\x6f\x3d\x0e\x92\x74\x0a\x34\x48\xe8\x05\x87\xd3\xfa\x4a\x65\x5c\xb5\x72\x2e\x6d\x4f\x61\x15\xc9\x7a\xfd\xa0\xb6\x0d\x2a\x5a\x81\xd2\xa9\xfa\x57\xbc\xf7\xa4\x5b\x2e\x73\xce\xdf\x9f\x56\x22\x95\xb1\xa5\xca\x11\x6b\x3e\x84\x97\xe0\x4b\xf0\xd2\x87\x6b\xd6\x7c\x08\x32\x41\x3f\x90\xf9\xe1\x67\xb7\x98\x60\xe8\xf5\x66\x17\x2e\x8e\x7d\x18\xdd\x57\x3c\x77\xd5\xba\xb1\xa2\xe8\x2b\xfc\xbc\x95\xeb\xc7\xf6\x7e\xfb\x38\xad\x55\x29\xa4\xe9\x2d\x87\x6c\x7d\x50\x96\xd5\xaa\x99\xb4\xd3\xca\x2a\x52\x33\x99\xda\xcf\x37\xa8\x18\x39\x7e\xed\x80\x3e\xe7\x1e\x07\x46\xb5\x5c\xa4\x93\xcb\x5b\x0e\x58\x51\x3a\xae\x4a\x31\xb7\x44\xa2\x08\xd5\x7e\xba\x4e\x4e\xe3\x2a\x28\x06\x7c\x43\x5e\xbe\x26\xb1\x40\xf4\xda\x7f\xc6\x47\x81\xd8\xdc\x6a\xa4\xd2\x31\x3a\x0e\xc0\x3b\x6b\x4e\x17\xfa\x5c\xfe\x0c\x09\x30\xb2\x01\xc6\x85\x66\x12\xb5\xd3\xa8\xa5\x11\xc5\x70\x02\x3f\xed\xce\xc0\xf8\x24\x88\xb0\x30\xb7\xff\xf8\x87\x6f\x97\x47\xcd\x47\xe0\xdf\xbd\xf0\xbb\x30\x98\x87\x16\x8d\x43\x07\x00\xe3\x81\xaf\x2f\xc0\x87\xde\x12\xfd\xae\x8c\x99\x7a\xee\xee\xaf\xe1\xdf\xc1\xde\x46\xd9\x34\x58\xd2\x7e\xf2\x64\xfb\x49\x11\x45\xaf\xd8\xf4\x83\x5b\xf2\xf0\x2e\xf0\xc8\xfd\x8f\xc3\x39\xd1\x99\x77\xef\x49\x85\xe5\xf6\xeb\x60\xcd\x15\x20\x0b\xec\x83\xa7\xe0\x27\xd1\x61\x1b\x95\xf4\xfc\xf5\xa0\x62\xa9\xe8\x24\x7e\x08\x8f\x2b\x1a\xf7\x2f\xee\x6d\xb2\x9b\x60\xa3\xdc\x2e\x1a\x2d\xac\x99\x20\x16\x51\x04\xf0\x18\x62\x88\xce\x27\xcd\x9b\xdc\x22\x2b\x36\x04\xc2\x58\x1b\x4a\x16\xcd\x83\x6e\x2b\xc0\x66\x41\x1e\x1c\x30\xa1\xb2\xb3\x94\xce\x48\x2b\x01\xcb\x6c\x86\x5f\xc1\xbe\x73\xca\xb4\xfd\xee\x9d\x21\x93\x2d\x54\x64\x7f\xbf\xd8\xbf\x9e\x4f\xae\xf5\x8e\x10\xab\x64\xc9\x9c\x69\x4c\x89\x6a\xab\xd6\xe0\xad\xcf\xf2\x4e\xa8\x71\x96\x97\x4a\xd0\xf2\xc9\x98\x65\xee\xfd\xe8\xed\x03\x4f\x1e\xd9\x3b\x3b\x25\x47\xdc\x27\x6f\xd4\xd4\x14\xd5\xce\x3b\x00\x22\x29\x2c\x3d\xe2\x81\x4b\xf0\xea\x0d\x0a\xe4\x5d\x5b\x0f\x86\x83\xbe\x20\x67\x3c\xfc\x46\xc9\x68\x86\x2e\xa4\xf3\x7e\xdf\x5b\x8c\x18\x3f\xc0\x0d\x75\xf0\xa6\x02\xe9\xab\x7d\x72\x06\x95\xa4\xf0\x12\xaf\x9b\x66\xcb\x32\x68\x5e\xab\x10\x33\x13\x87\xca\xca\x73\xd2\x6a\xa6\xfb\xc6\xbe\xfb\x84\xcb\x35\xac\xff\x71\x30\x66\xfe\x20\x38\x1b\xbe\xb1\xe6\x06\x75\xe5\xc4\x94\xb8\x2c\x27\x86\xe3\x1f\x10\xfc\x35\xb2\x44\xc5\x15\x6b\x7f\xa2\xf9\x29\x40\x0c\x3f\x5c\x98\xe0\x61\xd8\xd9\x5e\xe8\xbb\x01\x3d\x4d\xa0\x14\xfc\x5a\x5f\x31\xed\x26\xbe\x15\xb5\xdc\xc5\x63\xaf\x1f\x84\xdf\x4d\xaf\x1d\xcd\xb2\xa3\x6b\xa7\x03\xfd\xc1\xd7\x8f\xdd\x06\xcf\x3e\x9a\xaa\x7c\x12\xfe\xee\xcb\x4d\xb8\x6f\x3c\xc7\x3c\x02\x0a\xc1\x83\x07\xb6\x34\x2f\xbd\x63\xe9\x81\xb7\xde\x3c\xb0\x6c\xf3\xb2\xd9\x9b\xef\xe1\x2c\xf3\x76\xad\x19\xdf\xbe\x3d\x7b\x7b\xfb\xf8\x35\xbb\xe6\xcd\x59\x0e\xc4\x7b\x7e\x00\xd5\x27\x9f\xc3\x3d\x09\x2c\x8b\x5c\x6b\x85\x8f\xad\xae\x18\x5e\x02\x26\x7f\xf9\x27\x30\xb9\x74\x58\xe5\xed\xf0\x44\x6c\x7d\xa2\x46\xdf\xed\x47\x2a\x87\xf2\x51\x15\x54\x3f\xe2\xef\xc6\x2e\xac\x5a\x11\xdb\x82\x4b\x8d\x0a\x89\x75\x2d\x02\x5a\xa7\x88\xd1\x52\x68\x75\x82\x81\xcc\x30\x0c\x8e\x91\x21\x24\x1b\x7f\x37\x40\x64\x7e\x58\xc1\x15\xd8\xc9\xa2\x16\x11\xc5\x8e\xb5\x1f\xef\x99\xf2\x78\x11\x78\xb8\xe4\x2b\x78\xee\x91\x97\x1f\xfd\xf2\xa1\xef\xf3\x34\xe3\xde\x02\xfa\x17\xfe\x56\x01\x5e\x04\xc9\x56\x15\x75\xe3\xe9\x50\xf3\x88\x82\xda\x69\xfd\x66\x0d\x9f\xb3\xeb\xb6\x77\xfb\x7a\xaf\xbf\x39\x69\xe4\xa2\x7b\x56\x3c\xef\x99\x0c\xae\xd1\x97\xb8\x4b\x77\xef\xf8\x23\x3d\xaa\xa4\x60\xd7\x1b\xe3\x87\xdf\xff\xf7\x8d\xc3\x16\x03\x7e\xd1\x91\xde\x8f\x82\xe6\x5f\x86\xc0\xef\xd1\x84\x33\x11\x2c\x31\x07\x26\x57\x2d\x3e\xfe\x1c\x78\x6a\xd8\xe4\x7e\xf9\x8f\xce\xdf\xdc\xb1\x6a\xe4\xf8\x61\x03\x3e\xdd\x74\x96\x1e\x78\xd7\x6b\xaf\xc5\xe5\x6c\x61\x5e\xf0\x33\x82\x71\x01\x6e\xb9\xab\x69\xb8\x69\xbf\xd0\x97\xb8\x31\x4d\xe9\x14\xd7\xc9\x8e\xa5\x48\xd8\xcd\x8c\xda\x00\xd9\x88\x88\x90\x8d\x08\xd0\x14\xb5\xe1\x0d\x4b\x51\xa8\x6a\x02\xb0\x31\x24\x61\x04\xef\x67\x32\x67\x23\x82\xfe\x4b\x7c\xbf\x21\x1c\xd3\x79\x11\xca\x65\x44\xf3\xe2\x9f\x51\xb9\x4c\x78\xe7\x58\xe7\xc5\x7b\x69\x82\x12\x34\xfa\x1f\x7b\x7b\x56\xa7\xb9\xa3\x9f\xe1\xb0\x4e\x9f\x9b\x6c\xb5\x09\xae\xaf\xd1\xa8\x72\xba\xee\x7c\xa3\x5f\x49\x86\x47\xc9\x24\x69\x75\x2c\xed\xb5\x96\x4e\x84\x3f\x16\x54\x57\xb3\xdf\x82\x62\x74\x2a\x78\xfa\x82\x1a\xe6\xd0\xfa\xec\x41\x81\x95\x75\xb6\xec\xf2\x74\x87\x41\xaa\xd5\x8f\xe8\x9d\x37\xa8\xd4\xeb\xd0\x80\x0b\xd5\x5c\x38\x34\xa2\x64\xe9\xc6\xd9\x87\x26\x8e\xd6\x49\x7e\x18\xfb\x58\x73\x75\x01\x97\x84\x1f\x6c\xff\xb6\xa0\xfa\x03\x30\x65\x5a\xde\xc0\x7e\x85\x72\x73\x55\x4a\xf5\x6b\x47\x8f\x9e\x19\xec\xca\x0a\x29\xe4\x32\x53\x7e\xa1\x6d\xea\x93\xc2\xfa\x56\x79\x83\xe2\x6e\x23\xf2\x92\x7e\xd4\x63\xd4\x1b\x68\x56\xe5\x05\x88\x10\x41\x15\x1a\x2b\x90\x63\x25\xee\x98\x59\x14\x59\xc4\xe1\x20\x5a\x21\x18\xf9\x9b\xad\x57\x02\x31\xd3\x15\x93\x91\xd3\x13\x88\xe2\x74\x92\x89\xcf\x41\xf2\x31\x79\x35\x31\x8b\x2b\x41\x95\x1d\x45\xa6\x81\x38\xec\xb1\xe0\x8b\x49\x13\x43\x6f\x13\x2e\xd1\x1a\x12\xb7\x56\xec\x33\xea\xb1\xe5\x5b\x0c\x27\x06\x97\x81\x31\xea\x3b\x8b\x8a\x53\x13\xcd\x76\x32\x10\x51\x8d\x16\xec\x3a\x70\xf4\xd8\xbd\x7b\xe6\x2f\x08\x66\xcb\xd9\x62\x2f\x07\xb4\x96\xa2\xe9\x93\xc3\x1b\x76\xdc\xbd\x31\x3c\x49\x24\x55\xc9\x0d\x19\xd0\x50\x55\x61\xb0\x68\x54\x52\x49\xb0\x8a\x93\xaa\xd4\xb4\x56\x5c\x55\xa5\xb6\x6a\x15\x22\xbe\xb2\x52\x6b\x4d\x01\x6f\x79\xf2\x86\xd6\x7f\xf8\xd3\x87\xf5\x0d\x39\x2a\x20\x29\x2e\x92\x3a\x7b\x03\x66\xca\xcc\x3d\xbb\xcf\xbf\xbf\xab\xcc\x6f\x51\xa9\xd1\x6a\xcf\x25\x6b\xde\x31\xa0\x7f\xf3\xec\xfe\xa1\x79\x1b\x9a\x9e\xde\x54\xb3\x7d\xdb\x5b\x67\xb6\xf9\x92\x68\xb1\xd4\x6e\x34\xa4\x19\x34\xcc\x5c\xab\x35\x72\x11\x64\xae\xf2\xcc\x5d\x71\xdb\x87\xf5\x43\xf3\x3c\x69\x12\x99\xcc\xac\x90\xf0\xb3\xa6\x85\xf7\x6c\x5c\x9b\xa2\x45\xa4\x4f\xb1\xee\xd1\x07\xef\xbd\x43\x26\x5a\x10\x0c\x85\x2a\x5a\x5a\x76\xcd\x18\x69\x11\x8b\x2d\x80\x19\xd3\x77\xd5\xf4\xc9\xfe\x92\x92\x00\x2a\x31\xcb\xe8\x9c\x74\x03\x29\xb1\xb4\xbc\x8a\x53\xd3\x2a\x25\x2f\xad\xac\x52\xa7\x6a\xb9\xaa\x4a\x8d\x35\x65\xe0\xd2\x79\x33\x87\xd6\x8f\x1b\x57\xdf\xd0\x6c\xe7\x53\x34\x6a\xcb\x94\x6a\x30\x8c\xde\xd2\x34\xe3\xdc\xae\xdd\xe7\xd5\xb2\x22\xaf\x98\x61\x44\x77\xcf\x98\xd6\xaf\x7f\xfd\x80\x46\x38\xa5\x4f\xcd\xa6\xa7\x26\xbe\xb9\x7d\xdb\x36\x5f\x3a\x2d\x93\x48\xc5\x9c\x49\x45\x3f\xa2\x32\xcd\x83\xa9\xd9\xc3\x75\x9e\x71\xf5\x43\x67\xb6\x80\xf3\x62\xbd\x5a\x61\xe6\xc7\x66\x97\x14\x4a\xf3\x93\x15\x6a\xb6\x34\x54\x86\xfb\x4c\xea\x0d\x4a\xf4\xb9\x08\x63\x8f\x05\xa9\xc5\x58\xc2\xe6\xf4\x1b\xf5\x68\x3a\x70\xa4\x7b\xb0\x5b\x60\xe2\x94\xd9\xc4\x3a\xfd\x4e\x8c\x36\x83\x38\x34\xd4\xd9\x11\xb7\xaf\xa4\x1d\x4a\x26\x9b\x16\x00\x6e\xfc\x46\x8c\xd9\x97\x86\x19\x12\x2c\x2d\x50\x32\x64\x9b\x9e\x0b\x08\x5f\x1e\x0d\x14\x27\x31\x40\xb4\x32\x06\xa0\x27\xc6\x08\xfe\x72\xa0\x64\x44\x2a\x95\x51\xa5\x08\xae\xdd\xff\xd9\xd2\x65\x3f\x3c\x73\x6c\x6a\xba\x98\x15\x49\x15\x5c\xeb\x1c\xb0\x11\x1c\x78\x0d\xdc\x2b\xd3\xe8\xd3\xbd\x1a\xad\xc4\x90\xaf\xe1\x0c\x76\x73\xae\x2e\x07\x88\x94\x62\x09\x27\xc2\xfa\xbf\xa2\x59\x45\x9e\x55\x70\x43\x8a\xd3\xa5\x54\xfc\x29\x73\xb0\x4e\x27\x53\xba\x96\x6d\xd9\xb1\xbe\x39\x58\xd2\x78\xfb\xf2\x6d\x53\x8a\x0c\xe9\xa3\x44\x86\xde\xc5\xbd\xb5\xf0\xa3\xdc\x31\xab\x4f\x4e\x9f\xfa\xc0\xa4\xca\xe4\x68\x53\xbf\xaa\x9a\xe1\x56\x65\xaf\xe6\xb9\x95\xbd\x45\xa2\x54\x9d\x3a\x30\xb4\x4f\x61\x70\xec\x92\xf1\x59\x12\x95\x84\x03\xec\x92\xc2\xa7\x46\x66\x7e\xa0\x9e\x5d\x38\x2c\x4b\x29\xd5\xe5\xed\x37\xf2\x12\xec\x42\x54\x70\x16\x4b\xd3\xea\x02\x11\x2f\x07\x8f\xa6\x55\x15\x65\xcb\x64\x6d\xce\x41\x7a\xbd\xcc\xd8\x6b\x54\xa6\xa8\x60\xd8\xdd\x63\x87\x6f\x1b\x5f\x93\x65\x91\xd0\x6b\x2a\x6d\x3e\xda\xe8\x6c\x08\xa4\xf4\x5e\x3a\xa7\xa1\xb0\xa8\x66\xfc\x90\xf4\xe8\xe1\x91\xf9\xb9\xc6\xe4\xc9\x79\x25\x0f\xd0\xfa\xfc\x89\x9d\x36\x3f\x61\x32\x47\x79\x89\x86\xd6\xec\x04\x9b\xd0\x38\xaa\x72\x97\x6d\x6e\x67\xc8\x19\xc3\xb4\xf4\xc5\x30\x2e\xb9\x1e\xd7\x82\x7e\xe9\xaf\x58\xab\xc7\x8c\xb5\x88\x8b\xee\x98\x63\x70\x44\x08\x31\xb1\x14\x4e\x37\x12\x1d\x30\x25\x84\xd9\x70\x7b\x98\xa1\x12\x90\x0c\x12\x82\x1c\x55\x57\xdc\xa5\xbf\xd2\x84\xc9\x6f\x53\xec\x28\xd8\xa2\x0b\x1a\x85\x09\xe1\x76\x2d\x36\x3d\xa4\x43\x3d\x73\x22\xc1\x6e\xed\xa3\x22\x5e\x0e\xbc\x44\x83\xcd\x90\x38\x27\x14\x19\xb1\xbe\xdd\xbf\xc6\x02\xfd\x17\x0d\x8a\xda\x8a\x45\x93\x42\x54\x50\x1b\x41\x45\x88\xa0\x55\x21\x96\x44\x77\x55\x9d\x49\xf4\x4f\x15\xbe\x65\xab\xa1\x18\x70\x24\x9e\x46\x1b\xfd\x80\xa5\x5a\x6f\xaa\xb3\x10\x1e\x7c\xeb\x86\xaa\xeb\xde\x27\xdc\x88\x73\x21\x7d\xc2\xd9\x05\x71\xe6\x22\x54\xb9\xd3\xf7\x50\xcc\x0e\xdd\x64\xd4\xff\x9f\xb5\xc3\x28\x6c\x65\xfe\xca\x2b\x82\x8d\xf9\xab\xaf\x0a\x56\xe7\xf1\xeb\x57\x5e\x91\x44\x6c\xff\x59\xd3\xdc\x73\xeb\xec\x3a\xaf\x61\xdb\xff\xae\xbd\xf4\x68\x1d\x95\x49\x95\x60\xac\x58\x89\x00\x9a\x14\x6b\xa5\x98\xb5\xfe\xff\x55\x03\x71\x26\x48\x49\xcd\x52\xd8\x26\x14\xfd\x0a\x10\xea\xd2\xd1\xf4\x9f\x35\x0b\xdd\x1b\x52\x12\x09\xb0\x09\x0d\x82\x72\x23\xd9\x46\xcb\xfe\x83\xc6\x00\x9d\x3c\x6f\x6a\x8c\x8e\x00\x32\x35\xc7\x4f\x09\xd2\x09\xd0\x6a\x76\xd1\x49\x1a\x53\xfc\xe8\x32\x5f\x27\x7a\xf2\x22\xca\x65\x8e\x6c\x04\x8f\x2b\x5d\x66\x28\x9c\x3a\x84\x78\x74\x14\xe4\x8a\xac\xb0\xf6\x21\x5e\x47\xa8\xa2\x40\xa7\x9c\x3c\x0e\x7e\xe0\x24\x3b\x25\x9d\x22\x23\x3f\x78\x6d\x43\x90\x98\x7d\x0e\x07\x8f\x80\x5c\x78\x01\x36\xc2\x0b\x34\x85\x2b\xb3\xeb\x9c\xd6\xa2\x7d\x14\xb4\xaa\xa2\x0b\xf0\x2b\xe8\xbb\xd9\x42\xe1\x36\xc8\x05\x8f\xd4\xa1\x7b\xe7\x76\xe1\x64\xcb\x1e\x15\x64\x9a\x4e\xf4\x9d\x3f\x26\x73\x94\x93\xe8\xe0\x10\x11\x54\x97\xb8\xa5\xeb\x63\x61\xa4\xa6\x78\xb1\xba\xa8\x69\x0c\xb8\x01\xb3\x91\x06\xd1\xfb\x52\xe9\x76\x4b\x66\x3b\xb1\x37\xa5\x43\x82\x55\x2a\x95\x69\x89\xbc\x02\x04\x13\x55\x86\xe0\xa4\xb5\xb7\x66\x5a\xb6\x93\x94\x34\x6a\x5b\xf6\x8f\xe8\xab\x6f\xb7\x60\x40\x48\x82\x04\xe6\x32\x87\x2c\x1d\x57\x88\x8e\xbf\x99\x69\x15\x00\xc2\x50\x72\x9c\xa6\xb5\x55\x90\xb7\x8b\x29\xae\x83\xe8\x15\xe3\xb1\x4c\x09\x7b\xc9\x3c\x10\xb9\x9d\x5c\x5c\x63\xda\x1f\x40\xdc\x17\xe7\xf4\x73\x1a\x4e\xe3\x44\xff\x01\x3a\xf3\x5f\x5a\x8c\xda\x68\x38\x29\x29\x7a\x6f\xf4\x5e\xa9\x52\xa7\x41\x97\x34\xba\xa4\x9b\xe9\x66\x5b\x47\x12\x1d\xea\x68\xa2\x6d\x6c\x5b\xb4\x8d\xfb\x59\x6f\x6f\x0f\xeb\x6d\xfc\x0d\x4a\x26\xfb\xe5\x17\x4e\xa6\xb7\x73\xf8\x12\x90\x4b\xc5\x81\x0e\xe9\xd7\xec\x2f\x8a\x0e\xe9\x65\xf6\x97\xf6\x28\xfb\xcb\xe5\x0e\x69\xa2\x6c\x58\x83\x4a\xe5\x8b\xcf\x37\x78\xa3\x96\xb4\x24\x2a\x8f\xfd\x16\x31\xf1\x8d\x70\x3c\xac\x70\xb1\x69\x4a\xa1\xd3\x40\x1b\x2f\x46\x27\xd0\xc6\xb3\xdf\x76\xbb\xec\x78\x44\x2c\xa2\x29\xad\x4e\x21\x16\x41\x74\x12\x21\x66\xbd\x3d\xa4\x17\xa3\xce\xa3\x43\x73\xbb\x5e\x0c\x70\xa0\x67\x0c\x73\x83\x92\xea\xda\x11\x93\xce\x00\x14\xe0\x10\xcf\x1e\xdf\xaf\xb1\xf1\x78\x98\x63\xfb\x1a\x13\x85\x15\x62\x7b\x78\x54\x89\x9f\x05\xed\x4e\xb7\x88\x13\x11\x53\xcc\x40\x90\x0f\x60\x25\x09\xac\xea\x49\x0b\x8e\x53\xc0\xbb\xdd\x4f\x3f\xc2\xa9\x7f\x9f\x37\xed\x71\xd8\x5e\x9c\x2e\xd7\x33\x6c\x12\xe7\x54\xda\x55\x66\xa5\x8a\xdb\xf5\xf0\x8f\xe0\x3e\xf0\x2d\xb8\x8f\xae\x4d\x80\xf5\x14\xfe\x80\x07\x3e\x08\x2f\x3f\xa6\x7d\xbc\x44\xca\x00\xa5\x4c\x65\xe4\xec\x4a\xa7\xb9\xa0\xa0\x8f\x7b\x4c\xf4\xee\x27\x80\xfb\xb1\xc7\x3a\xed\x79\x13\xca\xed\x21\x88\xae\x3d\x6c\x83\xe2\x67\xbc\x77\x82\xc6\x4b\x1a\xc6\x73\x43\xfc\x38\xe6\xcb\x33\xfc\x6a\x17\xd0\x77\x56\x08\xcb\xa9\x7d\x2e\xbf\x0b\xbb\x94\xe0\x02\xc4\x27\x15\x76\x0a\x63\x05\xb7\xac\xd9\x55\xd8\x0c\x0f\xbd\x7f\xf7\xba\x51\x29\x49\x9e\x7b\x57\xe6\x94\xf6\x2d\x7f\x0f\x4c\x79\xff\x7d\x30\x14\x57\xb8\x5f\xed\x9b\xb0\xbd\xb0\x92\x53\x25\xb1\x0c\x07\xa4\xb4\x9c\xe6\x0b\x0c\x59\x49\x56\xd9\xa1\x67\xbb\x44\x1d\xf4\xb3\x37\xd7\x3b\xbc\xf5\xbb\x3b\x5a\xde\x1d\x58\xd4\x34\x76\x68\xc5\x1c\x97\x48\xbc\xf5\x3b\xa0\xfd\x0e\x6e\x7d\x02\x35\x86\xf8\xc9\x3e\x4a\x31\xa2\x33\xac\x9a\x55\x21\xb6\x50\xec\x33\x95\x78\x06\x64\x8e\x06\xa2\x7d\xeb\xbe\x3f\x31\x6d\xda\x89\xef\xc9\x77\x94\xb0\x14\xf7\x0f\xd4\x03\x45\x94\x94\x52\x60\x2a\xad\x41\x7f\x20\x19\x90\x33\x36\xe3\x85\xe8\x3f\x4d\x7e\x68\xc0\x8d\x06\xee\xe8\x49\x78\x89\x59\x16\x3d\x09\x32\xd9\xc3\x38\x4c\x0f\x81\x97\x71\x2c\x91\x1b\x36\xdc\x68\x15\x3d\xce\x85\x88\x1d\xba\x08\x50\x8e\x74\xc6\xc5\xd0\xd8\x7b\x6b\x30\x66\xf5\xaa\x15\xd6\x37\x01\x3f\x8a\xd4\x72\x46\xd1\xe3\x52\xf8\x1a\xfc\xaf\xaf\xee\x9a\x9c\xdb\x38\x60\x84\x76\xee\xa0\xa4\x47\x3c\xf7\x8d\x98\xb8\xd8\x94\x6b\x0c\x54\x7a\x67\x4c\x13\x2b\x56\x94\x86\x96\x83\x61\x1d\x4c\xfb\x77\x70\x12\x1c\x0a\xf8\x23\xa0\x0a\x88\xea\x26\x1b\xee\xc9\xbc\x53\x2c\x59\xbb\x15\x7e\x3e\xf2\xfa\x6f\x7e\x33\x62\xab\x19\xdc\x21\x13\x77\xae\x63\x45\x02\x2e\x83\x94\x20\x6b\xdb\x01\xa3\xb3\xa3\x0e\x2c\xa2\xda\x29\xb6\xfc\x93\x4f\xa2\x9b\x3e\xf9\x04\x94\xa3\x89\x81\x02\xc7\xe8\x65\x20\x0b\xfe\x31\x7a\x07\x3c\x1f\xef\xd7\xf1\x67\xb5\x54\x25\x35\x22\xf6\x3c\x4f\x30\xb7\x03\xee\x80\x1b\x3b\xda\xe6\xd0\x4a\x37\x80\xd5\x94\x63\xa0\x20\xd8\x06\x0b\xad\xa1\x0c\x76\x1f\x5a\x75\x62\x8d\x1d\x6f\xc0\x91\x8e\x39\xe9\xe2\x20\x0d\x7c\x44\x49\xcf\xa7\xb1\xa3\x95\x5c\x2c\x1d\x2e\x07\xb3\x4d\x5e\x9b\x96\x3c\x7b\x76\x72\x5a\xad\x7c\xa2\xcf\xe6\x83\xfb\x6c\xc9\xe0\x09\x47\xd5\x80\xc2\x8d\x1b\x9a\xea\xf4\x52\x45\x0d\x68\xdd\x2b\xe2\x68\x00\x4e\xb9\xbe\x11\xb1\x2c\x23\x4f\xa1\x97\xfa\x79\x8e\x86\xdf\x9b\x86\x99\xe4\xca\x7e\xb8\xf8\x6c\xab\x7d\xd8\xc2\xe4\xd2\xd2\xe4\x85\xc3\xec\x4d\x4d\x47\x6d\xf9\x86\x40\xad\x53\xb9\xe8\xf6\x01\x61\x31\x5c\xa7\x94\x03\xbe\x71\xa4\x12\x00\x96\x95\x72\x60\x7d\x58\x24\x62\xea\x53\x52\x52\x65\x91\xdf\x8e\x44\x4b\x21\x46\x2e\xa2\xc5\xd3\x8c\xbc\x1e\xde\xa5\x94\xd0\x92\x91\x42\xdd\xa7\x12\x1a\x84\xf7\x7b\x86\x62\x2f\xa3\x58\xcf\x90\x6c\xc8\xd8\x62\x9b\x30\x31\x88\x76\xa7\x2e\x08\x4c\x1c\x51\x2d\xc1\x63\xc5\xe7\x64\x58\xa2\xe0\x00\xf0\xec\x42\xe6\x19\xe0\x47\x0b\x8c\xf4\xd8\xc2\x14\xad\x19\xf5\x82\xe7\x41\x57\x1c\x06\x5a\xcf\x53\xbd\x8a\xe4\x17\xe1\x0e\x58\x0f\x77\x5e\x94\x79\x83\x8b\x87\x8d\xe8\xfd\x11\xc8\x5a\xcc\x24\x29\xc1\x02\xed\x80\x9c\x60\x63\xe3\xaa\x51\xf0\xe9\x66\x90\xfb\x71\xd9\x88\x61\x8b\xdb\x1f\x18\xb5\xaa\xb1\x31\x58\xde\xc8\x20\xf6\x5e\x6a\x95\x65\x1d\x39\x72\x24\x4b\x66\x95\xca\x64\x39\xf7\x4c\x68\x9c\x70\x8f\x71\xd5\xa8\xc6\xf2\x60\x23\xfd\x74\xd9\xc4\x64\x4f\xd1\x41\x78\x6d\xff\x7e\x20\x3e\x98\x9f\x9f\x3c\xa9\xac\x61\x49\xc5\xbd\x52\x5a\xa2\x50\x33\x43\x9d\x79\x28\x97\x51\xc1\x81\x30\x53\x72\x4f\xf9\x12\xf8\x0d\x79\x49\x23\x6c\x92\x59\x65\x52\x69\x76\x66\x66\xb6\x54\x2a\x4d\x93\xe5\x14\x49\x24\x45\xd7\xf0\xcb\x46\xad\x22\x7d\xba\xef\x0d\x5a\xf4\x32\x6a\x97\x02\x2c\x7d\x08\x32\x78\x1b\x0a\x6b\x3a\xd8\xad\x0c\xea\xd4\x1a\x91\x1c\xb1\x7e\x18\x94\x28\xa0\x04\xbc\xdd\xef\x61\xf3\xd1\x0a\xaa\x2f\x50\x8f\xd8\xf9\x1a\x00\x7b\xbe\x01\xf3\xe6\x37\x77\x1c\x04\x33\x1f\xf9\xc3\x1f\xdf\xae\x19\x07\xbf\x87\x0f\x6c\x7f\xf5\x67\x9a\xf9\xf2\x0f\x05\xbd\xd5\xf4\x4a\xb1\x2d\x38\xa4\xa1\xda\x68\xdc\x7c\xfd\xcd\x03\xf4\x57\xab\xbf\x79\x77\xef\xc8\x3f\xbc\xf9\xf2\x8d\x57\xe6\x1f\x6d\xb0\x99\xfb\x78\xe1\xe6\xc0\x40\xda\x5f\x03\x9a\x7e\xf7\x13\x18\x3e\xb9\xf7\xfa\x09\x83\x56\x0f\x2a\x31\xab\x00\xe0\x86\xac\xbb\x27\xde\x5f\x89\x6e\xbd\x80\x46\x9f\x42\x51\xa8\xa7\xc5\x58\x0a\xdc\x21\xb1\x11\x49\x27\xb3\xe4\x95\x50\x13\xaa\xae\x21\x06\x07\x1b\x71\x60\x33\x15\x11\xe2\x51\xfe\x81\xe2\x6c\x74\x53\x14\xab\x98\x83\x74\x62\xc2\x82\xb8\xa0\xb6\xb6\xaa\x09\x9d\xba\x9d\x2f\x13\xbb\x95\x02\x3c\xbf\x3b\xc9\x96\x1c\xee\x08\x82\x3f\xc9\x00\xf1\x26\x25\x08\xac\x11\x79\x44\x2c\x1e\x65\x4f\x70\x38\x6a\x62\x1c\xd8\x3e\xa5\xc8\x0a\x94\x40\x54\xf0\xd1\xc0\x9f\xb7\xef\xbe\xb6\x63\xc4\xce\xb7\xe6\xad\xbf\x5a\xf7\xc7\x79\xf0\xfe\x77\x7e\x03\x3f\xba\xb0\x7a\xf5\x05\xe0\xfa\xcd\x45\xb0\x00\x86\xe8\x67\x17\xc3\x5a\xf8\xc3\x73\x71\x09\xef\x73\x80\x05\xc7\x6e\xbf\xdf\xdd\xb4\xc5\x96\x27\x97\xe6\xfd\x32\x7f\xf9\x9d\x3b\xae\xed\x9a\xf7\xd6\xce\x11\xb7\xcd\xb9\xfd\xd1\xd6\xd5\x17\xe0\x47\x88\x7a\xa0\x2c\x3e\xa4\xfb\xc1\x23\x51\xf8\x51\x17\xad\x84\x3f\x5f\x85\x8b\x8f\x00\x62\x4e\x82\xda\xc9\x86\xea\xd1\x16\xc3\xd3\x8d\xe1\x11\x04\xec\xc0\xad\x01\x69\x88\xce\xd1\x76\xc0\xed\x8e\x1e\x18\xc7\x8c\x6a\x7f\xf6\x05\xf6\x7e\xfd\xee\xe8\x77\x60\x1c\x94\x47\x1e\x05\x53\x99\x5e\x60\xdd\x3d\x91\x4f\x17\x33\x63\xa2\xc9\x4d\x13\x23\x0f\x81\x21\xf4\x9a\xc8\xa7\x74\xaf\x78\xdb\x84\xb9\x1f\xc9\x7e\xee\xed\xa8\xa3\x10\x8f\xe4\x9d\x2e\x6b\x3a\xc3\x1c\xb6\x44\x21\x9a\x2c\xe8\x8c\xae\x11\xbf\x1a\x3f\xfb\x3a\xcf\x41\xda\xe8\xd5\x74\xfa\x24\x36\x08\x70\x39\xe8\x98\x2a\xec\x3e\x20\x62\x69\x28\xf2\x5b\xe9\x6e\xcf\xa0\xb3\x41\x23\x9c\xe9\xb0\xba\x49\x8d\xfe\x68\x2a\x7e\x8e\x86\x5b\x8e\xb4\x44\x71\x74\xe7\x8f\x93\xf3\x6a\x60\xb3\xe7\xda\x6d\x79\x2e\xc3\x20\xb5\xa6\x37\xaf\xee\x97\xa2\xad\xd1\x65\x16\x01\x35\x2f\xe7\x12\xd3\xd2\xea\x36\x75\xd7\x5f\x54\x0d\x42\x58\x61\x0d\xb6\xd2\x3f\xaa\xd5\x2d\x74\x0b\x3a\x90\x9f\x88\xc7\x06\xbf\x9b\x55\x0e\x93\xcd\x66\x72\xa8\x34\x52\x95\x4a\xfd\x81\x4a\xa1\x92\x6f\x04\x80\xe1\x45\x2d\xb1\x84\xd1\x1d\x2d\x6a\xc1\xc7\x23\xe9\xab\xb3\x04\x04\x2c\x81\xdd\x2a\x07\x76\xa3\xc9\xca\x11\xbe\x3e\x0e\xf2\x26\xac\x24\x51\x3f\xe3\xb0\x97\x2e\x3b\x51\xf8\x11\xbc\x3c\x61\xa9\x55\x20\x28\xea\x05\x62\xc4\x07\xcf\xc0\x8e\x74\x25\x8b\xd5\xa1\xb1\xfb\x47\x31\x2a\x1f\x6c\x15\x8b\x25\xbc\x3a\xf2\x90\xd3\xa3\xd6\xa4\x99\xd2\x6c\x9a\x26\xc4\xa9\x13\x9e\x1f\xa2\xa5\x64\x93\xad\x2c\xd7\x63\x71\x6b\x75\x26\x4b\x6e\x5e\x12\xbc\xd7\x78\x67\x23\x56\xda\x69\xbc\xd3\xd8\x9c\x94\x97\x6b\x31\xe9\xb4\x6e\x8b\x27\xb7\xcc\x36\xdb\x30\x39\x88\x2b\x1d\x9c\x6c\x98\xad\xb1\xa1\x7c\x34\x6a\x8f\x93\x1d\x63\x53\xd3\x1f\x8b\x5d\xe2\x56\x8e\x95\x6a\xc3\x65\xb3\x9d\x19\x41\x5b\x86\xba\x29\x9e\xb9\x56\xd9\xa4\x4f\xf1\xbb\xea\xdc\x59\xbe\xd2\x9a\xf4\xe1\x73\xf6\x5d\xd8\x37\x67\x78\x7a\x4d\xa9\x2f\xcb\x5d\xe7\xf2\xa7\xe8\x4b\xfb\xa3\xaf\xd2\xbf\x54\x9d\x61\x0b\x66\x38\x67\x97\x85\xb5\x7a\x59\x77\xdd\x00\x1e\x8d\x62\x3b\xe1\x49\x88\xf2\x0b\xa5\xc6\x36\x40\x5e\x12\xea\xa1\xd4\xb2\x7a\x48\x49\x34\x5a\x02\xe8\xe7\xd7\xc3\x21\xcf\x44\xd7\xd1\x9b\x6f\xa5\xad\x12\x6c\x19\x0c\x14\xf0\x1f\x80\x7d\x21\x12\x06\x0a\x30\xf3\x16\x9b\x27\x98\x86\x5c\x46\xdf\xc5\x8d\xb8\xe1\x32\x6a\x10\x35\x89\xf8\x20\x76\x8b\xe2\xf8\x4d\x78\x1f\x4b\x90\x55\x1b\x4d\x98\xdc\xbb\x85\x2d\x7e\xa2\x01\xd7\xe5\xbd\x43\xf0\x11\x67\x05\x26\xc1\x0d\x3c\x7e\x4c\xed\x76\x11\x11\x55\x86\xba\x33\x0a\x8b\x9d\x08\x17\x20\x9a\x5b\xed\xe3\xd5\x7c\x56\x92\x5c\x9e\x66\x91\x9a\x56\x7c\xb0\x72\xd3\x17\xfe\x39\xf5\xc6\xdc\x90\xa9\x76\x26\xfe\x1c\xac\x71\xc8\xfc\xfd\x6f\xdf\xd5\xf1\xe7\x47\x7f\x3c\xb3\x37\x08\x82\xbf\xfd\x0b\x18\x6b\x5a\xbc\xbf\x7d\x92\x29\x2b\x49\x67\x96\x6b\xfb\xf7\xd7\xca\x8b\x2b\xb4\x93\x00\xb5\xc9\x94\x65\xd2\x99\x15\xda\x39\x73\xb4\x0a\xb3\x39\xa8\x05\xcf\xf5\x9a\x68\xc8\xcb\x4f\xb2\x30\xd2\x52\x6b\xff\x01\x2b\xdf\x5f\xb1\xeb\x36\xcb\x60\x53\x28\xd7\x58\xbb\xf7\xc2\xde\xf9\x83\xef\x3a\xf3\xd7\x47\xf7\x7f\x69\x7c\xe1\x4b\xf8\xdb\x6f\x92\x5f\xbe\xed\xc9\x1d\x76\x85\xa6\xc2\xdc\x0c\xe8\x66\x73\x30\x43\x61\xbe\xab\x1a\x26\xbd\x95\xae\xd0\x06\xcd\x0f\xbe\xfe\xdb\x07\xcc\x15\x1a\xad\x3c\x05\xf1\x14\x19\x37\x28\xee\x0a\xd9\x87\x9f\x87\xd8\x48\x32\xeb\xe1\xb1\x2a\xe0\x32\x62\x0f\x08\x1c\x36\x7f\xc1\x82\x34\xac\x9e\x9b\x06\x88\x4f\x52\xd6\x8d\xb7\xdf\x7d\x71\x11\x1b\xc1\xf8\x72\x64\x03\x0f\x4b\x2c\xbe\x88\x57\x53\x2b\x63\xb2\x8a\xb9\x2b\xab\x9f\x59\xb3\xe6\x99\xd5\x57\x17\x1d\xb4\xef\xba\x3a\xf7\x85\x95\x93\xfd\x0e\xb9\xc4\x92\x37\x6c\x56\x43\x6e\x8a\xd8\x64\x99\xe3\xce\x5c\xb4\x4f\x9b\xe7\x9f\x30\xbe\xc6\xa2\x5a\x7c\xd7\x8c\xac\xac\xb1\x9b\xde\x5a\xb1\xfc\xcc\xda\x31\x2e\x6b\x8e\x3f\x57\x43\x8b\x74\xe6\xe2\x0c\x8f\x45\xaf\x6a\x74\x3a\xab\xa7\x64\x4b\x5d\xd5\xab\x47\xd5\xdd\x3e\xbe\xa6\x20\x5d\x27\xa5\x15\xa3\xd7\xac\x19\x3d\x66\xcd\x9a\x53\xaa\x27\x97\x0e\x0c\x0d\xce\xee\x33\x72\x78\x83\x57\xa9\xcb\xaf\xf4\x66\x38\xf2\x7b\xb9\x95\xe9\xf9\x29\x56\x1a\x4c\x6f\x30\xe7\xe5\xba\x8a\xf2\xd2\x15\x7c\x60\xcc\xc2\x3b\x26\x0c\xde\xb1\x7e\x52\x69\x71\xc3\xac\x99\x5e\x4f\x4d\x4e\xaa\x54\xaa\x75\xf9\x47\xf9\xd5\x3a\x00\x82\x83\x9d\x49\x2e\x7f\x41\xaf\xd4\xe4\x52\x7f\x28\xd0\xcf\x5f\xe3\x4d\xb4\xc3\x13\xec\xd7\x6f\xda\x3d\x70\xf6\xb8\x4e\x74\xc4\x4d\xb7\x6a\x95\x37\xc8\xda\x13\xa0\x23\xe8\x7e\x15\xee\xe9\x73\xbb\x89\x26\x23\xb9\x4b\x28\x14\x0b\x83\x1b\x3d\x3c\x6b\x77\xf1\x72\x82\xbe\x4d\x80\x58\xd3\x77\x5a\xc3\x53\xb6\x20\x50\x7b\xd0\x02\x1e\xa8\x8d\xce\x44\x5f\x69\x89\xb2\x86\xd8\x35\x9d\xdf\xdd\xa6\x1d\x1c\x06\x99\xed\xbb\x76\xb5\xc3\x4b\xe8\x08\x7e\xc0\x65\x68\xed\x2a\x14\x39\x70\x3d\x0b\xde\xf1\xc4\xae\xf6\xce\xa7\x06\x77\x2b\x7a\x42\xb8\x1b\xff\x8a\x3d\x1a\xde\xd4\x92\xdd\x5c\x98\x87\x12\x73\x00\xad\xbf\xd6\x56\x37\xb5\x0f\xd3\xa3\x7d\xfe\x69\xeb\x04\x12\x6d\x35\xff\x55\x6b\xcc\xeb\xaa\xcf\xff\xa0\x09\x7a\xea\x47\x39\xa9\x72\xc4\x6b\xe8\x88\x41\x33\x81\x57\x07\x88\x81\x27\x5a\xdc\x82\x12\x7c\xe7\xb9\xc8\x88\x85\x43\x82\x27\x3c\xd2\x46\x42\xd8\x6f\x33\x8a\x3e\x71\x30\x3a\x5d\xea\xf5\x70\xaa\x4e\xc7\x38\x44\xe3\x47\x5e\x1f\x3e\x92\xc9\x48\x06\x14\x59\x34\xe1\x03\x95\x9c\x01\xd7\xbb\x8a\x5d\x88\x46\xa3\x23\x86\xe3\x0a\xc3\xb7\x2c\x46\x83\xc1\x68\x01\xa5\x4c\xff\xc8\x75\x86\x4f\xb2\x27\x7a\xdc\xb4\xff\xe6\x06\x25\xf8\x9e\xc0\x14\x2a\x1e\xbe\xff\xf3\xcf\x63\x76\x76\xf8\x64\x20\x08\x45\xbd\xa8\x1a\x6c\x67\x07\xf0\x14\x95\x03\xe2\x3a\xbf\x31\x0f\x18\x68\xee\x72\x33\x1e\xc4\x11\x11\x35\x6b\x67\xbc\xe4\x46\x61\x94\x74\x86\x75\x7e\xac\xe3\xc2\x88\xf0\xa4\xe7\x07\x8c\x83\xe8\x6d\xc6\x3e\x03\xd1\x9f\xc5\x7a\xb1\x39\x71\x94\x7f\x4c\x9f\x49\x29\x55\x8b\xc4\x03\x3c\x1d\x94\x67\x80\x78\x91\x0a\x5f\x83\x69\x66\x07\x6d\xa3\xb3\x8a\xf1\xd1\x99\x0c\x8e\x60\xc7\x17\xc5\x2e\x10\x8e\x9d\x9b\x6c\xb4\xa3\x38\x0b\xdd\x73\x98\xb9\x64\x67\xc7\xea\xf1\x1b\xa6\xe9\xb6\x8d\x79\x58\xd0\x57\x7f\x78\xcc\x36\xdd\xb4\x0d\xe3\x65\x7d\xf3\x1e\xc6\xb0\x5f\x28\x22\xaf\x2f\x83\x5b\x30\x3a\xcb\xd3\xbb\xb7\x87\xde\x87\x82\x91\x36\x3a\xcb\x0c\x8e\x98\x1d\x6c\x96\x19\x36\x25\xa7\x87\x50\x18\xc3\x2c\x34\x91\xe6\xe9\x0a\x1b\x50\x38\x8b\x75\xe0\x8b\x2c\x3a\x9d\xfd\x08\x4e\x05\x2f\x36\xce\xc7\xb7\xe7\x37\xc2\xfe\xe0\xbe\xdc\x12\x1c\x2e\x41\xfd\xdf\x8e\xfa\xe5\x67\x64\x0d\x36\x04\x7b\xc8\x72\x30\x78\xf3\xcb\xce\xd8\x8b\x4c\x46\x22\x5c\x62\x88\x36\x28\xea\x15\x8e\xce\x10\xee\x25\x44\x8e\x94\x10\x22\x60\xdb\x46\x9e\xf1\x76\x86\x70\x0e\xcc\x67\x21\x18\x62\x60\x09\x9f\x04\x5f\x0c\x81\x80\x4a\x2a\x65\x4b\x38\x33\x7c\x71\x28\x9f\xd4\xa6\x96\x4a\x98\xc1\x10\x85\x3e\x57\x91\xd0\xdb\xf8\x84\x52\x82\xfe\x21\x1c\x26\x29\x41\xff\xa1\x7c\x72\x9b\x2a\x96\x32\x16\xc2\xf9\x48\xb0\x38\xea\x06\x05\xae\xb5\x25\xdd\xa0\xe4\x4a\x65\x5b\x12\x7c\x01\x4d\x6f\x6a\x50\x12\x3f\xa3\x43\x5b\x12\x10\xee\x81\x01\x38\x0e\x9e\x89\x9f\xe5\x72\x61\xfd\x39\x1b\xcd\x33\x7b\x63\xf6\x9a\x1a\x62\x71\x6f\xe2\x35\x26\x9e\x91\x30\x1a\x06\xeb\x0a\x02\x34\xfe\x89\xb5\x25\x1a\xa4\x04\x65\x93\xa9\xd9\xb3\x77\xef\x9e\xf5\xe0\x3c\x3c\x07\x8a\x60\xc1\x8d\xf1\x20\x04\x5b\xc7\x53\x37\xe8\xdf\x87\xe6\x1f\x3f\xfd\xcb\xe9\xe3\xf3\x43\xf1\x00\xf8\xd3\x9e\xbd\xcc\xb6\xbd\x7b\x22\x93\xc0\x79\x50\x84\xfe\x9f\x8f\x1e\xa2\x6e\x8c\x87\xa7\xe0\x29\xf4\x00\x68\x41\x63\xf5\xad\xb7\x57\x15\x16\xae\x7a\x1b\x94\xa2\xf1\x5a\x2a\x84\x85\xb1\x99\x79\x83\x62\x2e\x75\x96\x8b\x72\x06\xdc\x9a\x80\x5b\x87\x25\x05\x58\x71\x12\x9d\xe8\xe1\x8f\xa3\x7f\x36\x30\x35\xfa\x15\xfc\xe3\x1c\xb0\x18\x6e\x9b\x03\xb2\xe8\x94\x05\x27\x4e\x80\x79\x27\x4e\x44\xff\x1b\xde\x17\xfd\x92\x7e\x0b\x5e\x9a\x03\x96\x80\x25\x73\xe0\x25\xfa\xad\xe8\x97\x82\x5d\x4d\x4c\xd7\x0b\xcb\x63\xb2\xa8\x42\x8a\xea\x94\x1c\x75\x4a\x90\x44\x04\xcd\x4f\x87\xa5\x5f\x44\x7e\x88\xa5\x5f\x98\x38\xb3\xb1\x3b\x1c\x55\xd7\x5c\x57\xd7\x1c\xad\x23\x27\xb6\xee\x73\x01\xa9\x6f\xad\xa2\xa3\x4d\x67\x43\x3d\x50\xc1\xda\xc8\x39\xda\x14\xbb\xf3\x1e\x4e\x57\xc7\x90\xe4\x75\x30\x2d\x0e\xec\xd7\xaa\xd7\xb6\xa3\x4e\x6e\xd6\x6b\x39\x74\x7a\x39\x16\x4d\xe4\x46\xcc\x8d\xfe\xa2\x28\xf7\x22\x91\x92\xa8\x51\x49\x53\xb1\x3f\x18\xec\xf6\x45\x97\x05\x40\x21\x26\x4f\xfe\x22\x80\xdd\x3e\x48\x40\x21\x0e\x9b\x9a\x99\xa4\xc8\x7d\x5a\x25\x3f\x0d\x9c\xa3\xf7\xc0\xe7\xa2\x3f\xbe\x09\x8b\xde\x14\x17\x71\x05\xd3\x78\xa5\x36\x72\x1f\x93\x44\x2e\xc5\x4c\x30\x22\xa1\x97\x2a\x72\x0c\xa0\x38\x22\x11\x8d\x8d\xde\x47\x4f\x35\x45\x37\xc2\xf7\x0c\x39\x8a\xe8\x9d\xcc\x3f\xd0\x95\x29\x41\xde\xd6\x86\xbe\x04\xde\x75\x29\xc4\x7e\x51\x7d\x0e\x40\x6c\xc8\xdd\x18\xf0\x8a\x20\x4c\x72\x7a\xbc\x5c\x17\xd4\x27\xd3\x05\xe5\x49\xc1\xed\x07\x9e\x2c\xd0\x5c\x7a\xe4\x08\xd3\xb7\x79\xeb\xe6\xeb\x4d\xa0\xf1\xda\x9e\xb5\x30\x93\x60\x1b\x84\xa7\x8c\x86\xd1\x17\x56\x9c\x2b\xd3\xd5\xe9\xca\xce\xad\x78\x01\x46\x47\x4f\xf9\x11\x1c\x02\x5f\x83\x43\x3f\xd2\xad\x6d\xd1\x0b\xe3\x32\x68\x30\xb1\xb6\xa9\x7e\x12\x00\xb7\xb7\xb5\xbe\x7c\x6c\xfa\x9a\x43\x9f\xce\x6c\x04\xa0\x71\xe6\xa7\x87\xd6\x4c\x3f\xf6\xf2\xfb\xc2\x64\x10\xc7\x6e\x88\xcb\x4f\x84\x75\x96\x8e\xca\x44\xfc\x80\x60\xf3\x6d\x70\xf8\x74\xc4\x13\x99\xbd\xeb\x47\x44\xfd\xc0\xcd\x13\xe3\x93\xd8\x14\x87\x56\x66\x1c\xfa\xeb\xa1\xb7\x47\x33\x91\x48\x84\xf9\x09\x3e\x06\x46\x60\xb5\xdc\x68\x13\xe3\x96\x8b\x6d\x70\xd3\x07\x1f\xc0\x4d\x36\xb1\x5c\x2e\x66\x2f\x89\xd1\x92\xed\x45\x38\x8b\xde\xfa\x09\x3a\x7c\x31\x32\xd8\x91\x19\x1c\x39\x32\xc8\x5e\x0a\x8e\xa4\x17\x84\xc3\xd4\x8d\x35\x6b\x20\x46\x3f\xa0\x84\x70\xe4\x41\xfc\xc4\x0d\xea\xb1\xc7\xd0\x98\x14\x77\x64\xa2\x3c\xd8\x09\xfb\xf6\xed\xd3\x77\x3d\x36\xb2\x9b\xce\x4a\x1a\x9e\x95\x40\x6c\xc3\x5e\x94\x06\xb0\xb6\x8e\xc9\xca\xe2\x7d\x53\x1c\x43\x03\x0f\x47\xbb\x6d\x72\x14\x8f\xc1\xd9\x0c\xc0\x01\x94\xb4\x87\x66\xc2\xcd\x25\x5b\xcf\xa7\x67\x8c\x96\xba\xdd\xc1\x69\x8d\xbe\x5c\x09\x9b\x5b\xbf\x78\xd1\xee\xda\xfd\x00\x14\xf9\x2c\x83\xde\x83\x0d\x75\x0b\x86\xf5\x2a\xf3\xd4\xba\xd1\x30\x3a\x0d\x7c\x57\xef\x6c\xb0\x72\x4a\x85\x02\xf4\x69\x86\xdf\x18\xb7\x36\x9f\xd8\xfb\x12\x7d\xfe\x77\x0d\xef\x2c\xd6\x69\x32\xd5\xd6\xb4\x9c\x69\x1b\x26\x0c\xd7\x88\x87\xdf\x79\x7c\xdd\x12\x5b\x95\x88\x49\xcf\x30\x94\xa1\x91\xbf\xba\xf7\xba\x43\xf7\x5e\x79\x13\x14\x6d\x19\xd0\x72\xf2\x91\xaf\x8e\xff\x69\xd9\xf0\xe1\x26\xf8\x22\x48\xa5\x93\x94\xb4\x6d\x24\x95\xa0\xdb\x96\x4f\x76\xb0\x88\x87\x79\xca\x03\x78\xd6\xe6\x74\x29\xc9\x5e\xb2\x92\x46\xf4\x95\x28\x20\x20\x0a\x1a\xf0\x62\x75\x72\x6f\x51\x20\x88\xa1\xef\x69\x37\xe6\xf1\x63\x23\x92\xed\xb1\x16\xe9\x89\x52\xd4\x73\xad\xc2\x4d\x95\xe7\x99\x61\x07\xfc\x16\x76\x98\xf3\xe4\x29\xe6\xd7\xe7\xd2\x29\x66\x8b\x44\x6a\x4c\x96\x28\x73\xd5\x62\xbf\x26\x5b\xe3\x17\xab\x73\x95\x92\x64\xa3\x54\x62\x31\xa7\xd0\x73\x5f\x37\xc3\xe7\x89\x80\x93\xde\x3a\xff\x55\xf4\xe4\x17\xb0\xe3\xd5\xf9\xf3\x5f\x05\x1c\xb0\x02\xee\x55\x58\x0b\xcf\xc0\x2f\xcf\xad\x58\x71\x0e\x58\x40\x09\xb0\x90\xd0\x99\x5b\xad\x7f\x46\x14\xa7\x88\x82\x41\x51\x4a\x71\x9e\xc8\x23\x3f\xfc\xe9\xe8\xfe\x86\xe4\x02\x29\x9b\xa5\xdf\xba\x7c\xf9\x56\x7d\x16\x2b\x2d\x48\x36\xf4\x1f\xfd\xe9\x61\xb9\x47\x74\x94\x88\x53\x17\xf4\x78\x13\x0e\xcd\x59\x71\x0e\x7e\xd9\xe3\x85\xb0\xe0\x56\x6a\x68\xa8\xd7\x57\x23\xfa\xfd\x72\xac\x8d\x07\xa0\x18\x23\x31\x87\x21\xab\x1f\x1d\x81\xb5\x77\xc7\x34\x38\x51\x7b\xa2\x6e\x2f\xf2\x00\xa2\x93\x8b\x11\x1a\xd1\xe4\xe6\xa4\x05\xa5\x69\x3d\x28\x0a\x90\x55\x05\xb6\x2d\xc4\x7a\x82\x46\x6e\x55\x35\x97\xcb\x96\x67\x89\x98\xdc\x52\xc6\x71\x77\x60\xcf\x1d\x63\xcf\xee\xdc\x34\xfd\x8e\xe5\x0f\x02\xf1\xde\x67\xed\x8d\x65\x9c\xed\xaf\xe6\x6a\x2b\xf8\x36\x43\xae\xc9\x39\x0b\x16\x65\xed\x69\x6e\xde\x33\x33\xf2\xd1\xac\x31\x5b\x77\xbd\xba\xa7\x63\xd7\xe2\xad\xbd\xcf\xd2\xbf\xf4\xcb\x8f\x5e\xce\x2e\x01\x4c\x9f\x5c\xf0\xb8\x78\xc1\x9a\x4b\xf7\xdd\x31\x6d\xd3\xce\x73\xe3\xee\x5c\x98\x02\x72\x47\xfd\xc6\xca\x55\x35\xa6\x5e\x34\xf1\x5a\xf8\x95\x21\xbf\x4f\xd1\xb7\x7a\xf0\x68\x33\xce\xa6\xfd\xb5\xf2\xad\x8b\x77\xb5\xef\x79\x65\xcf\xd6\xc6\xb9\x3b\xcf\x52\x3d\x7d\xfc\x0e\x26\xbe\xe0\x7a\xf8\xf8\xc5\x28\x01\xbc\x92\x16\x36\xbb\x49\x74\x90\xf9\x7f\xd5\x7d\x09\x7c\x1b\xc5\xd9\xf7\xce\xec\xa5\xfb\x5a\x69\x65\xdd\xb2\x4e\xcb\x87\x64\x4b\xb2\xe4\xdb\x8a\xed\x38\x89\x1d\x27\x8e\x73\xc7\x89\xe3\xdc\xf7\x09\x39\x49\x88\x21\xe4\xe0\x86\x04\x52\x20\xe4\x6a\x80\x70\xb6\x25\xd0\x70\x15\x1a\xa0\x25\x94\x16\x48\xb9\x1b\x5a\x9a\x04\xde\xb6\x94\x12\x28\x94\xb6\x90\x68\xf3\xcd\xcc\xca\x8e\xed\x84\xd2\xbe\xef\xf7\xfe\x7e\xdf\x97\x58\x3b\x3b\xb3\xb3\xb3\xb3\xb3\xcf\xcc\x3c\xcf\xcc\xf3\x3c\xff\x34\xf1\x6b\x41\x60\x8b\x88\x36\x4b\x54\x56\x32\x81\x5e\x1d\x34\xb8\xa1\xb7\x0e\x22\x96\xb3\x3f\x7f\x4b\x2f\xcf\x41\x14\xef\xc7\x6e\x79\xdc\xb5\x45\x21\xaf\xcb\x4a\x62\x16\x47\xc2\xe3\x2a\x2f\x9e\x98\xac\x08\xbb\x12\x4a\x83\x5a\xb1\x58\xc5\xf0\xeb\x3f\xbc\xea\xfd\x33\xd2\xb9\x4f\x1f\x9a\x3b\xf7\xa1\x4f\x01\x43\x42\x70\xeb\x60\xa6\xb8\xbd\xb7\x44\x13\x38\x1d\x6f\xaf\x72\x5b\x4c\x66\xa7\x9e\xec\xe3\x35\xf9\xab\x03\x7e\x83\xd6\x16\xf0\x14\x56\x3b\xcc\xf5\x1a\xae\x83\xb7\xab\x8e\x3e\x06\x1a\x51\x71\xfd\x8b\x95\x9e\x18\xc4\x4a\xa3\xf6\x08\x9f\xa7\xd9\xc9\x44\x3e\xac\x43\x5c\x4b\x37\xb6\x91\xed\x5d\xcd\x41\x2d\x10\xc2\x08\x61\xa8\x6f\x79\x80\x40\x13\x5d\x0d\x22\x0d\x3b\xb0\x76\x0f\xe9\x73\x48\x48\xa4\x05\xd9\x27\xa7\x07\xf0\xd8\x07\xa3\x07\x13\x04\x26\x8f\xb0\x1f\xfb\xf2\x21\x80\x7a\x58\xa5\x03\x88\x58\x35\xa8\x1c\xfc\xa0\x67\xea\xd4\x9e\x4e\x70\x43\x4d\xa3\x4e\xba\x95\xd7\x31\x34\xaf\x5e\x0f\x0e\x34\xda\xf4\xda\x78\xb9\xcb\x46\xc3\x17\xd9\xf1\x7e\x46\x65\x32\xf3\xbc\xe0\x31\xaa\x99\xe8\x9b\xd6\x29\xad\x5e\x70\x3f\xcf\x23\x66\x4a\x5a\x52\xd4\x99\x97\x17\xe0\xd4\x31\x7f\x5d\x01\xf6\xb5\xb6\x81\xde\xe9\xa1\x95\x6a\x33\xb7\x52\xfa\x25\xad\xa0\x69\x35\xf3\x8b\xce\x21\x99\xce\xce\xcc\x90\xac\x3f\xee\x17\xad\xe0\x88\x86\x87\xb4\x42\x7b\xbd\xb4\x57\x4a\x1f\x2d\xb4\x73\x76\x9b\xb6\xc6\x61\x84\x93\xc1\xfe\x7b\x3e\xc8\x0b\x08\x5a\x00\x69\x8d\x39\x4f\x0f\x11\x3f\xba\xd1\x57\x90\xfd\x07\xab\xa1\x81\xf6\xbe\x15\x27\x2b\xd2\xd3\xbc\xcd\x0e\x51\xe3\x15\x0c\x4a\x30\x5d\x7a\xa4\x4c\xc1\x42\x56\x1d\x51\x3d\x0c\x3e\x06\x0c\x84\x4a\x05\xf1\x7d\x46\x53\x1f\x2a\x29\xc6\x89\x46\x5a\x35\xe2\x9e\xcb\xa8\x56\x6a\x0e\xb5\x09\xcf\x70\x34\x9b\xcc\xd9\x00\x01\xa1\x0f\x5d\x82\xc8\x04\x21\x19\x6e\x0d\x73\x00\xfd\xe6\x08\x44\x73\x34\xef\xc7\xee\x33\x93\x51\x3a\x9c\x70\xd3\x9e\x7f\x23\xc5\x0a\xfe\xf9\x10\xa0\x27\xcd\xe9\x4e\x25\x3b\x17\x67\x5f\x00\x82\xee\x3d\x9d\x20\xfd\x2e\xad\x32\x49\x5f\x59\x04\x2d\x2c\x56\x9a\xc0\x48\x9d\x99\xae\x3e\x7b\x4c\xfa\x42\x67\x36\xeb\x80\xe6\x65\x70\x07\xd0\x3b\x6b\x8b\x12\xa1\x4a\xbb\x01\x00\xa0\xb3\x57\x84\x8a\x22\x75\x2e\x23\x7c\x0a\xa5\xd7\x5d\x48\xb7\xf5\xa6\x1f\xc9\xe5\xaf\x18\x98\x0e\xa0\x1b\x28\xef\x9b\xb8\x50\xda\xb0\x12\xbc\x92\xd5\xe0\xd2\xeb\xc6\xe8\x03\x46\xf8\x95\xce\xfc\x92\x74\xe5\x6f\x51\x1f\xfa\x9b\xce\x2c\xcd\x56\x07\x16\xcd\x58\x53\x54\xb2\x66\x41\xa7\xc3\xa1\x70\x75\x4e\xdd\x5c\x1d\x5b\x3b\x6f\xb2\xdd\xfe\x1f\xa6\xcb\xfb\x9f\x6c\x0f\xfb\x05\xd5\x42\x4d\x45\x12\xca\xd5\x68\x5a\xc0\xc0\xf7\xd8\xa9\x3e\x01\x67\x0c\xa3\x36\x09\x25\xd3\xd8\x91\x07\x59\x81\x24\x68\xe9\x30\x67\xdd\xce\x13\x67\x79\x58\x24\xb4\x5e\xd0\x54\xab\x03\x02\x1a\xb3\xe4\xa5\x1d\x44\xef\x56\x11\x11\xaa\xe8\xc3\x85\xe0\x05\x20\x92\x62\xe0\xe5\x04\x24\x52\x86\x72\x49\x68\x96\xe0\xe1\x02\x3b\xe2\x2c\x14\x4a\xa5\x3e\x60\xed\xca\xf3\x69\x39\x15\xab\x00\xc1\x20\x50\xb0\x2a\x4e\xeb\xcb\xeb\xb2\x06\xf4\x4a\xa5\x02\xc0\x80\x7d\xa2\xd7\x8c\xe4\x8a\xca\xd1\xf5\x2e\x0f\x47\x97\x85\x42\x65\x15\x8e\xfa\xcb\x69\x3a\xe3\xb3\x99\xbd\x13\xf7\xd9\x43\x42\x30\x88\x31\xff\x5a\x5b\x2d\x4f\xa6\x4c\x82\xb0\x7c\x39\x8e\xed\xda\x75\x10\x47\xa6\xcc\x98\x31\x05\x47\x97\x5c\x7e\xf9\x92\x3b\xd5\x5d\x6b\x95\x4c\x89\x43\xa1\x53\xab\x59\x8b\xe0\x62\x7a\xa4\x1e\x0c\x09\xc9\xaa\xd5\x3a\x85\xa3\x84\x51\xae\xed\x52\x8b\xb5\x1a\x85\xc9\x18\x1b\x9f\x6e\xd4\xf0\x8b\x4e\x48\x5f\x9c\x58\xb4\x3e\xdc\x19\x00\xc0\xa4\xd0\xd4\xd2\x87\x42\xe5\x42\x10\xbd\x29\x86\x2c\x6c\x7d\xab\x55\xf8\x31\xc6\x99\x5b\x09\x6a\x56\xe2\x84\x5d\xd2\xa4\x5d\x2f\xe3\x84\xce\x3f\x03\xea\xcf\x9d\x38\x69\x09\x9a\xf2\x7e\x25\xfd\x89\xf8\x49\x37\xe3\x83\xa2\xa7\x8f\xd7\xf5\x10\x6c\xa3\x34\x55\x8f\xe6\x62\x8c\xa7\x35\x1d\xcd\xc7\xcb\xa8\x35\x88\xf2\xb7\x51\x37\x53\xdf\xa3\xf6\x11\x3b\x7b\xb2\xa3\x12\xc8\x85\x30\x17\x0e\x4e\xff\xd6\x7c\x83\x76\x34\xbf\x2d\xfe\x5d\xe1\xb7\xdd\x0f\xa0\xec\xb9\xf8\xfb\x24\x90\xff\xe0\xf7\xfb\xa7\x65\xbf\x7f\x71\x8e\xaf\xbd\xc4\xcb\x32\x5c\x4e\x02\x69\xf9\x25\x62\xac\x1c\x64\x07\xc4\x2e\x99\x33\x17\x03\xdd\x5d\x17\x9e\x00\xe5\x40\xea\xba\x38\x6d\x40\xe4\x9c\x6e\xbf\x7c\x37\xfe\x03\xb7\x5c\x1c\x39\x2b\x07\xf4\x80\xd8\xa5\x32\xca\x7f\x39\xdf\x65\xdc\x39\x8e\xea\xf3\x08\x3f\x92\x1a\x47\x2d\xa0\xae\xa0\x6e\x40\xac\x40\xae\xd5\x52\xbd\x48\x99\x80\x07\xbd\x16\x54\xf2\x6c\x49\x5b\xfa\x8c\xa5\x52\x04\x56\x0d\x77\x3d\x62\xed\x43\xd6\x1b\x89\xbc\xd7\xdb\xf6\x41\x39\x4d\x56\xea\x90\x97\x23\xbd\x62\x50\xc6\x9d\xc3\x0c\xaa\x8c\xbf\x26\xb2\x62\xaf\xee\x66\x2e\x41\x96\xfb\xff\x40\x8e\x63\x01\x35\x05\x49\xac\x8f\x90\x08\xfc\xd8\x9a\x0c\xf8\x3d\xae\x90\xfe\xd4\x3e\x2c\x89\x2f\xdc\x65\x4d\x04\x7c\x05\xe1\x80\x8c\x99\x80\xf2\xf4\x62\x37\x64\x49\x7e\xd0\x8c\x82\xcd\xd3\xa6\x5e\x83\x82\xd7\x40\xe0\x35\x70\x1d\xe1\xe7\x84\x7c\xbe\xe9\x6e\x8b\xc2\x60\x4c\x5a\x9e\x00\x41\xa5\xc5\xa6\xd6\x14\x1b\xa6\xbe\x2a\xf2\x06\x43\xd2\xf2\xc9\x7d\x64\xd1\xe1\x2e\x79\xe9\xa1\xe4\x3c\x35\x05\x50\xdb\xe4\x08\x55\x3d\x6b\x52\x2c\xe2\x0f\xd5\x35\x44\xf6\x9d\xc2\xab\x32\x0b\x2b\x67\x8c\x2f\x0d\x47\x93\x33\xd2\x32\x8a\x0a\xae\x53\x0e\x18\xe2\x7d\x72\x0b\xd1\xf6\xc0\x2e\x1e\x71\xb8\xe3\xb5\xd7\x6e\xc6\xac\x9d\x28\x1c\x5e\x85\x1e\x84\x2a\x70\xed\x16\xc2\xea\x9d\xd9\x8d\xa2\xe8\xe9\x39\x3d\x5c\xfa\x3c\xa5\xc8\xe6\xf4\x2c\xe6\x51\x3f\x22\xfc\x7c\xce\xf2\x9d\x70\xbb\x29\xec\x81\x2b\x46\xac\x6b\x72\xe0\x8a\x78\xf6\xd1\x11\xd3\x6f\x3e\x2e\xab\xc4\xe2\x16\x8d\x13\xcd\x7c\x34\xdf\x85\xc2\x41\x19\xea\x0f\xa3\x64\x0a\x29\x53\x3a\xe5\xc6\xa6\x49\x7c\x2a\x87\x89\x87\xce\x88\xc7\xfc\x20\x71\xcc\x47\x73\xb2\x36\x3b\x5e\x05\x4f\xf7\x7e\x2b\x72\x2e\xf3\x88\x75\x44\xcd\x20\xed\xeb\xbb\x90\xc8\x25\x57\x43\xd1\xca\xe2\x41\x99\x51\x54\xdb\x8c\x75\xc1\xf2\xd6\x80\xca\x57\x1a\xac\x33\xda\xe0\x65\xbd\x67\xd5\xb9\x2b\xd2\x04\xe3\x48\x7f\xdd\xf0\x44\x29\xad\xa5\xa7\xee\x29\x30\x3a\x02\x26\x8b\xc5\x14\x70\x18\x0b\xf6\x4c\xe5\x0c\x4e\xe9\x83\xcf\x74\xfa\x02\xe3\x7e\xb5\x4e\xfc\xf5\x6d\xc6\xdb\xd7\x79\x46\xc7\x79\x4f\x73\xec\x8a\x5b\x0a\xea\x19\xb6\xb4\x60\x5c\x6b\xb4\xfc\xb2\x79\x01\x3b\xfd\x68\x5f\x0e\xbb\xbf\xc4\x65\x93\xf3\x30\x8a\x40\xba\x7f\x2e\xd3\xbf\x78\x14\xd0\x39\x81\x1f\x3f\x0b\x66\x60\xb9\x2f\xdc\x5a\x5e\x91\xaf\xf0\x84\x7d\xe5\x57\xe7\x42\x48\x52\x81\xc9\x6f\x37\x7a\x8c\x60\xf6\xd8\x40\xab\x51\xa9\x34\xb6\x06\xc6\xce\x86\xd0\xb1\x96\xf7\x83\x8c\xb5\x4c\xbb\x06\xa8\x77\x03\xe3\x6c\x1b\x5f\x37\xca\x5e\x3d\x74\x9c\x11\x3d\x1b\xd5\x53\x55\xa2\x8a\x9b\x5a\x37\x48\x47\x71\x0e\xe9\xab\xdd\xd2\x67\xb3\x45\xbf\x47\xce\x01\x4a\x03\x7d\x39\x02\xdf\x52\xf6\x00\x9b\x63\x81\x6a\x42\x3c\xec\x54\xbc\xdf\x4d\xb4\xa3\x42\xde\x3e\x3d\x29\xc4\x9c\x12\x6c\x0a\x12\x23\x3d\x11\x89\x76\xb9\x7e\xca\x11\xf5\x7f\xb9\x9f\xd2\x78\x8f\x04\x71\xf1\xbd\x76\x77\x18\x6f\x87\x0e\x85\xb1\xaa\x1b\xe3\xc5\x1d\x44\xfa\xed\x6b\x28\xb8\xe6\xc9\x6b\xe6\xe3\x2e\x84\x09\x9e\x40\x9b\x04\xc2\x05\xbe\x40\xc2\xba\x6b\x21\xa6\xe1\x7d\xa7\xf4\x21\x97\xc7\x1f\x48\x5a\x3b\x77\x67\x5f\x38\x9d\x7d\x56\xe3\xd3\xdc\xaf\xd1\x70\x19\x74\xf8\xd8\x3e\xac\xe1\xaa\xce\xd7\xb5\x3e\x78\x34\x47\xee\x3b\x72\xe4\x0f\x3e\xc4\x70\x3c\x38\x22\xf7\x93\xf4\x8c\x64\x34\x5c\x3a\x7e\x46\xe5\x42\xb2\xac\xb9\x2f\xd2\x50\x17\xf2\x47\x62\x93\x66\x55\xa3\xde\x93\xbd\x01\x17\x8b\x4a\xf5\x69\x38\x0e\x1d\xb5\x1f\xdb\x86\xdd\xb9\xa0\xf3\x75\x4d\xff\x35\x7c\x33\x35\x89\xa0\x2e\x61\x08\x0f\xd9\xcf\x78\x6e\x8f\x07\x6f\xf1\xe7\x58\x81\x30\x66\xe5\x31\x4b\x00\x89\xed\xbe\xac\x85\xee\xf7\xe1\xbd\x0e\x34\x3f\xe2\x1e\x95\x73\x7a\x52\x47\x7c\x89\xe7\x14\xc6\x13\x17\x7b\x47\xa3\x67\x6a\x11\x43\x88\xb8\x42\xb3\xba\x2a\xd9\xdc\xe4\xb4\x3a\x8d\xe0\x0f\xa3\xb4\x16\x6d\xe7\x36\x48\x97\x7d\x91\x57\xdc\x75\x7b\xcb\x81\x9d\x36\xc0\x88\xba\xd6\x92\x42\x8b\xcb\x2d\xf2\x79\x43\x3d\xfe\x4a\xdb\xbc\x89\x1d\x3b\x26\x5b\x38\x81\xa5\xd5\xab\x97\x94\x8e\x06\x34\xab\x7c\x72\x80\x71\x5e\xd6\xd1\x18\x7f\x39\xae\xa6\x01\x9c\x95\x99\xf4\x70\x48\x97\x2f\x55\xea\xae\x60\x15\x6d\x50\x3c\x3d\xe4\x63\xce\x78\xeb\x4f\xa6\xef\xd8\xcb\x41\xdf\xd8\xe4\xcc\x58\x5e\xcc\x6b\x43\x9d\x93\x17\x5d\x4d\x1d\xbe\x49\x8b\x17\xee\x68\x17\x27\x8b\x1a\xae\xc6\x04\x94\x50\x3f\xd0\x4c\x0f\x71\xa9\x41\xc4\x43\x9d\x60\xcf\x53\x36\xc4\xa7\x52\xc4\x5f\x1d\x92\x68\x20\x06\x66\x41\x0d\x84\xad\x74\x4c\x32\xfa\x6a\x58\xbe\x42\x5a\x91\xf6\xfb\xfa\x60\xd2\xcd\x98\x80\x70\xd3\xd0\x69\x44\x6c\x85\xb2\x4a\x17\x41\xd1\x4c\x78\x8d\x66\xc8\xcb\xae\x81\xdc\x00\xfe\x89\xd1\xba\xac\xe1\xf0\x82\xc5\xc6\xc0\xd0\x18\xe3\xd4\x98\x55\xd0\x90\x31\x08\xf0\x0b\xbd\x82\x13\xdb\x33\x9e\x43\x4f\xea\x39\x95\x4b\x61\xed\xda\x7c\xb8\x7b\xdb\xbe\xf0\xc4\x54\xe8\x1e\x90\x1f\x8d\x7a\xf3\xbd\x25\xed\xe5\x45\x22\xcb\xab\x54\x2a\xf0\xe1\x37\x43\xaf\x78\x76\x69\x32\x05\x56\x8f\x64\xe9\x39\x07\x27\x88\x1e\x61\x3d\xf3\x7a\x9e\xcb\xa3\xb7\x56\x49\xff\xb8\xb6\x78\xec\xa8\x18\x00\xac\x46\xd5\x06\xca\xdb\x3a\xb3\x87\x78\x2d\xa0\x0d\xca\x69\x0a\x21\x70\xbd\xa7\xf3\xd1\x3b\xba\x0e\x6d\x2f\xef\x59\xd0\xe8\x04\xd6\x70\x7c\x78\x28\xbf\xa0\x7e\xda\xea\xee\x42\x25\xa4\xc1\x57\xa7\x17\x9f\x7e\xe1\x46\x41\x29\xdd\x31\x53\xfa\x7e\x80\xae\xac\xd3\xf2\x3f\x45\x34\x04\xd0\xfc\xb7\x89\x3d\x4b\xd5\x52\x1d\x88\x8f\xa1\x30\x6a\x2a\x5e\x46\xc0\x52\x30\x2a\x39\x47\x48\xd8\x67\x0b\xf6\x50\x52\x02\xe4\xb1\x0d\xb0\x41\x72\x82\x1d\xe7\x58\xe3\xb2\x81\x1c\x16\x90\x78\x6b\x0c\xd2\xbd\x8a\xec\x1e\xec\xaf\x8e\x13\x81\x80\x17\x81\xf5\x00\x5b\xbf\x93\x71\x9a\xa7\xe5\x2d\x45\x25\x90\x43\x21\x17\x17\x50\x0b\xe2\x4c\xa9\x34\x22\xb2\x7a\xaf\xe3\x83\xda\xb2\x1d\x05\xea\xe1\x5c\xcc\x9b\xfd\xab\xb4\x5f\x19\xae\x4c\x85\x00\x23\x65\x22\x95\x10\xd6\x84\xc1\xd3\xd9\x7f\x44\xe2\x1c\x57\x19\x54\x81\x53\xd2\x81\x50\x29\xc7\xa5\xfc\x9c\x0e\x1c\xfd\x0d\x60\x80\x55\x6f\x7e\xda\xaf\xb3\x39\x2c\x4f\x9f\x60\x03\x67\x00\x0d\xf2\xd4\x5e\x4f\x8b\xe3\x26\xc8\x01\xaf\x89\xbe\x57\xcf\xe8\x4b\x35\xe9\x85\x30\xb2\xa3\x3c\xf3\x81\xaf\x30\x11\xfc\xc4\xa6\xf3\xe5\xb7\xe5\x01\x95\xf4\x8d\xc5\x12\xf4\xb7\x9a\xff\xba\x5d\x6f\xf1\x05\x47\x19\x9f\x9f\xa3\x70\xe7\x01\x0d\xac\x88\x84\x2b\xe8\xe9\xa6\xdb\x0a\x2a\x1f\x8c\xd6\x48\xb3\xbc\x45\x4c\x85\xb7\xa2\x20\x98\x62\xbd\x35\x91\x70\x12\x64\xd8\x4c\xc4\x5f\x52\xd3\xa5\xaa\x0f\x06\x4a\x60\x77\x10\x44\xb5\x1b\xad\x63\xf2\x43\xaf\x6c\x0c\xc2\x10\xe0\x00\x0b\x3c\xa3\x6c\x56\xb5\x73\x27\x60\x61\xc9\x62\x70\x48\xfa\xfb\x88\x96\xf7\xab\x9d\xa9\xba\xd8\x83\xb5\x85\xb7\x59\x83\xa0\x22\x7f\x0c\xe2\xba\xbd\xd2\x7e\x70\xcc\xdf\x2e\x98\xf2\x7c\xd2\x54\x30\xc6\x3f\xca\x28\xd8\x43\xd2\x8c\x9f\xe9\x59\xb3\xe1\x64\xa4\x06\x54\xca\x63\xa0\x9b\xa7\xd8\x99\xe8\x6b\x4d\x43\xf2\x00\x62\x61\x82\x32\x78\x01\xa2\x47\x0e\x4d\x85\x78\xad\x95\xd8\x9a\xa4\xb0\x36\x87\x48\x46\x04\x22\x8b\x22\xf1\x1d\x12\x97\xff\x76\x20\x47\xc3\x68\xd6\xc3\x10\x5d\x7e\x6c\x9d\x4b\x13\xc0\x02\xc1\x1c\xb4\x06\x04\x18\x24\x6e\x1a\x28\x4c\xf1\x62\x6e\x24\x45\x9f\x2d\x18\xb6\x82\xd1\x90\x99\x70\x6f\xa5\x85\x61\x54\xbc\x8e\x33\xc1\x27\x81\x66\xa9\xf1\x72\x8d\x49\xb5\x61\xea\x6c\xa0\x02\xaf\xef\x34\x9b\x3b\xcf\x7f\x0f\x25\xa9\x05\xd5\x86\x8c\xd4\xc4\x57\x45\xe8\x7f\x9e\x51\x6a\xab\x2b\x69\xa9\x22\x5c\x94\x07\x36\xa8\x75\xd7\x32\x0b\x4f\x16\xfb\xa0\x97\xff\x11\x9d\x2c\x03\xc6\x47\x1f\x97\x3e\x6e\x1c\xde\x25\x2d\x75\x9a\x27\xac\x77\x16\x38\x0f\x5f\x69\x06\x1d\x4a\xfe\x71\x58\xf9\xa3\xa9\xee\xb0\xd2\x6c\x30\x6b\x44\x85\x95\x3e\xbb\xf2\x25\xad\xa0\xca\x18\xfe\x4b\x90\x3e\xfd\x93\x67\xa4\xe7\xa6\xdf\x67\x5e\xd2\x9a\x95\x28\x61\x0d\x9d\xe4\xf3\xac\xac\x94\x92\x86\xd3\x48\xe6\xe5\xe9\x11\xce\x82\xa2\x6c\x23\xa3\x2a\xe6\x7e\x0e\xf6\x94\x97\xd3\xc5\x1a\xe9\x29\xd5\xdc\xce\x65\xc0\x04\x2c\xcb\x33\x0f\x4c\x5d\xf8\x2c\xac\x2e\x70\xae\x9f\x60\x76\x3a\xcd\x57\x1e\x36\x32\x7c\xaf\x1e\xd9\xf7\x18\x89\x5d\x80\xb8\xfc\x18\xc1\xcb\xc5\xa3\xa9\xac\x5e\x4a\x06\x01\x2b\xc7\xe7\xd4\x71\xbd\x58\x72\x4a\xa5\xc5\xb0\x19\xea\x81\x2f\x8c\x61\x9e\xc2\x62\xd8\x12\x0a\xbb\x91\x60\x85\x17\xdd\xb0\x5a\x91\x3c\xfc\xe2\x81\x54\x06\x56\x62\xec\x3b\x6f\xfb\xc3\x9f\x76\xec\xdc\xfe\xc5\xce\xee\x09\x5e\xbe\xa1\xed\xd0\x87\xa7\x40\xc7\x49\x6f\x43\x65\xe4\x57\xfb\xf6\xe9\x5c\xf9\x63\x37\x0d\x2f\xd1\xd3\xe9\xf4\x88\x2d\x93\x96\x64\xc7\xb6\x9d\x18\x2e\xc0\xc2\x17\x17\xf9\x7d\xf6\xe8\xb2\xea\x2e\x47\x4b\x9e\x77\x05\xf8\xc1\xbb\xfb\x0e\x1c\xd8\xf7\xee\xce\x7f\xec\xf0\xd4\x65\x9c\x7f\xbf\xff\xc1\x4f\x3f\x7d\x70\x72\x9b\x36\x30\xb3\xf5\xa8\xf4\xda\x6c\xc0\x7a\x6f\xbc\xff\x8d\x1f\x76\x0e\xf5\xed\xff\x3e\x7c\xe7\x74\xf5\x79\xe9\xa9\xd6\xb5\x9b\x82\x42\xd7\xad\xb6\x54\x75\x70\x9c\xbd\xd8\x6d\x18\x5f\xb5\xe0\xb6\x25\xb5\x6d\x8b\x7a\xfd\x63\x91\xb9\xc3\x4e\x45\xa8\x28\x9a\x4f\xc7\x11\x0f\x1e\x44\x7d\x8c\xcb\xb9\x0b\xc0\x38\x19\x04\x25\xd9\x9b\xa2\x09\xe0\x15\x2f\x56\x83\x94\x11\xcf\x16\x61\x91\x4d\x12\x8d\x03\x02\x72\x88\xdf\x38\xc7\x8a\x0d\x9a\x2c\x18\xbb\x33\x52\x2c\xde\xf5\xa7\xdd\x77\x5f\x56\x5e\xc2\x58\x6b\x86\xdc\xf5\xfa\xeb\x20\xf9\xfa\x61\xa8\xf2\xc4\x27\x56\x5a\x2c\xaa\xf7\x43\x4c\x7b\xd5\x54\x70\x55\x22\x32\x76\x68\x7b\x5e\x8c\x96\x53\x70\x26\x00\xb4\x98\x93\x8d\x36\xb6\x9d\x0d\x36\xb6\x6d\xdb\xb6\x6d\x9b\x1b\x6f\x6c\xdb\xb6\x9d\x8d\xed\xe4\x8f\xff\xd8\xc9\x1f\x77\xda\xe9\xbd\xb7\xd3\xce\xb4\x7d\xf9\xce\x37\xdf\xcc\x79\x39\x4f\x67\x0a\x0b\xdb\xd5\x54\xb5\x89\x86\xf9\x9f\x09\xe4\xaf\x37\x45\x24\x40\xb3\xb2\xa8\xfd\x3f\x2f\x8b\x95\xc1\xd0\x6a\x06\x5f\xa1\xdf\x34\x6d\x1f\x12\x3e\xc7\xb5\xed\xc2\x1c\x8c\x1a\xfd\xcf\xab\x53\x16\x51\x8f\x4f\x03\x4e\xaf\x49\xcf\x54\x43\x9e\x92\x27\x48\xf9\x46\x98\x11\x48\xd4\x3f\xf1\x2c\x91\xa5\xeb\x60\x29\x74\xff\xc1\x0b\xf6\x5b\x29\x00\xfd\xbf\x17\xc4\x1c\x19\x36\xb6\x22\x0b\xa6\x0b\x4d\xdf\x47\xb7\x5b\xa2\xec\xfd\x6b\x9b\x64\x90\xa9\x4c\xbd\xf7\x9f\x48\x2e\x33\xe1\xd0\xc2\x89\x09\x50\x76\x68\x58\xdc\x91\xb6\xaf\xf9\x19\x39\x66\xdd\xef\xf6\xb5\xb8\xac\x56\x31\x2a\x70\xa1\x6c\x11\xec\x08\x03\xed\x4a\xfe\x9a\xab\x65\xfd\x48\x1d\x4d\xa8\xbb\xcd\xac\x3d\x68\x55\x2a\xe4\xb4\x42\xe3\x09\x2c\xf3\xd2\x2a\xb1\xf2\x52\x1e\xab\x97\xb5\x42\xe4\x81\xea\xc1\x0a\x1a\xac\x36\x5e\x8b\xaa\x09\x50\x91\x00\x3c\x16\x8d\x51\xc0\x71\x40\xe4\x30\xc4\x3e\x27\x64\x79\xd5\x07\xb6\x30\x11\x9e\x3f\x4c\x63\xa5\x4b\x2c\xbb\x0e\xb9\x33\x68\xc4\x46\xdb\x15\x16\xb8\xbd\xef\x00\x15\x8d\x19\x8c\xc4\x9d\x3c\x6e\x79\x70\x0a\x1e\x2b\x08\x35\x0a\x3c\x06\x6a\x13\x93\x9c\x07\xcc\xc4\x29\x43\x78\xa5\x08\x9c\xb4\x5d\x6f\x8d\x94\x56\x6d\xff\x6d\xb0\x4e\xce\x90\x73\x66\xcb\x9d\x6b\x85\xfe\xf8\x17\x4f\x89\x76\x47\xe0\xc5\xbd\xd3\xf7\x74\x25\x13\xa9\x52\xce\xca\x9e\xa1\x57\xf9\xb6\xea\x23\xef\xf4\x60\x65\xb9\xf8\x2a\x50\xcf\xa4\x3b\x73\x38\x52\x30\xa3\x9b\x5e\x95\x9d\x24\xa3\x50\x27\xbf\xe2\x7d\x39\xd8\xd3\x28\x91\xad\x3d\xd8\x9f\xd0\x14\xbb\x89\x36\xbf\x9c\x50\xa3\xd8\xf5\x88\x68\x91\xac\x70\x36\xd1\x33\xfe\x1c\x74\x51\x5f\xa1\x83\xdd\x1d\xee\x09\x99\xb3\x6b\x42\x7a\xb9\xcc\xcb\xdb\x76\x6a\xbb\x9c\x53\xcd\x6d\xa8\x8f\xba\xdc\x54\x23\xa8\x02\x70\xc2\x10\xfb\xa0\xab\x46\xd6\xa8\x7c\xc8\xd6\xcf\xd1\x39\xec\x75\x40\xf8\x87\xc3\x81\xed\x4d\x20\xcc\x1b\xa8\x7a\xf6\x56\x65\xbb\x86\x5c\x14\x7c\xf6\xad\x69\x6d\xd4\x00\x03\x91\x96\x74\x46\x12\x0d\x14\xd2\x2f\x20\x75\x6b\x30\x1f\x92\xb5\xa7\x54\x08\xc7\x5e\x9b\x8e\xba\x23\x71\x73\x22\x54\x03\x22\x6c\x86\xad\x0a\x8a\x95\x85\x92\x06\xd8\xab\x54\xaf\xd1\x0e\xb8\x07\xe1\xcd\xe3\xa2\xa0\x02\x29\x11\x07\x75\x96\xb8\xc9\x2a\x14\xe3\xe1\x48\xc8\x7e\xb6\x86\x4b\x88\x84\xca\x53\xfe\x68\x45\x42\x17\x46\x40\x0f\x96\xa1\xfc\x51\xaa\x24\x16\xd3\xe2\xa3\x64\x08\xd6\xa4\x40\x76\x50\x7d\x57\x51\x6e\x6a\xfe\x0c\xd3\x6b\x14\x74\x0c\xe2\x51\x42\xbe\x3d\x40\x93\x3d\xa2\xca\x82\x47\x87\x37\x62\x80\x33\x25\xd1\xce\x13\xcb\xdf\x10\x2b\x5c\xb3\xac\x3d\xe3\x81\x66\x5e\x91\xb1\x01\xde\x47\xb8\x28\x97\xa8\xc3\x56\xf7\x79\x4b\x75\x93\x71\x18\xfa\x48\xbd\x7d\x2e\x73\x9a\x16\x23\xbc\x19\x2b\xc6\xef\xb0\xdc\x5b\x8f\xb8\xd2\xae\x10\xbc\x84\xec\x6e\xb9\xfa\x44\x8a\xd9\xdf\xac\x6f\x1a\x54\x80\x6f\xbb\x13\x13\x43\xc9\x06\x0c\xc2\xa5\x1e\xcf\x60\x4a\xef\xe8\xe1\xc8\x20\x64\xff\xb5\x5b\x6f\x28\x0b\x2e\x2e\x52\xcd\x96\xc4\x18\xe3\x5a\x2a\x57\xd6\xf4\xaf\xc8\x78\xe8\xa9\xf1\xed\xf8\x90\x09\xcd\x3e\x25\xac\xdd\x2d\x58\x45\x2f\xe2\x56\xa6\x27\x74\xb9\xf3\x4e\x26\x75\x92\xf0\x97\x00\x03\x4b\x87\x96\x15\x46\x54\x3a\xf7\xa7\xf8\x55\x94\xc0\x62\xbf\xa3\xb9\xcd\x52\x62\x2a\x2f\x1b\x20\x28\xa8\x35\x13\x65\x79\x5d\x64\x81\xbe\xc3\xc1\x4a\x2c\x71\xe8\xdb\x9f\xcf\x98\x73\x22\xfa\x19\xe8\xa5\x4e\x1c\x77\xf5\x19\x60\xe5\x75\xb4\x74\x10\x64\x88\x06\xfd\x21\x06\x1a\x38\x42\x61\x82\x15\x63\xdc\xfa\x5d\x6d\x99\x0c\xa1\x3b\xf1\x75\x5c\x82\x12\x70\xba\x70\xf0\xc6\xff\x60\x23\x99\xb0\x1a\x2e\x11\xe1\x56\xac\x83\x77\x72\x55\xc9\xc0\xfb\xa1\xa0\xc5\xf5\x4a\x3d\x95\xc7\x1d\xce\x2a\x66\xfb\x32\x6b\x4b\x10\x0c\xfd\xe2\x24\x35\xdb\xd8\xce\xf1\x06\xdc\x12\x86\xff\xb7\xbf\xfb\xcb\xbf\xd3\x73\xc6\xd7\xb7\x4c\x61\xe7\x61\x37\xab\x57\xa8\xdb\x52\xcc\x43\xdb\x03\xb7\x07\xf3\x8b\x4e\x37\xb9\xd6\x38\x30\x8d\x02\x04\xd5\x50\x3e\x52\x8c\xcf\x5e\x04\xbb\x83\xc3\xfb\xe1\xa0\xf4\x01\x74\x8d\xe7\x75\xd5\xf9\xed\xf5\xe2\xb4\x90\xd8\xfb\x10\x89\x44\x5c\x4b\xfb\xf8\x0a\xef\x5e\x2c\xc9\x36\xbb\x17\xe9\x5a\x10\xf9\x1d\x7e\x28\xc0\x4f\x81\xd1\xe3\xca\xa5\xd1\xed\x18\xb0\x03\x54\xe6\x51\x74\x13\x9c\xbf\xc9\x6c\x3b\x1d\xd9\x64\xa7\x6a\x18\xb7\xe0\x77\xb3\x2c\x74\xc3\x5c\x87\xa4\x68\x38\xbb\x30\x0c\xe9\x3e\x63\x5b\xa7\x9f\xe1\x7e\x81\xef\x7a\xd0\x4b\x48\x01\x97\x3c\x23\x72\x6a\x51\x9c\x4b\x5a\x47\x13\xaf\xc0\x18\xe3\x3c\x74\x7d\x63\x92\x2a\x00\xba\x97\x11\xc8\x81\x11\x8e\x9b\x36\x6b\x2e\x8f\x0b\x89\x80\x8d\x7d\xa8\xe1\x5d\xe8\x47\x2c\x39\x80\x8d\x0d\x8d\x5f\x6e\x78\xcb\xbe\xd4\x64\x5b\xd8\xd3\x77\xee\xaf\x33\xbf\xbd\x7c\x27\x6e\x6b\x04\x76\xf9\x1d\xad\x8f\xba\xc3\xd0\xce\x58\x9c\x0d\x27\xe4\x15\x52\xe5\xbc\xd7\x17\xfc\xd8\xe5\xac\xde\xe1\xb0\xfc\x85\x8f\xd7\xe7\x79\xd6\x79\xf9\xb8\x05\xe5\x01\x9a\xe2\x9c\x7f\x44\x64\xcc\x07\x9d\xc4\x6c\xde\x4d\x49\xc4\x53\x4f\x45\x32\x6e\xde\x28\xa4\x95\x27\xdd\x7a\x6e\x50\x0d\x60\x5b\x12\x4b\x65\xe3\xec\x80\xf0\xf5\xe2\xfa\xc6\x2b\x0c\x0c\x6f\xb8\xf5\x05\x58\x53\x15\x53\x95\x52\xad\xd8\xf4\x64\x6a\x4b\x1d\x0a\xbf\xbc\x06\x37\xc1\xfe\x48\x17\xe6\xbc\x08\xb3\x2d\xe9\xf3\xb0\xdc\x12\x38\x71\x73\x6e\x58\xb3\xa9\x65\xf8\xf4\xfe\xd3\x56\xed\xad\x93\x90\x37\xa6\x4b\x74\xd6\xfa\x29\x3b\x45\xb4\x32\x3f\x2f\x8c\x21\x33\xb1\xc3\x4d\xd1\xb7\x4b\x6b\x26\x26\xf1\xf9\x77\xf4\xf9\x29\xb6\x0f\xfb\x29\x7a\xbd\x31\xf2\x8f\x98\x88\x44\x8d\xdb\x6f\x39\x09\x43\x96\xa4\x05\x33\xb4\x71\x34\xc2\x94\x4e\x77\xb2\xe5\xfd\xe0\xdc\x8e\x92\x23\x71\xee\x60\xa2\xd3\xea\xdb\x57\x9a\xba\xf8\x65\x0c\x31\xbd\xeb\x89\x61\x28\xf6\xbf\x51\x5b\x98\xaf\xc2\x90\xe1\xec\xbd\xe0\xf3\xb1\xc9\xbb\xef\xfb\x98\x8e\x7b\x8b\xc6\x99\x81\x4f\x3a\x9e\xf6\xe1\x5b\xd9\x12\xfd\xa5\x06\x9e\xe1\xcd\x72\xdd\x1f\xe7\xd9\x11\xf8\x3b\x4b\xaa\xe5\x3b\xa6\xc8\x37\x5a\x1c\xb2\xb4\xec\x96\x16\x16\xe7\x96\x6b\xc3\xea\xb5\x7b\xd9\x1b\x1e\xb2\x5d\x2d\xae\x0e\xaf\x47\x41\xcc\xca\xb3\x2d\xf1\x30\xab\x63\x59\x34\x67\x72\x54\xaa\xfa\x29\xb4\x24\x71\x01\x8d\xd1\xd4\x31\x9a\x8a\xb2\x14\x9a\x08\x4f\x11\x54\xed\x44\xf4\x33\xac\xa9\x08\xda\xdb\x4a\xf4\x70\x1a\x56\x65\xea\xcf\x7c\xc3\x23\xf5\xed\xef\x84\x2b\xe8\xe3\x1a\x4d\x78\xf4\x64\xe9\x89\xc6\x8a\xc1\x33\x86\x49\x79\x43\x1f\x95\x34\x58\xd5\xd1\xfe\xac\x0e\xa5\xdd\x15\x13\xbd\x8b\xfa\x7a\x97\x5f\xe9\x96\xb7\xa9\x9f\xe3\x27\xfc\x6e\x2e\x57\x25\xb0\x82\x7e\x2f\xef\x8b\xba\xae\x34\x87\x47\xf9\xe3\xab\x50\x61\xe3\x3a\xdc\xfb\x53\xb0\xd5\x9c\x3b\x6d\x17\x9e\x33\xa5\xb7\x4e\x7e\x8f\x40\x2f\x93\x47\xab\x33\xb3\x17\xff\x98\xec\xea\x17\xfa\xcc\x7e\x25\x00\x4d\x92\x87\xeb\x52\x0c\x6d\xba\x74\x3e\x9b\xd9\xf3\xfa\xe0\xbf\xa2\x58\xbf\x40\x53\x6b\x55\x5e\x14\xbe\x1d\xbf\x47\xe0\xbf\xe8\xd7\xd4\xb5\x5d\xff\xe3\x8e\x92\x29\x89\x6c\x6e\x7f\x36\x33\x03\x0f\xc4\xe4\x4a\x33\xef\xd5\x0a\x6c\xb0\xf4\x72\xe1\x87\x87\xd3\xeb\xa6\xe7\x2f\x96\x9e\x38\x38\x34\xfa\x60\x33\xae\xbd\x24\xa0\x6a\x41\xeb\x09\x17\x93\x98\xf9\xa0\x58\x67\xff\xb6\xe3\x9d\x2e\x5a\xda\x48\x10\x7f\xfb\x16\xb7\xf5\x9a\x23\x1b\xfe\x96\xe5\x8e\xd3\x70\x8d\x35\xfb\x03\xf6\x5e\xdf\xf7\xd1\xe4\xe7\xcb\x17\x9a\x9c\x41\x93\x19\xf5\x1b\x8c\x5c\xa8\xd6\xcf\x0e\xca\x3d\xd7\x99\x89\x49\xce\x7e\x37\xd7\xa7\x9c\x0d\xad\xfe\x83\x38\x76\x59\xe9\xb1\x95\xd0\x4e\x08\x3e\x4e\x48\xd7\x43\xf3\x8c\x82\x65\x63\x1b\xf1\x50\x02\xc7\x47\xfc\x62\x6e\xaa\x60\x9c\x41\x09\x03\xe6\x5f\xd9\xf0\x51\x72\xdc\x55\x97\x30\x2f\xb1\x89\x02\x04\x81\x73\xb6\xef\x17\x92\xcf\x04\x67\xb8\xda\xdf\xdb\xb9\xcd\x16\x67\x06\x72\x6d\xf2\x2a\x86\x96\x6d\x91\x38\xe7\xdb\xaa\xa5\x5d\x66\xee\x95\x8f\x10\x1e\x49\xf6\xde\xaa\x96\x8a\x8a\x96\x4b\x2e\xba\xaa\x8d\x44\x12\x72\x28\xef\xff\x46\x0e\x1f\x71\x42\x96\x06\x8b\x76\xb9\x82\xb3\x64\x76\x24\x94\xcb\xbc\xe0\xdc\x91\x38\xfe\x45\x98\x27\x76\xf8\xa0\x84\x57\x08\xf8\x00\x38\xc7\x1a\xe7\xc0\x9a\x5e\xe3\x98\x27\x1b\xf4\xd9\x33\xa3\x45\x57\xc3\x16\x12\x76\x16\x0b\xe5\xd6\x4b\xc0\xe5\x2d\xa8\x39\xa1\x8b\x29\xf5\x10\x45\xff\x25\x53\xd9\x7a\xef\x8b\x45\xf2\x6b\x91\x32\x80\x3d\xca\xef\x6a\xb9\xe3\xba\xe3\xbb\x39\xb9\xae\x37\xbe\x11\x5e\x19\x38\x76\xa7\xab\x56\xd1\x5c\x39\x07\xaa\x6d\x73\x3d\xdb\xf9\x52\x54\xf8\xa8\xd5\xc0\xc5\xab\x29\xda\xaf\x77\x67\x3f\xd9\x10\xf0\xc4\xfc\x10\x63\xd0\x15\xa0\xd1\xe8\x9c\x5e\x57\x71\x78\x16\x51\x0f\x50\x4e\x8e\xec\x2f\xf3\xdd\xcc\x8b\xf0\x8e\xa4\xd4\xfc\xda\x3c\xfb\xbd\xa9\xf3\xd1\x83\x38\x59\x17\xe1\xd1\x6c\xfb\x97\x07\xf6\xb7\x0a\x9d\x52\xd8\xe5\xe2\xef\xf1\xc5\x93\x8f\xb3\xb3\xa1\x38\x44\xf6\x35\xbd\xc6\x1a\x35\x1e\x8a\x1d\x71\x8c\xe6\xeb\x15\xf6\x8e\x2a\x78\x5b\x96\x60\xf5\x66\x1e\x1e\x0b\xc2\x7b\xcb\x7f\x2a\x5f\x61\x10\x8d\xbb\xcd\x97\xa4\xf3\xc9\x93\x66\x5c\xf6\x31\x8c\xaa\x19\x2d\xbb\xf3\xa3\x6e\xc8\xfc\xdb\x8f\x59\x3a\x88\x46\xc3\xbb\x97\xd2\x41\x25\xbc\xad\x22\x6f\x57\x4d\x19\x9d\x45\x49\x31\xd9\x8b\x1a\xea\xc6\x16\x6e\x44\x25\x44\xc4\x1b\x20\xf3\xaf\x8e\x0f\xc8\xd8\xfc\x86\x45\xd8\x04\x26\x6a\x46\xa7\xde\xbe\x42\x28\xcc\xf0\xd6\x85\xab\x42\x52\x53\xf5\xd2\xb8\xac\x7b\x99\xb1\x72\x24\xce\xd1\x20\x7e\xb3\xc8\xf7\x2b\x52\xfd\x64\x56\x6b\xf7\x2a\x5a\x1a\xb6\xb1\xa0\xde\x6d\xd6\x11\x14\xbc\x02\x57\x54\x72\xbd\x11\x28\xe8\xdf\x71\x23\x2a\x35\x96\xf0\xb5\x15\xe0\xe2\x28\x89\xad\xe8\x0d\x7f\xd2\xe2\x9f\xf7\xed\x6b\x9c\xa2\x92\x53\x71\xb4\x38\xd1\xeb\x8b\xbd\xab\xaa\xf7\xb3\xe5\x44\xd3\x75\x94\x2d\xad\x1d\x0c\x02\x6f\x54\x3c\x7c\xac\x7d\xd5\x7d\xfd\x68\xda\x1f\x77\x9f\x66\x66\xd2\x78\xc2\x79\xde\x69\x07\x3c\x2b\xac\xc5\xa5\x8c\x35\xbf\x9d\xb9\xb7\xd4\x23\xea\xd2\xdd\x1b\x15\x6f\x94\xb7\x94\xf1\x6a\xaf\xc1\x7a\xaa\xf8\x05\xaa\x6a\x4b\xed\xe5\xac\x61\x7a\xef\xf5\x52\x84\x9a\x7a\x0a\x35\xef\xad\x4d\xd5\x5f\x5b\xdc\xaf\xa6\x6f\x3f\x8c\xe6\xd7\xa6\xdb\xea\xb3\x35\x0c\xcc\xe5\x1e\xfe\x5d\x7e\x0a\xd6\xaa\xaf\x2f\x4b\xab\x01\x21\x4c\xad\xfc\xd8\x03\xb9\x7a\x9f\x5c\xd4\x34\x54\xec\x55\x97\xbf\xd4\x94\x0f\x69\x51\x47\x33\xda\x03\x0a\x76\x4d\x71\x57\xe2\x29\x9c\x12\x1f\xc0\x8b\x8b\x63\x1a\x8a\xd2\x2f\x27\xc9\x22\x7f\x02\xcb\xaa\x49\x35\x82\x91\x4b\x54\x8b\x8c\xc4\x18\xf1\x63\x0f\xf4\xcc\xaa\x09\x5b\x07\x47\x7f\x42\xe2\x7c\xf5\x20\xed\x85\xe9\x22\x14\x69\x78\x93\xd6\x14\xa8\x8b\x47\xd6\x99\x0d\x85\x17\xeb\x86\x80\x41\xea\x4a\x60\x46\xae\xb7\x46\x0e\x55\x34\x09\x87\x8b\xee\x3c\x61\x6d\x69\xf0\xb1\x21\x07\xf5\x14\x8e\xda\xd3\x05\x59\xb7\x7e\x96\x52\x8b\xf2\x96\x7a\x02\x9f\x87\x2c\x72\xb6\xf5\xd6\x15\xfa\xdf\x63\xaa\x5c\x08\x13\xe2\x20\xff\x64\x23\x6f\x0f\xfc\xa5\x1d\x90\xd5\x23\xd9\x5c\x8d\x9e\xb2\xb3\x8f\x81\x8e\x56\xc8\xcf\xc3\x08\x9e\x42\x03\xc6\xf9\x6b\xce\x14\xf4\xee\x76\xac\xe0\xcd\xbd\x30\x2d\xd5\xb9\x24\xb7\x19\xa7\xfc\x42\x62\x71\x27\xca\x9f\x53\x1d\xef\x51\xab\x29\x68\x26\xf5\xf9\x5e\x8f\x4e\x13\x1c\x80\x6e\xdf\xbb\x71\x08\x7a\xb9\xa2\x8d\xb1\x05\xb9\xe2\xbc\xa5\x06\x1c\x11\x34\x96\x95\xbe\x68\x86\x69\x84\xe0\xd6\x6c\x19\xa6\xa5\x6b\x9e\x78\xc2\x10\x09\x2c\x06\x4f\x86\xab\xa8\xa6\x3d\x60\xbc\x4b\x0b\xbe\x23\xf1\x1e\x97\xf9\xa9\xfd\x9c\x2c\x72\xb6\x61\x27\xfb\x65\x8b\xa0\x4e\x3b\xfd\x83\x96\x10\x5a\x18\x2f\x9c\x99\xad\xdc\x65\x5d\x02\xbf\xc1\x0d\xa5\xc4\x9b\x56\x5a\x21\xd2\xbb\x28\xf2\xef\xea\x30\x53\x82\xbc\xb6\xa9\x56\x71\xee\xf1\x47\xe1\xbd\x53\x14\xd2\x0a\xc4\xa5\x99\xa6\x40\x59\xa8\x33\x2d\xad\x0e\xa4\x09\xd0\xbe\xd1\x84\x18\xdf\xda\x6e\x2a\x5a\xdf\xde\x48\x18\x6b\x07\x41\xc7\xe0\xae\x17\x46\x6e\xa0\x24\x6d\x37\x69\xd6\x4f\xeb\x0d\xd3\x84\xcc\xd6\x7d\x31\xc0\xe9\xd0\x8d\x0b\x59\xc4\x62\xd9\x4b\x40\x17\xb9\x82\xf2\xcc\xd4\xa2\xee\x0b\x99\xc9\x17\xae\x06\xad\x64\xf2\x51\xff\x64\xe9\x16\x0b\xe9\x1e\xac\x8b\x98\x15\x7e\x18\x63\x3a\xdf\x3b\x80\x72\x4e\xea\x86\x55\xe9\x0e\x35\x39\xc2\xcf\x1e\x1b\x07\x09\x53\x5f\xd7\x88\x53\x2d\x44\x52\x1b\x6f\xd9\xc5\xc2\xe1\x29\x95\xae\x3b\xfe\x78\x6c\xe1\xd2\x96\xe0\x1d\x13\xe2\xc9\xe2\xa4\x9c\xc0\xeb\x94\xd1\x51\xf6\x0f\xba\x61\x2f\x7c\x5b\x1f\x62\xc4\x27\x8d\xef\x1b\xe1\xfc\x63\x93\x5b\xc3\x67\xf3\x82\x50\x7d\x49\xf2\x0c\xc1\xf6\x3b\x0b\xe8\xe9\x97\x25\xf1\xfb\x03\x7f\xfe\x30\x26\x63\x50\x39\x52\x9e\xef\xc9\x61\x36\x96\x9c\xe5\x3a\xbb\xaa\x20\xf0\xf5\x77\xbf\x1d\xa6\xac\xe0\x70\x93\x29\x72\xc3\x63\x3e\x29\xa4\x21\xd3\xc0\x04\xeb\x20\x2c\x41\xc6\x6c\x33\x45\x33\x26\x00\x11\xb3\x17\x71\x7b\xb2\x41\x05\x57\x71\x2d\x3e\x72\x1b\x93\x1e\x41\xb5\x31\xa5\xb8\xbe\xe4\xcc\x1e\xa1\xdd\x05\x7f\x66\x88\x77\xe3\x8b\x2f\x07\x3e\xee\xe3\x70\xb2\x8a\xfa\x6a\x8d\x59\xeb\xf6\x61\xb2\xba\x30\xca\xee\x0c\x7e\x3a\x9a\xe2\x94\xcc\x98\xe4\x64\x15\xea\x14\x16\x62\x36\x43\x72\x25\x6f\xf1\x19\x32\xdd\x83\xca\x64\x41\x6b\x28\xf7\x04\xed\xaa\x94\xe8\xa9\x43\x27\xa3\x92\xf0\x65\x22\xf7\x66\xfb\xcf\x17\x00\x3a\xb9\xae\xbb\x7a\xdf\x2e\x82\xc4\x82\xc0\x1e\x48\x46\x89\xbf\xe3\x2f\xa9\xa4\xc5\xed\x3b\xdb\x80\x46\xb9\x97\x58\xae\x72\x8c\x7b\x9f\x99\x64\xec\x6a\xa1\x19\x9f\xc1\x0c\x71\x6d\xe0\x37\x4e\x18\x83\xbd\xe3\x1c\xc9\xf6\x56\x31\xeb\x86\xb6\x37\x8b\xb6\x1e\x97\x2c\xb6\xd4\x4d\xe5\x39\x7d\x45\x95\xe8\xa9\xa6\x22\xbe\x6c\x66\x03\xde\x98\x3f\x65\x1d\x5c\x80\x1a\x73\xe6\x4f\x38\x22\xa9\x0e\xc1\x89\x5f\x6f\xca\x70\xc7\xe0\x3f\x4b\xca\xe0\xe3\x3a\x25\x8e\x63\x1f\xfb\x61\x53\xba\x80\xca\x5c\x1f\x4c\xbc\x93\xc8\xbf\xc9\xa4\x73\x46\x87\xab\x3a\x7b\xef\x2c\xfb\x87\x16\x2d\xba\x43\x86\xce\x19\x94\x51\x70\x45\x09\xf6\xaf\xf3\x30\x48\x63\x1e\xee\x94\x5a\xd8\x37\xad\x20\x9a\xa9\x82\x73\x09\x7f\xbe\x9a\x41\xa4\x9e\x8e\xff\xac\x9a\x90\xd9\xdb\xac\xc4\x79\xb7\x67\x6c\x71\x36\xdc\x5e\x7a\xac\xb8\x8d\x66\x41\xb0\x7a\x13\x02\x67\xf9\x0a\x96\xa5\xd9\xef\x72\x8f\xa6\x83\x29\xad\xe3\x79\x50\x63\x58\x04\x89\x4a\x92\xf4\x81\xfc\xd5\x2a\x16\x5f\x24\xae\x50\xc3\xd8\x77\xff\xf7\x65\x31\x98\xd4\xee\xcf\xe7\x10\xf3\x53\x80\x8a\xcf\xa7\x33\x7e\xff\x2f\x06\x45\xe4\xe3\xa6\x25\x30\x93\xf3\x55\xdf\x55\xc7\xe3\x28\x16\xf1\x4d\xda\x4e\x15\x49\x67\x63\x63\xe3\xc6\xe2\x94\x6a\xbb\x84\x0c\x1d\x95\x44\x99\xb8\x9d\xfb\x64\x7a\xdd\x80\x21\xd0\x5b\xf5\xa2\xee\xe3\x46\xfa\x13\x56\x0c\x91\x06\x90\x1e\x42\xed\x72\xc1\x8e\xec\xea\xe6\x26\x48\x94\x6c\x9e\x8e\xc0\xc7\x93\xa9\xcf\x72\xa1\x46\x66\xac\x92\x93\x36\xd5\xa2\x37\xb9\x32\xa7\xb5\xc2\x92\xaf\x66\x3c\xdc\xf1\xef\xd7\xfc\x69\xd0\x8f\x0c\x1a\xa7\x49\x10\xd8\x32\xb6\x8a\xe4\xbe\xe3\x62\x3e\xe5\xf1\xcd\x12\x85\x29\x84\xc1\x76\x80\x6e\x14\x79\xf0\x1f\x48\xdd\x83\xbf\x95\x0c\x84\x9e\x10\xeb\xdd\xf9\x7c\x13\xc4\x92\xaf\x9e\x23\xe1\xe0\x2d\xee\xb0\xd8\xf0\xe9\x03\xad\xc6\x15\x69\x29\x62\xa5\x3a\x0c\x0e\xeb\x17\xdf\xa1\x94\xe2\x18\x8f\xee\x12\x63\x6f\xd7\x37\xf9\xe0\xa2\x01\xc5\x99\xc7\x17\x72\x86\x0f\x7d\x3b\xac\x5f\x45\x58\xd0\x73\x89\x27\x33\x1e\x2f\xec\x47\x99\x7d\xab\x9f\x55\x8c\x57\x7a\x39\xa4\x90\x7f\x2a\x7b\x02\xd1\xe1\xa7\xab\xb1\x7d\x44\xd6\x06\x3a\x71\x6c\xad\x30\x0a\xbc\x43\xb9\x48\x9f\x26\x49\x3a\xc3\x24\xd3\x72\x65\x54\x22\x0c\xe6\x62\x7b\x69\xe2\x0d\xa3\xb3\xd7\xd8\x04\x9e\x36\x55\xe3\x6c\x39\x62\xe0\x85\xe1\x3b\xd0\x5a\xf4\xb2\x97\x38\x22\xca\x1d\xde\xe4\x7c\x3e\xfe\xfc\x82\xc0\x80\x0e\xec\x7b\x57\x17\x9d\x5a\x6f\xa4\x8f\xd0\xf4\xbc\x79\xdb\x47\xde\x37\xc6\x45\xfc\xc0\x90\x92\x6e\x97\x16\xfc\xba\x20\x19\x1d\x82\x7f\x62\x51\x02\xaf\xca\x58\xb7\x89\xa2\x8c\x79\x0d\xc9\xa2\xf0\x40\xc8\x74\x25\xb2\x62\xd6\x95\x87\x5d\xc8\x8e\x8f\x74\x49\x0d\xaf\x9f\xa0\xd8\x89\xc2\x24\xf7\x94\x4a\x08\x8c\xf8\x67\x96\xb6\x1d\x20\x5c\x7b\xf7\x1c\x31\xc7\x19\x3a\x9a\x2d\x18\x48\xa2\x69\x1c\x3f\xd4\x95\x22\x19\x10\x4b\xe3\xf7\x20\x1f\x08\x55\x7b\xf4\xdc\x3c\x6c\xf0\x79\xe2\xa0\xbd\xa6\xf2\x06\xbc\x76\x34\x80\x1a\xf6\xf1\x41\x3a\xb2\xe1\x47\x49\x18\xfd\xa5\xbb\x15\x04\x2e\x6a\xd0\xa5\x19\x3c\x68\x52\x26\x55\xab\x02\x0d\xee\x08\x35\xc0\x74\x8a\xe8\x6a\x86\xfd\xd7\x9b\x8d\x23\x40\x47\xf4\x6e\x8a\x33\xcf\xf7\x76\x2c\x3d\x06\xbf\x2c\x2e\x21\x8e\xc8\x75\xa7\x79\x3c\xbf\xd7\x01\x21\x89\xcb\x4c\xff\xb2\x48\x1a\xff\xe5\xb2\x47\xbd\xeb\x6d\x35\xd7\x97\x43\x21\x24\xff\x42\xc6\xd2\xc1\xdb\xf5\x41\xff\xa6\x3f\x70\xed\x84\xb3\x7d\x9a\x6e\xc5\x7e\x9b\x9b\xf8\x58\x82\x73\x66\x0f\x36\x7c\x7b\xca\xcf\xf5\xfc\xa4\x33\x1f\x9c\xb5\xdf\x1a\x9d\xf1\xf3\xb8\xb9\x93\xf3\xe5\x35\xdb\xc2\x3c\x10\x9e\xe3\x5f\xc2\x93\xcf\xfb\x13\x25\xb3\x40\x01\xad\x71\xe8\xa6\x2c\x18\xef\x53\xa1\x35\x12\x10\xce\x94\x66\x73\xcf\xb6\x1e\x07\x7d\xa3\xef\xaa\xd3\x7e\x2b\x0f\x02\x66\xb6\x70\x21\x35\xad\xb3\xc4\x35\x6c\x95\x29\x93\x78\xf4\x31\x4e\xca\x47\x64\x2e\x0c\x96\x3f\xc6\x52\xb3\xad\x4d\x63\x16\x5a\x11\x55\x45\xa0\x3b\xff\xea\x0b\xfa\x17\x77\x63\x7d\x40\xf2\x19\xa1\x86\xeb\xaf\x1f\x11\xde\x37\x84\xf0\x0d\x0e\xd2\xa8\xea\xf2\xad\x2a\xb9\xcb\x04\x7c\x79\x49\xfe\x52\xe4\x7d\x53\x5b\x2b\x1d\x5d\x7b\x1c\x39\x48\xf1\x30\xef\x63\xb2\xaf\x71\x0c\x78\x06\xef\x4a\x87\x0f\x30\x37\x3b\xcf\x40\x7f\xf9\xc6\xe9\xe4\x4c\xad\x64\x45\x43\x43\x04\x22\xba\xba\x1b\xd2\x2a\xa6\x69\x97\xe5\x51\xe9\xef\x50\xa0\x7e\x69\x9e\xc1\xa1\x94\x50\x4e\xdd\x91\x5c\x89\x59\x72\x65\x9f\x1e\x8e\xdc\x52\xc9\x3b\xde\xe8\x6b\x30\x61\x3f\x35\xbb\xbd\x09\x5f\xf2\x1f\xc5\x9c\x34\x99\xf6\xd6\xe0\x50\xb1\x35\x09\x1e\x6f\xe3\xcb\xcb\x87\xd3\xc5\x9b\x79\x46\x54\x3a\x8a\xab\xb5\xfe\xea\xef\x6a\x8f\xcb\x5f\x1b\x04\xa4\x03\x8e\xf8\xaa\xa1\xa1\x07\x97\x24\x88\xeb\x31\xe3\xeb\xb2\xe8\x68\x0e\xe3\x6f\x26\xd6\x22\xce\xfe\xfd\xab\x1f\x37\xed\xa6\x73\x6b\x51\x47\x1d\xc5\xa1\x91\x73\x94\xcb\x1e\x67\x7d\x69\x90\x37\x89\x1a\xd3\x06\x4e\xb1\x8f\xa3\x14\x78\x77\x22\x9b\x9d\xc3\x72\x2f\xda\x72\x69\x10\x91\x72\x52\x7e\x29\xb9\x12\x9f\x13\x0a\xf3\xb8\x88\xf3\x37\xa1\x12\xa1\xb0\xbc\xdc\x66\x51\x49\xac\xda\x99\x3f\x60\x51\x1d\x83\x7e\x09\x47\x24\xf7\x6e\x98\x9c\xc6\x37\x49\x93\x1b\x70\xcb\x90\x18\x9c\x24\x38\xe6\xbc\x01\x40\x77\xc8\x3a\x34\xe2\x86\x55\x7e\x62\xe4\x59\x86\x6d\x80\x42\x5b\x24\x76\x8e\x90\xda\xea\xc4\x0e\x96\x83\xb1\xca\xe1\x55\x39\xfb\x89\xfc\x46\xaf\xf4\xc7\xfd\x9b\x36\xfb\x77\xb0\x0e\x07\xc3\x97\xc9\x46\x5e\x2a\x82\x0e\x06\x8e\xda\xaa\x36\xf0\x80\xe8\x91\x62\x99\x33\x8a\x33\xf1\x33\xcb\x45\xc6\x58\x71\xf6\x19\x71\x86\xe1\xd8\xd9\x51\x57\x87\xf4\x36\xae\xcd\x74\x0f\x24\xd8\x56\xb7\x12\xc2\xf4\xef\x1f\x62\x44\x5e\x28\x18\xbd\x2e\xaf\xb7\xf8\x79\x9f\x6f\x9b\xa7\x25\xf9\x8c\x36\x44\x0b\x9b\xbc\x44\xd3\xca\x2a\x97\x0e\xff\x62\xc8\x23\x78\x2b\xf3\xd1\xf0\x15\x8b\x38\xc2\x0d\x24\x49\xa6\x50\x3a\xc5\x7d\x20\x16\x5e\x91\x9f\xb5\xfb\x92\x6e\x2c\xfb\x0a\x28\x17\x2e\xd4\x91\xdd\x45\x9a\x4a\x22\x9a\x1e\x35\xa3\x1a\x12\x67\x02\xb5\x7d\xd1\x1c\xd3\xd0\x46\x70\x8a\x58\x85\xd3\xd6\x6f\x87\x60\x4c\xd9\xbb\xb5\x8b\xb4\xd1\xc8\x9c\x07\xf0\x18\x80\xc8\x25\xaa\x12\x21\x8c\x61\x57\xf2\xe6\x96\x19\x52\x21\xaf\x9d\x6b\x3f\xd8\x9e\x9a\x15\x7a\x09\x0d\x88\xd0\x7a\x9e\x58\xa7\x56\xf5\x50\xf3\xc1\xec\x79\x9a\x93\x6a\x5f\xba\x67\x89\x9a\x23\x3f\x18\xca\x16\x89\x7c\xda\x17\x38\xb8\xed\x94\x1e\x22\x94\x30\x4a\x71\xac\xfd\xff\xb6\x06\x6b\x58\x57\x8b\xa5\x15\xf6\x16\xaa\x79\x57\xcc\x63\x72\x82\x19\x1d\x10\xd8\x5e\xff\xc6\x5f\xd5\xb3\x70\xe5\x0e\x93\xea\xa1\x54\x41\xf7\xc0\xc3\x20\xa8\x55\xb2\x8e\xa5\xa9\x6e\x16\x3a\xb6\xc2\x31\x80\xdf\xeb\x51\xa8\xc0\x63\x9f\xb5\x75\xd2\x8c\xd3\x10\x40\x95\xd6\xa0\x0f\x2a\xd2\x51\xa2\xed\x11\x79\x48\x65\xed\x66\x77\x8a\xa7\xc8\x5f\x75\x84\x54\x68\x20\x8c\x85\x19\x1b\xf9\x11\x09\xa8\xc8\xdf\x72\xbe\xc4\x3f\x4b\x70\x8c\xcd\x17\xdb\x42\xe4\x70\x0e\xa5\x25\x68\x2a\x26\x26\x68\x74\xd7\xb0\x8a\xd5\x2e\xdd\x4f\x09\xbf\xbb\x5b\xf8\x5b\x29\xa2\x81\xbe\x14\xfd\xfc\xf7\x8d\xa6\x77\xc6\xa4\x1a\x12\x01\x42\x76\x67\xb0\xcb\xaa\x85\x81\xab\xb9\x6e\x62\xba\x29\x91\xa3\x22\x26\xcf\x30\xdf\xa0\xdd\xec\x2e\xcb\xcc\xbb\x64\xb9\x60\x39\x43\x5f\x84\x6c\x21\x89\x7a\xf4\xab\x84\xae\x68\xd3\xba\x35\x8e\x95\x33\x61\xbb\x5f\x9e\xe7\xc1\x70\xf7\xd9\xba\x95\x28\x34\x60\x5d\xeb\x89\x58\x68\xf2\xe4\x30\x66\x95\xae\x90\x1e\xaf\x7a\xa1\x06\xe3\x9e\x78\x9d\xce\xff\xd1\xc9\xf8\xfb\x29\x82\x8f\xe5\x02\xbe\x12\x25\x21\x8c\x0b\xb5\xbb\xb2\x29\x9a\xaf\x02\xd2\x8f\xc0\x37\xa8\x73\xe2\xe7\xfb\x6e\xee\xbf\x86\x97\xed\x80\xf4\xd1\xc4\x17\xde\x9f\x74\x36\x06\xf4\x33\x42\x18\x4d\x20\x33\x68\x86\xbe\x30\xfe\xa1\xc0\x41\x62\xec\x48\xb6\x45\x53\x9b\xf2\x38\x62\x38\x3c\x77\x38\x0d\x0a\xfd\xf7\xbf\x5c\xdf\xbb\x60\xdb\xfe\xd4\xa1\x3f\xea\xe6\xda\x93\xd3\x2e\xc9\xa9\x7e\x22\xd1\xa4\x2e\x7d\xca\x96\xc6\xc1\x16\xe3\x6b\x31\x47\x17\xd9\x71\x49\x49\x4d\x67\xcb\x64\xff\xc9\xbf\x65\x63\x0e\x6b\xc1\x11\x27\xb5\xf4\x0e\x0d\x44\x49\xa0\x9b\x51\xe7\x57\x9f\xe1\x97\x67\x07\xb6\x94\x9d\xe1\x16\xf8\x94\x49\x6a\xdc\x5f\x90\x9e\xf2\x4b\x4e\x0a\xda\x7d\x18\xb0\x6e\x89\x18\x06\x3a\xa4\x9a\x7b\xc8\x6f\xad\xa2\x65\x0d\x49\x6b\x57\x99\xd9\x6e\xa5\x59\xe6\x6d\xdc\xa7\x3c\xb2\x03\xf2\x79\x9a\x70\x89\x86\x1b\xed\x8e\x2d\x9c\x72\xed\xf4\x44\x11\xec\xbe\xf2\x2b\x78\x7b\x04\xde\xbf\xed\x77\x06\x9f\x16\xbf\x65\x76\xa6\xd0\xd3\xbe\x9f\xba\x0c\x03\x3f\x03\xcb\x4f\x3e\x2f\xea\xc8\x1f\x9a\xf4\xde\xfb\xba\x8a\x3b\x8f\x04\xeb\x39\xdf\xde\x3d\x6d\xf8\x7d\x46\xa3\x17\xbe\x9d\xe3\x10\xfd\x71\xe4\xbc\x4a\x61\x7d\xab\x1d\xcb\x24\x94\xd1\x2b\x18\x6c\x18\x5a\x53\x74\xe4\xf5\xa5\xed\x4b\x1d\x8a\x3c\x94\x7d\xcd\x13\xb0\x0b\xd6\x34\x8d\x30\x4a\xcc\xed\x3a\xfd\x4c\x67\xff\xca\xc8\xb4\x98\x5c\xca\x65\xb8\x4a\xcf\x1c\x5d\x06\xa9\xf4\xde\xed\x32\x51\x97\x43\x42\x97\x23\xcf\x7e\xd3\xbf\xbc\xec\x8e\x23\xc2\x6d\xf0\xaa\x57\x5d\xca\xd3\x74\x57\x89\x96\xd2\x10\x31\xa8\xb5\x4c\xeb\x77\x5c\xf0\x85\xe3\x9e\x85\xcf\x21\x5e\xf8\xd4\x16\xe3\xe8\xff\x4b\xc7\x74\x2f\x4f\x14\xd2\x38\x9a\xd9\x4d\x57\xdd\x4d\x65\x0f\xa9\x04\xff\xf3\xc9\x2a\x43\xf5\x26\xe9\x82\x6b\x06\x7f\x44\xfd\x19\x4f\x97\x90\x17\x7a\x1e\x5c\x65\xac\x89\xe9\xf9\x65\xbd\xda\xa0\x0f\x3f\x47\x26\x41\xe8\xfa\x44\x48\x6f\xbc\x96\x68\x92\x2a\xc3\x23\x76\x9d\xed\xb2\xc0\x2c\x1d\x0d\x7c\x4d\xab\xa6\x62\x90\x81\xd5\x4f\x09\xa1\xd7\x7d\xf7\x7b\x82\xaa\x44\x0b\xc9\xe0\x49\xb1\x29\xe6\x20\xf3\x7e\x97\x38\xf7\xb0\x41\x76\x67\x7c\xfa\xf9\x64\x7a\xae\x7d\x39\x88\x7d\xe3\xf5\xd4\xe8\x37\xa2\xd4\xcb\x18\xf1\x55\x21\xbc\xb9\x5b\xa8\xf7\x1b\x29\x3a\x92\x61\x50\x5f\x23\x94\x80\x28\x4f\x2a\x0d\x73\x01\x72\x84\xb4\xeb\x4c\x91\xc3\xf9\xef\x5b\x9a\x4b\x5f\xed\xc7\xe0\x59\xaf\x73\x9d\xa4\x47\xbc\x96\x20\xb9\x2c\x62\x25\x76\xcb\xba\x33\xeb\x74\x46\x0e\x65\x72\x73\x28\x41\xf1\x51\x47\xf1\x5e\xa7\x9f\x19\x8f\x99\x03\xa1\x34\x65\x37\x16\x03\x11\x6e\x2e\x31\xea\xca\xb9\x48\xab\x8e\xcf\x1f\x48\x13\xa1\x33\x04\xca\x7f\xba\xcc\x7d\x87\x9d\x79\x31\xd7\x01\x87\x86\x65\x13\x8a\x10\x92\x09\x02\x0d\xe7\x50\x1f\x61\x2b\x45\x1d\xcb\x56\xad\x78\xf9\x06\x4f\x03\xca\xb7\x10\x7e\x33\x18\x57\x9e\x6c\xfa\x29\x49\x57\xe8\xc8\x46\x73\x43\xfa\xc5\x90\xb9\x9e\x46\xc7\x45\xe9\xe3\x9f\x38\xae\x93\x90\xf1\x06\x6e\x8e\xe3\xfd\x72\x7f\xbf\x7f\xce\x45\xb9\x13\x52\x6b\x88\x1c\xda\x45\xe0\x29\xd4\x26\xba\xf7\x78\x91\xcf\xa2\x69\xcc\xc2\x4f\xe3\x70\x80\x57\xf7\x1d\x7c\xaf\xfb\x7b\x83\xdd\x39\x87\x99\x0e\xf3\x91\x1b\x9c\x48\x6e\x13\x6b\x60\xcb\x43\x2d\x52\x93\xcf\xbd\x64\xaa\x67\x98\x1b\x7a\xaf\xeb\x12\x0d\x44\x8f\x86\x75\x93\x3f\x1b\x79\xc9\x52\xcb\x3c\x1b\xaa\x3a\x08\xe5\x73\xf8\xdc\x8b\x9d\xe5\x64\x9c\x32\x87\x14\xcf\xd3\x7f\x5e\xf1\x43\x49\xe8\x1b\x91\x28\x5d\xfa\x7e\x45\x3d\xde\x27\x70\xe6\x08\x30\x11\x06\xe5\x5f\x1d\x92\xca\x43\x40\x41\xfa\x8c\xda\x97\xaf\x51\x83\x56\x04\xa1\x1e\x67\x5e\x82\xd6\xdf\xb3\x9b\xcb\x39\x05\x7b\xbd\x1f\x96\x00\x80\x22\x6b\xb8\x91\x2d\x2d\x6f\x75\xf5\xe1\xaa\x74\x0d\x3b\xee\x2a\x75\x76\x24\xe5\x3b\x6f\x3a\xb6\xdf\x65\x8c\x21\x8f\xec\xc4\x7a\xfe\x53\x82\x8e\x50\xc9\x94\x74\xbe\x9e\x27\x29\xd4\xac\x7b\xfa\x3c\x77\x01\x42\xfe\x0c\xf6\x19\x42\xb6\x29\xa5\x94\xf5\x06\xd2\x09\xe0\x77\x54\xc4\x30\x14\x2f\xd5\xa0\xd1\x84\x0f\xe7\xc3\xe4\xc5\x8b\x62\xeb\x52\x0a\x45\xdc\xa5\xdf\xec\x72\x2b\x37\xc2\x1b\x85\xd9\xe0\xef\x1f\x3e\xa5\x36\xa3\xce\x67\x9f\x24\x01\x27\x27\x0f\xcb\x6f\xed\x91\xce\x70\xea\x4d\x42\xa5\x32\x57\x40\xad\xe7\x47\x84\xb8\x2f\x4b\xdd\xb2\x5d\xc3\x62\x15\xf1\x24\x19\xa8\x35\x17\x93\xc3\x93\xa5\x35\x97\x8f\xd5\xfe\x13\xbf\xe4\x29\x8f\xd1\x1f\x59\xc8\x3f\xb3\xde\x49\x52\xcc\xd9\xe4\x72\xc4\xf7\x44\x77\xe3\x12\x8f\x2d\x10\x04\xb7\x77\x0c\x0d\xc0\x5d\xb8\xc1\xb6\xe8\x55\x42\x8f\x39\x03\x06\x7a\xa9\x26\x5d\x2c\x1c\x8c\xa3\xae\x1f\x6e\x84\x54\xf1\xd8\x56\x55\x51\x8d\x62\x85\xd8\x7c\xa6\x2e\x9a\xb8\x31\xea\xe0\x57\xce\xaa\xd1\xe5\xcd\x51\x0b\x8d\x7e\x7b\x91\xdf\x2c\x01\xc1\x37\x3e\x7b\xe1\xc1\x1b\x74\x3d\x5c\x90\x94\xcb\x1e\x80\x70\x25\x4e\x5d\x3d\x79\x51\x4b\x77\x70\xc2\x9a\xf9\x86\x1e\x1f\xd7\xeb\x6b\x0c\x98\x72\xe5\x49\xcc\x42\x48\xa4\xf9\x44\x61\xa2\x66\x8c\x68\xbc\xd4\xd3\x85\x05\x5a\x7f\x47\x04\xbd\x4a\xaf\x7d\x79\xd5\xaa\x12\x04\x35\x2a\x3d\x0a\x8c\x31\xc3\x3d\x56\x0a\xb8\x7a\x6a\xbe\xab\xfb\xdf\xed\x37\x5c\x9c\x25\x80\x7b\x65\x6e\xfd\x6f\x93\x17\x02\xdf\x6d\x86\xdb\xc2\xad\x1f\x38\x82\xa7\xc1\x30\x47\xa7\x05\x4a\xec\xbf\x03\x14\x7c\xef\xa8\xa0\x91\xf5\x78\x1c\x0d\xf5\x7c\x52\x0b\xbb\x60\xfe\xd5\xf4\x9a\xf2\x15\x52\x20\x84\xf9\xa3\xea\x12\x43\xdd\x5d\xca\x9c\xb1\xb7\xbd\xa3\xf1\xf1\x65\xc0\x27\x6f\x18\x06\x1f\xa6\x1f\xac\x79\xab\x70\x90\x77\x11\xaf\x63\xdb\xa6\xd8\x94\x04\x48\xf4\x86\xd7\xca\xb9\x01\x5b\x2f\xc0\xa6\x26\xcb\x9c\xd7\x15\x66\x37\xd7\xc4\x5c\x86\xc3\x7c\xeb\xff\x9c\x90\x9c\x9d\x40\xb6\xc2\x3c\x79\x91\x8a\xb7\x81\xbd\xf2\x00\xc0\x2b\x99\x76\x6f\x47\x5c\x48\x76\xcf\xc4\xb0\x17\xb8\x42\x9e\xa6\x17\x0b\x1b\x12\xac\x34\x8d\xb5\xd1\x75\xf3\x9d\x80\x3f\xfa\xe2\x9d\x19\x16\x9c\x42\x95\x5d\x6e\x25\x3c\x78\xe0\x5e\x79\x28\x49\xd1\xf8\x71\x95\xfb\x66\xa3\x57\x95\xb4\xc6\x0b\xc0\x29\xcd\xc9\x78\xca\xd6\x8b\xfc\x99\x9e\x7f\x56\xaf\x62\x5b\x2d\x77\x95\x08\x67\x15\x35\xdc\xc3\x41\x39\xaa\xdf\xfa\x7e\xe2\xf5\x73\x94\x2c\x4c\x0c\xf2\xe4\x8c\xd0\x8a\x41\x74\xec\xb6\xb3\x62\x46\xb3\xd0\xdb\x67\xa2\x60\x78\x07\x2f\x2d\xd0\xcd\xf4\x4b\xe9\xf6\x0a\xd4\x19\x2d\x2a\x15\x2a\x15\x07\x83\x23\xcd\xbb\x29\x43\x95\xeb\x70\xd5\x59\x34\x2e\xcd\xc0\xa0\xe5\x25\xc1\xf2\x58\xc6\x09\xe3\x23\xc3\x2b\xd7\x6a\x54\xd3\x50\x2f\x89\x4c\x84\x16\x6c\x51\xbe\x9d\x82\xee\xcb\x09\x98\xc1\x52\x0d\x1c\xa9\x69\x62\x11\xb0\x0b\x16\x6d\x5b\x34\x8e\xbc\xe9\x74\x72\x43\x18\xb5\x26\x7e\x94\x6b\x4c\x75\x88\x27\x14\x44\xca\x08\x62\xd8\x87\x87\x28\xd0\xa6\xf4\x3c\x86\x59\x0e\xd9\x48\xda\x2d\x7c\xbc\xdd\xee\x2d\x44\xfa\x21\xf8\x37\x8e\x4f\x60\xdb\x8a\x1a\xd6\x5c\xb9\x52\x1a\xb1\x61\x65\xc4\xda\x01\xe8\xc3\x45\x48\x0f\x34\xd1\x78\x3f\x74\xec\xa5\x2e\x96\xde\xd8\xb3\x1a\xc6\xfa\xf1\xca\x69\x31\xa0\x9d\x65\xca\x7e\x1f\xd9\x65\x73\x0f\x5e\x22\x09\xc1\x5b\x2a\x6b\x3f\x16\x71\x2b\xb2\x64\xea\xf3\x34\xdb\x68\x6d\x16\xa8\x43\x28\xa9\x98\xc4\x57\xa8\x79\x13\xde\x39\xeb\xaa\xf9\x15\xd1\x31\x77\x53\x94\x5a\xb2\x60\xc6\x68\xea\x2c\x8b\xe4\x11\x06\x75\xa0\xef\x1c\x99\x58\x9d\x3e\x5e\x4c\xb9\x17\x19\x4b\xd3\x9d\xfb\x9a\x64\x08\xd7\x32\x6f\x54\x89\x15\x2b\x5d\x44\xe4\xa0\x35\xf8\xa4\xc1\xf8\x91\x6b\x09\xb4\xbb\xed\x1e\xd7\x89\xc4\x1f\x1e\xfe\x7d\x3b\x1f\x83\xf6\xfc\x97\x77\xaa\x10\x1e\xdd\x6b\xb3\x65\x5c\x70\xa9\xe0\x50\x95\xc1\x11\x40\x87\x38\xd8\x25\xbb\x59\x10\xda\xe7\xae\x15\x8b\x62\x85\xf1\xc7\xdf\x9b\x5f\x6a\x3e\x24\xdf\x8a\xfc\x04\xab\xf0\x1c\x27\x65\x4c\x38\x56\xed\x70\xce\x72\xea\xce\x13\x5b\xce\xf8\x32\xbd\x2a\x67\x26\xa1\x9c\xd9\x18\xf0\xe1\xb5\x83\xec\xf2\x40\x84\x08\x9d\x2d\x13\xfb\xfa\xe0\xf6\xc1\x97\xde\x47\xc9\xae\xfc\x36\x3e\x42\x6d\x14\xdf\x5f\xc3\x81\xc5\xc8\x26\x9f\x3d\x4d\xb1\x4e\x98\x9f\x82\x61\xe9\x98\xd8\xe6\x68\x43\x07\x01\xa7\x83\x68\x2a\x9f\x3d\xa0\x03\xda\x7e\xca\x77\x82\x8e\xc8\x3d\x79\x92\xb3\x9a\xfd\x5a\xad\xb4\x94\x34\xd3\x04\x4b\x2b\x33\x9e\xbc\xcd\x2e\x39\x2d\x39\xe5\x64\x1f\x0d\x26\x7b\x5f\xad\xd0\x90\xb0\x87\x5f\xc3\xec\xc3\x4e\xe1\xb1\xd1\x46\xb2\x3a\xd9\x6c\x29\xb5\xee\xc0\xbd\x04\x35\x71\x54\xcd\x64\x57\x3b\xb3\x99\x97\xcb\xef\x34\x38\xa4\x32\xb7\x13\x8b\xb8\xe9\xc5\xaa\x31\xab\x47\x7b\x5d\x37\x76\xa6\xf2\x92\x23\x03\x71\xfa\x99\xaf\xcb\x72\x83\x46\x51\xa5\x30\xea\x6c\xad\xa6\x4d\x92\x47\xc2\x16\x90\xe7\x13\x90\xc3\x3f\xa5\xc2\xd0\xd1\x7e\xc4\x74\xc1\x5f\x3c\xbc\x47\x07\x31\xe7\xa1\xa8\xee\xa3\xe8\x32\x6c\xb9\xa6\x14\x23\x9c\xc9\x6e\x56\x6f\x43\x81\x99\x61\xf2\x94\xa2\x49\xdf\xa0\x2c\x83\x0d\x54\x60\xca\xa4\x15\xe2\xc6\x1f\x63\xd0\x21\xce\x06\x34\x04\xf0\x73\xf5\x38\xe5\x2f\xd5\x6c\x74\x57\x98\x99\xa1\x7a\x05\x95\x22\x52\xd6\x53\x98\xb4\xfc\xce\x50\x70\x05\x04\xc3\xe1\x05\xe9\x48\xdc\xb8\x8a\xf3\x57\xa7\xdd\x5f\x6b\x6d\xbf\x7b\x7d\xd3\x73\x83\xf6\x51\x25\xd4\x70\xbc\xa0\x10\xff\x15\x86\x70\x34\x1c\xd4\xb8\x0f\x54\xcd\xbb\xca\xac\x38\x54\x1c\xac\x10\x40\xe3\x00\x96\x6b\xae\x11\xbc\x14\x69\xc0\x6e\x3e\xaf\xdb\x50\x7f\x57\x24\x1a\x40\x3f\x75\x49\x54\x0f\x5a\xcc\x37\xb0\xc9\x48\x5d\xd6\x6d\xb5\x8f\x1e\x3f\x5d\xf8\x7b\x4a\x43\x5d\x0b\xd1\xdb\xe3\xb5\xac\x0d\xaa\x94\x9e\x16\x16\xa5\x7e\x52\x65\x2d\xd0\xa5\x10\xb6\x1e\xcc\xfc\x66\xc6\xa0\x34\x98\x12\x83\x43\xa6\x65\xae\x59\x62\x04\x2c\x40\x02\x66\xa0\x8a\xaa\x26\xd7\x16\xd6\x1f\xa0\x88\x87\x64\x0c\x51\xe2\xac\x1b\x0c\x24\xc8\x00\x0b\xef\x91\x8d\xc1\xec\x44\x7c\xf3\xf2\xeb\x8b\x71\xa7\x43\x39\x7b\xb2\x0b\x7d\x89\xf9\xc3\x4c\x90\x45\xec\x32\xe3\x42\x18\xc7\xa1\xab\x04\xa6\x61\x91\x4d\x60\xa1\x1d\x64\x16\x88\xe3\x36\xc5\x9a\x0c\x3a\xc7\xcc\xd7\xf6\x60\x84\x8b\x2d\xef\xf6\x06\x59\xb8\xd8\x66\x6b\xd8\xaf\xd1\x3b\x97\x5f\x88\x8e\x32\xc4\x97\x5b\xd4\x9f\xf6\x85\xba\x86\xae\x7b\x2f\x6d\xe2\x70\xf7\xf0\x29\x08\xfe\xc7\x8c\xc8\x75\x8e\x16\x8f\x98\x7d\xb4\x7d\x01\x1f\xab\x46\x4a\x8f\x5b\xb8\xfa\xaf\xce\xd4\xdd\x57\x52\x47\x5d\x57\xf8\xc3\xfb\xd9\x6b\x7d\x5e\x65\xe2\x96\x8e\x5f\x9f\x17\xa5\x7d\xfb\xb9\xc1\x24\x12\x53\xd6\xe0\x51\x25\x71\x5f\x24\x78\x7c\x45\xc3\x58\xa3\xfa\x6c\x66\xb4\xf0\x78\xff\xd0\x04\xc2\x95\x02\x99\x20\x56\x4c\x7f\x6d\xe5\x1c\xfb\xe4\x7b\x32\xde\x86\xfe\xd3\xef\xe7\xff\x74\x15\xa2\xdd\x6e\x4e\xe7\x63\xfb\xfb\xdc\x4b\xdf\x0b\x51\x9d\xfb\x2b\x5f\x2a\xd5\x73\x9b\x0d\x32\xcd\x62\x4c\x5c\xdc\xfa\x06\x1c\xc5\xcb\xf6\x30\xe4\xba\xaa\xf3\x0f\x29\x56\x7c\x61\x30\x2d\x8e\x5a\x25\x3d\xa2\x3d\x7b\x30\xa6\xa1\x86\xf3\xdf\x08\x4a\xdd\x3c\x61\xea\x75\x8b\xa3\x99\x9f\x59\x99\xd7\x10\x4b\x11\x15\xec\xab\xf3\x74\x0d\xe0\xbf\xdb\x5b\x09\xd3\x05\x3a\xe9\x0c\xed\x35\x17\x8c\xe0\xe6\x43\x40\x63\x50\xb9\x1e\xdd\x65\xdc\x6e\x57\x33\xd9\xf0\xf0\x85\xe2\x8e\x73\xae\x5c\x6c\x34\x8a\x71\x43\xbe\xef\x71\xf5\x04\x3d\x76\x69\x4b\xe5\x8e\x95\xb0\x71\x5d\x72\x36\x12\x7b\x8c\x5e\x06\xc3\xbd\xe3\x5f\x71\x4d\x45\x06\x89\x85\x94\x68\x09\xaa\x95\x4a\x5c\x30\x71\x11\x98\x02\x20\x8c\x79\x61\xca\xa0\xce\x69\x1e\x9e\x99\x8d\x60\x68\x12\x8d\x64\x4e\x51\xd6\x3b\x52\x31\x0e\x33\x30\x7c\xa8\x51\xe0\x0f\x98\x5a\x52\xad\x71\x14\x3f\x6f\x1e\xf1\xf0\x46\x43\x0a\xce\xe2\xe2\x05\x18\x4b\x5b\xfd\x61\x4a\x35\xfb\x6c\xd3\x45\xe0\xa7\x86\x62\xea\x2f\x25\x43\x8c\x69\x56\xdb\x15\x9a\x06\xb2\xd7\x0f\xc3\x12\xc6\x12\x47\x81\x40\x3f\x22\xf8\xc7\x2a\x94\xe4\x8c\x6f\x28\x1c\x98\xae\xc1\x94\xa9\x99\xdb\x29\xe6\xad\x40\x97\x0f\xaa\xad\xf1\x09\x70\x2d\x81\xa3\x84\xc5\xf2\x45\xc6\xd2\x17\x8a\x33\xa9\xee\xee\x58\x42\xef\xa5\xe6\x72\x81\xf7\xf7\xb3\x35\x9d\x87\x6a\x1b\xb6\xc5\xee\x6f\x35\x21\xab\x3d\xd0\xd8\xb3\x43\x8c\xfb\x73\x6d\x79\x1b\x63\xc0\xc9\x80\x1c\xc8\xfb\x4e\x34\xd5\x38\x7d\xc3\x58\xbd\x91\xad\x58\xd3\x3a\x74\x30\x44\x28\x20\x0f\xcb\x2c\xb0\xf3\xec\x0c\xd7\xfb\xcf\x8c\x64\xf0\x53\xde\xc4\xc8\x84\xce\x95\xb3\x75\x35\xf9\x4e\x29\xb7\x53\x82\xe8\x94\xd0\xdc\xdd\xe9\x2d\xe5\xbc\xab\xcb\xc0\x15\x9f\x80\x2c\xf3\xc9\x42\xbf\xec\x0b\x01\x2f\x98\xcc\xd7\xf3\xd8\xcb\x89\x58\xcd\xe1\x4d\x27\x5d\x40\xb2\xdb\xca\xde\x40\x09\x25\x56\x2a\xdf\x53\x9b\x65\xe0\xe7\x9b\xa2\x87\x5c\xc4\xf5\x06\xaf\x41\xfa\x93\xf4\x04\x8e\xe8\x33\xf8\x1d\x9e\x0c\xff\xc2\x99\x81\x84\xbd\x88\xbf\x19\xf1\x93\x68\x34\x1a\x5d\x00\xf1\xb3\xd2\x1f\x2f\xc9\xcb\x4e\x96\x3b\xc1\x38\xe4\x93\xf0\x79\x2d\x0d\xb1\x80\xe3\x75\x28\x2b\x32\x83\x2f\xc1\x58\x62\x7d\x87\xdf\xec\x05\xfd\xc7\x7b\xa8\x2c\x82\x55\xbf\xb9\x3c\x31\xde\xe5\x4a\x59\xa1\x30\xa3\x98\xdf\xae\x75\xa5\x7e\x56\x10\x85\x0e\x02\xc4\xfb\x03\x5f\xec\xbe\x39\x71\x3f\x70\xb0\x04\x2f\x6b\x7e\x94\x17\xd0\xe6\x07\x4a\xfe\xbe\x40\x19\x9b\xff\xe0\x80\xf6\xcf\xd6\x65\xaa\xa7\xde\xda\x1f\x6b\x60\xc3\x84\x5b\x12\x2e\xc6\xb4\xdd\x0b\x33\x09\x5a\xcf\x5d\x3e\xb0\x1d\x19\x8d\xfe\x5b\xea\xae\x15\x76\xad\xfe\xf4\x0b\x44\xad\xd1\x06\xd9\x30\x72\x5e\xc0\x39\x1a\x1a\x37\x23\x56\x3d\x80\x67\x1e\x94\x4a\xe0\xd6\x08\xaf\x5b\xde\xd9\xb8\x91\x89\xfa\x2e\x80\xf5\x24\xd4\x76\xbd\x02\x71\xcf\xc5\x36\x03\xd9\x4a\x12\x45\x1f\xc8\xfd\x52\x58\x5e\xab\x53\xcb\xe0\xe0\xcf\x53\x1b\x87\xbc\x34\x9b\xfa\xe5\xb3\x0d\xf6\x70\xff\x2b\xe2\xb8\xd0\xcc\xaa\x93\x34\x29\x1f\x06\x71\xbc\xb4\x7f\x76\x05\x29\xc6\x76\x49\x51\xf7\x90\xa7\x76\xf5\xed\x91\x34\x5d\x5f\x1b\xf8\x83\xfa\x07\xc2\x2b\x5c\xb1\x1b\x08\xa7\x1b\x02\xdb\x4c\x31\xba\xd3\x25\xe8\x0b\xed\x18\xec\xb3\xc0\x85\xc0\x63\xec\x54\x89\x65\x91\x16\x72\x89\xe5\x98\x46\x6d\x73\x70\xf0\x43\x7c\x33\x0c\x53\xdd\x66\xff\x4b\x49\x04\x13\x72\xd4\x53\x76\x7c\x36\x03\x8e\x3f\x64\x68\xf9\x01\x69\x15\xca\xaf\x7c\xbc\x04\x85\x2f\xbc\x8c\xb5\xe0\xde\xe1\xac\xb6\x80\x06\x75\xb3\x1f\x25\xd5\x42\xde\x0a\xfb\xd8\x75\x41\x4b\x40\xb3\xdd\x52\x91\xf0\x27\x06\x76\x53\x47\x49\x85\x02\x15\x36\x79\xaf\x3b\x67\x45\x8f\x9b\xf0\x62\x63\xb7\xf0\xdd\x40\xc8\xfa\xd0\x01\xd8\x00\x94\xf3\x6b\xa3\x55\xfd\x4c\xec\x74\x64\x76\x83\x18\x14\x53\x72\x0c\x15\x26\xd2\x1c\x0d\x78\x32\x5a\x14\x25\x5b\x24\x13\x1f\xbc\x88\x96\x84\xc4\xa1\x46\x90\x7f\x9e\xe3\x9e\xb3\xdf\xca\xf1\xcd\x5e\x77\x90\xa4\x65\xbf\x41\x2b\x7e\x06\x31\xf4\x70\x49\xa8\xed\x5a\xe5\xb2\x64\x49\x7b\x7c\x4e\x73\xb0\x82\x0b\x92\x4c\x3c\x41\x88\xe7\xe0\x59\x75\xa0\xab\x11\xd2\x5c\x42\xd7\xeb\x93\xfa\x91\x5c\x67\x2e\xcf\xdc\xb2\xcc\x4b\x4d\x92\x41\xe7\x0d\xec\xd9\xb1\x69\x9b\xad\xd0\xe9\x31\x89\xff\x5e\x72\xc1\x41\x86\x7c\x0e\x79\xbd\xe0\xc9\xed\xb7\x5b\x85\x01\x59\x95\x76\x34\xa8\x40\x15\xa2\x1f\x45\x41\xd7\x7b\xa4\x27\x05\x8c\x96\x18\xa9\x88\xf8\x41\xdf\xc9\x3f\x81\x58\xee\xe3\xb6\xb0\x69\x5c\x42\x5b\xa0\x5d\x4a\x54\xf8\x6c\x65\xd1\xd9\xe9\xe0\xc1\x3b\x3f\x58\x5e\xf0\xca\x0b\x69\xf5\x00\x56\xde\x47\xf8\x0d\x30\x83\x88\xbf\x0b\x29\x20\x66\xdf\xc7\xf9\xed\x42\xed\x7d\x98\xf3\x08\x09\x4c\xea\x43\xd6\x38\x4d\x9f\x89\x1b\x86\xaa\x48\xa9\x5e\x9b\x7e\xb7\xbb\x4e\x61\x9e\x8b\x3b\x23\xf3\xb4\x07\x1a\xa2\xe9\xb9\xc2\xd6\xa1\x4c\xd6\x9c\x82\x0b\x86\xf3\x2b\xca\x17\x59\xa8\xc4\x54\xb2\x2f\xab\x2f\x8b\x2e\xa3\x2f\xc3\x2f\x57\x2f\xfb\x2e\x4b\x2e\xe3\x3e\xc6\xaf\x43\x97\x23\x85\x99\x4b\x19\xe3\xe9\x1e\x14\x78\xe3\xc5\xe0\xb4\x5c\xde\xc0\x65\xf3\xbb\x8a\x85\x91\xa8\x84\xa8\xa7\x68\x52\xa8\x98\x31\x0f\xe1\x51\x3d\xf0\xe7\xb9\xab\xc4\xfe\x66\x34\x5c\x06\x27\x39\x07\xe3\x46\xad\xdc\xee\x82\x5a\x6d\x47\x97\x4e\x1f\x81\x8b\x25\xeb\xa2\x88\x6d\x3e\x5a\xe5\x2d\x62\x4a\x1d\xdb\x89\x07\xa4\x96\xa1\x24\x07\xaf\x9b\x24\xd2\xca\xf7\x05\xa7\x48\x1a\xc5\x39\x35\xe9\x21\x00\x7d\xf3\xd6\x05\x5d\xb5\x66\x83\x55\x36\x30\xd0\x65\xd3\xe6\x2f\x27\xb0\x34\x38\xeb\x47\xe4\x59\x13\xcb\xbd\xd3\xc6\x05\xe6\x57\xe0\x5a\xb3\x5c\x61\x08\x06\x0a\x5a\xac\x96\xa9\x3d\xcd\x0a\x57\x50\x90\xb1\xfe\x98\x66\xed\xa0\xa2\x07\xc2\x4f\x79\xbb\x21\x21\xcd\x42\xea\x15\x6d\x4c\xc7\xda\x9f\x4e\x63\x61\x43\x70\xde\x65\x79\x65\x36\x56\xb2\x07\x38\xfc\xb4\x9c\xbf\xb0\x63\xb3\x77\x1a\xfa\x83\xb7\x8b\xbd\x50\xb1\x40\x6a\x0b\xbb\x5c\x2c\xbd\x6d\x26\x22\x99\x86\xca\x86\x29\x2a\x82\x17\xe9\x3a\xc1\x2e\x3a\x85\xad\xa8\x6d\xd2\x67\xe3\x58\x0b\x3d\xfd\xbe\xd5\xc0\xc5\xef\x21\x6f\x5c\xc1\x30\x90\xc2\x68\x77\xef\xb0\xf3\x02\x6c\xd8\xdf\x5a\x93\x8f\x76\x9e\xb4\x88\x79\xb9\x94\xc9\x5d\xa4\x4b\xb1\x9e\xbc\x33\x1e\x3b\x72\x65\x69\x31\x62\xe2\xc9\xf4\xc5\x8d\xd1\xbe\xa5\xa6\xb3\x70\x0d\xf0\x68\x14\xbe\x71\x5b\xc6\x43\x78\x53\x23\xfc\x88\x60\x06\x3e\x75\xe0\x55\xb0\x08\x2e\xd0\x8a\x33\x1f\x6b\x60\xa6\x87\x5a\xe5\xe1\x1e\x6d\x98\x2a\xf2\xe3\xe5\x41\x04\xa3\x8a\x08\x41\x64\x15\x16\xa6\xa9\x37\x12\x20\x6a\x85\x62\x02\xbd\xc9\x4d\xb9\x5b\xca\xac\x0a\x1f\xc6\x10\xdb\x83\x0a\x9b\x71\xad\xe6\xd6\x42\xd4\xe1\x5a\xe3\xd7\x22\xe5\x0c\xab\x44\x85\x6d\xa5\x9c\xbf\x05\x4a\xe1\xc3\x10\x16\xd7\x66\xef\x37\xbc\x65\xe8\xaf\x3a\xf7\xe8\x05\xa7\x67\xa5\xa9\x62\xff\xf2\x85\xa3\x12\x03\xd5\x64\x7e\x65\xb0\x78\x44\x8e\x91\x9b\x05\x37\x33\x97\x54\x5a\x31\xc1\xe3\x65\x68\x93\xfa\xf3\x37\xe5\x39\xdc\x98\x2c\xc9\x30\xd5\x98\x7d\x45\x29\xec\x44\x67\x23\xab\xad\xd8\x19\x72\x6b\x70\x7f\xfd\x93\xb1\xdd\x1c\x42\xce\xec\xb3\x0f\x2b\x2c\xf6\x25\xd2\x73\x60\x58\x2a\x6c\xa7\x94\x54\x13\x4e\x17\x61\x2a\x5a\xb3\x08\x73\x5d\xb1\x20\x1e\xd6\x82\xf3\xa3\x33\x2d\xc5\xe6\x39\x5f\xb0\xe5\xcd\x71\x17\x10\xf5\xc8\xd9\x1d\x9b\x97\xc8\xdd\x8d\x3f\x77\xd5\x91\xc3\x7d\xac\x3a\x48\xd1\x7c\x0a\x04\x53\x83\xdf\x6f\x03\x03\x03\xf3\xca\x31\x35\x32\x33\x32\x32\x32\xe6\xe3\xdf\xf7\x13\x37\xe3\xeb\x9f\xd1\x84\x76\xf0\x80\x46\xe9\x30\xf1\x5b\xfd\x29\xf1\xfd\xfd\x9d\x1f\x9c\xfc\x17\x71\xe4\xd8\xc8\xc8\x04\xec\x1c\x0c\xcc\xec\x17\xfc\xda\x7f\xec\x98\x82\xe6\x06\x06\x06\x26\x6f\x89\x7f\x72\xe1\xe2\x06\x91\x4d\x04\x59\xd3\x82\xf9\xc2\x41\xcd\x82\x79\xe5\xc4\x69\xc8\xda\x62\x08\xa3\xd4\x79\x3f\xf2\xc5\x66\xd3\x45\x60\xb2\x43\x6a\x48\xcb\xa5\xd0\x45\x57\x00\xc5\x4f\x1a\x88\x7a\xa3\x88\x10\xa2\xc8\x0e\xc4\xc9\x42\xa8\x5c\x6d\x3e\x70\xbf\x90\x07\x8b\xfb\x65\x7a\x6a\xd5\x59\xd5\xf9\xf7\x5a\x92\x6b\x64\x05\xaa\xba\xbb\xba\x76\x57\x92\xa7\x97\x2c\x0f\x0c\xdf\x92\x7e\xbf\x8a\xab\x2d\x06\xee\xbb\x0f\xb6\xdc\xf2\x2b\xae\xfe\xa0\xf2\x15\xe4\x33\xf5\x73\xcf\x13\xc8\x94\x33\xf6\xc4\xa9\x3b\xd4\xa7\x75\x9b\xf3\xbc\xc9\x9c\xc6\x39\x32\xd8\x3d\x73\x10\x63\x58\xf2\xb7\xdd\x7a\xf1\x59\x89\x84\x9f\xfd\x80\xcc\x24\xb8\xac\x8f\x53\xf7\x9f\xac\x2c\xc7\x71\xe4\x3e\xca\xe5\x79\x24\x9c\x8d\x49\x41\x7b\x3e\xe6\x3d\x04\xd5\xac\x4b\xcc\x57\xe4\xc1\x84\x34\x9d\x2a\xe6\x20\x77\xf2\x8e\x6e\x6b\x21\x61\xa8\x62\xaf\x88\x1c\xc7\xeb\x7a\x45\x15\x4f\x99\xff\x62\x51\x4f\x71\x9c\x82\x58\x2f\x9f\x16\x25\x7a\xcb\x0a\xeb\xf8\x9b\x55\x5f\x27\x28\x78\x90\xd3\x03\xcb\xdd\xa4\xe5\xe3\x8b\xe6\x19\x2d\x90\x0f\xab\xc8\x1a\xb7\x25\xde\x9a\x4f\xf3\x39\xf4\x21\x66\x7e\xdf\x91\x8e\xa3\x0b\xd1\xcf\x7f\x95\x92\xe6\x29\x5e\xcb\xe3\x5a\x6b\x7e\x5e\x29\xcd\xee\x38\x36\x9c\xa7\xb2\x13\xb9\x2e\x99\x53\x3f\x72\x1f\xce\xaf\x2a\xf2\xa1\xd4\x0d\xed\x8a\x36\xeb\xa7\x49\x1c\x47\x0b\x9a\xe8\xc2\x8a\x85\x5d\x03\x64\x06\xf9\xeb\x32\x0d\xed\xda\x1d\xe9\xc7\x31\x6b\x4c\x3d\x35\x94\x17\x07\x04\x6f\xb4\x34\x4b\x9c\x3a\x0e\xbd\x87\xef\xca\x6f\x8c\x2f\xbb\x14\x3d\xd6\x1e\xfd\xb9\x8b\xbf\xe1\x05\x9f\xa2\x0a\x7f\x1b\xba\x47\xcf\x56\x34\xb0\x94\x7b\x19\x3b\xaf\xf5\xee\xb4\x6a\x76\xec\x19\x41\xbe\xff\x9c\x07\xd9\x71\xa2\xd7\x64\x33\x56\xec\x7c\x5e\xe2\x2f\xc5\xba\x94\x3b\xb3\xfa\x43\xf2\x7b\x88\x0e\x7c\x60\x85\x0f\x8a\xd6\xa3\x5f\x49\x21\x4b\xf0\xf7\xa0\x8e\x17\x7a\xa4\x5f\x21\xdc\xe5\x0b\x3d\x58\x3f\xd8\xb9\xec\x33\xbc\xbb\x94\xb0\xf5\x88\x96\xde\xb7\x20\x3d\x2c\xd6\x6b\x80\xca\x9a\x2e\xed\xcc\x34\x86\x6a\xa2\xe5\xa0\xbe\x74\x7b\xcd\x9f\x2f\x14\xbe\x20\xf7\xce\x98\x34\x97\xfb\x91\x8f\x1d\xbb\x30\xe7\x92\xdf\xac\x1d\x5d\xf1\x35\xe3\x3c\x7d\x78\x6a\x7d\xbe\xb6\xcf\x95\xeb\x2b\xb5\xc3\x20\x1e\xb4\x3f\xf3\x59\xdb\x06\xc7\x54\x3e\xbd\xa7\x2f\x64\x49\x22\x05\x04\xf7\x1f\x68\x7f\xdd\x88\xc4\x56\xc7\xbe\xf8\x7d\xc9\x7c\xf6\xd5\xfa\xd8\x94\xc1\xb4\xbe\x11\x85\x1e\x73\x40\x81\xf4\x85\x7a\xd5\xc5\xe8\xfb\x95\x22\x3d\x66\x04\x1c\x00\xdd\xb1\xee\x03\xbc\xa1\xad\xab\x9a\x2f\x5b\x50\xc0\x65\x22\xc5\xda\x7a\x40\xaf\xbc\xb9\x84\x76\xdf\x7c\x73\xca\xda\x95\xde\xba\x9d\x50\x6e\x68\x1d\xcd\x3d\xe9\xf5\x9f\x73\xe4\xde\x0a\x77\xc1\x34\xaa\x0b\xfb\xd8\xee\xa0\x87\xa4\xd9\x1b\xc4\x69\xaa\x93\xa6\x0f\x66\x2e\xf8\xcf\x89\x67\x81\x16\xcf\xc0\xe7\x37\xd1\x8f\xe1\x2c\x3d\x8b\x4e\xf9\xb2\x6e\x53\xff\xc2\x1b\x50\x00\xfb\x6c\x20\xd1\xeb\x0b\x86\xdd\xcc\x0c\x76\x94\xbd\x23\x1d\xc3\x8a\x7f\xee\x0b\xb1\xf6\x4d\xe1\x7d\xb3\x4b\x85\xee\xaa\x6c\x6e\xe0\xd9\xf8\xb4\x85\xde\x13\x8c\x77\x7b\xd1\xa7\x48\xbf\x24\xd2\x95\xf7\xe6\x10\x51\xa3\x63\x6a\xde\xcd\x9a\xa8\x6e\x73\x45\xff\xd7\x19\x22\xe0\x66\x73\xc7\x0f\xf2\xb6\x5f\x1c\x6d\x4e\x5c\x08\xae\xf7\xfa\xac\xee\x48\xcf\xbf\x07\xdd\x8c\x6f\x07\xc3\x67\xf7\x86\xf1\x09\xce\xef\xce\x2b\xa7\x34\xcd\x57\x6d\xce\x92\x60\x7c\x6f\xee\x50\x81\xa1\x33\x02\x05\xcf\x7a\x46\xe4\xaf\x59\x34\x8a\x09\xe9\x21\x4a\x4c\x27\x6b\xb3\x75\xb6\x7c\xc4\x1f\xf3\x58\xf2\xb5\x4e\xb6\xf4\x5a\xf9\x09\xfe\x23\x22\x2a\x36\x17\xe4\xce\xc8\x44\xeb\x3a\xd2\x4b\xf3\x6f\x50\xe0\x45\xce\xcb\xeb\x57\xdf\xdc\x43\x67\xcf\xde\xcd\xdc\x83\xbf\xc2\x62\x7f\x20\xd1\x37\x38\x73\x52\xe5\x4f\x2c\x29\x8e\x1f\x66\x52\xe1\x21\xc2\x79\x6a\x5c\x6a\x34\xe7\x70\x75\x52\xa3\x92\x32\x14\x63\x3f\x9e\x65\x9b\x0c\xfe\x21\xe6\x24\x11\x14\x95\x2c\x42\x94\xb2\xc0\xaa\x68\xef\x4e\xdd\x5d\x4b\x69\x8f\x8f\xaa\x78\xbb\xd0\xcc\x17\x8b\x94\xa9\x39\x93\xfd\x4e\xa4\x59\xa8\x6f\x4a\x57\x2b\xcd\x39\x12\xcb\x53\xed\x52\x73\x6f\x51\xa3\xff\x39\x22\xbd\x72\x76\x3a\xed\x83\x78\x6f\x83\x05\xe3\x54\x25\xce\x98\x8e\x0b\xa6\xd0\x7a\x58\xca\x93\xa7\xa2\x8f\x3d\x99\x8a\xa3\xd9\xb1\x02\x9f\x72\x6e\x29\xeb\xf0\x68\x07\xc6\xe9\x79\xbf\xad\x9a\x28\x89\x9c\x20\xb9\xe8\xfb\xe8\x08\x44\xf6\xea\x23\x46\x5a\x7f\x10\x6b\x3e\x95\xa9\x44\xe5\xc7\x1f\xae\x84\xe5\xef\x05\x1c\x8f\x76\x73\xb6\xf6\xee\x5f\xe4\xd2\xb1\x1f\x7b\x2e\x31\x09\x29\xb0\x72\x71\x88\x96\x27\x40\x14\xc4\xcf\x51\x56\x72\x1b\xb0\x9f\x9e\xf1\x62\x1c\xc9\xd0\x3f\x4b\x05\x00\xad\x61\x05\x6e\x21\x6e\x6d\x46\x0d\x68\x7d\xde\x93\x6f\x14\x73\xc1\x40\x30\x4a\xdd\xee\x8c\x89\x8c\xad\x85\x9e\xf8\x1d\x30\x2a\xb4\x89\xa0\xb6\xcb\xd6\xc3\x5e\x7e\xe7\xab\xe6\x12\x92\x73\x0f\xa1\x40\x49\xe2\x4a\xd5\x22\x0c\x39\x39\x4b\x97\xae\x82\x7e\x78\xbe\x6e\xc0\x7b\xa4\xb4\xca\xcf\x1c\x11\xc0\x1a\x26\xa1\xfe\x5d\x25\x3e\x5f\x37\x73\xe8\xf5\x88\xbb\x65\x5f\xe1\xe5\x4b\x81\x85\xa2\xdf\xa5\xf8\xce\x2e\x68\x19\xc6\xf0\x4d\x89\x17\xa1\xce\xd8\xe9\x4c\x56\x4f\xf0\xe3\x5a\x32\x21\xa1\x12\x35\x3e\x1e\xfc\x08\x79\x60\x3c\x38\x1c\x5c\x0f\x3a\x1c\x6c\x76\x10\xa0\x66\xfd\x93\x3d\x72\xde\x15\x67\x3b\xb2\xd0\x9f\xab\x19\x47\x78\x0f\xd5\x09\x0f\xb6\x5d\xb1\x52\x30\xfa\x63\x6e\x9d\x78\x66\x03\x44\x30\xd7\x5f\xf0\x82\x33\xab\x02\xf9\xf0\x87\xe4\x45\xd6\x65\x4c\x99\x2a\xc9\x15\xfd\x8f\xe0\xa1\x36\xb1\xe2\xb6\xe7\xc2\x22\xe4\x09\xf3\xdf\x56\x69\x05\xb0\xbc\xe4\x3b\xa6\xe8\x0d\x71\xe5\x40\xb8\x4e\x55\x00\x37\x66\x9c\xe0\x3c\x15\xde\xf5\x12\x80\x29\xf7\x03\xd7\x7a\x51\x71\x64\xce\xcc\x11\x8b\x9b\x79\x9a\x39\xa2\x77\x23\x27\x41\x0b\x34\xda\x84\x05\x9f\xaf\xb5\x6a\xc2\x9d\xee\x0a\x14\x8c\xcc\xe1\x62\x1b\x53\xa6\x45\x4a\x38\x19\x0a\x24\x3a\x75\x16\x78\x30\x1c\xa8\xc1\xe2\x91\x8d\x01\x74\x45\xbd\x7e\xc8\xd5\x8f\x82\x9a\xc3\x7c\x64\x37\x74\xa3\x3d\xa7\x32\xb4\xf9\xde\xfb\x01\x73\x2e\x6c\x8c\x92\xc3\x70\x16\x6d\x3f\xf2\x68\x33\xd7\x68\xce\xc9\x9d\x56\x35\x0e\x7d\xc9\x5a\xd1\xee\x5c\x10\x6f\x6c\x5d\x4a\x5a\x1f\x75\x22\xc7\xdc\xa7\x99\x61\x1d\xa4\x73\x2e\x9e\xbc\x5a\xf2\x6e\x4c\x21\xb6\x39\x6f\x09\xed\x82\xf6\x24\x7c\xec\xcd\xb0\xb2\x33\xa6\x2c\x3e\x36\xe5\x76\xe8\x97\x37\x43\x88\x75\xb9\x23\x75\xf7\x73\xe5\x76\x39\x0e\xda\x07\xad\x7d\xdf\x74\x2f\x83\x24\xe1\xb2\x3c\x8b\x1c\xb1\x79\x3c\x55\x1d\x91\x59\xb7\x23\x89\xdf\x6f\x6d\x04\x3f\x54\xce\x52\xa3\xf7\x60\x6e\x6f\xc1\x78\x90\x0f\x02\xf1\x2c\x29\x11\x05\x22\x81\xee\x51\x3c\x91\x95\xae\x90\x7d\x92\x5a\xb2\x91\x53\xf9\x23\x04\xa5\xa7\xca\x6e\x04\xa1\x81\xd0\xad\xf1\xc5\xdf\x5c\x0f\xbc\xc1\xab\xe8\x7c\x8a\x8b\x87\xe4\x17\x54\x0b\x7e\x70\x8a\x0a\xcd\x81\x78\xfd\xb3\x80\x77\xdc\xfb\x59\x96\x72\x39\x37\xcb\xa2\x7d\x02\xdb\x53\x80\x3b\x91\xe3\xdc\xf0\xfe\x8f\x3e\xbd\x02\x49\xac\x9e\x66\x80\xdf\xdf\xf5\x18\x60\x4f\x58\xda\xd4\xa5\xfe\x49\x76\xc7\x8f\xd3\xea\x1a\xc3\xe1\xf4\x0b\xab\x8e\xd9\xce\x89\x88\x43\xc4\x03\x47\x96\x43\xdd\x91\x9d\x22\x4f\xa4\x8b\xf6\x57\xac\x9b\xa0\x6e\x12\xec\xbd\x6b\xe7\xb4\xef\x03\xb9\x5d\xcb\x1b\xf0\x3e\x3e\xb1\xa5\x5f\x2e\xc4\x0f\x84\xfc\x83\x91\x54\xb7\x7e\x32\x01\x02\xbb\xa7\xaa\x17\xb8\x96\x07\xdc\xbd\x06\xf3\xcd\x41\x8e\xa5\x60\xf1\x8c\x0b\x2f\x68\xbb\x8c\xfb\xdf\x70\x33\xf5\x5a\xbe\xfa\x7a\x12\x98\xe6\xd1\x76\x49\xd4\x6f\x52\x65\x5a\x7d\x72\x77\x08\x99\x68\x10\xe6\x32\x69\x10\xf0\x66\x32\xdc\x93\x5c\x18\xd0\xb4\xe6\x32\xbe\x13\x29\xfb\x34\x0c\xf8\xf4\x87\x13\x8e\xe3\x5e\x99\xf7\x67\x2c\x98\x7e\x42\x1c\x6b\x6e\xb1\x72\x14\x9c\x42\x76\xc7\x06\x05\x42\x65\xff\x88\x70\xcb\x7f\x67\x56\x99\x9a\x57\x89\xff\x53\x43\x4e\x75\x16\xa0\x50\x1d\x26\xbe\xad\x91\x56\xa0\x3f\x5f\x33\x99\x0b\xef\xd9\x1c\x59\x23\x6d\x63\xd8\x3e\x8f\x4f\x71\x36\x9f\x4b\x25\x7a\x8a\xfc\xd7\x71\x3c\xd1\x01\x33\xe5\xa5\x54\x4c\x3a\x27\x81\x0a\xb6\x1b\x57\x3f\xc1\x76\x07\x29\xcd\x62\x00\xcb\xb2\x5b\xc3\x49\x51\x96\x59\x8d\xe0\x59\x68\x4d\x44\x7e\x18\x43\xb4\xc7\x97\x89\xf5\xf8\x10\x9a\x60\x58\x26\x47\xcb\xf5\xc6\x3b\x05\x39\xdf\xec\x9e\x25\x87\x8f\xd2\xa1\x55\x46\x7f\x77\x25\xf4\xbe\xc0\x22\xcc\xc7\x3b\x50\x5e\x0c\x2f\x64\x4a\xc5\x05\x53\xdc\xcd\xda\xe7\x26\x2c\xfa\x13\xc0\xc0\xba\x03\x98\xe7\x57\xa2\x4c\xe9\x20\x72\x7a\xff\x4d\x80\xb2\x95\x4c\xd4\xdb\x03\xc6\xdc\xbb\xb0\x88\x7f\xf3\x06\x70\x24\x3e\x18\x9e\xdf\xc6\x26\xfa\x5c\x87\x4f\x48\x3e\x53\xac\xff\xa2\x66\x81\x00\xbc\xc2\x7a\x43\xa0\x9b\x43\x17\x9a\x33\x6d\x46\x9a\x4d\x22\x98\x2b\x0c\x0f\x99\x45\x0c\x5b\x62\xe0\x49\x2c\xf9\x22\xb8\xf7\x89\x6c\xad\x39\x11\xc7\xb4\x39\x56\x7c\x5f\x21\x64\x3a\x1f\x89\xdd\x13\x24\x08\x5c\xd3\xb0\x06\xf7\xc0\x4e\xbb\xfe\x60\xcd\x8b\xaa\x4f\xae\x78\xe7\xbf\x4b\xde\xe7\xc8\xfc\xfc\x7d\x5f\x0e\xd8\x53\x0b\x90\x6c\xe6\x8c\xdb\x26\xce\xbc\x78\xe4\x0c\xda\x93\x63\x9b\x19\xd9\xd2\x06\xe1\x89\xf6\x6f\xe4\x64\x73\x1f\x8d\xdf\xe5\xc4\xd4\x75\x4e\xfb\x10\xb5\x9e\xa2\x77\xa3\xe8\xc7\x54\xb4\x67\x74\x50\x4c\x3b\xc3\xe2\xa5\x37\xb5\x21\xcc\xa5\x31\x0f\x83\xd4\x32\x8f\xa7\xcd\xa1\x7a\x35\x8b\xcc\x31\xfd\x03\x73\x7f\x3f\xe0\xf3\xa3\x01\xa6\x08\xcd\xd0\x5c\xf6\x0e\x3c\x7b\x40\xa1\xae\xad\x78\x8e\x9a\xae\x58\x68\x77\xe6\x88\x7a\xab\xf7\x7d\x58\xbd\x17\xc0\xfe\xf8\x17\xf2\x0f\xa9\x03\x7f\x78\x22\x07\x71\x53\x96\x5d\xa7\xb9\x8c\xab\x4b\xc7\xf1\x3d\xc2\x9c\x48\x42\xa0\x6c\xb0\x2a\x9c\xbf\xe7\xa2\xe3\x1a\x7e\x43\x5b\xb6\x8e\xef\x6d\x20\x23\xc1\xcb\x90\xa3\x20\xf7\x7b\xa6\x27\x8d\x0f\x52\xc1\x2b\xc9\x27\xf2\x10\x05\xe2\x6e\xe4\x80\xf1\x1b\x81\x31\x23\xe1\x8c\xe4\xbe\x5f\xec\x1b\xee\x23\xdf\xac\x9d\x22\x53\x75\x32\x69\x50\xef\xd2\xf4\x19\x42\xef\xac\x4b\xda\xec\x81\x32\xe5\xe9\x13\xdf\x07\xa3\x12\x2b\xbc\x5e\x09\x96\x67\x78\xa7\x58\xef\x94\x53\x67\x34\xf2\xda\xc4\x54\xc4\x38\xe2\xb3\xc3\xdb\xe4\x76\xc8\x1a\xfd\xe3\xf1\x80\x60\x24\xab\x7b\xb6\x80\x27\xd0\x3b\x72\xcf\x73\x3f\x23\x26\xa1\x73\x32\x68\xf3\xa5\xc2\x9d\xd8\xff\x65\x21\x25\x32\x82\xef\xe3\x0d\xdf\x1e\x19\xf0\x90\xd8\x13\x09\xfa\xce\xe8\x52\x04\x05\xe4\x3b\x5d\xe7\x0f\x5d\x51\x0b\x1c\x0f\xdf\xe0\xda\xce\x79\x07\x06\x5b\x42\x8d\x60\x14\x84\xfb\x0e\xf7\x1c\xd1\xf5\x14\x8d\x67\xbf\x1f\xb8\x47\xd4\xdc\x25\xb5\xce\x36\x85\xf3\x99\xc1\x23\xa7\xd2\xbb\xc8\xb4\x69\x45\xd9\xc1\xae\xca\xde\x6f\xed\x47\xdb\x9d\xf1\x6d\x34\x29\x34\x1d\x6b\xb9\x4e\xa7\xd5\x02\xa8\x74\xff\x82\x64\x82\xbe\xeb\xed\x30\x15\xb5\xa9\x88\x37\xaa\xea\x9a\x56\x8a\xcc\xab\x1f\xba\xc7\x28\x37\xb2\x0a\x49\xf4\x57\x29\x54\xda\x38\x5a\x2f\xc8\xff\x75\x41\x4f\xf5\x89\xfa\xf5\x92\x6c\xbc\x8d\x74\xf1\x27\xd9\x33\x89\xae\xe6\xb2\xbf\xd0\x6d\x78\x1e\x9a\xf1\x7b\x71\x94\x68\x0c\xeb\x69\x2b\xce\xff\x96\x69\x6b\x14\xfc\x9d\x68\x9f\x44\x77\x81\x49\x7a\x31\x13\xa0\xea\x92\xdd\x3d\xf1\x96\x74\x03\xbf\x86\x85\x14\x94\x15\xe0\x40\xa2\xda\x46\xb1\xad\x83\x7a\xd3\x2f\xc4\x01\x46\x68\x7f\x60\x0e\x51\xb9\x10\xff\x52\xe0\x24\x14\x00\x03\x82\x2a\xff\x20\xfe\x80\x30\xef\xcd\x77\xfb\xcf\xff\x92\x67\x9a\x7c\xb2\x60\x16\xec\x87\x9c\xd0\xf4\xcf\x30\x04\x04\x24\x23\x01\x08\x30\xc2\xdf\xe0\xf2\x60\x5e\x39\xa9\xc9\x7b\x36\xe8\xc2\x18\x63\xfd\x3b\x25\xf2\xb6\x25\x46\x0b\x2a\x3d\x89\xc2\x62\x83\x31\x3b\x2d\x29\x58\x21\x9c\x5b\x82\x67\xf2\x56\x26\x3f\x4b\x35\xcf\x39\x78\xa5\xd3\x28\xbb\x8d\x3d\x92\x12\x6d\x0d\x85\x6e\xa1\x46\x68\x89\x85\x7a\xb0\x7b\x1e\xd5\x21\x89\x07\x1d\xa9\x4c\xd1\x1b\x45\xe4\xa5\x4e\x38\x2d\x4f\x3e\x5e\x67\x37\xa0\x1a\xae\xf8\xc2\x43\x5f\xc7\xc7\xf1\xa7\x90\xfe\x81\xcc\x36\xc4\x61\xf7\xe8\xb0\x9d\x90\x05\xe9\xb1\x95\x3d\x88\x74\x0c\x06\xcb\x54\xdb\x7b\x64\xde\x97\x5d\x60\x19\x77\x2c\xd3\xd6\x9c\xd6\xfc\x1d\xbd\x09\x3d\xb7\x19\xd3\xa6\xbc\x00\x5f\x0d\x3d\xc1\x92\xe1\x41\xda\x39\x07\x3c\x9e\xf5\x72\x63\x39\x84\x76\xfb\xb9\xe6\xe9\xed\x02\xba\x0c\x00\xe6\x3e\x5d\x06\x93\x29\x67\xfa\x7a\x00\xac\xfb\x8c\x77\xea\xf3\x5a\x9a\x2c\x08\xd8\xd3\xda\x13\x61\xef\x69\xe1\x4d\xf8\xb2\x83\x9c\x36\xe5\x75\x1d\xd0\xda\x13\x8c\x1d\xfe\x23\x3e\xd1\x24\x0c\x17\xc3\xe4\x71\x3e\x32\x62\x80\x59\x44\x8e\x44\xba\xbc\x04\x12\x75\x0e\xca\x43\x79\x10\xe9\x79\xff\x2f\x04\x02\x08\x53\xd6\x20\x73\x43\xba\x2e\xc9\xf6\x9a\xf0\x8e\x32\x7e\x71\x41\x6e\xb4\xb7\x0f\x6b\x7c\x5f\x2c\x7a\x89\xe9\x8f\x85\x49\x7b\x53\xf3\xcd\x1f\x23\x26\x94\x93\xdf\xe8\x32\x16\x2a\xf2\x66\x62\x91\x78\x17\xd2\x38\x8c\x03\xcb\x62\xb2\xcc\x47\xd1\x3a\x59\x40\x23\x9a\x66\xb7\x09\xf9\x98\x34\xa2\xb1\x1a\x12\x33\x86\x16\x33\x47\xbe\x9f\xea\xd7\x5b\x03\xb8\x9b\x15\x4b\xef\x28\xea\xd7\x9b\x2d\xb9\x80\x1f\xf2\x2e\x31\xbc\xcb\x78\x96\x57\x3e\x4e\x5a\xf6\x2d\xb6\x54\xd8\x33\x12\xd5\xfe\xdd\xb1\xa7\x12\xea\x12\xad\xaf\xfa\xc1\xfc\x36\xbc\x80\xfa\xa6\x65\xec\x1c\xd9\xd4\x51\x6b\xb2\xe7\x1e\x88\x7a\x13\xb1\x5d\x06\xaf\x64\x11\xf2\x52\xb3\xb2\x63\x6f\xf4\x6e\xca\xdc\x02\x43\x9b\xaf\xf7\x93\xa3\x32\xe5\x63\x01\xc2\xc5\x9b\xa1\x2e\xbd\x95\x24\xc5\xb5\x93\x39\xfa\x68\x6e\x32\x9d\xc8\x32\x7b\xcd\x96\xf0\x16\x1b\xf4\x9b\xa4\x2b\x3d\x31\xe9\x8e\x93\xee\xf8\xca\x4c\x55\x6b\x24\xb3\x0c\xe9\xd9\x4a\xda\xd4\xf9\xca\x79\x7f\x6a\xac\xe2\x19\x33\xc9\xd3\xa1\xee\x4a\x16\x2a\xfd\x2a\x74\x9d\xf0\xbf\x04\x11\xe7\x32\x61\x3a\xd5\x20\x17\xbb\x3a\xf2\xca\x78\x5e\x96\xe6\x50\x8d\xb2\xa6\x7e\x9f\xe2\x96\x0e\x87\x59\xf9\x39\x32\xac\x39\x34\x39\x62\xb6\x77\x95\x63\xda\x6b\xc3\x0b\xc4\xef\xa8\x33\x5c\x73\xa0\x2d\x7f\xd5\x5b\x80\x81\x01\x57\xc2\xcd\xe8\xd9\xb7\xd8\x2d\x77\xa5\xb7\x26\xda\x92\xf7\x37\x31\xf3\x27\xb8\x38\x65\xe6\xe3\x1d\xfc\x5c\xcc\x3a\xaa\x57\x8e\xbf\x26\x94\xdb\xe1\x44\x93\xbb\x7a\xa6\x09\x15\xae\x56\x59\xfb\x74\xca\x7a\x5a\x0e\x9d\xa2\x51\x66\x66\x6f\xd3\x4e\x1b\x7b\x1a\x7d\x1c\x09\xd3\xd4\xf4\xf4\xf4\x74\x42\xe6\x33\x73\xbf\xff\xf4\x74\x43\x42\x66\x55\xc9\xb3\xdc\xc9\x87\x6b\x80\xc2\x22\xf9\x4e\xdf\x8e\xbf\xa3\x26\x35\xb5\xdc\x67\xbf\x20\x08\x0f\x3b\x71\x08\xa3\xd4\x41\x46\x3f\xbf\x8b\xc1\xdd\xf4\x3c\x6d\xb9\xb6\x12\x5f\xa5\xbd\xd4\x01\x1a\x32\x84\xcd\x8c\x04\x9e\x7b\x62\x18\x05\xa3\xe0\xe7\x30\xd3\x8f\xe2\x06\x84\xb4\x61\x38\x2d\x58\xfc\xc1\xb1\x06\x58\x3b\xb8\xec\xc1\x93\x06\x28\x3b\x58\xdd\xc1\xd5\x06\xc4\x1e\xd8\xb6\xf0\x2b\x23\xdf\x75\x70\x8f\xb0\x5c\x23\xcb\x75\x28\x8f\xf0\x1d\x23\xcf\x75\x88\xe7\xb0\x5e\x23\xc7\x75\x98\xe7\x70\x66\x9c\x48\xb4\x94\xc2\x1f\xd0\x19\x4a\xe1\xb0\x19\x61\x9f\x46\x81\x5c\x60\x48\x61\xa1\x00\x23\x2e\x48\x8d\x41\x0c\xb9\x61\x84\xe9\xa1\x42\x27\x1c\x02\x24\xc9\x81\xbf\x4e\x18\x04\x88\xe3\x03\x8d\x4e\x04\x04\xc8\x54\x03\x7f\x9c\xd0\x72\x10\xca\x07\x2a\x9d\xf0\x72\x90\x2c\x07\x32\x9d\xb0\x72\x10\x4f\x07\x3a\x95\x42\x1f\x06\x42\x7c\x6c\xd8\x9e\x24\x6c\x20\xf1\xe6\x21\xa1\xe8\xad\x44\x61\xec\xb4\x10\xf5\x9d\x0a\x60\xfc\x9d\x06\x43\xd9\x01\xa2\x60\xa4\x62\x4c\x30\x0f\x0d\x60\x31\x0d\x58\xb3\x91\xf0\x00\x91\x8e\x9f\x0c\x11\xb2\x00\x95\x0e\x04\x86\x48\x5a\x80\x4c\x07\x5c\x5d\x84\x2d\x40\xa7\x03\xa9\x2e\x12\x1f\x20\xd1\x01\xeb\x10\xa1\x0b\xd0\xe8\x40\x74\x88\xe4\x05\x28\x74\xc0\x5f\x47\xf8\x02\x0c\x3a\x90\xaf\x23\x61\x00\xc2\x5e\x3f\x89\x22\x24\x01\xca\x5e\x08\x44\x91\x54\x00\x69\x2f\xb8\xbc\x08\x4b\x80\xb6\x17\x52\x5e\x24\x36\x40\xdc\x0b\xd6\x20\x42\x13\xa0\xee\xc5\xda\x03\xb5\x0b\xe7\x18\xda\x3e\xcc\x0b\xc8\xbd\x65\xf0\xe2\xec\x81\xd9\x85\xbf\x09\x7d\x19\x86\x01\x84\xde\x92\x82\x98\x7a\xa0\x89\x83\x13\x86\xc6\x01\x87\xb7\xb0\x20\x72\x3f\x38\x01\xc4\xfc\xe0\xb9\xa1\x53\xc0\xc3\x2d\x14\x88\xac\x07\xc9\x30\x84\x71\x58\x13\x50\x7d\xcb\x0e\xe2\xf1\x83\xe8\x83\xdd\x0b\x71\x1c\xf6\x04\x74\xdf\xf2\x83\x04\x3e\xc0\x02\x7e\x0a\x86\x10\x0f\x2b\x02\xca\x6f\x59\x41\xdc\x1f\x3f\x02\x60\xfb\x43\x0c\x87\x1d\x01\xed\xb7\xd0\x1f\x48\x01\xc8\x81\x41\x82\x43\xf9\x80\xb9\x5b\x6c\x10\xed\x07\xe2\x17\xd2\x77\x50\xe0\x50\x3f\x60\xef\x96\x18\xc4\x58\x86\x82\xf2\x97\x29\x0e\x77\xda\x04\xe9\xa1\x92\xd0\xe9\x27\xbc\xd6\x88\x31\xc1\xa0\xb2\x5e\xc4\x94\x33\x54\xdd\x48\x9c\x93\xe9\x36\x24\xe7\xe8\x8c\x93\xeb\xf6\x8f\xf6\x91\x5a\x27\xdb\x6d\xe8\xbd\xb0\xad\x03\x8f\x0e\xfe\xeb\x20\xde\x03\x85\x0e\xd6\xeb\x90\xee\x03\x87\x0e\xde\xeb\x60\xdf\x03\x83\x0e\xce\xeb\xd0\xf7\x03\x9c\x78\x53\xd8\x29\x2d\x61\x08\xf9\x9a\x03\x48\x85\x83\x80\x0e\x41\xa2\x20\x98\x03\x61\x2f\x26\xa2\x90\x6a\x27\xb8\x72\x67\x68\xcb\x3b\x25\x3e\x04\xe4\xf1\x5f\xb7\x52\x7c\x70\x09\x63\xa6\xb7\x5a\x7c\x48\x09\xe3\xe8\xb7\x62\x7c\xd4\x4f\x3c\x79\xb1\xe5\x80\x4a\x2f\xbc\xbc\x78\x4b\x40\xa6\x17\x56\x5e\xdc\x29\xa0\x53\x6b\xf8\x61\x7e\x88\x87\xa3\xe1\x0f\x9c\xee\xfa\x18\xd2\x66\x07\x5e\x37\xd0\x08\xf9\x1d\x58\x14\x69\x3b\x3f\x0e\x26\x1a\xeb\x84\x74\xea\x0c\x8e\xed\x4c\x9f\x97\x80\x0d\x08\xf7\x42\x35\x88\x4d\x07\x94\x7a\xe1\x1a\xc4\x6b\x02\x52\xbd\x30\x0d\xe2\xd6\x00\xad\x5e\x84\x06\x09\x9c\x80\x38\x2f\xf4\xdd\xd8\x76\x40\xad\x17\xfe\x6e\xbc\x27\x20\xd7\x0b\x7b\x37\xee\x05\xd0\xeb\x45\xbc\x9b\x80\x0c\x08\x05\xa1\x08\xc4\x26\x00\x8a\x41\x38\x02\xf1\x8a\x80\x64\x10\x86\x40\xdc\x1c\xa0\x19\x44\x20\x90\xc0\x08\x88\x01\xa1\xf5\xc5\xd6\x03\xaa\x41\x16\x7e\xf0\x7d\x98\x7b\x11\x8e\xe3\x9e\x00\xde\x3b\x7d\x90\x83\x1f\x72\x1f\xf6\x5e\xe4\xcd\x38\x32\x00\xe6\x4e\x14\x64\xec\x87\x28\x18\x42\x3c\x9a\xb0\x3f\x7e\x87\x0e\x92\xfe\xc0\x08\xc0\x13\x0c\xcd\x1f\x9d\xdb\x3f\xbd\x83\x07\x89\xfb\x11\xf6\x87\x19\x8e\xd5\x03\x34\xef\x6c\x41\xee\x1f\xd0\x01\xe8\xfd\xe1\x7b\x63\x37\x00\xcf\x3b\x5f\x90\xff\x07\xf8\x17\x4a\x60\x98\xe0\x58\x3e\x40\xf1\xce\x12\xe4\xfa\x01\xf5\x85\x16\x18\xde\x3f\xb6\x07\x70\xbc\x43\xfc\x20\xfc\x22\xfa\x0e\x0a\x1c\x11\xdc\xcf\xbf\x63\x04\x69\x7e\xe0\x7f\x11\x7e\x07\x7f\x8f\x04\xee\xf7\xdf\x09\x82\x0c\x65\x50\x51\xd0\x94\xb3\x58\x52\x4a\x09\x8e\xad\xa3\xe0\xd4\x4a\x8c\xf1\x0a\x95\x75\x24\xa6\xac\xa1\x6a\x4b\xe2\xac\x4c\x37\xc3\x38\x4a\x67\xac\x5c\x37\x43\xda\x4a\x6a\xad\x6c\x37\x23\x76\xc5\xb6\x16\x3d\x5a\xf8\xaf\x84\x78\x17\x15\x5a\x58\xaf\x44\xba\x17\x1d\x5a\x78\xaf\x84\x7d\x17\x0d\x5a\x38\xaf\x44\xdf\x17\x71\xe2\x54\xff\xfc\x53\x23\x0d\x95\xab\x5a\x84\x94\x5f\x0c\x68\x11\x24\x14\x82\x59\x14\x76\x63\x22\x14\xa9\xb6\x8a\x2e\xb3\x8e\xb0\x38\x53\xe2\x89\x45\x2a\xff\x05\x94\xe2\x89\x8e\x2f\x33\x05\x6a\xf1\xc4\xc7\x97\xa3\x03\xc5\x78\xfe\x28\x94\xa9\x02\xd5\x78\xe2\x14\xca\x59\x81\x72\x3c\x31\xb3\x65\xae\x40\xbd\xaa\x05\x6f\x33\xe5\x5c\xbc\x65\x72\x71\x7a\x1b\xd5\x48\x3b\x1d\x79\x7d\x97\x0a\x49\x7f\x97\xc9\x62\xf6\x23\x55\x21\x52\x71\x36\xc9\x87\x16\xa1\x98\x96\xb4\xd9\x72\x78\xa0\x48\x57\x14\x43\x99\x2c\x50\xa5\x2b\x96\xa1\x9c\x16\x28\xd3\x15\x5d\x57\x66\x0b\xd4\xe9\x8a\xaf\x2b\xc7\x07\x4a\x74\xfd\x71\x28\xd3\x05\x6a\x74\xc5\x39\x94\xf3\x02\x15\xba\x62\xae\xcb\x7c\x81\x06\x5d\x09\xd7\xe5\x30\x40\x61\x9f\x28\xa2\x32\x49\xa0\xb2\x4f\x2c\x51\x39\x15\x50\xda\x27\x3a\xaf\xcc\x12\xa8\xed\x13\x9f\x57\x8e\x0d\x14\xf7\xf9\x63\x50\xa6\x09\x5c\x59\x26\xcc\x6c\x33\x85\x12\x2e\xc3\x86\xf2\xf8\x85\xff\x7b\xca\xd1\xed\xbe\x4a\xb0\x9c\x60\x4d\x35\x13\xe9\x65\xd8\x0d\x45\x27\x40\x38\x3a\xeb\xdc\x7b\xdf\x84\x07\x2e\x25\xdf\x61\x43\x81\x91\xd8\xc3\x26\xfe\xb8\x1d\x33\x22\x37\xa7\xe5\x8a\x44\xac\x3d\xfb\x49\x7d\x2e\x57\xb5\xb3\xb5\x6e\xab\x7a\xe3\xd3\x4f\xaf\x5b\x59\xca\xa1\x3a\x15\xf1\xd2\x63\xcf\xa5\x62\xbf\x8d\xb5\xd0\x11\x2a\xd7\x6d\xfc\xaa\x92\x6f\xae\xcc\x26\x0d\xbd\x4c\xb4\xbb\x7c\xb1\xcf\x96\x3d\x32\xfb\xda\x6f\x6f\x3f\x02\xe1\x14\x26\xd7\xee\x48\x3a\xb5\xf1\xdd\xdd\xb3\x10\xc8\xbd\x6a\x52\x6b\xfc\x8e\x28\xc9\x5c\x5e\x5e\xc3\x74\x5a\x9d\x56\x1f\xa2\x60\x90\x86\xa6\x08\xec\x88\x73\xe8\x3a\xd6\xba\xfa\xe1\x58\x76\xe6\xbe\xdd\x07\x07\xe7\x5a\x87\xfe\xa4\x16\xb7\xa6\xba\x2c\x4f\x8a\xb3\x78\x35\x31\x55\x77\x87\xef\xa0\x7a\x7c\xae\xa1\xa7\x6a\xd5\xba\xf4\x81\x5d\x72\x51\xb7\x35\x23\xbb\xd0\xfc\xe1\x30\xf6\x70\x15\x90\x61\xaf\xc5\x7f\xac\x7b\x96\xb6\x85\xfc\xda\xb9\x34\xbd\x59\x78\xbc\x1e\x67\x52\x81\x35\xa4\x23\xb9\x71\xa5\xa0\x15\xb5\xf5\xe0\xc1\x7a\x89\x01\xd2\xee\x36\x74\x55\xa3\x25\x50\xc8\x42\x5c\x41\x4e\x35\x94\xe3\xe9\xeb\x11\x48\x6a\xd1\x94\x14\xb6\x6a\xc7\x5a\x6a\x4a\x2f\xda\x71\xbc\xf7\x85\x55\x68\x3f\xf4\x94\xd4\xd5\x10\x9d\xac\x5c\x39\xb9\x2c\x73\x71\xcd\xdb\xf9\xf9\xcb\xd0\x9c\x7f\xc5\x71\x5d\xa1\xd0\xd2\x9b\x5d\xbb\xfa\xbe\x59\x43\x95\xf2\x08\xfd\xc4\xbd\xaa\x8c\xd0\x22\x24\xfe\xb8\x5a\xae\xb8\x18\x14\x26\xd6\xf0\x97\x44\xcd\xa0\xd6\x81\xbd\xeb\x21\x6d\x8f\xc0\x5a\xdb\x2f\x2c\xd4\x20\x60\x5e\x6a\xaa\xd0\x92\x2f\x46\x7e\x60\xcc\xa9\x57\x6f\xea\xc9\xdc\x8f\x2b\xc0\x7f\xfe\x8f\xe5\x62\x6e\xac\x4e\x2d\xde\x3e\xd3\xc3\xf4\xab\x43\xd3\xc3\x5f\x61\xaa\xdd\xa1\xc4\x53\x31\x61\xf9\x58\x65\xe0\x86\xff\x0e\x1d\x25\x65\xf4\x16\x77\x3b\xfe\xda\x2f\x5b\xb2\x51\xc9\x21\xae\x33\xc4\x8d\xcf\xb4\xec\x81\x90\x88\x7a\x35\x41\x60\xc7\x7e\x54\x04\x45\x1d\x8e\x89\xd1\x22\xcd\x72\xed\x57\x81\xf5\x6b\x1f\x2f\x71\x7d\x71\x06\xdb\xa1\xfa\x51\xb2\xc7\xd1\xd9\x69\xe3\xaf\x83\x5f\x68\xc4\x77\x2e\x3f\x7c\x6b\xab\x5a\xc9\xc6\x71\x57\xaf\x0a\x2c\xb9\x67\x5d\x5a\xe7\x9d\x6a\xf2\x5a\x1d\xb4\xcf\xda\x76\x4c\xb6\xa8\xab\x47\x3d\x47\x34\xbd\x5b\x27\x24\x4c\xd9\x23\x4a\x16\x9c\xb6\x85\x10\x1f\x2a\x1f\xaf\x02\x78\x03\xf8\x87\x4f\x37\x34\x5f\x23\x8e\x2b\x02\x96\xee\x9b\xfb\x56\x1c\xbb\x7a\xf5\x86\xaf\x9e\xb4\x0e\xed\xe6\x6c\x5e\xd4\xb5\x70\x72\x34\x8f\x6a\x79\x25\xb5\x89\xb7\xf8\x73\x34\x69\x08\xf6\x6b\x7d\xf3\xe4\x36\x00\xf0\xbc\xdb\x26\xd8\x34\x82\xa4\xb4\xe7\xf1\x74\xc6\x99\x06\xa0\x9c\x7b\xd1\x6c\x5c\x4d\x60\xc0\xf8\xd3\x55\xab\x9d\xe1\x14\xae\xc9\xf8\x1a\x1e\x61\x26\x79\x4e\xbb\xe8\xb3\xb9\xcb\xad\x09\x4b\xa3\xff\x36\xbe\x02\x81\xa1\xa9\xcb\x5e\x69\x9d\x8e\xdc\x83\x3d\xd2\xbd\xcf\xe4\xa0\xd4\xfa\x1f\x9f\xa7\xa0\x35\x1a\x98\x76\xb9\x17\xb3\xce\x45\xe2\x68\x08\xe9\x71\x17\x9d\x51\xae\x2e\x72\x66\x0a\xaa\x07\x97\x28\x1c\xe7\xcb\x80\xf4\x99\x4c\x02\xf3\xd9\x98\x10\x24\x47\xdb\x30\xc7\x84\x7b\x6e\xbb\xe5\x23\x67\x02\x91\xcb\x80\xb4\xc9\xde\x59\x93\x46\x7b\x56\x51\xfe\x3b\x61\x34\xc2\x30\xca\xc3\x06\x64\x90\xd3\x71\x1f\xb6\x69\x0c\x95\x58\x71\xe8\x54\xb6\x1b\xfc\x1d\x3c\x6c\xe6\xae\x53\x40\xc3\x9a\x1d\x8b\x2b\xc7\xb9\x2c\x02\x75\xd3\x28\x68\x71\x02\x9c\x73\x12\xf9\xc7\x39\xdb\xab\x4a\x03\x3e\xe8\xf6\xed\xac\xcb\x25\xc7\x44\x34\xbe\x75\x14\x06\xbf\x4a\x24\xd2\x7c\xf9\x3a\x3e\xfb\xa0\x4d\x6f\x3b\xba\xc7\x4c\x0c\xc9\x4c\xfc\x60\x62\xd3\x47\xb2\x6e\xdb\x88\x3c\xcf\x68\x03\x5a\xf4\x6f\x3b\xa9\x54\xd9\x3e\xce\xf5\xaa\xba\xc7\xee\x29\xef\xde\x64\x98\xc6\x3c\x62\x13\x81\xb2\x37\xab\xa8\xfb\x9e\x46\x6d\x04\x66\x45\x08\x17\x67\x27\x55\x66\xdb\x8d\x84\x81\xce\x2c\xcb\x30\xd1\x9f\xac\x8d\xae\x26\x2e\x11\xa5\x5f\x70\xda\x32\x09\x8a\xa3\xf7\x26\xdf\xeb\x06\x3c\x0d\x27\x6a\xc2\xb3\xe5\x1a\x96\xc5\x1e\x1b\xce\x75\x73\x01\x43\x13\xc2\x6b\xfb\x51\xfb\x5b\xfa\x98\x1e\x5e\x43\x1e\x96\xbf\x0f\x3a\x8e\x1e\x5a\xa2\xd7\x94\x3c\xd5\x22\x66\x6c\x39\xb9\xa6\x25\xe3\xae\x51\xa6\x26\x2e\xf6\x2f\x78\xbb\xea\x30\x89\xdf\xef\xdb\x2e\xda\xbc\x39\x2f\x4c\x84\x9c\x27\x85\x22\xd8\xd5\x62\xa0\x04\x5c\x31\xc7\x78\x67\xa8\xe4\xfb\x4a\xa4\x7f\xf5\x8d\x48\xb3\x0a\xd0\xf6\x71\x12\x0c\xbd\x0b\xf3\x38\xf9\xb7\xe1\x61\x4f\xf2\xff\xd1\xf5\xf3\x86\xce\xa4\x57\xa0\x81\xa8\x2f\xf5\xde\x61\xc0\x2f\x9b\xf9\x72\x74\x91\xa9\xea\xae\x71\x56\xde\xd2\xde\x25\x20\xd2\xe2\x9d\xfd\x4d\x70\x28\xfa\x6c\x5b\xc1\xd5\x76\xb2\xb1\x25\x60\xeb\xe8\x2c\x76\x94\xa1\xe9\x64\x86\xca\xde\x26\xce\x3f\xe7\x1c\xec\xee\x50\xbd\x00\x8a\xb2\x0d\x45\xe0\xc8\x71\x43\x2f\x3f\x21\x4f\x5d\xf5\x99\x21\x33\x1d\x8e\xc7\xbf\xdd\xaf\xf6\x43\xd9\x28\xfc\x9d\x86\xad\x0a\x6b\xda\x36\xf8\x47\x86\x7a\x96\x89\x41\xd2\x7c\x32\xc5\x99\xe7\x2f\xfd\xf2\xaf\xad\x7d\xc2\x96\x07\x84\x67\xf2\x1b\x04\x6d\x7e\x8b\xf6\x37\xc4\xd4\xab\x4a\x8b\x35\xa4\x18\x7a\x6d\xb4\xe6\x1a\x8d\x1e\xb7\x51\xef\x82\xe4\xb0\xca\x55\x2d\xd9\x5a\xab\x2e\x65\xfd\x9a\xe5\x74\xf4\x84\xcf\xf6\x41\xa9\x83\x7e\xc4\x88\xf5\x40\xfc\x47\x73\xc3\xf0\x27\xd0\x01\x9a\x51\x40\xd0\xef\x9a\x40\xf6\x35\x35\xe1\xf4\x25\x89\xd5\x46\xbe\x4a\x93\xe2\xb0\x61\xfe\x76\x86\xf7\x68\xc7\xc3\x86\x67\xcf\xcb\xf6\xa1\xac\x09\xc4\xa7\x65\x69\xd6\x85\x4c\xcf\xad\x9b\x07\x8b\x24\x4f\xd6\x9c\xcf\xdc\xd1\x10\x24\x28\x3f\xa6\xa9\xf4\x88\x01\x2e\x04\x7a\xd8\xd0\x45\xc6\x0a\x28\x45\x07\xe3\x22\x06\x78\x20\xc5\x8d\x79\x08\x11\x23\xf9\xd2\x41\xf5\x4a\x79\xde\xf9\xd1\x26\xc1\x05\x5f\x75\xe6\x29\x13\xf6\x3b\x19\xe3\x1e\xda\xfd\x89\xd5\x76\x94\x28\x7c\x77\x67\xe6\x29\xeb\xc9\xa5\x39\xb7\xf5\xab\x09\x4e\x34\xf6\x48\x3d\xf7\xd4\xea\x28\x2f\x61\x10\x57\x06\xf9\x24\x59\x5f\xff\x19\xb4\x64\x23\x69\xb0\x54\xd7\xa5\x4c\x83\xb1\x66\x99\x6d\xe9\xb9\x99\xb3\xb4\x05\x35\x34\xea\x9e\x54\x5f\x5f\xdb\x78\x5b\xfc\xb9\x74\x8c\x61\xf6\x6f\x64\xdf\x85\xcd\x56\x17\x8f\x36\x9b\xdf\x0a\x05\x2c\x85\x04\x87\xc0\x37\x0b\xfa\xaf\xdb\xf3\xf5\x7f\xd6\xf1\x48\x68\xf2\x4d\x59\x98\x49\x45\x36\x97\x94\xcf\x4a\x66\x30\x84\x02\xca\xf9\xa1\xb9\x49\x23\xcd\xf3\x56\x2e\x41\x8b\x1b\x94\x38\x7e\x2d\x35\xdb\x46\x62\x30\x15\xa5\xa2\x68\x05\x69\xcf\x87\x60\x2b\xb0\xbe\xf1\x7f\x1d\x20\x85\xb9\xa7\x76\x8f\x12\xb5\xa5\x8a\xaa\x38\x98\x25\x29\x67\xe3\xf1\x1b\xf7\xec\x19\x1b\x42\x29\x60\xad\x47\xbb\x1a\x85\x17\x65\xd6\xfe\x99\x1e\x17\x82\x96\x14\x4f\xe6\xee\x49\xea\x3d\xdd\x3e\xd3\x45\x73\xea\x92\x13\x89\x91\x4f\x08\x47\xd3\x0d\xec\x32\xd8\x4c\xc6\x29\xe7\x0e\xe7\xa2\xb8\x6a\xc6\x35\x8b\x34\x88\x18\x31\x93\x52\x88\x2d\x21\xfb\x9e\xfd\x6a\x29\x9a\x29\xa0\xb5\x6f\x30\xda\xea\x7a\xf4\x29\x30\x5f\x97\xeb\x7c\x31\xa0\xe4\x9b\xde\x05\x6a\x9f\xb1\x26\x13\xce\x97\x9f\x4e\x2b\x89\x38\x8e\x58\xb5\x11\x6b\xbb\x9b\xa7\x0e\xb9\xd4\xb0\x4d\xbd\x08\xab\x67\x39\x9b\x34\x18\xe4\xeb\xf4\x38\xf1\x5c\xb8\x6a\x25\x0b\xe1\x38\x3e\xfb\x45\x9b\x6a\xff\x0e\x3a\x11\x84\x6a\xda\xcd\xc7\x98\xaa\xd6\xea\xd5\x49\x19\x23\x30\xba\x70\xc4\x9d\xfb\xfc\xea\x4a\x36\x30\xca\x8c\xc4\x82\xce\x27\xba\xd8\xfd\x3b\x3c\xcd\xbe\x41\xf7\xa1\x3c\x43\x9a\xdb\xff\x08\x3d\x18\xd3\xdf\xd8\xb1\xf7\x5c\x6b\xd0\x36\xba\xd7\xa2\x9f\x5f\x43\x19\x19\x7f\x77\x0e\xb2\xda\x41\xba\xf8\x4b\xd0\x9b\x16\xfc\xab\xf0\x10\x3b\x99\x86\x48\xe7\xa4\x43\xae\x45\x40\x36\x8e\xee\x4c\x72\x77\xb1\xfc\xa0\xfa\x58\xf6\x6d\x12\x33\xff\x74\x4e\xcf\x53\x60\xe2\x8e\xfd\x49\xbf\x3b\x73\x3f\x06\x95\xfe\x96\xe5\xaa\xeb\x28\xad\xa0\x1b\xe8\xac\xe2\xfa\x4b\x50\x0b\xbd\xd1\xe4\x83\x7b\x40\xc3\xb9\x99\x1e\x69\x2a\x5e\x46\x96\x14\x96\xaf\x85\x1f\x8e\xec\xef\x2a\x9b\xeb\xfd\x5c\x1c\x7f\x79\x05\x51\xab\x73\x5d\x76\xa6\xa6\xc7\xce\x71\x20\xc1\xdb\xc7\x14\xa3\x9a\x6c\xf1\xdd\xae\x6d\xe8\xcc\x94\x96\x79\xb2\x99\x74\x68\xce\x05\x39\xb7\x24\x51\x66\xb1\x3c\xa7\xde\xbd\xd0\x18\x65\xc4\x29\x48\x35\xa7\x5f\xe6\x90\xfd\x6e\x62\x64\x5d\x2a\x69\xe3\x20\x38\x8b\x56\x94\x82\xfa\x9f\x4a\x94\x06\x7a\x04\x46\x19\x86\x3a\x35\x65\x49\xc6\xb4\xb8\xff\xfb\xfc\x9d\xba\xa9\xdf\xea\x2a\x57\x82\x1c\x9c\x55\x13\x9d\x3e\xb8\x3c\x9c\x95\x8a\x50\xf2\x8f\x2c\x8c\xf9\x23\xb3\x2e\x0d\xdc\x18\x54\x77\xeb\xd4\x92\xdf\xb2\xca\xd2\x16\xd9\x78\xe9\xf1\xd4\xe2\xea\xd1\xb0\xd4\x90\x6c\x02\x94\xe1\x7c\x84\xd8\xf3\x1d\x41\x63\xb4\x2a\x38\x2a\x3f\x4d\xf4\x50\x0e\x43\x70\xd6\x6c\xb3\x89\x96\x5a\x01\x32\x21\xb4\xb0\x75\xe4\x1d\x49\xff\x29\x4c\xa9\xe1\x95\x74\x51\x4d\x24\xff\x42\x7e\x5f\x1c\xcf\x00\x61\x2d\xc7\xdc\x09\xfb\x49\xe7\x9b\xca\x72\x98\xdd\xec\xcf\x75\x28\xeb\x27\x08\x30\x8d\x6b\x7f\xda\x8a\x6b\xd1\xde\x41\x04\x6b\xb0\xb9\x69\x44\x21\x92\x72\x98\xe9\x88\x0a\x45\x04\x21\x80\xe3\xfe\x60\x81\x34\xfb\x39\x91\x58\x9a\x15\xc2\x04\x65\x0c\x37\x84\x11\x56\x99\xee\x63\xf5\x21\x27\x64\x91\x3a\xd7\x8d\x29\x88\xae\xa4\x4e\xa4\x06\xa5\x86\xf9\xdf\x47\x78\x19\x0d\x9b\xba\xaa\x81\x83\x94\xac\x55\x55\x48\x06\xca\x48\x18\xc9\x08\x36\xe6\x9d\xb8\xb8\x9f\x32\xaa\xa1\xda\x7f\x68\x26\xca\x48\x09\x09\x25\x14\x69\x59\x85\x1c\x9c\x49\x53\x92\x43\xaa\x09\xee\x06\xc6\x76\x34\xf1\x4f\x11\x39\xe3\x06\xea\x0e\x9c\xf4\x22\x72\x71\xed\xe8\x68\x8c\xff\xba\xd2\x34\x35\x52\xf6\x36\x86\x2c\x0e\x4b\x3a\x69\x1a\xd3\x08\x5a\x84\xd6\x10\x8a\x2c\x8e\x09\xac\x28\x9d\x71\x2c\xbc\xb4\xb4\x94\x4c\x08\x0a\x2b\x8e\x09\xb4\xe8\xb4\x51\x14\x2e\x02\x73\x28\xa9\x05\xd3\x08\x42\x44\xc6\xe0\xff\x12\x61\x0d\x25\xb4\x51\xcc\x85\x53\xa0\x48\x89\x98\xfe\x85\x54\xfc\x2c\x22\x8b\x8a\x26\x11\xf3\x11\x2d\xe1\xfc\x2f\xd0\x84\x30\x41\x92\x76\xe1\x17\x75\xff\xdf\x50\x46\x22\x27\x1c\x05\x8c\xa0\xfe\xa9\x8a\x42\xe7\x53\x3d\xf2\x93\x01\x72\xb0\xc8\x55\x16\x85\xac\x8b\xb4\x08\x5f\x5d\x58\x0d\x8a\xb4\x08\xff\x7f\xf8\xff\x0b\xcc\xd4\x3f\xff\x40\x46\x88\xfd\x10\x25\x0b\x1e\x2c\x6a\x97\x51\xc7\xdc\x6a\x61\x63\x2e\xb3\x1d\xcb\x24\xeb\xa5\x5e\xcc\xe6\x21\x4a\xa1\x44\xd0\xcf\x66\xd1\x4a\x35\x11\x81\x3b\x61\x1d\x95\x2d\x03\x3a\x46\x7f\xfd\xff\xc2\x82\xba\x33\xad\x54\xdd\x27\xbc\x7a\xcc\x5d\x7f\xd1\x5d\x7b\xcd\xa7\xb2\xfa\x51\x45\x33\xb3\xab\xee\xdc\x47\x64\x2d\xf4\x55\xe3\xcc\x47\x66\x6d\xa9\x2b\x6f\xe1\xc9\x4e\x45\xd1\x7a\x97\x7a\x86\xb7\xd4\xbb\x9c\xed\x26\xe5\x24\x77\xb1\x47\x35\xcb\x53\xe6\x41\xe1\xff\x88\x9a\x30\x33\x8b\x2d\x27\xb9\xab\x3d\x4b\x59\x9e\x3a\x0f\x0a\xb6\xbb\xd6\x33\xbc\xb5\xde\xe5\xec\x37\xff\x5b\xac\x36\xb5\x95\x1e\x5f\x5d\x8c\x3d\xc9\x5d\xe8\x61\xcd\xd2\x94\x5c\x4f\x8a\x6f\x28\xc5\x9d\xe1\x2d\xf6\xb6\x64\xbb\xf9\x9f\xd5\x53\xe2\x61\xd6\x6a\x57\x7b\x86\xb7\xda\xdb\x92\xfd\xa6\xe6\x24\x77\xa5\xa7\x39\xcb\x53\xe3\x61\x36\x5a\x95\x92\xfd\xac\x86\x32\x77\xa5\xa4\x39\xcb\x4d\x23\x79\xd6\x66\x71\x63\xe3\x1b\xbc\x0b\x16\x26\x16\x0c\x0c\xec\xbf\x05\x00\x00\xff\xff\x18\x33\x7b\xe0\xe8\x7e\x01\x00") + +func uiAppLibFontAwesome470FontsFontawesomeWebfontWoffBytes() ([]byte, error) { + return bindataRead( + _uiAppLibFontAwesome470FontsFontawesomeWebfontWoff, + "ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.woff", + ) +} + +func uiAppLibFontAwesome470FontsFontawesomeWebfontWoff() (*asset, error) { + bytes, err := uiAppLibFontAwesome470FontsFontawesomeWebfontWoffBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.woff", size: 98024, mode: os.FileMode(420), modTime: time.Unix(1, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _uiAppLibFontAwesome470FontsFontawesomeWebfontWoff2 = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x00\x12\x40\xed\xbf\x77\x4f\x46\x32\x00\x01\x00\x00\x00\x01\x2d\x68\x00\x0d\x00\x00\x00\x02\x86\x98\x00\x01\x2d\x0e\x00\x04\x01\xcb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x46\x46\x54\x4d\x1c\x1a\x20\x06\x60\x00\x85\x72\x11\x08\x0a\x89\x99\x28\x87\xb6\x58\x01\x36\x02\x24\x03\x95\x70\x0b\x96\x10\x00\x04\x20\x05\x89\x06\x07\xb4\x75\x5b\x52\x09\x72\x47\x61\xf7\x91\x84\x2a\xba\x0d\x81\x27\xed\x3d\xeb\x3a\xb5\x1a\x26\xd3\xcd\x3d\x72\xb7\x2a\x0a\x02\x19\xe5\x1a\xf1\xf6\x5d\x04\x74\x07\xdc\x45\xaa\x6e\xa3\xb2\xff\xff\xff\xff\xe4\xa4\x31\x46\xdb\x0e\xdc\x40\xe0\xd5\xf4\xfb\x7c\xad\x8a\x14\x08\x66\x93\x6d\x92\x60\x9b\x24\xd8\x91\xa1\x40\x64\x5b\x42\x51\x11\x24\x28\x5b\x55\x3c\x2b\x28\xad\xb8\x40\x50\xd0\x35\x1e\xe4\x60\x81\xb0\x0e\xda\x3e\xf6\x50\x10\x1a\x3b\xe1\x28\x91\xd1\x31\xb3\xfd\x6c\xdb\xfe\x68\xd4\xa8\xa2\xc2\x29\x9f\xdc\x59\x79\x94\xf2\x4a\x69\xe9\xeb\x17\xad\x85\xce\x7c\x25\xdb\x81\xb7\x5e\xac\x14\x47\x82\xa2\x33\xb8\x12\x6e\x9e\x95\xe8\xba\xda\x95\xdc\x0a\xc4\xcd\x90\x44\x8a\x9e\x70\x5c\x59\x72\x20\x94\x4c\xdf\x50\xf4\x0e\x8d\x1b\x83\x74\xa5\x29\xcb\x11\x98\xef\x13\xa7\x36\x52\xc2\x5e\x22\x53\x0b\x4c\x7e\xf1\x59\x52\xd7\x43\x58\x52\x15\x09\x8a\x34\x81\x8e\xe6\x46\xfa\x79\x5c\x5b\xbf\xe8\x37\x6e\xa1\xe2\xae\x7c\x1d\x73\xe0\xbb\x8c\x71\x1e\xa3\x4d\xbb\x8e\x25\x4b\xc9\xff\x17\x2e\xdb\xba\x0e\x2c\x0b\xfa\x84\xf7\xf8\x4c\xd0\x74\xff\x27\xf6\x10\x90\xc9\x4d\x1d\x2c\x11\x15\x63\xf7\x88\x2b\x62\xfa\xc4\xd7\x87\xe7\x4f\xfd\x73\xf9\x5e\xd8\x24\x85\x86\xd7\x7a\x2e\x07\xf5\x6d\xc5\xa0\x0c\xfc\x68\x26\x67\x62\xde\xf0\xe1\x76\xed\x87\xf3\x01\x0e\xc9\x27\x8a\x0f\x36\xa3\x3a\xb0\xbb\xc3\xf3\x73\xeb\x6d\xa3\x62\x8c\x31\xd8\xa8\x6d\x30\x22\xc7\x82\x1a\xb0\xbf\x2a\x56\x8c\xa8\x8d\x1e\xa3\x63\xa3\x24\x2c\x30\x41\x54\x50\x54\xb4\x31\x12\x03\xfb\xf4\xac\x3c\x0b\xed\x3b\xed\xf3\xd2\x60\x10\xe6\xb6\x27\xf1\x48\x0e\x3f\xf1\x73\xce\xa9\x3a\x91\x0f\x4e\x44\x9f\xa8\xfc\xa9\x10\x49\x11\xa4\x24\x8c\x04\x54\x14\x8b\x5b\x81\x82\x62\x34\x8a\x11\xcd\xfc\x7f\xea\xec\xef\x2c\xaf\xce\xbc\xd7\xef\xbd\xa3\x62\x6c\x36\x91\xba\x0b\x49\x4c\xe9\x69\x7d\xdb\x8c\x26\xe0\x34\xe3\x94\x6d\x2c\x27\xcb\x16\xcb\xf3\x23\xbd\xd7\xa5\xb3\x7f\x52\x77\x01\xa2\x62\x75\xc0\xb6\x2c\x4b\x96\x0b\xc6\x06\x9b\xe2\x76\x8b\x03\xdb\x08\x6d\x5f\x2d\xc0\xc0\xe6\x5c\x48\x8b\x9d\xfb\x8e\x48\x48\xfe\xaa\xf3\x93\xea\x07\xc6\xc2\x3f\x98\x96\xd3\x6d\xf3\x0b\x39\x50\x88\xad\xd8\x29\x39\xe7\x4a\xa8\x86\x24\xc6\xbd\x88\x9c\xe7\xb1\xf4\x38\xf8\xe8\xc7\xda\xce\xce\x7e\xb9\x3b\xc4\x72\x15\x8d\x6e\xbf\x3d\x24\x11\x1a\xb5\x1f\x94\x4e\x64\x64\x6e\x1b\x21\x27\xae\xa6\xf0\xe3\x3b\xb3\xf4\xac\x38\x99\xbc\x27\xd9\x4e\xa6\xed\x1e\x21\x7f\x2d\x18\x06\x4a\x19\xca\xb6\xd3\x2e\xe0\xd8\xfa\x91\xee\x58\xaf\x3d\x0c\x2c\x12\x04\x0e\x90\x9b\x1e\x22\x60\x3a\x18\xa2\xff\x1b\x0f\x09\x09\x20\x7b\x8d\xef\x9e\xdc\xe0\xbc\x12\xcb\x4b\x21\x27\x9f\x00\xa1\x2d\x46\x48\x94\x9c\x09\x89\x23\x24\x7e\x9b\x5a\x5f\x84\xb9\x9d\x10\x12\xb5\x03\x4e\x35\x56\x55\x38\x46\xc8\xaf\x1c\xa2\x8e\x25\x14\x50\xd4\xfb\xdd\xab\xda\xdb\xfb\x06\x08\x0c\x86\x43\x70\x08\x02\x24\x04\x51\x19\xa2\xb4\xbb\xda\x10\x9d\x72\xac\xec\xa2\xca\xbd\x9b\xee\xba\x6b\xbb\x6b\xda\x1b\xa7\x33\xd9\xb7\x13\xd1\x3a\x52\x11\x25\x1e\x10\xb6\x81\x32\x7b\xf4\x87\xde\xa9\xf5\x92\x1d\x68\x25\xbb\x29\x38\xc9\x11\xf6\x00\xf8\xf1\x01\x0f\x18\x0a\x49\x4c\x4b\x90\x36\x76\xf4\x23\xed\xfb\xb3\xee\xfe\x06\x2c\x3b\xd0\xa6\x36\x87\xa0\x4e\x9a\x32\xce\x68\x76\xb7\x0f\x0e\x08\xfe\xef\x7f\xcd\xfe\xeb\x0c\x4f\x4f\x91\xa7\x74\x23\x16\x85\x06\xe2\x78\x54\x89\xef\xaa\x42\x66\x02\x9d\x9e\x84\x71\x5e\x16\x23\x9c\xae\x9f\x96\x3f\x7b\xfe\x35\x62\x8a\x49\xe2\xe0\x25\x2d\x57\x5a\x90\xeb\xb9\x62\xa4\x41\xa3\x13\x0c\x5e\xe4\x31\xcd\xd9\x6e\x35\x19\xf9\xae\xe9\x8a\xd7\xa6\x4e\x51\x9d\x59\x27\xfa\xe6\xdd\xcd\x12\x96\x04\xfc\x91\x53\x04\xdc\x18\x1f\xa6\x21\x74\x22\x20\x06\x60\x62\x33\xe9\xf7\x25\x93\x07\xf4\xef\x33\x35\xbb\x02\x14\xd1\x66\x76\x3b\xab\x9d\xd5\xce\x6c\xce\xac\xee\x39\x9c\x3a\x6a\x67\x66\x3f\x67\x72\x9b\xf5\x70\xff\x78\x9f\x20\x80\x0f\x7c\x12\xfc\x20\x24\x08\x20\x65\x12\x94\x1c\x12\x94\x5a\x14\x28\xc5\x14\x24\x77\x28\x5a\x72\x53\x90\xe8\x76\x2b\x9b\x5a\xd9\x1c\xcf\xd6\x71\xf6\x4d\xa2\xec\x1e\x9b\xee\xcd\xea\xdd\x99\x6d\x3f\x26\x73\x5b\xf6\xe5\x74\x99\x53\x92\x53\x6a\x8e\xa7\x39\x9c\xaf\xe3\xf7\x3f\xad\x7c\xda\xea\x0d\xf1\xf0\xc5\x3e\x47\x0e\xcc\x06\x2c\x10\x62\x44\xd5\xb7\x5e\xa9\xf4\xaa\x5e\xa9\xc7\xdd\x1b\x3a\x6c\x8a\x33\x8e\xbd\x4e\x41\x9a\x60\xab\x35\x0b\x9c\x32\x36\xb3\x01\x4c\xf9\x70\x53\xf2\x09\x41\xdf\xa7\x2f\x55\xeb\x0a\xc2\xd6\x98\xb4\xbc\xb3\xb4\x27\x39\x5c\xb4\xa7\xd5\x86\x74\xb8\x85\x10\xaf\x21\xdf\xf6\xf6\xfa\xb7\x1a\xfd\x1b\x81\x6c\x00\x06\x85\x20\x50\x4d\x52\xb4\x9a\x90\x39\x6e\x80\x0a\xcd\x60\x15\x12\x13\x28\xca\x10\x40\xd2\x20\x48\x79\x29\x4d\xd2\x64\x4d\xca\x0d\x90\x1c\x35\xe9\xd4\xa4\x13\x48\x27\xd2\x91\x9a\x1c\xf2\x6d\x53\x3c\xfa\xe8\xdb\x71\x26\x6b\xbc\x29\x5c\xcf\x7b\x3b\xee\x31\xc5\xc3\x6d\xf9\x07\x9b\x38\xdb\x7b\xe1\x8b\xd5\x58\x84\x31\xdd\x2d\x33\xc7\x9a\x90\x91\x29\x82\x42\x28\x84\x91\x2c\xfb\x25\xf5\x93\x10\xb0\xb6\xb6\x8d\x04\xc4\x0b\x05\x05\xdd\xfd\xdb\x77\x9f\x6f\x7e\xbe\x98\x74\xed\xf0\x48\x57\x38\x6c\x90\xd4\x5a\x11\x09\x72\xa4\xe3\xbf\xff\x3d\x65\xb3\x1a\xec\xdf\x31\x2b\xe6\x07\x05\x2f\xc9\x8e\x31\x57\x3f\xd6\xb0\x72\xee\x12\x0e\x38\x39\x50\x4c\xc6\xd2\x01\x3e\x75\x6f\x39\x20\xc5\x18\x31\x20\x74\xc3\x98\xab\xc3\x75\x63\xa7\x9d\x91\xee\xc4\x40\xb3\xf9\x5d\x4b\x14\x10\x52\xef\x7f\x62\x4e\xff\xbb\x92\x76\xfb\x93\xb4\xd4\x1a\xaa\xa8\x28\xb8\x22\x8a\x83\x79\xeb\xbd\xbb\x7b\x1c\x0c\x63\xae\xff\x8f\xe6\xf3\x73\x63\x7a\xa6\x19\x26\xae\x70\x35\xa7\xe5\x04\xa1\x2c\x6a\xb3\x6e\x20\xa2\x6b\x4e\xc4\x21\x83\x2e\x83\x6e\x5e\xf7\xf8\x55\x75\x1f\x00\x40\x7c\xfc\x18\x3f\x76\xb5\x3e\xf7\x07\xb9\x1d\xb9\xdc\x1c\x91\x72\x18\x55\x61\xdc\x48\x52\x20\x0b\x1a\x8f\x10\xfa\xb9\xd7\xf8\xd5\x91\x00\x93\xf3\x49\x0d\x44\x89\xdf\xcb\x8b\x51\xbf\xbd\x7e\x70\xe9\x0a\x80\xdc\x8d\x3b\x3b\xb8\x6e\xf9\xf9\x8d\x4c\x18\x17\x24\xa1\x74\xf9\x09\x3a\x09\x68\x46\x43\x59\xa1\xed\xde\x54\x4f\xa0\x46\x4e\x1d\x4e\x7e\x7d\x17\xf1\x31\x22\x60\xb3\xa8\xfc\x9f\xd8\x61\xcf\x07\xcb\x28\xcd\x3f\x48\x20\x11\x97\x96\x87\x1f\xc4\x5c\x96\xcd\xe5\x75\xca\x30\x13\x4c\xd4\xb5\xf5\xf1\x27\xb5\xed\xba\xbd\xbe\xcd\x94\x50\x62\x6e\x6d\x4f\xbf\x98\xeb\xb6\xdd\xfd\x8d\xbf\x02\x18\x4a\x6c\x8b\x3f\x02\x01\x08\x9e\xe5\x73\xab\xe7\x05\x88\x30\x2c\x0e\x38\x8c\x78\xc9\x42\xf2\xfa\xf6\xbe\x42\x19\xc7\xe5\x91\x46\x89\x10\x14\x9f\x5f\xdf\x1b\x52\x69\x5a\x1d\xf8\xff\xb7\xd4\x7e\x65\x23\x15\x6a\xb0\x11\xb1\x77\xfd\x68\x4f\x63\x2a\x26\x46\x36\x0c\xac\x59\x71\xc1\x92\x05\x7b\x89\x7d\x3f\xc9\xf3\x3e\xf7\x75\x1e\xfb\xb6\x2e\xf3\x34\x0e\xce\x68\x25\x05\x67\x94\x60\x04\xa7\x26\xd7\xe7\x20\xb8\xcb\x12\x29\xa9\xac\x52\x35\x18\xe5\x48\x8c\x7d\xb1\xa7\xff\xcb\xa4\xb0\x6b\xdc\xa9\xdb\x1c\x90\x27\x4a\x99\xde\x4f\xbf\x00\x49\x88\xdb\x13\xb6\x9d\x5f\xef\xb3\x7f\x05\x91\x71\x4f\x62\x27\xd6\x48\xc7\x9f\x00\x42\x59\x45\x4d\xa3\x03\x1c\x36\xc8\x76\x84\x81\x35\xaa\x10\x4e\x4a\x0d\xe5\x15\x01\x4f\x88\x4e\x07\x1a\x46\x0b\x4e\x78\x28\x31\x92\x3a\x01\x5c\xba\xdf\xab\x43\xe0\x6b\x8e\x63\xa0\x62\x38\x05\x51\xf4\x09\x13\x64\xe1\x18\x5b\x4c\x14\x28\x65\x6c\x1c\x2b\x32\x75\x2d\xee\xd0\x61\xd6\x98\x64\xa2\x8e\x35\x3b\xa2\x4e\x24\xd4\xf6\x22\xa2\x48\xaa\x8f\x10\xab\x53\x46\xba\x6f\xeb\x32\x69\xa8\x22\x8a\xd9\x5c\xb3\x68\x04\x37\x49\x8c\xf6\xa0\x3c\x53\x43\x4f\x02\xad\x19\xb8\x96\xc8\x90\x48\xa0\x1e\xe2\x45\x77\x21\x01\x2e\x1f\xd7\xe9\xfd\x21\x42\x53\x12\x43\xaa\x67\x1e\xc4\x9d\x89\x63\xe3\x0e\xb9\xe4\x73\x2a\xd5\xa7\x73\x89\x28\x35\x6d\x94\x3d\x71\xc6\xca\x8a\x65\xa2\xfb\xf1\x59\x91\x0b\x24\xeb\x5c\x3e\x10\x66\x4e\x38\x80\x71\x97\x8c\x78\xea\x23\x76\x0a\xa5\x36\x75\x6d\xef\x09\xe0\x19\x9d\xb0\x60\xdb\x4e\x4d\x2d\x4a\x00\x5c\xf4\x10\x46\xb7\xc7\x72\xe9\x44\x02\x80\x1e\xb5\x5a\xd3\x30\x93\x07\x23\x27\xea\xa5\x88\x6e\xec\x11\xd2\x47\x6a\x4c\x82\xda\x86\x58\x14\x1b\xca\x8c\xa2\x41\xaa\x9d\xf1\x67\x59\x73\x99\x2a\xb2\x59\xca\xdc\x07\xc7\x5e\xd9\xb5\x98\x3b\x22\xd8\x1d\x24\x68\x62\x7f\x3d\xb9\x16\x19\xcf\x9b\x13\x98\x30\xde\x76\x48\x3c\x97\x56\x76\x7f\x81\x63\x9b\x5f\x00\x5c\x59\x8a\x03\xec\xa3\xe8\x77\x3b\x64\x42\x16\x02\x83\x8b\x03\x4e\x83\x84\x33\x1b\x21\x24\xce\xe7\xe7\xb4\xe7\xe2\xde\x49\x7c\x50\x98\x20\x7e\x13\x26\x13\xe4\x03\x64\xc5\x2e\xc8\x03\x1b\xd4\xb0\xe9\x02\x2d\x61\x07\xf3\xfa\x61\x19\x09\x2b\x2b\xc2\x13\x92\x39\xba\x2e\x6d\x52\xf8\xe9\x34\xe3\x63\x79\xaf\x9e\xb9\x23\x8b\x55\xd5\xc2\x46\x57\xee\x08\x75\xbd\x0d\xdc\x09\x17\x69\x2f\xf0\x9c\xaf\x94\x66\x7e\x80\x34\xdd\xf0\x6c\x83\xeb\x0e\x58\x53\xf4\x39\xc3\x84\x1b\xf7\x31\x45\x9d\xf0\xbd\x33\x40\x90\xfd\xda\x6b\x13\x88\xdc\x15\x40\x17\x27\x23\xa3\xbc\xb6\x63\xac\xbd\xd9\x6e\xea\xa9\x20\xba\xf1\x15\xef\x53\x5f\x3b\xac\x25\xfb\xee\x49\x8a\xd0\xc1\x2b\xbb\xf8\x2e\xf3\x4c\x1a\xd8\x43\x02\x78\xb1\xeb\xee\x1e\x1e\xbe\xfa\xea\x86\xb1\x77\x09\xda\xcd\x56\xdb\x82\x80\x81\xba\xa8\xe1\xa4\xc0\xc3\xf9\x45\x78\x66\x7e\x48\x60\xbd\xe9\x30\x1f\xbc\x21\x64\x94\xe8\x40\x51\x7b\x4f\x68\x31\x89\x17\x17\xb1\x48\xc1\xb6\x46\xc3\xab\xd5\x7a\x73\x1a\x8d\x37\xf3\xdd\x89\xb6\xb3\xc6\x9c\x74\x0f\x72\x76\xcc\xe8\xa9\xd2\x6b\x9d\xbb\x86\x68\x65\x53\x33\xb7\xdb\x87\x76\x99\x39\x84\x71\x7c\xab\x4f\x82\xef\x97\x4b\x29\x95\x55\x5c\xf2\x96\x41\xd2\x25\xa3\xb9\xbb\x02\xc4\x6f\x1e\x7b\x6c\x3c\x86\xdb\x4b\xb8\xff\xba\x9d\xcd\x8e\xa2\xa4\x8e\x69\xb3\x8f\xf1\x48\xeb\x47\x80\x49\x85\x7a\x9d\x3d\x36\x9a\x57\x57\x6f\x30\xeb\xd9\x0b\x7c\x15\xde\x25\x41\xf7\x1a\x6a\x64\x44\x29\x21\x0d\x80\xa9\x70\x77\xae\xc8\xee\x5f\x82\xb3\xeb\x3b\xb8\xf1\xa6\xdb\x63\x97\x44\x23\xe9\xff\xcb\x81\x4d\x90\xc0\xde\x4e\x7a\x9c\xf2\x05\xb7\x04\x70\xb0\x5e\x8f\x43\x44\x78\xde\xc2\x78\x6a\x29\x84\x35\x4f\xc8\x39\xfb\x0d\xa1\x60\xd1\xd2\x45\x44\x58\xee\x78\xf1\x8d\x20\xdd\x92\x47\x55\xc8\xc0\xed\xcb\xaf\x0e\xc4\x99\xaa\x04\xa9\xef\xd6\xda\x89\x9c\x2e\x25\x0d\xb7\xbf\xb6\xce\x88\xb1\x7e\x0c\xe3\xf1\xfa\x3d\xff\x08\x1a\x16\x43\x13\x6f\xa6\x29\x0d\x46\x84\x37\xf3\xca\xe7\x24\x5a\xa4\xfd\x28\xb7\x67\xc1\xeb\x6f\x42\xad\xa7\x0d\xdb\xc6\x9c\xc0\x40\xde\xe5\x26\xf2\xc3\xda\x65\xee\x7b\x06\xea\xe2\xe5\x8e\xa3\xa0\x08\x6c\xa0\xb0\x66\x8a\x5f\xc6\x52\x78\x99\x4e\x5b\xa7\x5d\x0c\xae\x9b\x07\x38\x60\x2d\x33\x99\x73\xb4\xa6\xc1\x92\x7b\x7f\x50\x6a\x01\xde\x19\xb8\x57\x75\x63\x39\xef\x85\xb8\xae\xa9\x84\x1b\x5b\x3e\x1d\xea\x2d\x9f\x2e\x44\xa2\xdc\x8e\x59\xfa\x1f\xf7\x9b\x15\x0f\x80\x1e\x64\x87\x0c\xcf\xc2\xd8\x07\xa2\xb2\x2b\x18\x5e\x7b\x93\xae\xb9\x43\xee\xf7\x89\xb1\x6d\xe0\xc4\xd9\xf0\x2c\xa6\xb1\x40\x4e\x3c\xb2\x90\x1d\xda\xd9\xd0\xf8\xf2\x89\xaf\x1f\x7f\x0e\x2e\x8d\x94\x56\xf1\xe6\x4d\xf0\xda\x11\x53\xec\x2b\xd3\x5c\x44\x9e\x2b\xa2\xda\x52\xa2\x7c\xd1\x36\xb5\x0b\xe2\x27\x71\x5c\x54\xe0\xdd\x02\xa6\x95\xf3\x1c\x1e\x39\x87\x44\x84\x06\x58\x3c\x7f\x24\xed\x70\x89\x80\xde\x07\x22\xbb\xe9\x85\xa6\x92\xfc\x24\x9b\xd2\xb7\x0b\xde\x2c\xf9\x70\x1f\xbb\x73\xf9\xa5\x54\xd3\xce\x1a\xdd\xfe\xaf\x62\xbb\xff\xd4\x4e\x6b\x49\x91\x1e\x5f\xe6\xa1\x60\xd5\xe6\x0a\x46\xe8\x88\x1f\xea\x57\x93\x9f\x56\xff\x94\x25\xd9\xd1\x77\x08\xad\x7e\xa9\xa4\xc4\x44\xd4\x90\xd9\xc2\xcb\xdd\x2a\xf3\xb3\x78\x69\xf2\x1e\xb8\x79\x5b\x72\x5a\xaa\x87\x00\x99\x5b\x53\x25\xb4\x47\x9b\xdc\x18\x73\x60\x46\x3c\xe3\x85\xa3\x85\xb3\xac\x20\xa2\xc1\x56\x8b\x2b\xfe\xf3\x21\x2b\xad\x96\xf7\xf5\x8a\xb8\xd8\x8d\x8b\x39\x79\x9f\x6b\xc5\xc1\x66\x62\x91\x38\x32\xde\x06\x73\xde\x7d\x6c\x3b\x5b\x29\x65\x24\xc4\xf8\x89\x54\x9d\x86\x96\x6b\xad\x83\x92\xe0\x29\x9a\x76\x8f\xb6\xa9\x39\xac\x01\x84\xe3\x1b\xa7\x7b\xd3\x75\x13\xf2\x75\x8f\x74\x8f\xc8\xde\xb3\x40\x45\xe3\xf4\x3e\x7c\x43\xf6\xda\x3c\x5c\x34\x25\x08\x97\x52\x76\xe1\x0c\xa5\xb6\xe9\xe5\xc4\xe8\xaa\xda\xf4\x40\xd7\xba\x43\xcc\x38\x5c\x91\xf8\x7e\x29\x14\x23\x6b\x7c\xbe\xb9\x2e\x61\xeb\x6f\xaa\xba\xda\x03\xba\x30\x30\x47\x94\x71\x30\x1d\x14\x25\xf1\xfc\xf0\x13\xa1\x99\x68\x70\x8b\xa9\xba\x0d\x4c\xff\x9c\xde\x22\x8c\x2b\x3e\x8e\xec\xe6\xb5\x25\xaa\x0b\x5e\x4d\xcb\x8a\x98\x4e\x9a\x73\xd3\xc8\x06\x71\x8e\xb4\x3d\x95\x12\xb0\x0f\xbe\xee\xe5\xe4\xa6\x86\xb0\x4b\x11\x34\x72\xe7\x2d\x2a\xef\xe7\x25\xe8\xda\x68\x23\xd7\x25\x3b\x70\x50\xe9\xa6\x94\x68\xd6\x43\x3d\xf7\xce\xfa\xda\xda\x0d\x97\x1a\xe5\x26\x14\x29\xa9\x62\x61\x84\xc6\x4b\x4c\xf8\x40\xbf\xf9\x9e\xe4\x74\xba\x21\xa2\x7e\x32\xed\x53\x5d\x72\x59\x6c\xba\x5a\x36\xd0\x33\xd1\x9e\x4a\xde\x6f\xb4\x98\x4f\xa3\x56\xf5\x3b\xb9\x68\x26\x67\x4f\x35\x92\x52\x54\x88\x2f\x7d\xf9\xc1\xd2\xc6\x7b\xae\xa5\xf2\x17\x17\x41\x5a\xd2\x26\x87\x19\x53\xf3\xe2\xd9\x74\xd8\xca\xf9\x9c\xcf\x03\x0b\xcd\xaf\x01\xe9\xa2\x50\xea\xeb\x43\xa1\xa4\x14\xa2\x30\x13\x08\xb4\xb6\x44\x2c\xfb\x70\x62\x70\xd0\xb7\xd4\x7a\x29\xa7\x20\x5d\x80\x49\xf7\x3e\x1a\x00\x0e\x51\x5c\x42\x6c\xc1\x22\xba\x97\x5e\x33\x52\x3e\x72\xfd\x2a\xfb\xbb\x04\x43\x3e\xc0\x1e\x1e\x83\xa7\xe1\x17\x78\x50\x55\xba\x7a\x1e\xad\x7d\x59\x11\x3d\x02\x0f\xf5\xcc\x95\x16\xbc\x7d\xf5\xd0\xb6\xc7\x10\x9a\x19\x0a\xe7\x0d\x1c\x36\x2d\x60\x2f\x22\x48\x0b\x0a\x6f\x85\x26\x92\x44\x97\x49\x30\xff\x45\x32\x58\x61\x89\x95\x2d\x1f\xa9\x7b\x0e\x35\xc0\x81\x99\x3c\x0d\x2c\x7d\x94\xd1\x13\x60\x60\x36\xfa\xc7\xed\x18\x90\x6a\x69\xa2\xe9\xd8\x69\x6d\x3c\x55\x75\x6a\x59\xa9\x5a\xfa\x6a\x0e\x42\x5c\x40\x8c\x67\xcb\x33\x45\x6a\x66\x70\x96\xf8\x98\x9f\x3a\xba\xda\xed\xea\x10\x57\xdb\xc7\xae\x9f\xba\xd9\xdf\xb3\x8e\x9c\x94\xce\x70\xa5\xc4\xb3\x33\x61\x6f\xaf\xfb\x11\x81\x31\x88\x64\x61\x8b\xf8\x20\x9c\x03\xb7\xdd\xab\xa5\xfd\x88\x99\x4a\x82\xd7\xb2\x3f\x20\x6a\xce\x71\x37\xae\xbe\x4d\xc3\xe6\xce\x66\x66\x99\x59\xb5\x66\xcb\x1c\xd4\x73\x02\x1e\xb0\x1b\x24\x9b\x9c\x09\x84\x95\x48\xfd\x91\x14\xe6\xac\x6c\xa5\x96\xf5\xb9\xbf\xc0\x88\x97\x28\x25\x2e\x9b\x72\x06\xe3\xd2\x77\x3f\x03\xf2\xbe\x6d\x3d\x7e\x0b\x82\x79\xb2\x63\x59\x91\x62\x67\x29\x3c\xcb\x57\x84\x20\x2f\x56\x78\x16\xda\x6b\xa9\xb4\x92\x24\xe7\xf3\x8f\x0c\x42\xf0\x72\x7e\xf1\x86\x01\xa7\xd3\xf0\x39\x13\xde\x36\x8d\x30\xd1\x26\xfe\x99\x5f\x76\x4d\x00\x59\xc2\x25\x84\x93\xd2\x9d\x7b\xe6\x45\x7f\x89\x36\x3c\xc3\xe9\x95\xc7\xc2\xed\xdb\x25\x8b\x25\xab\x34\xad\x8b\x8e\xdf\xa0\x4f\xde\x40\xef\xf3\x4e\xe1\xf9\x08\xa1\x82\xaa\x22\x5a\xb7\x18\xdf\x4f\x44\x7b\x75\x33\x53\x0f\x8c\xc7\x57\x8b\x4d\xb0\x95\x52\xa7\xed\x33\x73\x3c\xc3\xf5\x19\xa7\x91\xd8\xb3\x0d\xa3\x80\xa6\xf1\xb0\x5c\x49\x0e\x30\x8d\xab\x2e\xa0\xc5\x2d\x32\xdd\xad\xec\xcf\xe3\x84\xad\x3b\xaf\x09\xec\x83\x30\xd5\x0e\xb6\x7d\x4e\xab\x2f\x62\xf5\xf6\x1a\x8e\x4e\x7b\x84\x49\x99\xb3\x7c\x62\x5f\x72\xc4\x65\xf8\x9d\x5f\x70\x53\x69\x83\xe3\xca\x14\x0f\x3e\x12\x27\xdc\x77\xac\x35\xfc\xdb\xfa\x52\x46\x2c\xd1\x87\x88\x25\x1e\x53\x59\x96\x84\xbb\xc6\x57\x68\xa3\x36\x4c\x5f\x69\xec\x83\xa3\x3d\x9a\x9b\xbe\x69\x31\xf1\x33\xfe\x59\x49\x37\x4e\xb8\x43\x70\x8d\x49\xc9\xf0\xc4\x94\xbe\xc3\x12\x28\x0f\xa8\x72\xaf\xbe\xbd\x30\xab\xdd\x7b\x6a\x89\x19\xf7\xba\x85\x72\x8b\x4b\xbc\x9e\x99\xe5\xd0\xa2\x6f\x29\x6c\xd9\xc4\xf4\x87\x33\x6e\x61\xbf\x54\x31\x7f\x5c\xa7\xc3\x49\x19\x45\x28\xe9\x6d\xbd\xf7\xb2\xbd\xdf\x83\x9b\x93\xc2\x44\xf4\x6c\xfa\xac\x7f\x65\xb3\xb3\xc7\xe6\x24\xc3\x85\xdf\x77\x58\x9e\x88\xcc\x55\xac\xfc\x28\x40\x95\x84\xae\xf7\x4d\xf5\x61\x22\x6e\xac\x0e\x2c\xe4\x2a\x76\x47\xb3\x1d\x96\x1c\x89\xcc\xa8\x13\x78\xb9\x8a\xae\x3e\x95\x47\xd9\x0c\x53\x82\x11\x83\x80\xee\xbd\x67\xc0\xcc\x89\x22\x94\x51\xcb\x76\xa4\x62\x14\x30\x2a\x7a\xdb\xc8\x50\x45\xf4\x79\xc1\xc9\x89\x8c\x3f\x37\xaf\x24\x13\x0b\xc1\x8e\xd8\xf0\x25\x9e\x1d\x89\x47\x87\xd2\xd1\xe4\x70\xc9\x64\x59\xc8\x26\x66\xe2\x07\x21\xed\xfb\xc7\x61\x36\x94\x8e\x7c\xa8\x08\x29\xbf\x0e\x3b\x75\x37\x23\xc2\x33\xc9\x34\x90\x6d\x4a\xc4\xb3\xdb\xf8\x0a\x6f\xf7\xf6\x89\x4f\xf8\x70\xad\xc8\x81\xa2\x76\x38\x6a\xa0\xea\x99\xfc\x78\x28\x4b\xcb\x2f\x5a\xdc\x64\xbb\x03\x8a\x8f\x78\xc9\xc5\x83\xfd\x6d\x37\x56\xd1\x5f\x5c\xa7\x66\xd7\x4c\xe5\x37\x0c\x70\x9b\x58\xf3\x7a\x16\x1e\xec\x85\x48\x37\xbe\x2d\xab\x0e\x96\xb5\x2c\x28\x31\x4b\x48\x62\xad\x65\x90\xa8\x2c\x72\x2d\x19\x1c\xa3\xa0\x11\x70\xa1\x4c\xcb\xef\xc6\xed\xa0\x33\x3d\xe6\x54\x98\x02\xc6\x32\xa9\x74\x91\x32\xd9\xbc\x58\x96\x6b\x3a\xa9\xb4\xb5\xff\x08\x5a\x80\x35\xc0\xcf\x73\x05\x89\x0e\x70\x0e\x88\xd2\x53\x73\x54\xab\xb8\x05\x1a\xd5\xeb\x3a\x2e\x5d\xb5\xb7\x44\x22\x94\x40\xb0\xf5\x2d\xb6\x45\xb7\xcc\x91\x06\x21\x10\x94\x13\x41\x8d\xf0\x91\x32\xba\xc9\xb6\x2d\xf0\x46\x19\x7d\xb1\xcb\x92\x80\x32\x42\xc7\x83\x92\x8d\x51\x1a\x99\xd5\x17\xe0\x05\x29\x74\xc5\xc3\xa7\x7c\xda\x23\x34\x84\x7c\xdc\x5c\xf7\xe3\xa8\x80\xf0\xc8\x60\xb7\x66\x63\x10\x2c\xb6\x9f\x23\xd4\x07\x67\x89\xe9\x31\x3a\xd9\x2d\xd6\x16\xab\xa1\xb9\x74\x79\x17\x20\xdb\x5d\xfb\x87\x98\xe0\xe4\x32\xaf\x5a\x7e\x02\xb1\x84\x00\x2e\x29\xe3\xe9\xae\xf3\xf4\xb3\xd7\x02\xc7\x8c\xe0\xd6\x1e\xb5\xa1\xdc\x25\x52\xa5\x4b\x8d\x98\xab\xbf\x28\x79\x90\x02\x60\x91\x38\x96\xb6\x43\x1a\xd7\xc7\xd6\x8d\xfa\xb7\xcb\xf7\x7a\x93\xba\x1d\x8a\x4b\x2d\x4e\x8e\x0c\x84\xf3\x01\x0e\xf5\x60\x5e\x2b\xa6\xf5\x8b\x9e\x6e\x08\xa2\xa8\x8b\x33\xb9\xdb\xcf\xb4\x18\xfe\x02\xe5\xf4\x80\x9d\x16\x95\x54\x81\xf2\x33\x82\x74\x51\xe1\xd8\xa3\xa9\x06\x08\x34\x3c\x3e\x3a\x4a\x30\xc3\x88\x25\xe5\xdd\x91\x5a\x61\x62\x60\xe8\xbd\x03\xea\x76\xcd\xac\xfc\x86\x61\xf6\x54\x2f\x5a\x01\x02\xfa\x14\x9c\x61\xde\x9d\xc7\xd0\x93\x49\x69\x09\x9b\x57\x31\x90\x16\xfc\xf1\xfd\x83\x5f\xa9\x90\x10\x3e\x29\xc3\xfa\x97\xbe\x48\x22\x94\x8a\xf9\xe3\xe9\x70\x92\xeb\x0b\x83\x7c\x37\x6d\x14\x46\xb5\x5e\x5a\xcf\xcd\x7e\x66\x8b\x11\x17\x30\x4a\xf1\xea\x5e\x00\xc9\x49\x91\x17\xdc\x33\x56\xb9\x21\xe9\x18\xa5\xdc\x7b\xd3\x3c\x65\xcc\x2f\x3d\xce\x70\x60\xda\xd7\x0c\xde\x71\xad\x9e\x00\x38\x5e\xf6\xd4\xd9\xd3\xc1\x4b\x38\xcc\xeb\x4f\xcd\x39\xf6\x77\x30\xd3\xea\x5a\x90\xb4\x7c\x1e\x8a\xdc\x04\x76\x3f\x91\x6e\xc3\x14\x09\xe0\x0c\x33\x97\x81\x66\x81\x21\xfd\xcb\xdf\xb7\xd1\x7e\x95\xfc\x54\x8a\x20\x1f\xa7\xe4\x1d\xfb\xc1\xca\xf2\x20\x4a\xd3\x9b\xa5\xfb\x84\x07\x11\x1c\xdf\x35\xd7\x0b\xc1\x70\xa6\x8f\x14\xba\x56\x09\xbc\xdf\x33\x87\xcb\xab\xb8\xc5\xd7\xf3\x0f\x2e\x3d\xc6\xf1\xcc\xee\x81\x2d\x7d\xa7\xdc\x5b\xce\x67\xe5\x52\xe1\x35\xab\xf3\x9d\xf3\x6e\xec\xa3\x42\x38\xe1\x91\xf7\x83\x99\x33\x2e\xbb\x08\xd2\x38\x14\x09\x59\x67\xa1\x23\x30\xdf\x26\xb8\xbd\xaf\x53\x84\x2f\x2e\x66\x67\x5c\x0a\x1a\x45\xe2\x66\xe7\x7d\x0e\x90\xc8\x2c\x6b\x87\xa2\x94\xe9\x93\x67\xfc\x06\x14\xfb\x24\x03\xb9\x3f\x58\x59\x93\x07\x2a\x8f\xfa\x94\xa9\xba\x11\xbc\x31\xaf\x90\x70\xad\x97\x45\x28\xbf\xd7\xeb\xf2\x52\x53\x92\xa4\x51\xba\x98\x74\x9e\xee\x03\x36\x2c\xa0\x51\xe3\x6a\x5c\x08\xf0\xe3\x3c\x08\x2f\x5d\x4e\xae\x73\xfb\xcd\x1d\xa5\x3b\xcd\x27\x0c\x18\x48\x58\x5d\x8e\x45\x98\x32\x1e\x39\x90\x87\x64\xa6\x6b\x59\xfd\x0d\xd9\x6a\x90\x8e\xc2\x52\x36\xd1\xd4\xed\xf7\x03\x51\x12\x21\x98\xca\x00\xea\xee\xf7\x20\x56\x86\xbb\x99\x0a\x25\x22\x08\x15\x5e\xd0\x60\x97\x4e\x33\x4f\xf2\x8c\xa2\x0f\xfa\x86\x83\xac\x5b\xf1\x1d\x76\x3a\xe0\xca\x84\x3a\xd9\xe8\x5e\xda\x9c\x72\xd7\xbf\xe7\x11\x40\xea\xd2\xec\x0a\x8d\x46\xc5\x5f\xae\xd7\x11\xe5\x01\x08\x4e\x63\xcc\x42\xd2\x17\xf1\xfd\xc3\x38\x70\xa3\x5c\x69\xaf\xa2\xb5\xd7\x37\xcf\xee\x8b\x67\xe5\xad\x03\x2a\xee\x8f\xd1\xcd\xfd\x2c\x83\x43\xab\x9d\x1a\xc2\x0e\xe1\x5b\x87\x36\xb4\x54\x92\x3f\xba\xba\xb5\x16\x85\x25\xf2\x7a\xfb\xc5\x40\x01\x06\x18\x6a\x41\x70\x42\x4e\x35\xf0\x9e\x22\x34\x54\x9e\xa5\xe0\xf4\x22\x96\x7d\x30\x75\x4a\xf4\x87\x8f\x9e\x96\xc8\x9c\x7e\x33\xf6\x1e\xd9\x0e\xd1\x7b\x7d\x02\x75\x57\xf6\x8c\xe0\xee\x4d\x93\x1e\x6a\xfa\x39\xc8\x2d\x82\x5d\x13\xf5\xab\x9d\x11\x99\x27\x6c\x53\xb2\x20\x2f\xf0\x52\x3e\x3c\xa5\x2b\xe7\x4f\x9f\x95\xdb\xd8\x1f\x65\x42\x23\x95\x42\x63\xd2\x1a\xd9\xc0\x02\xe8\x6a\x4c\x5c\x11\x12\xa3\xc4\x2d\xbe\x5a\x68\x95\x5b\xd7\xfa\x49\x3c\x8d\xaa\xfc\x0f\xf1\x84\x18\x71\xa8\x76\xde\x7e\x96\x6b\x5d\x9b\x47\xc3\xce\xd5\x54\x44\xbf\x3f\x53\xa9\xcb\xd9\xd6\x2f\x1a\xc6\x2d\xd4\xd7\x25\xdd\x92\x89\x94\xd9\xe8\x37\x0c\x88\xfe\x77\xa6\x69\x7c\x43\x16\xcb\x49\xa1\xc4\x71\xf1\x77\x63\xa8\x80\x57\x01\x9b\x14\x78\x0c\x9a\xb1\x20\xcf\x0c\x2f\x37\x04\x81\x78\xac\x82\x48\x4f\x2f\xae\xe5\xb5\x1d\xf0\x6f\x5d\x91\x9e\x0f\x94\x47\x5d\x8a\x79\x8f\xdf\x83\xeb\xfc\x87\xfb\x23\x85\x87\x1f\x37\xa9\x8f\x62\xcd\xe3\x24\x93\x74\xc7\x1c\xaa\x52\xdb\x24\x20\x06\xbe\x98\xe9\x7f\x5d\xe3\xb4\x61\x37\x1b\xcd\x46\xa3\xd1\xae\xaf\xb2\x8f\x2c\x6e\x21\x72\xcb\xdf\x49\x7c\x32\xc0\x10\xbc\xe3\xb8\x38\xea\x92\x78\xff\x36\xe7\x99\x67\x53\xa6\x68\xb1\x09\xb2\x93\x52\x5e\x5e\x93\x44\x2e\xf8\x78\x8a\x4d\xd1\x4d\x53\x3f\xe6\xbc\x9e\x27\x47\xfa\x23\xfc\x7e\xe1\x2b\x9d\xac\xba\xc4\xec\x08\x76\x34\x8a\x64\x21\x46\x79\x54\xdc\x39\xf1\x2d\xb2\x66\x56\x61\x37\x68\xfb\x42\xae\xcb\x17\x34\xfe\xab\x9f\x96\xe8\x17\x2c\xa9\x32\xbc\xc6\x89\xc4\xfd\x15\x26\x76\x54\x48\x4d\x71\x70\xf0\x34\x14\x3f\x02\x52\x5c\xb4\xbd\xb2\xaa\xbe\x58\x61\x3c\x91\xd8\x34\x10\xee\x96\x1c\x40\x4d\x69\xac\x48\xd4\x44\x5f\xbe\xe8\x09\x9b\x45\x11\x67\xaa\xcf\x52\x89\x79\xb1\x4d\x9a\xd3\xd1\x6c\x54\xfe\xd8\xa0\x4a\xdd\xae\x0d\xab\x96\x79\x0f\x63\xca\xce\x22\x99\x48\x4a\xf4\x2c\x20\x36\x8a\x75\xf6\x2f\xda\xb4\x9b\xe2\x0e\xad\x9d\x04\xc0\x0f\x8b\x94\xe9\x89\x79\x8e\x00\x97\x56\xcb\xd9\xe6\x6e\x4a\x6e\xdb\x9f\x48\x5c\x50\xc5\x52\xa3\x42\x64\x7c\xd3\x14\x34\xb9\x5f\xe8\x8e\x24\x6b\xee\x9c\xcb\xc6\xc0\xc6\x2e\xb9\x9a\x77\x12\xea\x96\xca\x1b\xc2\x99\x14\x01\x49\xa0\x70\x53\xbd\xfd\x24\xe4\xfc\x1c\x96\x7c\x7d\x6a\xce\xd6\xf4\x39\xc8\xda\xe4\xa4\xe9\x13\xc3\xfe\x11\xa1\x6d\x87\x7c\x83\x31\xd1\xdf\x98\x9e\xb7\xb7\xfc\x6e\xbe\x39\x33\x83\x39\xbe\x1f\x01\xeb\xee\xac\x90\xd4\x35\x71\x02\x53\xfa\x7c\x86\x9b\x9f\x78\x57\xed\x39\x13\xda\xdc\xec\xcd\xea\x42\xb2\x96\x56\x5a\x21\xba\x99\xb8\xcb\x6d\xa7\x4b\x2f\xfb\x4c\x6e\x3b\x69\xab\xee\x75\xb3\xed\x24\xe6\x15\x2a\xce\x74\x33\x10\xd6\xcd\xb6\x13\x8c\xd7\x40\x7d\x00\x14\xb0\xa4\xb4\x42\x7b\xf5\x59\xef\xe2\xb8\xe4\x9f\xd4\x91\x94\x14\x7a\xab\x32\x4a\xe7\x75\x40\xdf\x61\xf7\x16\x5c\x19\x4d\xfb\x89\x87\x0e\x52\x37\x6f\xb3\xf3\x18\x64\x7a\xe8\xa0\x15\xa8\xa0\x9b\x65\xb3\xf2\x37\xde\x2f\x24\x34\x5d\x5e\x95\xc1\xbf\x32\x6b\x8a\x1c\x68\x24\x8c\x13\x3d\x1c\x25\x00\x89\xe5\x31\xee\x49\xe7\x42\xd2\xd8\x83\x20\x83\xcf\x48\x7c\x08\x02\xf8\x4e\x2e\x5b\xc9\x4d\x5c\x0b\x4c\x97\x8c\xfb\x62\xda\xed\xda\xe9\x31\x4d\x67\xe6\xf2\x1a\x3a\x9d\x4e\x56\x2e\x5f\x30\xb1\x00\x2c\x9e\x2b\x16\xe1\x2c\xb8\xa4\x68\xdd\x74\x37\xb4\x6c\x38\x8d\x73\x7e\x49\x56\x5e\x0d\x4e\xe5\xcb\xbc\x4d\xf2\xb2\xc3\x7f\xf8\xd8\x91\x6a\xe4\xdc\xd9\x83\x2d\xa2\x09\x6f\xdc\xae\xc5\xaf\x51\xe4\xc1\x6f\x10\x5b\x6d\x7f\x88\xa0\x6a\xe9\x3d\x72\x03\x9c\xfc\x6d\x3e\xf1\x7e\x7a\x34\x24\x4d\x9a\xe1\x17\x1b\x7d\x7a\x20\xd5\xef\x9b\x80\x73\x00\x8b\x68\x22\x22\x9e\x87\xec\x75\x37\xb7\x56\x7b\x52\xc3\xbb\xdd\xa6\x00\xb8\x4f\x11\x2d\x9e\x85\x44\x39\x56\xd6\xd9\xa5\x67\x86\x49\xca\x8e\x4b\xec\x4c\x67\xdb\xb6\x42\x10\xff\x54\x0f\xa8\xf3\x50\xb5\x27\x87\x4b\x17\xcf\xca\xcc\xa6\xef\x0a\x0e\x71\x57\x05\x84\xd6\x92\xf3\x33\x65\xb6\xb3\xa5\x12\x04\xff\x70\xe4\x86\x26\x90\x96\x88\xdb\x92\x89\xe6\x4c\x8b\x18\x68\x70\xb3\xaa\xa7\xd5\x4e\x83\x61\x53\xae\xa3\x0c\x77\xf9\xa1\x0a\x26\x98\xd4\xe2\x85\x3b\x65\x28\x87\x2c\x2d\x02\x37\x76\xca\x78\xa3\x2d\xbf\xdb\x77\x24\x57\xa9\x17\xcf\x6e\x58\xf3\x55\x9f\x9e\x87\x85\xb8\x89\xea\xf7\xc6\x74\x38\x89\x9b\x11\xb5\x91\x99\x03\x59\xe7\x11\x8a\xba\x3f\x4b\x4d\x9f\x63\x74\xbb\x59\xd8\x83\xbe\x70\x2a\xd5\x87\x8e\xfa\x89\x05\x8b\xe2\x2d\xed\x84\x1c\xee\xcb\xd0\x91\x66\x4c\xac\x7c\xc2\x5b\x6e\x4c\x8a\xe7\x9c\x0d\x7d\x34\x89\x7b\x35\xd9\x18\xe9\xa0\xa0\xa3\x33\xe1\xa7\x8c\x1d\x15\x0b\x88\x6e\x8a\xb0\x94\x24\x24\x2c\x2b\xa3\x44\x4e\x07\xd4\x84\x2d\x48\xed\x56\x3e\x98\xd7\x48\xa6\x8e\x98\xda\xf9\x4f\x73\x5c\x08\xb7\x05\xff\x95\x2d\xd1\x3b\xc0\x57\x36\x00\x4e\xf8\x95\x4d\x89\xdd\x38\xb2\x9d\x46\x69\x95\x91\xd4\x3b\xbe\x8d\xa5\x37\x19\x6b\xf3\x32\xb1\x36\x25\x02\xd6\x92\xcc\x0f\x1c\x61\x5d\x2c\x3a\x21\x8d\xca\xb2\xda\xbd\x45\x2c\x1d\x9f\xde\x7b\x55\x84\xfe\x01\x0b\x6e\x61\x77\xbb\xb1\xf9\x85\x4e\x67\xa1\x86\x2e\xad\xf2\x49\x07\x39\x72\x3a\x6a\xa0\x84\x15\xff\x92\x8c\x1a\xb0\x3c\x49\x13\x45\xb5\x31\xf0\x60\x24\x60\x4c\x62\x72\xc7\x92\x84\x81\xd7\x9d\xea\xce\x5d\x11\xe5\x78\xe2\x1d\x39\x3d\x52\x19\x76\x26\x2a\x51\x35\xe8\x80\x04\x30\x7a\x7f\x1e\xf3\xcb\xf8\x79\x3c\x88\xe0\x01\xea\x83\x60\x4d\x7c\xf6\xd4\x99\x9a\x64\x4f\x86\xd9\xa5\x69\x5a\xae\xe3\x19\xc5\x24\xae\xee\x19\xbb\x2b\x23\x1e\x4b\x48\xc8\x46\x0a\x8d\xc3\xe9\xc4\xea\xed\xbe\x83\x00\xa7\x8e\x09\xee\xc8\x18\xf8\x89\x1f\xa7\x8f\x29\x2d\x09\xbe\x06\x3a\x4d\x24\xcb\x79\x63\xa0\xae\x45\xc0\x25\x41\x69\x95\x92\x05\x32\x5d\x96\x98\x08\xcc\x6c\xe5\xb6\xa8\x90\x89\x1c\x9a\x19\xcd\x38\x86\x49\x1a\xbc\x79\xb2\xd2\x05\x5a\x17\x47\x4a\xb3\x83\x1a\xa2\x06\xae\x5c\xd5\x1e\x32\x1a\xd6\x99\x58\x62\x18\xbf\x4c\xbe\xf6\xf0\x9f\x49\xc2\x41\x2d\xfd\x47\x72\x52\x00\x21\xcd\x30\xa0\x13\xa0\xdb\x4c\x2b\xc0\x51\x68\xaa\x53\xf3\x59\xd4\xd2\x13\xd7\xf2\x53\xbf\x35\xfd\x5f\x1e\xd8\x28\xa5\x06\x0e\x70\x6f\x46\x9a\xa7\x54\x89\x87\x11\xaf\x23\x6b\x1c\x4e\xdb\xbe\xea\x6c\x7c\x72\x87\x6e\x06\xb3\x64\xd7\x48\xa0\x07\x1e\x96\xdc\x79\x13\xdb\x8a\xe6\xf9\xee\xe4\xc8\x26\xdb\x86\x17\x78\xe3\x70\xb0\xc1\xf7\xe1\xe5\x5b\xe9\x16\x38\x47\x1a\x86\xfe\xd9\x64\x74\xac\xa2\xac\xa3\xb1\x7a\xec\xb0\x83\xd9\xa6\x06\x09\x38\xb4\xb4\x42\xbd\xae\x4b\x50\x22\x40\x32\x65\x8c\x65\x03\xe6\x94\x0b\xac\x79\xe6\x1e\x78\xe7\xa7\x1e\xda\x6a\xbd\xb8\x9c\x06\x95\x4a\x4b\xc2\x88\x68\xc1\x58\xc5\xac\x42\xec\x7d\xea\x11\xa6\x36\x08\xf9\xc3\xa2\xff\xb5\x60\x3f\xb5\x69\x10\x91\x2a\xbc\x5b\x39\x65\x2b\x62\xd1\x56\x4c\xef\x61\x4c\xcd\x99\x13\xb3\xa6\x9f\xe9\x64\x0c\x02\x42\x59\x70\x2e\xb3\xcf\x88\x0a\xc6\x6e\x5c\x34\xec\xe7\xb3\x85\xc6\xa4\x8a\xdc\x1e\x8d\x64\xec\x11\x3c\x77\xa0\xdf\x57\x22\x06\x05\xcf\xd3\x3f\x20\x9f\x27\xb9\x4f\x25\x12\x8f\x61\x01\x32\x19\x4e\xff\x39\x1f\x8b\xad\x2c\xb9\xdf\x9f\xa1\xb6\x0f\xea\x21\x9b\xc5\xe2\x7f\x2e\xd3\x79\x7f\x97\x5a\xf9\xaf\x25\xf2\x34\xf6\x55\xc4\xf5\x5e\xfa\xcb\x75\xa0\xcf\x86\xe2\x67\xa0\x29\x02\x4d\x25\x96\x00\xe7\x43\xf5\xce\x1a\x56\xe9\xa9\x07\x9a\x9e\xca\x4d\x21\x7a\xd4\x26\x90\x9d\xbc\xed\xd9\x7c\x16\x44\xc2\x2c\xa6\x69\xf5\x7e\x52\x2c\x25\xb1\xfa\x7c\x4f\x22\xbe\xfb\xd9\x0c\xe4\xcf\x1d\x68\x5c\x33\x2b\x7f\xa3\xf2\xfc\x61\xab\xbd\x1a\x9c\xe2\xe7\x04\x80\x83\x9e\x05\x88\xd0\x69\x38\x93\x82\x1e\x5c\x14\x24\x03\x21\x31\x99\x4c\x8a\xe5\x61\x36\x73\xb6\x0d\x7a\x12\x2b\x4d\xc2\x52\xad\x62\xe7\xd2\x17\x5f\x0a\x6b\xe0\xb5\x76\xcb\x6a\xc4\xdd\xe9\x8d\x1b\x55\xf8\xaf\xe8\xa3\x92\x2d\x82\xc3\x6a\x58\xfa\x47\x74\x1f\x95\x0b\x98\xbf\xc0\xa6\x95\x62\x98\x7e\x88\xcb\x9a\xc0\x93\x1b\xea\x96\xba\x77\x74\xd1\xf9\xad\x8a\xcd\x9d\xa7\x53\x12\x6b\x50\xd6\x32\xff\x8c\xa0\x28\x3d\x63\x76\x74\xf3\xa2\x22\x9e\x5b\x33\x99\xc9\x17\x26\xb6\xad\x68\xea\x44\x4e\x05\x88\x08\x3d\xb7\xf2\x88\x8e\x8b\x50\xc9\x9b\xf4\x41\xb4\x47\x14\x92\xf9\xc2\x27\x13\x5f\xe8\x52\x23\xa8\xc6\x4d\x3a\x2e\xd7\xec\x11\x9f\x33\x80\x09\xc5\xee\xd6\x74\x4a\x7e\x17\x9c\xe4\x33\x7a\x77\x78\x20\xc0\x94\xd8\x3b\x98\x37\xba\xe9\x02\x4f\xa4\x1c\x0b\x38\x9c\xc9\x59\x29\x0a\xc9\x44\x53\x45\xf8\xae\x84\xdf\x2f\x80\xa4\x13\xd4\xcc\x37\x97\x69\x0f\xe0\x0c\x8d\x21\x77\x79\xca\x36\xc0\xea\xb4\x24\xa0\x13\x8d\x38\x45\x30\xea\x54\x61\xde\x8c\xfb\x7c\x40\x08\xc6\xff\x0d\x67\xfa\xea\xd7\x0f\xf1\x2e\x3b\x6d\xc9\x1d\x07\xb4\xef\x39\xe0\x39\xc1\x73\xdd\x48\x72\x4c\x1e\x37\x26\xaa\xa4\x07\x92\x91\x8e\x33\x1b\x42\x73\x04\xe0\x8e\x7c\x5b\x6f\x10\x01\x26\x12\x6f\x75\xda\x53\x67\xf7\xd5\xad\x18\xae\x2b\x7b\xa1\x41\x45\xbf\xdf\xe5\x6b\x5a\xe2\x09\xa4\x22\x4e\xe2\x8a\x64\xea\x19\x35\x83\xa2\x3a\x9a\x98\x49\x56\xb5\xa2\xda\x8a\x95\x3e\xab\x46\xed\x62\xac\x4b\x85\xc7\xce\xa8\x66\x29\x2a\x63\x96\xa6\x47\x35\x3c\xf3\xcc\x43\xa0\x98\x00\x9f\x95\x2e\x67\xf4\x15\x5d\x04\xa8\xeb\xaf\x6b\x96\x92\x0a\x19\xb6\xa5\x81\x17\x20\x41\x30\xe3\xbe\x2d\xbe\xd3\xd9\xa3\x16\xa6\xa9\x76\x7f\x04\x86\x54\x20\xb8\x05\x06\x0f\x64\x34\x4b\x28\xa8\x16\xc5\x59\x71\x60\xb2\xaa\x9b\x28\x75\xdd\xe5\x7b\x2c\xbd\x3a\x30\x2a\x24\x7c\x32\xec\x0e\x83\x9a\x8b\x2f\x04\x49\xba\xcb\x2c\x93\x60\x45\xbc\x86\xe8\xd8\x14\xf1\x78\x50\x1b\xae\xb3\x23\x71\x84\xb0\xaf\xcf\xcc\x60\x00\x9b\xe0\x2f\xeb\x3a\xea\x80\xc8\xd2\xd3\xd6\x27\x3b\x8d\xd9\x89\x56\x06\x87\x11\x44\x29\xcb\xb4\x0c\xce\x0b\x72\xc9\xfc\xe3\x8f\xf6\x38\x39\xbe\x77\xa2\x7d\x5b\x01\xfa\x86\x46\xac\x88\xcb\x08\xeb\xa2\xf9\xde\x9c\x17\xce\xb7\x0e\x9c\xbe\xa1\x1d\x2b\xe5\xd2\xc2\x9a\x68\x9e\x4b\x48\xde\x5c\xe0\xc7\x9a\x55\x8a\x8e\x1d\xa8\xe4\xac\x82\x4a\xc0\x56\x24\x70\x55\x6a\x99\x7c\x63\x30\xcb\xee\xdc\x7b\xaf\xde\xc7\x4c\xf3\xeb\x41\xab\xda\x3f\xe8\x56\xe6\x3d\xa7\x34\x8d\xf2\xef\x53\xba\x19\xc5\xb4\x74\x60\xf5\xc5\xc6\x64\x99\xff\x89\x6f\xfc\xd9\x64\xa5\x62\x06\x55\x50\x06\x94\x17\xcc\x02\xf0\x4a\xa5\x78\x13\xd1\x67\xa4\xae\x4a\x52\xf8\x72\x9d\x4f\x85\xb9\xcf\x73\x09\xf3\x1d\xc6\xc1\x91\xa1\xda\x18\x34\x4d\x77\x98\xa9\xdc\x1e\x0d\x0f\xe8\x22\x22\xf6\x34\x14\x32\xf7\xe1\xe8\xe0\x60\x4d\xc4\x1a\xf1\x44\xba\x2f\x4e\x21\x89\xd5\x76\x82\x33\xd5\xb9\xb7\xf2\x81\xe1\x2e\x8c\x15\x66\x2b\x93\x40\x78\x4f\x97\x56\xc8\x71\xea\x9b\x6a\x5e\xd7\x43\xdf\xaa\xa9\x4b\x6d\xae\xf7\x9f\x11\x2c\xe2\xb1\x38\x48\x04\x39\x8c\x5a\xa8\xac\x3c\x26\xb8\x6f\xb6\x85\x1f\x28\xd1\x40\xff\xb0\x6b\xa9\xf1\x1e\xdf\xd6\x4d\x35\x9b\xf3\x1f\x8d\xa1\x5d\xb1\x4d\x85\xb8\x55\x32\x0c\x3d\x10\x76\x70\x42\x36\x44\x58\x6a\x60\xa9\x72\xaa\xf2\x3c\xf5\x77\x95\xc6\x31\xe6\x99\x59\xd0\x3a\xd5\x20\xe7\x6f\x91\x3c\xbf\x00\x39\xa2\x3b\x8c\x01\x9d\xf8\x8e\x46\xc0\xd5\xfa\x93\x24\x1c\x3b\x32\xd6\x9c\xd7\x6a\xb4\xb1\x10\xfa\xde\xba\xec\x78\x2c\x16\x12\xcb\x1a\xca\x81\x9d\x43\x04\xc5\x52\xc4\x89\x74\x18\x16\xb8\xb0\x12\x24\x83\x1c\x56\x4a\x66\x1e\xc1\x66\x88\xc5\x39\xc7\x29\x00\xaf\x61\x99\x39\x50\x89\xab\x26\xe0\xf8\xd1\xc5\x36\x4f\x6f\xbe\xd6\x03\x17\x6c\xa9\x3c\x9d\xd4\xf3\xe2\x02\x19\xf2\x19\xef\x64\x73\x3d\x23\x01\x33\xc5\x73\x16\x8f\xb5\x50\x2d\xd0\x62\x44\xa0\xd4\xfc\x22\x8d\x0f\xec\x5b\x3a\xb0\x77\xc9\xba\x5e\x6a\xf9\x89\xd3\x81\xbb\xd0\x51\x65\x6a\x60\x8c\x8b\x97\x54\x71\x92\x05\x3d\xa2\xfa\xb1\x94\x48\x26\xa3\x6f\x8f\x1b\xa1\x1b\x6b\xc4\x89\x4c\x44\xde\x57\xa1\x4f\xfb\x86\xc2\xf9\x94\xeb\xca\x2a\x4a\x33\x73\x5b\x19\xce\x36\x9d\x6a\x31\xf0\x40\xd9\xd8\x6e\x72\x3c\xae\xce\xbe\xdb\x87\x86\x23\x89\xcd\xd2\x40\x09\x88\x30\xbf\x9b\x63\x06\x09\xa2\x9d\x1f\x05\x99\x3f\xef\xb5\x9d\x3c\x32\x8a\x44\xd5\xd3\xa6\x09\xbf\xe8\x7d\xaf\xb0\x54\x73\xcd\xd9\x53\xce\xfd\xd0\x22\xe2\x0b\x52\xcd\x0a\xae\x95\xa4\x2e\x7d\xdf\x6f\x5a\xde\xcd\x18\xe3\x87\xf9\x46\x6f\x2a\x98\x95\xa7\xdd\x97\x87\xb6\xff\xb7\x96\xb5\x3a\xdd\xf4\xd6\x1b\xc1\x93\xbc\xc1\x37\xc9\xed\xf7\x48\xc2\xf2\xe4\x8d\x9a\x0e\xa5\x78\xa1\xb4\x5d\xc5\xdb\xc7\x61\x19\x36\x1e\x76\x35\xed\x12\x52\xfd\xa0\xcc\xbe\x65\x31\x87\xed\x24\x58\x4c\x85\x9b\xba\xc3\x0a\x4a\x89\x61\x61\x9a\x11\x13\xdd\x86\x2c\xc6\xf3\xec\x84\x90\xcc\x1a\x22\x33\x2d\xcf\x47\xe4\x21\x1c\xcb\xa5\x38\xb3\xb7\xf2\x38\x0a\x7c\xe0\x54\x3a\x53\xde\x50\x93\x8c\x02\x1f\xb8\xb6\xf5\xf1\x70\x1c\x4d\x52\xae\x59\xde\x62\xf4\xe6\xa5\x7b\xef\x2b\xbb\x4f\xfd\x65\xdb\x9b\x32\xf6\xf2\xd7\x67\x05\xa7\xa9\xd3\x75\xae\xe7\xf7\x56\x3d\xfa\x55\x3e\x2d\xc5\x01\x6b\x62\x36\x55\x9f\x12\x92\x92\xd0\xa9\x70\x5a\xe2\x4d\xbd\xd0\x4f\xa8\x60\xff\xb2\xdc\x24\x57\xe8\x44\xc1\x79\x1b\x8e\x11\xb9\xf1\x41\xdf\xbb\xa3\x5b\xc0\x34\x05\x8d\xfc\x61\x91\xfc\x4a\x7f\x3f\xae\x66\x44\x3f\x3d\x97\xef\x91\x89\x64\xb0\xaf\x28\x4b\x44\xe4\xb4\xb1\x3a\xe2\x9c\x44\x1e\x93\x2f\x5b\xe5\x23\xa2\x7f\xf5\x24\x41\x0c\xc5\xfb\x23\x4b\x48\x2e\x11\x3a\x95\x9e\x78\x3f\x25\xe6\xdb\x56\xf4\x72\xb7\x15\x40\x01\x5b\x42\x24\xcc\x7d\x9e\x63\xf1\x6f\x18\xe1\x93\xdb\x53\x36\x60\x4c\x50\x66\x4d\x26\xc9\x94\x80\x9b\x41\x3c\x3a\x8a\x07\xae\x76\x90\x9e\xc3\x9a\x0a\x51\xd2\x7e\x50\xdf\x1b\x10\x77\xa1\x92\xef\x5b\xeb\xed\x2b\x08\xf7\x9e\x14\xad\x91\x86\x8f\xfb\x01\x60\x2b\x6a\xa3\x20\x56\xdf\xc7\x2b\x8f\x9e\x52\x2a\xe3\x01\xb6\xb5\x75\xa3\x6c\x7f\x21\x14\x0e\xa3\xfe\xea\x7c\xfe\x2b\x27\xaf\x4b\x59\xfe\x36\x9b\x36\xb6\xcd\x5f\x06\xeb\x96\x75\x64\xd2\x7d\x5f\x03\x87\xac\xdc\x5b\xff\x79\x75\xdb\x98\x95\x6a\x8e\xa5\x00\xb0\xbb\x6f\x24\xc6\xe3\x59\x3d\xa0\x79\x6a\x52\x9c\x11\x69\x29\x8b\x16\x99\x06\x62\x90\xd4\x8b\x4c\x61\x44\x28\xbd\x58\xfd\x55\xca\x77\x49\x08\xab\xda\xbb\x5a\x80\x16\x24\xf4\x37\x02\xda\xbb\xee\x39\x1a\xb9\xfa\x26\x7f\x99\xd6\x34\x5a\xc3\xdd\xd6\x27\x8c\x93\x44\x46\x9f\xf5\xdd\x10\x5b\x4e\x5d\xc5\x7e\xe6\x64\x18\x44\x3f\x56\xf0\xf6\x17\x51\x95\x57\xa1\xcd\xcd\xb2\x81\x7d\x76\x53\x3e\xc1\x4e\x0e\x03\x6d\xf7\xc9\xc3\x2b\x03\x53\xde\x71\xf0\xb8\x0e\x48\xb0\xff\x61\xff\xfa\xca\x55\x21\xf7\xce\x92\xaf\xe6\x86\x1a\x17\x89\xda\x57\x62\x5f\x2b\xa5\xab\x8d\x99\xe8\x55\xf4\xfe\x4f\x5d\x8a\x5e\x1b\xbf\xec\x08\xfc\x6c\x35\x07\x39\x09\x40\xc5\xe4\x31\xe6\x27\x7f\xeb\xe0\xd9\x41\x9f\x5e\xfe\x83\x6d\xec\xaa\x12\xfd\xc9\x11\xb2\x6f\xb1\x12\x3a\x9b\xc1\x39\xb8\xd7\xa3\xa3\x73\x19\x0e\x9b\x2d\x13\xdd\x00\x4e\x3a\x1a\xbb\x11\x98\x80\x74\x44\x01\x2d\xc6\x7a\x6b\x53\xb7\xea\x6a\xb5\x61\x34\xed\x9f\x72\x63\xb4\x7f\x7a\x0f\x46\xfb\xdb\xbb\x20\xde\xbf\xe1\x84\x78\xff\xda\x76\x88\xf7\x37\x5b\x00\xbc\xc3\xa4\x43\x38\x96\x23\x37\xb6\x70\x35\xdf\x2b\xb3\x86\xb3\x20\x1c\xe2\x7e\x1d\x2a\x85\x62\x4a\x4a\x59\xdc\x7a\xd6\xb3\x77\x2b\xfc\xb5\xcd\xd9\x02\xef\x10\x2d\xc8\xea\x70\x99\x2f\x4c\xcc\x4c\x5b\x63\x67\xd8\xf7\xd1\xcd\x6e\xf4\x6c\x63\xb8\x93\x61\xff\x50\x89\x86\xd4\xcb\x48\xab\x46\xe7\xbf\x02\xbb\xbe\x9b\x24\x7d\xd2\x39\x60\x7f\xa3\xa1\xcb\xd6\x18\xb0\x91\x5c\x0a\x82\xf4\x0f\x38\x33\xe6\x12\x59\x6d\xf0\x31\x62\x3e\xbf\x7e\xc6\xbd\x4a\xae\xf9\xd8\x82\xaf\xcf\x8f\xc9\xfc\x79\x42\x73\x3d\x22\x92\x86\xe8\xcc\xc3\x66\xed\x28\x7a\x4b\x89\x05\x1c\xf7\x4d\x7f\xc5\x22\x8d\x1a\x08\x48\x60\xe5\xc6\x77\x08\xb5\x63\xbd\x45\x64\x85\xea\x3a\x62\x38\xae\x36\x28\x02\x39\xb0\x18\x89\x3c\xef\x10\xc9\x63\xff\x6c\x8d\xdd\x98\x1e\x2f\x85\xbd\x16\xfc\x10\x6b\x9d\x9b\x67\xea\x0c\x47\xa4\xb4\xbd\x8c\x01\x91\xb0\xc9\xda\xe0\x5e\x02\x45\x53\x45\x29\x35\xd6\x47\xeb\x5f\x5e\xbd\x8f\x6b\xdf\x87\x0b\xf2\x76\x89\xbf\xd5\xcc\x9a\xd3\x11\x7d\x54\x33\xff\x3b\x36\xf1\x0c\x20\x57\x76\x15\x54\x43\x50\x5f\xa0\xf6\xd0\x6b\xf3\xc2\xea\x8c\x2e\x5f\x65\xbc\xe0\xd1\x94\x4e\x4a\xd3\x4c\x00\x7b\x54\xc9\x21\xb3\x8a\x36\x93\x6a\x3e\x68\xf8\x9c\x30\xdd\x0c\xba\x23\xe7\x86\xdd\xd9\x5b\xaf\xea\xe3\x97\x9a\xa9\xc0\x86\xcc\x4b\xc3\x01\xb1\x7a\x93\x2c\xfe\x21\xda\x13\x33\x88\xa6\xd2\x32\x98\xe7\x06\x81\xb6\x3a\x36\x64\x3e\x1d\xa5\x05\x68\x69\x6d\x45\xd6\x5c\xcc\x3d\xf0\x48\x0c\xba\xd4\x1c\x5a\x2b\x7b\x36\x9c\xac\x40\x57\xca\xca\xaf\x26\x11\x6c\x43\x27\x12\xc2\x2c\x92\x10\x11\xd0\x72\x58\x20\x14\x12\x07\x21\x15\x1a\x38\x9f\x28\x5c\xe3\xcc\xad\x32\x98\x2d\xc1\x50\x38\x0e\x68\xe8\xef\x40\x0e\x92\x14\x43\x34\x0b\x9a\x8d\x3c\x7e\xb3\xa1\x06\xd9\xee\x5a\x37\x6a\x25\x29\x0c\x65\xfe\xb4\xc5\xeb\x65\x46\xcb\xfc\x70\x5a\xea\x27\x31\x35\xb1\x0b\xd3\x5e\x36\x1a\x42\x83\xcd\x05\xc8\x33\xb8\x6e\x63\x99\x6f\x23\x14\x7e\xba\x88\xc2\xc2\xb2\x71\x98\xaf\x52\xdb\x40\x21\xd5\xa1\xf7\xd0\x20\x7a\xc3\x5e\xdd\x4b\x73\x5d\x54\xde\x40\x83\x54\x4e\xb3\x54\x20\x85\x2c\x53\x2a\x40\x01\x37\xd0\x13\xd9\x17\x43\xbe\xaf\x89\xc4\xab\xdb\xc9\x85\x98\x0f\xf6\x93\x92\x4c\x0e\x9d\xa8\x69\x51\x86\x4e\x95\x1c\x2c\x84\xc4\x09\x23\x3a\xe5\xce\x52\xd1\xaa\xbb\x88\xa5\x6a\xf8\x92\x17\x17\x39\x97\x05\x15\xe2\x31\x80\x2d\x82\x59\x99\x97\x50\xc7\x4e\xc2\xbf\x00\x8a\x5c\x26\xb9\x79\x4c\x38\xaf\xd3\xb9\xcd\xf7\x89\x26\x30\xcb\x63\x92\xc1\x76\x08\x14\xf0\xc6\x89\x5c\x8e\xc0\x8a\xa1\xf2\x4a\xb5\x41\xca\xcd\x3b\xa4\xf2\x51\x3b\x1c\x95\x5d\x85\x89\xfd\x49\xb4\x4d\x38\x09\xd9\x73\xaf\x02\xaa\xd8\x14\x4d\x66\xf4\x3f\xd4\xb0\x07\x1c\xa1\x49\x12\x18\x9a\xb2\x72\x1b\xbb\x72\x21\xd2\x4b\x86\x39\xd1\x8f\x38\x70\xd9\x7d\x51\xbf\xec\xbd\x8d\x8b\xe7\x67\xfb\x2d\x84\x2a\x0f\x73\x6d\xb5\x7e\xc5\x58\x06\xd7\x50\x1a\x30\x64\xf8\x4d\x5e\x08\xb5\xf0\x3f\x44\xc5\x18\x64\x49\x82\x6d\x3c\x86\xa8\x70\x3b\xa1\x7f\x06\x79\x8e\x06\x2c\x22\xdb\xa6\xa6\x36\xad\xe4\x76\xca\x70\x07\x54\x5c\x5e\xca\x6e\xf4\xdb\xf7\xbe\x7f\x05\x33\x6d\xa4\x3e\x38\xa4\x65\x43\xae\xf1\xdc\x4e\x7d\x10\xad\xcd\xea\xed\x63\xc3\xa0\xe6\xd9\xad\x24\x73\x37\xdb\xbc\x13\xfa\x9c\x23\xd5\xb5\x3c\x53\x46\x2d\x41\xba\xa7\xa0\x14\xe4\x86\xf9\x7a\xac\xd2\xe2\x89\xb1\x13\xcf\x0a\x80\x42\x81\x09\x2a\x7b\xb8\x06\x36\x63\x67\x1d\x89\x87\xb1\x54\x7a\xad\x47\x07\x58\x1f\x32\x2b\x93\x82\xcd\xf6\xd9\x19\xff\x61\x07\xb6\x9c\x30\x9b\x01\x1b\x86\xa4\xff\x07\x3b\xe6\x1c\x20\x9d\x45\x45\x61\x47\x98\x64\xf1\xce\x98\x00\x06\xd7\xbf\xc0\x5b\xef\xaa\x4d\x00\xbc\xab\x06\xe1\x0a\xae\x69\xf0\x1b\x9e\xd3\x0f\x67\xf4\xd2\x3a\x42\x88\x5b\xc4\x09\x55\xfa\xb9\xad\x12\x33\xbd\x19\x4a\x39\xdd\x0d\x30\x08\xca\x0f\x9a\x49\x06\xbe\x32\x27\x09\x6f\xab\xfd\x93\xd0\x16\x12\x5c\x65\xa0\x25\x34\x5e\x35\x7d\xa3\x86\xb6\x1e\x02\xe6\x35\x82\xd4\x0b\x1d\xfd\x20\xd2\x30\x3d\x07\xf3\x13\x0d\x9e\xc1\x4a\xc7\x7d\x6d\x7f\x1f\xe4\x13\x79\xb0\x12\x26\xa9\xa8\xa9\xcf\x22\x91\xfe\x2e\x63\xd6\x82\x09\x56\xbb\xf1\x7d\x65\xe7\x4a\xdf\xda\xeb\x3a\x34\x32\x71\x60\x47\xcc\x4f\xf4\xa6\x9b\x2d\x13\x14\x95\xf2\x9c\xaf\xc1\xe3\x2d\x42\x94\x8b\xee\x99\x4a\x97\x46\xb8\xe9\x59\xc3\xdb\xbe\xa2\x33\x7c\xff\xc5\x7c\x29\xc9\xe4\x0e\x8a\xe0\xf3\x06\xac\xba\xea\xf6\x49\x47\xee\xcc\xc1\x61\xbe\xe9\x0f\x9e\xa2\x08\x2b\xef\x2a\xbd\xef\x74\x74\x50\x11\x62\xef\xf6\x82\xef\x41\xdd\x1d\x18\x44\x6f\x3f\x04\x43\x10\x8e\xa1\x67\xb4\x74\xf3\xb4\xf5\xd0\x3b\xf2\xb8\xc4\x49\xcb\x5d\x47\x1d\x85\x98\x32\x52\x45\x3c\x5e\x95\x6d\x4b\x33\x94\xac\xf7\x14\xa7\x2b\xe1\x13\xac\x3b\xdf\x0d\x9a\x5b\x8b\xaa\x16\xcb\x33\xcb\xda\xf9\x8f\x19\x5b\x31\xb0\xbc\xc1\xbd\x79\x84\x76\xb8\x85\x8f\x0a\x17\x23\x7f\x0f\xaa\xdc\x70\xdf\x3c\x6a\xd4\x69\x43\xd3\x61\x66\xe6\x7e\x5c\xe7\x1b\x47\xa4\x03\x43\xa5\x34\x1b\xee\xc2\xde\x64\x75\x62\x74\x20\x42\xa0\x4b\x97\xc2\xf5\xd0\xb1\x51\x6d\xbd\x13\x3d\xce\x61\x9b\xa6\x9b\x54\x71\x3c\xad\xf6\x5e\x7a\xe7\xd8\xa1\xf1\xaf\x28\xcb\xde\xb9\x96\x47\x7e\x51\xdb\xbc\x5a\x6f\x4f\x18\xf8\xd6\x63\xe7\x86\xe0\x94\x0f\x72\x3e\x52\xa5\x7b\x62\xba\xb9\x34\xa6\xf7\xcb\x76\x4d\x9d\x71\x84\xb3\x11\x83\x6c\x29\x3c\x8b\x56\x94\x7b\xc4\x9b\xe6\x99\x90\xb1\x32\x50\x99\x00\xfa\x54\x19\x80\x27\x1d\x44\xd8\x0c\x0a\x56\x74\xbb\x02\x90\xbc\xce\xf2\x15\x9d\x87\x6f\x50\xad\x61\x55\x92\xc9\xe3\x36\x60\x88\xa0\x01\xff\x22\xc2\x81\x81\x51\x65\xef\x5d\x6b\x04\x61\x2d\xdf\x5e\x3c\x78\x6a\x9f\x3c\xe4\x47\x2e\xdb\xd9\xd5\x7e\xad\xa5\xb6\xd7\xeb\xc5\xe9\xf4\x35\xdb\xb9\xbd\xdb\xaf\x5d\xd3\x56\xfa\x1d\xbe\x60\x38\xcf\xa6\xbe\x8e\x11\x97\xf8\x25\xb9\xbd\xbb\x72\xd7\x1e\x79\xa3\x76\xd1\xf4\x0e\x02\x18\x02\x9b\xf3\x92\x9c\x3b\xe3\xdb\x70\x63\xff\x19\xf7\x85\xea\xb5\x1c\xfd\xe8\x9b\xfc\xca\xd3\xdd\x60\x00\x9b\xd9\x98\xbd\x75\xd2\x99\xc1\xed\x16\x39\x71\xb9\xef\x71\x10\x9b\x45\xa9\xc4\x7f\xa9\x19\xd2\xb9\xe6\xcd\xec\x42\xc5\x19\xd2\xe7\x15\x14\xa7\x07\xdb\x36\xd8\xc7\x91\x03\x61\xb7\x65\xdc\xc1\xb6\x45\xf5\xd8\xab\x4f\xe2\x59\x94\xfa\xad\xc7\x91\x23\x3a\x79\xeb\x12\x70\x1c\x02\x80\x10\xc6\xe9\x2f\x21\x2f\x1c\xa5\xbf\x35\x73\x91\xa7\x96\x55\x27\x21\x20\xe0\x7f\xeb\x22\x7c\x87\x8d\xa5\x42\xe3\xa1\xaa\xa8\x0a\xe3\x0f\x74\x5c\x1b\x8f\x54\x23\x19\xe2\xf3\xd2\xd2\x9d\x4d\x8e\x24\x2b\x32\x6e\x5f\xc5\xe4\xde\x20\x91\xba\xbe\x62\xd3\xda\x1c\x1c\xe2\x5e\xa7\x26\xf5\xb1\x90\x92\xaa\x99\x8f\xc8\x65\x17\xc3\xe9\x14\x69\x99\x1b\xa6\x63\xe0\x49\xea\x3d\x15\x15\x84\xfa\x05\x75\x25\x45\x16\xa6\xa3\x8c\xc8\xad\xf3\xd6\x93\x1f\x0a\xcd\xca\xd3\x66\x6a\xb0\x61\xd8\xb8\xd6\x90\xa0\x93\xce\xcd\x45\xc0\xd3\x9d\xe0\x13\xe2\xab\x5f\xd1\x65\x02\xf6\x9c\xe0\x28\x72\x7d\xf2\x9e\x6d\x6f\x39\x19\xba\xfb\x55\x50\x36\x7a\x48\x24\x67\xb0\x34\x04\xf1\xd9\xba\x36\xa9\x50\xf3\xf7\x40\x40\xe2\x58\x0d\x28\x31\xcd\xce\x98\xcd\x00\x7f\xe1\x78\x5f\x09\x4a\x79\xbd\x7b\x95\x33\xda\xe6\x13\x03\xad\x27\x2c\xbe\x83\xf1\xe3\x4d\xeb\x31\x6e\x9b\xd8\x15\x85\x3e\x76\xf0\x4f\xea\xf4\x86\xd5\xb3\x86\xfd\xf8\xc4\x6a\xfe\xdf\x12\x98\xd6\xb0\x72\xcd\x31\xe3\x66\x34\x63\x73\xba\x5f\x25\x76\x25\x6c\x93\xe3\x4b\xdf\x5a\x4e\x69\x92\x2b\x56\xf8\xee\x33\xdf\x27\xb7\xa4\xc4\xd4\xe0\x7e\xe7\x94\xeb\x4e\x9b\x4d\xe0\x47\x40\x48\xef\xe4\x1d\x42\xee\x62\x2b\xd3\xfd\xca\xee\xa7\x76\xdd\x56\x46\x71\x40\x18\x9b\xdd\xb1\x75\x4b\x5a\x9d\x68\xaa\x70\x40\xec\xed\x45\x30\xf7\xf8\x81\xbf\xe4\x75\x61\x81\x97\xce\xf2\x53\x58\x64\x84\xee\x85\x55\xb8\x93\x98\x4b\x7d\xd4\xaf\xd2\x38\x47\x81\x58\xc7\x4b\x02\x19\x69\x49\x04\xac\x82\xed\xa3\x25\x9a\x0b\xc7\xfb\x83\x00\x07\x19\x75\x52\x29\xb1\x45\x9e\xe0\x92\x49\x2d\xa8\xda\x96\x38\x9c\xc6\x7c\x0e\x31\x07\xd6\x12\xcb\x47\x12\x80\xce\x9e\xe0\xe6\x66\x36\xeb\xc8\x80\xee\x3d\x21\x16\x4b\xc0\x46\x36\x92\x51\x66\x1e\x5b\x58\xb1\x15\xd2\xda\x7e\xc0\x10\xf4\x97\x5f\x8f\xe0\x6a\xa2\x5c\x5e\xea\xcd\x8b\x5e\x14\x6b\x85\x94\x9a\x9d\x60\x93\x88\xfe\xf9\x44\xf8\xb5\x73\xf5\x05\x05\x06\x47\x5d\x7e\x96\xe3\xa4\x9b\x79\x13\x07\x6f\x10\x02\x01\x8a\x7d\x8e\x7f\xd1\x3b\x2b\x69\x25\x8b\x08\x1a\x4e\x7d\x87\x51\xbc\x9c\x30\xbf\xe5\xfe\xd4\xa5\xed\x55\xbf\xc9\x75\x29\x4d\xb6\xdd\x5b\xc6\x5a\x60\x22\x9f\x37\x0d\xb9\xe2\x1a\x0e\x3f\x2f\x5b\x43\xe4\x7b\xcc\x6c\xf1\x82\x29\xf2\x24\x18\x4d\x72\x89\xf5\xc0\x9a\x7c\x5e\xba\x04\x91\x09\x61\x99\xbb\xe2\xb7\x10\x03\xfe\xa7\x3a\x88\xa0\xcd\x22\xe9\xd6\x8a\x9d\xdb\x61\x09\xc2\x6c\x02\xf2\x3e\x1b\xde\x68\x00\xc7\xe1\x79\xa2\x7f\x80\x14\x61\xd1\xce\x7b\x9e\x32\x3e\xaf\xfe\x43\x50\xae\x89\x90\xb0\x4c\xc5\x0f\x10\x20\x9a\x6a\x3f\xd1\x6e\x08\x74\x67\xe5\x9e\xd8\xd3\x5d\x03\xa6\x16\xe1\x53\x88\xb8\xf8\xf8\x7b\xe1\xb5\x55\xd3\x87\x05\x91\x28\x27\xb3\xb5\x62\xe7\xa3\x27\x66\x8f\xe6\x67\x30\xd3\x83\xdd\xea\x18\x95\xc4\x4c\x50\x41\xa5\x4d\x74\x64\x15\x07\xcc\x29\xe3\xb3\x32\xc3\xba\xe3\x59\x21\xd6\x76\x00\x8e\x26\x60\x6f\x85\xaf\xfe\x32\x12\x50\x5b\x0b\x1b\x9d\x61\xde\x94\x84\xbb\x35\xfb\xc0\x0c\x53\x87\x7c\x23\x2b\x80\xb2\x01\x37\x4a\x05\xa4\x8a\x0a\x23\x1b\xc8\xb8\xcc\x5f\xab\xd5\x64\x55\xa9\xa4\x36\x23\x56\x19\x44\xae\x86\xc0\x9b\x42\x22\x4b\x83\xf7\xd6\x7c\xa2\x1a\xb8\xc0\xc1\x19\x16\x80\x29\x02\x6f\x90\xd0\x10\xaa\x74\x6b\xfd\x6c\x03\x9a\xe6\xc8\x2c\xae\x14\xfb\x6c\x11\xe8\xa1\xeb\x0f\xf3\x55\x1f\xec\x29\xdd\xb9\x65\x98\x35\x81\x3c\x41\xba\x08\xb0\x1e\x5c\x30\x9c\xeb\x9e\x5f\xec\x37\xd8\xd9\xf6\xed\x5e\x7e\x7b\xd8\x24\x0d\x71\x52\x82\xce\xb0\x66\x93\x13\x01\xfb\xeb\x50\x0a\x10\x61\x1a\x21\x66\x97\xb4\xf9\x16\x58\x55\x83\xb2\xb3\x68\x58\x1b\xf2\xa2\x6c\xdb\xbd\x5e\xc1\xf1\x3a\x28\x9f\x03\x6d\xa0\x3f\x92\xc5\x40\x3d\x62\x68\x67\x99\xdd\x4f\xcd\x96\x7b\x2d\x93\x69\xd0\x3a\x92\x27\xb4\x41\x15\x8b\x38\x3f\x67\xc2\xf0\x7a\x48\x46\x7a\x30\x11\x10\xf7\x5b\x0f\x44\x23\xe3\x90\x41\x8c\x19\x2e\xf6\xe0\xba\x25\x27\xb6\x80\x77\xad\x3d\x32\x0f\x33\x1a\xa4\xc9\xb8\xb7\x9d\x5a\x27\xf2\xa1\x48\x78\x86\x93\xaa\xbb\xee\x9b\x26\x07\x49\x9d\x92\x34\xd0\x31\x49\xef\x9d\x4a\x69\xa4\xad\xbf\x9b\x65\xe8\x7a\x94\xda\x1b\xcc\xd3\xcd\x8f\x97\xfd\x6f\xe2\xd9\xb4\x9b\x8f\x7b\x83\xa9\x81\xfe\xb0\x69\xe7\xc3\x9f\x38\x1d\x09\x30\x5b\xcb\x4b\xb8\x2f\xee\x03\x1f\x6e\x2a\xed\xa8\x61\x35\xf3\x11\xd2\xed\xe1\xb0\x89\x10\xea\x2c\x63\x02\x90\x98\xac\xe8\xfb\x98\x18\xb1\x12\xd7\x2b\x9a\xd5\x41\xbe\xb7\x07\x42\x44\x72\x6c\x44\x6f\xb8\x9f\x11\xf1\x22\x24\x1f\x54\x68\xda\x54\x17\xb5\x99\x8a\xa2\x39\xe6\xae\x24\xc6\xe5\xb2\xa3\xe9\xfe\x27\xf7\xf2\xf6\xbc\xf8\xe1\x10\x30\x56\x88\x27\x7c\xe3\x22\xcf\x05\x92\x98\xe2\xeb\x80\xf4\xa1\x1c\x0a\xc0\x91\xd7\x53\x96\x41\x0f\x4a\x21\x94\xd5\x8f\xdf\x91\xd2\x36\xc6\x46\x36\x52\x5c\x8a\x36\x14\x5c\xbf\xbb\x39\xb4\x08\x17\x2d\xf8\x5f\x3d\xa6\xc1\x51\xb3\x22\x39\x49\x57\x2e\x5c\x2e\x0e\x7a\x6d\x6b\x7a\xcb\x46\xcd\xb5\x55\xf4\x78\x0f\x3c\x39\xdf\xd0\xc9\x91\xaa\x24\xc6\x37\x69\xfc\x46\x53\xe9\xef\xcf\xe1\xfe\xca\xa7\x62\xdf\x82\x40\xfe\xdb\xa8\xea\x94\x7d\xfa\xcf\x75\xe5\x01\xf4\x6f\xf6\xa1\xfe\xcf\xbe\xbc\x11\xde\xd1\xaa\x0f\x07\x10\x6a\xbd\x34\x3d\xa4\xee\xfe\xba\xe3\xa5\x6f\x65\x55\x4b\x0b\xe6\x78\x64\xe9\x57\x98\xeb\xbb\xb8\x31\x6e\x44\xa5\x58\xcd\xf5\x98\xe5\x79\x96\x22\x8d\xae\xe9\x35\xe5\x80\x98\xc0\xca\x82\x82\xd7\x14\x95\xd5\x4b\x01\x95\xec\x17\xd1\xfb\xa4\xbf\x14\x2d\xa4\x6f\x37\x42\x22\xb4\xe0\x12\xc4\x9b\x29\x1e\x98\xa5\x75\x57\x0c\xe2\xd1\x1f\x45\xc1\x68\x39\xac\x10\x01\xc0\x62\x29\x1a\x50\xe4\x25\x2e\x96\x24\x84\x47\x9c\xc1\x28\x40\x28\x16\x91\x11\xf1\x75\xa3\xd6\x52\x8d\x1b\xec\x66\x4c\x54\x20\x06\xcf\xaa\x1b\x4a\x36\x0d\xe9\xce\xea\x29\x0f\x48\x2a\x79\xd3\xdf\xf1\x0b\xe8\x9f\x3d\xce\xd2\xcc\x51\x0b\x2f\xab\xdd\xd2\xd8\x75\x49\x2e\xbd\x08\xba\x3c\x8f\xdb\xef\x90\xc1\x18\x2c\x96\xb0\x72\x23\x82\x79\x04\x7c\xbe\x03\x06\x6c\xc9\x3c\x60\xfa\xc6\x51\xf9\x07\xea\x3d\xc4\xfb\xd4\xf9\xeb\xa9\x46\x24\x1b\xe8\xab\xd2\x41\x92\x74\xe9\x98\x8d\x32\xda\xec\x94\x64\x36\x01\x63\xcc\xf3\x82\x57\xc7\xa5\xe4\x87\xa3\x34\x7e\xf6\x25\xef\x76\x1b\x62\x19\xfc\x61\xff\xd0\x95\x5f\x43\xd5\xae\xe3\x59\xde\x6c\x87\xcc\xa8\xce\x76\x1a\x71\xa4\x1a\x80\x73\x10\x24\x6d\x3a\xb0\x47\xdf\xf4\xe3\x5c\xbc\x57\x5b\xf6\xb3\xa9\xb3\x43\x09\x19\xe5\x6c\xf1\xf4\x7d\x0f\xd3\x52\xc5\x5e\x9f\x32\x4a\xa9\x49\x36\xde\x58\xfc\x6c\x39\xa1\xe8\xaf\x3d\xf1\xff\xfb\x83\x11\x8c\x60\x74\x07\xfd\xd3\x91\xef\x15\x2f\xf5\x17\x94\x19\x83\x50\xac\xd9\x6a\x65\x73\x22\x9c\xa9\x5f\xac\x0d\x4c\x19\x8d\xc4\x77\xa7\x6d\xab\xcb\x7e\xc0\xa6\x58\x14\xba\xe2\xcd\x4e\xfb\x16\x4d\xef\x31\x78\xbf\xd5\x16\x7f\xaa\xd9\x9b\x23\x02\xb8\xea\x4e\x6d\x7a\x53\x0f\xef\x8d\x25\x62\xb7\x96\x1f\x2c\xef\xf2\xe3\xa0\xc5\xbd\x9b\x7e\xb2\x42\x9d\xee\x09\x60\xff\x39\xef\xf5\x56\x75\x36\x55\xaa\x7d\xd6\xba\x47\xa6\x7f\x1d\x0c\xac\x75\xf1\x6e\x8b\x77\x4f\xbe\xb5\x03\xaf\x1c\xb0\xe7\x1c\x66\x73\x43\x97\x5c\x1c\x81\xb2\x08\xbd\x1c\xcf\xfe\xdb\xcf\x67\xfd\x1a\xb4\x13\x87\xb8\xfe\xb9\xb3\x56\x97\xeb\xce\xa6\xae\x8f\x40\x9b\xb6\xfd\xe2\xac\x3a\xaa\x5f\x60\x63\x2b\x7d\xf1\xfd\xfe\x4c\x95\x3c\xd1\x5b\xb4\x90\x23\x55\xab\xd6\x2a\x1f\x7c\xd0\xe6\xad\xba\x5b\x93\xdb\x5b\xe5\xa7\x99\xeb\xba\xd4\xa7\x6f\xb8\xca\xc9\xbc\x02\xb9\xbf\x5c\x3d\x47\x52\xf8\x4b\x2c\x21\x5b\x3c\x8b\xbe\x48\xe3\x3f\x8e\x85\x3b\x85\x39\xe1\xf8\xc6\x05\x81\x3a\x91\xd4\x49\xcd\xa3\x2b\xbe\xcc\x61\xfe\x98\xf9\x21\xbf\xb7\xed\x2a\x8f\xc8\x3f\x23\x92\x27\x47\xd0\x07\xe3\x3d\x9f\xed\xc4\x51\x36\x15\x9b\x2c\x1a\xe3\x67\xcb\x6d\x26\x3b\xb6\x87\x88\xd4\xf3\xd7\xce\xeb\xb9\xd9\x58\xe6\x95\x85\x30\xf2\xf5\xe1\x0a\xf9\xc0\x1f\x80\x93\x0e\x9d\xec\x0b\x8f\x3b\x71\x57\xa9\x71\xcd\x27\xab\x34\x8c\xae\x49\x0b\xf0\x0c\x43\xb5\x67\xed\xdc\xf1\xce\x83\x59\xad\x60\xc6\x13\x7e\x1d\x60\x36\x69\x78\x11\x30\x0e\x4f\x47\xba\x19\x67\x60\xce\xee\xde\x5b\x7e\x93\xe0\x3f\x4e\x43\xe0\x51\x40\xea\xf8\xc8\x84\x36\xe6\x90\x4e\xce\x81\x84\xaa\x9e\x41\x7d\x6a\xc0\x8e\x42\x61\xf3\xc1\x1c\x33\xed\xc5\xa5\x29\xea\x15\xc3\xcf\xcb\xb4\x3a\x71\xba\x49\xab\x00\xed\xaf\x9e\xc1\x1d\x67\x5a\xbe\x08\x32\xcf\x76\x1a\x6c\x66\x2c\xdf\x10\xd0\xa3\xa2\xce\x7f\x59\xbf\xf3\x87\xd1\xae\xec\xdd\x62\xd4\xa9\xea\x1c\xf9\x9e\x19\xd9\x58\x6f\xc3\x49\x12\xc4\x97\xcb\x9c\xdd\x58\xa8\x81\xa2\x0e\x5f\x27\x01\xc4\x12\xf2\xc3\x35\xf5\xc7\x15\x5d\x1a\x4a\x84\xb8\xfc\x32\x50\xd2\x08\x39\x32\xb0\xa8\x43\xcd\x89\xfa\xd4\xff\x0c\xfd\x40\xf1\x99\xa6\x43\xa5\xa0\x86\xf9\x9b\x18\x36\x14\x45\x9f\x65\xd1\x00\x42\x40\x8b\x0b\x06\xe8\xac\xdf\x41\x91\x39\x94\xdf\x87\xc3\x02\xe7\xe6\xc7\xb4\xe8\x79\x06\x5d\x00\xf5\x05\x48\xf1\x09\x07\x89\x03\x2d\x1c\xe0\x20\xdb\x62\xb6\xa8\x39\x0d\xd1\xf0\x4f\x1e\xf5\x19\x30\x0c\x75\x77\xa7\xac\x49\xe2\xc8\xf1\xa6\x02\x37\x4a\xa6\x78\x95\xc5\xab\x32\xaf\xf3\x5c\xca\x19\x56\x66\x3d\x6e\x56\x91\x56\x80\xab\xa4\xd0\x22\x23\x39\x93\xac\xd6\x76\x38\x78\x0a\xfb\xb6\x6d\x15\x0f\x14\x70\x41\x68\xf6\xd3\x13\xe8\x79\xe2\x91\x33\x82\xbb\x70\x51\x09\x0e\x25\xe4\xd0\x74\x5e\xaf\x91\xd8\x20\x7c\x83\xc2\x82\x5d\x9d\x59\x42\x38\x6a\x43\xd7\xac\x6e\xc4\x23\x07\x26\xcb\xc9\x87\x0b\xee\xfc\xbd\xf0\xca\xb4\x76\xac\xcb\x92\x50\xa1\x3e\x15\x96\x4f\x03\x7f\xa1\xa9\xa7\x04\x93\x93\xaf\x03\x89\x79\xb5\x55\x41\x74\x32\xd0\x5f\xb7\xe0\xfd\xee\xf1\xd1\xee\x03\x0b\xf2\x6e\x35\x33\x65\x2a\x83\x83\x31\xbb\x93\x93\x76\xf4\x15\xb0\xb4\xde\x28\x4b\x5f\x48\xb5\x76\x56\xcb\xca\x89\x33\x7d\x12\x07\x2c\xd5\xc6\x41\xb4\x43\xe0\x55\xc6\x8d\xd8\x82\x12\x94\x43\x75\x08\x99\xab\xc9\x74\x0e\xac\xf9\x69\xce\x2d\x5d\xb9\x60\xe6\x05\xce\xd6\xe9\xf9\x1b\xcc\x37\x84\x5d\x52\xe6\x0f\x0d\x21\x7a\x73\xb2\x4e\xfb\x96\x74\xa3\x04\x8a\x91\x26\xbe\xc5\xcc\x89\xcc\x84\x6b\x29\xbc\xce\x53\x4c\xa5\xcd\xf4\x9b\x0f\x84\xcc\xb9\xae\x79\x11\x37\x82\xaa\x24\xb4\xb0\xcf\xa5\x44\x4a\xae\x4e\x1f\xca\x64\xe5\xec\x22\x89\xd4\xf9\x7f\x39\x1c\xe9\x0a\xe6\x33\x31\x20\x49\xcd\x17\x97\x5a\x28\x5e\x28\x0d\x6c\x77\x36\x0d\x2f\xf5\x40\x8e\x59\x8a\x42\x8e\x5e\xde\xd8\xd9\x7d\xb0\x4f\x54\x7e\x39\x63\xbe\x63\xc2\xf2\x8e\x5d\xf9\x9a\x95\x7b\xe2\x29\xcb\xdd\x7d\xee\xb9\x44\x38\xed\x24\x13\x7b\x13\xfb\xf0\xde\x13\xc7\x79\x63\x96\x2c\x12\xca\xa4\x80\x7b\xf6\x74\x41\xba\x57\x33\x7a\x10\x48\x49\xba\xab\x6d\xc3\xf0\x44\xc6\x34\xdc\xa4\x55\x04\xfd\xda\x54\x33\x64\xa6\x0f\x49\xd2\x0e\x9d\xf3\x44\x92\x29\x0d\x12\x8c\xe0\x49\xdb\xac\x8d\x2e\x01\x64\xeb\x7e\xe9\x5b\x0c\x2d\xfb\x4b\x96\x5e\x32\x80\x5a\x63\x0c\x93\xda\x0a\xdd\x38\xfd\x83\x75\xbe\x2c\x59\xe9\xb4\x5e\x5c\xd9\x5f\xa6\xac\xd4\x81\xc1\x5f\xf8\x2b\xda\x17\x63\x4a\xa5\xda\x1c\x24\xa3\x5c\x32\x3a\x5a\x57\xe6\x0c\xd5\x62\xd4\x42\xa0\xed\x77\x3d\xd7\xda\x5b\x31\x27\x4e\x03\x9f\x59\x56\x7a\x34\x93\x1e\x3b\xb3\xfc\x28\x97\x66\x7a\x4e\xa7\xc4\x7f\xe0\x55\x81\xf3\x66\x28\x7f\x70\xd6\x99\xe0\x21\x78\xd7\x23\x83\x97\xe0\xb6\xcf\x4c\xa9\x3d\x23\x16\xc5\x8b\x54\xe5\x68\x6e\x05\xd3\x62\x8b\xe4\x61\xcb\xb3\x22\xd6\xc5\x2c\xcc\x54\xe2\x5c\x6f\xd4\x21\x82\xf0\x40\x40\x73\x4e\x25\xa6\xd6\x18\x7c\x0a\x95\xc7\xe7\x74\xe8\xe4\x58\x6a\xbb\x09\x6a\x1b\xb3\xd3\x09\xbf\x51\x6f\x35\xba\xfd\x8a\x9d\x1a\x98\xb9\xb3\xed\x6f\x8f\x65\x46\x03\x29\x19\x6f\x10\xf9\xf4\x81\x90\x20\xeb\x39\xcb\xb7\xcf\x3a\xe1\x68\x2a\x27\x63\x4a\xe5\xf5\xe5\xad\x8f\x98\xbc\x5b\xce\xd9\x7b\x12\xc8\x84\x06\x4e\x66\xa5\x6e\x7a\x99\x5d\x38\x46\x11\xbf\x2f\xea\xa7\x1b\x7c\x92\xba\x31\xca\x76\xed\x0c\xff\x67\x40\xd4\x4a\x3a\xb1\x59\xcc\xef\xd5\xb6\x4e\x75\xda\x3a\xa2\x64\xea\xe6\x68\x48\xac\xa2\xf0\xf6\x6f\x0a\xa1\xf8\xbf\xbb\x74\xbc\x4d\x90\xc6\x60\x84\x84\x52\xcc\x8d\xbf\x52\xf4\xf7\x69\xc1\x3a\x7c\x4e\xdb\x5f\x50\x22\xa0\xa2\xfd\x88\x42\x40\xb0\xb9\xb4\xc8\x20\x6d\x60\x61\x9e\xf5\x8b\xa2\x3a\x4d\xfd\x0b\x8b\xd0\x02\x12\x09\x63\x32\xcb\xc5\xa8\x3c\xc8\x15\xa6\xfd\xd8\x93\xb4\x96\x55\x08\x8f\x4f\x8d\x53\x02\x92\x5c\x9d\x81\x00\x25\x61\x5c\x41\x05\xba\x70\xe7\xf4\x0c\xe4\xf8\xea\x84\xaf\xf2\xb1\xbd\x65\xc6\x5c\xe6\xc8\x41\x92\xac\xa9\xa9\x9b\x2e\xcc\xb0\x7b\xa7\xd6\xeb\xac\x77\x86\xc7\xbf\x7e\x3c\x64\x58\x49\x68\xc1\xfd\x52\x4e\xbd\x67\x6b\x1a\x76\xe0\xe6\x6f\xdc\x7b\x6e\xa6\xd4\x9c\xa2\x7d\x8d\xd7\xee\x1e\x48\x7c\x65\xac\x69\x56\x95\x57\xa9\xa1\xd8\x1c\xc7\x3f\xa1\xcc\x1c\x23\xcd\x28\x4b\x3a\xb4\xb9\x07\x6d\x1d\x60\x11\xef\x26\xe6\x4c\xfe\x78\x5e\x46\xae\x92\x01\x2b\x27\xa5\xdd\x03\x99\xeb\x1e\xc6\xd8\x9c\x5a\xe6\x85\x89\xb2\x94\xc5\x8f\x1a\x1e\x31\x3f\x5e\xeb\x07\x45\x0e\x04\xa6\x28\xa0\xdd\x9d\x1e\xf8\x44\xe0\xa9\xc8\x75\xe4\x89\x16\xf2\x36\xaf\xe1\x54\xc2\x98\xef\xfb\x90\x13\xed\xc1\xa1\x4c\x53\x8e\xbb\x36\x4f\xb1\x61\x6d\xef\xda\x64\xeb\x07\xca\x99\x0e\x79\xc7\x32\xf8\xd0\xfa\x99\x7c\x92\x5e\xd8\x53\x12\xde\x4b\xf0\xa4\xbd\x7d\x2a\x8c\x32\x4c\x2f\xc5\x98\x04\x29\x19\xcf\x00\x68\x08\x7e\xf7\x9b\xc2\xf2\x5c\x31\xed\xc9\x20\x0d\x44\xb9\xcc\x85\x8c\xf7\xe8\x24\xa6\x18\xd5\x31\x93\x47\x2f\xce\x95\x6f\xa9\x80\x30\x03\x5e\x0c\xea\xdb\xfa\x87\xfb\x5f\x7c\x71\x2c\xc1\xad\x0c\x7c\xab\xfc\x60\xfe\xdc\xb7\x07\x06\x2a\x7a\xf0\x7c\x94\xa6\xc6\x27\xec\x75\x1c\x73\x76\x15\x83\x6a\x28\x1f\x71\xe0\xab\x52\xab\x89\x7a\x4c\x3e\xd1\xcd\x36\xff\x8e\xba\x99\xbf\x88\x09\xf8\x1c\x3b\x08\x73\x32\x83\x14\xc5\x8b\x60\xf8\xb1\x85\x57\x8b\x60\xfd\x54\x79\x50\xf7\x67\xa8\x01\x65\x65\x30\x16\x87\xf7\x0c\x11\xed\xf4\x30\x30\xea\x7d\x2f\xc7\x94\xbc\x8d\x3b\x68\x5b\x74\x47\xf9\x44\xbb\x35\xd6\x5e\x45\xbf\xc6\x23\xe3\x68\xf7\xc8\x8d\x3a\x66\x3f\x09\xfb\x05\x75\x33\x7a\x30\xef\xda\x8e\xef\x24\xea\x54\xa8\xa8\x9e\x5e\x54\xcf\x41\x68\x7a\x05\x12\x97\x09\x97\x78\x0a\xe8\x49\x7b\x0f\x81\xdd\x35\x1b\xa6\xe8\xce\xdd\xc0\x8c\x8b\xf8\x27\xe4\x72\xc2\xfc\x19\xa5\x4b\x0a\x80\x9b\x7a\x8e\x6f\x20\x6c\xd6\xa2\x3c\xba\x9e\xd5\x4e\x6c\xb2\x8c\x9d\x10\x66\xa8\xa7\x4d\x7f\x2a\xcc\x7e\xd0\x55\xca\x8f\x87\x57\xf3\xda\x5f\x9f\x04\x3f\x07\x96\x76\x1e\x3b\x28\x41\x80\x19\x85\xa8\xcd\xba\xda\x52\xc3\x5e\xff\x20\x33\xb7\x3d\x36\xd2\x36\x3d\x32\xe6\x6e\xeb\x7e\x7d\x63\xaf\xbd\x15\x07\x90\x4f\x37\x93\x58\x0c\x86\x95\xe0\x64\xba\xac\x01\x4a\x19\xd6\x7c\x8f\xde\x4c\x50\x9c\xde\x9d\x7e\x0f\xcd\x85\xa9\xfa\xf1\x38\x9a\x2b\x51\x44\xec\xf4\xe0\x5c\xaf\xd4\xe6\xd2\xad\x0b\xc3\xad\x53\xc3\x17\x5c\xa7\x3d\xf7\x55\xd9\x76\xcc\x0d\x4d\xe4\x85\x9a\x1e\x63\x22\x61\xfb\xab\x4b\x3b\xcf\x41\xae\x1c\x16\x3d\xd4\xa8\xc4\x9a\xa9\x94\xb9\xd6\x6b\x81\x01\x4a\x84\x4e\x80\x70\x9b\xe8\x4d\x25\x41\x52\x60\xd1\xd9\x88\x3b\xd8\xf9\x28\x13\xfb\xbd\x87\x35\xc3\x10\x57\x9a\xbd\xdb\x3d\xb5\x08\x8b\x86\x59\x20\x9d\x67\x2d\xe4\x5e\x08\x76\x34\x81\xd0\x58\x7f\xae\xd9\x89\xfa\x85\x4a\xd8\x40\xee\xd7\x3d\xf8\x63\xc7\x33\xc5\xea\xfc\xec\x7d\xca\x2a\x29\x12\x08\x75\x92\xd6\xca\xff\x62\x1b\xbc\x54\xb9\x13\x46\x9a\x1b\x27\xd3\x7c\xb9\x4e\x33\x97\xc1\xb9\xe6\x45\xdf\xde\x00\xb2\xce\x39\x89\xbb\xda\xaa\x29\x31\x90\xd0\x21\x12\x47\xdb\x1a\xbd\xf7\x6b\x38\x92\xad\x36\x94\x44\xef\x0a\x7e\x48\xaf\xb8\xbd\x47\x70\xc0\x04\x25\xa8\x46\x7a\x33\xee\x32\xc1\xc4\x4d\x1a\xdf\x4a\xa2\x61\x5a\xde\xd6\x3f\xab\x63\x8d\xe0\x6e\x30\x9e\x29\x3f\x8b\x68\xe1\x04\x4e\x17\x80\xc0\x75\x9e\xcf\x1f\x9a\x05\xb2\x1d\xfe\x0b\x6d\x33\x1f\x48\x8e\x7e\xb2\xc1\x1f\xdb\xca\x31\x72\x44\xfc\x27\xbd\xac\xd6\xd7\x31\xfb\x9e\xe0\xc7\xd5\x7f\x91\x4b\x72\x9d\x74\x9b\x73\x01\x4a\xd4\x4a\x0f\x73\xbe\xa3\xd9\xf6\xb3\xa6\x7f\xbe\xd6\xb8\x55\xd7\x05\xcc\xcf\xcd\xf5\x05\x10\x9e\x32\xb4\xf5\x14\x72\x5e\xa0\x2b\x68\x4e\x7a\x67\x96\xb1\x6c\x30\x27\x5c\x1c\x2f\x65\x91\xdb\x74\x58\xd4\x90\xd3\x76\x9d\x6c\x20\xc9\x6a\xe7\x63\x6d\x7d\x21\x51\xd6\x1d\xcf\xbc\x8e\xe3\x74\x23\xd4\xe6\x7a\x88\xb6\x23\x5d\x16\xdb\xd5\xda\x1f\xa1\x1f\xcf\x95\xd7\xde\x4f\x9c\xd1\xd7\x87\x6a\x45\xe1\x3a\x93\x23\x09\xf7\x36\x81\x6e\x3a\x3c\x91\x4e\xe7\x10\xcd\xd1\x75\xc7\x69\xb1\xa6\x8d\xe1\x18\xc9\x7b\x85\x7a\xde\x18\x0f\xb5\xd7\x31\xca\x9e\xa4\xea\xfe\xe3\xa3\xeb\x55\x56\xc9\xf2\x6c\xfd\x0c\x2b\xd1\x61\xc2\x4e\xf0\xc2\x57\xab\xe4\x8d\xc9\x68\xbb\xcb\x29\x4f\xa7\x32\x79\x6d\x45\x6c\xd9\xa4\xaf\x41\xd6\xd5\x37\x1f\xa4\xa5\xab\x59\x51\x70\xf0\x15\xf6\x06\xb1\x66\x42\xac\x8a\x3c\x38\x8a\x9f\x85\xbb\x3b\x02\xc6\x1f\x05\x8f\xe5\xf4\x96\xf8\x27\x67\x4b\x52\x35\x6e\x99\xf6\xcc\x06\xe6\xbd\x0b\xc1\x54\x40\x09\xae\x6e\xbc\x2a\xb6\x17\x83\x21\x3d\x16\x61\x35\x7f\x89\x9e\xac\xa2\xa1\x83\x88\xb0\x5a\x7e\x43\x57\x97\xd1\x50\x5e\x44\x58\x2d\x58\x66\xa7\x6a\xe8\xfc\x4e\x80\xc5\xb1\x10\xbd\x71\x34\xff\x4f\x12\x06\xc1\x49\x40\x15\xf9\xe8\x53\xd2\x12\xfa\xc0\xfb\x7d\xf2\x58\x68\x2f\xed\x3e\xdc\x2c\x62\x96\xe3\xe7\xf3\x38\x39\xb5\xc9\xf4\xee\x2d\x3a\x47\x7c\x05\x57\x05\x91\x92\x29\xdd\xde\x62\xdf\x1f\xfb\x41\xc7\xea\xf8\x35\x47\x93\xde\x3c\x2a\xd9\x95\xdb\xda\x3a\xc4\x9f\xa3\x06\x21\x14\x5d\x67\x6a\x7e\xab\x4f\x07\xdf\x26\xff\x8b\x55\x87\x4e\xeb\xa2\xb9\x38\xd7\xdb\x20\xae\xf8\x94\xe5\x87\x13\x67\xf1\x0c\x5d\x07\x2d\x57\x1a\x57\x7f\x28\x57\xec\x87\x4e\x49\xbc\x33\xba\xc3\x1a\x4e\xd2\xc6\x0e\x67\x72\xe3\x9e\x33\x7c\xb7\x92\x6d\x0d\xf2\x6d\x8d\xa0\x27\x3d\x5b\x6e\x94\xed\x9e\xac\x4d\x2c\x3f\xe6\x8c\x24\xb0\x08\xd1\x48\x44\xae\x93\x44\xb2\x2d\xae\xdb\x4f\x18\x3f\x35\x75\x08\x58\xad\x5d\xcb\x93\xec\x14\xd3\x33\xfa\x12\x1f\x37\xf9\x3e\xab\x17\x2a\xe6\x87\x77\x80\x01\x67\x3f\x9a\xa8\x95\x2a\x21\x92\xe9\xf8\xfa\x4a\x79\x54\xa2\x40\x0b\x55\xb3\x67\xce\xd3\x7a\xc5\xd1\x49\xf1\xba\x95\xcf\x5f\x17\xa4\x06\x85\x37\xd2\x26\xf2\x5c\x74\x8c\x10\x7f\xf0\x48\x2e\x1f\x59\xf1\x5a\xe6\x28\x34\x59\x27\xeb\x64\xc2\x0c\xd7\x54\x87\x0d\x91\x46\xb8\xd2\x73\xbc\x2d\xec\x71\x79\xba\x61\xad\x12\x37\x1b\xd3\x0d\x5b\x8d\x84\x36\x37\x4b\x26\xc3\x4a\x88\x2f\x24\xe0\xb1\x63\x2f\xc3\xd4\x78\x8c\x10\xf7\xbd\x5b\x17\xc4\x01\xa1\x80\xe1\xb6\x8f\x0e\x3b\x7f\xf7\xc4\xaa\xa2\x7a\x31\x1a\x46\x76\xf8\xa7\x5d\x47\x84\x27\xda\x8f\xea\x51\xaf\x42\x53\x4f\xc2\x03\xfb\x89\x0e\x95\xe5\xbb\xed\xe9\xfd\xd0\x86\x24\xd0\x01\x13\x79\x99\x28\xde\x13\xf0\x54\x53\x93\xfc\x2d\x18\x1e\x3b\x96\x68\xc5\xb1\x7a\xbe\xcc\x11\x54\x9a\xc8\x25\x44\xe1\xa3\xd7\x74\x73\x04\xa0\x88\x22\x89\x89\x3d\xea\x67\x77\x55\x12\x81\x75\x44\x3f\x62\xa1\x18\x24\x1a\x1e\x5a\x16\x72\xfc\x39\xe8\xf7\x47\xbc\xce\xeb\x3c\x99\x8c\x26\xfc\xc3\x91\x61\x3c\xc5\x76\x35\x9f\x93\x30\xd1\x5d\x19\x66\x25\x53\x17\xf2\x89\x08\x9e\x61\x1f\x7f\x6e\x2a\xf1\xd7\xeb\xd8\x8a\x9d\x9d\x1d\xb3\x6f\xd0\xbc\x62\xda\xce\xfd\x82\x38\x70\x4a\x39\x9f\xc1\x82\xd8\xe2\xa0\x9a\xc2\x27\x98\x2d\x73\xce\x40\x86\x72\xd0\xf0\xeb\x84\x85\xbc\xa9\x54\xb0\xba\xa5\x41\x58\x81\xa4\x06\x49\x0c\xd1\x5c\x38\x6d\x5d\x7b\x83\x4f\x66\x0b\x95\x60\x23\x1c\xca\xd6\x13\x58\xb3\x54\x5e\x66\xba\x19\x35\xf7\xd4\x27\x27\x1b\xd9\xec\xc4\xec\xd0\x18\x16\xf8\x57\xca\x32\xcf\xb7\x20\x76\xc5\x73\x45\xe2\x5c\x7f\x9e\xed\x88\x51\x18\x73\xb5\x9e\x28\x99\xcb\x90\x40\x41\xe8\x14\x6a\x52\x14\x1e\x2a\x5a\xe8\xfc\x19\xb0\xe5\x61\x91\x88\xcc\xb3\xe8\x1c\x53\x6c\x01\xd1\x96\xa2\x52\x8c\x5b\xcb\xdc\x9c\x64\xbc\x2a\x29\x9d\xc9\xa9\xbb\x9c\xc0\x0c\x50\xe4\xc2\xa2\xc4\xbd\x48\x74\x18\xa3\x6f\xfd\xbc\x35\x9c\xf4\x38\x89\xc9\x2e\x84\xc2\x5d\xc0\x68\xcb\x5c\x73\xe0\xd0\x86\xd8\x8b\xe1\x0b\xda\x03\x10\xe6\xd7\x3f\x18\xf5\x56\x73\xf1\xd8\xe8\x68\x2d\x55\x83\x27\x89\x23\x45\xf6\x67\xf2\x89\xba\x6d\x5d\xf4\xc4\x32\x4e\x6a\x57\x6c\x19\xf6\x72\x6d\xa9\x5a\xcd\xe3\x12\x97\xa3\xc3\xc3\x23\x32\xe7\xf6\x42\x45\x18\x37\x35\x5e\x5e\x87\xa4\x03\x61\x34\x07\xda\x04\xc5\x77\x55\xa9\xed\x4b\xcb\x27\x67\x3f\x67\x65\x93\x7f\xc8\xdf\x13\x32\x31\x33\xce\xe6\xe7\xb8\xcc\xc7\xb8\x9b\x6f\x60\xd4\xd7\x6c\x4b\x7a\x50\x36\x5e\x97\x20\x88\x24\xf7\x24\x39\x4e\x8a\x90\x14\x8b\x57\x76\x67\x32\xf9\x48\x02\xcf\x8f\x93\xaf\xe6\x43\x52\xef\xdf\x9c\x61\x37\x46\x0e\xa1\x2f\xe3\xb9\xf1\x33\xf1\x5c\x38\xad\xfb\xad\x46\x84\x5c\xb9\x2f\x7a\x0c\x50\xcc\xef\x2f\x3f\xfd\xbd\xec\x1e\xe8\x07\xee\xa7\xe9\xf5\x7b\x78\xd6\xe3\xd3\xbc\xf7\x5d\xaf\x0f\xb3\xbe\xbb\x00\xf9\x89\xeb\x17\x2f\xb4\x17\x5e\x39\xfa\x40\x37\x63\xa3\x7f\xde\xa5\x0e\x1a\x47\x1b\x3c\x48\x17\x6f\x7e\x97\x46\x8a\xf2\x21\xcc\x36\x94\x3a\x86\x6a\x99\x2a\x9a\xaf\x4e\x62\xda\x6c\x4e\x79\xba\x89\xd7\xc3\x43\xc4\x63\x47\xa1\xdc\x64\x32\x5b\x64\x37\x86\x57\x34\x5d\xd3\x0a\xd1\x35\xc0\x34\x69\xcd\x32\xa9\xa6\xc1\x2a\x1a\x80\xdd\x68\xd1\xef\xfb\x70\xb9\x1c\x2a\x82\x1d\x1e\x39\xdb\xce\xd6\xf9\x6d\x59\x6d\xd8\xb7\x8a\x1e\xb7\x6b\x68\x22\x12\xc9\x8b\xc5\x8a\xa3\x57\xde\x0b\x21\xf9\xa8\x41\xf0\x8a\x61\x6e\xfa\xd9\x4a\xae\x7c\xeb\x56\xd7\x4e\xb8\x63\x7c\x87\x75\xaa\xdb\x1f\xef\x6a\x2b\xad\x27\xfa\x1d\xd3\xd0\x19\x37\xb4\x18\x15\x8e\xc8\x14\x0b\xb8\xe4\xd2\x28\x27\x74\x63\x6e\x56\x84\xe3\x64\x13\xaa\x1b\x55\x63\x9e\x0c\x8c\xea\xf7\x29\x90\x49\xe2\x95\xb5\xc0\xe3\x1b\x38\x28\x29\xf5\x4b\xdf\x0f\x19\xce\x96\x39\xdb\x55\x27\xd7\x1c\x18\xb4\x8f\xd5\xba\xc1\x1a\x6a\x84\xe6\x3f\x56\xd7\xa4\x40\x42\x92\x1d\x4f\xcf\x45\xe0\x10\x47\x0d\x19\x2c\xe0\x63\x43\xa4\x22\x51\x5b\x62\xb8\x24\xdf\xf5\x15\x39\x19\x74\x64\xd2\x86\x89\x3d\x94\xe4\x58\xa6\x20\xe0\x64\x4c\x83\x90\xea\x17\x4d\xff\xe5\xe9\xcd\x8b\x08\xb2\x82\x68\xdd\xe9\xb3\x7e\x88\xc9\xf8\xca\x6c\xa3\x63\x8e\x2e\x14\xe6\xcf\xd0\xb6\x9c\x74\xe8\x71\xd5\x0c\x3f\x59\x27\x7b\x12\x27\xde\x88\xea\x41\xe4\x63\x53\xf1\xfd\x56\x81\x4d\x18\xf6\x25\xa9\x6b\x44\x98\x0d\xac\x7b\xc6\xa6\xed\x18\x58\xe4\x3d\xde\x3a\xeb\xc6\x2a\x7c\xa4\xcd\xbc\x65\x22\xee\xee\xd1\xda\xe6\xe5\x7e\xc0\xe4\x4f\x76\x09\x3b\xaf\x47\x5f\x52\x1a\xcf\x9e\xfd\xf4\x5c\xbc\xd4\xdc\x47\x91\x24\x34\x3c\x14\xab\x89\x69\x65\xc5\x66\x33\x7f\xbd\xd2\xc6\x50\x68\xb4\x48\xb6\xfb\x62\x30\xd2\xe8\x36\xc4\x8e\x55\xba\xbe\x92\x18\xb7\x73\xfb\xc1\xb2\xb4\x4c\xd3\xa8\x9f\x1a\x97\xa8\x51\x1e\xf3\x7c\x5f\x50\xe6\xd1\xca\xe7\xdc\x33\xc5\x30\x9e\x7f\x99\xb9\xcb\xf6\x1b\x44\x1e\xad\xe6\xe2\x43\xbe\xd3\x04\x48\xef\xa1\xa1\x1c\xa2\xe9\xc6\x2c\x7f\x41\x31\x5e\x27\xdf\x4d\x34\x8b\x92\x1b\x8b\xe8\xe4\x02\xdb\x5d\x25\xed\x45\x4a\x35\x33\xce\xe8\x95\x82\x0d\x2b\xcd\xaa\x42\x50\x1f\xc9\x5e\x24\x52\xba\xc6\x52\x0a\x44\x42\x2b\xc9\x4d\x2d\xed\xb2\x09\xb1\x73\x02\xda\xe0\x62\x8c\x52\x0c\x88\x56\x46\x65\x50\x05\x9f\x3b\x37\x8b\xba\x82\xae\x49\xf9\x13\xab\x6f\x97\xdb\x6d\xb5\xc2\x5e\xac\xd4\x4d\xa5\x8a\xfd\x8a\x6b\xdf\x0c\xc5\x2b\x2b\x5f\x9b\x95\xa2\xa0\xc0\x5b\x39\x4b\x9e\x92\x11\xc6\x12\xd8\x57\xa4\x83\x52\xba\x03\x76\x0b\x10\x7f\xdb\xa7\xad\x17\x14\x3f\x66\xc8\x71\x32\xca\x05\x73\xaa\xe1\x9e\x7d\xbf\x58\x04\xb9\x40\x79\x9a\x66\xab\xb3\xaa\xba\xc2\xc9\xda\x16\xc5\x48\xca\x2f\x3d\xf7\x98\x9b\x1b\xfb\xca\xd6\xaf\x8c\x41\x7e\x20\xfe\xac\x30\x06\xd5\xcc\x9c\x08\xf5\x19\x78\x72\x61\xa1\x20\x47\x44\xbf\x76\xab\x6c\xbf\x00\x51\xac\xae\xe9\x5a\x5c\x5c\x91\x44\x2c\x68\x95\x69\xbf\x4a\xe2\x14\x19\x5d\x26\x28\x41\x2f\x8d\x22\x46\x62\xdc\x17\x13\x80\x61\xd1\xc6\x9a\xbe\x08\x0d\x0c\x88\xe9\x6d\x32\xa3\x6c\x5d\x82\xe5\x89\x78\x24\xec\xfb\x92\xe8\x45\x35\x78\xcd\xc3\x90\x31\x78\xb5\x93\x7b\x99\x90\xd7\x05\x01\xb9\xe1\x41\x85\x31\x3e\x5e\x32\x9f\xe0\xe6\x5f\x96\xc6\xc2\x42\x65\x9a\x3b\x62\x96\xa2\x7e\xf3\xd6\x83\x29\xc7\xce\x8c\x32\xb3\x6a\x80\x8b\xd0\x20\x0e\x95\x72\xf1\x38\x5d\x27\x87\x37\xda\xf3\xb0\x0d\xf5\x8b\x89\xc9\x20\x62\x8c\x43\xdf\x68\xc7\xfa\x54\xe6\xc5\x64\x97\x87\xee\x98\xb5\x0c\xfd\x29\x04\xa6\x2b\x0b\x92\x89\xc5\x07\x6d\x44\x29\xb2\xf5\xd5\x2e\x35\x87\x31\xd1\x2d\x14\x00\xae\xfc\x1b\xce\x7c\x59\x79\xf5\xf1\x92\xe0\x2a\x12\x01\xb1\xba\x6f\x8d\xda\xa4\x1c\xf2\x4c\x13\x20\xa4\x06\xdf\xf2\x34\x41\xe5\xa5\xb9\x3d\x02\x0a\xc4\xf1\xf6\x54\x83\x98\xb8\x40\x7c\xcc\x58\x24\xa6\x15\x69\x1a\x6e\x2e\x4b\xdc\x49\x7c\xee\x52\x84\x02\xa0\xf7\x40\xdf\x50\x82\x86\xfe\xe6\x40\x85\x91\xdc\x50\x8f\xe3\xbd\x1c\x2a\xb1\x96\x1b\x8a\x61\xb2\x97\xc3\xf5\x04\xb6\x6b\x40\x0c\xce\xdb\x9f\x8c\x0f\x95\x7f\xaf\xa3\x94\x97\xed\x3d\x49\x9a\x84\x09\xe0\x3d\x9b\x6c\x17\x9b\xc1\x01\xbb\x8e\x5b\xbc\xa9\xbc\xd7\x92\x22\xc4\x68\xec\x58\x30\x8f\x51\xd2\x9c\x08\x66\x01\xa7\xfb\xcb\x92\xdc\xe2\xed\x8e\x96\xf7\x63\xdc\x1e\x3c\x1d\x23\x39\x60\x7c\x63\x4f\x7d\x24\x6f\x01\x3e\x65\xa9\x58\x3c\x8c\x60\x2c\xfa\x6f\xbe\x90\x11\xa9\x5f\xb1\xe8\x4b\x89\x33\x0b\xe7\x0c\x8c\x8d\x8e\x83\x15\x70\x96\x7b\x59\x12\xb1\x05\x87\x95\xe1\x1e\x41\x6e\x5b\xed\x19\x39\xab\x4d\xdb\x08\x0d\xa9\x54\x28\x21\x22\xbe\xa8\x06\x3f\x5a\xb0\x5d\x03\x83\x69\x05\x45\xc4\x6d\xb2\x0b\xc4\x9e\xc2\x3e\xd5\x27\x96\x86\x99\xe5\x7b\x47\xc8\x74\x9d\x1a\xaf\x20\xaa\xd7\x2a\x11\x7e\xa6\xfc\xeb\x9a\x79\xb9\x95\xeb\x60\x89\x27\xab\x41\xfb\x3f\xd9\x98\x23\x01\xfc\xd4\x29\x02\xb7\x10\x6f\xc6\x28\x24\xe2\xf5\xe3\xc8\x89\xdb\x95\x4c\x9f\x8d\xd4\xfc\x76\x59\x4f\x31\x6f\x1d\xbc\x9c\xf3\x5f\x3c\xec\x2f\xc7\x90\xb8\x01\x4d\xca\x28\xb9\x80\xb4\x14\x57\x7f\xe8\xaf\xe8\x97\x91\x51\x91\x27\x5e\xea\x1b\x23\x30\xfa\x4d\x7c\x97\x33\x7d\x78\x37\x74\x91\xc9\x3c\x88\xce\x61\xfe\xd6\x40\xbe\xcc\xbb\x00\xcb\x48\x9d\x6c\x8f\x31\xc7\x3e\x81\xc0\x1e\x9f\x26\x20\x2e\x13\xd4\x6d\xf3\x76\xa2\x9a\x21\x2a\xe0\xf4\x29\x24\xf3\x7a\x9f\xdc\x6d\x72\xc7\xd8\x74\xbd\x85\xb4\x15\x28\x88\x3a\x1e\xb0\xb7\x83\x47\x88\x1c\x47\x87\x62\x65\x56\xa6\x77\xa2\x69\x24\x43\xbe\x4f\x31\xf4\xf8\x10\x20\x90\xd0\xdb\x63\xe7\x5a\xdc\x5a\xec\x3c\x47\x63\x3c\x7a\xac\xfe\x40\xb1\x3a\x03\xab\x4a\x2d\xc0\xd5\xc4\xdf\x5f\x60\xe8\xa9\x03\x38\x80\xa1\x99\x7e\x0e\x80\xda\x86\x88\x0c\xe4\x4d\x16\x8a\x09\xa7\xa9\x03\xe8\x29\x0d\x75\x45\x8d\xb4\xb3\x91\x02\x73\x59\x31\xf2\x8d\x8c\x42\xb5\xa3\x37\x16\xd7\x34\x77\xdf\x30\xeb\x47\x97\xd3\x35\x89\xc1\x7a\x8d\xc2\x05\x41\x30\x1f\xef\x7c\xd0\xa0\x96\x9f\x5b\xa7\xe4\x40\x9c\xc4\x56\xf7\xcf\xdc\x9f\xec\xfd\x9f\x51\xcd\x16\x71\x5e\x40\x57\x01\x9c\x72\x2d\x8e\xfd\xd2\x55\x8c\x9e\x4f\xed\xb7\x03\xd9\xfe\xc5\x24\x39\x27\xe7\xc8\x49\x42\x6a\x66\x60\x35\x0d\x9b\x22\x14\xd1\xa6\x0e\x59\x78\xc8\xf8\x5a\xef\xf4\x20\x81\x55\xee\x4f\x2f\x26\x38\x33\xdf\xdc\x2c\xc8\x38\xce\x0e\x6b\xac\x32\xe2\xfa\x1e\x26\xa7\xbe\x20\x27\x99\x3f\x9a\x65\x45\x76\x87\x24\xce\x19\xd5\x4c\x60\x8f\x42\x10\x89\x25\xb6\x3d\xb3\x54\x87\xbd\x66\x74\x46\x35\xe5\xaf\xbe\x38\x91\x2e\xc5\xcf\x1b\xbf\x3c\x31\x3d\x3e\x8e\x30\xcb\x47\xc6\x20\x08\x37\x02\x01\x7a\x40\x4a\x79\x96\xaf\x7e\xc2\xe5\x70\x29\x67\x1f\xd4\x2c\x67\xed\xd9\x59\x1b\x4c\x2e\x24\xb9\x2c\x1f\xab\x05\xf7\x20\x97\xc6\x2d\xde\x3c\xa0\x7f\x6b\x17\xce\xf9\xd2\xf9\x7b\xce\x7f\x79\xfc\x63\x2a\x30\xae\x32\xc6\x2f\x71\x31\xa7\xb5\xce\xe1\xf2\xbb\xc1\xab\xa2\x93\x12\xbf\x67\xc2\x0f\xeb\xba\x16\x81\x83\xe0\xe4\x4b\x16\xbe\x95\xf1\x4d\x26\xc0\x52\x3c\xe8\x0e\xe5\xc7\x37\x78\x43\xe6\x9e\x79\x5b\x4d\xf4\x96\xca\x9b\x0d\x23\xcd\xba\xf9\x00\x8e\xa3\xe7\x44\x18\x79\x61\xb9\xfe\xa9\x33\x5c\xae\xa7\x77\x66\x9e\x77\x72\xc8\x11\x46\x3c\x47\x9a\x57\x3e\xd9\xc4\xb8\xbf\xb7\x4d\x13\xb3\x5d\x0b\x5c\xb3\xa8\x4e\xf8\xd8\x1e\xb0\x73\xb1\x57\xdd\x8d\x64\x9d\x3c\xd3\xa1\xfb\xd2\x00\x83\x57\xe5\x00\xbc\x9d\x08\xaa\x30\x36\x34\xdf\xfe\x74\x07\xd5\xc8\xb4\xef\xd0\x76\xf0\xc8\xbb\x30\x3e\xd4\xaf\x0c\xcc\x04\x88\xef\xd0\x3b\x20\x04\x08\xbd\x93\x29\x66\xaf\x23\xaf\x2a\x09\xa2\x32\x3c\x02\xfb\x0e\x68\xfd\xcd\x20\xf7\x1f\x7e\x27\x42\x18\xc2\x77\xac\x0b\x92\x0f\xba\x6d\xa2\x48\x2f\xe2\x19\x9c\xbd\xd3\xec\xb7\x03\x90\xaf\xe1\x77\x71\x4d\xb0\x1d\x0f\xf0\x14\xc9\xd8\xf6\x6f\xee\x67\x0c\x13\x10\x1b\x43\x29\xcc\xb5\x36\x37\xdb\x23\xe5\x88\x42\xc6\x53\x90\xf8\x3e\x5f\x2d\x15\x5b\xcd\xc4\x4c\x7c\x52\xbe\x52\xcf\xf1\x90\xcb\xd1\x6c\x14\x51\x83\x7d\xee\x1c\x5c\x54\xbe\x48\x29\x0a\x9f\x39\x46\x61\xb1\xbb\x22\x5e\xe0\x62\xa6\x41\x3a\x91\xdd\xb3\x51\x34\xb1\xbb\x27\x20\xca\x3d\xbd\x73\x4f\x09\x0f\xa1\x03\x10\xc3\xf1\x27\x83\x1b\x19\x40\x02\x2e\x9a\xe8\xd9\x59\x26\x38\x7a\x0a\x8a\x2c\x69\x37\x15\x1a\xb2\xb5\xa3\xea\xfd\x33\x79\xd8\xc1\x3b\x8d\x81\xeb\x55\x7d\x70\x2f\xdf\x49\x9f\x0c\x01\xeb\xff\x0b\x78\x56\xf9\x78\xd6\xde\x69\x6c\xf8\x46\xbd\x5a\xc5\xea\x66\x9b\xff\xcb\xf9\x68\x58\xda\x63\x87\x98\xd4\xec\x1e\x2e\x62\x0c\xe8\xea\x42\x2a\xac\x7c\x26\xbf\xe2\x8f\x7c\x67\xab\xb7\x65\x2f\xca\x6b\xc8\x75\xbb\xfe\x76\x5c\x5f\x48\x87\xb6\x9e\x9e\x62\x82\xa0\x0c\x07\xfa\x64\xd9\x70\xe1\x47\x9b\xbe\x2f\xeb\x41\x9a\x7d\xf3\xc0\x08\xe3\xac\xac\x27\xec\xf7\x78\xc8\x9c\xae\xd5\x8b\xe1\xb9\x3b\xd6\x45\xf0\xdd\xd8\xe9\x0a\xcb\x21\x57\xb8\xdc\xdf\xe8\x04\x07\x80\x6a\xcc\xcc\x7b\xaa\xed\x9c\xd9\x5a\x49\x24\xdf\x7a\xbe\x7b\x4f\xde\x14\x70\xaf\x1e\x3b\xe7\x78\xa6\x12\xb0\x3d\xd7\xba\x98\x71\xde\x7b\xfd\xd3\xf5\xa0\xf5\xc9\x35\xfa\x6c\x32\xb8\x33\x4f\x8e\x0c\xe5\x3d\x01\x19\xf9\x40\xed\x13\x6a\x86\x6a\x23\x0c\x13\xf8\x47\x59\xbf\x54\x93\x6e\xa1\x3e\xf9\x26\xde\xac\x0e\xaf\xcd\x23\x83\xcf\x43\x42\xcf\xa9\xff\x7a\x4c\x1e\x75\x79\xb5\xf9\xdd\x6c\x7f\x53\x1f\x02\xef\x61\xbd\x61\x97\xa5\xee\x30\xc7\x4c\x54\x76\x82\xc0\x33\x96\xe2\x2c\x8c\x32\x0a\xe5\x73\x64\x54\x01\x72\xe7\x55\x7d\x45\xdd\x03\x95\x9c\xdd\x6c\x00\x31\xe0\xb7\x7a\xa2\x60\x58\x0f\x61\x2a\x68\x7b\x1f\x9a\x71\x1a\x69\x75\x55\xe3\x5c\xde\x1a\x16\xaa\x22\x4c\xfe\xba\xd0\xb4\x40\xf9\x54\x95\xd6\x58\x00\x00\x40\xff\xbf\xd9\x52\x55\x87\xbe\x46\x03\x67\xf6\x5d\x73\xe5\xc4\xdd\x17\x45\xc1\xce\x14\xb3\x35\xab\x56\x30\xdf\xcb\x58\xac\xd2\x16\x2f\xc6\xef\x75\xeb\xb5\xc6\x6b\xba\x7a\x85\x9d\x42\xf5\xbc\x27\x07\xd9\x83\xc0\x4a\xba\x78\x19\x1b\xa2\xcc\xe7\xdf\x1c\x09\xe6\x49\x7a\xf3\xee\x01\x80\xd2\x37\xfa\x8a\x91\xf5\x8d\x92\xd2\x59\xfe\x86\xce\x95\xed\x31\x74\xb4\xbf\xb6\x79\xaf\x88\xb7\xce\x9a\x5f\x7d\x81\xa1\x7c\xb4\x78\x6d\xe3\x5b\x04\xc0\x78\x02\x4a\x7d\x7a\xfc\x6c\xf3\xc8\xfe\x44\x9b\xd7\x56\x97\xfb\x86\x72\xf3\xd7\x63\x73\x64\x73\x71\xba\x76\xe5\x5b\x91\xe3\xb7\x26\x11\x8e\x8e\x60\x9f\x6f\x55\xb6\x7f\xb8\xbe\x6c\xeb\x3f\x07\x3c\x1c\x6a\xdb\x43\xf4\x21\x09\x4f\x65\x12\x71\x42\x0e\x93\xb6\x3d\x99\x4a\xdc\x5c\x9c\x1e\x60\x9e\xc4\x4c\x72\xb1\xe5\xad\x88\xe1\x64\x31\x4d\x68\x1d\xf7\x6f\xab\x77\xd1\xd1\xb9\x4b\x69\x06\xea\xc4\xa3\xea\x64\x8a\x95\x2a\x3b\x5e\x18\xd2\x8b\xcb\x18\xbf\x24\xb5\xb5\x78\x48\xb1\xef\x18\xc7\x55\xb8\xb3\x55\x60\x5d\x47\xb5\x6b\x43\xad\xea\x86\x82\xe6\xec\xf7\xb3\x03\x06\x9a\xb1\xfd\x4f\x98\xed\x51\x53\x85\x43\x95\xe2\x77\x93\x6f\x8f\x16\x0b\x67\x7e\xe1\x1f\x79\x47\x38\x50\xef\x99\x7b\x7b\x48\xae\xbf\x2e\x24\xf5\xfb\x17\xdf\x15\x36\xc5\x21\x16\x11\x7d\x08\x1c\x64\x34\x2c\x71\x1f\x3e\xe4\x60\x16\x80\x04\x6c\x6c\xb5\x55\x4d\x42\x52\x93\xb9\x50\x65\x02\x86\x32\xe6\x41\x8d\x31\x52\x84\xb9\xe2\x48\xfc\x71\xbc\xe1\x6c\x08\x42\x90\x51\xbf\xa6\xa6\x24\xd2\x57\xa3\x25\x89\xc7\x62\xe2\xb7\x68\x42\x89\xb2\xf9\x0e\xc3\x9a\x56\x1c\x40\x28\x3f\xfc\x1d\x1d\xb6\x7f\x46\xf7\x08\x9e\x41\x98\x51\x7d\x3c\x47\x44\xf4\x32\x1c\xc2\x1a\x3a\xac\x0f\x65\x40\x90\x66\xd4\x24\x22\x03\x8d\x17\x38\xe2\xbd\xf7\xc8\x8d\x46\xfa\x97\xa6\x99\x66\xf3\xeb\xb7\x35\x60\xbc\xea\x7b\xa9\x15\xc0\x82\x0c\x4b\xf4\xf5\x75\x76\xdc\x5c\xa6\xcf\x58\xe7\xb5\x2b\x98\x9f\xf2\x0c\x76\x08\x6a\x13\x85\xe0\xb6\x02\x5e\x34\x3d\xde\xcf\x30\x33\x4f\x93\x83\x28\xe0\xe9\xfa\xbe\xda\x30\x2d\x49\x87\x8d\x66\x4b\xd1\xf5\x52\xa0\x11\xc8\xc7\x6f\xb0\x9b\x82\x4f\xa8\xbc\xcd\x69\xe3\x32\x13\x06\xc2\x29\xd8\x86\x07\x14\xb3\x47\xf2\xc7\x9e\x0a\x58\x3c\xd1\x12\xc7\x98\x65\xc7\x6c\xe7\xea\x1a\x6d\xa3\xc5\x53\xcd\x5c\xa0\xe7\xf6\x87\x50\xcc\xdc\x21\x21\xfa\x6f\x78\xee\x24\xc3\x2b\x0c\x17\x89\x08\x83\x04\x3e\x64\x6c\xed\xc5\xe0\x2b\x8c\xe7\x9d\x62\x8a\x9b\x10\xe1\x4e\x49\x4d\x03\x16\xc3\x64\x54\x22\x2b\x18\x0e\x82\xc6\x8c\xb9\xb0\x18\x6f\x30\xed\xc5\x60\xc4\x18\x38\x39\xc1\xfe\xd7\xcf\xfc\x5c\x7c\x35\x20\xde\xa3\xf4\xbb\xd8\xa6\x28\xc7\xfa\x93\xa0\x8b\x92\xd8\x79\x0b\xf1\x6a\xa5\x71\x94\x19\x6d\x28\xb2\xec\xf7\x80\xe6\xd3\x3c\x5c\x47\x91\x09\x15\xde\x32\xd7\x07\xe9\xf1\x64\x54\x9e\x18\xf3\x50\x9c\x97\x30\xaf\xf4\xe8\x24\x88\xa7\xb6\x6e\xcf\xe5\x1f\x40\xa1\x0a\x02\xc4\x92\x21\x01\xd7\x58\x0c\xbf\xe3\xba\x95\x9f\x96\x96\x1c\x8d\xd3\x4e\xe9\x83\xc6\x19\x6b\xd5\xb3\xad\x78\x69\x6b\x69\x90\xf6\xde\xf3\x9c\x7f\xdd\x9d\xcd\xa8\xd1\x9b\x22\x30\x3f\xce\x5e\x32\xe5\xb6\x58\x46\xe7\x8d\x2c\x7b\x73\xc0\xe6\x72\x5f\x65\x10\x40\x56\xae\xfa\x15\x92\xc1\xf1\x92\x79\x9f\x67\x88\x92\x14\xfe\x1a\x13\x0c\xce\x4e\xca\x5f\xe7\x69\xf4\x08\x8e\x97\xfb\x77\x02\x71\xbd\x3b\x58\xda\xc8\x1c\x45\x44\x83\xa0\x5c\xa1\xad\x62\x31\x1a\x1e\x47\xa3\x92\x28\xb6\xa4\x10\x8d\x8a\x52\x73\xd7\xc0\x92\xaa\x54\xc5\xcb\xdd\xf4\x3c\x1b\x5c\xda\x89\x51\xfe\xf9\x91\x02\x32\x74\x54\x09\x83\x3b\x97\x9f\x0b\x60\x92\xd5\xdc\x5b\x1b\x07\xd9\x2c\xb0\xea\x41\x6b\xbe\xa3\x4b\xa3\xea\x62\x44\x6c\x23\xe3\x62\x38\xcd\x2c\x5d\x99\x69\x5c\xac\x9b\xb1\xfe\x7c\x6b\x43\x89\xd9\xe5\xd0\x78\x4c\x71\x7e\x72\x16\xdd\x0a\xd4\xce\x86\x3e\x7c\x8b\x7a\xcc\x8c\xbb\x0f\x42\x8a\xdc\xc3\xc9\x61\x9f\xe8\x62\xc4\xf7\x3f\x61\xdf\x10\xf0\x80\x87\x61\x0e\x67\x33\xbc\x30\xa0\xe8\x0e\xd2\xe3\x28\x09\x6a\xea\xdc\x22\x46\xb5\x41\x2a\xed\x7b\xdf\xa3\xcb\x64\xb4\x5d\xc5\x99\x2b\x58\x48\xe6\x94\x7a\xc0\x73\xff\xd9\xd6\xf7\x0b\xe5\x0b\x5a\xa9\x02\x53\xe9\xe2\x4c\x1d\x0f\xe0\x0e\x75\x3a\xa7\x99\xcb\x85\xe1\x29\xd2\xd2\xb2\xc0\xdd\x6e\xb8\x4a\x1c\x8e\x45\x42\x0f\x6e\x53\xbe\xf6\xec\x0f\xb4\x3e\xc4\xa6\xf1\x02\x13\x93\xfa\xc2\xcd\x09\x6d\xfd\x68\x2c\xf2\x52\xcd\xfb\xe7\xdd\xd2\x54\x8a\x7e\x7d\xe9\x39\x2c\x09\x90\x2f\x82\xa5\xa7\xbe\xe2\xfb\xb5\xaf\x2e\xee\x84\x02\xe1\xfd\xaa\x48\x80\x7e\x85\x21\xc5\xe0\x85\xcb\x60\xd2\xd7\x02\x45\xf9\xbb\x0f\xbc\x18\x78\x19\xfb\x14\xf8\x14\x4f\xf9\xdb\x96\x20\xdb\x1b\x6d\x04\x77\x01\x49\xb0\x6c\xea\xa7\xb4\xd1\x91\x55\x7a\x9d\x7a\xf6\x6b\x2a\xbd\x2a\x7c\x6d\xe5\x99\xca\x02\x2a\x0b\x2e\x3f\xfd\xf5\xf7\x7e\xe5\xfc\xbe\x0d\xc8\xe5\x63\xeb\xf8\xb9\xc0\x02\x68\x70\xd7\xd3\x3f\x65\xcd\x59\x97\x5d\xb9\x2a\x48\x7c\xcc\x9b\x31\xcf\xf4\x91\xf9\xc8\x65\x3f\xa9\x56\x3b\x09\xd8\xa7\x09\x0e\x32\x11\x9a\x50\x51\x56\x88\xbc\x92\x6c\x57\x36\x6d\x1c\x35\x4f\x11\xa4\x33\x1b\x27\x03\xdb\x5e\xfd\xa2\xab\x1c\x78\x13\x12\xe0\x2c\xa8\xd2\xb9\x1b\xb3\x61\x29\x54\xec\x99\xf3\xa5\x65\x55\xfb\xae\x73\x31\x30\xab\xdb\xd9\x16\x84\x66\x74\x39\x17\x13\x80\xfc\x80\xc3\xfe\x1c\xfc\x54\xbb\xae\x7b\xd2\x21\xb0\x8a\x4c\xc0\xa7\xd1\x40\xef\x4f\x4c\x8e\x97\xd5\x74\xc7\xbd\x21\xc9\x0e\xfa\xb9\x5e\xe3\x4c\x21\x74\xad\xe6\x69\x20\xf6\xa4\x96\x5e\xb8\xf9\x3a\x43\x12\xf8\xcc\x52\xee\xd6\x09\x82\xbd\x99\xf0\x4b\x9c\xfd\x0d\x12\x3f\x32\x54\xc9\xea\x59\x78\xff\xdb\xa9\x46\x71\x23\x1d\x30\x85\x8a\xb0\x0a\x3c\xf2\xbd\x16\xaf\x68\xd1\xad\xce\xfa\x9a\xf5\xc3\x29\x99\x06\xf5\xae\x1b\x6b\x65\x73\xb9\x61\xbd\x54\x93\x6c\xd5\xf1\x0d\x78\x83\xb5\xaa\xc9\xff\x01\x39\xb4\xf1\xbd\xd2\x64\x8f\xc9\x25\x2b\xfe\xb3\x62\x38\x58\xfd\x5a\xca\x20\xeb\xc8\x3b\x67\x9d\x03\x76\x38\x0c\x6e\x17\x37\x93\xcf\xbb\xd4\xd8\x61\x93\x80\x26\xbd\x5e\x1c\x8a\xc1\xd4\x6f\x9c\x62\x7b\x77\x09\x4f\x4f\xe1\x03\xfb\x15\x37\xbf\x6a\xcf\xaf\xb7\xd8\xb2\xce\x9e\xc0\x05\xc3\x2c\xe9\x7e\xa2\xf3\x57\x59\x16\xbe\xf0\xd8\xbb\x71\xc3\x8e\x7a\x9d\x1b\xb0\x8e\xb3\x56\x6f\xce\xbb\xe9\x67\xc6\x27\x35\xc2\x8d\xf7\x28\xab\xea\x22\xd5\xa5\x0c\xc3\x0a\xfe\x41\x96\xd3\x83\x06\x5b\x9d\x3a\x94\xd3\x50\xbf\xf1\x7c\xb9\xd3\x92\x2b\x3e\xa4\xf2\x23\xd1\x06\x32\x3f\x24\x4d\x6e\x64\xbd\x75\xea\xc0\xa8\x65\xd1\x53\x9f\x4a\x25\x9f\x8c\xad\xfe\x12\x65\xd8\x9e\x7e\x9d\xfd\x55\x9f\x71\x97\xd5\xf1\x18\x9a\x0a\xbc\xde\xb3\xd9\xd2\x88\x7a\xd9\x05\x52\x6e\xe0\xd0\xbf\x2c\x37\x84\x05\x8b\xcb\xb1\xe8\xf7\x12\xb5\xf7\xd1\xc5\xc5\x3e\x60\x17\xc5\x15\x06\x0a\xcd\x2f\xeb\x75\x46\x12\x67\x87\x87\x13\x4f\x67\x29\x50\xe7\x95\x4a\xf4\x85\x5c\x29\x58\x1b\xbf\x04\x6b\x20\x56\x46\x22\xf1\xe8\x03\x5c\x74\xf6\xd7\xd8\xca\x72\xd2\x02\x23\xf2\xd8\x77\x45\x5d\xb3\x73\x1a\xac\x3a\x59\xa0\x23\x6e\x87\x9a\x38\xc1\x80\x0b\x4c\x6d\x22\x36\x44\x1b\x8b\xda\x0a\x8e\x1c\x56\x00\x1b\xc4\xa1\xae\x48\x60\x51\x20\xe0\xaf\xa2\xaa\xe0\xa8\xd2\xaf\xee\xad\x51\x17\x6b\x47\x0c\xd3\xff\x5d\x01\xf2\x3c\x32\x92\x4e\x88\x3f\x9d\x91\xa4\xe0\x55\x0d\xe7\xd0\x26\xe4\x19\xf2\x7c\x86\x61\x95\xb9\xbd\x02\x5f\x47\xdc\x8f\xb1\x7d\x9b\x64\x69\x9f\x21\x90\x3a\x60\xc8\xbe\x05\xe5\x85\xd1\xc1\x1b\xa1\xf8\xf5\x5b\x04\xed\x5c\x2c\x59\xa9\xc4\x5d\x4a\xb3\xba\xfe\x19\xe9\xcf\xb9\xdf\x90\x88\xac\xc4\xc3\xac\x7e\xbb\xb6\x97\x4f\x10\x11\x93\x9e\x1c\xde\x41\x25\x3e\x9d\x0b\xb6\xf1\x99\x04\x5d\xd5\xe4\x13\x32\x50\x99\x6c\x35\x70\xb8\xe0\x4f\x93\xc3\xd1\x90\x08\xf6\x81\x5b\xca\x80\x34\x4f\x40\x9f\xc2\xa1\x11\x2c\x00\xc7\x00\xd2\xac\x8a\x87\x83\x2d\x83\x2c\x19\x99\x34\xbd\x1d\xec\x58\x37\x9f\x2d\x23\x3f\x90\x33\x92\xb8\x04\x7f\x7b\x1e\x1f\x8b\xfd\xa9\x16\x4d\xce\x87\xdf\x43\xbf\x8d\x31\xce\x38\xa3\x15\x61\xbd\xaf\x1e\x59\x29\xb3\x4d\xbf\x22\x6b\xea\x13\xad\x61\xe6\x5f\x3d\x34\xa7\x4a\x71\x4d\x85\xe5\x3f\xa2\xcc\x6e\x68\x36\x8e\x6b\x8a\x1d\xc9\x9c\x98\x10\x9d\x50\xff\x1a\x20\x10\x09\x9a\x32\xa0\x3b\x89\x33\x0c\xb3\x67\x82\x34\x01\x1e\xd5\x8d\x5a\xd0\xa6\xd3\xa9\xa7\x47\x5a\xec\x6b\x28\x6d\x8d\x0c\x70\xb6\x76\xab\xeb\xa6\x0c\x72\x69\x5a\x11\x46\xcd\x7d\x8a\xb8\x8b\x69\x3a\xc9\x2f\xeb\xfb\x9a\x10\x1d\x8c\x63\x7a\x50\x9f\xc5\x75\x56\xc5\x51\x39\x45\x8d\xd2\x26\x27\xcc\x2f\xec\x0b\x87\x91\x76\xe5\x9c\xf2\xad\xf9\x04\x3c\x80\x32\x86\xdf\xf4\xdb\x8a\xde\xf6\x8c\x16\x85\xe9\x59\x51\x29\x82\x6a\x2e\x1a\xcd\xf8\x48\x4e\xac\xfb\xa2\xda\x17\x31\x31\x99\x73\xcd\xd5\xca\x97\xad\xe9\x92\xe7\xd8\x8b\xe0\x7b\xe6\x0d\x9d\xa5\x27\x7c\xad\x6b\x83\xaa\x6c\x54\xab\x25\xef\x31\xf2\xea\xaa\x8b\x1d\x43\xa5\xcf\xdd\x67\xf6\x51\x55\x4a\x5b\xee\x27\xf2\xc4\x55\xfa\xd8\x94\xfb\xcc\x9d\x97\xd6\xb6\x7b\xbf\x38\x31\xe9\x20\x1f\x8a\x8d\x72\xa5\x6e\x9a\xef\xe2\x9a\xd2\xb9\x85\x12\xcd\x7d\x1d\xba\xce\x0a\x05\x3a\x13\x11\x00\x2c\xc4\xd0\xb9\xdc\xf7\x36\x1a\x58\x37\xa4\x9f\xae\xef\xac\x66\xac\xc1\x1a\x65\x9b\x27\x05\x0d\x07\x4e\x4d\x19\xa1\x15\x32\x70\x7c\x82\x34\xd9\xf4\x70\x36\x05\x90\xb6\x02\x56\x6e\xeb\x93\x81\x70\x26\x53\x3d\xc8\x5b\x2d\x20\xdf\x9e\xf1\xe0\xbf\x7e\x9d\x4e\x6a\xc6\x49\x9e\xb0\x9c\x59\xf5\x2f\x63\x60\x59\x41\x71\x36\x9a\x2d\xfd\x8b\x59\xae\x33\x30\x23\x56\x7e\x1a\x68\x07\x73\x86\xfe\x45\x50\x54\x3b\xa1\x75\x1d\x97\xf0\x62\x36\xd6\xf8\x86\x57\x44\x23\xc5\x07\x4e\x31\x6f\x3e\xc1\x19\xea\x29\xce\x98\xa9\xff\x43\x1b\x78\x34\x8c\x24\xb5\x2f\x6a\x08\x6c\x31\xf7\x0a\x79\x97\x2e\xd8\x2f\x9b\xad\xf2\x2c\x97\xee\xf2\x8d\x52\x72\xd7\xf9\xe3\x96\xd0\xf7\x5b\x59\x45\x2a\x47\x10\xd0\x95\xe2\x4b\x6d\x2f\xfd\x7c\x37\xfd\xc7\xee\xfc\x0b\xef\xfc\xdf\x53\x49\xb8\xea\x82\x53\xc6\x97\xb8\x71\xa6\x46\xd5\xd7\xe3\x8d\xb9\xf8\x8c\xa8\x36\xfd\xcc\x15\x05\x3a\x05\x63\xe6\xfa\x56\x73\x07\xc2\x0b\x40\xd8\xea\x77\x9a\x80\x2b\xda\x6b\xff\x31\x81\xc4\x63\xcd\x1c\xcf\xf5\x61\xc3\xad\xe2\xe9\xc9\xfe\xa4\xe1\x77\x1e\x30\x0b\x3a\x59\x35\xcd\x51\xb4\x22\x0a\xc0\x8a\xea\x9f\x2b\x16\x67\x22\x12\x25\x2a\x1e\xa3\x32\x1a\x01\xe9\x74\xcb\xf5\x9a\x60\x8d\x47\xa5\x90\xdd\xb4\xa5\x0d\xc0\x66\x3a\x68\x4e\x33\xec\x16\x33\xc6\x16\x5e\x05\x86\x7e\x3c\x50\x10\x03\x4d\xfa\xbf\x5a\x00\xcb\x04\x2a\x77\x82\xf9\xc6\xcf\xd6\xd2\x90\xf2\x49\x30\xa0\x16\x70\x21\x22\x60\x81\x50\x53\xe6\x02\x0b\x4c\xe8\x03\x15\x36\x0b\x0a\x36\xac\x4f\xdc\xd4\x13\x7b\x03\x26\xb8\xbc\xad\x60\x28\x89\x02\xdb\x85\x92\x13\x05\xbf\xb9\x4d\x71\x0b\xb4\x61\x50\xc8\x06\xcc\xd8\xd9\x3d\x50\x9b\xeb\x5a\x5f\x5d\xa3\xde\x70\x76\xf5\x57\x91\x7f\x7b\x6d\xaf\x68\x3a\x0d\xf5\x55\x0c\x75\x06\x2c\x0a\x41\xe9\x87\x6a\x39\xf4\x5e\xf7\xab\x2a\xef\xa5\xd5\x04\x37\x23\xed\xc0\x43\xaf\x66\xa5\x05\x9c\x5d\xb7\x11\x8c\x10\x14\x67\x72\x8b\x7b\x4e\x59\xbc\xb2\xb4\x20\x35\xac\x8f\x14\xc4\x1e\x24\xa0\x4f\x80\x08\x65\xfe\x0d\x47\x6e\xc5\xc6\x73\x98\xe1\x24\x8a\x8c\x5c\x06\xef\x69\xfb\x60\xe3\x44\xd6\xd8\xd9\xd1\xed\x3f\xb4\xdf\xbe\x05\x3b\xf2\x00\xea\xe8\x77\xdc\xcc\xeb\x35\x55\x82\x78\x6a\x7e\xee\xb4\xcc\xa6\xd6\xdc\xb5\x86\xaa\xa7\xf4\xd6\x9d\x9f\x3e\x87\x79\xd3\xa9\xdf\xf6\xe0\x29\x1c\xd2\x6f\x29\x6c\x2a\xde\xee\x91\x48\xf0\x2d\x1d\x96\x3b\xfb\xc8\xf4\x03\x03\x2b\xd9\x7c\x91\x18\xd2\x2b\x5b\xa5\x8a\x2d\xd9\xd8\x15\x5a\x47\xae\x13\x58\xf9\x66\x7e\x3c\x46\x89\x86\xc4\x5f\xce\xf4\xcc\x9d\xe1\x1c\xf7\xfd\x8e\x7f\x72\x1d\xbd\x66\x5e\x05\x10\x52\xcc\x05\xbe\x0d\xdf\x82\x8b\x34\x2f\x29\x2b\x8e\xd8\x31\x4c\x61\x31\x50\x15\x45\x76\x7e\x1a\x92\x3a\x2b\x4c\x3e\x8e\x12\x4d\xc6\x65\x95\x62\x37\x0f\x35\xa4\xb7\xd3\x5b\x09\xde\x48\x6f\x16\x7d\x70\x10\x03\x69\x38\x7f\xf1\x3b\x1d\x60\x7f\x94\x24\x90\x37\xbd\x98\x7e\xef\x59\x77\xa2\x34\xf7\xe5\x52\x79\x70\x06\x4a\x92\x73\x88\xa2\xaa\x03\x82\xbd\xe0\xc1\x87\x86\x02\x7d\xd8\x21\x2a\x59\x66\xd7\x7e\x91\xb0\xf1\xb0\xea\xa6\x57\xf9\x81\x5d\xb4\x54\x4b\x56\x18\xe0\x30\x46\x79\xf9\xda\x6c\x83\x1b\x89\x24\x22\x99\xcf\x5c\xd6\xf9\xc2\x41\x1a\xbb\x83\x45\x3f\xfe\xa2\xd4\x04\x57\x0d\x2c\xdd\x5b\x62\xf2\x12\x1e\x30\x71\xf9\xe6\x10\xd3\x2e\xfb\x7c\x97\xcc\x78\xb5\x5a\x1e\x8d\x2f\xca\xcb\x81\x04\xc1\x95\xff\x5d\x92\xf0\xd5\x50\x2a\x34\x1a\x03\x94\x24\x2a\x28\x93\x94\xc1\x89\x08\x19\x52\x37\xd1\x01\xb4\x4c\xa0\x26\xbe\xa2\xe0\x12\xe5\x60\x67\x6f\x10\x54\xdc\x91\x2e\x19\xa2\x24\x9c\x56\xcc\x87\x89\x68\x16\xb5\x55\xee\x4c\xf0\x48\x6e\xa8\x65\xbe\xfa\x69\x5f\xad\x22\x81\x93\xd8\x03\x6f\xdf\x81\x00\xfd\x16\xb7\x65\x2a\x6d\x62\xee\x9d\xe4\x44\x32\x9a\xa3\x96\x75\x7b\xf4\xf4\x1e\xdd\xb9\xd1\x88\x0d\xdf\xb6\x5c\x1b\x9f\xa8\x89\xef\xd8\xbf\xe8\xa9\xec\x84\xd9\xed\x5a\xa7\x44\xc7\xdc\x9a\xc6\xf4\x0a\x76\xe8\x7a\xfe\x0e\x31\x55\x6c\x87\x10\xe0\x52\x6c\x2d\x77\x6b\x32\x56\xf9\x78\xd9\xd5\x91\x3b\x9d\xd8\x80\x34\xfd\x30\x30\x85\x3d\xd4\x91\x78\x8f\x7e\xde\xbd\xda\xab\x03\x03\xd1\xd7\x0c\x6f\x32\x02\x52\xdb\x6d\x7f\xd4\x94\xb8\xd7\x3d\x7f\xde\xf4\x5f\x7f\x9d\xd1\x72\xd7\x1f\xfb\x96\x5a\x26\x96\xd7\x9f\x2f\x7f\x1b\xdf\xb8\xa7\x9d\xaf\xa1\xab\x28\xe7\xcd\x5b\xcd\xe1\x43\x7b\xe8\x25\x62\x5b\x66\x03\x85\x2e\xe1\xcc\x3c\x4e\x63\x30\x47\x32\xb8\xda\xbc\x6a\xab\xf7\x7e\x48\x92\xe5\x69\x44\x50\x9c\xc2\x63\x65\xde\x7f\x7c\x3a\x50\xdc\x37\x69\xc5\x2f\x71\x18\x97\xd5\xd7\x2d\xda\x8f\xa7\x1b\xcd\x7f\xfa\x5c\xec\x62\xd1\x37\x52\xf4\x3e\xaf\x5c\x6c\x24\x7d\xed\x56\x11\xb5\xf8\x82\xcb\xf7\xda\x86\x1f\x55\xf6\x9f\xc8\x1d\x2a\x42\x33\xfd\x6c\x94\x0e\x14\x52\x50\x66\xeb\x09\xd1\x64\x03\xaf\x27\x0e\xbe\xfa\xcd\x3c\x6a\xc6\xc1\x0e\x14\x45\xad\xec\xc2\xcb\x1f\x78\xfc\x0b\xf7\xb3\x7d\xc4\x36\x66\xad\x73\xd0\x17\x28\xc4\xb0\x53\xc8\xcb\x1b\xee\x65\x7e\x01\x34\x9e\x04\x55\xd8\xe0\xe8\x29\x11\xd3\x43\x31\xe5\x69\x8b\x73\x25\x43\xf5\xac\x72\xa3\x1a\x48\x22\xf7\x33\xd8\xe6\x0e\xda\xd8\x83\x1e\x29\x09\x94\x8b\x4c\x5b\xd8\xe8\xd3\xa9\x29\xcc\x6d\x6a\x0c\x14\xa5\x01\xe6\x03\x55\xed\x86\x1b\x03\xdb\xd9\x9c\x22\xfc\xfe\xc5\xd9\x49\x89\xa7\x52\x0b\xf0\xb7\xc6\x36\xcd\x57\x33\xae\x96\x6e\x50\xa5\xd7\xd1\x48\x8d\x87\xb5\xd5\xdf\x9b\x35\x51\x37\x73\x5c\xea\x40\xbf\x8e\x13\x53\x77\x95\xaf\xae\x52\x68\x14\xc6\x84\xf8\x65\x71\xea\xdc\x8d\x47\x30\x3f\xde\xbd\x7e\xfc\xd8\x91\x5a\x1b\x3e\xd5\x0e\xde\xd6\x02\x47\x4c\xee\xee\xe5\xdb\xd1\xc5\x63\x01\x5b\xc3\x64\xfd\x4e\x0a\x8d\x25\x43\x39\x8b\x58\xa5\x3c\xfa\x51\xed\xed\x5e\x69\xf9\xbb\xda\xef\x8b\x70\x2c\x55\x20\xc8\x91\x14\x17\x0b\x1f\x54\xc3\x89\xf6\x7e\x91\xed\x55\xae\x32\x17\x28\x27\x77\x7c\xd6\x2f\x9a\xab\x42\x33\x14\x00\xc2\xea\xb1\xd7\xe8\xe7\x4a\x08\x2c\xbb\x74\x0a\xea\x1e\xdc\xf1\xac\x57\x67\x4c\x4e\x24\xf2\x20\x5b\xc8\x56\xe3\xfc\x0e\x7c\xde\xbe\x99\x76\xc0\x68\x30\x58\x9d\x58\xfe\x0c\xe9\xec\x9a\xcf\xd0\x3c\xdb\x6a\x8e\x68\xe7\xf9\x9c\xb6\x19\x89\x6a\x30\xd0\xce\x7b\x72\x4c\x4e\x6d\xb3\xad\xe6\x5b\x5b\x4c\x1e\xf6\x33\x53\xb1\x24\x59\x08\x83\x11\xf7\xa5\xf1\xca\x88\x13\x7e\x0d\xdf\x87\xa5\x7f\x92\x91\x4b\x9e\xb0\xba\xad\xf1\x18\xdd\x21\xd5\x51\x45\x28\xd8\x8b\x9a\x93\x8b\xc3\xd9\x50\x3a\x26\x7f\x97\xf9\x7b\xaf\xc6\xbc\xd3\xac\x34\x73\xc5\x93\x89\x85\x57\x4c\x33\x41\x8c\x36\x85\x52\x0d\x11\x69\x76\x2d\x15\x37\x05\x53\x10\x3a\x9f\x4c\xb1\x33\xad\xb0\x65\x06\x9a\xf1\xee\xb9\x3d\x5e\xaa\x8b\x89\xaf\x19\xa2\xc5\xa6\x34\xcb\xb3\xbf\x34\x06\xc2\x4f\x43\xdf\xe9\x52\x7e\xdc\x90\x8c\x85\x4e\x4b\x30\x2b\x63\x24\x26\x33\x96\x4d\xb1\xfc\xd6\xe9\x75\x3c\x3a\xa5\x22\x15\x5a\x93\x94\xe8\x00\x2c\x9d\x8a\xc7\x6e\x32\x4e\x96\xc6\xd4\xce\x45\x47\x96\x10\xeb\xd1\x25\x57\xd5\xa9\x21\x60\x10\xdd\x03\x34\xd9\x89\xc2\x87\xfa\x1b\x0f\xba\x5f\xda\xce\x1c\x60\xd5\xea\x80\x7d\xb4\x2e\xf1\x4b\x71\xdf\xf4\xc5\x7e\x9b\x4a\xc7\x6b\xa6\xa7\x74\xb9\xca\x6b\xcd\xf6\x53\xc3\x79\x2a\xcb\x0d\xb3\xca\xfb\x29\xf7\x49\x8c\xf9\x6b\x24\x51\xee\x86\x8c\xde\xf6\x86\x72\xd5\x71\x33\x89\x54\x94\xb5\x7f\x29\x41\x0a\x52\x73\xfe\xc8\x3d\x5b\x44\xb8\x0a\x6a\x39\x1c\x71\xaa\xef\xe2\x76\x1e\x7f\xcf\x43\xdc\x6e\x6f\x03\xe2\x9d\x4b\x52\x1e\x32\x86\x76\xdf\x29\xc6\xcd\xd4\x31\x64\x9c\x63\x7d\x44\x99\x32\x6b\x3c\x39\x3f\xc0\x5d\x0e\x3b\xc4\x38\xfd\xa1\x7f\xfa\xba\x42\x52\x29\x78\xf6\xcb\xa3\x3b\x48\xd3\x69\xb4\x7d\x7b\xcd\x37\x34\x9e\xcd\xca\x17\x34\xcf\x8f\x5b\x16\xc4\x0b\x0c\xde\x3a\x67\x9a\x56\x07\x2d\x7d\x40\xb8\x20\xdd\xa1\x1a\x5f\xd7\x80\x4a\x50\x7a\x17\xa5\xb3\x8f\xfa\x87\x8d\x95\x58\x3b\x97\x29\x61\x44\x4a\xcd\x3f\xa5\x8f\x9c\x5c\x15\x23\x58\x92\xc1\xec\x72\xe9\x9a\xe7\x77\xf0\x6d\xbe\xc9\xcd\xfe\x41\xf3\xd0\x8e\x32\x5c\xa9\x0d\xdd\x3d\x11\xe6\x36\x39\x6a\x89\x52\xf0\x0b\x4c\x6d\x8a\xa1\x8b\x02\x2e\x49\xc2\x65\x47\xe3\xb5\xfc\xa0\x52\xb0\x27\x9c\x88\x76\xf7\x24\x98\x09\x50\xd0\x19\x3e\x35\x68\x0c\x5f\x0a\x80\xaa\x01\x63\xd5\xd2\xa0\x57\xae\x3f\xbc\x86\x2b\xfa\xc2\xe0\x00\xf5\xff\xbc\xf7\xe3\x60\xde\x83\xcf\x87\xb2\x23\x43\xbd\x80\x97\xcb\x08\x18\xc5\x42\xea\x9b\xe9\x57\x27\x42\xab\xc3\x7e\xb3\xab\x82\xcd\xfd\x63\xe1\x62\x0d\x00\x13\xd2\xfe\xef\xda\x35\x7e\x7d\x60\xf0\xd5\x41\xd6\x45\x28\x12\x28\x72\xa2\x1b\x7b\x32\x6d\x65\x35\xfb\x14\x0a\x74\x3e\x60\x76\xb3\xc3\x03\x03\xef\x64\x02\x2c\x0c\x70\x2a\x3d\xae\xcf\x95\xc6\xbc\x01\x18\x27\xd8\xe1\xb9\x07\x20\x6f\x8e\x24\xdd\xa5\xaa\x3b\x66\xf2\x60\xa2\xcc\xa2\xd8\xfc\x74\xb1\xb9\xc9\x9f\x4a\xaf\x24\xdf\xfb\xe3\xaa\x48\x1f\xfe\xe5\x5a\xe5\x00\x04\x12\x4b\x95\xc3\xd4\x8a\x83\xb1\x1c\xcf\x6b\x03\xc0\x2b\x10\x4c\x01\x6d\xed\xad\x14\xde\xdf\xef\x52\x32\x1e\xa4\xe5\xae\x31\xf4\x2c\xb0\x71\xe1\xc7\xc3\xf5\x88\x95\x87\x46\x1e\xef\x0b\xc1\xa3\x70\x92\xcc\xb9\x2d\x97\xbd\x4a\x25\x62\xc7\xeb\x1f\xa0\x95\xcf\x3d\x67\xf5\x56\xf5\xa3\x8d\x5e\x89\x79\x81\x90\xbd\x7e\xcf\x17\xc3\xd7\xbc\xf5\x15\x30\x7e\x2d\x50\xc7\xcf\xd7\xaa\x7b\xfc\xc6\x9b\x42\xa2\xf8\xc6\x32\x58\xb2\x5a\xda\x3f\xeb\x08\x6f\x47\x21\x78\xcd\x6e\x2e\xca\xdb\x7d\x25\xae\x7d\x4f\x1b\x6f\x09\x5f\xbe\x3f\x62\xb8\x1b\x4a\xdc\x12\xe1\x89\xe7\x4e\xbe\xf9\x76\x1b\xb2\x24\x62\x6c\x3b\x7a\xe9\xce\x60\x86\x26\x4b\xab\x87\x78\x5e\x5d\x22\x11\x92\xe5\x15\xc3\x64\x98\x0f\x2b\x11\xe4\x67\x0b\x01\x65\x49\x32\x80\xf9\xaf\x8b\x04\xf6\x20\xf2\x81\x14\x42\x23\xf0\x28\x69\x6a\x4e\x4e\x3e\x53\x77\x46\xc1\x0c\x57\x00\xd3\x0c\xa1\x7c\x97\x03\x62\xb8\x18\x09\xfe\x02\x88\xc0\x57\xf9\x6f\x57\x5e\x5c\x71\x13\x1a\x8f\x3f\xbf\xa6\x31\x3e\x04\x42\x00\x4c\xd0\x2f\x3d\xd1\x69\x52\xff\xdb\x2c\xbe\xeb\xf8\xe0\xc8\x63\x79\x6b\x57\xbe\x18\x5a\x29\xc7\x42\x55\xbc\xa0\x8e\xd6\x6b\x6a\x79\xd5\x1b\x34\x58\xfe\xf5\xc7\x4b\xc3\xe6\x2c\x0d\x33\xf1\x0a\xee\x46\x00\x02\xfb\xe5\xbc\x39\x18\xe2\x70\x4b\xeb\x75\x8e\xaf\xb0\xd5\xb7\x83\x0b\x97\x8c\xd9\x71\x90\x40\xf7\x9c\x98\x4f\x41\x76\xfe\x79\x47\x34\xf0\xfa\x90\xcb\xde\xde\x2e\x2c\x6d\xb9\xa3\x23\x44\x22\x5e\xcc\xd1\xa3\x87\x01\x38\x6c\xa4\x51\x5a\xf5\xa5\x31\xf5\xf3\x82\xab\xd0\x43\x94\xae\x9f\xe8\x5c\xab\x34\x6f\x4a\xdc\xa8\x8c\xe8\xed\x9e\x8a\x0f\x95\xa6\xa0\x85\x1d\x93\xfd\x64\x44\x36\xe7\x68\x5b\xa6\xbc\x7c\x1a\x99\xd7\x4c\xd1\x1c\x5d\xd5\x56\xf8\x7e\x81\x2e\x86\xd7\x3a\xb6\xe9\x0e\x8c\xc6\x12\xcc\xd4\x30\x7a\x2a\x05\x18\x1c\xfa\x19\x15\x9a\x48\x58\xd7\x2c\x80\xcf\xbf\xcf\x37\x9f\x91\x7a\xae\xf6\x55\xf4\x51\x4e\xbc\x65\x2e\x37\x24\x3a\xba\x86\xc5\x2e\xcd\xca\x30\xd6\xa3\x4d\xbd\xe5\x6a\xb9\x13\xeb\x39\xff\x17\x67\xaa\x0b\x7b\x32\xda\xac\x43\x8d\x1b\xfe\x1b\xab\x4f\x19\xbd\xa2\xe5\xa2\xb8\xd3\xfb\xff\x90\x4e\xd9\x98\x7f\xc3\x40\x2e\x8b\xd4\x57\xd4\x31\x05\x44\xb1\x07\x7a\x1c\x5b\x10\xc1\xb0\xe2\x5b\xb0\x4d\x25\x56\xe6\x35\xec\x72\x21\x34\x26\x55\x99\x72\xab\x0d\x73\xe2\xa0\x37\x25\x79\x7f\x00\xe7\x4e\xd9\x4a\x28\x3f\xa5\x6e\x59\x6d\x89\x1e\x22\x54\x13\xfa\x43\x8d\x4d\x6d\x72\xfb\x2e\x04\xee\x98\xdd\xb4\x7b\x62\x53\x4e\x54\x8c\x1d\xec\x5d\x2a\x19\x7d\xe8\x92\x1b\x76\x60\xaa\xa4\x98\xfb\xa2\x95\x31\xea\x5e\x48\x9d\xe5\xee\x8b\xd3\x76\x93\x4e\x6f\xee\x55\xdb\x86\x41\x53\x36\x57\x99\x4f\xd9\x89\x65\x0b\x5b\x28\xda\xce\x42\x11\x03\xe5\xa2\xcd\x9d\x1e\x85\x74\x6f\x31\x62\xcf\xab\x15\x5a\x48\x82\xe7\xbc\x7b\xd1\xc0\xf5\xa4\x7e\xcb\x4e\x80\x7d\x56\x1d\xcb\x8b\xd9\xb9\x00\x6f\xb2\x92\x15\x3c\x8b\x3e\x23\xc7\xfd\xa2\x6f\xaa\xf0\xee\xbe\x54\x46\x44\x22\xef\x1b\x25\x37\xef\x33\xae\xac\xd7\x2e\xf5\x28\x3f\x15\xbe\x66\xb7\x92\x83\x8a\xe5\xe6\x5d\xdf\xd2\xf5\x60\x21\xf5\x9c\xc0\xb1\xfc\xc0\xbf\xbc\x31\x25\x55\xef\xf4\x71\x4c\x3a\xe8\x9c\xa7\xa8\xcf\xb8\x7c\x92\x04\xfb\x40\x38\x27\xf3\x17\x2b\xae\xf5\x56\xa8\xb6\x57\x1e\x75\xdb\xa0\x82\x9d\x30\x7f\x8b\x0b\xcb\x7d\x20\x2b\x54\x2f\x89\xee\x51\x6e\xe9\x13\xa0\xe2\x6c\x10\xea\x9e\x7e\x86\x63\xbb\xf2\x7b\x97\x70\xab\xfe\x61\xed\x3d\xa6\xe8\xa3\x56\x3a\x23\x76\x6d\xf8\xe9\x7e\x90\xe2\xc8\x31\xee\x81\xcf\xed\x90\xf6\x74\x09\x30\x8d\x53\x50\x48\x81\x5d\xb6\x2f\xc8\x6a\xe2\x67\x2f\x21\xbb\x92\x88\x1b\x7b\x2f\x1b\xa3\x63\x20\xe5\x6a\x9d\xd0\xf7\xc9\x68\x91\x85\xe2\x5b\xe3\x3d\x92\x10\x55\xd5\xfa\x40\xca\x8d\x71\x8b\x49\x67\x36\xce\x4d\x96\xad\xff\xfa\x1f\x97\x95\x6d\x71\xe9\xfb\x25\x59\x38\xec\xbe\x64\x63\x7f\xd5\x60\x22\x17\x8d\xda\x58\x91\x74\xae\xa4\xe5\x01\xb3\x9d\x13\xa4\xaf\x3e\x9d\x17\x07\x22\x03\xb7\xfb\x7b\xe2\x85\xc5\x72\x69\xb8\xc5\x14\xe9\x50\x9d\x4f\x3f\xfb\xac\x30\x3d\x86\x2f\xbf\x39\xb3\xd2\x46\x01\xed\x13\x6e\x1e\x56\x7d\xa6\x4f\x59\x5b\x12\xd5\x9c\x0f\x1b\xbd\xb5\xaf\x22\x49\xee\xd9\x0a\xe9\x7b\x47\x45\x7a\x09\x60\x29\xd3\x87\x72\xca\x12\xec\xc1\x1d\xb6\x4f\x6f\x4b\xf1\xff\x59\x02\xea\xba\xa7\xfe\x53\xef\xe9\xc7\x02\x95\x34\x03\x3b\xa0\xa5\xbb\x94\xbe\xeb\xb7\xd4\x1e\x4c\x27\xf4\xb1\xb9\xa2\x3e\xe1\xb0\x63\xe8\xc4\xe1\x92\x4e\x40\x19\x95\xbd\xe0\xaa\xf1\x38\x20\xe1\x17\xca\x8b\x8a\x7b\xec\x82\x95\x7a\x14\x62\xf6\x04\x38\x05\x5f\x78\x08\x56\xe2\xd4\xf0\xd3\xdc\xda\x28\x1e\x58\x22\x5d\xce\x94\xac\xc4\x9b\x4d\x36\x77\xfe\x2c\xa4\x66\xe8\x67\x66\x94\xd3\x2b\xcd\x9c\x29\x54\xaa\xd5\x4a\x1b\x55\x08\x74\x3e\x0d\x2d\xe8\x5d\x7a\x7d\x03\x1b\x86\x6f\xa3\x2a\x91\x6d\x47\x07\xc5\xb6\x1f\x96\x31\x89\x53\xcd\x1d\x8c\x3c\xbb\xb1\xba\xbb\xdb\xb5\xe5\x87\xfc\xb7\x26\xaa\x85\x15\x3a\x17\x97\x99\x51\x83\x7a\xf1\x48\xed\xe1\x6a\xba\xbd\x6c\x1a\xa6\x6a\xfe\xb9\x4c\x01\xee\x1c\x0d\xd8\x46\x2c\xfb\xff\xc1\xf0\xf8\x8f\x61\xe8\x59\xaa\x22\x27\x4c\xcb\xac\x86\xc9\xb4\xa5\xb2\x62\x4a\x70\x7b\xf6\xbc\x97\x36\xad\xd5\xab\xe6\xa4\x0e\x68\x93\xe6\xd1\x5d\x13\xbf\x8d\x10\x6d\xaa\x0d\xfd\x45\xd2\x3d\xae\x0b\xd2\x7e\x92\xea\x66\xa1\xbb\xda\x04\x46\x76\x1c\x8a\xdf\xea\x87\x45\xbb\x60\x45\x57\x69\x6e\x16\x75\x78\xe0\x38\x21\x47\x56\x59\xe7\x3f\x3f\x37\x4b\x5e\xf6\x15\x2b\x9b\x5b\x32\xb7\x96\xdd\x25\x5f\xac\x6d\x77\xe4\xba\x73\xc3\x5a\xb5\xea\xe9\x4d\x5a\x3f\xdc\x76\xe2\x6c\x9e\xb3\x93\x39\xa3\xb9\x66\xa4\x88\x4f\xca\x0c\xcf\x7b\x1c\xf9\xb2\xaa\x2c\xb3\x27\x39\xab\x2f\x1b\x7d\x15\x00\x0d\x54\x7d\xe5\xcc\x1b\xeb\xca\xe7\x36\xd9\xde\x56\xeb\x7a\xc3\xb4\xff\x76\x55\x12\xb9\x5b\xe2\xd1\x64\x54\x1e\x2c\x5f\x75\xea\x56\xca\xed\xa3\xe4\x45\xcd\x2b\x42\x16\x3a\x81\x78\xe2\xe1\x61\x8f\x59\x2e\x4c\x34\x8d\x72\xdd\x50\xcb\x31\xf2\x22\x11\xad\xa1\x6e\xaf\xef\x6a\x5b\x29\x58\x73\xd6\x11\x35\x34\x8d\xf5\x01\xdb\x20\xc9\x34\x73\xe5\x53\xca\x36\xdd\xc1\xab\xa2\xf2\x0c\x7b\x99\x28\x05\x2c\x89\x6b\x57\xaa\x87\x10\xfb\x0a\xab\x3a\x1a\x44\x6d\xaa\x33\xfc\x88\xb0\x8e\x2f\x0a\xf0\x54\xc5\x2a\xdd\x1f\xd7\x05\xa9\x7a\x27\xa9\x31\x1e\xb6\x6f\xf1\x27\x33\xff\x18\xf8\x6f\x8a\x77\x7c\xd0\x8b\x14\xa5\xa9\x3d\xca\x59\x87\x3c\x10\x0a\x04\x61\x9e\x44\xa8\x6d\x82\x1e\x3f\x46\x5f\xa3\x59\x33\xe7\x66\x02\x5e\xb7\x4c\x12\x95\x66\xeb\x66\x27\x1a\x15\x40\xd4\x18\x26\x4d\x37\xb7\x46\x30\x7b\x82\x8c\xe7\x95\x12\x47\xa7\x8a\xb1\x54\xc8\x42\xc4\xd1\xce\xd3\x2f\xaf\x1f\x66\xb8\xd5\x7a\x71\x63\xf8\x5d\x2e\x4c\x2e\x49\x11\xb2\x6e\x5e\x1e\xbd\xa4\xd9\xd2\x57\xa1\x6b\x94\xd6\x28\xed\x10\x68\x1a\x8a\xdd\x63\xa4\x21\xc8\x9c\xfa\xeb\xae\x7c\xe2\x8a\x25\xd8\x3f\x25\xc0\xd0\x5c\xfd\x84\x36\xdd\x15\x51\xc6\xc0\xb4\x6e\x2a\xb9\x99\x30\xc0\x02\xe4\xb3\x27\x18\xab\x19\x27\x8a\x8d\x8e\xd3\x57\xae\x68\xc4\xa9\xe3\x9f\x3d\xfb\x00\xee\xc5\x9d\x4c\x96\x1a\xdc\x43\x67\x08\x52\x04\xf1\x9b\x99\x8c\x89\xa6\x39\x56\xee\x94\xea\xe7\x8e\xab\xd8\x9b\x41\xa5\x10\xd3\x9a\x54\xbf\x51\xf5\xae\x79\xcc\x05\xc4\x8d\x26\x69\xfd\xd9\xa3\x68\xf5\x9c\xe3\x51\x4a\x2c\x23\xf6\x7c\x64\xe9\xa9\xba\x05\x7a\xcd\xca\xf1\xa2\x7c\x79\x59\x48\xb4\xc8\xe7\xee\xd1\x7b\xaa\x46\x49\x12\x25\x99\xac\x4f\xd8\x11\xe8\x14\x82\x16\x52\x44\x92\x26\xd6\x6b\xea\x27\xce\x09\x17\xf5\x91\x28\xa8\xac\xfd\xf1\x6b\xd5\xcd\xb7\x5f\xdc\x75\xe1\x58\x54\x05\x81\xb0\x34\x83\x4a\xdd\x14\x6f\xad\x81\xdd\x74\xc7\xa0\x80\xf5\x1d\x60\x12\x58\xb3\x7f\xe8\x0b\xec\xf3\x88\x6c\x04\xda\x2f\x84\xde\x2d\xdd\xd4\xa9\xaa\xac\xae\xc1\x19\x0a\x14\x54\x42\x49\x6a\xa2\xd4\x9b\x2f\x03\x9d\x0a\x82\xf8\x4a\xc0\x6e\x30\x2c\xa6\xc4\xa7\x58\x42\xc4\xf7\xdd\x55\xba\x9e\x48\xd5\x68\x1d\xd7\x17\x46\x65\xa8\x02\x25\x0c\xd6\x36\x8e\x25\x0c\xd4\x2f\x12\xc6\xc1\xb5\xc6\x02\x14\x3a\x26\x7a\x4c\x6c\xb1\x19\x64\x4b\x54\xb5\xf4\x0a\xb1\x5e\xbc\x47\x76\xcd\x8a\xa2\xca\x0f\x53\x41\x34\x8a\x3a\xe4\x44\xc1\x04\x49\x81\x06\xf9\xde\x03\xaf\xca\xaf\x91\xf0\xe8\x3c\xb8\x0b\x96\x21\x2e\x94\x31\x3f\x1e\x6e\x54\xe5\x9e\xe0\x19\xc8\x7a\x1d\x07\x68\xd4\x93\xe5\xb0\xb5\x0c\x9f\x5a\x88\x42\xe4\x18\xaa\xf2\xa9\x17\x96\xce\xef\x87\xaf\x43\x6e\x16\xd2\xee\x97\xb5\x1f\xf9\xee\x49\x9d\x9e\x00\xf8\x8f\xb3\x89\x7e\x03\x2b\xdb\xef\x73\x02\x6d\xa6\x38\xb9\x54\x7f\xb0\xc5\x3d\x66\x21\x63\xb7\x28\x9a\x4b\x1b\x48\xf7\x8a\xea\x83\x53\xad\xcb\xe8\x48\x37\x21\x4c\xf0\x53\xbf\x2e\x44\xc4\x02\x34\xe7\x8b\x24\xfe\xd9\x7e\x5d\xcb\xda\xd9\xb4\x61\xbc\x47\xe9\x02\x9a\x73\xaf\x69\x08\x4b\x37\x90\xc0\xe0\x22\x7f\x64\xcf\xb8\x7d\xbf\xac\x89\xb5\x9a\x7c\x9f\x7b\x9d\xa9\xd8\xdc\xb0\x51\x92\x37\xde\x72\x2d\x0f\xca\x1d\x79\xa7\xfb\xc7\xe0\x88\xcc\x82\x7a\xab\x15\x52\x61\x56\xce\x5d\x08\x76\x34\x74\xbc\x96\x9e\xa0\x8f\x8b\xbf\xb0\x05\x32\xfa\x08\xed\xe4\x04\xfa\xc2\x2d\xe6\xc7\xe8\xae\xa8\x59\x44\x8e\xdb\x8c\x19\xed\x53\xd8\x40\xaa\x25\x5f\xd1\x42\x28\x46\xd6\x13\xe3\xdd\x48\x6b\x65\x7f\x25\x26\x04\x35\xfb\xd5\x3d\x27\xbc\x1b\x6a\x46\x2c\xa7\xf7\xfb\x98\xba\x47\xf5\xf4\x6f\x57\xf8\x10\x39\xe8\x3b\xfc\x28\xef\xda\xa4\x90\xc1\xf7\x58\xd0\x33\x7a\x60\xf7\x66\x9d\x4d\x83\xd4\x3c\xb5\x7e\xdf\x31\xea\xcb\xf9\x62\x52\xf4\x36\x74\xa6\xe8\x14\x30\x6c\xbd\x75\xd6\x46\x9a\xa9\xbe\x49\x6a\x11\xcb\xaf\xfb\xe3\xcb\x1e\x4a\x6f\xab\x88\x49\xcc\x71\xa8\xb9\xb6\xc4\xb4\x10\x28\x85\x1b\xae\x63\x7f\x03\xc7\x98\xc7\x55\xef\xc8\x40\xf4\xba\xab\xdb\xd1\x1d\xd1\xa2\x23\x02\x65\xcd\x26\x9b\xb1\x56\x95\xb3\xf7\xa9\xcc\xf3\x79\x28\x18\xfa\x09\xf2\x7b\xcc\xa7\x4b\x75\xa4\xcf\xe1\x98\x57\x4b\x13\x65\x01\x94\x90\x5a\x0a\x5e\x3e\x28\x77\x44\x49\xa6\x19\x92\xdb\x12\x15\xdf\xb9\x7d\x78\xc8\xde\x0a\xfe\xda\xc6\xba\xe2\x35\xbc\x67\x59\x80\x47\x32\xa6\x1c\x32\x0f\xc8\xd3\xfb\x26\x8b\xf3\xfb\x9e\x0c\xd3\x73\xcf\x83\x21\x71\x19\x80\xca\x5c\x09\xa1\xc1\x9e\xbc\xac\x8c\x8e\x19\x43\xdd\x50\x25\x55\x8b\x0d\x66\x62\xeb\x13\xf5\x05\xf7\x53\xb5\xaf\xe5\xda\x27\xb5\x48\x85\x4c\x62\x69\xcc\x2c\x9c\x73\xb5\xe4\x46\x03\xc0\xb9\xf4\x36\xe4\x04\xa6\xae\x37\xdf\xbc\x44\xe4\x0a\xe6\xa6\x67\x1d\xcc\xa3\x6f\x47\x61\x29\x6a\xe8\x53\x2d\x26\x9d\x3e\x37\x94\xd2\x79\xc6\xcf\xe7\x15\x1e\x43\x43\xce\x96\x08\x69\xe2\x5d\x00\x4d\x52\x1c\x93\xa0\xbb\x0c\x41\xf1\x1a\x8f\x30\x99\xf0\x0c\x0d\x4b\x66\x93\xb4\x46\x3d\x7a\x0b\x8c\xc6\x67\x04\x67\x8a\x03\xaf\x74\x66\x9b\x37\x17\x4b\x78\x20\x90\x5b\xd0\x12\xe5\xab\x1f\x0c\x4c\x5e\x2e\x5b\xb3\xa6\xd4\xad\x3e\xf3\x5a\xd1\x01\x63\xfb\x19\x37\xe4\x16\x13\x07\x8d\x85\x33\x36\xfe\x16\x63\x1e\xcd\x97\x99\xd7\x71\xcc\x07\xb2\x77\xac\xb9\x2a\x43\x43\xf9\x56\x3c\xb7\xfc\x0e\x5d\x29\x45\x8d\x1d\xc3\x39\x9a\x9f\x29\xa8\xcf\x9b\xca\x30\x6c\x94\x53\x4d\xeb\x1f\x2e\x24\xf4\x62\x41\x53\x98\xea\x96\x48\x69\x62\x13\x25\x7a\xec\xb2\x71\xdd\x93\x56\x10\x03\xdd\xcf\x1b\xde\xb7\xca\x80\x18\x37\xe4\xf6\x2b\x38\xe0\xfa\x7b\x0a\x5c\xe2\x48\xa6\x41\xe1\x5a\x1e\x00\x23\x5b\x97\x38\xc4\x05\xa4\x30\x9e\x2a\xc6\x0c\xd1\x72\x1f\x5b\x2d\x9c\x73\x77\x1b\x6e\xdb\x78\x50\x2b\xee\x94\xa8\x48\x45\x6c\xfb\x19\x87\xe5\x59\x2e\x2f\xdd\x6b\x36\x77\x19\x4b\x62\xae\x3f\xfb\x38\xd6\x38\x47\xf6\x49\x07\x01\x2e\xdf\x0b\x75\xa1\x01\x96\xb7\x72\xde\xbc\x99\x6c\x39\x8f\x0f\x45\x69\xde\x9c\xf8\x01\x12\xa2\x86\x99\x60\x86\x22\x82\xc6\x83\x9e\x91\x8f\xc8\x87\x9f\xcb\xba\xf3\xf6\x26\x76\xa1\xcc\x49\xcc\xdb\x04\xd5\xa2\x75\x2a\x4a\x5c\x5b\xd5\x5e\x03\x65\x6e\x06\xf4\x51\x05\x25\x6a\x09\x3f\x7b\xeb\x6e\x57\x2b\x9b\x10\xb3\x31\x0b\x82\xb2\x5a\x80\xd8\xdc\x43\xab\xf2\x09\x16\xd2\x24\xaf\xd7\x33\xf7\xaf\x21\xdb\xee\x36\xea\xf7\x95\xa3\xfe\x2f\xa5\x53\x47\xc7\x20\x40\xa9\x34\xce\x8c\x1d\x19\x45\xb8\x21\xc3\x52\x1a\x64\x9e\x1e\x38\x68\x67\x3f\x83\xd3\x4a\x7e\x11\x8f\x10\xa2\xb2\x75\x3f\x0b\x5a\x69\xa1\xbf\x44\x18\x83\x87\x34\xa3\xed\x4b\x7b\x6a\x25\x18\x29\x88\x27\x19\xb7\x05\x78\x9a\xe9\x4d\x61\xfe\xff\x59\x76\x6b\x45\x74\x82\x2c\x6c\xd6\x04\xc5\x01\xfd\x13\x63\x3a\xc9\xc3\x77\xe1\x85\x58\x6b\x7c\x7c\x32\xf3\x9c\x85\x12\xeb\x24\xc2\x2e\x45\x79\x86\x3d\x1f\x06\x78\x92\xc7\x2a\x2d\x4c\x4d\x9a\xb9\x5f\x16\xbe\xb6\xef\x78\x43\x83\xd3\xd3\x7b\x05\xc0\x74\xd3\xe7\x88\x34\x02\x2e\x9f\xa6\x3c\x19\xa0\x04\x50\xf0\x72\xf1\xcd\x99\x99\xe1\x11\x73\xb9\x31\xb9\xbc\x2f\x9c\x16\xd5\x4e\x1d\x38\xb0\x75\x75\xa2\xbd\x2e\xd3\xbf\x53\xaa\x5f\x72\x84\x6a\xab\x5d\xb8\x5c\xad\xa5\x9a\x61\x76\x5e\x95\xe4\x1b\xa2\xa9\xe1\x73\xf6\xf3\x51\x11\x88\x9e\x0c\x5a\xc5\x9c\xf5\x2d\xc5\xd4\x44\x8c\x00\x75\xb5\x53\xdd\x0f\x18\x8d\x67\x8b\x36\x83\x84\x0f\x86\xb2\x7b\x24\x7b\xe6\x16\x72\x0f\xa6\x32\xda\xcf\xf0\x00\xfe\x35\xf3\x3e\xb6\xf8\x1b\x85\x2c\x09\x93\x87\x68\x0f\x63\xa6\x1b\x16\x62\xb1\x4a\xd6\x8a\xcf\x3f\x24\x7b\x6f\x75\x95\x6f\x3e\xcd\xa8\xfe\xa4\x76\x43\x6c\xa1\x92\x28\xb6\xc2\x3c\xdc\x2f\x30\xe7\x78\xfb\x28\x0e\x44\x27\x7f\x61\xd4\xa7\xd8\x52\x99\x30\xdc\xdf\x22\xe0\x6f\x40\x9a\x86\xa8\xa4\x3e\x4e\x08\x9b\x39\xdf\x96\x51\xb9\x5d\xb6\xe2\xa8\x1a\x7d\xb8\xb7\x00\x33\x81\x28\x8b\x20\x7a\x1e\x5e\x29\x28\xd2\xae\x65\xb4\x08\x7d\x45\x31\x17\x5c\x04\x02\xdf\x70\x1a\x9d\x42\x80\x28\x79\xfb\x95\x66\xcc\xb7\x13\xc5\x48\xf0\xf1\xcf\xc8\x59\x84\xc4\x2f\x48\x49\xfe\x8d\x00\x3b\x2c\xff\xa7\x94\x08\x71\xc2\xab\x3d\x95\xa7\xfc\x04\x64\xd6\xc6\x7f\x3c\x7a\x6c\xb0\x68\x69\x20\x66\x7c\x41\x97\xd1\x66\xc0\x67\x5d\x79\x5c\xc5\xe8\x0f\x3a\x65\xd4\xe4\xfd\xce\x7d\x8f\x1f\x8b\xc7\xd5\xaf\x13\xe7\x46\xae\xd9\x4d\xb1\x2e\x4d\x17\xa5\x2d\x4c\xda\x43\xa3\xe4\x45\x88\x66\xe9\xba\xac\xbf\xac\x75\xed\xe2\x5c\x51\x28\x14\x4b\x8d\xdb\x84\xa0\x52\x6a\xad\xab\xb9\x52\xfb\x12\xc7\x8f\xd1\xef\x2f\xb5\xf0\x5b\xcd\x04\xb7\x75\x0e\x54\x4f\x62\x0e\xa4\x8b\x44\x3b\x13\x43\xd8\xb7\x63\x02\x8d\x45\xbb\x96\xbd\x45\xc6\x54\x53\x71\xc3\xdd\xfc\x68\x33\x64\x94\xdb\x2d\x7b\x05\xfc\x66\x58\x70\x16\xc4\xc3\xf0\x36\xa7\xad\x68\x0f\x5d\xa2\xb9\xdb\x56\xa3\x48\x61\x33\x3c\xad\xd5\xdc\x00\x76\x99\xd4\x4a\x40\x58\xa6\xe2\xe9\xbe\xe7\xf6\xcd\x4d\xc4\x7a\x64\x52\xca\x4c\x62\x05\xa3\x33\xa2\x91\x2f\x98\x02\xf4\x08\x98\x87\xb8\x64\x7a\xa8\x22\x97\xf8\xf3\x3f\xd4\x80\x03\x1f\x67\xda\x3a\x44\x5f\xa5\x1d\xd1\xc2\x50\xa8\xbe\x37\xbd\xad\xc2\x5f\xd9\xa0\xcb\x53\x63\x15\x7d\xbe\x15\xa1\x96\xc2\xff\xdf\xa8\xf4\xca\x95\xfc\x30\x90\x24\xf9\x9d\x30\x02\xa5\xa0\x73\xfb\xbb\xe0\x9b\x4d\x47\x25\x5e\xfb\x96\x58\xe2\xc9\x03\x35\xd3\xdd\xfe\x54\x6e\x3b\x9b\xbd\xc0\x3e\x26\x02\x11\x54\xa6\x04\x3c\xe5\x8d\x16\x99\x29\x33\x08\x53\x66\x56\x31\xf3\xe5\xda\x93\x27\xac\xfd\xd4\x76\x68\x92\xca\xca\x44\xe6\xf4\xa4\xfc\x0b\xee\x6e\x86\x24\x34\x6e\xab\xb5\xb7\x27\xdc\x72\x7d\x62\x12\x30\xef\xe4\x44\xdb\x78\x6f\xfc\x56\xea\x0b\xc1\x03\xd0\xfc\x55\x9d\x4a\x67\x49\x1f\x18\x4e\xfe\x89\x9c\xa7\x7d\x06\xb2\xd6\x34\x83\xbb\x2f\x12\xc1\x1b\xee\x8a\x7c\xdf\xa5\x5c\x94\xec\x24\x4d\x95\x8c\x79\x81\xbb\x22\x99\x6a\xa6\x7d\x05\x6a\x8f\xb9\x00\xe8\x91\xc3\x69\x08\x7f\x62\xd3\xf9\x21\xd4\x0f\x4e\xd3\xbd\x10\x53\x42\xb6\x76\xf3\x43\x39\xae\x77\x70\x9d\x37\x7d\xea\xca\x35\xb1\xfd\xf8\xac\x84\x1e\x71\x32\xe8\xd1\xaa\xe0\xc6\xd2\xb4\x00\xf7\x55\xc3\x8d\xbb\x2c\xeb\xd5\xe9\xbc\x81\x1b\x49\x9d\x16\xf5\x7d\xff\x3b\xed\xdd\x59\xcd\x9c\xc8\x9d\x94\x44\x4a\x6d\x5b\xf0\xf6\xe5\xd0\x4f\xac\xad\x73\xde\xa5\x24\x46\x6c\xe5\x58\x8a\x8e\x7e\xa6\x3d\x2f\x5f\x18\xbb\xe1\x53\xe9\x4c\xec\xb1\xec\x17\x4a\xc4\xd3\xdd\x26\xa8\xc7\x5e\x28\x0d\x71\x77\x76\x23\xeb\xe3\xbf\x09\x1e\xef\xea\x92\x8e\xfb\xff\x2e\xd1\x50\xdf\xd9\xe5\x16\x3a\x62\x42\xf8\xb1\x66\x1a\x56\x88\x32\x71\xcb\x67\x6e\x89\xd9\x99\x0b\xaf\x8b\x05\x6c\x38\x56\xd3\x85\xb8\xb4\x62\xd1\xe5\xb4\x30\x17\x83\x61\x47\x2d\x4f\x54\x6c\x4f\x3d\x41\x8c\x66\x93\xb1\x57\xec\x4f\xd7\xad\x4f\x4a\x9f\xfe\x1d\x7b\x9b\xd5\xcc\x91\xcd\xb2\xb9\x67\xc6\xf0\x20\x6b\x19\x3a\x87\xe1\xf9\xed\x49\xfe\xe7\x33\xe4\xcf\x2a\x7a\x10\x15\xe6\x9b\x41\x24\x11\xff\x87\xf3\x95\xbd\xcc\x8a\x6b\xbe\x50\x0d\xc9\x60\xe6\xe6\xb3\x6e\xf5\x46\x47\x78\x29\xeb\x47\xff\x52\x50\x45\x25\xbd\x35\xc4\x5c\xfd\x7d\xb7\xae\xda\x12\xc0\xbc\xa9\x33\xdb\xb5\x52\x75\x75\x9b\xde\x08\x57\xe7\x2d\xcc\xe8\xf1\x1f\x99\xfe\x98\xdf\xfa\x32\xd4\x14\xd4\xe6\xfb\xb9\xfa\xf4\xa5\x47\x89\xa2\x12\xfe\xab\x0f\x9d\x92\x8b\xf4\x1a\x0e\x25\x76\xcd\x6f\x4d\xff\xdd\xcd\x6b\x20\x78\x07\x86\xef\x42\xf8\x75\x46\x8e\xe9\x4e\x37\xd7\x82\x6b\x56\x29\x31\x32\xf0\x64\x42\x21\x08\x34\x0d\xf9\xe0\xae\x2e\x0a\x92\x8a\x4e\x91\x03\x38\x4f\x2c\x66\xbd\xfa\xa7\x12\x9c\x7f\x32\x54\x69\x56\x0d\x75\x8b\xb1\xe4\xc4\x64\xdb\x4c\xf2\xae\xed\x7a\x79\xa7\xf9\x1b\xca\x75\x98\x67\xd1\xf0\xc2\x92\xcc\x3b\xa6\x19\x4b\x73\xdf\x27\x0f\x5e\xa4\xa7\x12\xa0\x79\x2b\x83\x1a\x37\x55\x55\x4f\x9d\xa8\xfb\x42\x99\xf8\xd0\xb6\xea\x2b\xad\x24\xb4\x25\x4f\xbb\x39\x65\x6c\xd5\xa5\x2a\x91\xda\x63\x40\xaa\x89\x05\x46\x89\x04\xf5\x63\x36\x14\x67\x67\x05\xf4\x4d\x55\x7f\x5f\xd9\x7e\x31\x66\x84\xa6\x76\xbd\x56\xbb\x35\x0d\x89\x10\xf3\x2d\x56\x0d\x9b\xdc\x30\x1d\x8f\x18\xc1\x20\x17\x29\x5f\x44\xf1\x7b\xbd\xf3\xd4\xb3\x62\x31\x1b\x19\x96\x23\x51\x7c\xe6\x83\x6b\x9e\x39\x3d\xad\x3f\x87\xf7\xe4\x50\x6f\x99\xc1\x9e\x63\xd6\x73\xbb\x1f\x1f\x83\x24\x26\xf1\x16\x9d\x7d\xd3\x42\x6f\x57\x54\x87\xe2\x22\x4d\xc2\x0c\xa7\xbc\x3d\xa0\x44\x79\x24\x2c\x49\x9c\xd7\x08\x4e\x01\x2c\xda\x86\xb1\x09\x77\x99\x03\x49\xcd\x78\xfb\x45\x8d\x8f\x11\xa7\x36\x90\xbd\x78\xe0\x6e\xa1\x43\xd4\x43\x1f\x2d\xa1\xf8\x1c\x99\x2c\x9d\xcf\x95\xd2\xda\xcc\xb2\x59\x0d\x3a\xdd\x79\xa5\x7e\xb1\xcc\xca\x9d\xcb\x17\xd8\x8c\xa8\x8e\x3d\x59\xa2\x07\xc3\xe2\x9e\x63\xcf\x2c\x54\x78\x65\xa1\x71\x55\xa2\x6b\xe7\xe0\xdd\x2a\x4f\xeb\xe6\x54\x71\xf4\x5c\xb1\x45\x1c\xd8\x07\xac\x80\x2a\x84\xe2\x2f\x00\xd8\x92\x2f\x89\xaa\x4e\x53\xe4\x7f\x55\x1e\x66\x3a\xec\xf5\x89\x96\x62\x8d\xfc\x3f\xd5\xc4\xab\xa7\x48\xd2\x74\x03\x24\xd9\xb6\x55\x66\x75\x87\x86\x64\x48\x22\x85\x1a\xa4\x24\xb6\x32\x6b\x51\x0c\xcc\x2f\x8b\xad\xcf\x57\x17\x69\x58\xfb\xfe\xcd\x1a\x4e\x1b\xee\xb6\xce\x78\x0d\x1c\xb0\x72\x36\xfd\x9c\xba\x5f\x79\x7b\x3f\x32\xc2\x17\xda\xbd\xcd\xf3\x43\x7e\x7b\x93\xee\xda\x75\xd5\x38\xe5\x99\x1b\x7c\x86\x0e\xdc\x81\x1c\xb9\x53\x66\x95\xe9\x2b\xe3\xa2\xef\x7b\x06\x96\xea\x33\x17\x98\x30\x60\xbb\x77\x17\x62\x63\x43\xf3\xd5\x0f\x91\x51\xd8\xf4\x2b\x7a\xc6\xaa\x5c\x54\x9f\x7f\x2d\x0f\x1c\xe9\x1f\x7b\xf8\x5d\xde\x02\xa3\xce\xbe\x36\xd5\xd1\xae\xc2\x63\x91\x3f\xc2\x38\x96\x5a\x7e\x7c\x82\x26\xc4\x65\x13\xf3\x1c\xae\x44\x9d\x96\x39\x71\x57\x93\x32\x52\x2c\x59\x2b\x96\xbd\x13\xb8\x79\x3c\x60\x4f\x77\xef\x41\x9a\x62\x7a\x36\x7c\xb6\x5d\xdc\x3a\x71\xa7\xe4\x5a\xdf\x4f\x17\xf7\x56\xd6\x67\x4d\xf1\xd2\xcc\xa5\x69\x63\xcc\x6b\x4a\xcb\x30\x05\xc0\x3d\x2c\x9e\xfa\x89\xf2\xcc\xd2\x34\xda\x2c\x61\x6d\x22\xd3\x1d\x88\x1a\xa6\xf4\x52\x43\x23\xf8\xdb\x2c\x63\xe1\x0c\x66\xa2\xac\x1a\xca\x5a\x1e\x36\x52\x63\x47\xbd\xc5\xa2\x3a\xba\x29\x11\x1f\x65\x8c\x09\x09\xfd\x9a\xc2\x65\x49\x17\xbd\x16\x1b\xdd\x72\x0f\x36\x2e\xea\x10\xf4\x5a\x3b\x97\xcd\x50\xb0\x2b\x4f\xd3\x29\x88\xd3\x24\x16\x5c\xc1\x77\x49\xa2\x56\xec\xc2\x28\x68\xef\xf6\x60\x7a\xb4\x7b\x25\xcf\x66\x70\xba\xfb\x78\x6c\x09\x7d\xe8\xa5\x1a\x6f\x9f\xd1\x6e\x1b\x72\x0d\xb1\x95\x37\x9a\x25\xd3\xa7\xff\x1c\xb8\x7b\x9e\x1f\xaf\x0d\x9b\x13\xe1\x78\x03\xaa\x6d\xa1\x1d\xa7\x06\xbd\x31\x6f\xd0\x92\xb3\xf4\x69\x83\xf1\x71\x13\xb0\xe4\x20\x12\x4a\xd6\xca\xdc\x4f\x9a\xaf\x27\x56\x21\x89\x99\x22\xb7\x12\xb0\x3d\x89\x24\x15\x0a\x0d\xd1\x97\x34\x84\xc2\xf8\x4b\x53\xba\x2b\xea\x91\xc2\xca\x26\x5a\xda\xdb\x99\x83\x91\x27\xa4\xe6\x86\xa5\x59\x8e\x0e\xe0\xd0\x5e\xdb\x16\xb7\x05\x65\xbe\x05\x02\xcc\xe6\x7e\xff\xff\xf7\x7d\xe2\x96\x2c\x85\xc2\x78\x27\x22\x73\xa3\x6f\xdf\xae\x64\xb1\xc7\xfd\xb1\x1f\xa3\xdf\xbd\x7d\x7b\x2e\x08\xe7\x6b\xe8\xc8\xc8\x54\x4a\x59\x3b\x66\x66\xea\x96\xef\x85\x8e\xd7\x6a\xa7\x4b\x56\x92\xb8\x1c\xbc\x42\xef\x2b\xd1\xf6\x6a\xc5\xdc\x01\x1d\x71\x4d\xae\x57\x4c\xaf\x22\x9b\x1b\x65\xf5\x2f\x9d\xd7\xb6\xbb\xdf\xbb\x59\x66\x99\xfd\x8c\xf4\x78\x77\xa2\x49\xf5\xf2\x3a\x6b\xeb\x91\x49\xeb\xe8\x71\x2e\x86\x87\xc7\xb2\x08\x9c\x64\x4c\x57\x69\x6d\xee\xfc\xb8\xb3\x5d\x1e\x00\xc9\x97\xf5\xc2\xc7\xfb\x5d\x0d\x66\xcf\xe2\xb8\x29\x82\x42\xe1\xea\x7b\x6c\xb2\xd6\xbb\xb7\xc1\x1d\x60\xee\x8c\xb1\xca\x6a\xd6\x7e\xa3\xde\x86\xde\xe9\xaf\x3b\xc4\x81\x3b\x7e\xad\x37\xb1\xc5\x2d\x7a\x41\xc1\xef\xd8\xd7\x58\xc1\x27\xac\xce\x0e\x74\x62\x9f\x8d\xd8\x1c\x83\x57\x4f\xd5\x2e\x98\xcb\x1f\x24\x00\xf4\x06\x47\x53\x30\x52\xc9\xe4\x13\x11\x61\xa1\x11\x23\xe5\x51\xb8\xde\xfe\x08\xfd\x50\xca\x1d\x4f\xc9\x7c\xda\x50\x5b\xaa\x9b\x0c\x86\xe3\xf9\x25\x60\x43\x12\x29\x63\xff\x9a\xc5\xc0\x22\x17\xd6\xcd\xbd\x64\x44\x31\xca\x7f\x78\x70\x5f\x73\x2a\x35\xc5\x61\x63\x3c\x9b\x76\x1f\xfa\xc8\x50\x0b\x1f\xdb\xec\x63\x9b\x71\x60\x7b\x44\x38\x86\x53\x68\x76\x10\x92\xec\x90\x69\x20\xfb\xfa\xce\x57\x03\xd9\x09\xa7\xf3\x77\xfa\x70\x6b\xee\xe0\xe6\x52\x12\x7c\x18\xf6\xbd\x1a\x4f\x9a\x32\x2f\x6e\xd0\x40\x92\x36\x4d\xe1\xb2\x00\xcd\x52\xe8\xd5\xab\x42\x7c\xa9\x10\x98\x5c\x15\x55\x6e\xa1\xa4\x0b\x5e\xc3\x6c\xaf\x73\xdd\xc2\x05\xb4\x3d\x10\x5b\x7b\xac\x97\x1e\xa5\x41\x03\xae\x05\x3f\xb2\xf1\x0c\x7a\x4a\x5f\x10\x52\x36\x02\x04\xad\xfe\x53\x41\x83\xe5\xbf\xe3\x09\xbf\x8c\xfa\x8f\xa0\xb5\xfc\x6f\x98\xa8\xff\x77\x6e\xb6\x96\xfb\x7e\xe1\xe1\x9e\x47\x4b\x0f\x2b\xf7\x28\x75\x68\x4b\xb9\x37\xd9\x03\x01\xfa\xe1\x14\x2c\xb9\x07\x06\x0f\xce\x16\xe7\x48\x81\x0c\xff\xe2\xba\x94\xc7\xf9\xc8\x11\x87\x51\xb8\xdb\x2f\xb0\x9a\x2c\xbf\xa7\xbf\x5a\x8b\xf4\x79\x92\x28\x4e\x5a\xe8\xfd\x8c\xf6\x79\x0a\x88\x8b\xfb\xba\xc9\xa7\xb5\xb3\xe6\xf6\x65\x2b\x75\xce\x68\xad\x43\xbe\x3c\xc6\x2f\xef\x2c\x73\x09\x77\x79\xa8\xbf\x23\xf1\x6a\xd7\xd8\x49\xe7\xf0\xc0\xa6\xe8\xaf\xb5\x9f\x7b\xf1\xd2\x8e\x12\xfe\xb4\xfa\xc9\x2c\xd9\xbf\xf2\x25\xee\xa5\x83\xce\x60\x05\x53\x22\x5b\x3b\xb4\xdd\xfd\x5f\x7e\x60\x1b\x21\x3e\xec\x5d\xfa\xdc\x8e\x13\x2a\xce\xda\x74\x5d\x38\x4a\x99\x75\x1b\xd7\xb7\x0f\xcd\x75\x4f\xc1\x0d\x89\xd5\x0e\xd5\xa1\x48\x3e\x88\x8a\x08\x68\xef\x4c\x6b\x71\x37\x67\xe2\x12\xb8\x52\x32\x16\xf6\x2c\xca\xaa\x91\xba\x18\x5a\x5d\xc6\x7c\xa0\x90\x24\xac\x43\x5a\xa5\xac\xe4\x6d\x0d\xb6\xd6\xee\xf4\xad\xc3\xf2\x71\xa2\x17\x03\x58\x01\xa7\x81\x09\x9c\x4c\x72\x53\xf9\x8f\xdf\x4b\x62\x1f\x9f\xcc\xed\x99\x9e\xfe\x97\x12\xd3\x25\x48\xbe\x89\x85\x2f\xba\xce\xcc\x1a\x77\x8d\x3e\x0f\x47\x9b\x39\xc2\x28\x7c\xf2\x76\xed\x76\x0f\xf3\xa0\x4e\x6e\x4e\x76\x58\x0d\x4e\x0a\xd0\x80\x60\x70\xbb\xd2\xc7\x0e\xc3\x19\xd1\x2b\x03\xc9\x7b\x28\xa4\xbb\x75\x03\x5c\x1f\x9c\x20\x73\x04\x8c\xbb\x51\xc8\xfa\xb3\x70\x0b\x87\x0e\xdd\xa8\x33\xb9\x99\x71\xc5\x5c\x92\xf6\xcd\x9f\x9c\xe8\x24\x12\x19\xd1\xef\xb5\xa7\x8a\x3b\x51\xd8\x53\xc5\x99\x7a\xc1\x0e\x89\x5b\x6a\x6c\x09\x8a\x36\x6e\x98\x20\x06\x38\x85\x44\x54\xe4\x1b\x7d\xb5\xe9\xb9\xe3\x94\xa8\xf6\x50\x8a\x45\x02\x09\x25\x81\xba\x42\x57\xf0\xfe\xaf\xd8\xad\x16\x14\x8e\x59\xab\x1a\x77\x17\x85\xb7\x2e\xc0\xed\x1d\xd1\xe2\xb4\xe5\x89\x21\xa1\x9c\xbd\xa7\x2f\x14\x5e\xb2\x6d\x64\x53\x5a\x7e\x6a\x3d\xb8\x2a\x51\x67\x64\xfd\xe2\xa8\x8e\xd1\x30\x74\xc3\xc6\x1c\xb1\x5d\x86\x9f\x05\x05\xa2\x81\xc3\x71\x16\xc1\x2d\xee\x2e\x50\xa7\x4a\x42\x70\x96\xea\x31\x09\xe0\xd8\xab\xe0\xc4\x61\x74\xff\x6c\x89\x2f\xfa\x83\xf1\x79\xf2\x70\xd7\xf9\x71\xc6\x7b\x7e\xc7\xd1\xf8\x54\x4f\x48\xd3\x05\x8c\xa6\x36\xf7\x04\xd7\xfb\xb4\x1d\x09\x75\x85\x4e\xa2\xff\xa3\x77\x59\xb9\x7c\xc3\xf6\x0a\x41\x98\x56\x72\xcf\xec\x77\x44\x08\x68\x34\x4b\x6b\x96\x16\xa2\xf1\xc1\x2b\x0d\xe1\x2f\xbe\x40\x0d\x40\xd5\xc6\x4f\x1e\x9c\xfb\x07\xfd\x19\x94\xbe\x4a\xfc\xec\x01\x5a\x42\x31\x5b\x87\x3f\x6c\x7b\xf9\x4a\xd5\x8a\xfc\xa3\xad\x1b\x71\xa4\x39\x50\x76\xad\x6f\x00\x59\x36\xc7\x43\x4a\xb0\x82\xba\xb8\x83\xf7\xa9\xfd\xcc\x0e\xd2\xc9\xe7\x24\xb5\xb7\x94\x48\x60\x37\x06\x45\x69\x8d\xaf\xa8\x29\x2a\x65\x4b\xc1\xa3\xd8\x82\x59\x08\x38\x7f\xa9\x97\x7b\x56\xbb\xa2\xab\x29\x62\xa7\xd0\x0c\x70\x4e\x76\x2f\x41\xd9\x25\xe5\x82\x3b\xdd\x75\x1d\x68\x87\x28\x77\xcc\x83\xbc\x6c\x7d\xa2\x2a\xd1\x34\xcb\x79\x7c\x75\x56\x3a\x07\x26\xe0\x2a\x50\x3b\x4c\xf1\x18\x51\xee\x99\xf3\xf3\x67\x2a\x7d\x4f\xbe\xcd\x57\x3b\x13\x78\x54\xbf\x21\xb8\xba\xd8\xf6\x46\x82\x5b\x0c\xa5\xf9\xad\x6f\xe9\x0d\x6c\x95\x88\xbe\x2a\xfa\x1a\xb0\xa7\xb4\xc0\x4b\x06\x01\x95\x84\x4b\x87\xe2\x55\x76\xb6\xdc\xbc\xc6\x8c\xd9\xab\x4e\x59\x34\x9b\x24\x47\x64\x2b\x84\x33\x95\x24\x4b\xc0\x56\x5a\xd1\x18\xbe\x0e\xb8\x46\x26\x11\x46\x75\x52\xf6\xa5\x6a\x2e\x47\x4e\x9b\xac\xdb\x96\xca\x35\xc6\xb4\xca\x08\x72\x65\x19\x13\x76\x76\x16\x9f\x19\x76\xa5\xfc\xfa\x05\xc8\xac\x32\x4d\xfa\xea\x43\x5b\xcc\x29\xcf\x18\x7c\xc8\xdf\x01\x65\x47\x79\x62\x10\x18\xa7\x7b\xf8\x29\xda\xbb\x03\x8e\xbd\x90\x2e\x15\x49\x7b\x6c\xda\x31\xa7\xa6\xfc\xa0\x43\xc0\x06\x97\x65\x85\x73\x5a\xe8\x74\x11\x8d\xc3\x68\xd1\xc6\xc9\xbb\x91\x52\xc3\xa6\x01\x47\x70\xc6\xc3\x15\x37\x3f\xbd\xb8\x28\xa7\x64\xb1\xc6\x57\x84\x5e\x3d\xb7\x0d\x08\x0a\xa0\xc4\xd9\x26\xf5\x66\xf0\x56\x03\xbb\xf1\xcd\x9e\x07\xb7\x69\xcf\x9f\x12\x5c\x1b\xb4\x87\x91\x47\x17\xce\xf5\x9a\x36\x24\xde\x05\xb0\x24\x92\xb8\x75\x50\x3d\x07\x6f\xe7\x75\x38\x37\xbf\xd4\x1e\xbd\xec\x9d\x5b\x9e\x25\x3e\x60\x3c\x15\x0e\x9e\x2e\xf7\xcb\x24\xc7\x4d\x74\xd3\x97\xb6\x42\x29\x47\xaa\x6a\x53\xae\x51\xe3\xe6\xc6\x55\x64\xfc\x60\x8e\xe8\x53\xb6\x22\xb8\xa7\x1f\x33\xb7\x99\x1d\xc9\xbd\x85\x7d\x4d\xd7\xb1\xb3\x54\x0b\x74\x68\x3f\xf4\x17\x37\x9f\xb1\x06\xed\x5d\x9b\xe1\xd0\xf7\x84\xf2\x97\x69\xa2\x45\x48\xe5\x15\x89\x9f\x7a\xc5\x9f\xfd\xe5\x7c\x15\xa7\x2d\x9f\xc1\x19\x14\xd5\x74\x64\x86\xa7\xbf\xdb\x91\x2c\xfd\x3a\xcb\x44\xcf\x07\x9a\x1b\x92\xa9\x16\xd0\x6a\x37\x6c\xc1\xdd\x04\x44\x00\x36\xd9\xa7\x17\x2d\xfc\x86\x8f\x02\xb7\xd4\xc1\x2b\xa7\x7d\x5a\x55\x34\x9f\x5e\xae\xe7\x78\x4f\xb5\xdd\xbc\x9d\x9f\x66\xc5\xfc\xd8\x51\x1e\x48\xf8\x1b\x14\x10\x0b\x8d\xc2\xea\x55\x3b\x22\x49\x7b\xf7\x29\x91\xdc\x31\x85\x04\x8d\x5a\xc0\xb0\xf8\x1a\x2e\xf5\xd8\x17\xc5\x07\xe1\x94\x12\x40\xf3\x88\x9b\x32\xf3\x84\x96\xa9\x62\x03\x2b\x71\xba\x7a\xf3\x56\xf0\x9b\x0b\x81\x73\x5e\xc6\x3e\x9f\x1f\x1e\xaf\x04\x02\x56\x5b\xc5\xb5\xa5\xef\xc5\x2d\x1f\x18\x35\xce\x76\xbe\x80\xa1\xb4\xf1\x5d\xe8\x9a\xae\x96\x97\xda\x63\xa6\xfb\x22\xfc\x8d\x22\x66\x88\xf9\xc4\x5c\xa5\xdf\xac\xaf\xe3\x9c\x3c\x8c\xdb\x8b\x63\x79\x1e\xad\x98\x23\xb6\xc5\x51\x6a\x9f\x36\x64\x72\x7f\x23\x01\xa7\xc8\x91\xb3\x82\xde\x14\x4a\xed\xcb\x34\x6c\x12\x1a\xf2\x4f\x16\x06\xee\xdf\xc6\x28\x79\x0e\x87\x16\xef\x4e\xf5\xcd\x7d\x24\x6d\x8e\x0c\x5b\x9a\x04\x2d\xcb\x7c\xf3\x93\xd4\x88\x2a\xfd\x11\x1d\x94\x53\xf1\x8a\x5c\xf7\xd1\x9c\x8d\xfe\xe8\x87\x89\x40\x12\xff\x0b\xcb\x40\x0a\xdd\xe0\xa4\x08\xa8\x69\x65\x27\x9a\x6d\x82\x9f\x27\x71\x24\x9d\xb4\x12\x73\x27\x42\x03\x9a\x7f\x81\xc6\xe0\xa9\xbb\x41\xa9\xb9\x64\xf3\x29\xf6\xf0\x2e\x06\x88\x2a\x09\xf9\x5f\x79\xb6\x8e\x23\x7a\x5f\x17\x19\xd0\xab\x5f\xee\x0f\xcf\xf1\xf4\x7b\xbd\x13\xea\x5f\x61\xac\x5f\x3d\x2b\xe4\x8a\x92\xd3\x8c\xcf\x9e\x27\x50\xf4\xdc\xba\x77\x0d\x47\xd4\x4a\xee\xd6\x6c\x2e\x8b\xba\xfd\x72\xa8\x71\xfb\x5a\xc8\x76\x1f\x44\x28\x9d\x44\x43\x19\x18\x47\x8f\x26\xe3\x43\xe9\xd8\xb1\xc3\x21\x11\xa1\xf2\x93\xaf\x3d\x92\xc7\xa3\x7a\x34\x85\x82\x8a\x76\x28\xa3\x24\x3b\x03\xbc\x7b\x06\x88\x1b\x32\x1a\x14\x14\x20\x40\x8f\x69\xc7\x98\xfc\x75\xdf\xee\x07\x70\x63\xd2\x45\xc3\x14\xec\x0a\x1a\x09\x68\x68\x00\x09\x73\xe4\xcf\x3e\x0d\x13\x81\xd6\x4c\xb6\x5e\xeb\xa2\x66\xef\xda\xbb\x77\xbe\x0d\x54\x57\xde\x9f\xb6\xff\x07\x52\xd9\x0d\xcc\x2f\x5f\xb9\x49\x1e\xaa\xc4\xa6\xc4\x4d\x27\x42\x7f\x2e\x9e\xb4\xd8\x2c\x50\x9a\x2d\xe8\xfa\x48\xca\x6a\x29\xfd\xfe\x25\x50\x7f\xf9\xbd\xbe\xf4\x44\x70\x32\xdb\xc8\x5e\xed\x5e\x77\x8d\x60\x4b\xd6\xab\x81\x4b\xe8\x03\x50\x61\x3e\xce\xbe\xef\xab\xa5\x6a\xcf\xa8\x67\xea\xf8\x29\xfd\x4b\x53\xfc\xd3\xd9\xbc\x12\xee\x64\x47\x46\x59\x47\xcc\x24\x93\x15\xaa\x95\x15\xf8\x58\x60\x88\x0c\x37\x25\x92\xd2\x80\x63\xb2\x4b\x91\xda\x51\x16\x4f\xb9\x1b\xc1\x8f\x81\x22\x42\xd5\xa1\x1b\x42\x95\x27\xab\xe8\xb6\x5e\x10\x2e\xeb\x60\x22\xf0\x86\x3b\xca\x47\x7f\xa2\x06\xd3\xff\x80\xc8\x6c\x65\xd4\x92\xad\x4f\x5e\x6c\x89\x83\x3a\x99\x51\x19\xa1\x3e\xec\x34\x35\x65\x1b\x16\xf8\x1a\x3d\x5b\x37\x24\x7a\xbd\xa7\x05\x83\xb4\x7f\x0c\xe1\x69\xbf\xe5\x46\xf0\x5c\x2a\x42\xf4\x0e\x14\x27\xc7\x9d\xc6\x41\x96\x0c\x05\x6b\x6f\xde\x02\xb8\x90\xe7\x4d\x46\x63\xbc\xc0\xdd\x10\xbe\x84\x85\xa7\x02\x17\x33\x7c\x80\xd3\xac\x25\x76\xf1\xa2\x3e\x21\xd2\x1c\xb4\xaf\x5d\xd8\xc2\x80\xa5\x9f\xd8\xf6\x89\x27\x21\x09\xf0\x1e\xef\x7d\x3a\x78\x69\x89\x17\x2f\xea\x78\x63\x52\xb1\x5e\x01\x57\xa5\x8b\x49\xab\xf6\x86\xb6\xdf\xe1\x43\xfa\xef\x9b\xa6\xdf\x7a\xe4\xf3\x5f\x60\x7e\x63\xfe\xa2\x9a\x56\xa6\xef\x46\x76\x66\x8f\x5d\x35\x4f\x6e\x14\xfb\xac\x43\x82\xf2\x3f\xc5\xdd\xd2\xb7\xba\x37\xac\x39\xa1\x9f\x27\x5d\xa6\x2f\x67\x7d\xa1\xe7\x82\xd6\x83\x69\x04\x81\xde\x55\x49\xc8\x83\xa9\xae\x4f\x92\x74\x16\xda\xf0\xbe\xad\xcc\x92\x06\xc2\x3f\xcd\xd5\x6b\x8c\xe7\xe7\x17\x02\x3a\xd2\xc8\xd5\xd0\x5b\xf9\xdc\x3e\x54\x53\x69\xc3\xf4\xa1\x10\xa0\x04\x98\x9b\x9c\x1c\x45\x3c\x37\xf7\x1a\x45\x2d\xef\x4e\x09\xd8\x90\x77\x3b\xe7\x6d\x44\x08\x8d\xaf\x75\xd6\xc7\xe4\x5b\xc5\x1d\xea\xca\xc5\xd3\x06\x7a\xc4\x2b\x39\xaa\xc9\x67\x5f\x50\x1a\x4f\x24\x1f\xde\xcb\x55\x59\x4e\x94\x81\x5b\xbb\x23\x6a\xad\xa2\xdc\xfb\x0f\x49\x26\xf5\xc3\xd3\x33\x96\x5c\x65\x34\x6e\x85\xcf\xd7\x11\x85\x29\x1d\x52\x76\x63\x78\xeb\x2f\xf4\x56\xd2\x43\xc4\x3f\xdd\x4b\xf5\x87\x9d\x89\x9b\x67\x7b\x1f\x47\xb9\xfa\x58\xf9\x92\xb2\xb6\x22\x62\x17\xac\xe3\x28\xe3\x36\xce\x0b\xbc\xca\x9b\xbd\x7c\xba\xa9\xf6\xf2\x09\x52\xf0\x72\xd1\x49\x9c\xc9\xe0\x26\xc0\x2d\x4e\xd5\xb1\xdc\xcf\xf9\x2a\xa7\x3f\x8e\x86\x32\x42\x70\x45\x59\x50\x0b\xd1\x17\x5b\x00\xa4\xdd\x2e\xff\xa0\x85\x72\x3f\xfd\x67\x4f\xa3\x01\x68\x92\xbf\x2f\x25\x6c\xe4\xaf\xfd\x52\x4f\xb8\x13\x45\xbc\x0d\xba\x66\x1d\x20\x4e\x3d\x64\x26\xfe\x75\x5f\x71\x62\xc0\x3f\x0c\x58\xc2\xb0\x82\xdc\x13\x66\x04\x3a\xd8\xcc\x4a\x2f\xac\x0b\x93\x7d\x3f\x28\x75\x8b\x36\xbe\x8b\xa3\xcf\x50\x98\x22\xf8\xb3\x4c\x7e\xd7\x69\x56\x2d\xdf\x67\x31\xed\xe8\x59\x42\x1c\x67\x82\x06\x09\x14\x98\x1c\xdc\x18\x14\xfc\x0c\xfe\xec\xa4\x7d\x17\x48\xa4\x4b\x32\xa0\x34\x05\xe9\xb5\x96\x72\x29\x08\xa9\xdb\xa1\xc8\x23\x7c\x74\x69\x08\xeb\x40\x40\xa3\x1d\x86\x4a\xe6\x52\x18\x5b\xc5\x19\xc4\x6b\x0d\x78\xa6\x93\xc9\x0f\xd8\x63\x02\x03\x45\x5e\xf1\xe0\xec\x0e\xf2\x49\x32\xdf\xb8\xb0\x64\x56\x6f\x95\x71\x50\xcd\x1f\x87\xb9\x6b\x5a\x61\x32\xdb\xd7\x48\x82\x2f\x8e\x1b\x3d\x28\xb8\x63\x5b\x6c\x57\x25\x69\xd6\x1b\xb8\x1f\xa3\xb7\x63\x58\x00\x82\x63\x88\x0f\xc1\xa3\x68\x50\xc6\x71\xb7\xd3\xe9\x36\x89\x12\x19\x63\xfc\x4d\xf2\x3f\xbe\x0b\x7d\x1f\x69\x53\x68\x87\x52\x6d\xd0\xe8\x5d\x1e\xf9\xd0\x15\x36\x3b\xf4\xa8\x9f\x96\x8d\xda\x3f\x27\xaf\xac\xf2\x04\x83\x42\x7d\x67\xc5\xd9\x4d\xab\x6d\xf4\xee\xc7\x9e\xeb\xec\xcb\x43\x6a\x2c\x76\xb4\x9c\xcf\xd4\xb1\xaf\xa0\x3e\x89\xfa\xa7\x0f\x97\x47\xf0\xc0\x16\x7f\x92\x2b\x7a\x59\x6c\x3f\x47\xe8\xdc\xa6\x2a\x7b\x82\xb1\x12\x2e\xec\x6d\x37\xe4\x41\xc7\x54\xaa\x5e\x31\x44\xe5\x22\xa5\x3b\x52\x8e\x55\x72\xf0\xa0\x10\x84\x22\x62\x68\xf8\xa6\x0e\x6c\x71\x77\x24\x92\xb1\xd4\x2f\x67\x79\xbe\x52\xbf\x6d\x5a\x70\x87\x25\x14\x8b\x30\x42\xce\x15\xcf\x9d\x23\x34\xff\x62\xc1\xe8\xe8\x5c\x71\x30\x6e\xed\x08\x09\xee\x4e\x5d\x4d\x89\x3c\xbe\x71\xeb\x88\xce\x4e\x97\xd4\xf5\x7b\xd4\x88\x86\xcd\x68\xcc\x40\xfe\xfc\x31\x3f\xbb\xdb\x7e\x8b\x74\xf9\xf2\xc0\xea\xc2\x36\xcd\x9c\xd8\xda\xc1\x54\x9d\xb8\x6b\xa7\x8e\xd5\xcc\x86\x0f\x1e\xd2\x99\x19\x0f\xd2\x87\xfb\x5c\x4d\x08\x00\xe5\x7c\xc0\x74\x20\x10\xd3\x35\x4f\x3c\x34\x3e\x20\x4a\x0e\xe7\x7d\xbe\xde\x19\x2c\xff\x51\x1d\x72\x51\x2a\xcd\xaf\xf6\x9b\x41\x5c\x15\x27\xf5\x29\x79\x05\x7a\xd4\x27\x86\x1d\x13\x4b\x64\xd8\xae\x06\x44\x8d\xf6\x57\x64\x69\xbc\x40\x67\x7a\x75\x27\x31\x5c\x15\x7d\xbb\x5e\x71\xc1\xe7\xcf\x49\x3c\x06\x3e\x65\x5e\xd6\x68\x29\xc8\x51\x2a\x1e\xb9\xf4\x14\x6c\x7a\xad\x7f\x42\x80\x6c\x3f\x0b\x67\xdc\xf9\xb2\x01\xd4\xf7\x8a\x8b\xca\x03\xcd\x47\xd6\xee\x5a\x9b\x1a\x1a\x82\xbe\x30\x60\x12\xb3\x07\xe5\x7e\xfb\xdd\x07\xea\x93\x39\xa3\x3c\x21\x3a\x04\x95\x88\xce\x2b\x92\xa9\x78\xdb\xa3\x22\x22\x70\xaa\x5b\x85\x57\xc5\x7d\xf7\x8f\x15\x22\xe2\x59\x7c\xca\x92\x91\xaa\x3e\xf7\x2f\x69\x65\x2b\x55\xb6\x72\xaf\x1f\x57\x97\xe9\xd1\x57\x73\x36\x0a\x94\x67\xed\x2a\x9d\x44\x7d\xec\x7a\x81\x79\x6e\x2b\xe1\x88\x85\x77\x55\xd3\x8b\xd6\x89\xeb\xcd\x66\xa9\x14\x0f\x47\xbf\x03\x25\x21\xa9\xbb\x88\x4c\x5b\x23\xfe\x83\x22\xd1\x68\x32\x99\x66\x6d\x68\xff\xd2\x7c\x46\x71\x62\x7d\x2a\x95\x48\x88\x08\xa9\x23\x7a\x9c\xb4\xb1\x1f\x6e\x56\xcb\xb4\x80\x99\x5d\xf6\x78\x41\x20\x98\x31\x8d\xae\xa2\xa5\x6d\x01\xb7\xa9\x1f\x6b\xb1\x0a\x09\xd7\x82\x56\x12\x10\x7c\x3d\x08\xc4\x40\xbb\x3d\x85\xc1\x4f\x42\x07\xb0\x7a\xc6\x50\xbc\x64\xf3\xc0\xc9\x35\x56\x72\x6c\x24\x00\xbd\xa1\xd1\x5a\xd5\x84\x38\x90\xbb\x83\xb4\x38\x5e\xcf\x8f\x98\x71\x70\x28\x3a\x41\x36\x4a\x35\x50\x59\x32\x09\x09\xc3\xa8\x56\x1e\x99\xb5\x0e\x27\x47\x94\x89\xce\xcc\x70\x65\xe6\xe1\x9d\xad\x5c\xb6\xaa\x68\x6a\x93\x16\x1f\x1d\x0e\xa2\xd2\x70\xa1\x31\x61\x84\x8e\xca\x77\xc5\xca\x93\x53\xb9\x41\x03\x08\x24\x13\xd3\x7c\xbd\x48\xc1\xf5\x45\x23\x37\xd1\x87\xd5\xd2\xe0\xb4\xdc\x7c\xfe\xd0\x70\xb2\xde\x1c\x2a\xea\xca\xc4\x0a\x9b\x07\x60\xe5\x44\x5d\x5a\xf3\x94\x8c\x42\x2d\x92\x80\x5c\x36\xcb\x13\x69\x57\x0f\x78\xcc\x88\x47\x8d\x04\xfa\x90\xfa\xfe\xef\x0e\x47\x47\x92\x10\xa0\xd7\xae\x7e\x8d\x59\xba\x4a\xa9\xbe\x54\x37\x4d\x71\x5e\xc2\xe8\xba\x23\x82\x30\x81\xa7\xe4\xd8\xc3\xb5\x71\x87\xbe\x04\x1a\xf3\xd7\xcb\xea\x62\x8b\x30\x9a\x4b\x56\x6f\x74\xf1\x5b\x0d\x8a\x19\xd5\x96\x6d\x11\x0e\x5e\xe7\x6b\x20\x17\x6b\xb4\xba\x2d\x64\xcb\x70\xda\xdd\x9f\x7f\xff\xaf\x5e\x0c\x4a\xf4\xdd\x64\xf6\x33\xa2\xc7\xdd\x95\x46\x1a\x13\x8f\x46\xcf\x54\xe6\xcf\xba\xdb\x97\x9d\x39\x6f\x93\x5c\x53\xe3\x02\x38\xe7\x03\x19\xd1\x71\x6b\x10\xea\x22\x81\x02\xcf\x83\x78\x4c\x5f\x3a\xaf\xf8\x1c\x50\x9c\x8a\x4c\x68\xc0\xa5\x30\x21\xdc\xde\x69\xcb\x8c\x0e\xd4\x17\x7b\xe8\xe8\x38\x1b\xb5\x3a\xb9\x9e\xf3\x7a\x45\x0d\x04\x20\x18\xae\x4f\x79\xfa\xab\x8b\x2f\xd0\x98\xe0\x6c\x0d\x2c\x29\xf3\xb4\x47\xbe\x86\xf2\xe7\x8d\xc5\x71\xce\xf2\x51\xb6\x14\x98\x1b\x52\x19\xf3\x0e\x60\x81\xb0\x5c\x15\x0b\x4a\xf9\x3e\x5b\x8b\x1b\x00\x94\xa6\xa1\x69\x70\x26\xd5\x80\x40\xa1\xac\xf1\xad\x1a\xae\xb1\x0d\xae\xa9\x00\x24\xaf\x89\x05\x3a\xc1\x10\x51\x38\xb2\xa2\xa0\x42\x74\x3a\x40\x60\x7b\x3e\xbc\xa7\x85\x16\x27\xfb\x61\xe7\xde\x9d\x75\x39\x07\xe7\xe9\xfe\xf7\x39\x10\xf0\x9e\x27\xa0\x01\x08\xa9\x4c\x1e\x12\xf9\x63\xd0\xb8\xca\xc4\x91\x48\x68\x91\xf4\x64\xcd\x9e\xf2\x87\xeb\xe1\x59\x47\x8f\x66\x99\xa9\x01\x04\xb6\xab\xc1\x12\xd6\xdf\x2f\x9f\x09\x4e\xe6\x02\x3d\xf0\xf8\x53\x66\xbb\x30\x54\xab\x3b\x57\x4a\x26\xc3\x20\xc6\x49\x9c\x0b\x32\xb8\xb4\xf2\xfa\x02\xec\x33\x31\x91\x00\xdb\x6b\xc3\x89\x72\x60\xc8\xd4\x7d\xb2\x92\x41\xcc\xb6\xae\xfc\x99\xbe\xab\x13\x81\x83\xd4\xfc\xeb\x64\x08\x84\xbc\x94\x40\x1d\x0c\x5c\x71\x2d\x10\x9e\x39\x28\xd6\x42\xec\xac\x2c\x76\x11\xd1\xa3\xad\x12\x41\x4c\x58\xc2\x71\xaa\x48\x5b\xa9\x21\xc9\x66\xe4\x85\x2d\x74\x7c\xf8\xef\x9f\xd9\x04\x89\x6e\xb9\x50\xce\xa4\x52\x03\x5e\xb0\x62\xc2\xec\xd5\xf8\xc3\x47\x4f\x9f\x66\x85\x00\x3d\x2b\xa5\x8c\xa4\xe5\x68\xfe\xb4\xb0\x57\xf0\x44\x3b\x4b\x66\xde\x78\x31\x82\xc8\x5e\x17\x0b\x55\xab\x5d\x92\x33\xa0\x40\x6a\xfc\x4b\x38\x7b\x56\xdb\x2e\x20\x22\x6b\x35\x02\x81\x0f\x1d\x11\xb0\xd1\xfe\x68\xa5\x47\xc2\xbe\xb5\x70\x43\xe9\xb9\x92\xb3\x2a\xf9\x36\x04\x06\x69\xaa\xd3\x53\x2b\xd0\xbf\xb8\x75\x34\x34\x39\x35\xea\x64\x6a\x90\x2b\x0c\x86\x9d\x4b\x6b\xb9\xd2\x4e\x71\xe9\x42\xa5\x19\x02\x05\x94\x4d\xf0\x88\x13\x0e\x2b\x2b\x3f\x7b\x07\xc6\x32\x13\x4d\x83\x9b\x4e\x4a\x7f\x56\xf1\x75\x10\xfc\x39\x30\xd1\x24\x23\x64\x56\x9c\x2f\xd5\x2c\x29\x91\xcf\x0d\x41\x6b\x30\x94\xc6\x82\x5e\x1b\x8c\x87\x81\xf9\x46\x1c\x94\xdf\x9b\xcd\x05\xc0\xdc\xdc\x6e\xb1\x02\x8b\xf7\xfb\xba\x94\x3c\x25\xa2\x11\x9c\x4a\xad\xc0\x9c\xf7\x8c\x76\x71\x00\x24\x9c\x9b\xea\x1e\x9f\xc9\xe8\xaf\x64\x09\x40\xe4\x77\x77\xf5\xb8\x3f\x9d\x04\xe5\x52\xc0\xfd\x18\x73\x90\x0a\x44\x31\xab\x46\x13\x2d\xa0\x5f\xf1\x45\x31\x7d\xfd\x7a\x63\xe3\x91\x16\xc6\x9d\x5a\x8c\x19\x68\xd0\xf4\x5b\xdc\x11\x1e\x07\x94\xc6\xcf\x24\xc3\xfd\x9d\x26\x05\x00\x44\x57\x78\x18\x26\x66\x65\xc5\x25\xe9\xed\x20\x7e\x29\x09\x7e\x8e\x12\x83\x58\x4c\xb7\x74\xcb\x9b\xdd\xd2\x85\x96\x8e\x4a\x06\x4b\xdd\x2f\x2f\x28\x97\x46\x5b\x0c\x98\x4b\x59\x3d\x3b\xca\x1f\xca\xd8\x95\x62\xff\xfa\x97\x83\x7e\x24\x56\x64\xb8\x5d\x9a\xa2\x38\xda\xdc\x7c\xd4\xf7\x1a\x02\x81\x62\x4a\xd3\x16\x29\x3a\x76\x20\xff\xfa\xa3\x18\x33\x52\x86\x52\x97\x51\xb4\x8f\x04\x7d\xcb\xba\xe4\x7f\x4f\xed\x0c\xd6\x09\x6b\x06\xc5\x55\x50\xc4\xc1\x8b\x7d\xb3\x9f\x53\x56\x95\xaf\xfd\x0c\xcc\x7f\x78\x7f\x73\x00\x51\xca\x72\x6f\xaf\xb1\x9f\x33\x1e\xa3\xff\x7a\xe7\x90\x32\x89\x46\x10\xa4\x8c\xd2\xfa\x27\xd6\xaf\xa3\xd8\xdd\x6e\x4e\x3f\xf0\x1e\xd7\x7b\x22\x5d\xf5\x31\x16\x42\x2b\x1f\xc4\xd5\xb5\xa5\x0d\xe3\xb0\x3b\x2a\xab\x0a\x8a\xed\xd1\x65\x4f\x5d\xc2\xdd\xd6\x2d\xce\xd2\x4e\x7e\xb5\xbf\xf8\x32\xf5\xcc\x9c\xf2\xa3\x75\x25\x6c\xc5\x28\x5a\xbe\xad\xbb\xa3\x9d\x62\x7f\xa1\x39\x4d\x99\x68\x5d\x5a\x1f\x0e\x33\x27\x29\xa2\x14\x39\xa0\x23\x87\x3e\xcc\x2a\xd7\x03\x3c\x63\x8c\x3b\xda\x1c\xd4\x9a\x7d\x6c\x3e\xe2\xa7\xfb\x25\xfb\x29\xb7\x56\x60\x10\x6c\x65\x59\x17\xee\x2e\x35\x2a\xd0\x0f\xd9\x0f\xa5\x44\x7e\xea\x2d\x0c\x89\xf6\x07\x64\x35\x4a\xe1\xc6\x5a\xf5\x21\x51\x03\xb5\xb9\xd3\xa6\xa7\x5e\x66\x01\x50\x80\xa3\x2f\x66\x6a\xbe\x0b\x81\x54\xca\x58\x91\x12\xa2\x04\x58\x26\x28\x66\x21\x08\x88\xc3\x9d\x5e\x13\xf2\x98\x67\x2f\x6a\x3c\x09\xb3\x2f\xda\xc7\xeb\xa5\x83\x53\x27\x4a\xd6\x93\x35\xe1\x56\x5e\x09\xfe\x95\xfa\xdf\x9f\xbf\x9e\x5e\xc4\x19\x6d\xbc\x7b\xa0\x8f\x06\x32\xbe\xac\x3b\xa2\xa5\x0d\x30\x69\x37\x04\x24\x01\xe0\x0f\x07\x16\x26\xe2\xa9\xb5\xfe\xd3\xb5\x8e\x8d\x8d\xab\x8f\x58\x45\x4f\x53\xe8\x1f\xc0\x78\xc6\x35\x0e\x1e\xc7\xb1\xbd\xd9\x8a\x74\x22\x8e\x15\x68\xaa\x11\x88\x76\xe7\xaf\x5f\x43\xda\x16\x83\xe5\x53\x95\x9b\xbd\x7e\x41\x24\xba\x3c\x86\x40\x0b\xd1\x01\xbc\xe5\x1e\x66\x8a\x5c\x3b\x53\xcc\x61\x8c\x29\x9a\xa6\x36\x43\xd1\xd1\x5f\x9d\xde\xdf\xce\x8a\x0c\x67\x30\x28\x34\x69\x2d\x6b\xc2\x13\x3c\x05\x0a\x23\x35\x74\x8b\x5c\x43\x43\xa3\xab\x19\x68\xf5\x3e\x0c\x3b\x8f\x21\x60\xb6\x08\x90\xa9\xa8\x0b\x20\x33\xaa\xf3\x2d\xd7\x00\x05\x36\x95\x68\x74\x0f\x89\x44\x5d\x1b\xe9\x53\xb0\x65\x4e\x87\xa8\xea\xeb\x0d\x8d\x7d\x83\x7d\x8d\x8d\x8b\xa8\xe6\x22\xad\xde\xce\xcf\x13\x23\x51\x6e\x93\xb7\xb2\x16\xba\x60\x46\x3a\x9f\xc3\x19\x10\x04\x3e\x15\xa1\x37\x39\x24\x6c\x56\xda\xcc\x65\x7e\xcc\xcb\xc7\xcc\x88\x16\x4a\x10\x61\xfa\x25\x93\x89\x71\x7e\xd6\xdc\xa3\xb3\xcb\xb4\xaf\xa7\x5e\x0f\x6c\x87\x43\xb1\xf4\xb3\x03\x0d\x66\x2b\x2f\x0e\xae\x0b\xb9\xfe\xe1\xb4\x65\x42\x61\xbb\xe8\x13\x3c\xed\xba\x27\xb4\x20\x5c\x2a\x00\x46\xf3\x99\x43\xdb\x3b\xad\x8d\x7c\x1c\x84\x63\x0d\xb7\x86\xda\x80\x98\x4e\xba\x7f\xf6\x66\xbe\x21\xe0\xff\xf9\x4c\x32\x69\x7e\x81\x3c\x5b\x0d\xc5\xd8\xc5\xed\x70\xeb\x84\x08\x26\x9a\xd1\x95\x41\xbe\x6b\x6e\xee\x6e\xba\x90\x72\xbe\xed\x8b\xa7\xfd\xec\xe9\x1b\x6e\x26\xbb\x66\x17\x7f\x76\x1c\x6e\x6a\x6e\x94\x2d\xcd\xe8\x32\x1f\xdc\x35\x28\x21\xec\xd1\xf2\xa2\xf4\xd5\xdd\xc4\x72\x43\x7e\x87\xe4\x8a\x44\x04\xb2\x97\xcd\x22\x60\x5c\x54\x9f\x27\x6a\x09\xbe\xcc\x50\x60\x92\x30\x69\x1a\xdc\x4f\xcd\x9a\xe7\x9d\x46\xec\x6b\x72\x66\xed\x75\xc9\x99\xf7\xa2\xda\xa9\x6a\x5c\x27\xaf\x1e\x33\x83\x21\x42\xba\x49\x45\x6c\xdf\x51\x3f\xa6\xf3\x6d\x31\x32\x3c\x54\xbf\xa7\xf3\x12\x52\xe7\xa4\xa5\x7c\xc0\x58\x7d\xdf\xf5\xe7\x0b\xef\x76\x85\xab\x66\xe9\x2a\xb7\x3f\x5f\x88\x4b\x7c\x49\x59\xf5\xde\xc4\xfb\xa3\x92\x85\x7b\xbd\x25\x6d\x60\x2a\x10\x35\xdc\x44\xbb\xa4\xd1\x60\x8c\x87\x4e\x81\x9f\x39\x24\x23\x93\x63\xbd\x87\xa4\x0c\xd8\x14\xa0\x05\x18\x7a\xe1\x4b\x8b\xca\xcf\x17\x84\x74\xb1\xd8\x80\x1f\x0b\x64\x82\xba\x6b\xd8\x81\xdd\x37\xf3\x07\xec\x5b\x83\x33\xa8\x03\x7a\xa2\x19\xdc\x90\x2c\x9e\xa6\xc1\xbd\x62\x3c\xf7\x1a\x7c\x53\x3c\x97\x7e\xd8\xba\x2d\x56\x45\x89\x6c\x0f\xcc\xa4\xaa\x02\xed\x69\x41\x40\x4f\x5b\xb6\xd8\x2e\x35\x3e\xc4\x70\x51\xf5\xa5\xa5\xe2\x65\x8b\x3e\x96\xe1\x52\xc7\x77\xe7\xd8\xaa\x44\xe7\x2e\xdb\x8b\xd0\xde\xe4\x0d\x58\x4e\x23\xb1\x27\x4e\xa2\xa4\xca\x6a\x6a\x01\xa2\x91\xd0\xbe\x34\x17\xd5\x21\x06\x99\xb1\x74\x4b\x5f\xbd\xe2\x93\xcb\x66\xa5\x52\x80\xc0\x21\x40\xe6\xa3\xbc\x43\x12\x94\x4a\x2d\xa8\x12\x6a\x61\xc9\x1e\x48\x2a\xf6\xcd\x0c\xe3\xfb\x8d\x81\x9d\x4e\xee\xcb\x70\xb4\x40\x77\x97\x56\xb4\x5b\x3b\xbb\xdd\x0d\xdd\xea\xe2\x9e\x84\x73\xec\x71\xc2\xe5\xd1\x48\x8a\xa4\x6c\x81\xb6\xda\x9c\x41\xbb\x3f\xd4\xfe\x79\xad\x09\x22\xba\x6a\xfd\x21\x80\xe4\x84\xd6\x3c\x7f\xdc\x55\xb4\x3f\xdd\x68\xbd\xe5\xc0\xe5\x7f\xa6\x6b\xe1\xa7\x31\xb1\xa6\x6f\x61\xde\xbb\xf8\xdb\xd6\x65\xe9\xfd\x38\x53\x80\x9c\x31\xf7\xd0\x9d\xe4\x8b\x84\xb6\x04\x8c\x21\xd3\xf3\xba\xe2\x39\x93\x68\x85\xd8\x49\x0d\x18\x87\xd6\x42\x8e\xeb\x0a\x07\x11\x39\x4b\xab\x6f\x5f\x28\x00\x5b\x01\x66\x19\x30\xb7\xb8\x88\x6f\x21\xfc\x0b\x85\x92\xf9\x33\x31\x1d\x9e\x43\xb7\xbe\xc1\x3b\x58\x0e\x96\x49\x68\x24\xa5\xc9\x80\xe7\xa6\xb9\x40\x84\xc5\x40\x30\x57\x6c\x0d\x1f\xdd\x11\x5d\x86\x26\x29\x73\x36\xf0\xe0\xa8\x34\x77\xf1\xa4\x59\x90\x33\x63\x2e\xfc\xe3\x4d\x02\x67\x0b\x5e\xbc\x14\xc8\x31\xd2\xc7\xe9\xb9\x4f\xb3\x71\x73\x23\x4d\x73\xf1\x82\x33\x5a\x4e\x4c\x4d\x69\xf6\x7d\xf0\xf0\xc6\x0d\xa1\x39\x8d\x7f\x55\x82\x7e\x87\xe8\xb3\x78\x7e\x7b\x16\xae\x24\x36\xba\x08\x9c\xa8\x03\x46\xd5\xc9\xac\x51\xaf\x45\x69\xee\x32\x57\x76\x86\x59\x14\x46\xa6\x0c\x41\xdb\xe7\x9e\x56\x10\x6c\xa8\x0b\x14\xb8\x06\xed\xd6\xe4\x04\x56\x44\x58\x65\x72\xe2\x28\xb4\xc0\xb0\x5a\xba\x65\x9e\x92\xeb\xcd\xb0\x90\x16\x33\x29\xdb\xca\x5c\x74\x00\x1a\x8a\xf9\x35\x5c\x5e\xe1\x22\x72\xf2\x19\xd0\xa8\xe7\x73\xb3\x0a\xdc\x77\xee\x1d\x50\xe4\x35\x8e\xaa\x66\x37\xa1\x4e\xdf\x4b\x24\x66\xb3\xc8\x5e\x71\x7b\xb0\x22\x4c\x8d\x9d\xdc\x5d\xaf\x88\x19\x7a\x60\x40\xf8\x95\x44\x51\x68\x97\xcc\x04\xe6\x36\x66\xb2\x9d\x16\x95\x1c\x7e\x68\xab\x47\xa9\x35\xc6\x75\x55\x04\x37\x47\xe4\xf0\xed\xeb\xb8\xc4\x15\x7e\xf7\x0a\xc1\xb8\xe3\xf5\x2e\x88\x23\x33\xf1\x50\x13\x0b\x8e\xfa\x54\x56\xca\x21\xbc\x1f\x6e\x7f\xac\xaf\xef\xda\x98\x05\x50\x66\x36\xa0\xd5\x89\x3e\x6c\xdb\x36\x09\x39\x40\xdd\xd2\x96\xf7\xa6\x99\x1e\x8f\xa5\x02\xe0\x35\xcf\x9a\x36\x32\xf2\xf9\x74\x40\x37\x0a\x9e\xe1\x4c\x8e\xce\x32\x09\x1d\xf6\xd7\x17\x20\x74\xfc\xf5\xed\x27\xd4\xaf\xc0\x62\x48\xca\xe4\xef\xd4\xbc\x01\x88\x77\x12\xcb\xe6\x57\x66\xf2\xf1\xb7\xc9\x8a\x37\x3d\xcc\xdb\xfc\x2e\x3d\x62\x78\x0d\x25\x05\x64\x3f\x0d\xba\x7f\xc1\xee\x8d\x61\xb3\xca\xcb\x20\x92\x39\xe0\x65\xff\x70\x90\xa7\x8b\xbd\x48\x8f\xd2\xa9\x0c\x4b\xc8\xe5\xf7\x5c\xf0\x90\xc5\xdb\x8f\xfb\x9d\x84\x9e\x84\x8c\x24\xa0\xb0\x98\xe3\x9b\x43\x25\x96\x30\xa8\x96\x1c\xc1\xe6\x0d\xc9\xc6\xca\x05\xe6\x83\x01\x9d\xdd\x6e\x74\x76\xa3\xbc\x3a\x80\xb5\x4d\xc8\x60\xe1\xb3\x91\x42\x84\x8d\xdb\x61\x73\x70\x93\x26\x0b\x29\x02\x22\x2d\x12\x71\x63\x83\xa3\xaa\x09\x9b\x93\x40\xa9\x49\xe2\xc7\xe8\xf3\x62\x6b\xdc\xd9\x14\xb9\x9d\xa9\xcc\x05\x33\x65\x50\x9c\x16\x46\x38\xdd\x01\x89\x5a\x6d\x55\x4c\x28\xd9\x11\x28\x71\x50\x30\x35\xbf\x19\x6e\x19\x27\xbc\xa5\xc1\x43\xf8\xc7\xc2\x56\x89\xb5\x8a\x69\xc0\xb5\xaa\x9b\xda\x12\x93\xa1\x8e\x6a\x95\xd0\xf0\xc9\xbf\x04\x58\x3f\x71\xe9\x67\x5e\x3a\xd3\x9b\xc0\x5b\x5b\x50\xb0\x56\x38\xa9\x9c\x19\xb2\x0b\xa1\x9f\x36\xa4\x00\xda\x3d\x49\xc9\x89\x28\x08\xb5\x63\x06\xcd\x47\x96\x9a\x15\xdb\x40\xa9\x15\x17\xbd\xe0\x4c\x62\x21\x6c\xb7\x6c\x05\xdc\xc6\x38\xdf\xac\x4d\x76\xda\xf9\xfa\x9d\x76\x56\x62\xf5\x71\xdf\x7e\x15\xdc\xd2\x12\x2f\xa4\xda\xcd\x25\xc7\x49\x69\x1f\x88\x85\xc0\xb6\xd2\x82\xcf\xa1\xd6\xa3\x54\xf3\x9d\x3d\xfa\x21\x42\xb3\x83\x04\x50\x06\x53\x06\x3a\xa6\x6d\x9d\x75\xac\x76\x8b\xd0\x04\x05\x50\x04\x9f\xc8\x73\xcf\xcf\xa5\xef\x3b\xa7\xbf\x17\xa6\xcf\x5a\x04\x7c\x73\x2c\x16\x47\x85\x0f\xcb\x3a\xe0\xc6\x70\x48\xf6\x8a\xaf\x67\xd9\xe9\x56\x15\x75\x80\xa3\x17\x5a\x08\x52\x3e\x66\xe6\xcc\x40\x9d\xe2\x00\x65\x14\xe2\x8b\xae\x40\x46\xc3\x3c\x36\xe3\xcd\xb2\xe0\x2e\x1d\x05\x93\xba\x4c\x81\x0d\xd6\x10\x2f\x81\x29\x93\x58\x94\x0b\x04\x33\x22\x4c\x4e\x3e\x94\x5e\x82\x6d\x0b\xd4\x14\x98\x77\x27\xd6\xc1\xe5\x15\x95\xa9\x3e\xdb\xfa\xd4\x1b\x5c\xe3\x43\x3c\xeb\xf1\x85\x43\xfd\x4b\x62\x60\x9e\x28\x2e\xf6\xee\x75\xd6\xc1\xd6\xb0\x9a\x81\xa5\xd6\x54\x9e\x18\x27\xc8\x20\x82\x6f\xef\xd5\x06\xf3\x4d\x47\xf4\x98\x7b\x1d\x78\xb8\x24\x0a\x76\x06\xac\x1b\xfa\x39\xef\x0a\xab\x7c\xe8\x9e\x46\xb0\x8d\xc9\x78\xca\xca\x80\x61\x10\x40\x51\x49\xdb\xd6\xa7\xf3\x27\xed\x7f\x3d\xcf\x7a\x7c\x51\xf9\x6f\xd8\xfc\x5e\x42\xec\x66\xd3\xff\xa2\x2c\xb3\x5a\x66\xfa\x57\xfa\x01\x34\xe6\xa9\x23\x9d\x08\x07\x34\x93\xce\x79\x81\x49\xac\x07\x95\x98\x39\x23\xdb\xf4\x35\x0c\x0e\x5a\xda\xad\x0e\x45\x0c\xa7\xd9\xe6\xc0\x32\x1d\x07\xe2\xb7\x70\x93\x27\xc6\xdb\x16\x42\x87\xa4\x7e\xbb\xa5\xf6\x55\xb8\x6a\x7d\x15\x1a\xdb\xa3\x10\x57\x77\x45\xfd\x60\xee\x09\x0d\x11\x6d\xf7\x27\x3f\xe8\x16\x21\xac\x40\x20\x00\x80\x83\x43\x20\x32\x43\xd9\x1e\xf9\xd1\x00\x70\x63\xad\xc4\x08\x6c\x13\xdd\xbb\x4f\xc5\xa1\xd8\x1f\x7b\x28\xbe\x43\x32\x0e\xc9\xe0\x6b\x43\x89\x83\xf1\xd1\x6b\x81\xf6\x27\x8c\x55\x98\x22\xae\x16\xe9\x43\x3f\x08\xbf\x0c\x54\xf2\x51\x5e\x90\xee\x0c\xda\x9d\xb8\xa4\x6b\x4b\xf1\xe6\x6d\xc5\x33\xce\xe9\x6d\xec\xea\x24\xba\xdb\x9d\x16\x81\x00\x8e\x1f\xcd\xae\xb0\xb4\x5d\xe0\x3c\x69\x28\x00\x51\x26\x77\x6c\x64\x6d\x59\xdd\x31\x9f\x20\x0f\x73\xbb\xe8\x33\xec\x95\x68\x4f\x01\x4a\xa6\xa5\xff\xf1\x3a\x9c\x4e\x89\x49\xa2\x95\x37\x4e\xc1\xd8\x24\xa9\x7a\x16\xda\xb8\xba\xf4\x0b\x23\x23\x1c\x04\x6f\x74\x34\x7a\xcf\x8a\xb9\x70\xe3\xe4\xe9\xa9\x9a\x9c\x30\x8f\xa4\x6b\xfe\x78\xe5\x0c\xc8\xac\x55\xaa\xb7\xb6\x18\xcf\xc3\x9c\x46\x7e\x3a\x28\x7c\xb6\x42\xb9\x8e\xfc\x94\xcb\x6e\xe9\xe9\x6d\xc6\x09\x60\x4e\x0b\x2d\xab\x95\x8f\x64\xcd\xfe\x6c\x9d\x9d\x39\xa3\x2f\x19\x5c\x54\xcc\x26\x31\x89\xcc\xc2\x03\xbe\x17\x01\x39\x9b\x56\x3c\x76\x6e\x1f\x06\x03\xb7\x3a\x7d\x3b\x42\x2b\xd7\x87\x0e\x64\xde\x53\x8e\x5c\x48\xa0\x11\xda\x08\x0c\xc9\x6c\x35\x14\xed\x20\x6a\x8b\xa8\xa6\x66\x65\x5f\x88\x8c\xd6\xe9\xe6\x4e\xcc\x81\x61\xc4\x38\xbf\x82\x7c\x7c\x67\xf5\x80\xc0\x78\xcc\xd4\x57\x46\x8c\x69\xf0\xc8\x25\x11\x43\xcf\x46\x01\x23\xed\xf6\x4d\x6b\xa7\x8c\x31\x97\xe8\xf4\xb1\x11\x06\x9e\x77\x4a\x25\x22\x83\x11\x5c\xd3\xbe\x37\xc5\xdb\xc3\x17\xa4\x52\x0d\x18\x19\xeb\xdc\x36\xbd\x3b\x94\x7b\x3c\xb1\x55\x4b\x91\x39\x60\xdc\x3b\x24\xea\xd1\xbe\xb5\x3c\xe1\xbb\x7b\x62\xf1\x61\x2a\x4d\x77\x66\xd4\xb1\xba\xb3\xa8\x4f\x5f\xee\x67\xa8\x32\xc3\x0f\x0e\xf9\x45\x17\x06\x6a\x89\x5d\x56\x11\x16\x01\xe4\xd7\x34\xf2\x58\x95\x0c\x2a\x8f\xe9\x67\xef\x53\x30\x8c\x4b\xf7\xbc\x88\x63\xfe\xeb\x8e\x41\xa4\x81\x54\x1a\xed\x50\xf9\xdd\x8f\xb8\x60\x7e\x8f\x65\x3f\xa1\x16\x46\xfa\x5b\xbe\xba\x6e\xba\x6a\x58\xcc\x6e\xd8\xb1\xdb\x55\x94\x95\x35\x5a\x20\x1b\x1a\xbc\x22\xa0\x92\x0e\x70\x88\x73\x73\x99\xb4\xd6\x34\x31\xd8\x40\xb7\x84\xcf\x01\x06\x94\xd6\x10\x47\x69\xc0\x3c\x4a\xdb\xc4\x3c\x7b\xa6\xc9\x7a\xd3\xe5\x01\x9f\x0e\x0b\xde\xa2\x4d\xd6\x7d\xa0\x0c\x61\x9b\xcf\x21\x42\x65\x3a\xe1\xdc\x8d\x6f\xb9\x60\x2d\x93\x43\x5c\xd8\x2e\x79\x6b\xac\x1a\xfe\x24\x03\xf6\xec\x82\x65\x78\xc7\xb3\x80\x4e\xf0\x48\x95\x01\x1e\xd2\xe8\x90\x28\x81\xcb\xc8\x5f\x8c\xa3\xbd\x9d\x01\x21\xcb\x4b\x46\xb3\xab\xd7\x08\x6f\x74\x76\x57\xd5\xd8\x77\x2d\xe5\xc4\x73\xb4\x4c\x00\xd2\x3e\x89\xcc\x5d\x39\x62\xf3\xb0\x09\x88\x4a\x6e\x12\x99\x29\x73\x6e\x9c\x74\x5f\xf2\xf2\x19\xeb\x5f\x0f\x78\x45\x4b\xad\x94\x44\x94\x06\x20\xa5\xbc\x42\x09\x99\x24\x67\x59\x98\x41\xbf\x56\x3e\x1f\x67\x24\x95\x25\x4c\xd0\x30\x4c\x23\xee\xe3\x7b\x1b\x26\xce\x9d\x98\x96\x46\x74\x0f\x64\xeb\x5c\xc0\xa5\x50\x94\x13\x3d\x9c\xd2\x1b\x61\x34\xe2\xca\x0d\x8f\x1f\x0f\x38\x22\x9c\x3c\xdc\x9d\x8a\x8b\x73\xfc\x4c\x5e\x5e\x4e\xdf\xdc\xf2\x45\x63\x9c\xc7\x76\xb9\xac\xed\x48\x2d\x5f\x3e\xe9\x97\xf2\xa7\xf1\xd6\x8b\xd8\xda\xf8\x02\x3b\x7c\x2b\x87\x63\xa9\xc8\x21\x8b\xa9\x04\xbf\xb6\xbf\xde\xea\x0b\x38\xbe\x1f\x4f\x2f\xd2\x2e\xe8\xa7\x84\xc1\xf7\x4a\x6e\xc6\x38\xbc\x26\xa8\x2c\xec\x11\x81\x96\x25\xeb\x73\xf3\x74\x90\x5d\x36\x28\x0b\x6b\x07\x96\x48\x36\xf1\x0c\x89\x46\x71\x23\x28\xdb\x89\x5b\x96\x79\x97\x8c\x8f\xa6\x7b\xfb\xc1\x30\x28\x93\x5e\xe0\xca\x0b\xd6\xbf\xc1\x62\xd6\xf8\xeb\xd7\xa3\xac\xc5\xac\x0e\x03\x83\x92\x80\xe4\x17\x14\x00\xdc\xda\x0b\x9d\x9d\xfd\xb4\x91\x26\x66\x86\xce\x7a\x43\x71\x49\x89\xcf\x12\x10\x15\xdd\x3c\xce\x9c\x24\x92\xab\x28\x28\x68\x5c\xd2\x45\x44\xe9\x43\xd1\xf4\x1f\x01\x1d\x15\xad\xdd\x1c\xdc\xf3\xe9\x63\x5f\xe8\x78\xf6\x2f\xc1\x83\x45\x82\x2e\x3a\xe4\x1c\xfd\xfc\x69\x5e\xf8\xc6\x2b\x8a\xce\x9f\x9e\x31\x7f\x18\xd7\xa6\xc9\xf3\xd2\x82\x4a\x69\x34\x40\x60\x6c\x87\x78\x10\x4e\xef\x4c\x24\xe6\x90\x98\x36\xc3\xd2\x54\x97\xaa\xc5\x12\x2e\x9d\x96\x3f\xd0\xea\x8f\xe4\x0f\x34\x07\x5d\x0c\x8d\x58\xa4\x31\x68\x7c\x7d\x67\x38\x3c\x31\xc8\xa4\x3c\x0b\xee\x40\x4b\x02\x8d\x9a\x2f\x16\xc7\xf5\xa2\x2f\x0b\xe3\xa5\xd1\x35\xed\x70\x01\xc8\x7f\xd7\x9c\xca\x6f\xeb\xe8\x91\x74\x92\xae\x70\x87\x10\x61\x20\x6a\xe9\xa5\x74\xe0\x62\x45\x91\x12\x9c\x0b\x45\xa9\x79\xf6\xb7\x26\xd0\xa6\x34\x60\xd8\xaf\x11\x89\xbd\xb5\x24\xd2\x4c\x87\x04\x9d\xf9\x22\xab\x85\x7f\xad\xe7\x83\x4a\x76\x69\xbe\x0c\xc1\x6c\xee\x00\x6a\xa3\x5a\x25\x3d\x27\x29\xbe\x96\x38\x96\x18\x65\xe6\x88\x14\xc8\xe1\x60\x38\xfc\x54\xca\xe1\xc7\xec\x2a\x8f\x4d\xe7\x38\xf5\x9b\xbb\x2e\xac\x80\x87\xbb\x8d\xd6\x77\xb8\x7e\x0f\xc9\xe2\xf5\x5c\x28\x48\x94\x74\xa4\x76\x0b\x72\xab\x22\x6a\x44\x6f\xbd\x47\x10\x47\x0d\xe6\x98\x69\x03\xfe\xb2\x84\x6c\x03\x48\x65\x8c\x86\x25\x69\x61\x26\x39\xb3\x64\x89\xb6\xcf\x1c\x64\x3e\xf3\xfc\x0e\x2d\x69\x0d\xb7\x6c\x4d\x12\xee\xbe\xdc\xb0\xd9\x16\xa1\x54\x41\xef\x94\x24\xb6\x9c\x56\x48\x47\x7c\xe7\xb3\xec\x0a\x88\x17\x24\xc7\x0f\x0b\x0b\xea\xf9\x3a\x1d\xc7\x12\x31\x52\x0c\x15\x73\x5c\xf0\x5a\x20\x14\x24\x91\x50\x6a\xd7\xdb\x87\xbd\x8f\x5d\xd9\x8b\xc6\x67\xd8\x38\x60\xe7\xb0\x86\x20\x16\xfb\x7a\xdf\x92\xf2\xa4\xcb\x56\xd4\x58\x8f\x19\x15\xa3\xdd\x95\x78\xba\x72\x74\x58\x2f\xa0\x41\xd1\x70\xd7\x32\xb4\x0f\x08\x5e\x5b\x31\x7e\x52\x7b\xef\x08\xeb\x9a\xac\x97\x19\xb2\xbc\xc9\x87\xa2\x3a\x6b\x0e\x43\x11\x55\x12\x27\x35\x6e\x98\x90\x1c\x25\xa1\x27\xd7\x43\x58\x02\x50\x30\x36\x47\x83\xdb\xae\x91\xfb\x6c\x5b\xe9\x3c\x96\x1b\x4e\x83\x73\x63\x4f\x46\x65\x51\xfa\xca\x2d\x92\x67\x69\x24\xf3\x18\x52\x4e\xe8\x13\xb2\xfd\x6f\x19\x37\xd2\x57\x7a\x9a\x0d\x5f\x74\xba\xb9\x22\x3f\xea\x7a\x3c\x51\xd5\xeb\x6c\x26\xb5\x91\x42\x2c\x35\xec\xa5\x22\xfa\x7d\x12\x5c\xd9\x11\xdb\x69\x5e\x93\x7c\x7d\xc3\xf0\xb1\xa2\x52\x9f\x9c\xbd\xd8\x19\xe8\xb4\x6c\x0f\x3b\x7f\x24\x89\x8c\xd1\xbb\xf9\x27\x64\x78\x77\xe1\xf2\x41\x2a\xc6\xcd\xba\x31\x0f\x5f\x77\xf0\x66\x24\x6f\x72\x97\x77\xa6\x56\xa5\x15\x24\x0a\xc8\xe9\x54\x1d\xdb\x48\x06\x69\xf9\xf3\x03\xfa\xf2\xd3\x4c\x16\xdb\xe2\x16\xfc\xe4\x6c\x56\x07\x63\x5c\xa0\xa7\xbc\xbe\x37\x4f\x0b\xec\x8a\x9a\x0e\xb7\xf4\xc5\xb9\x52\x86\x44\x29\xd7\x5d\xee\xf8\xbc\x8c\x42\xee\xd1\x01\xd3\xe4\xb6\x3d\x33\x95\xe8\xe9\x71\x46\xc9\x4d\x4d\xc9\xe8\xc8\x93\x86\x42\xca\xfc\x67\xb7\xc9\xd8\xdb\x0a\xad\x4f\x4d\x5b\xfa\xd4\xb0\x60\x12\x10\xf4\xad\x57\x5b\x70\x42\xce\x89\x74\x0c\xbb\xdf\x02\x69\xca\x5c\xf6\xf1\x00\x04\x40\xfb\xbf\x60\xde\x7b\x19\x58\xea\xd1\xf1\x2f\x29\xd3\xc6\xa9\x63\x44\xbb\x52\xa7\xff\x50\x76\x7a\xee\x8b\x78\x9f\xee\xa6\x34\x39\x48\x13\x86\x5f\x9f\xc1\xd9\x87\x85\x23\xe9\xba\x31\xa2\xf9\x26\xd3\xeb\x50\xc2\x2f\xd6\xd5\xd6\xa1\xa7\xd5\x26\xae\x7f\x55\x9c\xa8\x75\x8e\xa8\xe0\x29\x96\xef\x6c\x39\xf6\xd0\xad\xf6\x3a\x21\xe5\x7d\xc9\x91\xbc\x3d\x5b\xf2\x12\x2a\xb2\x99\x3b\xa7\xad\xb2\x01\x84\x75\x7b\xb0\xb4\xb1\x03\xeb\x2e\x1a\xa4\x96\x70\x11\xbd\xe2\x22\xea\x21\xea\xe2\x06\x2c\xfe\xbc\x7c\x1c\x76\x0e\xab\x0f\x6e\x4e\x19\x9b\x4b\x0c\x13\xed\x36\x33\x75\x00\x64\x3e\x83\xf6\x36\x8c\x97\x04\xbb\xcf\x79\x2f\x48\x16\xa2\x7d\xdc\x13\x1e\x92\xf1\xd1\x91\x83\x02\x7b\x71\x4c\x81\x1d\x9c\xf1\x24\x92\xf2\x0d\x0a\xe7\x9c\xe0\x2d\xc4\xc4\xf4\x61\xa1\x8f\x5b\x8e\xfe\xf9\x73\x74\x0b\xdd\x6e\x53\x8c\x6e\x32\x8e\xc4\x9f\xe0\x40\xa1\x7f\x92\xee\x1a\xd1\xb7\x8a\x8d\x0f\xbf\x0e\x0f\x8f\x8c\x78\x48\x4e\x70\xc1\xa2\x89\xc7\xe3\xb5\xde\x10\x1e\xd2\x32\xf1\xd0\xe3\x08\x26\x04\xe1\xe9\x0b\x33\x03\x09\xa7\xf1\x84\xf3\x91\xcd\xc0\xc6\x66\x8c\xf7\x78\xe3\x0f\x29\xe7\xfa\x0c\x11\x01\x57\x50\x27\x68\x82\x37\x66\xf2\x3e\x91\xda\x20\x96\x02\x73\x21\xa8\x3b\x15\xfc\x70\x81\xd5\x26\x51\xfd\xb1\xb7\xce\x63\x0e\x4e\x1f\x04\x3e\x4f\x67\x64\x48\xf7\x45\xde\x31\x75\x09\x10\x7b\x84\xcc\x5e\xcb\xda\xaf\xfc\x56\xe4\x7d\xf1\xe8\xe3\x32\xdb\x40\xe7\x4a\xca\x48\x05\x95\x53\xe1\x16\x1e\xf6\x14\x3e\x21\x7e\xf5\x16\x9b\x4c\xe9\x5e\x64\x1b\x10\x09\x98\xe6\x72\xc0\xd2\x35\x2f\xe7\x1d\x90\x47\x79\x4e\x0f\x57\xfe\x08\x2d\xf5\x60\x05\xa4\xb1\x1b\xe2\xe4\xc9\x9a\x4c\x4a\x03\x9e\x8b\x3d\xa9\xd4\x28\x52\xa5\x56\x32\xc3\xc8\x8f\xec\x4d\x3b\xbe\x3a\x8b\x2d\xcf\xec\x41\x08\x30\x3c\x19\xc8\xa4\x09\x4c\xc3\x07\x31\x4c\x3c\x46\x28\xd2\x4a\xee\xad\xf4\x14\x4c\x0e\x86\xee\x43\x6c\xa8\x59\xf7\xf6\xc3\x4e\x8f\xfc\x03\x5f\x37\xed\x00\x3a\x2a\x95\x5c\x38\xcd\x8f\xde\x77\x08\xa0\xea\x0b\x0d\x64\x35\x27\x4c\xb2\xdf\xcf\xe5\xa6\xee\xf5\x48\xf7\x73\x35\x4d\x20\x9e\x32\x49\x44\x8e\x25\x9e\xb6\x57\x50\x5c\x70\x79\x72\xa2\x7e\x85\x83\xd2\x8d\xe9\x29\x71\x4e\x30\x07\xc5\x45\xf7\x7c\x29\x89\x28\xf5\x40\x01\xfc\xd6\x28\x22\x3b\x91\x4a\x47\x5a\x90\x21\xa3\xa3\x97\x55\xa5\xdb\x2c\x57\x4c\x8a\x23\x45\xd7\xac\xd2\x45\xb6\xad\x84\x87\x1c\x18\x99\x4f\x35\x2e\x4b\xfa\xc1\x91\xb1\x91\xa6\xf9\x99\x53\x6c\x73\x6f\x02\x8c\xc5\x7a\x89\x64\x92\x13\x37\xe3\xe9\xd3\xb3\x3b\x25\x05\x6e\x3c\x8f\x0f\x35\xff\x2a\x8f\x14\x0f\xf7\xd9\x69\x75\xb8\x8e\xb6\x3f\x6f\x8c\x93\x6d\x49\x96\x97\x22\x6d\x90\xf7\x2e\x1d\xe7\x14\x58\x4c\xf3\xde\xf7\xc6\x46\xa5\x91\xb5\xb5\x91\x8e\x19\x72\xe2\xc7\xf5\x73\x0c\xea\x96\x0b\xbd\x9f\xf9\xb4\x8e\x0d\x38\xb3\x21\xa2\xc8\xcb\x7b\x4e\x93\x63\xc6\x79\xd9\x97\xa3\xed\x04\x8a\xf9\x4e\x66\x80\xe7\x32\xe3\xfd\x21\xfc\x6e\x1b\x22\x35\x68\x55\xc4\x46\xf8\x86\x4a\x27\xd0\x64\x84\x42\x00\xc4\x32\xe5\xf2\x73\x76\x35\x11\xde\x09\xd6\xd7\xe5\x8b\xf0\xca\x43\xa1\x72\x13\x3e\x7e\x18\x2e\x81\xac\x1c\xb5\xdc\xa4\x10\x89\x6b\x67\xc7\xcf\x4c\x69\x6e\x4e\xf1\x64\x9b\x90\x8f\xf3\xbd\x75\x27\xad\xf2\xd2\xe3\x66\x5d\xa1\x1e\xf1\xb5\x42\xfb\x73\x14\x4c\xb7\xb7\x41\xc9\x01\x35\x53\x87\x68\xd5\x4b\xa3\x76\xe6\x9c\x76\x6e\x2d\xca\x5f\x65\xbc\x39\x10\x65\xf5\x56\x07\x22\x6d\x93\xaf\x07\x89\x42\x12\x3a\xef\x47\x03\xce\xab\xbe\x78\xd6\x63\xf5\x5a\x58\x0a\xae\xbe\xc9\x6f\x1a\x1b\xe9\xda\x79\xfe\xe5\xf9\x00\xf2\xc2\x48\x10\x4b\x67\x54\x9c\x1c\x7e\x63\x4e\x07\xc2\xb8\x17\xed\xe2\x00\x87\x4f\x5a\x4b\x3a\xdc\x62\xdc\x41\x07\x80\x25\x39\x43\x09\x5d\x9d\xc3\x6f\xf2\x15\xca\x97\x17\x98\xb9\xc8\xd5\x77\xdb\x31\x8d\xdd\x29\x1b\x28\xa3\x74\xb8\x98\x5e\xb2\x3f\xb1\x81\x75\x80\xc6\xa6\x98\x03\x2d\x14\x41\x01\x9d\xba\x8a\x39\xaf\x19\x8b\xa3\x00\xa7\xe9\x39\x4e\xd6\xd9\x84\x1d\x4c\xad\xf6\xc1\xbd\x23\xda\x41\x32\x59\x75\xda\xe9\xe1\xe1\xbd\x35\xc7\xc6\x2f\x5f\x1e\x1f\x3d\x66\x12\x71\x6c\x14\xca\xc7\x6a\xf6\xc6\xe5\xde\x87\x88\xbf\x11\xbe\xcb\xa1\x3f\x75\xf6\xfd\x41\x72\xa9\x5a\x99\x9a\x16\xcd\x02\xd1\x5d\xd3\x41\xeb\x58\x20\x14\x5f\xd5\x76\xef\x4d\x0f\xbc\x8f\x31\x56\x1c\x96\xbf\x26\x19\x50\x5c\xef\xea\x1d\xc5\x36\x58\xa3\x93\x32\xeb\xeb\x9d\x6d\x37\xe4\xa5\xb1\x5b\x6c\xd2\x8f\x27\xbb\x1e\x41\xa9\xc9\x51\x36\x52\xbb\x0b\x53\x0b\xed\x51\x7d\xeb\xeb\x94\xad\x53\x87\xec\x65\x7f\x95\xec\xef\x53\x1c\x5c\x44\x2d\x77\x4c\x72\x54\x43\x5d\xb9\xd3\x8e\x6f\x72\x6c\x79\xbd\xdd\x82\x58\xa5\xcd\xdb\x4a\x5e\x66\x6f\xee\xa3\x0c\x2d\x8a\xe9\x0b\xf0\xcb\xb0\x87\x95\x28\x95\x58\x33\xd3\x52\x3e\x5c\xd6\x23\xea\x96\x09\x39\xe2\x16\x89\x56\x50\xe9\xa5\x98\x51\xd5\x90\xdb\x91\x1e\x2c\x1e\x61\xf9\x65\xa4\xcf\xe4\xa6\x58\x9b\x23\xbf\x2a\x85\xdf\xe7\x67\x56\xec\x54\x6e\x71\xf9\x8f\xcd\x47\x4c\x97\x28\x98\xc2\x5a\x29\xd3\x6f\x84\x4d\xf3\xc1\x69\x8e\xe5\x21\x23\x5a\xd1\x18\x04\xca\x48\x05\x2e\x83\xd0\x24\xf1\x89\xc9\x80\x57\xfa\xf5\xb4\xa0\xaf\x5c\xb0\x70\xa9\xb8\x15\xd0\x2a\xc8\xb6\xf5\x8d\x0b\x17\x2f\x0f\x94\x95\x2e\x67\xbe\xd2\x79\x20\x39\x93\xef\x4c\x32\x97\x81\x1a\x70\xa7\x28\xd1\x23\x5a\x2d\x29\x69\x8e\xc1\xb8\xf3\xb5\xdd\x6a\xeb\xb4\xd2\x6a\xd4\xad\x19\x3d\x1f\x1a\xbc\x30\x62\x93\xf3\xf2\x1b\x60\x6e\xa3\x30\xe0\x61\x5d\x9c\x6b\x32\x93\x49\x29\xba\x58\xed\x45\xdb\x38\x66\x96\x6e\x44\xb1\xce\xb7\xbb\x25\x38\x92\x43\x53\x2e\xde\x6f\xda\x15\x8b\xc4\x9b\x18\xf6\x4e\x67\xdf\x27\x7f\x64\xdd\x70\xad\x2d\x9d\xd9\x4a\x93\x3d\x61\xba\x8a\xbd\x59\x3c\x6c\xdc\xec\xc7\xa0\x0c\xa3\x4f\x1a\x59\x64\x62\xc9\x48\x6c\x5f\x4c\x01\x43\x0a\x06\x5e\x1b\x5d\xc7\xca\xd2\x1d\xd1\x6f\x0e\xaa\xf1\xc7\xe0\x8f\x3e\xab\xc9\xb9\xd8\xa8\xa8\xfc\x4e\x6b\xb1\x59\x09\xa5\x91\xd4\xb5\x3d\x81\x9a\xd4\xc3\xe3\xf5\x17\x66\x85\xe7\x4e\xa5\xac\xec\x03\x48\xce\x5e\x95\xb9\x03\x9f\xce\x19\x9f\x66\xe3\xa8\x3c\x96\x97\x1f\x89\x28\x7c\xe2\x45\xd3\xe4\x28\x53\x4c\xb5\xd7\x5c\xf9\x9f\x8a\x3e\x9c\x75\xc2\x34\x0f\x76\x64\x4e\x97\xe9\xbe\xf5\x7e\xb4\x48\x4e\xf2\x00\xab\x5b\xb1\x6e\x44\xc4\xcc\xca\x65\x68\x2f\xda\x88\x28\x32\xa9\x31\xa2\x68\x65\x5f\xca\x94\x51\x6e\x56\x3d\x91\x43\xe4\xf6\xf0\x92\xa8\xf9\x48\xff\x1c\x1b\x7f\x45\x8d\xef\x67\x1b\x69\x7e\xa7\x25\xaa\x42\xa5\xe3\x31\x35\xfe\xc6\xe0\x63\x7a\xc5\x95\x0b\x76\x0d\x81\x3e\x61\xeb\x59\x80\xf1\x25\xb1\x65\xbe\x26\x63\x21\xa0\x89\x15\x70\x49\x42\x0d\xcb\x38\xd0\xb3\x5d\x7e\x41\x2d\x6c\xa1\x36\x34\xc3\x31\xa5\x98\x92\x2f\x15\xb0\x5b\x5c\x12\x5c\x5a\x08\x0c\x49\xf5\x0a\x54\x34\xd0\x1c\x57\xb9\xf9\xf0\x61\x61\x38\x27\x6c\xfa\x88\x78\x52\x59\xac\xdf\x4e\x92\x65\xfb\x00\xc6\x6a\x33\x3a\xdc\xed\x2d\x06\x3a\x47\x90\xdb\x36\x17\xe5\x19\x76\xd3\xe1\x61\x64\x24\x24\x60\x83\x4d\x2c\xdc\x94\x43\xf4\xf6\xbe\x04\x7a\xf0\x33\xb7\x21\x71\x86\x31\x93\x98\xf7\x8f\xe0\x5d\xd3\x8b\xd9\x17\xdf\x6e\x23\x78\x8e\xb5\x42\x0e\x8d\xca\xe7\xc6\xc0\x6c\x5d\xb8\xbe\x4b\xc3\x5e\xb7\x0f\x74\x0e\x95\xf4\xb9\xd6\xc2\x13\x5f\x40\x59\xd0\xfc\x17\x75\xec\x9c\x67\x53\xfa\xb5\x6b\xae\xe7\x5d\xd0\x02\x4f\xc6\xa4\x97\x26\x76\x3a\xf5\x98\x1f\x4e\x83\xdb\x61\xfa\x4c\x19\xd8\x11\x65\x77\xc9\x8b\x9e\xf5\x2d\x68\x59\x7d\x3a\x1e\xa8\xc1\x78\x69\x20\x4f\xb9\x05\x20\x95\x8a\x78\x7c\x2b\x5e\x8b\xc3\xb1\xb2\x43\x71\x01\x25\x84\x7f\x03\xe6\xb8\x5d\x7b\x5b\x5b\x1b\x1e\xd8\x71\x22\x9a\x09\xdc\x78\x40\x4c\x07\xd6\x75\x70\xd5\x94\x1d\xd5\xc3\x6a\xbb\xea\x83\x0b\x0b\xdc\xd6\x2d\x01\xdd\xe8\xa3\x5b\x3d\xc9\x7f\x8b\xc0\xf5\x93\xd8\xa6\xb2\x5c\x0c\xf1\x65\x89\x8b\x6a\x71\x5b\xfe\x25\xef\x1c\xb3\x5e\x57\xa5\x87\x94\x1a\x19\x27\xe2\x48\x6a\xd3\x79\xc2\x63\xea\xf4\x25\x4a\x38\x8a\x18\x49\x6d\x78\x95\xc2\xe5\x3d\xe8\x43\x2f\xfa\x5d\x2e\x26\xc1\x77\x34\xcd\x44\xde\xc3\x2c\xc6\x98\x17\xce\x13\xca\x1c\x33\xf9\xb9\xea\x94\x22\xb6\x7a\x96\x14\x9f\x83\x60\xc5\x55\xa9\x90\x16\xea\xc1\x0d\x7c\x4d\x3a\x1f\x33\x51\x63\x21\x93\x5f\xc7\xa3\xe5\xf1\x57\x28\x01\x18\x57\x6a\x87\x90\xd3\xf9\x71\xeb\xd6\x53\xf2\x23\x66\x28\x47\x34\x47\xde\x97\x49\x3e\xb4\xa7\xd4\xe0\x85\xe4\x6e\xd5\xda\x84\x45\x92\x06\x0e\xfc\xd9\xa9\xff\xf7\x8d\xf2\x5e\x84\x9b\x92\x80\xe6\x97\xcb\x97\x8b\xda\x3c\x44\x24\x3e\x6e\xf1\x48\x47\x5b\xc7\x16\x4d\x89\x27\xc9\x43\xd4\x26\x92\xc7\xb8\x27\x6f\xf8\x72\x55\x6d\x08\x05\x80\x1c\x8a\xc6\x11\xfb\xcd\x4e\xcb\xcf\xdd\xbe\x7f\x77\x4a\x01\x3f\x89\x12\xe5\x36\x97\x5c\x41\x3c\x88\x8f\x4e\xc1\xb6\xf7\x0e\x5a\x4b\x35\x12\xa2\x44\xc1\x29\x98\xfc\x85\xef\x1d\x48\x69\x3d\x17\x82\x69\xd9\x71\x6c\x53\x05\xce\xd5\x3a\x9c\x42\x1a\x32\xb6\x26\x79\x59\x91\xed\x5e\x1b\xd9\x06\x17\x62\xd8\xae\x75\x7d\xe6\x10\x59\x2b\x6c\x7f\x63\xfc\xbe\x5a\xdb\x6d\x4c\xc7\xd5\x25\x39\xa4\x15\xe3\xa6\x73\xc1\xc6\xcc\xaa\x59\xef\x4f\xf2\x31\xe9\xdf\xba\x59\x44\x32\x0e\x4c\xb6\x0a\xbf\xfd\xbf\xca\xa2\x25\xf8\xa2\xf5\x63\x15\x2b\x37\x9d\x07\x56\x94\x5f\x2e\x72\x73\x49\x71\x0d\x70\x1b\xd7\xa9\xf0\xb9\xe5\xba\x20\x3e\x10\x04\xc9\x62\x47\xec\x4e\x7a\x95\xc5\xbd\x32\xb2\x71\x96\x58\x93\xfd\x44\xf9\x49\xae\xd6\x61\x8a\xf6\x96\xda\x27\x48\xff\x10\x56\x83\x54\xa2\xad\xec\x9c\xbc\x99\x9f\x1f\x95\x45\xc9\x74\x8f\x7c\xfa\xda\x47\xb5\x33\x96\x28\x0d\x6f\x4f\x74\x72\x4a\x6c\x0f\x97\x12\x73\x02\x3c\xe5\x3b\xd5\xf2\xdc\x33\x29\x59\x51\xf9\xe8\x81\x60\x67\x77\x87\x38\x05\x22\x6f\xbd\x26\xef\xdf\x37\x3e\x17\xee\x63\xd1\xad\x82\x88\x5e\xa2\xf5\x40\x26\x0b\xe6\xd1\x74\xea\x54\x93\x07\x12\x7d\x67\xbb\x1c\xb1\x24\x82\x7d\x88\xec\xb0\x30\x68\xba\x68\xbd\x13\x29\x88\x47\x54\xfa\x01\xbe\x00\xc7\x73\x94\xe3\x79\x34\x72\xec\xc7\x00\x0d\x20\x14\x00\x7f\x6f\xea\x0d\x4d\xf2\x48\x3b\x0b\xce\xa6\x77\xea\x7e\x7c\xaa\x20\x21\x28\xeb\xef\xf2\xf7\xcf\xf9\x0b\xf6\x86\xd9\xe0\xb6\x19\xf7\x61\x64\xd8\x07\x22\x09\xb9\x91\x0b\xdb\x2d\x73\x51\x67\x23\xe2\x2c\x31\x4d\xb0\x16\x9c\x7c\xaf\xad\x2f\xa9\x75\xcd\x68\xf6\x52\x94\xb1\xd3\x2d\xc7\x2e\x6b\x24\x47\xf8\x4b\x2c\xdd\x85\x31\x61\x15\x3d\x61\xab\xfc\x8c\x59\x50\xc7\x41\xc6\x2c\x71\x94\x25\x21\x11\xd6\xff\x0a\x4f\x4e\x05\x15\x7a\x76\x4e\x36\xd7\x5e\xa5\xc6\x03\x3e\xf0\xee\xc6\xac\x41\xe9\x76\xdc\x4a\x87\x46\xf0\xd3\xbd\xcd\x29\xb0\xc9\x0a\x2f\x9d\x99\x8a\xde\xaa\x6c\xcc\x92\xa9\x42\x33\x47\x4d\x19\x9c\xaf\x27\x5b\x18\x90\x1a\x2c\x6e\x5c\x16\xbe\xe7\x8c\x5c\x1d\x6b\xde\xd1\xa3\x0d\x6d\x31\x05\xa5\x68\x6d\xb4\x6f\xb5\x3e\x21\xd3\x1a\xf4\xbb\xf0\xd5\x6a\x4d\x30\x43\x20\x3c\xa6\xe9\xe7\xff\xf3\x07\xe5\x9f\xb5\x80\xb9\xdf\x8e\x5c\xbd\xbc\xbb\xbb\x91\xbe\x60\x4b\x7f\x7c\x07\x5f\x78\x4e\xf4\x11\x11\x60\xc7\x80\x9c\xb8\x9e\x70\x57\x1d\x1d\x4a\x0c\xe8\x0c\x6a\x48\x4c\xf6\x4d\x0f\xa9\x3c\x94\xea\x5f\x94\x92\x89\x3d\x07\xf9\x7f\x9f\xaa\x90\x43\x05\x14\xa8\x8a\x06\x4d\x40\x07\x57\xde\x85\xce\x25\xea\x89\xb7\x16\xb8\xfd\xc7\x86\x82\xf4\xe1\x93\x66\x14\x97\x7f\xa3\x8e\x25\xe4\xa7\x4d\x6e\xd8\x70\xe6\xa1\x0b\x5a\x00\xd4\x33\xfd\x40\x3e\x27\xf6\x4d\xbc\xf0\x64\x0d\xfe\x59\xba\x2c\x42\x04\x54\xb3\x97\x75\xb1\xc2\x4a\xf5\x3a\xf9\x03\x1b\x83\xe6\xd8\x6f\x3e\xaf\xb5\x62\x5e\x1d\xd5\xb9\xe1\xc8\x91\x92\xde\x8b\x47\x78\x8e\xba\x5f\x57\xeb\x60\xcf\x04\x48\x0c\x04\x8f\x92\x22\x3d\xb4\xcf\x9f\xa3\xfe\x01\x7a\x26\x3d\xde\x05\x08\x1c\x40\xfe\x25\xd3\x8c\x48\xd9\xf3\xd8\x71\x69\x93\x78\x17\xb0\x44\x48\xba\x58\x78\xcf\x6a\xea\x84\xaf\x4b\x01\x20\x16\x7c\x40\x00\x04\x51\x54\x16\xb0\xc6\x50\xa8\xe4\x2b\x07\x18\xe3\x3a\x75\x1e\xee\xb2\x63\xdd\x7d\xd0\x9e\xbd\x54\xb2\x9b\xcb\x0b\xa1\xf0\x85\x42\x35\x8c\xda\xa8\xca\x02\x38\x31\x82\xd6\x68\xc8\xa9\xaa\xaa\x9c\xa7\x61\xb7\x99\x46\x75\xf6\x58\x4c\x63\x5b\xa1\x6e\x4e\xd7\xa8\x78\x74\x4e\xdf\x44\x9b\x58\xd8\xc5\x2a\x11\x4e\x38\x04\x02\xfd\xf0\xc6\xdc\xe1\xc3\x73\x37\x1e\x02\x16\x89\x15\x7c\xf8\xf6\x18\x86\xcd\x32\x0d\x7f\x90\x05\x52\x7b\x3e\x7d\x37\x38\xf8\xd8\x2e\xc7\xe1\xb9\x47\x8e\x9d\x04\xd5\x79\x11\xd5\x82\xb0\x9f\x4f\x67\xc1\x23\xf8\x51\x0e\x96\x91\x9a\x71\xf3\x27\xa0\x67\x12\x0a\xcf\x66\x92\xaa\xb8\x12\xc2\x07\x18\x4b\xf8\x59\x88\xb4\x60\xb2\x39\x8f\x68\xf3\x32\xea\xc2\x84\xc9\x36\xda\xfd\x24\x7d\x93\x1e\xae\x0e\x1e\x20\x97\x83\x28\xc3\x54\x3f\xbb\xef\xb2\x18\x7d\x41\xad\x60\xf7\x0f\x37\x1b\xd4\x05\x38\x94\xe8\x80\x18\x4c\x19\x48\x46\x52\x12\x03\x89\x47\x8a\x0a\x0b\x45\xfd\x46\x4a\x08\x58\x77\x21\x53\xc3\x4b\xd2\x72\x86\x1d\x8e\x00\x04\xde\x40\x45\x4b\x61\xfa\xdc\x32\xcb\xf6\x27\xbe\xe9\xb1\xca\x8c\x94\x25\x76\x5b\xd8\x9f\x5b\x37\xbe\x82\x1f\x53\xae\x46\xb3\x6a\xbc\x01\xe8\x6a\x86\x14\x87\x5b\x35\xe8\x68\xa1\x4d\x06\x74\x2c\xa1\xb9\xe1\x5e\xff\xa1\xd2\x69\x23\xda\xe1\x43\x6f\xaf\xb4\xce\x71\xc2\xa7\xfb\x5a\xa7\x65\xe8\xe6\xf3\x9a\xbd\x74\xac\xbf\x65\xe3\x19\x57\x69\xfe\x95\xb7\x87\xee\x70\x5f\xd7\x74\xa8\xff\x5e\x2a\x3e\xb2\xb8\xb1\xf9\x56\x6c\x68\xf1\xf9\x17\x5a\x9a\x51\xa3\x6a\x58\x07\xa7\xcf\x1c\x42\xdf\xe3\xa8\xaa\x82\x39\xa9\x71\x02\x37\xd6\x40\xf9\x19\xb1\x8b\x82\xaf\xb8\x27\xb4\x12\xd0\xed\x16\x1e\xe3\x9e\xe1\xfa\x1d\xab\x5b\x3d\x65\x1e\x1c\x89\xc4\x48\x2b\x5e\xd1\x97\xba\xc5\xde\xea\x61\x2f\xf5\x47\x85\x13\x36\x8c\x7a\xd5\x3c\xf0\x36\x29\x79\xd0\xb6\x87\xe5\x44\x48\xe4\x77\x46\xcb\xcf\xf3\xe3\x13\x76\xe5\xfa\xfa\x32\x6e\x46\xbd\x29\x25\xc3\x64\xf8\xf3\xef\x03\xb9\xee\x2e\x9d\x29\xe1\x08\x14\xc6\xdb\x95\x50\x36\x5e\xc3\xb7\x72\x09\x8d\xe3\x04\x7b\xaa\x68\xf7\xc8\x3c\x8a\x4c\xca\x3f\xb3\x49\x68\x2e\xa7\xb7\x98\x8e\xb4\x64\x68\x74\x5b\x24\x9d\xe5\x1e\xe3\x16\x5d\x09\xec\xe2\xb2\x66\xc5\x98\xb0\x39\x26\x34\x2e\xda\x3b\x00\xe6\x73\x3b\x8f\x42\x8c\xaf\x95\xfd\xf6\x0a\x12\x9a\x6b\xf6\xf5\x19\xdc\xe6\xf5\xf5\x95\x7e\xcf\x3e\xa8\x6a\x29\xcf\xb0\x79\x22\x54\xcb\xe3\x9d\xbc\x6a\xbd\x4d\x55\x1b\x81\x02\xe9\x64\xce\x82\x4d\xbc\xdd\xb1\xad\xb4\x5b\xff\x84\x44\xf1\x67\x34\x0f\x7b\x1a\x2b\xe1\xdd\x9d\x1f\xa9\x8c\x02\xa1\x17\x3a\xaa\x3c\x83\x39\x71\xa9\x02\xb7\x01\xfe\x41\xcf\x7f\x14\x02\x05\x7f\xa1\x15\x77\x07\x09\x4c\x7d\xbb\xc5\x41\x3d\xc2\xa3\x36\x13\x1b\xaf\xdb\xa0\x65\x76\xf8\xdd\x41\x75\x11\x94\x2b\x55\xfa\x5f\xff\x1f\xf6\x51\xde\x33\x66\xde\x3f\x9f\xe4\xe2\x95\x1b\x52\xb7\x5c\x97\x08\x30\x05\x52\xc6\x00\x18\x7f\x0d\xa4\x52\x5e\x20\xf3\x2c\xf7\x98\xeb\x56\xd1\x77\x85\xdc\x57\xa2\x1b\x1d\x15\x82\x7f\xb2\xee\x32\xe2\x60\x41\x09\x1f\xe5\x76\xa9\x47\xa9\x3c\x39\x0b\x0f\x93\xca\x34\x6e\x58\x3b\xa1\x3f\xbb\x0b\x89\x3f\xf2\xa7\x1b\x2a\x75\x56\x30\xfb\xab\xe4\xb4\xd3\xed\x03\x7b\x5b\x01\x34\x22\xae\x10\xc3\xce\x82\x2c\xb6\x17\xc4\xee\x82\x15\x1a\x71\xd3\xbc\xb1\xe7\x3c\xec\xe7\x92\x52\x4b\x9a\x2b\x82\x08\x07\xdf\x1d\x86\x6b\x35\xc8\x57\x78\x63\x46\xec\x84\xf0\x18\x50\x08\x4f\xfc\x7f\x1f\x3d\x2a\xc2\xf0\xa5\x3b\x45\x12\xfb\x83\x05\x99\xd5\x18\x44\x83\x7e\xbf\xcf\x3a\x17\xd4\x09\x92\x6d\x5c\x41\xb6\xbe\x70\xf8\xb2\xda\xfd\xcb\xeb\x19\x5c\x58\x58\xa7\x08\x64\xb7\xff\xab\xf5\x2b\xbf\x48\x0e\x6b\x36\xfb\xff\x5a\x62\xde\xec\xdf\x57\x73\x58\x0c\xe4\xac\x2f\xd4\xcd\x03\x24\x5f\xba\xad\x51\x84\x13\x12\xf1\x84\x5a\x5f\x97\xa9\xbd\x68\x68\x90\x4c\xf5\x75\x7c\xd7\xc6\x10\x38\xf9\x0d\x09\xc2\xd6\xe4\x5a\x94\xa6\xc2\xd4\x7d\xf1\x49\x48\xc2\x3a\xc6\x8b\x6f\x4b\x7d\xbb\x8c\x0a\xcc\x61\x2f\x2d\xd5\x6b\xa3\xf3\x78\x56\x71\x30\xc4\x02\xc2\x72\xca\xce\x7f\x4c\x43\x90\x5f\xe0\x84\x08\x14\x44\x10\x36\x68\x26\xe8\xbb\x93\x53\xa5\x71\x7d\x70\xdf\xa8\xf2\x3d\x9a\x18\xb8\x7e\x33\x38\xbe\x10\xa1\xf1\x5e\x78\x8e\x53\xdf\xa1\x63\xbe\xa8\xd5\x38\x55\x6d\x11\xb1\xf7\x65\x7e\x37\xb0\xb8\xb6\x1e\xf4\x99\x56\x55\x5a\xc7\x3a\xf4\x76\xc6\xaf\x0b\xe4\x5b\x6d\xe9\x3e\x85\xbf\x13\x80\x3f\xd3\x0d\xd1\x08\xe0\x70\x1b\x7d\xf4\x5f\x06\xe1\xf9\x10\x67\x4b\x06\x42\xdd\xf4\xa1\xfa\xc3\x5f\x0a\x25\xeb\x5f\xa4\x67\x3d\xf7\x49\x68\x7c\x2e\xdd\xa5\xc4\x85\xf2\xfe\x56\x0e\x5e\x31\xe4\x93\xba\x30\x09\x22\x7b\x93\x96\x37\x86\x83\x6d\x86\x73\xd0\x39\xc8\x0f\xea\x9b\xa6\xb3\xf4\xd1\x42\xe0\xf5\xec\x4e\x9e\x94\x49\xc1\x13\x70\x87\xcc\x69\x7b\x0a\x5d\x4a\xac\x20\xea\x10\xf6\x3a\x4d\xb8\xaa\xa5\xd2\x79\xe4\x25\x89\xc5\x75\x86\xe7\xd5\x06\x00\xbf\xfa\x47\xe6\x04\xcd\xff\x56\xd6\x81\xa1\x02\xb5\x0b\xe6\xd2\x01\x6b\x02\x6b\x3c\x6f\x29\x1a\xce\x7b\x3c\x1d\x4f\xf1\x47\x4a\xd7\xa5\xa1\x78\x43\x4e\x6a\x33\x2d\xcb\xaa\x1b\xaa\xef\xf1\x10\x57\x2d\x37\x17\x33\x39\x8a\x1f\x42\xc6\x92\x28\x54\x0a\x60\xda\x50\x0c\x1e\xaa\xaf\x88\x58\x1f\xe9\xbe\x69\x8a\x91\x0b\x77\x08\x51\xe5\x3a\xe5\x9d\xd7\xc1\xdb\xf0\x80\x36\xe3\xb8\x29\x12\x22\x53\x11\x20\x23\x13\x16\xb7\x2d\xe8\x8f\x0c\x08\x8f\x2c\xae\x22\x76\x09\x08\xf5\x84\x5c\xee\x1a\xea\x64\x7e\x6e\x15\xb0\x91\x32\x72\x72\x32\x4f\x62\xbb\x36\x82\x5b\x96\x54\x81\xd6\xd2\x0a\x52\x18\x0f\xab\x4b\x63\xcb\x59\xf3\xe7\x8a\x8b\xf8\xaf\x34\x63\x5d\x91\x3e\xb4\x14\xa4\x8d\x06\x8c\x70\x79\xe0\xa7\xe6\x81\x6a\x06\x70\x3a\x1a\x04\x47\x5d\xaf\x5a\xd0\xe8\xd8\xc8\x24\x12\x30\x0a\x8b\xf4\xfa\x5f\xea\x4e\x2b\x4d\x37\xfa\x59\x32\x18\x6c\x15\x0a\x40\x07\x78\x87\xea\x36\x07\x71\x9d\xe1\x09\xb7\x9d\x34\x9f\xd5\xdf\x35\x39\x4f\xd4\xd0\xa2\x9c\x7d\x11\x54\x93\x90\x72\xfc\x66\x35\xfa\x9f\x32\xff\x6b\x16\x20\x74\x01\xaa\xdf\xb2\xba\x7d\xbb\x70\xc4\x55\x5c\xd2\x75\x72\xba\x9b\xb7\xb1\x73\x56\x6c\xb8\xd7\xaa\x85\x61\x87\xf5\xbc\xde\xb2\x8e\x0d\x7d\x56\x6d\xda\xf1\xc7\x7e\x33\xff\x67\x6d\x86\x8d\xcd\x2c\x18\x5c\x37\x6d\x7d\x95\x2d\x8e\xc1\x84\x2a\xe3\x9a\x10\x2c\x45\x48\x9b\x71\x03\xe7\x24\x59\x78\xb8\x3d\x0e\x45\x15\x98\xfc\xfe\x5f\x56\x27\x9e\xf6\x43\xea\x19\xb2\x52\x99\x69\x87\x4e\x44\xb5\xfa\x39\xf5\x03\x9d\x91\x2f\x00\x0b\x43\x19\x62\xb2\xb3\xc1\xd8\xf8\x78\x9d\xa1\x40\x38\x60\xc1\x32\x49\xcc\xaa\x2c\x21\xf1\xd1\xc2\x03\x66\xdd\x84\xb2\x6e\x45\xf1\xf3\x38\xde\x62\xf1\xfa\x2b\x12\x51\x90\x94\x32\xec\xaa\x98\xeb\xbd\x43\x5a\x5e\x3f\x47\xf7\xf8\x56\x66\xe2\xec\xf6\xe7\xa0\xb1\xb2\x04\xfb\x17\x28\x42\xeb\xe0\x49\x65\xf3\xfc\x2b\x14\x89\x39\xad\x16\xee\x3a\x0d\x41\x0c\x0e\x0b\xc3\xf5\x9c\xef\x0a\xff\xbc\x76\xa8\xa5\xd4\xd0\x34\xd4\x52\x42\xb7\x48\x20\xd7\x7a\xe7\xd1\xb3\x79\xec\x7c\xff\x78\x1b\xbe\xae\x9c\xd6\xa3\xdb\x57\x3f\x80\x45\x1b\xfb\x12\x1a\x74\xb4\xd0\x46\x4f\x0e\xcf\xdc\x94\xe1\x93\x63\x1e\xfb\x94\x3d\xf5\x9a\x31\x45\xe5\x24\x56\x28\x54\xf3\x92\x9a\xd7\xc1\x7d\x0b\xe6\xab\x72\x59\x18\x0e\xa3\x21\x48\x1c\x68\x51\x21\x2e\x46\x2f\x0d\x64\x10\x9e\xf6\xf4\xd5\xab\x47\xb4\x83\x9e\x30\xff\xef\xd4\xd1\x3b\x6a\x17\x07\x38\x36\x74\x1d\xfe\xc0\xc4\xea\xaa\xc5\x16\xae\xec\xd0\x09\x38\xdc\xd5\x79\xe4\xf8\x0b\xdf\x51\x47\xb4\xfd\x2f\x5a\xb5\x90\x61\x33\x06\x3d\x06\x0a\xcb\xcf\xf4\x4f\x81\xaa\x87\xc2\x5f\xd5\xd8\xa4\x4a\x9a\x99\x50\xd7\x92\xa2\x49\xb1\x52\x73\xa3\x5a\x3d\x8e\x90\x7c\xda\xbc\x41\x23\x91\x8c\xac\xac\x8c\xf0\x0e\x23\x91\x73\x75\xeb\xee\xe6\x9b\xbb\x3b\x2e\xeb\xe9\xdd\x1a\x06\xbb\xfa\x2e\x74\x8a\xd7\xa9\x3a\xea\x4b\x16\x49\x54\x27\x17\x81\x36\x98\x1a\x95\xca\x6d\x37\x98\xd2\x22\xf2\x3a\xef\x1a\xec\xe2\xbe\x73\x07\x03\xc5\x62\x12\xc7\x71\xd7\x79\x4c\xe2\x40\x5a\x2c\x59\xaf\x09\x62\x67\x98\x8e\xdd\xc5\x2c\xc1\xfe\xbf\x6e\x9f\x06\xfb\x89\x98\x7b\x0e\x4f\xb8\x3b\x5d\x93\xc9\xaa\x21\x5f\xe3\x22\x3d\x63\x17\xf8\xd3\xba\x02\x86\x9a\x82\x64\x69\x6a\x9b\x32\xa4\x47\xec\x42\xbf\x58\xb5\x24\x80\xe3\xb5\xe0\x7c\xa9\xab\x17\x7f\x69\xdb\x21\xb1\xa1\x82\x2a\x6e\x54\xee\x01\x25\x9b\x02\x13\xfb\x3b\xcf\x15\x2a\xea\xc5\xf6\xe4\x5e\x33\xce\x2f\x63\xed\xae\xb9\x45\xc0\x9f\x13\x73\x9f\x08\x34\xf6\xba\x43\x03\x77\x4c\x6a\x7d\x29\x19\xb1\xf9\xe2\x3c\x28\x86\x9e\x59\x70\x48\x77\xe2\xdd\xf3\x57\x8b\x5e\x92\xfd\x48\x4c\x8c\x2d\x0b\x76\xcb\xdb\x70\x84\xf9\xc4\x91\x40\x01\x77\xde\xc4\xd0\x9f\x70\xc5\xcc\xb9\x9d\x55\xfa\x4b\xb8\x97\xc0\xa1\x3e\x31\xeb\xb7\x80\xf1\xc4\x4c\xcb\xbe\xa9\x66\xe2\x04\x30\x70\x89\xd0\xce\x8e\x97\x1b\x3d\xd4\x5f\xeb\x8c\xf1\x9f\x21\x0b\x09\x39\xfe\x71\xc6\x5b\xba\xba\xc1\xc6\xad\xae\xf9\x74\x84\x2d\x63\x5c\x0d\xd5\x09\x40\xd5\x71\xf1\x5d\xb2\x92\xe0\x43\x41\x4a\xb4\xaf\x70\xcd\x50\x61\x6f\x7c\x1e\x79\xa9\x6c\x4e\xde\xea\x91\x7b\x0f\x46\x86\xf3\x2a\x33\xb3\x46\xd0\xf8\xcb\x78\x4c\x7f\x54\x76\xa2\xb4\xd0\x30\xd4\x9b\x56\x2c\x91\x90\xbb\xe4\xde\xfb\xf3\xd4\x6a\x48\xf5\x41\x28\x5c\xc9\xf4\xd4\x78\xe2\x07\xfa\xfb\x9f\xbe\x07\x78\x74\x50\xbd\x0d\xf5\xaf\xaa\x52\xa5\x5e\xa9\xd7\xe5\xe5\x00\x53\xbf\xef\x68\x22\x91\x48\xb0\xc6\xfd\x4a\x6e\x23\x5f\x70\xbf\x2e\xc2\x24\xad\xb2\x02\x19\x8d\x73\x32\xf0\x69\xa8\xf1\xfb\x42\xcc\xe6\xe6\xf1\x7b\x54\xd1\x75\x5a\x4b\x0b\x74\x5c\xd4\x4c\x1a\x49\x87\x19\x25\xbe\xed\xf1\x2a\x9a\x0b\x8c\xbf\x50\xf8\x3d\x16\x7b\xf9\x62\xe0\x22\x55\xb8\x51\x87\x22\x56\xd3\x52\x7d\x09\x3e\x5a\x82\xd6\xf1\x8a\xd2\x0c\xa5\x81\xc5\x8a\x4e\xb1\xb3\x56\xdd\xae\x02\xe9\x2d\xfb\x4a\xc9\xec\x68\x02\x0c\xcf\x83\xe1\xcd\x0d\xc3\x5e\xa9\xd9\xd5\xc1\x0c\x11\x8c\x3b\x92\xa6\x46\x51\xc3\xd4\x2c\x2a\x2b\xe8\xad\x22\xf5\x22\xd5\x30\x30\x29\xb6\x3a\x3b\x3a\x56\x94\xa7\x12\x50\x38\x2a\x65\x28\x37\xd2\x4a\x6c\x97\xbd\x8e\x8b\x9b\x30\x6f\x48\x65\x5e\xc6\x8a\xe2\xe5\x79\x25\x81\x60\xbc\x93\x1d\x34\xa7\xc7\x59\xd2\x5b\x65\x58\x16\x7d\xb2\x36\x4b\xfc\x4a\x05\xcb\xa9\x84\x91\x12\xcc\x00\x00\x5e\x23\x3c\xc9\x9d\xc9\x08\xcf\x49\xdf\x5f\x2f\xee\xae\x32\x33\x2d\x40\xb1\x6c\xb3\x34\x96\xcb\xfb\x60\xca\xec\x50\xe2\x3d\x01\xe6\x4b\x26\x3d\x2e\x29\xe9\xcd\xd5\x9c\x58\x76\x4c\xaa\x88\xc5\x66\xb1\x6f\xd9\x0b\x9d\x8b\x42\x47\x5d\xde\xae\x8d\x16\xd2\x2b\x02\xf2\x8b\xe6\xd8\x82\x50\x79\xb8\xd0\x49\x8e\x6e\xa9\x56\x60\xe6\x6b\x2d\x7e\x53\x8c\xc5\x64\xd0\xed\x11\x64\xfd\x02\xd8\x63\x55\xb7\x97\x2e\xda\x67\xc6\x97\x27\xdd\x20\x31\x4e\x8a\xfd\xf5\xad\x30\x50\x21\xf4\x00\x08\xa1\xce\xaf\x82\x87\x48\x95\xed\xa8\x5d\x48\x66\xb0\x12\x9e\x0f\x5b\xb4\x5a\xc2\x78\xcb\x1d\xe2\xc5\x05\x5c\x2e\xc2\x20\x91\xe0\x80\xbd\x2b\xa2\x5c\x5f\x16\x34\x13\x62\x98\xa6\x4f\x76\xaf\x1a\xff\x82\x8a\x92\x23\xbb\xae\xf6\xb1\x88\xc5\x76\x21\x82\x6c\xcc\x04\x2c\xd4\x78\x3c\xec\x1a\x44\x13\x78\x49\x4e\x02\x2d\x46\x13\x82\xec\x65\x2c\x2f\x89\x5c\x6d\x82\xde\xd3\x64\xb4\x50\x79\x98\x12\xc4\x49\x72\x86\x83\xc7\x90\x26\x24\x8a\x11\x47\x1b\xbc\x4b\xf1\x4b\xb6\x16\x84\xd6\x87\x31\xc4\x71\x12\x97\x7a\x47\x9f\x21\xaf\xa3\xb2\xb5\x41\x05\xed\xbb\xc0\x11\xb9\x33\x38\xad\x11\xcc\x8d\xcd\x04\x39\x37\x55\x3b\xc8\xb4\x56\x65\xe6\x67\x20\xb0\xe9\xdd\x8c\x1e\xbf\x4c\xbb\xf8\xce\x90\x6f\x9c\x74\x70\x92\x52\x3c\x73\x9a\xe5\x6b\x30\x04\x55\xe0\x2d\x0b\x82\xa2\xc0\x82\xb0\xe6\x9c\x3d\x43\x98\xcb\x01\xbe\x43\xb1\x9e\x9e\xd1\xf6\x1c\x57\x6a\x41\x9c\xb2\xb5\x0c\xda\x4f\x69\xc3\xed\x9f\x8c\xa5\x92\x69\x6c\x30\x07\x18\x47\x74\x63\x3d\x07\x54\xa3\x09\xac\x75\x35\x9d\x3c\xd9\x84\xf1\x85\xfa\x27\x4d\x8a\x3e\x23\x05\x8e\xab\x0d\xee\x41\xa7\x44\x88\x16\xa2\xc3\xe4\xb6\x85\x10\xa2\x29\xe8\x6d\x83\x22\xc7\x9b\xf1\x19\x58\x21\x10\x0e\x2d\xea\x97\xce\x9c\x61\xbe\x52\x1e\x95\xaa\x82\xb9\x99\x5f\xad\xf4\x91\x7d\x29\x3b\xcd\x3b\x36\x13\xc5\xef\xd0\x9f\xb2\x28\x8e\x8e\x6f\x3a\xd6\x94\xfc\x71\x43\x5e\xfd\xf9\xc7\x95\xed\xa9\xfb\xad\xdb\xb5\xe9\xad\x41\x3d\x8e\x7a\xf9\x1a\x4f\xef\x07\x62\xca\x09\x85\x64\x84\x7e\xf8\xca\xc5\xdb\xdb\xfb\xb6\x8d\xd7\xee\x68\x7a\x97\x6e\x2f\x4a\x7e\x98\xc7\xaa\xc5\xa4\x7a\x53\xe8\x2c\x4a\x82\xa6\x4a\x23\x32\xc5\xad\xc3\xf3\x10\x69\x0b\xe1\xff\x5a\x7e\x5f\xa2\x7b\x63\xbb\x8c\x1e\x5d\x6f\x07\x96\x62\x52\x3a\xf4\x76\x3a\xeb\xa3\xe2\xf6\x3f\x65\x3f\x09\x74\x5a\x5d\xd6\xb8\xdf\xd5\xa0\xdf\x67\xd5\xaa\x4d\x6b\x0e\xea\x16\x14\x26\x8e\x7a\x7a\x9f\x71\xb3\x1f\xe5\x25\xc3\x55\x43\x57\x5c\x59\xde\xda\xbb\x65\x73\xf5\xb6\x86\x37\x69\x76\xa2\xe4\x07\xb9\xac\x5a\x97\x64\xef\x08\x1a\x14\x11\x9f\x54\xa9\x16\x56\xe6\xac\x51\xcc\x43\x8e\x1c\x24\x6d\x04\xc4\x8c\x6b\xc0\x69\x0c\xdd\x77\xb4\xc6\xbf\x05\x12\x23\xf3\xe6\xaf\x3b\x0f\xcd\xf8\xcc\x8b\xc9\x09\x25\x79\xcb\x47\x1f\xad\x38\x40\x35\x3a\x79\x71\x29\xb4\xa8\xac\x7c\xe2\x8c\xac\x4e\xdd\xe7\x3d\xfd\xb4\xc6\xec\xc5\xdd\x42\xd6\x81\xc5\x5e\x5c\xfe\xa9\x53\xf9\x38\x5d\x07\x02\xeb\xf5\xaa\x5d\x9a\x3f\x7b\xbc\xa0\x72\x57\xf9\xb5\xf2\xd2\x5b\x7f\x2d\xec\xb9\x2b\x57\x0f\x18\xa4\x71\xd9\x29\x5e\x32\xd5\xf8\xdf\xfd\xc7\x2d\xc8\xcc\x1b\x4b\x4b\xa0\x14\x30\x67\x34\x89\x4c\xd2\xbc\xee\x26\x4f\xf9\xb2\x53\x50\xbc\x64\xed\xe0\x02\x9d\xc5\x9e\x2d\x6d\xb2\x15\x80\x05\xc7\x3e\xf7\xb8\xdd\xf3\x80\x87\x6e\xec\x78\x1b\xca\x51\x79\x59\xe5\xb4\x8e\x00\x62\xe1\x1c\xe2\x89\x79\xa6\x43\x12\x51\x9a\x08\x9b\xce\xc7\xfa\x41\x00\xcf\x19\x93\x29\x08\x98\x8f\x42\xcb\xeb\x44\x60\x3c\x60\x92\x88\xec\x99\xc1\xd7\x18\xb3\xb1\xb2\xf0\x05\xe9\xbf\xfe\x37\x9e\xc9\x07\x91\xbb\x25\x66\x22\xa5\x59\x89\x16\x93\x15\x8d\xfb\x3e\xb6\x92\xd9\xd0\xa8\x47\x5d\xdc\x54\x7d\xea\x5f\xf3\xe2\xfa\x9d\xc3\xea\xc8\x54\x18\xc4\x2c\x61\x7f\xd2\xec\xdf\x5e\x26\x78\xd4\xa0\xab\x91\xe7\x2c\x76\xa5\x34\x98\x45\x70\x57\xf0\xc2\xb6\x9f\xf2\x53\x84\x41\x14\xfd\x4e\xef\xe2\x85\xad\x08\x67\x6a\xde\x29\xde\xc9\xec\xe2\x26\xaa\x8a\x64\x99\x00\x0c\xba\x35\x0b\xb8\x34\xad\x7f\xe4\xfe\x28\xda\x04\x08\xe7\xe4\x24\xc1\xfd\xe3\x73\x44\xe2\x42\xdd\xa6\x78\x9d\xf0\x4f\x9f\x68\x11\xaa\x58\x51\x9f\xcc\x4c\xe2\xb2\x77\x98\x05\x8a\x60\xed\x1f\x71\x8e\x6e\x1d\x50\xee\x88\x73\x54\xa1\x17\x73\xdb\xd5\x27\x40\xc7\x54\x7a\xc0\xbd\x2c\xed\x32\x1f\xcc\xe8\x4a\xb5\x2a\x6e\x6a\xde\x88\xfb\x34\x5f\x98\x7d\x33\xb9\xb8\x17\x9d\x9c\xbb\xd7\x99\xc7\x6a\xc5\xd2\xab\x2d\xab\x25\x69\xf9\xa8\xf2\xa5\xbd\xe9\x0a\x80\xf2\xb7\x01\xbd\xc2\x50\x92\x4f\xf3\xa4\x46\x3f\x8f\xad\x6b\x6a\x53\xdb\x23\xed\x07\x04\x47\xfa\x27\xeb\xca\x70\x1b\xf6\x31\xe6\x8e\x1d\xbd\x4a\xc3\x18\x6d\xea\x62\x06\xda\xf6\xcd\xd5\x61\x5b\xef\x32\xef\xb1\xe5\x3f\x6b\x4b\x71\x01\x1c\xa7\xb2\x21\x8c\x88\x40\x2d\x5e\x59\x39\x37\xf7\x2a\x9d\x96\x6f\x30\xf0\x81\x91\x69\xc5\x4d\xd2\x6c\xe4\x3d\xf5\xdf\xba\xfc\xb6\xb4\xed\xaa\xbf\xa5\x92\xf6\xbe\x28\xe9\x37\x67\xa9\xbc\xbf\x5f\xab\xdf\xc7\x99\xc7\x04\x57\xe5\xd8\xa3\xa4\xd3\x2e\x2e\xfb\x8d\x0a\x8c\x0e\x70\xcd\xdb\x1e\xe8\x6b\xa4\x8c\x03\x9f\xae\x0b\xee\x23\x0f\xac\xf3\xf8\xf8\xc1\x63\x5d\x06\x40\xe0\xf9\x03\xee\x97\x92\x8d\x71\x03\x8b\x6f\x9a\x73\x16\x5d\xac\x76\x4b\x8e\xc0\x69\x5d\xd3\x43\x15\x2b\x1d\x9a\x4b\x36\xd6\x0b\x2d\xed\x2f\x27\x53\xa2\xcb\xe8\x7b\x56\xaa\xe1\x46\x23\x70\x05\xc6\xa6\x75\x4f\x26\xe1\xe5\x67\x1e\xf4\x7a\x89\xa9\x75\xf2\xe0\x74\x92\xaa\x78\x65\x4c\x94\x2e\x8a\xa8\x76\xde\x73\xdc\x4d\x66\xef\xd1\x9f\x40\x2f\xe3\xce\x29\xf6\x75\x95\xb0\xef\xc8\x1b\x41\xe3\x29\x1b\x30\x21\xdb\xbd\xf8\x00\x29\x2f\x59\xb8\x08\xa2\xc6\x5f\x24\x6d\x55\x3f\x53\x7f\x5e\x15\xde\x09\x47\x71\xd1\x01\xda\xcb\x13\xc8\x56\xc4\x8b\x6a\x2e\x76\xdd\xd6\xf1\x55\x48\xa1\xf3\x30\xc1\xca\x6d\xc7\x95\xd6\xd8\x2a\x33\x12\xa8\xbc\x87\xd0\x62\x07\x74\x33\x80\xa3\xda\xc9\x28\xe1\xcf\x24\x46\x23\xb1\xc4\x50\x83\x68\x7a\x5a\x98\xb2\xb2\x6f\x11\xb6\x14\xda\x5c\xa2\xc8\x64\xf9\xe6\xb2\xa0\x70\x6d\x1c\x4c\x91\x7e\xf6\x4c\x0c\x6a\x0e\x13\x62\x10\xcb\x6d\x10\x6d\x4b\xe5\xd0\xc7\x09\xa8\x71\x73\x4e\xf1\xb6\x22\x51\x5f\x51\x68\x39\xd1\x09\x2d\x91\x1b\xdb\xe3\xb3\x9f\x43\x55\xcf\x03\x01\xd1\x9f\xfd\x8f\x4f\xea\x3d\xde\x86\xf6\x79\xd4\x35\xf1\x84\xd1\x0c\x59\x6b\xc8\xed\xd4\x1f\x8a\xc3\x4e\x2e\x65\x1c\x75\x9b\x69\xad\x23\x75\xb9\xe5\xda\x92\xe0\xa0\xa0\xb9\xad\x92\x70\xd5\x0c\x2a\x93\xd8\x21\xa1\xf4\x43\x5f\xdf\xbb\x33\x8c\xd5\x51\xda\x70\x83\x61\x7a\x04\x6d\xa6\x67\x1a\xe7\x2d\x96\x8c\x99\x09\xb9\x2d\xe5\x89\xf3\xf4\x07\x00\x02\x6b\x0a\x0b\x38\x89\xab\x5a\x07\xc4\xc3\xe8\x8e\xa7\x16\x96\x59\x50\x94\x64\xcc\x1f\x4d\xaa\x9c\xb1\xf1\x60\x54\x47\xbc\xb5\xd0\x1c\x68\xd1\xa4\x5d\x3a\xab\x64\xf8\xd4\xd0\x56\x4e\xcd\x76\x02\x63\xaa\x57\x3a\x77\x99\x13\xeb\x8d\x7c\x6b\xd2\x81\x2e\x3a\xd3\xab\x1e\x8d\x4f\xdd\xda\x91\x73\x80\x77\x1c\x20\x70\x00\x54\x12\xca\xd2\x1f\x0c\x80\xb6\x25\x7a\xce\x81\xd9\x87\xc1\x2a\xec\x30\x29\xd8\x0c\xea\x1e\x41\x07\x26\x33\xaf\x92\x13\x50\x50\x51\x5f\x69\x2e\xde\x2d\x5a\xe9\x21\xe1\x8d\xd1\xf6\xbd\x25\xd1\x54\x74\xf6\xa8\xf8\x66\x33\xeb\x6b\xd7\xb4\xde\x2b\xb4\xf0\xb4\xff\x66\x83\xd0\xdd\x36\x8b\x9d\xe3\xb5\x07\xa5\x0b\xab\xd5\x36\x6d\x50\xd0\xd1\x8f\x48\x34\xb1\xd7\x87\x18\x85\xc3\x32\xfe\xd5\xfc\x0a\xb1\x75\x6d\x4d\x43\xcd\xa5\x06\xe7\xa1\x70\x6d\x2a\x59\xcb\xad\xab\x8b\xd2\x39\x0e\x01\xc2\x5f\xbb\x9d\xf2\xe2\x15\x4a\x11\x5b\xc4\xf3\xf3\xba\x2e\x39\xb4\xd7\x26\xf3\xe1\x2c\x72\x80\x48\xb8\x69\xdf\x83\x38\xc9\x85\xa0\xef\x61\xc2\xcd\xd6\xc8\xdf\x19\x97\x5b\xbf\x4e\x1e\x98\x6e\xb3\xfe\x3c\x8e\x43\x72\x78\x4c\xb5\xef\x72\xf9\x4a\x32\xe2\x76\x63\x18\x14\xfe\xe4\x3e\x78\xcd\x09\xfc\x9c\xee\xd6\x11\xe4\x4a\x1e\x82\x23\x75\xe3\xa4\x07\xb7\x3a\x6e\x59\x93\x16\x9d\x98\x7d\x1a\x6c\xf4\x7a\xc2\xd3\xae\xb4\xe9\x5e\x59\x3b\x9e\xb6\xe4\xb1\x7a\xb4\xea\xb3\x17\xd3\x89\xac\x31\xc0\x60\x37\x7a\x83\x76\x2f\x9a\x98\x5f\xe7\x9c\x93\xb0\xca\x0e\x7b\x90\xcf\x1b\x3d\x27\x54\x87\x20\x60\x4a\xd9\xbc\x5d\x18\x02\xf8\xc8\x87\x55\xcb\x02\x29\x4b\x7b\x76\xfb\x5b\xa5\x84\x14\xb0\xd5\x9d\x79\xac\x60\xd7\x2d\x30\x2d\xd3\x3f\x9d\x9a\xc1\x5e\x82\x9a\xff\xc7\x5b\xc9\x6d\x03\x0f\x53\xc6\x90\x1e\xc2\x3d\xf9\x03\x4f\x23\x5f\x44\xad\xad\x9d\x71\xc8\x71\x1a\x8e\x6d\x52\x1f\x30\x0e\xcd\x1a\xc2\xd3\x29\x95\x0a\x69\xa2\x62\x11\x4a\x9d\xb1\x7d\xe7\xce\xed\xf8\x3c\xdd\x77\xf8\x6f\xe2\x61\x81\x01\x19\x36\xba\x5b\x9e\xf6\x81\xbb\x5e\x44\x85\xde\x1c\x84\x5a\x7a\x60\xaf\xab\x9c\xe0\xcc\xb6\x2e\x44\xe6\x4b\xcf\xf2\xa7\x7f\xcd\x1a\x3d\x62\xb1\x05\x09\x9b\xc6\xe2\xee\x62\x88\x00\xe4\x9d\x6c\xad\xde\xb2\x77\xed\x97\x82\x4d\xe2\x18\x9a\xd3\x06\x37\x64\x18\xd6\x86\xa5\xa3\x08\x85\x80\x15\x80\xed\x23\x77\x51\x5d\x21\xb0\xf6\xd8\xcb\x98\x98\x14\xf3\x67\x31\x7d\x42\x4a\xda\x39\x89\x86\xfa\xc4\xc2\xd4\x8e\xf1\x49\xae\xf3\x3d\x43\x56\x52\x8d\xb9\x25\xce\x4c\xd5\x4d\x55\xa2\x5d\x43\x28\xf5\x2b\x23\x4f\xf7\x31\x51\xae\x64\x6a\xca\x32\xbe\xb9\x7e\x12\x26\xc7\x42\x27\xd9\xa9\x70\xbe\xd9\x63\xf0\x51\xde\x1c\x34\xcc\x1b\x31\x23\xb0\x96\x9a\x71\x1d\xca\xb8\x4c\x8f\xc9\xcc\xae\xae\x4c\x9b\xe2\x9e\x92\x16\x08\x9b\x86\x19\x0e\x47\x5a\x74\x2a\x6a\x18\x96\x1e\x49\xb6\x60\xe8\x16\xdb\x51\xb5\xa2\x8d\x2f\xd0\x02\x48\x4a\x65\x7f\xd6\x6c\xb9\xe8\x87\xd2\x1f\xe8\xb1\x8e\x95\x9b\x94\x78\x5b\x30\x94\x44\xa3\xd6\x8c\x31\xc2\xc0\x53\x54\x4b\x89\x61\x66\xd4\x3b\xa2\x0c\xf8\xd9\x33\x60\x17\x4c\x98\xb0\x7d\xe4\x8d\x7b\xd8\xa7\x4a\x11\x26\x35\xb3\x80\xb1\xc4\xd9\xea\x4a\x84\x5e\xb7\xfc\xf5\xb4\x47\xbd\x8f\x86\xa1\x86\xeb\x26\xf5\xf6\x9e\x78\xad\xee\xb2\x25\x6e\x86\x71\x23\x23\xe9\x47\xb3\xa1\x37\x96\xa4\xff\x70\x28\x2f\x38\xf9\x84\x9d\xd7\xca\xb6\x4a\x1b\x47\x79\xd1\x1b\xbe\xf6\x38\xd1\x3f\x96\xa4\xff\xb0\xc8\x2b\x3e\x49\x08\xb4\xa5\xae\xf8\x8f\x10\xe5\x85\x8b\x57\xe2\xbb\x54\xdc\x6d\x0a\x41\x6a\x98\xf7\x2f\x62\x88\x07\xa6\x88\xb3\x59\x46\x4e\x47\xff\x75\x17\x63\xfe\x04\xf7\xb5\x8e\x5c\xae\xc1\x8b\x88\xcf\x3a\xeb\x69\x25\xba\x96\xe1\x66\x55\x2c\x70\x17\xe6\x82\x49\xec\x8d\x70\x20\xff\x96\x5e\x79\xb6\xeb\x95\x1f\x08\xf7\x42\xc0\x63\x78\xc2\x32\x8a\xd0\xec\x1b\xf7\xca\x16\x0d\x56\x62\xe0\xa7\x36\x4e\x01\xbf\x64\x0b\xd6\xd9\x8d\xd3\x99\x54\x80\xe4\xe6\x9d\x6c\x14\xc6\x57\x86\x7b\x74\xc4\x88\x54\x7b\xf0\x96\xe8\x53\x11\x1e\x2f\xa5\x51\x95\x59\xfe\xa5\x4b\xfd\x8e\x15\xd5\x37\xb7\xe4\x23\x12\xae\xbb\x70\x16\x51\x63\x47\x6f\x91\xde\xf0\x67\xfb\x51\xa0\x80\x47\x3f\x65\x3c\x80\xf3\xb4\xe8\x05\x74\x19\x86\xfd\xe7\x4a\xa0\xf8\xe9\xac\x38\xb7\x33\xd7\x59\xb5\xb5\xde\xa8\xfc\x46\x5e\x3a\x9e\xcc\x8a\xe3\x7c\xee\x8e\xca\x9a\x38\x60\x72\x7d\xe0\x51\xe7\xc1\x68\x46\xe9\x34\xd5\xeb\xa2\xba\x6a\x22\xb3\x3a\x6b\xa2\x32\x3b\x6b\xa3\xce\x2e\x2c\xef\x26\xfe\xd6\x7a\xdb\x54\x49\x46\xb7\x54\x79\xf8\x3d\x9d\x4b\x99\xc2\x3b\xc2\x70\x72\x02\x24\xdc\xd1\xb2\x80\x38\x66\x5f\x9b\x93\x54\x49\x1f\x56\x5b\x85\x8a\x5b\x01\xb2\xc5\xba\x60\xf6\xc2\xe6\x2e\x4e\x0f\x30\xce\x55\xb8\xa9\xe3\x38\x49\x00\x59\x9e\x97\x0d\xc7\x44\x35\x0f\x95\x37\xf6\x6f\x2d\x0a\x1c\x21\xf3\x6d\x76\x39\xa9\x8f\x1c\x5c\x2f\xb5\x4b\x52\x99\x9d\xb1\xe2\x21\xfd\x1e\x8c\xff\x36\xff\x88\x0c\x81\x62\xe9\x1e\xc9\x5c\xb5\x2b\x27\x49\xe7\x65\x2f\xb1\x9d\x61\xf6\xca\x46\x7a\x1b\xcd\xb7\x10\xfb\xb5\x7b\xed\x8b\xf3\xf0\x50\x7c\xf3\xb5\x77\x8d\xc3\x34\x65\x6a\x2d\xa5\xa0\x74\xc2\xdb\xa0\x5e\xc2\x5c\xdf\x53\x4b\xd7\x2b\x27\xbc\x4a\xe6\xfb\x52\x9b\x82\x53\xf4\x8e\x00\x1d\x66\x99\xf0\x0e\xc8\xe6\x82\x03\x34\xbe\x96\xd4\x96\x2b\xc6\x65\xf9\xd0\xc7\x22\xd3\x83\xd6\x6a\x1a\x5c\x91\xf3\xca\x8c\xe0\x45\xcd\x2e\x02\xc5\x3e\x70\xb6\xe6\xed\x97\x21\xcd\x5c\xec\xbe\xf5\x42\xf5\xe0\xb8\xc3\x7d\x76\xda\x86\x4e\x21\x07\x22\x66\xc5\xeb\xba\xe3\x52\x8b\x30\x72\xd6\x47\xc0\xdf\xbb\xc0\x2a\xb9\xd0\xfd\x1f\x20\xad\xc6\xf6\x95\x8d\x2f\x4a\x95\xe4\xf3\xe2\x36\x1b\x98\x4d\x9a\xfe\xf1\x6e\xff\xeb\xca\x7e\x8b\xab\x7d\x7d\x18\x3c\xf1\xed\x8e\x1d\x6f\x13\xe1\xb0\xe0\x98\xe7\x6c\xcf\xb8\xfb\x70\xef\xfc\xbd\x66\x25\xed\xde\xff\x10\x6e\x7e\xdd\xd8\x57\xd5\x58\xee\x55\xe1\xbc\x6c\x11\x41\x21\xb9\xcb\x8d\x21\xd3\xab\xc2\xfd\xfd\x38\xeb\x69\x44\x2a\xb9\x7a\x12\x33\xc9\xd9\x40\xb8\x85\x45\x59\x6f\xca\x05\x4a\xd2\x4e\xf1\x43\x38\x66\xa4\x04\xb7\x92\x2c\x03\xe3\x52\x1d\x12\x09\x9c\xc6\x8f\x83\x6d\xd6\x77\xf0\xac\x45\x1b\x0e\xc1\xf1\x28\xc9\x69\xfd\x77\x4c\x8c\x05\xdf\x65\xee\xe3\x37\xeb\x78\xd0\xac\xbb\xf2\xd3\x32\xed\xe7\x4c\x7a\x00\xac\x20\x42\xa2\x08\xc1\x2c\xe4\x27\x1a\x5c\x6e\x40\x4f\xde\xa4\x6c\x0b\xef\xf7\xff\x18\x6f\x3c\x69\x91\xbd\xe3\x59\x55\xc8\xd7\xca\xa3\x96\x3a\x87\x38\x96\xde\x70\xec\x80\x75\xa3\x88\x5a\xe5\x13\x38\xf3\xb9\x26\x3e\xe6\x73\x34\x50\x63\x58\xa1\x59\xfb\x13\x96\xc5\xdf\xcf\xef\x0b\xe5\x11\x8f\x7d\x74\xf2\xac\x70\x8f\x2d\xb4\x09\x89\x8e\x79\x43\x1c\x26\xea\x1f\x83\x7a\xa5\xb1\xca\x0a\x0e\x5a\x60\x37\xa1\x29\xaa\x3c\x69\x9f\x1d\xa9\xa2\x36\x4f\x67\x67\x74\x7f\x78\xbc\x0a\x68\x54\x49\xba\x1f\x77\x31\x61\xee\x72\xcc\xcc\xde\x33\x3b\x65\xae\x17\x1e\xbb\x99\xe5\x30\x74\xfe\xd0\xeb\xfc\x1e\xfd\x59\x73\x6d\x76\xcb\x59\x45\xf6\x8d\xde\xc3\x1a\x7b\x29\xae\x4b\x1e\x92\x92\xf6\x59\x1b\x68\x01\xf4\xa3\x1d\x26\x8d\xdb\x91\xc7\xb6\x85\xf7\x1b\x58\x9e\xee\xd6\xe1\xb1\x3e\x54\x29\xab\x30\xff\x6a\x4a\xa2\xf9\xd8\xd7\xaf\x8f\x24\x37\x0a\xa0\xbf\x93\xa2\x80\xdb\xb7\x6f\x12\xc1\x55\x63\x6b\x97\xb1\x77\xf1\xd4\x59\x3b\x38\xa0\xb6\x3e\xcc\xeb\x80\xf1\x2b\x67\xd1\x36\x77\x26\x24\x1d\xd1\x3e\xde\x82\x75\xcb\xeb\xb6\xee\xfa\x3e\x1b\xc2\x0a\xdd\x56\x5a\xeb\xc1\x88\x4a\xb4\x05\xa3\x91\x1a\xb4\xb8\x67\x82\xcb\xbf\xe5\x3d\x8a\xfe\x83\x3e\x4f\x8b\x01\xe5\x69\xe9\xb6\x5d\x40\x9c\xc9\x01\xff\xe5\x51\x59\xd6\xf7\x86\xf9\xa7\xf7\xd8\x4f\xda\xe6\xda\xf2\xbf\xd2\xc6\xbd\x0c\x41\x49\xae\x4e\x25\x46\x28\x9d\xe0\x9a\x04\x59\xfe\x39\xcc\x39\xa3\xde\x4a\xd5\x43\x08\x34\xce\x51\x40\x4a\xfd\xb8\xb6\x39\xa0\xe1\x75\xae\x33\x70\x3d\x05\x82\x30\x41\xa3\x8a\x31\x0a\xb8\xe4\x2c\x5e\x19\xf5\x3e\x05\x84\x28\xb5\xda\x48\x52\xa9\xd4\x42\x78\x8d\xb5\x4c\xd4\x87\x88\x6a\x2d\x18\xf0\xed\xef\x61\xda\x70\x33\xad\xff\xfb\x37\x75\x62\x03\xf0\x4e\x56\x34\x7c\x07\x11\x75\x87\xa0\xe7\xa0\x8b\x61\x6c\x65\x0c\x8d\x9a\x7a\x08\xa2\xf6\xa8\x4a\x40\xea\xd5\x35\xfa\xab\xe2\x79\xb8\x43\x17\x07\x8d\x51\x40\x52\x52\x71\x82\x4f\xf9\xa7\xb0\x3c\x2f\x1d\xe4\x26\xf1\x1d\x49\x47\x26\x02\x2d\x70\x40\x5f\x53\x2f\xbb\x6d\x6e\xa6\xf5\xbf\xd8\xc2\x03\x63\xa6\x90\x5a\x35\x3b\xf5\x3c\x79\x04\x09\x18\xe3\xcb\x18\x2f\xe9\xaa\x9e\x50\x96\xc8\x65\x7f\x20\xe0\x9d\xb6\xfa\x81\xad\x02\xf0\xa2\x04\x94\xd3\x07\x96\x50\x2e\x57\x6b\xf4\x59\x89\x44\x34\xce\x01\x3c\xed\x1f\x41\x8a\xfa\xa5\xd3\x17\xa6\x90\x4e\xc7\xac\x95\x9a\x69\xc5\x44\x95\xf6\x0e\x4e\x24\x7f\xc2\x37\x20\xed\xf7\x2e\x86\x20\xd2\x2b\xcb\xc0\x67\x1c\x49\x9c\x67\xa1\xc6\x3a\xb5\x23\x3f\xe1\xb8\xa4\x50\x75\x47\x97\x17\x71\x2b\x35\x3c\x28\x93\x19\xcf\xda\xae\x2d\x48\xbb\x4a\x44\x9f\x1b\xaf\xb8\xe0\x55\x31\x26\x67\xec\xbb\xce\xbe\x23\x59\xb9\x02\x18\x23\x7d\xc4\x83\x90\x89\x07\x2d\x94\x73\xa3\x15\x3c\x49\x9a\xca\xb9\x8d\x60\xce\x7b\x36\xc2\x81\x70\xd8\x53\xa4\xfb\x9a\x75\x41\xeb\x9c\x6d\x6d\x16\x8b\x47\x83\x70\x3c\x10\xed\x99\xdc\xfa\x73\xf8\x4f\x69\x63\x30\x02\xca\xb6\x82\x75\xbf\x18\xf8\x05\x9d\x94\x9c\x66\x1e\xc2\x35\x6f\x23\x0f\xac\x92\x9c\x92\x1f\xda\xd5\x2e\xef\x6f\x5d\x85\x6c\xae\x3c\x28\x7f\x49\xeb\xd5\x96\x2b\xd0\x20\x5b\x14\x44\x2d\x96\xb1\xd3\x12\x64\xa1\xf1\x04\xbf\x71\x1d\xea\x9d\xbb\xe1\x29\x19\xcb\x3c\x55\x50\x71\x79\x6f\x51\x5e\x34\x39\x4b\x1c\x9b\x12\x23\x09\x2a\xc1\xbf\xf1\x25\x5e\xfe\xe6\xf6\x8f\x22\x56\x1f\x76\x84\x1c\x2a\x2d\xc2\xe6\xea\x73\xd9\x79\x31\x22\x4e\xa4\x21\xc3\x34\xc6\x08\xf0\x5c\x55\x24\xd1\x9f\xca\x8b\x5b\xad\xcc\xc0\x4d\x7d\x81\xdf\x91\x4f\xbe\x7f\x72\x02\x3d\x99\xf5\x4b\x2d\x91\x07\x0a\x89\xbf\x38\x32\x49\xe5\xad\xfe\xde\x2b\x91\x08\xca\x28\xb1\x1d\x59\x64\x6d\x68\xaf\xa6\xc5\x90\x88\x9c\x05\x4c\x61\xa0\xbc\x24\x55\x99\x54\x97\xae\x0a\xf6\x94\x43\xf7\x28\x06\x0f\x04\xbe\xda\xe5\x8a\x1d\x8e\x1d\x27\x20\x48\x28\x04\x78\x0e\x08\x19\xcb\x15\xb5\x0a\xf6\x03\x03\xca\x3d\x9e\xaa\x3c\x58\x55\x97\xae\x51\x94\xa4\xca\x03\x89\xc2\x05\x4c\x0e\x29\x46\x4d\x8b\x87\x5e\xab\x3e\x86\xc2\xbc\x85\x70\xc5\xde\x18\x85\xef\x31\x03\xcc\x42\xb8\x8f\x6a\xb0\x2a\xbd\x0e\x08\x19\x4f\xf2\x80\xed\x7c\x4f\xb1\x0e\x0c\x14\x2c\x82\xee\x02\x8a\xfd\x91\xee\x30\xc9\xdf\xb0\xaf\xca\xb9\x02\xd0\xbd\xf3\x88\x2c\x1c\x75\xee\x89\x80\xc3\xe8\x84\xfc\xc0\xc2\x0a\xb4\x48\x73\xfe\x12\x35\xbd\xde\xc4\xb2\xd9\xca\x52\xa5\xd5\xea\x28\xa5\x87\xf3\xf5\x8d\x2b\xa4\xd0\x46\xbb\x4c\xc7\x1f\x3f\x46\x68\x23\x7e\x4a\x17\xf4\xf2\xbd\x31\x0f\xf5\x94\x96\x96\x02\x1c\x0b\x94\xb4\xa1\x10\x70\x29\x4f\x22\xcd\x2d\x4a\xc8\x12\xfd\x71\x10\x0d\x9b\x02\xc9\x83\x37\xc7\x75\x36\x95\xd7\x28\xdb\x84\xa2\xbf\xf7\xab\xec\xff\xee\x96\x21\x50\x40\x81\xea\x08\x3e\x1a\xc3\x81\x31\x94\x0a\x00\xa4\x26\x14\x19\x27\x8e\x73\x33\xad\xd9\x87\x86\x58\x2c\xeb\x39\x59\x83\x17\x7c\xbf\x73\x1a\xab\xd3\x41\xc8\x43\x45\x76\x70\xc6\x7c\xcc\xba\x25\x14\x98\xb3\x04\x33\xb8\x37\x1f\x7f\x94\x5f\x2a\x78\x43\xeb\xe6\x38\xcf\x0a\x3c\xa3\x22\x8c\x1f\x1b\x27\x22\x47\xc1\xb5\xf1\xe7\xd2\x21\x07\xdd\xc2\xa3\xc4\x10\xa4\xe7\x56\xf5\xeb\xb3\xa9\xe0\x73\xc0\x26\x3c\x36\x44\x2d\x6d\x9e\x8f\xc1\x9b\xa1\x8b\x0e\x81\x74\xae\x74\x9e\x7a\xe8\x71\x35\xfe\xb7\x22\x6d\xf7\x8c\xaf\xbc\x4a\xeb\xdc\xec\x7d\x5f\xfc\x28\x5e\x0e\xbd\x6d\xed\x27\x56\xa0\xb3\x9b\x9b\x73\x12\xde\x02\xdb\xb4\x46\xf7\x3e\x12\x0f\x7d\x2a\x73\xd6\x56\xc9\x15\xd3\x87\x03\x16\x22\xb0\xa6\xa0\xcc\xf7\x6d\xfc\xb7\xb7\xad\x06\xef\xfc\xfc\xa8\xd5\x16\xf4\xa9\x39\x6f\x71\xa8\xb9\xa7\xba\xd1\xf9\x7b\xc1\x94\x6f\xac\x90\x21\x0c\x3c\x0e\xa2\x7f\x5d\x77\x07\xbf\x40\x61\x0e\xf0\x23\x61\x8c\xc4\xe9\xb9\x59\xd7\x59\x7d\x69\xc1\xa2\x94\xc4\x7c\x23\xd2\x72\xef\xd2\x5c\xf6\x06\xf2\x89\x97\x49\x0c\x02\x94\x5f\xdf\x99\x89\x57\x2b\xdb\xcb\x22\xed\x91\x8e\xff\xdc\x4e\xdc\x9e\x82\x30\x97\x7c\x97\xe7\xa7\x39\xa7\x38\xe8\xd6\xbd\x0a\x2e\xc5\x79\x66\x90\xa4\xb8\x08\xef\x6e\xec\xfe\x73\xcb\xa1\x00\xe8\x62\x98\xbf\xce\x7e\x1d\x70\x2a\x35\x45\x23\x01\xf2\x05\x73\x0a\xcb\x76\x4e\xde\x39\x3e\xd0\x63\xc9\xe4\xe8\xb3\x51\x47\xd5\x21\xeb\x80\xc3\x9a\xc7\x0f\x81\x38\xfe\xfc\xd0\x8a\x91\x79\xb3\x36\x26\xaa\xca\x0c\xbd\x2d\x32\xb3\x7e\x51\xfb\x96\xcb\x00\x81\x5b\xf4\x61\xe1\xb9\x96\x98\xeb\xd0\xbe\x29\x35\xd5\x1f\xe3\xe3\xd9\xe9\x5f\x5b\x97\x91\x7a\xef\x5f\x69\x1e\xef\x74\xaa\xe5\xf3\x62\x28\xdf\xad\x1e\x1a\x4f\xa4\x8d\x3d\xe8\x43\x2f\xfa\xc9\xe0\x9c\x0c\xed\x0e\xb0\x19\x50\x34\x3f\x0c\x0f\x39\xe6\x54\xcb\x2c\x02\xee\x31\x00\xa2\xaf\xd5\xac\xd2\x14\x86\x39\xd1\xcd\x22\xf5\x66\xbd\xe0\xc9\x50\xee\xac\xa6\x5d\x53\xbb\xf5\xdb\x1f\xd4\x9c\x7f\x28\x1f\x30\x76\x34\xfb\x73\xcf\x4a\x07\x73\x62\xb5\x99\x6e\x51\xb7\x7b\xe9\xec\xfc\x06\x7d\xcd\x0c\x23\xc1\x40\xa4\xfd\xf2\xf7\xee\xc9\x8f\xa0\xf1\x9f\x19\x98\x55\xd9\xc1\xfb\x13\xbd\xa6\x5e\xbe\x9c\x52\x2b\x18\x81\x2f\x36\xf7\x27\x0a\x12\xa4\x97\x90\x19\x8b\x8b\x11\xc8\x4b\x68\xa7\xf7\x2d\xed\xdf\x46\xf8\x73\x81\x35\x93\x58\xfe\xb4\xde\x96\x58\xfc\x79\x58\x51\xf7\x33\x88\xd5\xfe\x07\xd2\xe9\x0d\x80\xb8\x9d\xed\x57\x4b\xfd\x8a\xd4\x62\x22\x8d\xa8\x26\xcb\xc3\xa2\xd1\x7b\xd6\x5b\xed\x6d\x13\x96\x70\xdb\xda\x1a\x5a\xa2\xbe\xe2\xd6\xb6\x2f\xca\xb2\x96\xc3\x5a\x5b\xcb\xdb\x5a\x2d\x6c\x24\xde\x4e\x8a\x65\x94\x57\x48\x57\x06\xcf\x4d\xc8\x5f\x18\xd1\x0a\x56\xd3\xa7\xe4\x78\xe6\x73\x93\xe4\x80\xb1\x58\x0d\x29\xe4\xd6\x1c\x1f\x99\x6f\xc1\x43\x26\xa9\x36\xd9\x6c\x98\x6b\x74\x49\x70\x89\xa1\x5d\x00\x2e\x40\x3f\x77\x1a\x53\xb9\x9e\x86\x68\x97\x73\x2d\xe2\x86\x24\xe1\x39\xec\xe8\x6e\xb1\x50\x5b\x03\xb6\x9f\xf8\xf5\xb0\x8e\x70\x83\x59\x8f\xd3\xb2\x47\xe6\xf5\x1f\x3a\xf5\xa5\xaf\xf5\xf5\x99\x45\xeb\x74\xd1\xd7\xe7\xee\x03\x62\x26\xb8\x3c\x0d\x98\x45\xe8\x5f\xeb\xf1\xd1\x70\xd1\x30\x4a\x74\x7a\x1f\xc0\x58\x0c\xa7\xad\x42\xb4\xb2\xf5\xac\x2e\x52\xf6\xed\xfa\xf5\x0a\x2e\x45\xc2\xe2\xc4\x8e\xa0\x94\x75\x2d\x30\x4f\x53\x42\xc3\xbe\x18\x6d\x09\xe2\xdb\xd5\xc7\xa2\x9c\xa0\xf1\xe2\x93\xec\x1a\x07\x5d\x76\x94\x16\xdf\x64\x9d\x60\xb7\x7f\xcb\xc3\x9d\x58\x19\xff\x50\xff\xe0\x9c\xe2\xfa\x9b\x5b\x0d\x17\x8c\xea\x56\xee\x43\xd3\x34\x4f\x10\x91\x8c\x91\xb5\x90\xbf\xf7\x30\x26\x7a\xcd\xcd\x75\xa0\xc0\x34\xc6\x26\xd1\x10\xd4\x45\xa1\xca\x99\x27\x74\xd9\x41\xee\xf6\xcd\x42\xc1\xb5\x25\xda\x2b\x87\x44\xcb\x8e\x47\x1c\x7f\x7e\x41\xed\x78\xd6\x1e\xf0\xbc\x43\x50\x4b\x5a\xaa\x00\x97\x6e\x16\xac\x9f\xe7\xbe\x52\x67\xbc\xbc\x78\xc2\x2b\xce\xf4\x1b\x69\x7c\x1b\xb8\x6f\xf1\xca\x9c\xe2\xf1\x92\x38\xac\xb7\x6f\x9c\x17\x71\x4a\xb3\x60\x03\x9c\x14\xeb\xfc\x47\x14\xdc\xe1\x7e\x0c\x86\x89\xc9\x95\x6f\x20\x50\x0a\xe7\x38\x10\xb0\x79\x0f\x75\x71\x82\xeb\xa2\xb5\xd9\xc2\x08\xcc\xfa\xd6\xf0\x90\xa0\xb5\xfa\x99\xa7\x8d\x8d\x9f\x99\xd5\x8c\x3d\xc6\xb6\x9f\x13\x9b\x54\xdc\xc2\xb7\x6e\x32\x70\xad\x12\xb9\xbf\x61\x41\x1d\x2f\xe1\x46\x5b\x0d\x5d\x2b\x70\x5e\xb6\xb5\x46\xb5\x17\x9b\xc4\x28\xca\xf3\xfd\xc2\x3f\xc9\xac\x33\x67\x67\x01\xf3\xb3\xf5\xd9\x0e\x04\xec\x51\x29\xb4\x01\xc3\xc4\xc4\x8a\xb5\x0e\x44\x4c\x6d\x34\xf7\x98\x47\x3b\xbf\x3f\x38\x31\xd7\x5b\xd1\xab\xd4\x54\xd8\x3e\x20\x3d\xb1\x51\x38\x1a\xe3\x13\xaa\x29\xca\x92\xde\x35\xc1\xa8\x63\x6b\x2b\x67\x64\x52\xbe\xf6\x00\x86\x88\x1d\xc3\x12\x41\x7c\x86\x76\xe4\xec\xfd\x61\xea\xae\x6b\x42\x63\x7a\xff\xed\xe5\x5b\x95\xe9\xc9\x43\x38\x94\x5e\x27\xb3\xd5\xa4\x86\xd4\xcf\x4f\x07\x80\x53\x30\xb7\x83\x2a\x20\x29\x9b\x35\x72\x8f\xeb\x7c\x9f\x80\xc8\xa4\x8a\x93\x5e\xcc\x3f\xf8\x7a\x7d\xb7\x5b\xf0\xa2\xc0\x81\x53\x57\x07\x55\xf7\xbd\x1e\xf6\x1b\xb1\x04\xec\x54\x7d\x1a\x81\x8d\x3f\x4c\xd7\xc0\xf6\xf9\x0e\x55\xcd\x5e\xbb\xc0\x8c\xcd\x7d\x18\x4c\x09\xd2\x36\x68\xb8\x38\xdb\x0d\xee\x62\xe2\x8d\xc7\x8e\x45\xda\xb0\x02\x6e\xbc\x2f\x84\x4d\x01\xd1\xd9\x41\x85\x0e\x04\xec\x36\xca\xe2\xeb\xfb\xb6\x93\x36\x4d\x6b\x14\x3c\xe9\xcc\x75\x39\x8d\x6f\x35\x29\x3f\x71\xa9\x09\x23\xc6\x30\x31\x39\x75\xa3\x41\x2e\xca\x6d\x58\x02\x16\xa9\x69\xc8\xaa\xf2\x66\x67\xc6\x51\x7f\x1a\x93\xb7\xba\x57\x6f\xf1\xfe\x67\xad\x40\xc6\xeb\x18\x75\xac\x3b\xc3\x09\xc9\x6f\x17\x23\x08\x96\xa5\xcc\xf5\x26\x8f\x6f\x34\x8e\x11\x4f\x91\x3a\x6f\x6e\xd3\xf4\x4d\x5e\xa9\x9d\xa2\x3b\x3e\x9e\xe7\x72\x82\x30\xb6\x2e\x27\x9a\x7d\x17\xbc\x29\x58\xf5\xe4\x0c\x22\xa2\x39\x99\xba\x4f\xe7\x0c\xb0\x8a\x8b\x7e\xa9\x2e\x37\x40\x33\xbc\xb4\xf2\xf1\x9a\xbf\x5f\x7e\x49\x2a\xfa\x8f\x95\x60\xfa\x85\x0e\xeb\xd6\xa3\xc1\xb1\x12\x71\xad\x14\xc1\xca\x5e\x0c\x51\x28\x54\x86\x95\xcf\x03\xd8\x04\xdf\xa0\x31\xf7\x60\x60\x06\xc2\xf3\x77\x32\x8d\xbe\xde\xc6\x75\xad\xa4\xe0\xaf\xd5\x93\x05\xaf\xd7\x05\xd8\xa3\x08\xcb\xda\xc5\x30\x06\x12\x8c\x46\xef\xb5\x28\x7a\x63\x3c\xb9\xc8\x6d\x4c\xa9\x68\x63\xf2\xf5\x2d\x70\x13\x14\x86\x3a\x92\x7c\x6d\x03\xe9\xde\x2e\xc7\xa2\xb9\x56\x66\x68\x4a\xe2\xea\x4d\xf8\x7e\x9a\x20\xed\x5b\xd0\xb5\xb4\x7d\xfc\xf4\x72\x8a\xca\x32\x8b\x04\xb8\x7e\xfc\xe8\xa0\x77\x7a\x4a\x05\x90\x3a\xd5\x8d\x7b\xe9\x73\x09\x10\x9e\x33\x11\xf6\xf7\x78\xd4\xba\xd7\x2c\x47\xb7\x20\x9d\x4d\x4b\x64\xbc\x9a\xb0\x76\x17\x25\x62\xed\xb1\x6f\xbe\x83\x7f\x07\xd6\x7c\x02\xe0\xfc\xad\xda\x6c\x36\xa5\x7a\x09\x5e\x61\x43\x47\x3b\x7a\x56\x6c\xb8\x0e\x20\x7c\x5f\xf5\xc3\x0f\xa6\xfd\x6d\xe0\xaf\xb7\x45\xa9\x5a\x51\x6c\x9c\xee\x5a\x1c\xeb\xee\x3e\x67\xb7\xe9\x10\x73\x53\x6f\x98\xac\xbf\x6c\x07\x9b\x03\x87\xf3\x50\x8f\xe4\xae\x1b\x38\xff\x43\xe8\x34\x3e\x40\x15\x9a\x8f\xf2\x80\x65\x31\x62\x14\xcf\x82\x1f\xdc\x1d\x9c\xe0\x09\x20\x0e\xfe\xcc\x7a\xd0\xd7\xf7\xe0\x46\x08\x5d\xb5\x35\xb6\x03\x51\xc6\x83\x8c\x2f\x59\x0d\xe1\x76\x41\x66\x47\xdb\x57\x12\x4a\x3b\xff\xa8\x3d\xde\x79\x77\x16\x40\xbc\x52\xbf\xdb\xe5\xfe\x71\xba\x19\x5c\x03\x12\x6b\x4b\x30\x7b\x32\x74\x76\xed\x30\x06\x3d\x22\x77\x0d\x30\x7f\xc4\x4e\xde\x17\x94\x03\xf5\xbc\x72\x0d\xaf\x44\xee\x6e\xda\x06\x83\x4a\x60\x33\xc4\x37\xf9\x25\x2f\x2d\xc3\x2a\x9d\x52\x9e\xee\x80\x2e\x55\x2b\xfc\x5b\x6c\xaf\x51\x9d\x86\x37\x48\xc2\x16\x7f\xc1\xd7\xf3\x30\x78\x1b\xf8\x2f\x7b\xc7\x86\x01\x71\xb0\x90\xc1\x38\x3e\x36\x46\xb2\xbe\x0e\x27\x30\x2a\x08\x47\x5c\xf2\x51\xdb\x61\xd7\x24\x3b\x03\x9e\x68\x89\x66\x14\x00\x45\x42\xd7\xfc\xa7\x99\x43\x12\xba\x96\x84\xb7\x2d\x60\x19\x30\x81\xdd\x01\x29\xf0\x8f\x83\x79\x94\x5b\x68\xca\x91\x91\xf6\x13\xbf\xc4\x56\xea\x95\x0a\x48\x32\x9e\x70\x43\x8a\x19\xb4\x78\x51\xb5\x50\xc2\xa5\xf0\xe8\x39\x9a\x12\x3e\x26\x7a\x67\xe1\x80\xad\x8f\x2a\x95\x2b\x6b\xc9\xbc\x84\x27\xc5\x14\xbf\xca\x57\x5f\xa4\x7e\x49\xf9\xb5\x8e\xc1\x50\x67\x5f\xf7\x10\x43\x4f\x7b\x62\xf1\xe2\xce\xcc\x96\x89\xa3\xaa\x61\xd5\xb7\xf3\xb6\x4e\xc9\xc8\x20\xf0\xd0\xf4\x0a\xa7\xfb\x7e\x41\x27\x0e\x95\x2f\x02\x49\xd9\xe5\xed\x8c\x9f\x6f\xb2\x99\xf5\xea\x1f\x22\xa7\x0c\xda\xdc\xac\x1a\x2a\x30\x77\x02\xa7\xc1\xb9\xf3\xb0\x81\xeb\x8e\x4b\x1a\xa3\x4f\x4c\x78\x8b\xfb\x89\x69\x31\xc0\x4d\x2a\x7f\xcb\x80\x7a\xdc\x97\xb1\x7b\x99\x20\x9b\x6d\xcd\x65\x4a\xba\x21\x2c\x4f\x27\xf6\xa8\x5a\x32\x4e\x8a\x6d\x0e\xc2\x0f\x06\xe2\x3a\xa8\xb4\x8e\xdc\xa2\x2a\x47\xc7\x60\xe0\xf4\x78\x5d\x73\xd2\xb6\x23\x66\x44\x5c\x98\x10\xfd\x01\xf2\xba\x15\xa3\xc4\x46\x49\x82\x9d\x48\x77\xf3\xed\x5d\x12\xab\xaa\x00\x92\x49\x0b\xfb\xa2\x91\x3f\xb8\x37\x23\x15\xc8\x82\x55\x89\x2e\xf1\x35\x77\x35\xc9\xae\xce\x52\x3f\x37\xfb\xd6\x17\x90\x0f\xae\xe4\x30\x1c\x91\x3a\xbd\x33\xa9\xbf\x6e\x13\x01\x70\x26\x39\x26\xe7\x56\x75\x70\xb0\x1d\xb4\xa4\x41\x46\x73\x90\x14\x9b\x8c\x1b\x55\x63\x3b\x49\x7d\xbb\x21\x5c\x8f\x18\xae\x55\x76\xc2\x1b\xb4\xe5\x7d\xa8\x84\x01\x62\x82\xbf\x0f\x99\x7a\x3a\xcd\xcd\xce\x39\x79\x1e\xdc\x21\x20\x52\xd9\xd4\xd8\xd7\xce\xbe\x93\xee\x93\xde\xfc\xa9\xca\x0a\x4e\x40\x29\x89\x30\xdf\x97\x44\x64\x3b\x28\x41\xb0\x58\x72\xb4\x5b\x42\xf9\x12\x4e\xfe\x61\x1d\x1f\x2b\x96\xe3\x7b\xc7\xcd\x3f\x58\x81\x87\x13\xfe\xdf\x2f\xa7\xaa\x4a\xda\xbd\xd5\x9c\x76\xd6\xdd\xb6\xc3\x36\xf6\x6c\xd2\xa4\x67\x8c\xb4\x87\x4f\x25\xba\xa5\xc1\x50\x0a\x28\xc5\x2f\x56\xab\xcd\x20\xea\x6a\x0e\x84\xfe\x3e\x4d\x54\x8d\xf2\x63\x37\x34\x62\xc9\xa4\x5e\xec\x7e\x5e\xec\x28\x29\x79\xc7\x14\x49\xbd\x8a\xc7\xd8\xd0\x84\x65\x37\x61\x27\x78\x8c\x55\x24\x75\x38\x95\x91\xe6\x2f\xa1\x9c\xe2\x9c\xf4\x4e\xf2\xce\xa8\x27\x16\x6e\xba\xe0\xce\x68\xe8\xb4\x91\x9e\x35\x31\xdb\xe8\x19\x3b\xbe\x5e\x6e\x34\x8b\x38\xeb\xbe\xdf\x96\x53\xcd\x71\xcf\x46\x3b\xe2\x20\x4a\x78\x0e\x89\xa4\xdc\xca\xf0\x5d\xf0\x5d\xe6\xe6\xfe\x59\x20\xee\x1d\xd6\x4d\x47\x2d\x57\x4d\xa8\xc6\xd5\x5f\xc9\x09\x4b\x0f\xe3\xa6\xc7\xe9\x56\xa4\x67\x47\x67\x17\xc7\xe4\xe3\xd3\x3e\x84\x95\xdd\x57\x26\xfa\xc2\x19\x19\x69\xbd\x26\x0d\xfb\x0c\xc9\x99\xdb\xa3\xce\xba\x35\xcb\x58\x98\x6e\xbc\x13\xd6\x17\x46\x3e\x67\x6c\x61\xd1\xe2\xa7\xb2\x8f\x30\xc3\xe6\x11\xc2\x78\x29\x7b\x93\xe5\x1b\xe2\x38\xdc\xdc\x7d\x3e\x3b\x7c\xce\xc4\x39\x09\x69\xb8\x20\x37\x3f\xc4\xc9\x6b\x4e\xc1\xbc\x1b\xce\xc1\x57\xb6\xbd\xa6\xe6\xff\x16\xe2\xb3\xfc\x20\xf9\xd5\x41\xf2\xf2\x50\xf9\x45\x6a\xf6\x87\x70\xe5\xa6\x59\xd2\x72\xd2\x8a\xd2\x13\xf2\x1d\x92\x4a\x16\xe1\x12\x70\x18\x37\xc3\x7e\x56\xa1\xbb\xda\xc0\xb7\x38\xe0\xb4\xcb\x6f\x9f\x3f\x97\xa3\xda\xef\xbb\xcb\xd7\xfe\xeb\x20\x87\xab\xda\xe7\xad\xfc\x33\x23\x4a\x46\x09\x3b\x53\x6c\x36\x10\x51\x41\x80\x69\x12\xdd\x7f\xab\x04\xa4\xf1\x05\x43\xdf\x0f\xec\x66\x7f\x54\x30\x59\xf2\x77\x1e\x02\xc2\x49\xfb\xf7\xb4\x2b\x7e\xd4\x1e\xb4\x5b\x97\xb0\x6b\x42\x1d\xb1\x05\xe2\x93\x34\xd1\x31\x4c\xf9\xa8\x5b\xa1\x2a\xf3\xc6\x3b\x2f\x6a\xd3\xfa\x4c\x01\x41\x4d\x30\x58\xe5\x7d\x3e\xfd\x10\xb1\xb9\xa4\xb2\xf5\x2e\xe4\x74\xd8\xba\x75\x15\xc8\xc3\x74\x1f\x6a\x8d\xb2\xc4\x69\x5a\x8d\xb8\xea\x36\xc4\xec\xa1\x29\xe3\x10\xb1\xa4\x75\x11\xec\x1e\x64\xf8\x9a\xf8\x6e\xe3\xae\xfc\x04\xc0\xb9\x95\xab\xbf\x9e\x7f\x3f\x94\xb4\xd9\xca\xca\x15\xee\x0a\x83\x7c\x6e\x34\x6f\x5a\xbb\xf3\x38\x48\xdb\x2f\xa3\xd0\x68\xd5\x21\xab\xdd\x04\x06\x7d\x83\x49\x3e\xa9\xd7\x16\x1f\xde\xfc\xdf\x64\xfe\xe4\x09\xe4\x7f\x5f\xe3\x15\x08\x59\xf6\x33\xa3\x72\x44\x90\x77\x63\x36\xd3\x5a\xf9\xb5\xcf\x4b\xe5\x05\xd8\xac\xf8\xf7\xc6\x41\x1e\xbf\x3b\xf8\x9f\x54\xc9\xf8\x9d\x05\x01\x20\x47\x58\x19\x4b\x62\x34\xee\x70\x00\x3a\x49\x39\xe8\xeb\x6d\x8d\xca\x7b\x23\x3f\x7b\xff\xc7\x58\x25\xf6\xa5\x43\xb0\x87\x4b\x4d\x3b\xe1\x8c\xeb\xc2\x00\x45\x8d\x28\x7b\x76\x54\x12\x36\x0b\x4c\x61\x9b\x59\x7d\xc6\x6a\xe3\x4f\x93\x8c\xd1\xad\x54\xf6\xd0\xb2\xbf\x60\x10\x75\x20\xb1\xb9\x00\x84\x95\xed\xbb\xcb\x1f\x4a\xc4\xda\xdb\x83\xf5\x32\x66\x84\x31\xf6\xdf\x44\x9a\xe9\xe3\xae\x2f\x9f\x4d\x1a\xfc\xe8\x52\x8d\x31\xb3\x43\x62\x87\x16\x20\x40\x23\x0f\xc4\x5e\x24\x79\x48\x22\xb6\x63\x03\xe1\x25\x1b\xdf\x80\x1b\xe4\xc0\x90\xe2\x2e\x13\x4d\x74\xbe\xd8\x42\x9b\xc9\x6c\x37\x20\xea\x94\xd5\x5e\x84\xa7\xc8\x5d\x5d\x5d\xbd\x2a\x97\x02\xbf\x08\x10\x18\x12\x65\xc2\x67\x5e\x31\x3a\x8e\xb3\x09\x76\x22\x74\xaa\xbc\xc5\x32\xed\xe5\x3d\x4d\x40\x66\x5d\xe7\x4d\xba\xcc\x9f\x44\x5f\x9c\xf1\x77\x60\x74\xd1\x98\xfc\xef\x02\x86\xc1\xff\xa6\x6d\x9d\xac\xaa\x95\xc8\x75\x1e\x4a\x77\xa5\x22\x42\x68\x9b\x96\x85\xb4\x4f\x3b\x93\x1b\x1b\xfc\xd6\xbd\x04\x2e\x84\x85\x77\x89\x33\x2c\xc3\x65\x4a\xfb\x56\x4b\x6d\x04\xc4\x43\x32\x4c\x43\x14\x79\xd3\x9d\x4f\xd8\x07\x11\x4c\xfd\x81\x55\x95\x7b\xca\x2f\x5c\x22\x88\xe6\xf1\xef\x4b\xb1\x09\x68\x81\x9e\x90\xaa\x09\xbf\x62\x78\x1a\x5a\x88\xbf\xeb\x4c\x52\x12\xbe\x9a\xba\x69\xbd\x4f\xc7\x28\x3d\xee\xb6\x7c\xd2\xed\xa4\xfc\xc7\x56\x7d\x88\xba\x29\xf0\xb5\xd7\xbe\x9d\xe0\x5b\x5b\x01\xe9\x1f\xda\x50\xf6\x5b\xcf\xf3\xee\xf1\x6e\x1d\xcc\xf3\xe4\x32\xec\x36\x59\x17\x9d\x4b\xaa\x95\x09\xbf\x55\x18\x4c\x13\x9a\x7d\x03\x92\x57\x19\x30\x24\x7f\xda\x83\x52\x3a\xa0\xa7\x0c\xa5\x4f\x00\xfd\x33\x49\x6a\xba\x28\xce\x92\x1f\x52\xd6\x85\x4a\x8d\x80\x0b\xf0\x91\x29\xa7\x9d\xd4\x16\xf9\xed\xb7\xa6\xb1\xb1\x05\xfb\x06\x48\x9b\x49\xfb\x83\xd9\x6e\x9c\x53\xb7\x28\xcb\x67\x98\x4b\xea\x70\x0b\xa5\xa8\xef\x32\x9b\x5c\x9f\x8f\xa6\x0e\x6f\x4e\xdd\xef\x81\x1d\x79\x61\xe8\xbb\x9a\xf6\xaf\xc1\x9e\x38\x94\x27\xe4\x90\xda\x70\xb6\x0e\xb1\x25\x1b\x7f\xd7\x01\x4b\xab\x45\x45\xa9\x67\x4f\x18\xc5\x5b\x3a\x2a\xcc\xd7\xb8\x10\x00\xcf\x0f\x70\xba\x98\xe2\xb3\x87\x04\x57\xde\x1f\xde\xfa\xfc\x19\xc7\xc8\x46\xcb\xe4\x74\xf8\xb5\x21\x03\x57\xe5\x6f\xe3\xf6\xda\xa7\x82\x22\xb2\xcb\xb2\x22\x43\xd6\x80\x6f\x88\xc5\x6f\xbe\xe5\x42\xad\x4a\xe6\x64\x86\x97\x3b\x27\x4b\xcd\x92\xe0\x5f\x5f\xf6\xfa\x9e\x68\xa1\x76\xea\x2b\xdb\xf3\x93\x17\x0c\x0c\x81\x64\xc0\x81\x03\xb6\xe4\xc8\xde\x8d\x8a\x8b\x20\x27\x01\x7f\x97\xac\x9c\x87\x92\x86\x56\x94\xaf\xe1\xb8\x6d\xac\x19\xb3\x0e\xaa\x49\x2e\x5e\xc5\xcb\x85\x09\xc1\xbc\x1e\x38\xdf\xf0\x42\x9f\xe3\xaf\x73\x7f\xad\x66\x89\x47\x30\xd8\xfe\x38\xe3\xd5\xbc\x1a\xb2\x2a\xca\xae\x20\xbc\x99\x14\xea\xa9\x90\xad\x11\x54\xd2\x95\x84\xa3\x63\xbe\x1b\xb3\x36\x88\x73\x7e\xf8\x07\xa0\xee\x02\x4a\x69\x6d\xb0\x17\x16\xe9\xb1\x16\xa4\x78\x59\x7e\xad\xea\x56\xd3\x29\x89\x49\xba\xb7\xc6\x9b\x15\xaf\xc0\x2b\x08\xd4\xe1\x1e\x68\x17\xfc\xf3\x81\xca\xce\x9c\xc5\x3b\x5d\xf5\x9e\x45\x9e\xc4\xd0\x1c\x42\x01\x41\xd0\x90\x05\x51\x99\x89\x6c\x22\x94\x55\xd5\xda\x7f\x86\xf0\xb5\x2c\xde\x43\xec\x29\xfe\x10\xe4\x27\x66\x9b\x43\x7b\xdc\x4b\x44\x86\x5d\xda\x70\x23\x28\x1c\x05\x5e\xf1\xce\xdf\x1e\x15\xba\xe5\x79\xf7\x0e\x73\x3d\xbc\x99\x18\x3d\x55\xb9\xdc\x6a\x6f\x16\x6e\xfe\x10\xf0\x6c\x56\x65\x14\xf6\x75\xc9\xf8\x69\x4a\x2b\x24\xcf\xda\x64\xc5\x55\xdd\x23\xba\x3b\xf5\xb6\x05\x4f\xeb\xed\x9c\x0a\x09\x3f\x39\xaf\x32\x9c\x0b\x95\x3c\xd7\x3b\xb2\x71\x3e\x6f\x09\x54\xaf\x72\xa4\x1e\x78\x26\xd6\x0a\x5b\xb5\xbb\x27\x2d\xd2\x78\xa6\x70\xa8\x30\x6a\xa7\x5b\xf0\x3b\x33\x0e\x9c\x49\x77\xe9\x8a\x0e\xbc\xb5\x80\x36\x4e\x3f\x3b\x9b\xb1\x3c\x6d\x27\x2a\x8c\x78\x44\xd7\xfd\x3f\x24\x41\xe0\xca\x82\xf1\x1a\x38\x0f\x89\x66\x22\x22\x30\xc6\xef\xbb\xca\x5a\x49\xf9\x3b\x8c\xa3\x20\x5f\xdf\xa2\x55\x12\x63\x47\x6b\xa8\x22\xc9\x0c\x06\x23\x98\x2b\x0b\x51\x45\x09\xfa\xa0\x70\x0f\x9b\x58\x64\x0b\x7c\xc4\xad\xcc\xa7\xc6\x21\x78\x33\xa3\x66\x32\xf6\xf9\x5b\xd0\xf4\x46\x83\x87\xd7\xc9\x4b\xe0\x11\xc1\x6f\x61\x00\x9d\xe6\x0c\xad\x4b\x7e\xb6\xdb\xb7\x52\xa9\x36\x09\xdc\x59\xc3\x63\x6a\xfc\xd3\x3c\x84\x97\x4c\x5d\xe8\x17\x83\x25\xa1\xd2\x11\xd2\x54\x53\xcb\xb6\x52\xe7\x4f\x8d\x9e\x57\xc3\xb6\x62\x63\xbb\xc2\xa3\xc7\x65\xd0\x50\x84\x7d\x8e\x53\x0c\x02\x16\xbd\xae\xbc\x10\x5c\x16\xf5\xdc\x0a\x1e\xde\xe1\xfb\x54\x84\x1f\xdd\xf6\xd1\x75\xe1\xa4\x20\x68\xc1\x8c\xb9\xd0\xab\x6b\xa6\xbb\x2e\x78\x08\x06\xfb\x7f\x7b\x07\xc8\xe8\x08\xdf\x13\x7a\x5a\x09\x4a\x0e\x54\x6f\x8c\x3b\xc7\x38\xe6\xcd\x48\xcb\x10\xaf\x89\x0e\x80\xcb\x50\x1f\x5e\x45\x73\x54\x0a\x12\x27\x4b\x9c\x40\xc1\xe4\x06\xee\xcf\x04\xf7\x0c\x0a\x84\x74\xf6\x81\x42\xf3\x25\x46\x6a\xe4\x64\x43\xd3\x7f\x83\xd7\xd7\xaa\x06\x16\x0d\x6f\xb1\x1d\xa3\xae\x86\x40\x58\x56\x2b\xae\x17\xe3\xea\xb0\x7a\x2e\x05\x93\x07\x54\xad\x14\x04\xf3\x22\x21\x22\xa6\xc6\x1b\x8d\xd4\xc3\x42\xc3\x9e\xb2\xe0\x02\xba\xcc\x46\xf3\x8b\x2e\x7e\x8b\x5f\x87\x1c\x99\x61\x63\xa8\x61\x0b\x1b\x3b\xa1\xd8\x00\x0d\x10\xf4\x3b\x25\x23\x09\x4f\x36\x90\x4c\x9b\xf7\x3d\x42\x0d\x1e\x64\x58\x98\x99\xe1\x6f\xda\xc0\x0a\x08\xf4\xdf\xa1\xbc\x73\xea\xef\xe5\x4c\x9e\x21\x2e\x88\x41\x32\x9d\x52\xf7\x20\x0f\x20\x9b\x34\x0a\xa3\x19\xa9\x98\x82\x3a\x1d\x67\xb5\x5f\x8d\x2a\x5b\x74\x04\x97\x88\xf4\x53\x2a\x5d\x8e\xbf\x36\x15\xec\x2c\x81\x1b\x4f\x39\xbb\x33\x03\xa6\xa4\xe3\xb6\xdf\x35\xfe\xb7\xd8\x96\x23\x5e\xa1\x9e\x6c\x83\x1b\xe9\x81\x6d\xbc\x17\x04\x93\x5b\xca\x65\xa2\x85\xd0\x9f\xbe\xa8\x05\x57\xa8\x0a\x07\x3d\xe8\x36\x38\x75\xc7\x50\xbc\x1b\xdd\xa4\xe4\x5f\x97\xe7\x0d\xd9\xc7\x4d\xee\xd4\x70\x82\x22\x07\x4b\x8e\x7d\x71\x14\x9d\xdc\x66\x19\x6e\x8e\x56\x7d\x14\x5b\xe0\x5b\xa0\x21\x71\xa8\x65\x8b\xae\xa3\x2a\x60\x67\x20\x69\x66\xcd\xf2\xa0\x7c\x16\x54\xec\x11\xdb\x2f\x5c\x0b\x77\x84\x47\x33\xeb\x09\x95\xb9\x7a\x43\xea\x55\x6c\x72\x8e\xb9\xb3\xe2\xba\xce\xcd\x13\x51\x48\xe4\x24\x71\xfe\x7d\x72\x60\x96\x93\xfa\x6f\x67\x1e\xaa\xd5\x9a\x67\xc9\x4f\x33\xcb\x19\x3d\xe9\xaa\xc4\xfa\xba\x2b\xe5\x7f\x1b\xbc\x1b\xdc\xf9\x1e\xf6\xc6\xbb\x81\xdf\x7b\x00\x04\xdf\x4e\x9f\x62\x01\xdc\xf3\x2d\x70\xa9\x67\x5b\x72\xef\x3a\xa6\xf4\x8f\x83\xbd\xaf\xeb\xec\x96\xf0\x7e\x44\x66\x1a\x2c\xb0\x15\x21\xb3\x3e\xa1\x11\xa9\x4b\x06\x9a\xa3\x9a\x39\x59\x52\x32\xba\xf0\x76\xf1\x72\xf9\x44\x33\xef\xc4\x27\xfa\x0a\xc3\xf8\x99\x0f\x4b\xb6\x67\xd5\x82\x3f\x68\x3f\xcb\x72\x5f\xfa\xd4\xf8\x4b\x26\x0c\x60\x74\xcd\xa1\xf1\x9f\x9e\x89\xa8\xce\xed\x79\x37\x85\xd4\x26\x2e\x9f\x3e\xfd\x74\xf5\x01\xf4\x75\xe7\x34\x98\xdf\x9b\xcd\x14\x47\xb7\x0a\xb9\xee\xdd\x3a\xe8\x5e\x16\x4d\x8a\x70\x76\x84\xef\x77\xda\xb4\xdc\x59\x7a\x7e\x1c\xda\x87\xd5\xb1\xf7\x4d\xd9\xaa\xe5\x21\xc1\x52\x57\x9b\x64\xc5\x3b\xb3\x23\xf4\xdf\x09\x5e\x83\x7a\x1c\xd7\xca\x88\x83\xb4\xf0\xc5\x06\x51\x15\xa9\xdb\x0c\x74\x5c\xa3\x57\x79\x02\xbb\x5c\x14\x4f\x4a\x17\x31\x34\xbe\xc7\x3a\x35\xd2\x5c\xb2\xfe\x0c\xf0\x97\x53\x58\x54\x85\xb7\xdd\x20\xdd\x93\x12\x1c\x9a\xf9\x67\xe7\x76\xb7\x1e\x56\x39\x8f\x55\x6b\x58\x2c\x6d\xb6\x69\x4d\xb2\x5c\xea\xe8\xb6\xfe\x0f\xc6\xee\x28\x6e\x8e\x9e\x3e\x45\x9d\x49\x0f\xa1\x20\x61\xbb\xb7\xef\x49\xe7\x69\x85\x5f\x14\x1f\x93\xbd\x2c\x83\x98\xda\xe2\xc7\xea\x1f\x28\xf7\x0d\x15\x3b\x2e\x73\x9e\x29\xb0\x3d\x35\x9e\x41\x9e\x49\x9e\xe9\x28\xdc\xcb\x77\x58\xa1\x67\xa7\x7d\x34\x59\x93\x94\xb1\x91\x44\x70\xc4\x34\x97\xac\x7b\x1a\xea\x6a\x71\x28\x51\x0a\xcc\xb7\x5a\x4a\xb2\x55\x8d\x5a\x66\xb1\x4b\xb1\xf5\x2a\xc5\x78\x00\x43\x7e\x70\x22\xd2\x12\x32\xaf\xac\x72\x83\x23\xeb\x24\x21\x0e\x8c\x4a\x1e\x86\x1d\xe4\x7a\x5a\x05\x59\xd1\x2e\x0e\xa0\x5e\x7c\x12\x68\xd0\xfd\x7d\xa0\x9d\xc8\x7a\x8e\xc0\x1b\xb2\x58\x61\xe3\x8e\x15\x49\xa7\x8b\xa8\x45\xaa\x58\x67\xd0\x74\x5e\x34\xab\x52\x7b\xfe\xb3\x66\x14\x1a\x8a\x4c\xc9\x11\x79\xd3\x7f\x70\x08\xd1\xe1\x9a\x9a\xc9\x06\x00\x31\xde\xa8\x7c\xb0\x4f\x07\x0d\xde\x14\x32\xdb\xe0\x35\xde\x22\x0c\x0c\xf2\x74\xc9\x55\xe3\x92\x41\xe9\xde\x97\xf2\x95\x40\xf6\xff\x11\x75\xfb\x1b\x52\xe4\xa1\xfd\x50\x1a\x04\x4e\xb6\x58\xc6\x31\xa2\x5a\x4e\x06\x81\xfe\xff\x2f\xa8\xdc\xa8\xbf\x78\xa6\xf6\xfd\xaa\x95\x49\x51\xaf\xc3\x97\x07\x06\x96\xc3\x5f\x03\x04\x8e\x79\x36\x90\x45\x4b\xf8\xaa\xa1\xa5\x20\x2f\xbc\xba\xa1\x11\xb5\xf7\xc7\x20\x63\x75\x44\x96\x6f\xbf\xba\x80\x37\xd5\xa4\xaf\x09\xd0\xfc\x07\xd6\x1d\xdb\x7c\x32\xfc\xd0\x56\xe6\xfc\x43\xe5\x0b\xce\x66\x2b\x48\x8c\xbd\x0a\xb5\x3a\x60\xbe\x77\x9f\xf9\x01\x69\xf2\xc4\x79\xdb\xff\x7e\x77\x6b\xb8\xe5\x93\xd6\x74\x40\xcb\x34\x4f\x45\x5d\x2c\xfb\x3c\xbb\xfa\xff\xc9\xcd\xa6\x3f\x0f\x73\xe6\x12\xa1\x62\x18\x31\x2d\xab\x84\x0d\xf2\x4a\xbf\x92\xdf\xc3\x41\x9c\xb4\xa7\xa8\x8c\xd2\xf1\xfe\x41\x32\xe0\xd2\x2d\x3d\x86\xc9\x74\xed\xec\xb9\x99\x43\xc2\xc3\xb5\xcc\x8d\xe0\x7f\x3a\xf0\xc0\x0f\x0a\xe9\x9d\x42\x61\xb3\x3b\x05\xf5\x57\x17\xe9\x92\x43\x45\xa2\xce\x9e\x16\x72\xff\xe5\x7b\xe7\x60\xc9\x26\x89\xc4\x2c\x1f\x27\xf4\xdb\x74\xff\xdd\xec\x15\x8e\x8a\x5b\x38\xc1\x17\x71\xe1\x89\x75\xee\xf8\x0a\x2d\x28\xc7\x4a\xec\x5d\xbb\x98\x34\x0d\xa8\xda\xf3\x99\xb2\xeb\xca\xb9\x35\xab\xe7\xf0\x61\x79\xfc\xb7\x0a\x68\x68\xfa\x59\xb1\xfd\x99\xb8\x2e\xef\xfe\xcb\x34\x9d\x07\x6a\x26\xb0\xb6\x1a\x93\x34\xdf\xf2\x82\xb6\x61\xf6\x1c\xa2\xf6\x0b\x83\x71\xcb\x27\x28\x9a\x0b\x85\x35\xe0\x97\x15\x13\x1d\x84\xf2\xb8\x14\x73\x1a\x8a\x58\xc3\x47\xf4\x6a\x57\x42\x99\xec\x86\xde\x7e\xad\x92\x85\xc9\x63\x6d\x08\xdb\xb6\x18\x8c\x2f\xfd\x99\x2e\x01\x36\x1d\xca\x61\xff\x5f\x1b\x41\x35\xbc\xfd\xfb\x2b\x3d\x64\xbc\xdc\xe3\x0c\x3e\xc4\xb9\x5f\x2e\x19\xee\xaa\x68\xcf\xcf\xc8\xe8\x38\x74\x42\xe1\x73\xb8\xe8\x30\xc4\x0f\x48\x4a\xc6\x1f\x8a\x6c\x9c\xe1\xa1\x6c\x5b\x55\x48\x34\xf6\x76\x2e\x09\xbb\xca\x3e\x5d\xc6\x28\x0a\x6b\x8c\x39\x2e\xa0\x20\x55\x94\x41\x3a\x2c\x41\x2d\x15\xac\xbf\xc6\x77\xe6\x85\x79\xca\xb0\x90\xd2\x89\xcb\xf1\x56\xe0\x6a\x56\x55\x0c\x9c\x5e\xbe\x98\x81\x7d\xb0\x7c\x77\x7f\x54\x48\xc1\xd3\x98\x2c\x1f\x03\x41\x71\xc8\x30\x3b\x2c\xf3\x5a\x44\x2a\xae\xdc\x23\x7b\x9f\xbc\xad\x6c\xcc\x48\x37\xe0\xd5\x62\x1e\x52\x58\xef\x30\x43\x81\xc7\x64\xcd\x75\x42\xd1\xa2\xf5\x35\xd2\x64\xa8\x3d\xcd\x56\xb0\x5c\x54\x3d\x9b\x51\x33\x00\x13\x8b\x37\x6f\x0b\xed\x71\x13\x41\xcc\x90\x41\xfb\x8c\xeb\x4f\xfc\xfc\x06\x6c\xee\xdc\xbf\xa2\x9f\xe7\x21\xfb\xad\x7b\x5f\x75\x44\x0c\x47\x5f\x93\xad\xce\x72\x6b\xf6\xaf\xdf\x98\x54\x94\x5e\x98\x90\xa2\x7d\x57\xd0\x6f\x29\x18\x2e\x38\x1a\x98\x98\xac\xa5\x7c\x67\x57\x0f\x50\x95\x43\x65\xee\x4a\x9f\xbd\xf6\x9c\x78\xee\x36\x4e\xb2\xd3\xfe\xff\x07\xdf\x1f\x28\xc3\x7e\x76\x07\xfc\x5f\x99\x3b\xa2\xce\x9e\x0e\xaa\xfe\xe0\x53\x3f\x08\x8b\x99\x8b\x57\x23\x18\x4d\xfc\xcb\xbf\xdf\xd7\x5e\x8a\xdb\x7f\x53\xe9\xc8\x16\xa1\xcf\x6d\x47\xff\x0d\x1b\xce\xb8\x4a\x7f\x9f\xed\x51\x35\x30\x07\x06\x20\xe5\x99\x69\xba\x3c\xa5\x26\x2b\xae\xc8\x3b\x17\x1e\x85\xf1\x56\x3d\xf4\x4b\xae\x72\x55\x84\xbc\x0a\x9c\x1f\x65\x0f\x93\xb6\x83\xa0\xe6\xc4\x23\xf6\x02\xa7\x2c\xcb\x10\x74\xac\x9e\x46\xa4\x6a\xc3\xab\xaa\xc2\xce\x93\x1a\x98\x55\xb2\x04\xc9\x7c\x4e\x27\x75\x4c\xa4\xe2\xc3\x1c\xa1\xd1\x78\xa5\x87\x26\x8a\x29\x0a\xa9\x36\x77\x72\x72\x6f\x47\xe6\xa0\x34\x01\x17\x0d\xb1\xbe\xde\x4c\xdb\x52\xb7\xba\x09\x67\x6e\x94\x88\x5a\x61\x9f\xa3\xb9\xc0\x94\x23\x74\x2b\x15\x32\xe4\x3e\x69\x66\x21\x08\x7f\x12\xcf\xa5\xbd\x1c\x11\x29\xc7\xbe\xf9\x3e\x30\x24\x26\xdb\xcb\x04\x71\xa4\xc0\xbc\xd8\xed\x71\x4a\x59\x5c\x92\xa7\xda\x49\x02\xd6\x53\x28\xa5\xcb\xa4\x37\xb8\x5e\x1c\x2b\x0f\xad\x27\xd5\xc0\xd6\x19\x83\xc4\x77\x94\xd9\x9a\xea\x7a\x65\x0c\x02\x8d\x21\xf8\x65\x95\x86\x2d\xcb\xe1\xcf\xdd\x99\x7b\x98\x85\x61\xba\x05\x8e\x77\x1c\x03\xcf\x84\xc4\xfc\x18\x20\xa4\xed\xbd\x4b\x1c\x22\xab\x4a\x64\x0d\xc1\xe6\x1d\x4c\x79\x22\x46\x89\xcd\xd5\xbb\x0f\xe3\x50\x8c\x00\x1c\x6e\x88\x29\x0f\x87\xd0\xb6\xf3\xdc\xf5\x0c\x77\x97\x2d\x59\x55\xb8\xff\x36\x4c\xfa\x38\x22\xb8\x21\xd1\xa1\xff\x19\xde\x7c\xce\x46\x15\xfc\x6a\x3d\x63\xf4\xe8\xc8\xa0\xec\xc0\x80\xec\xe0\x81\x45\x9d\xed\xf6\xc8\xce\x52\xfa\xd0\xc3\x7a\x21\xf9\x3c\xab\x6e\x55\x17\x3c\xa4\x51\x63\xaa\xe6\x8c\xe7\xf0\xda\xf0\xf7\xf7\x6f\x2b\xf1\xfc\x2d\x60\x28\x7c\xc9\x8d\x20\x87\xc8\xee\xa1\x4f\x2c\xf0\x8a\x74\x1c\x0b\x16\x63\x52\xd2\x87\x13\x9f\xd3\x86\xae\x9e\x05\x8a\x2f\x6a\xe4\x6e\xed\x40\x3c\x97\x51\xa0\x67\xd8\x1a\x9b\x18\xab\xf9\xf7\x34\xf4\xfc\x36\x9f\xa1\x9f\x57\x3d\x5a\x8d\xda\x92\x92\x39\x99\xae\x9d\x34\x63\x4b\xa8\xb6\xd6\x26\x7b\x9e\xdb\xde\x7d\xee\x38\x23\x5a\xf3\x58\xf3\x1e\xed\x57\x55\x17\x55\x2b\xe9\xfc\x51\x47\xce\xd1\xf9\x51\xf3\xdc\xc6\xdf\xe4\x33\x2c\xe4\xeb\x2f\xe0\x25\x8a\x45\x6f\x9c\xa3\x02\x8e\xdf\xc3\xde\x87\x0e\x14\xd5\xbc\xe8\x0e\xe7\xf4\x95\x64\xcd\x37\x7a\x7d\x04\x0d\x23\x1d\x4f\xb7\x74\x7b\x79\x44\x22\x33\xe1\xac\x0b\xbb\xc2\xf4\x4b\x9e\xce\x64\xae\x95\xf0\x20\x7b\x43\x75\x37\xfd\x90\x27\xd2\x0d\x1a\x43\x29\x6e\x84\x30\x7b\x1e\xcf\x34\xac\x6b\xa6\xad\x90\x28\x7c\x09\x75\x28\x35\xfd\x95\x75\x29\x22\xeb\x7c\xb6\x14\x56\x20\xfe\x94\x57\x72\x14\x9e\x9c\xf0\x65\xae\x14\xf1\x6e\xdd\x7f\x6e\x93\xde\xeb\x58\x57\x84\x4f\x1e\xa4\x7b\x8f\x84\x92\x42\x75\x99\x57\x55\x87\x06\x1f\xa9\x92\x2c\x32\x4c\x21\x8d\x28\x8b\x4b\x7d\xb8\xa2\xe4\x8a\xf6\x3d\xef\xf3\xa3\x86\x09\xb2\x5b\xff\x4d\x50\x29\xe2\x73\x32\xf1\xdb\x6c\xa2\x36\x25\xe0\x18\x6a\x0d\x23\x5c\x4a\x7f\x67\x31\x61\x5e\x1c\x39\x51\xec\x1a\x1f\x1e\x17\x2e\x99\xfd\xd8\x46\xce\x2f\x0a\xf6\x0a\x79\x7c\x78\xa4\xe4\xf8\x26\x8e\x3e\x7a\xd4\x7c\x25\x25\x4e\xa9\x88\x7b\x90\x06\x39\xb4\xb5\x63\xd7\x89\x53\x27\x49\xe6\x23\xe6\xfa\xc0\xdc\xb3\x26\x91\x51\x46\xbe\xe5\x8c\x6e\xb6\xe0\xb9\x95\x92\x12\x19\xa1\x0c\x21\x1a\x4a\xc6\x84\x65\x03\x99\x65\x91\x6f\x1c\x7d\x2c\xdd\xd0\x58\xd6\x4d\x30\x63\xec\x7f\x02\x73\x39\x5d\xe9\x98\xc3\x65\x03\x30\x38\x75\xf8\x78\xac\xe4\xe3\xc1\xde\xbe\xfd\x42\xe4\xa6\x82\xc0\xe2\x40\x68\x7e\x54\x24\xc5\x25\x0a\x3f\xee\xcf\x2d\x26\xec\xb9\x3d\xa5\xdd\xc4\x45\x73\x9b\x02\xa6\x6e\xcf\xa8\xdb\xec\x66\x27\x24\x82\xf6\xd0\x84\x60\x39\xe5\xcf\x77\xa7\xa3\xdf\xe5\xfb\x76\xc8\x92\x9c\xdf\x96\xd3\xd2\xe2\x24\x73\x4e\x79\xb1\x37\x7a\xd4\xaf\xe9\x33\x2e\xc9\x89\x41\xbb\x3e\x85\xf2\x63\xbe\x9f\xf2\xb1\x2c\x76\x99\xfc\x41\xe8\xe2\xc5\x3f\x70\x2d\x3f\xda\xf5\x23\xfe\x47\xce\x76\xcb\xa7\xa6\x68\x6d\x2c\xdd\x14\x51\x76\x96\xa6\x47\xa2\x3d\x4b\xd4\xbe\x09\x86\xff\x6e\xbc\x6b\x40\x70\x2a\x83\x3b\x72\xf4\xde\x51\xfb\xfc\xb3\x77\x9c\x5a\xba\x2a\xda\x93\xf8\xc7\xa4\xcd\xe6\xf4\x20\xfa\x33\xce\xbd\x93\xd5\xa5\x77\x52\xf2\x01\x2d\x85\x60\x51\x7a\x5c\xef\xd3\xa7\x8d\x76\xe9\x00\x81\x63\xf4\x8f\x3c\x80\x73\x08\x00\x89\xb8\xd0\x2a\x29\x7f\xe2\xc6\xdf\x25\x6d\xe7\xbf\x67\x4e\xdc\xa6\xee\xba\xad\x49\x79\xb2\x7e\x23\xe7\xe5\x2b\x55\x60\xee\xb7\xb9\x7e\x82\x55\x8f\xce\xed\xf2\xaf\xe7\x8d\xab\x6c\x27\xe3\x7f\x2d\x07\x71\x12\xf4\x27\x12\x89\x84\xd6\xa3\xa2\xd5\x01\x8f\xdb\x68\x26\xc9\x9a\x02\x2c\xd8\x42\xbf\x4c\x13\xa4\x07\xc0\x3c\xaf\x67\xe4\x4d\x49\x4d\x7f\x09\x00\xd9\xa7\x00\xe5\xfb\x8e\x12\x18\x08\xe1\xce\xc2\x40\x6e\x66\xe0\x00\x86\x5c\xa0\xf8\x7d\xc1\xb4\x64\x1e\x1c\x6f\x98\xc2\x87\x89\x8c\xed\x8c\x5b\x17\x36\x5b\xae\x42\x24\xac\xba\x39\x2d\xb7\x9e\x52\x5d\xd5\x82\x93\xe2\x06\x06\x54\xcd\x7d\xed\x75\x12\x41\x24\x9b\x2b\xc1\x65\xd2\xa2\x14\x34\xc6\x6b\x00\xfa\xbb\x8e\x76\x27\xef\xea\xe9\xfc\x9f\x96\x5e\x4b\x08\xce\xec\xd2\xca\x1c\x18\x36\x0d\x61\x3b\x38\x64\x2d\x78\x2b\xb5\xd5\xe1\x4a\x07\x5f\x86\x75\x15\x5f\x32\x0c\xce\xa2\x47\xaf\x01\x07\xca\x72\x03\x65\x3d\x1d\x9d\x3f\xc0\xdc\xfb\xdb\x28\xb6\xfd\xfd\x03\x81\x8a\x13\x77\x87\x94\x1b\x2f\x2f\x94\x28\xc7\x02\x5f\x60\xbd\x35\xfa\x77\xce\x2f\x9e\x2f\x2b\x3a\x58\x7d\xb7\x5a\xfc\x58\xd6\xc2\x2e\x72\x75\xc8\x90\x51\x96\x80\x97\x81\x57\x26\xed\x03\xdc\x65\x55\x73\x3f\x7f\x81\x7a\xf0\x7f\x4e\x83\xd2\x7c\x6a\x6a\x04\x1a\x5f\xc8\x4d\x77\x33\x31\x87\xe4\xc7\x11\x1f\x0f\x23\x71\x16\x4a\x5b\x75\xff\x57\x46\xf0\x78\xf9\xd4\x8e\xb0\x7d\x08\x07\xda\x79\x7d\x4d\x85\x72\xbd\x2e\x29\x72\xe8\xbe\x31\x2b\x89\x1b\xb5\x17\x29\x09\xf3\xa5\x51\x6e\xb5\x22\x7c\x44\x1f\xc2\x55\x17\x29\x5e\x38\x73\x36\xdc\xfe\xed\x0c\xfd\x63\xab\xc4\x23\xfb\x92\x0f\xa8\x41\xec\x3b\x7d\x97\x2f\x0b\xdf\x0a\xa3\xc2\x09\xcf\x1b\xb9\xd2\x3f\xef\x1b\xd6\x4b\x7f\xe4\xf0\x80\xce\xb8\xc4\xbb\xec\x47\x9f\x9f\xfa\x4d\x67\xdd\x69\xbd\xa0\x0f\x39\x5e\x23\x30\xf3\xcf\x3b\xd8\x8e\x97\x12\x4a\x62\x18\x8b\x8f\xea\x98\x99\xd8\xda\xf6\x23\xb2\x3c\x9f\xe8\xeb\x4d\xeb\x7a\x7d\x1e\x74\x75\x6d\xfe\xb8\x6b\xfb\x8e\x70\x87\x96\x61\x53\x16\xac\x98\xae\x9e\xd3\x16\x20\x32\xf3\x70\x18\x2e\x41\x5e\x53\x31\x9e\x5f\x2e\x77\x47\x1f\x61\x6f\x25\x37\xae\x2c\x53\x55\x57\xa9\x94\xd5\x95\x0a\x37\xe7\x6d\x64\xb4\x25\x45\xf6\x3d\x2c\xdb\x50\x85\xde\xea\xa9\x5b\xd2\xb0\xd3\xe5\x8a\x9a\xaa\xf5\xed\x6c\x8a\xed\xe7\xf1\x4b\x90\x3d\x33\xba\x3e\x68\x3a\x70\x5a\x37\x7f\xd7\x9f\x1f\xbb\x67\x7e\xff\xde\x23\xef\x8a\xd4\x3b\x1c\x78\x44\xaf\x74\xdb\xdf\x4f\xbb\xa6\xfe\x7c\xd9\xde\x74\xd2\xba\x7d\xd4\xd5\x26\x59\x39\xfd\xe7\xe7\x14\xba\xc6\xae\x70\x62\x75\x55\x5b\x5d\x90\x89\xf1\x98\x54\xba\xa2\xd8\xce\xb9\x23\xc2\xe1\xaa\x55\xd6\x46\x6f\x7f\x7e\xf9\x16\x79\xce\xd5\xa5\xaa\xa5\x6a\xd8\xcc\x60\x61\xee\xb2\xea\xe5\x85\xcb\x7e\xaa\x2e\x3b\x15\x26\x5c\x55\x42\xc1\x44\xae\xc8\x08\x19\xbd\x93\x3c\xe1\xa2\x12\xf0\x03\x6a\xc0\x9a\xc1\x35\x79\xa4\xd1\x83\x6f\xe5\x29\x5d\xba\x8d\xef\xb1\x2c\xbd\x84\xb6\x2b\xe8\x5d\xc7\x2a\xd1\x44\x8c\xac\x38\x39\xbb\xc5\xbc\xe2\x9a\xf6\x15\xa6\xa0\x6d\x53\x8a\xdd\x54\xa5\x49\xcc\xf6\x39\xe2\xba\xb9\x03\xe3\xec\xdb\x22\xaa\xfe\xad\xc4\x5f\x4b\x4b\x67\x68\xc5\xf0\x26\xc3\x5c\x5e\x61\x3d\xa4\x0b\x12\x58\x86\xa7\x1e\x10\xc6\xfd\x28\x89\x1c\x75\x60\xee\xb3\x1d\xa5\x6d\x67\x4f\x1b\x2c\x8b\xd3\x89\x86\x02\x68\x7d\x81\xfb\x92\xde\x79\xa8\x06\x24\x99\x03\xdb\x92\x12\xa4\x24\x0c\xdf\x45\xc6\xfb\x5b\xd3\xe9\x62\x92\xc7\xe6\x0c\xb3\x5c\x1d\xda\x8a\xc8\x78\x6c\x7e\x5b\xc5\xf0\xbe\x00\xd1\xd3\x6c\x3a\xb2\x0e\xe9\x88\xbc\xf6\x2c\xb5\x12\xb3\xdd\xcd\x67\x03\x9f\x5c\x6a\x81\x1b\x11\xad\x67\x59\x13\xea\x09\x8e\x88\x27\x07\xb4\x1c\xe5\x26\x66\x29\xe1\x8b\x47\x4c\x7c\x9f\xc6\xad\x2a\xe1\x87\x1c\x51\xdb\xdc\x70\x72\xa5\xa3\x83\x7e\xee\x1a\x3b\xce\x5a\xf1\xb4\x92\x7f\xc3\x49\x5d\xac\xdd\x0d\x21\x3c\xf9\x61\x50\x7f\x42\xb7\x49\xee\xf3\x0e\x62\xb8\x43\x55\x78\xd0\x8f\x1c\x0e\xf6\xfd\x45\x67\xff\xc6\x43\x7f\xff\x28\xa6\x3c\x15\x7f\x67\xb7\x64\xef\xdb\xd7\xd0\xa0\x72\x4d\x7b\x4c\x57\xd2\xae\x47\x07\x68\x12\x37\xfc\x39\xb3\x57\xf7\x46\xc9\x9c\x2c\x73\x52\x06\x85\xcb\xdf\x95\x7a\x48\x37\xd2\x7a\xcf\x99\xcc\x46\x72\x63\x48\x4b\xfc\xff\xf8\x1a\xdf\x6f\x19\x53\xae\xe1\xe3\x46\x61\x30\x19\xc3\x16\xad\x7a\xb2\x81\x95\x68\xc7\x43\xaa\x1c\xce\xd7\x3a\x2b\x06\x2f\xa1\x9d\xaf\xd5\xd2\xad\xfd\x5b\x2d\x57\x98\xc0\x20\x70\x02\x94\x04\xc0\xd0\x33\x14\x76\xe8\xed\x5c\x75\x71\xc7\x47\x47\x2b\xd4\x9b\x44\x58\x29\xdd\xe0\x9e\x03\x27\xd6\x06\xe3\xb7\x26\x4d\xeb\x75\x19\xc6\x97\xd3\xc3\x9b\x7e\x45\xad\xbc\xde\x88\x8c\x57\x7f\x17\x70\xa7\xf6\xdb\x35\x02\x4a\xd9\x70\x47\xd5\xa0\xd3\xd2\xf4\xb4\x30\xcc\xea\x8c\x5f\xd5\xd4\x8d\xaa\x8e\x00\xdf\x71\x57\xff\xc4\x98\x94\x98\x0a\x7f\x5d\x35\x98\x78\x0c\x92\x00\xc9\xf6\xa0\x9e\x16\xe0\xf9\x31\xcb\x79\x75\xd2\x26\xe6\xa7\x0e\xaf\x38\x48\xc8\x8f\x27\x13\x9f\xfe\x3b\xa4\xd2\x40\xbb\x3c\x51\xee\x76\xf5\x38\xb9\x84\x8c\xad\xbe\x75\x56\xac\x3c\x1e\xe6\xb7\xc9\xa6\x45\x59\x29\x16\x2b\x99\xef\x74\x6e\xb9\xb1\x7c\xce\xdf\xb2\xd5\x4b\xb5\xf4\x95\x0c\xd4\x1f\xdd\xe9\xb5\xd5\x33\x2a\x89\xcb\x16\xa8\xea\x22\xdb\xfc\xb6\x02\xf6\xde\xab\x23\x23\x1b\xfa\x1e\xf0\xb8\xdb\x0d\x92\xd0\x8e\x4e\xd9\x69\x22\x4d\x43\xa3\x46\x00\x04\x40\xfb\xbf\x98\x5a\xc1\x75\x54\x08\x0a\xdd\xc1\x83\xa6\x37\xf4\xed\x10\xea\x79\x5c\x3d\xf7\xd1\x86\xbe\xd1\x91\x63\x04\x95\x0f\x58\x59\x24\x2a\xe6\x5e\xda\x49\x4e\xeb\x68\xee\x71\x1c\x05\xc1\x87\x68\xc9\x3c\x87\xb0\xec\x87\xa2\xd2\xea\x1c\x5b\xb7\x00\xe7\xad\x86\x91\xb5\x25\xc1\x89\xc5\x55\x59\xf6\xce\x41\xee\x47\xf4\x38\x9c\x6d\x1b\x5e\x8e\xd0\x73\x1f\xad\xb2\x75\x17\xd6\xc2\xb6\x93\x93\x24\x36\x09\x79\xc0\x37\x59\x56\x50\xb3\xdf\xbe\xd4\xc0\xd0\x03\x02\xf6\x74\x46\xf3\x28\x6a\x7f\x91\x3a\xa8\xaf\xc1\xda\xb8\xe7\x15\x24\x6a\x1a\x1a\xc1\xc2\xef\xa0\x85\x96\xd1\x7b\x77\x25\x70\x68\x11\xec\x42\xb6\x4c\x91\xdd\x1e\xf1\x5c\x3d\x40\x92\x22\x30\x1d\xb8\x8b\xe1\x34\x29\x55\x16\x10\xaa\x0c\x77\xf1\x04\x27\x20\xaa\x4f\xaa\x77\x1e\x34\x07\xca\xca\xf5\x23\x1f\xe2\x99\xf0\x4e\x3e\x71\xa2\xa6\xd9\x98\xec\xee\x0b\xaf\x3e\xc4\xea\x30\x53\x7c\xdb\x5f\x41\x65\x91\x67\xae\x3c\x32\xcc\x38\x10\xfd\x40\xad\x2b\xe9\xb1\x35\x94\x09\x33\xfb\x67\x4b\x70\x3a\xd6\xe9\xf0\xac\x45\x07\xea\x4c\xde\xff\x42\x76\xff\x4b\xaf\xae\x8b\x89\x6a\xfb\x3a\xe2\xbd\xee\x2a\x26\x7a\x85\x94\xdd\xe0\xa9\xfa\x30\xe2\x0e\x56\x20\x0b\x3e\x0e\xa1\xcd\x47\xb4\x58\x1d\xfe\x43\x4a\xa3\xea\x49\xf2\x4f\xb2\xf7\x45\x72\xb2\x03\xb2\xf0\xe3\x10\x13\x57\xdf\xed\xc6\x02\xed\x62\x95\x24\x9f\x57\x2b\xc2\x5e\x6a\x92\xc9\x92\xac\xfb\xfb\xf6\xf5\xcf\x96\xf6\x9e\x10\x88\x85\x36\xe0\x1d\x48\xd3\x58\x23\x31\x38\x0b\x8d\xcb\x8c\x35\x98\x91\x15\xd6\x03\x14\x97\xd4\x8b\xa2\xf4\x96\xd9\x60\xa2\xd6\xa9\x8e\x77\x47\xae\x55\x17\xca\x03\x2c\xf0\xb7\x9f\xfe\x30\x33\x09\x8f\xa0\xab\xec\xab\xf4\xda\xe7\xcc\xb5\x31\x0b\xc1\xd0\x51\x99\x26\xc8\x1e\xa2\x9c\x67\x3b\x21\x8f\xd0\x5d\x76\x9a\x58\xe6\xeb\x7e\x30\x9c\x61\xf6\xb9\x0b\xb9\x9b\xc1\xd5\x09\x8f\xf8\x5c\xbd\x4d\x81\xb8\xfc\xa1\x86\x46\x34\x43\x26\x68\xe2\x99\x20\x8d\x56\xd4\xd3\xbe\xd3\x97\x7c\x8e\xac\xae\xe6\x80\x99\x77\x39\xea\xa3\x7d\xc1\x9c\x39\x8d\x2f\xb5\xed\x48\x86\x14\x59\xbc\xb4\xa5\x9a\x31\xea\xe6\x95\xcb\x9a\xb5\x57\x05\x85\x28\xd4\x75\x32\x69\x67\x16\x6f\xd4\x7d\x39\xa8\x7e\x21\x56\x37\x1b\xd6\x3b\x9d\x3a\x48\xa9\x09\xf3\x78\xc7\x97\xd7\x13\x7e\x08\xe3\xb2\xbf\xa7\x8a\x0f\x76\x05\x57\xdc\xd8\xb2\xfb\x6a\xa1\xcb\x0d\xfb\x77\x8f\x24\x19\xe2\xc4\x6b\xca\xaa\x65\x9a\xbe\x88\x31\x5a\x5e\x9d\x57\x24\x53\xd7\x2b\xc4\xbc\xd1\x9a\x2c\xa9\x2d\xab\x33\xad\xd6\x07\x21\xec\x63\x6d\xee\x99\x68\x16\xfc\xba\x39\x95\x8e\x9b\xa1\x25\x06\x20\x51\x2a\x3b\x25\x81\x5f\x96\x0f\xee\x00\xa8\x38\x88\x46\x56\x28\xb3\xd5\xf8\x86\x9b\x73\xf8\xdf\xb7\x66\xcc\x38\x14\x64\xf5\x9b\x9d\x17\x9f\x10\x9c\xd8\xb4\x67\x6d\x35\x40\x40\x37\x56\xd6\x89\xb5\xc9\x21\x29\x91\xde\xc2\x5e\x60\xac\xd6\x23\x6d\x8c\x13\xdc\x8a\xa5\xbb\xbe\x87\x47\xb1\x6b\x82\x21\xbd\x06\xe3\x06\x79\xc3\x75\xe8\xa8\xa6\x19\xb3\xe4\xd4\x28\x2b\xcb\x71\xfe\xd1\x3a\xde\xc2\xad\xd1\x44\xdd\x89\x35\x2f\x80\xcb\x62\x8d\xb3\x77\x19\xed\x9e\xeb\xf0\xf2\x89\xf9\xd4\xc8\x62\x2b\x19\xed\x62\x0f\x16\x9f\xf8\xe1\x8e\x81\x9a\xed\xbb\xd7\x36\xce\x7d\xeb\x48\xaf\xd0\x9b\x87\x6d\x24\x9c\x9a\x74\x65\xd6\x31\x2d\x1e\xc4\x9b\x0a\xee\xfc\xb5\xbc\xbb\x08\x47\x5d\x69\xb9\xdc\x98\xf0\xa8\x99\xe0\xb9\x24\xbb\xba\x51\x3a\x6e\x1a\x70\x79\xeb\xfe\x73\x86\xc7\xa9\x89\xe9\x42\xd9\xe0\x71\x38\xf9\xa6\x7f\x48\xaf\x72\x2d\x3b\xa1\x2d\x63\xff\x4e\xbf\x2a\xef\x9a\x8d\xa5\x12\x72\xb3\x4a\x5d\x15\x63\xc4\xf2\xf3\xe8\xfd\x47\xd6\x1b\x59\xf9\xce\xed\x75\x63\x79\x55\x6b\xdb\x75\x0c\xd4\xca\x18\xbf\x44\x51\xa0\x1a\x29\x8d\x9f\x3a\x34\x5e\x9c\x9e\xad\x4b\x3c\x7c\xe7\x58\x45\x95\xde\x9a\x2e\x14\x48\x78\xa3\x72\xe4\xba\x9e\xa9\x6a\xc9\xf8\xce\x9a\xc6\xa1\xf1\x86\x05\xfb\xe3\x2d\x9b\x5d\xfd\xc9\x65\x55\x36\xa5\xff\xa3\x78\xac\x62\x6b\xae\x17\x13\xe4\x1e\xa0\x5f\x6c\x6f\x9f\x18\xd3\xe2\xb0\xaf\x75\x76\xa6\xb8\x6f\x4c\x0e\x94\x7a\x41\x2b\xd4\x24\x5e\xd2\x95\x5c\x77\xea\x02\x25\x3e\xea\x5b\xa1\x50\xa0\x8f\x47\x3c\xaa\x9a\x99\xa9\x32\x1a\x95\xd3\xe2\xf6\x8f\x3c\xbd\x55\xc7\xe4\xe5\x8e\xee\x77\xb0\x95\x9c\x98\xae\x2b\x3d\xdc\xa7\x54\xf3\x32\x62\x77\xdd\xa0\x77\x78\xb6\xbd\x9f\xf2\x0a\xc8\x61\x79\x99\x23\x47\xe5\xe5\xc1\xa8\xe7\x74\xc6\x73\x2b\xc7\x73\xaa\xe4\x8a\xca\xca\xf1\x0f\x96\x5b\xf2\xab\x55\xd1\x59\x31\x8b\xcd\x6e\x1e\x2c\xa6\x2c\x28\xa7\x34\x9c\xf7\x63\x24\xa1\x55\xcc\x53\x99\xeb\x39\x93\x91\x9d\x42\xe7\x8c\x25\xc5\x5a\xfd\x48\xab\x5c\x52\xe8\xb7\x15\xd7\xae\xf5\xc2\x19\x6d\xe8\x59\x5a\x84\x2c\x5d\xe1\x4b\x48\x92\x5b\xda\x45\xb7\x10\xc3\xbf\xc7\xe4\x2f\x6c\x3b\xdf\x66\xbd\xeb\x12\x0a\xe8\x9f\x24\x80\x36\xa8\xc2\x21\x5b\x61\x42\x85\x72\xef\xeb\xd6\x64\x07\xb7\x5a\xf5\x0c\x8c\xcc\x56\xcf\x7a\x6f\xd9\x92\x88\x04\x81\x6e\xd0\x48\xef\xa5\xf6\xa5\x1d\x4b\xb0\x56\x16\x55\x85\x25\xb6\xce\x0f\xd2\xc3\x29\x47\x92\x8e\x42\x99\x24\xbe\x45\x37\x5c\x66\xfc\x59\xd6\xb5\x54\xe4\xae\xed\xb8\xc7\x0a\xf5\x06\x4b\x67\xde\xdf\xc9\xb7\x3b\xa2\x37\x1b\xef\x20\x77\xaf\xa9\x42\x68\xfe\x29\xf9\x6b\x85\xcd\xcd\x34\xb2\x8d\x97\xff\xe9\x5c\xf3\xb3\x72\x3c\xc2\x7a\x75\xc1\xab\x74\xab\x53\xe5\x6f\xd7\xf9\x3f\x28\x18\x23\xad\x08\x22\xa4\x2a\x47\x84\x99\x0c\xb6\x1d\xba\x07\x3c\x4b\x3f\xbe\x27\x03\x3c\x69\xeb\xf3\xf8\x9c\x54\x3f\xfa\x99\x9a\xef\x5a\x6d\x0d\x6c\xcb\x15\x15\x94\xd7\xb1\xfe\x7f\x6b\xa6\xc6\xb0\x43\xd2\xeb\x64\xb5\x09\x40\xd2\x50\xb6\x4a\xea\x8b\x1a\x1e\xfa\xf5\x94\xac\x75\x55\xb9\x20\x37\x22\x43\x08\x2a\x89\x00\xa8\xa6\xc9\x6c\xce\x65\xbc\xd5\x10\x80\xf1\x41\xb5\x49\x18\xe6\x90\xe0\xc8\x11\xe5\xcc\xae\x42\x5a\x7c\x47\xd5\x7e\x10\xdb\x99\xe7\x07\xd9\xe0\x51\xb6\xbe\x02\xac\xef\x65\x63\x29\x58\x48\xa8\xdf\x23\x0f\xbb\xc0\x95\xfa\x95\x6b\x86\xba\x9e\xe9\xe6\x33\xa4\x93\x4b\x56\xc3\x20\x3d\x5b\x12\xdd\xf4\xf2\xe3\x58\xc0\x5f\xc6\xc7\xdf\x90\xe6\xfd\xef\xe9\x57\x1f\xd6\x43\x6f\xa7\x98\xff\xd8\x46\xab\x78\xb6\x23\x29\xc8\x81\x74\x38\xe6\xad\x36\xeb\x5d\x9b\xe5\x48\xaf\xce\x77\x33\x2c\x11\x6b\x79\xab\x94\xd1\xa1\x78\xad\xbc\xc2\x81\xca\x2c\x41\x86\xd7\xb7\x09\x65\xe2\xa9\xcb\x23\x86\x85\x2f\xd4\xe8\xfd\x74\xdb\x73\x75\xac\x9d\x23\xfa\x9c\xc2\x38\x89\xb3\xe7\xe6\xcb\xe1\xf9\x3b\x67\xcc\x97\x0c\x9d\xda\x5d\xc7\xfe\x1c\x5b\x87\x7f\x64\x60\x14\xc6\x6f\xb3\xae\x41\x81\x08\x6c\x88\xfb\x18\x67\x23\xb7\x20\x6f\xfd\x40\xde\x5e\x1e\xf3\xd1\x76\x49\x0e\xa3\x43\xb5\xb9\x86\x12\xe1\xcf\x17\xe0\x6b\xcf\xe3\x11\x72\x02\x88\xfc\x6b\x88\x4d\x70\x0b\x16\xd5\xd4\x80\xe1\xf3\x4b\x9d\x8d\xce\x6d\x6e\x0e\x4a\xf8\x36\xa4\xd1\xcd\x21\xc4\x09\x7b\x85\x7a\x51\x49\x56\x4e\x9e\x72\x81\x72\x45\xce\x5a\x96\xba\x70\xe4\xb5\xd2\x57\xa5\x77\x28\x5b\x79\x1a\xf9\x1d\xf9\xab\xb2\x0d\x2a\x0a\x4e\xf9\x43\xf9\x53\xc5\x0e\x83\x21\x7f\x21\x7f\xc3\xd8\xa3\x63\xd4\xee\x90\x84\xa3\xfe\xc2\xc2\x2d\x71\xad\xbd\xd0\x1e\x55\x77\x4a\xfb\x3d\x6a\x2c\xc2\x1b\xf0\x05\x9d\xd0\xd8\xeb\xbd\xd0\x6c\x00\x1e\xed\xb1\x5b\x5e\x73\x4d\xee\x1c\xe4\x75\xe7\x8b\x3b\xd7\x9b\xce\xa7\xbf\x3a\x7d\xe1\xbd\xd2\x9c\xf5\x09\xf1\x09\x71\x67\xfb\xe1\xb9\x06\xb6\xfb\xce\x17\xe2\x63\x4e\x68\x9b\xfb\x94\xfd\x54\xc2\x7f\x76\xd7\x29\x57\x9b\xe3\x64\xc2\xc9\x19\xed\x5d\xc7\x5d\xc7\x1d\x2a\x49\xd9\x1d\xc7\x1d\xc6\x12\x9c\x6e\xbe\xa4\x0f\xc1\xe5\x4d\xf3\x3a\xc5\x32\xb1\xd2\xb1\x81\x75\x78\xe4\x76\x87\x3e\xeb\x0f\xa7\xaa\x19\x8b\x46\xa1\xac\x6e\xe3\x44\x21\xea\x24\x01\x53\xab\x78\x38\x90\xa0\x3b\xad\x8a\xc4\xcf\x3b\xc5\x28\xba\x93\x00\xa5\x7e\x1b\x0d\xaa\x57\x6f\x75\xba\x5c\x18\xcb\x1d\x07\x48\x74\xda\x2a\x47\xc4\x9e\x0e\x76\xca\x3a\xaa\xd3\x5b\xe3\xbe\x4c\xd7\x72\x98\xde\x2d\xa0\xab\xa9\x79\xfc\x47\xd0\x6d\x0a\x6b\x83\x2d\x36\x4b\x17\xbf\x3d\x82\x39\x01\xd8\x44\x3e\xb9\x47\x6b\xf6\xbe\xe2\x0e\x9b\x61\x44\x18\xee\x6c\x39\xe0\x3c\x6a\xdd\x1b\x55\x98\x14\x72\xaf\x9d\x00\x37\x0b\x8c\xac\xe0\xf4\x6a\xb4\xb9\x2a\xed\x06\x4e\x6c\xa5\xbb\xc0\x14\x8f\x93\x17\x29\x38\xc1\x11\x6a\x90\x32\x94\xd0\x62\xe2\xe9\x53\xcb\xc0\x1e\x2d\x61\x8a\x9b\x73\xf3\xef\xe8\x34\x64\x20\x2c\x19\xa6\x01\x60\x04\x82\x38\x06\x01\x1b\x1e\x6a\x30\x5f\x46\x43\x2a\xb8\x12\x36\xa5\x14\xa7\x89\x2a\xbf\x5b\x24\x5f\x5c\x20\x71\x27\x3b\x18\x43\x32\x6c\x44\xd6\x49\xd2\xf9\x13\x3d\x23\xe2\x17\xf1\x3a\xde\x56\x70\x2d\x28\x5f\x9b\xe9\x48\x61\xcc\xb9\x24\xa4\x24\x3d\x77\xbf\x23\x16\x6d\x06\x43\x2a\x41\xe1\x31\x4a\x8b\x19\xd5\x50\xb9\x25\x9a\x73\xe0\x64\x2a\xa7\x3a\xd4\xe1\x25\x09\x7d\xe8\xba\xeb\xd1\x34\xaa\x41\x52\x38\xee\xbc\xc4\x05\x06\x85\x99\x93\xf8\x7a\x1f\xc3\xb8\xa7\xc1\xc7\xc0\x3d\x81\x3f\x45\x75\x2c\x71\x2d\x11\x17\xae\xb5\xd8\xa3\x81\x82\xc3\xcc\xc3\xb7\xa5\xae\xf5\x2c\x21\x96\x70\x8f\xe2\x4e\xd0\xfe\x99\x3a\xbe\x0b\xda\xc5\x90\x35\xd9\xec\xb9\x56\x80\x49\x34\xaa\x94\xa2\x86\x3f\x3e\xab\x2a\x4b\x32\x83\xcd\x14\x8b\xed\x4a\x38\x4f\x73\xfc\xd3\x1e\xbf\x8f\xb2\xf5\x50\x22\xe5\x81\x99\x13\xf3\x62\x4e\xdb\x25\xae\x0d\xbe\x16\x04\x70\xee\x06\x78\x63\xc8\xcc\x4e\x92\x26\x61\x08\x79\x8d\x7b\x7f\x4d\x8b\x6c\xc6\xaa\x07\x33\x1e\x23\x4c\x8d\x6d\x4e\xcc\x95\x26\xd5\x3e\x18\xec\xf4\xb3\x34\x77\x12\xcd\x10\xd8\xd5\x99\xde\xa8\xc3\x17\x86\x96\x18\x7c\x33\x91\xe0\xe4\x96\xda\x7d\x2b\xad\x65\xd5\xff\x7d\x87\xe8\xfe\xa6\xe1\x8d\xf8\xfa\x5f\x83\xc8\x10\xd7\x2c\xbe\x2c\x41\xcb\x4c\xe8\xe3\x75\xb4\x5b\x99\x9a\x9c\xf9\x1d\xcf\xb2\x51\x4a\x35\xda\x27\x7a\x99\x95\x0f\x9a\x40\x4e\xd4\x9d\xcf\x5a\xcc\x89\xa7\x45\x44\xce\x40\xa3\x28\x50\x56\x64\x6c\x93\xac\x5c\x38\x4e\xe9\x26\x2c\x9c\xb0\x29\x49\x5d\xb6\x64\xab\xe6\xa4\x4e\xf3\xfe\xcf\xde\x59\x16\x38\x2b\xbb\xca\x9e\xea\x5f\xbb\x06\x77\xa0\x04\xce\xfb\xec\xff\x75\xe2\xa5\x8a\xec\x38\xd7\x23\xfb\xe4\x2b\xf3\x31\x02\x64\xed\x38\x73\x36\x81\x92\x03\xf5\x9e\xc7\xac\x1b\x7d\xe5\xa3\xaf\x0c\x9f\xe2\xd1\xf4\x55\x79\x8b\xf2\x66\x63\x90\xc1\x99\xb8\x2b\xca\xd4\xfb\x21\x29\x8d\xc8\xa6\xb3\xde\x31\x9b\xb7\x15\xbe\x5b\xe7\xb2\x4e\xeb\xb0\xf4\xea\xd7\x7d\x33\xc7\xae\x49\x47\xac\xdb\x75\x5d\x8e\xdb\x78\x7e\xde\x5e\x85\xca\x94\x98\x34\x0a\x9d\x99\x9b\x71\x64\xe9\xe6\x98\x03\xb8\x5b\x1e\x3e\x94\x2c\x7b\xec\xae\x31\x23\xf1\x5e\x33\xaa\xef\x49\x44\xef\x9b\xeb\x3d\xeb\x71\x07\x24\xb1\x25\xf2\xa0\xc9\xa5\xc2\xf3\x3a\x41\x2a\x81\xde\x43\x67\x0a\x0b\x52\xc9\xc1\xc4\x40\x0c\x95\x42\x94\x86\x48\xfd\x8e\x98\x40\xe4\x21\x1e\x54\x6e\xfd\x9b\x15\xda\x77\xb6\x6c\xe2\xcd\xcb\xad\xf0\x15\xd8\x61\x08\x14\xb1\x5d\xee\xcd\xf3\xc9\xac\xb2\xc3\x11\xf4\x03\x7a\x35\x13\x9b\x0b\xb5\xd2\x18\xf1\x08\x7b\x7a\xdf\x16\xc5\xf1\x31\xd2\x04\x52\x26\x80\x8f\x6c\x9e\x5c\x57\xd1\x9f\x94\xfb\x67\x82\xf0\x98\x00\x92\x45\x49\xd9\x91\x74\x29\x87\x1e\xa2\x08\x84\x38\x90\x52\xa8\x54\x70\x2a\x03\x59\x4d\x9b\xda\x8b\x9b\x46\x66\x52\xbe\x38\x56\x97\x59\xc2\x62\x4a\x69\x72\x16\x35\x46\xc4\x8d\x09\x4e\x34\x65\xac\x67\x48\x25\xa7\x3c\x90\xd9\xbc\xa5\x0d\x84\xbc\x08\x6e\x8a\x6a\xcc\x63\x2a\x76\x84\x9d\x3c\xe1\xa7\xbc\x15\x20\x2f\xef\xab\xe3\xe2\x55\xf6\xdb\x6a\x61\x6f\x2e\x6c\x47\x05\x8b\xe5\x92\x76\x41\xb3\x76\x50\xc0\x02\xb2\xf2\x04\xd8\xa0\x84\x5a\xab\x6a\xaa\x89\xfb\xea\x39\xb7\x49\x64\x41\xe0\xe7\x76\xea\xc6\x89\x3c\x9f\x8f\x0b\x6a\x4f\xef\xeb\x33\xb5\xaf\x6a\x1a\x0f\x89\x35\xcf\x4b\x68\xf4\x69\x03\x4d\x74\x7c\xb2\x06\xa8\x07\x65\x6e\xdf\x2a\x3d\x2d\x41\x00\x42\x8a\xf3\x98\x05\x51\xf5\xf8\x95\xf0\x1e\xd7\x8d\x2e\x7c\xa7\x22\x3f\xa9\xe3\xc3\x8f\x73\xb9\xee\x9d\xd8\x5c\x5a\xde\xe5\xfb\x1b\x25\xd2\xfe\x1b\x67\x92\xf3\x74\x32\x5e\x4c\x90\x23\x3b\x4b\x9e\x30\x3e\x3b\xb2\x1f\xc3\xce\x21\x90\x93\x12\xf9\x53\x53\x49\xd5\xc7\xfc\x04\x21\x21\xaf\xd5\x07\x48\x87\x3e\xa0\x53\xd5\x14\xce\x7c\xbc\x42\xbe\xcf\xb5\xc5\xb5\x1e\x51\x4e\xaf\x08\x2c\x24\xab\x16\x2c\x4a\xef\xcb\x2c\x01\xad\x9f\x79\xf3\x61\x8e\x3e\x41\xa2\xf0\x02\xf7\x22\x54\x07\xe0\x53\xe8\x83\x4d\x9d\xcf\xd6\x0e\x4b\x96\xbe\xfe\xd1\xed\x07\x22\xc3\x49\xec\xab\x88\x9c\x2b\xa9\x3b\x3b\xa5\xd3\xbc\xe8\xa5\x5b\xef\xe9\xe1\x35\x90\xad\x2a\x5e\xe5\x9e\x31\x21\x89\xdd\x3b\x00\x6d\xc9\x2d\x2d\x3f\x77\x62\x5e\x65\x99\xa2\x43\x69\xe8\x4f\x15\x7b\xe5\x2a\x82\x9d\x03\xd9\x4e\xf8\x43\x2f\xfa\x8d\xef\x2e\x4d\x7f\xe3\x73\x27\xf8\xce\x0b\x1f\xb5\x0c\xb6\xf4\xd0\x66\x2b\x76\x9a\x53\xf8\x27\xeb\xcc\x98\x88\x0c\x81\x02\x0a\x54\xeb\x6b\x4f\xf4\x48\x8c\x4c\x96\xc4\x54\xda\x70\x52\xa4\x8f\x73\x19\x87\x23\x32\x04\x1c\x94\x59\xdf\xd6\x14\x40\xb0\x32\xbc\xe6\x81\x4e\xf7\x36\x5e\x54\x9a\xbf\x29\x75\x5b\xcc\x15\x3e\x34\x28\x6e\x23\xe3\x11\x2a\x77\x9f\xc2\xb2\x4a\x62\x9e\xd2\xdd\xff\xae\x24\xc8\xa4\x95\xd6\x46\x0f\xfa\x54\x78\x4d\x33\x04\x13\x2c\x22\x26\x0d\xf4\xdc\xb4\x79\xb6\xcf\x57\x6d\x1b\xc2\x01\x02\xc7\xc0\x81\xce\x0c\xe7\xaa\xfe\x6b\x21\x6f\xbf\x20\xaa\x84\x09\xe5\x16\xfa\x2c\x0b\x12\xcb\x92\xd2\x65\xbe\xaa\x8d\xac\x36\x99\x47\x8c\x47\x5c\x72\x5d\x55\x32\x25\xb6\xe8\x38\xcc\x57\x48\xef\x85\xe5\xb0\x0a\x43\xfd\xd9\x1c\xa2\xc4\x51\x6f\xe5\xa8\xa3\x96\x29\xb3\x9f\xc0\x2a\xe9\x5b\x7a\x62\xc3\x32\xe5\x6e\xa3\xae\xfc\xb5\xcd\xb4\xa8\x2e\x43\x4c\x3f\x9b\xdc\x67\xfa\x9f\x6c\xd3\x32\xdb\x5c\xf5\x94\x23\xa7\x2e\x57\x98\xaa\xf2\x59\x60\xe9\x1d\x1e\x57\x47\x81\xc1\x3e\x72\x38\xf4\x8e\xa6\x13\xee\x65\x31\x1b\x8a\xba\xcf\xfa\xee\x6a\xae\xc9\x42\xf3\xcd\xe3\xfd\xf3\x0d\xff\xd5\x55\x95\x98\xbf\x71\x38\xa5\x60\x7b\x1f\x6c\x5f\x64\x3c\x43\xc9\x68\x1d\x6a\xac\x68\xb0\xbb\x7c\xd1\x76\xfb\x6f\x1d\xe3\xd0\x4c\x39\xa6\xa1\xc0\xdf\xfb\x17\x67\x8a\x06\xad\xf1\xe4\x87\x84\xa8\x62\xc8\x25\xbc\x26\xb7\xb2\x68\xc8\x20\xde\x78\xc0\xd6\x4c\xa0\xad\x29\x7b\x0b\x17\x28\x66\x6f\xf6\x9b\x7f\xec\x50\x9b\x48\x19\x96\xeb\x9e\xc7\x7e\x6c\x17\x96\x93\x1d\xf1\xd8\x38\xa2\x20\x2d\x73\xea\xb4\x33\xbb\x28\x21\xcd\xdf\xdd\x43\x6b\x19\x62\xab\x85\xc3\x65\x72\x91\x0a\x41\xc7\x45\xd2\x48\xd5\xf3\xd0\x8a\x6d\xc7\x71\xb5\xd8\xa0\xcc\xae\x90\x78\x82\x19\xb6\xc0\x2b\x39\x26\x56\x9e\x1c\xcb\x48\x4c\x61\xc4\x02\xca\x0e\xb2\xf5\xe7\xe0\x6a\x4b\x23\x23\x30\x63\x95\x65\xa3\xc5\x5b\x61\x62\x68\xcd\x40\xf6\x2f\x39\xda\xf3\xe4\xf1\xdc\x4a\x79\x1c\x31\x9e\x4d\x4b\xfc\xbb\x3a\xe4\x35\x62\x9c\x6f\x4e\xbe\x4b\xc2\x54\x92\xbf\x68\x1e\x77\xda\xe7\xd8\x51\x1e\x97\xc6\x17\x7f\x09\xba\xb0\x29\xe5\x9d\x81\xdd\x28\x0a\xbd\x69\x98\xc7\xb6\x17\x26\x70\x39\x91\x9c\x90\x98\x9c\xdd\x1e\x46\xa3\x64\xf7\x49\x80\xc0\xf6\x53\xf0\x9f\x7a\xb1\xd5\xd4\xa2\xa5\xe7\x02\xd6\x75\x71\x9b\x17\x15\x67\xde\xdd\xb4\xe9\x56\x44\xd1\x5a\xf4\x26\x60\xff\x57\x9e\x3a\x3a\xed\x2a\xc2\xfe\x5e\xeb\x21\xdd\x56\xc6\x00\xff\x70\x7d\x9d\x85\x99\x9f\xf9\x61\x13\x19\x81\xe7\x95\xeb\x2c\x3f\x0c\xb7\xf0\xe7\x38\x90\xd0\x10\x16\x07\xe6\x99\x9b\xfc\x4b\x86\x9e\x5f\x95\xaf\xb5\x37\xcc\x67\xe2\x3f\x04\xd0\x72\x9b\x11\x57\x2e\x55\xe5\x5b\xd6\xe4\x1c\xc5\x63\xea\x3e\x98\xe7\x39\x29\x5c\xbe\x3c\xad\xba\xfe\xb1\x72\xc1\x2e\x2d\x95\x0f\x07\x5e\x88\x0d\xa0\x42\x74\x52\x40\xe4\xbb\xcd\x93\xc6\x66\x9d\x04\x38\xf1\x77\xf1\xd1\x05\x01\x3c\x5f\x49\xc8\xee\x82\xc0\xad\x18\x05\x61\xce\xc0\xb7\xc2\xc6\x9f\x10\x18\xcc\xa2\x04\xf8\xb3\x28\xc1\x81\x11\x43\x9b\x55\x82\x03\xdc\x2f\x29\xab\x5c\x52\xd6\x0e\x7e\xfb\xde\x1f\x82\x3f\x7e\xdb\xa8\x0a\xc3\xbf\xb7\x64\x5a\x0c\xeb\xed\xab\x5a\xdb\x95\x47\xc6\x90\x83\xde\x18\x11\x91\x80\xfb\x72\x67\xc2\x0f\xd9\xf1\xb7\x4a\x70\x5f\xfd\x22\x7d\xfb\x49\x65\xcf\xf5\x67\xa6\xac\xba\xae\xbd\xcc\x92\x16\x36\x2d\x17\x04\x47\xee\x3b\x9b\xd1\xcb\xe2\x0e\x4b\x0b\xc6\x3e\xa9\x01\x24\x6e\xdf\x1c\xde\xd6\xed\xf8\x0c\xca\x2b\xff\xb2\x4c\xc1\x5b\x80\x91\x6f\xdd\x22\xa0\x4e\x9f\x3e\xf4\x89\x8d\xf1\xb6\xaf\x65\xeb\xd0\x59\x91\x66\x1a\x82\x9b\x43\x2d\x9b\xbd\x02\x5c\x51\x7a\x84\xf4\x25\x81\xec\x73\x65\xec\x1d\x1d\x67\xb4\xa7\x83\xac\x40\x9f\xb9\x25\xed\xa9\xf0\xf3\xf9\x07\x20\x16\x49\xf3\xc5\xfe\xb6\x5e\xd8\x84\xad\xbc\xcf\xfc\x8b\xd8\xf3\xb9\x2a\xcd\xd3\xac\x88\x95\x1c\xe5\xec\x1e\x44\xe7\x80\x06\x98\x3c\x92\xad\xc3\xf5\x8a\xe5\x21\xaa\xd8\x30\xe9\x4f\x21\x0d\xf4\x77\x21\xf5\x95\x86\xa9\xde\x9e\x7b\xfb\x7f\xc1\x1b\xc0\xbc\x44\xeb\x53\x9a\xe3\xec\xd3\x72\x2e\xa0\xfa\x7e\xa7\xff\xfe\x42\xb6\x7a\xe3\xe6\x2b\x85\x1f\x42\x1a\xea\x6d\x41\xea\x2a\xf6\x2b\x79\xbd\xaf\x0b\xfb\x1d\xd9\x28\x6b\x00\xc3\xc8\x13\xf8\xf5\x77\xeb\x5f\xed\x33\x64\xdc\x1f\xde\xe2\x16\x56\xae\xbb\x79\xfe\xd4\xf9\x34\x2f\xdc\xba\xc2\xdf\x59\xad\x80\x99\x68\x73\x92\x76\x84\x7a\x4a\xde\x05\x30\xef\x61\xe1\x14\x70\x36\x1b\x37\x9f\x9a\x58\xbd\xde\x36\xa4\x9e\xaf\xc5\x09\x9e\xe9\x79\xc5\x6e\x01\xce\x6f\x15\xa3\xff\x9b\x7d\x6c\xa7\x86\x6b\x01\xf2\x83\x8e\x6e\x9e\x72\x37\x0a\x79\x79\x68\x10\xdd\x44\xa5\x62\x4b\xa5\xf4\x53\xeb\x4f\x52\x35\x70\xa5\x38\x1f\xec\xa7\x2e\x54\xac\x61\x5b\x0c\xab\x91\x59\xbb\x68\x4b\x48\x43\x4a\x5d\x63\x40\xb9\x2f\xe5\x89\x73\x01\x2d\x1d\x60\xcf\xbc\xb8\xa2\x8b\x45\xb6\x8e\x61\xa4\x47\x6b\xa6\x59\x72\x9a\x01\xca\x87\x85\x4b\x3c\xf3\x45\xc3\xc1\x08\x65\x8e\x9b\x57\xf0\x56\x03\x90\x52\x50\xad\x85\xfc\x74\xac\x47\x2b\x24\xef\x8d\xd0\xb4\xf7\x20\xb4\x8a\xf1\xe5\x52\xb0\x93\x62\xa0\xcd\xcd\x87\x1e\x50\xe0\xc7\x54\x45\x5b\x6a\xd2\x85\x8f\x0d\xde\x0e\xf4\xe8\xbd\x10\x18\x2a\xb1\x85\xb5\x4e\x55\xb6\xa6\x5a\x9a\xf2\x7b\x01\xa6\x56\x3c\xca\xd5\xf7\x8e\xf4\xb6\x0c\xad\x1c\x51\xf1\xe6\xca\xfe\xe0\xad\xd8\x77\xfc\x2a\x93\x3f\x9b\xd3\x83\x37\x4e\xea\x95\x0c\x73\xfb\x4f\xa3\x82\x14\x09\x6a\x93\x24\x80\x30\x60\xdb\xb1\xfb\xc1\x97\x2f\x1c\x0e\x91\x4e\x9c\x4b\x1d\x9f\x5d\xcf\xab\x92\x5d\x0d\x69\x5a\x3f\x3b\x1a\x3a\x77\x88\x81\xd9\xfe\x1f\x3c\x82\xc6\xf4\x87\xa7\xf5\xd3\xfa\x37\xd2\x86\xc3\xd2\x87\x95\x1f\xbc\xdf\xa6\xb4\xd9\xa8\x1f\x6e\x56\xee\x77\x6c\xe7\x7d\x44\xc5\xc9\x41\x84\x25\xfc\x79\x76\x8f\x98\x04\x88\x2b\x84\x77\x24\x2c\xc6\xc8\x58\x6c\x1b\x0f\x3e\xdd\x2f\x6a\xfd\x1d\x31\xc3\x27\x0f\x24\x59\xa7\x10\x46\x9d\x97\x0f\xf5\x5c\xfc\x83\x28\x08\xfd\xf8\xc8\x41\xd0\x83\xea\x5d\x78\xef\xc1\x69\xf1\x5a\x6b\x90\xb0\xe3\x24\x35\xa0\xec\x05\x55\xdc\x88\x88\x3f\x03\x5a\xaa\xb5\x4e\xfe\x03\x3a\x35\xdc\x5a\xbf\xbf\x01\x02\x43\xe6\x05\x27\x5a\xea\xdc\xa4\xca\x7d\x1f\x14\x77\xa1\xa7\xda\x7e\x48\x45\xe3\xde\x01\xad\x56\x4e\x27\xf3\x4f\x3a\xa9\x52\xc5\xfd\x18\xa8\x7c\x4a\x25\xac\x12\x14\xd8\xa1\x18\x02\xcc\xd4\x43\x2e\x5e\xe0\xb9\xc7\xda\x8e\xe5\x60\xcb\xda\x67\xcd\x90\x28\x33\x21\xb6\x8f\x61\x0d\x8c\x5b\x30\xc9\x98\x0e\x10\xc2\xbb\x00\x23\xa0\xa8\x63\x5d\x6a\xa1\xdb\x1b\x29\x98\x81\x60\x12\x1b\xef\xd2\x72\x73\x4a\x21\xa5\x2a\x6a\xb6\x05\x12\x13\x63\xf5\x08\x66\x60\x14\x94\xbd\x6f\xcb\x2b\xe6\x0d\xae\xef\xed\x1d\x19\x19\x1b\x3b\x6d\x78\xa8\xbc\xb8\x78\xff\x81\x20\xb5\x1c\x32\x3c\x73\xc6\x15\x35\xd5\xfa\x8e\x40\x83\x48\x54\xc2\x7d\x89\xaf\x5e\x8d\xe0\x50\x81\xc8\x3a\x15\x75\x7b\xfd\x1e\xac\x50\x27\xb5\xd7\xed\xd9\xf8\x2f\xb5\xba\xad\x3e\x3d\x0d\x7d\x08\x4a\x4b\x6f\xab\x9b\x95\x19\x0d\x61\x0a\xe5\xa9\xea\x58\x4e\xe6\xba\x2d\xe1\x04\xbe\x4b\xba\x03\x3b\x14\x78\x4c\x40\x40\x1d\xc1\xb6\x89\x94\x61\x1d\x8b\xf0\x2c\x04\xe2\x89\xc8\x11\xa8\xaa\xcc\x75\x5d\x1d\xcf\xba\xa9\x9d\x55\x2c\x59\xf6\x3b\x49\xed\x61\xd8\xcb\xaf\xac\x25\x16\x79\xcb\xc2\x5c\x09\x88\x1c\xc0\x23\xb9\x32\x22\xa0\x64\xb9\xc1\x11\x89\x61\x45\xde\xb5\x3e\x50\x95\x7e\xaf\x3f\x6e\xc5\xa0\x76\x5d\x77\x5a\xc4\xef\xcc\x59\xd7\xac\x02\xce\xef\x8e\xb1\xb0\xf0\x80\xb7\x61\x29\x88\xe6\xde\x33\x9d\x33\x74\x32\xd0\xf1\xe3\xef\x0f\xf7\xad\x54\xfe\xfd\xdb\xb7\x4d\x4e\xef\xf8\x36\x3d\xed\x9c\x3f\x43\xdd\xb9\xd3\xde\x90\x81\x07\x64\xff\x7d\x31\xf0\x19\x79\x22\x39\xf5\x67\x56\xe0\x15\x0e\xca\xcb\x9a\x21\x5a\x31\x03\xb1\x71\x7a\x26\xdf\x57\xba\xb1\x77\x95\x8d\x2d\x66\xa3\x52\x9c\x08\x84\x43\x7c\x4b\x0f\xc2\x3e\x1d\x0e\xc1\xfe\xa8\x27\xdf\x63\x77\x00\x41\x3f\x60\x36\x24\x2c\xd8\x7c\x43\xc3\x6b\xd9\x9d\xed\xe4\x30\xe9\x2d\x3e\x5c\xf7\x23\xa8\xcb\xbd\xc8\xf7\xc2\xd5\xef\x9f\xf4\x35\x4b\x1c\xef\xb0\x4c\x69\xd2\x54\x6f\x6d\xf1\xcc\x5c\x5b\xda\xa9\x4e\x4a\x58\x75\x8e\x7d\xea\x95\xb5\x07\xdb\xa1\x18\x92\x78\xfd\xc6\xc3\x5b\x40\x34\xab\x75\xab\x09\xab\x67\x86\xf7\xf7\xf2\xfb\xa1\x00\xe2\x40\xc0\x1d\x8b\xfc\x2b\xfa\x22\x80\x05\x93\x52\x2e\x13\x41\x53\x90\x54\x9b\x2b\xae\x07\x38\x53\x07\x80\x99\xb1\x33\x72\x0a\x50\x2c\x71\xdd\x95\x56\x5e\x84\x66\x05\xba\x00\xdd\xd3\x62\x99\xf6\xda\x9d\x5d\x64\x7c\x6b\xb0\x0a\x1a\x78\x74\x51\x0b\xdc\xc3\xa4\x3d\xa2\x13\x3a\xe2\x08\x04\x71\x43\x2f\xd1\xbe\xdf\x4b\xfa\x36\xe4\x39\x40\xce\x11\xcc\xa6\xb4\xff\x38\xdb\x83\x8d\x29\xaf\xe3\x36\x06\x6d\xd5\x6b\x8f\xcf\x8b\x1f\x85\x12\x7a\x7b\x89\x76\xfd\xb5\xb5\xc5\x43\x12\x0b\xeb\xed\x47\x13\xad\xfa\x1f\xd6\x76\xdb\xcc\xa0\x64\xf8\xbc\x85\x0d\x6c\x43\x11\x88\xc8\x87\xe7\x60\x97\x68\x16\x96\x95\x72\x80\xb1\xa4\xae\xfc\x00\x2e\xba\x53\xa7\x1e\x46\xdb\x6d\xee\xd8\xa5\x3e\x32\xed\x91\x88\xba\x95\x6e\xfc\x99\x5c\x8f\x79\x0a\x96\xbc\xd9\x33\xc3\x6b\xd8\x1a\x90\x34\x33\x62\x91\x3f\xef\x82\xec\x73\xcd\x4e\x6a\x97\x86\xe4\xe9\x87\xfa\x54\x85\x88\x12\x99\xe6\x25\xd2\x61\xbf\x29\xb4\xf9\xf6\x32\x9f\x10\xb2\x7d\x1e\x37\x0a\xfd\xba\xea\x20\x49\x94\x9d\xec\x0a\x7d\x41\x36\x6d\x85\x22\x6f\x27\x82\x69\x4c\x49\x8c\x1d\x9e\x49\x0f\x35\xf9\xbc\x79\xe0\x97\xe3\x3f\x00\x81\x84\x87\x81\x7c\xaf\xd6\x55\x65\x2d\x87\xd2\xa2\xcc\x68\x62\xeb\xe7\x3d\xcf\xaa\x06\x13\xdb\xb1\x5f\xd2\x02\x2a\x27\x80\x7b\x9d\x88\x10\x68\x9d\x1e\x33\x72\xbc\xea\xd0\x07\xb3\x79\x22\x3a\x96\x55\x40\x3e\xe7\x71\xc2\xdb\x7c\x4a\xd9\xff\x21\xec\xf9\xb5\x80\x95\xf6\xd7\x8e\xba\xef\x98\xed\xa7\xb4\x37\x32\x10\x5a\xce\x9d\xbc\xcd\x09\x5d\x82\x70\x1f\x1b\x25\x7d\x05\x8e\x19\x80\x2c\x72\x09\xe4\x54\x0f\x83\x96\xe5\xc4\x81\x65\xb3\x75\xda\x31\x27\x74\x0e\x84\xcc\x96\x58\xfb\x6d\xe4\xd9\xa9\x58\x24\x3a\x44\x6c\x3e\x80\x4f\xc5\xf2\xea\xea\x05\x1e\xf3\xfe\xed\x85\x4b\x58\x1d\x5b\x92\x3b\xb6\xf4\xe1\x84\x34\x45\xcb\x68\x21\xc8\x42\x41\xad\xcb\xdf\x6a\x17\xaf\x13\x5a\xc9\x3c\x7c\x3a\x66\xb1\x1b\xa1\xa2\x03\xac\x5e\x03\x8b\x4f\x9b\xef\x68\x35\xad\x80\x01\x61\x95\x20\xf5\xf0\xfc\x80\x84\xaf\xf9\x4b\xb2\x93\xa9\xbd\xe5\x84\x75\x1b\x90\x85\x9d\xa4\x2f\x62\x03\x7a\xac\x74\x9a\x80\x77\x7e\x9b\x38\x69\x24\xf9\xa8\x6f\x6f\xa3\xef\x74\xb2\x5e\x04\x33\x51\x3f\x72\xd5\xed\x4c\xcb\x8a\xcb\x66\xac\xf7\x6f\xcb\xcd\x08\x49\x0f\x6e\xcf\xf5\x48\xd8\x15\x99\xcd\x1d\x69\xd9\x71\x55\x67\x67\xea\x8d\xe5\x29\xd3\x87\xa6\x14\x69\x1e\xf5\x2d\x1a\x61\xab\xfd\x75\x69\xcc\xcb\x34\x2c\x61\x7b\x9e\x20\x6e\xbe\x59\x24\xb0\xb8\x9b\xf9\x48\xed\x6b\x4a\x19\x63\xd4\xce\x4a\x08\x01\x38\x40\x89\x74\x31\x41\x92\x79\x8f\xea\xfb\xa5\x38\xa3\x52\x51\xce\x29\x28\xe7\x0d\xc1\x71\x72\xfe\x3c\xb5\xc2\xe9\xab\x27\x54\xc4\xff\x94\x32\x51\x55\x45\xbe\xf3\x54\x88\xa8\x87\x14\xbf\x17\xa2\x0c\xd4\xab\x0a\x9e\xe9\xd2\x2a\x44\x3c\x21\x04\x94\x12\xe2\xa5\x98\x60\xf2\x94\xab\x05\xb9\x5d\x92\x30\x5e\xdf\xa2\x2b\x3d\xc7\xab\xf5\xaa\x49\x7c\x09\x5e\xbe\x12\x4f\xfd\x61\x78\xa3\xbb\x27\x97\xe3\x89\x44\xd0\x54\x53\x12\x52\x3c\x3d\x9e\x4f\x2b\x12\x5f\x2e\xc5\xcb\xe3\xa8\x8a\xb1\x07\xa3\x08\xb8\xbb\x64\xf5\x97\x27\xf2\xe5\x09\x74\x6c\xfc\x39\x89\xba\xa7\x65\x35\xa6\xe4\x2c\xc6\x99\x12\x4f\x76\x27\x07\x7a\x05\x7a\xb8\x7b\xc4\x53\xc2\x5d\xf2\x17\xaa\xa6\x78\xe3\x0b\xbd\x08\xaa\xdb\x6a\x0a\x44\x5d\x81\x1d\xc3\xa2\x4b\x71\x6f\x22\x0a\xa9\x8f\xa7\x4d\x7e\xab\x10\x13\x8a\xfe\x37\xf7\xf0\xbb\x2a\x00\x35\xd7\xaf\x08\xe5\xfc\xed\x16\x53\x85\x70\xb9\x45\x8d\xcb\xf1\x42\x3e\x57\x56\x2d\x4a\x28\xf2\xf4\xb8\x59\x57\x5a\x7e\x5d\xcf\x5e\xd5\x05\xcc\x6f\x1f\x50\xe5\x36\x7b\x0a\x9e\x5b\xa5\xc4\xe9\x3d\x3c\x6f\x7a\x11\x51\x0f\x25\x1e\xaf\xc1\x08\x67\x84\x66\x78\x0b\x19\xf7\x10\x8f\x07\x3e\x92\x05\xf2\x00\xdf\xca\xa4\xc3\x05\xc6\x94\xda\x97\x8b\xf2\x89\x3e\xfa\xa2\x19\xf9\x82\x1d\xe1\x21\xc1\xfe\x88\x43\x05\xb0\x2f\xe1\x39\x17\xa0\x99\x86\x6b\x79\xee\x79\x99\x72\xad\x4c\x2b\x3e\x3b\xa3\x9a\xca\x92\xb1\x98\xaf\xb5\x5b\xe3\x2f\xf0\xb1\xf8\x09\x05\xcf\x66\xf7\x6e\xeb\x90\x03\xda\x3e\xd1\x4f\x3c\x0b\x83\x31\xe8\x23\x14\x72\xc9\xca\x79\x17\xea\x77\x85\x00\x19\x37\x30\x22\x01\xa2\x90\x13\xd8\x61\xc1\x1a\x59\x4d\x80\xb8\x30\x7f\x49\x62\xbe\x38\x48\x5e\x2d\x72\xe4\x69\xad\x0d\x61\x0c\x05\x9b\xde\xb4\x42\x8c\xe2\x90\x00\x37\x91\x4e\x39\xb3\x21\xb5\xf8\x67\x49\x20\x32\xeb\x83\x04\x69\x4f\x42\x1f\xb9\xac\x0b\xba\x2a\x7b\xc8\xaa\x21\xbd\x26\xba\x46\xdc\x10\x73\xa8\xc1\x53\xa1\x9f\xef\xe1\xe8\x6d\x74\xd3\x2a\x56\xc6\xea\x91\x63\x68\x7c\xb5\x92\xca\xa2\x8c\x26\x10\x45\x3d\xa3\xad\x45\x04\x96\x2b\x82\xd3\x42\x4a\xa0\x26\x51\x22\x2f\x71\xc2\x64\x91\xe5\x22\x8b\x38\x59\x6e\xd9\xfd\xa3\xb6\x84\x80\x24\x9e\x3a\x10\xef\xef\x19\xa4\x8a\x57\x06\xbb\x7c\x0e\xa6\x38\x9d\x8b\x9a\x61\xc1\x25\x09\xe3\x46\x8e\x82\xe5\xa8\xeb\xd6\xee\x7e\xbd\x5c\xd7\xda\xd8\xea\x5c\xe3\x20\xca\x04\xb0\x05\x81\x07\x3d\x0f\xf6\xe9\xa1\x77\xc0\x8e\x16\xe5\xb8\x99\xe4\x22\xaa\xe4\x69\xaa\x34\xe0\xc8\x7d\x42\x95\xa9\x57\x33\x99\xdf\xac\xee\xe3\xee\x5b\x6f\x34\x59\x66\xb9\xcc\x22\x8b\x1d\xfe\xd2\xd2\x33\x31\x03\x44\x7f\x6f\xda\x94\xbd\xc0\x72\xc1\x5d\x43\x83\xaa\x84\x70\xcf\xbc\x41\x79\x6c\xb0\xa2\x6b\xc9\x37\x53\x20\x4c\xae\xcd\x6a\xc1\xaa\x0d\xf5\x40\xd9\x3e\xfd\xf9\x73\xfa\x25\xff\xf1\xea\x30\xdb\x29\x75\x11\xb5\x41\xba\x20\xdd\x39\xfd\x88\x2d\x5e\x7b\x1a\x23\x78\xf8\x2f\xa1\xde\xa6\x4c\x5b\x16\x60\xe2\x30\x2f\xad\x96\x28\x89\xdc\x3f\xc2\xa8\x59\xcd\x29\x86\xd8\x9b\x61\x0a\x8c\x77\x49\x7b\xe2\xad\x64\xcd\x64\x43\x08\x31\xaf\x95\xb6\xd9\xdd\xf8\xed\xda\x90\xda\x47\xf0\x8c\x64\x85\x12\x6a\x89\xbc\x3c\x96\xe3\x80\xf1\x1a\xf2\xa4\x52\xaf\xeb\x30\xf0\x2a\x65\x59\x43\xb1\x4e\x73\x49\x28\x7e\x2e\xe4\xb8\x11\x44\x3c\x81\x9f\x6f\x75\x0f\x77\xcf\xaa\x2f\xdb\x9f\x45\x50\x9b\x71\x02\xdc\xf7\x7b\x82\x0b\xdb\x63\xdb\x89\x58\x24\x36\x02\xe3\xe2\xeb\x1f\x13\xd0\x69\xdd\xe0\x8b\x45\x06\x00\xf3\xec\xf7\x98\x82\x3c\xa8\x2d\xb6\x8d\x80\xb5\x6f\xe5\x6d\x70\xef\x56\xf3\x17\x05\x74\x58\xd7\xfb\x62\xd1\x4b\xbd\xcd\xbb\xf9\x0e\x91\xa5\x17\x2f\xd5\x6d\x6a\x68\xf5\xe8\xa8\x6f\xa9\xe7\x32\x2c\x3b\x57\x9e\xcc\x81\xcc\x78\xbf\x49\x96\x67\xc6\xad\xd8\x8c\x39\x30\x73\xd9\xf4\x51\xf0\xa6\x4e\x13\x4f\xf2\x0c\xf7\x20\xa1\x48\x1e\x50\x04\xb2\x31\xe8\x98\xfe\x27\xbc\x01\x67\x4b\xa4\x2c\x2d\xc8\xde\xcc\x22\xf8\x7a\x32\xf1\xf3\xd7\x98\xda\x6d\xa5\xb4\x84\x71\x12\x0a\x5a\x89\x28\x45\x7a\x92\x51\x4e\x65\x96\x73\x44\xa4\x12\x11\x1c\xab\xa3\x3d\xd5\x86\x3b\xec\x07\x2c\x63\xab\x50\x98\x5f\x22\x62\x70\x79\xb1\x1e\x07\x49\x0c\x6b\x3c\xc6\x89\x74\x92\x2c\x5f\x82\xf0\x42\xa5\xa6\x8e\xea\x2d\xf7\x71\x92\x98\x97\x20\xa0\xec\xdc\x90\x2e\x98\x5f\xb6\x15\x06\xd3\xd6\xff\xaf\x68\x8b\x22\x7b\xd8\x18\xf9\x67\xf2\x47\xdb\x11\x6a\xae\xdd\xe7\x14\xe1\x79\x10\x06\xe1\xc2\x15\xad\x87\x3b\x21\x58\x8c\x3b\x8a\xc6\x1b\x83\xfc\x16\x43\x0a\x48\xa8\x92\x2a\x67\xf6\x72\x2d\x90\xfe\x3b\x32\x49\x3b\xb2\x81\xf0\x64\xe3\xfa\x54\x92\xd7\x58\xea\xc4\x25\x12\x5c\xdd\x66\x17\x54\xac\xf7\x07\x95\x9b\xc7\x9a\x52\x73\xa0\xdf\x6d\xf9\x10\xc7\x2d\xee\x2f\x2c\x8e\x1d\xcb\xc2\x3b\x55\xb0\xbd\x55\xb2\xdb\xdf\xf9\xb1\x10\xc4\x76\x2d\x7b\x85\xa7\x93\x3d\x95\x6e\x4f\x09\x39\x82\x00\x9d\xf2\x6b\x80\x1f\x11\x55\xae\xeb\x95\x90\x9d\xaa\xee\xe2\x93\x12\x1e\x04\xee\x8b\x12\xe1\xff\x28\xfa\x6e\x17\x64\x7a\xb6\x49\x69\xfe\x13\x0c\xfe\xc3\x50\x5f\xed\xad\x0d\xa6\x6b\xad\x90\x61\x8a\x15\xb7\x36\x64\x3e\x2a\x3b\x9f\xef\x02\x09\xda\xbb\xeb\x7b\x95\x56\xda\xe0\xd5\xfe\x71\xd0\xcd\x53\x82\x07\xfd\x1b\xea\x87\x02\x5b\x98\x42\xee\x4f\xef\x6c\x5d\x79\x57\x9e\xe9\x4d\x52\x5a\xc1\x24\x2e\xa9\xdd\x25\x98\x92\x9b\xf8\xaf\xa7\x71\x6a\x22\xb6\xcc\x99\xb1\xdd\x2e\xef\xdd\x39\x2a\xed\xb7\xab\xa7\x07\x14\xab\x9d\x48\x2a\xee\x3a\x9c\x48\xa8\xc9\x66\x63\xa1\x45\x70\xdf\xe6\x52\xb5\x96\x6f\xa5\xbe\xb9\x51\x23\x22\x68\xd5\xe2\x74\x4c\xc2\xc9\x5c\x97\x56\x97\x09\xb0\xa8\xc1\x4f\x66\xf5\xda\xe2\xda\xcf\xc0\x94\x7d\x05\x3d\x51\x5d\xaf\x9a\x4c\xbd\xa5\xf1\xbe\x48\xaf\x97\x7c\x9b\x3c\x6c\xe7\x98\x25\x8a\xcb\x43\xd3\x36\x07\x68\xff\x25\x60\x74\x34\xa8\x35\x7b\xdb\x29\xcf\x44\xbc\x17\x24\xef\x43\x9d\x82\xbd\x57\x32\x4d\x85\xb2\xea\xa0\x46\x97\x98\xcb\x44\x85\xab\x97\x70\x8e\x97\x98\xfe\x56\x49\x34\x65\x40\x94\x20\xb4\x0c\x89\xac\x47\x22\xf9\xc1\x9d\xc6\xc2\x05\x53\xb3\x5d\x7d\xb3\xa7\xdb\x85\xf3\x8d\x82\xf8\x96\x4d\xc8\x62\xe4\x46\xdc\x29\xbd\x4b\x74\xdd\xb8\xcf\x7f\x95\x1a\x9a\xb2\x99\x4d\x71\x39\x25\x71\x1b\x63\x2b\x8f\x8f\xa2\x39\xba\xb1\xba\xc0\x73\x66\xf8\x0a\xd1\xb6\xb2\x9c\xf9\xa6\x62\x18\x92\x21\x13\xf3\x74\x8a\x4f\x65\xad\x0d\xc9\x5e\x37\x75\x7c\xcf\x50\xad\xdc\xe3\x81\xfa\x90\x5e\x67\x2d\x6a\x12\xd1\x8a\x28\x42\x94\x09\x71\x0d\x05\x02\x37\xff\x7e\xc6\xd4\xc6\x10\x3f\x56\x5c\x78\x5d\xa2\x6f\x46\x86\x6f\x67\x26\x9e\x77\x35\x4f\xa7\xd6\x6f\xeb\x2c\x33\x95\xdb\xaa\x6c\x4c\x54\xfd\x9f\xd6\xc3\xb5\xdc\x19\x86\x4e\x6e\x05\xf9\x55\x60\x7a\xa7\x5c\x54\xe4\xec\xc3\xe4\x64\x1a\x91\xad\x53\xf4\xe9\xe9\x5c\xfa\xaf\x6b\xc6\xde\xfb\x2b\x5d\x28\x50\x58\x9c\xd1\xf1\x98\xf4\x78\x25\x32\x8a\xba\x5f\xca\xe5\x9e\x98\xe7\x32\x67\x40\xfe\x45\xc0\x9f\x97\xc9\x67\x86\xa4\x48\x6a\xbb\xcb\x74\xe9\x4d\xed\xfb\x0e\x89\x4d\x11\xea\x36\xf6\x46\x4e\xbe\x0d\xdb\x63\x5e\xba\xca\x05\xf0\xd9\xb2\xbc\xed\xad\xf2\x63\x91\xd5\xeb\xac\x7f\x2d\x4a\xe0\x44\xd4\x5f\xc7\x05\x2e\x2b\xf1\xa1\x4c\x51\x6c\x81\x4f\x91\x03\x08\xc2\x64\xe5\x00\x60\x75\x93\xbb\xa7\x1f\xbc\x3b\xa9\xe1\xd6\xa6\x55\xfd\x62\xed\x68\x98\x2b\xe8\x11\x7d\x4f\x90\x5d\xe6\xe6\xb3\xf1\xee\xc1\xf0\x13\x0e\xda\x89\xc3\xb5\x21\xcc\x19\x7f\x62\x68\x98\x09\xc5\xfc\xe2\x1f\xd3\x06\x12\x8e\xc7\x79\x32\x2f\xf6\x24\x7d\x2d\x34\x03\xbe\xad\x90\x2d\x02\x81\xf7\x12\xa8\xa2\xdb\x1c\x7d\x96\xe0\x19\x7c\x90\x7e\x5c\xc7\xcf\x2f\x6d\xe9\xda\x88\xcf\xb1\xc0\x04\x20\x5e\x84\x24\x32\x03\x9e\xcd\x94\xe2\x35\x23\xdc\xe7\xbe\xc0\x5c\x0f\x81\x50\x5c\x82\x6b\x58\xb3\xb4\x0e\x8c\xbf\x74\x78\x4d\xac\x29\xc6\x95\x14\x4f\x6c\x06\xc0\x29\x5e\xf8\x56\x39\x66\x2b\xfb\x14\x74\x73\x8d\x6a\xbc\x11\xda\xc8\xcb\x97\x23\x23\xf3\xf3\xae\xc2\x81\x78\xf5\xea\xd5\x3f\x67\xe1\x42\x1b\xe5\xff\x98\x50\x7c\xc1\x43\x76\x0d\xde\xb6\xb1\x13\x71\xd3\x3f\x2f\xb9\x26\xed\xb5\xd5\xfb\xca\xe8\x92\xec\x08\x79\x74\xbb\x67\x22\xb9\x67\x27\x5d\x11\xab\x4f\x49\x69\xf0\x57\xe9\x76\x64\x15\xec\x16\x8d\x2f\xbf\x1f\x9a\xf6\xcd\x6e\xdf\x10\xb0\xf2\xf1\x29\xd0\xf9\x30\xa4\xfb\xeb\x50\x23\x58\x32\x3f\xf9\x42\xc7\x86\xb3\x11\xa9\x29\x8b\x35\x0b\xe3\x93\x73\x62\xf2\x62\x7b\x74\xaa\x63\x86\x7a\x63\xce\x37\xfb\x55\xeb\x14\x41\x19\x1f\xfd\xd4\x92\x31\x29\x21\xa2\xd8\x28\xbd\x8d\x93\x91\x53\xf9\xce\xf1\x2c\x84\x17\x34\x90\xf2\x1f\xe4\x48\xf8\x43\x8e\x24\x6e\x70\x3f\x24\xc1\x3d\x82\xc7\x02\x69\x5b\x9e\xee\x7e\xc5\xd7\x89\xab\x9d\x0f\xb5\xa3\xc1\x59\x58\x96\x85\x03\xc4\x41\x23\x93\x5f\x30\x82\x16\x92\xa8\x8a\x96\x6a\x85\x25\x1d\x17\x23\x4a\xc9\xf3\x38\x5f\xa5\xbc\x99\x66\x2e\xe7\xef\xc4\xc8\xe1\x2d\xce\x8a\x5e\xc6\x2e\xe0\xd6\x27\x0a\x8c\x64\x75\xc1\xfe\xec\xe2\x83\xd0\x78\x08\x2c\x3d\x72\xff\xee\x9c\xb2\x23\x91\x65\xb1\x93\xb6\xa5\x81\xf2\x2a\x41\x5a\xcd\xca\xdd\x85\xc5\x13\x5b\x53\x2a\x6b\x0c\xa1\xf5\xb5\xc4\xec\xb4\x80\xf4\xe8\x48\x4e\xbd\x04\x17\x54\xb2\xb2\x25\xf9\x45\x9d\x84\x1d\x95\x16\xf9\x76\x8c\x41\x82\xe6\xc8\x63\x8a\x52\xdf\x59\x94\x36\x80\xe2\x00\x64\xeb\xcc\xbb\xab\x59\xdc\xb2\x01\xa5\x00\x1b\x14\x87\x0e\x02\xfc\xf4\xca\xef\x81\x1f\x8a\x8d\x47\x26\x07\xff\x19\x63\x03\x88\x3c\xe3\xf4\x6f\x9e\x97\x90\x26\xe2\x6c\xf3\x77\x75\x8c\xbd\x3f\x4c\x48\x5a\x94\xb3\x94\x6e\x9c\x8d\xab\x4d\x29\x44\x2f\xf3\x55\x9c\x71\xd6\xb2\x3b\xbf\x1b\xf6\xbc\x3b\xea\x0f\x05\x0d\x8f\xec\x8f\x8c\xee\x0c\xbc\xc6\xf6\x67\x1e\x8d\xb7\xb3\x11\x9b\xb8\xdd\x29\x01\xca\xd1\xdd\xa2\xaa\x9f\xa5\x8c\xff\xb9\xb7\x79\x0e\x77\x7c\x5e\x7e\x64\xdf\x6c\x03\xaf\x16\x26\xc9\xbe\x40\xe3\xe3\xc1\x53\x0a\x08\xfd\x6c\xd6\x87\x07\x17\x1c\x06\xc6\xce\x8d\x72\xb8\x53\x1e\xef\x5a\x1e\xb6\x2e\x62\x7e\x88\xeb\x0a\xc5\x10\x7e\x8e\x94\x65\x79\xf9\x79\x65\xbd\xe2\xbf\xc5\x66\xfa\x1f\x69\xfd\xb6\x89\x08\x53\x07\xdf\xd5\xc0\xd4\x91\x44\x54\xba\x95\x17\x9e\x95\x95\x4d\x15\xe2\x18\xc9\x00\x81\x4f\x25\xe5\x2c\x25\x11\x64\x2c\x7f\xee\x4c\xf4\x3d\xce\x42\xfd\xa9\x2d\x83\x82\x31\xea\x3b\x2c\x82\x8f\x7b\xea\x7d\x17\x84\x2c\xd2\x9c\xdc\x3d\xad\xbf\x73\x8f\xde\x6e\x8c\x89\x3d\xc7\xba\x4f\x49\x3b\xf6\x24\x7f\xaa\xee\xd2\x70\xf2\xed\xc2\x27\x69\x26\x6b\x8c\x1f\xdc\x37\xae\xd9\xfa\xbd\x47\x2e\xee\xf6\xb1\x12\xe6\xfd\x8d\xba\x0f\xdd\xf6\xcd\x74\xf4\x00\x14\x30\xea\x1b\x72\x05\xb5\xe8\x0d\x27\x1d\xad\xfc\x62\x5c\x39\x83\xaa\x72\x7f\x91\xdb\xee\x0d\x6c\x67\x6a\x4f\xdc\xda\x2d\x72\x0c\xdc\xfe\x92\x6c\xf1\x03\x63\x12\xc5\xec\x8b\xc3\x37\x69\x63\x6d\x2b\xd3\x21\x15\xab\x44\x97\x5d\xd5\xf4\x89\xce\x61\x31\x3d\xd1\xa4\x35\x71\x81\x8b\x6c\x06\x7f\x8e\x0f\xad\x0e\x6c\xef\xdb\x06\xd5\xa3\xa3\x25\x11\x95\x91\xb4\x1a\xd2\x91\xfd\x6a\xc4\x09\x47\xf7\x64\x54\x0a\xc2\x0f\x76\x02\x2f\xa3\xf4\xf9\x09\xf5\x88\x23\xf6\xec\x8f\x1f\xa9\xbd\x4e\xde\xbe\xd5\x5e\xc1\x0c\x78\x93\x9c\xec\x42\xae\x3a\xc6\xc1\xdc\x57\x18\xa9\xda\xbc\xc9\x8f\x08\x98\x1b\xa4\x45\xd1\x76\x52\x34\x71\xcf\x03\x55\x3d\x7a\x6a\x55\x64\x41\x52\x4b\x16\xd6\x5d\xe4\x95\xd0\xd4\x14\xef\xb9\x68\x6c\x21\xd5\x57\x99\x9f\xd8\x75\x42\xe8\xeb\xa2\x0d\x6d\x0f\x28\x63\x0f\xda\xe7\x27\x0a\x48\x02\x65\x8e\xa8\x74\xed\xdc\x15\x6f\x7b\x52\x96\x7d\x24\x6f\x45\x14\x62\xfb\xb1\x3f\x99\xc3\xd9\x15\x81\xcb\xac\xee\xa3\x41\xa1\x0f\x79\x15\xb3\x66\xdb\xfe\x9a\xb1\x43\x2f\xce\x9f\x9c\x7b\xdd\xd6\xb3\x75\x37\x7a\xe4\x92\x8f\x1d\x8f\x1a\x93\xd0\x58\x47\xb6\x76\xa1\xb2\xd5\xfe\xda\xdb\x2d\x57\x3e\xbf\xb9\xad\x5f\x7e\x99\x6b\xcf\xa3\x94\xc8\xf1\x8f\x88\x94\x94\xee\xbf\xaa\x76\xee\x72\xc8\x9b\x69\x82\x26\x21\xaf\x2a\x29\x81\xb3\x08\x1d\x72\x49\xf5\xec\xd2\x62\x40\xe5\xec\xaa\x96\x25\x4d\x35\xd0\x9d\x73\x93\x21\x4e\x9b\xbd\xeb\x3d\xd5\x33\x68\xc4\x25\x60\x81\x1d\x55\x33\x06\xb2\x8e\x8f\xf5\x79\x56\x7c\x0c\x8e\x8d\xe4\x70\x88\x0f\x08\xd3\x6b\x2c\x36\xae\xd6\xd5\xad\x8a\x5d\x2b\x7b\x13\xf6\xf4\xc6\x45\xce\x97\x5c\xc0\x13\xd4\x5e\xd9\xd3\x04\xca\xd6\x03\x79\x6e\xdb\x94\x2e\x2a\x1d\x51\x7a\x95\x4d\x4f\xb3\xf3\xd5\xbf\xff\xe9\x10\x44\xef\x11\xee\xdd\x27\xec\x54\x95\xff\x53\x5c\xa2\x30\x98\x57\x55\x27\x35\xfb\x94\xbe\x3a\x99\x23\xe1\x68\xce\x85\x41\x15\x25\xca\x45\x5a\xb7\xca\x9c\x35\x62\xb5\xd2\x9c\xab\x14\x36\x4d\x2e\xfb\x5e\x71\xe7\xd5\xed\xd3\xb6\xda\x58\xd7\xdb\x28\x92\xa6\x02\x31\x85\xa7\xd8\x5d\x6c\x87\xee\xd4\x28\x34\x17\x1c\xa2\xa7\x41\xd4\xe6\x98\xe2\x8d\xd2\xa2\xed\xdb\x8b\xc0\xc2\x02\x13\xad\x56\x58\x6b\x76\x29\x5e\xdb\x9a\xdc\x6e\x36\xe3\xab\x65\xa5\x08\x51\xa2\x7e\xee\x80\x71\x60\xeb\x61\x34\x45\xa4\x9b\x95\xad\xd4\xdb\x6c\x11\xd9\x5a\x7b\x21\x9e\xb3\xce\xde\x65\xa7\xd9\xb9\x10\x08\x0c\xc2\x52\xbb\x96\x66\x6d\xa5\x84\x77\xc5\xa1\x17\x7c\xb5\xf8\xda\x4e\xf6\x77\x00\x64\x61\x7b\x25\x51\xf4\x09\x63\x9f\x79\xd8\xd1\x67\x91\xfd\x52\xb3\x9e\xa0\x9c\xc5\x41\x39\x7a\xef\xa0\x58\xb5\x07\x42\x4e\x9e\x7c\x35\xf9\xd9\x91\xb3\x11\x87\x4f\x9c\xfb\x34\x39\x5f\x77\xec\x9c\xce\x39\xa5\xb5\x90\xa0\xaf\xbb\x10\x1c\x2e\x07\x99\xe8\xe5\xa2\xff\x66\xed\x6f\xfa\xb1\x28\xfb\x1b\x44\xdf\xe6\x99\x5c\x13\x03\x1c\x45\x50\x6c\x9d\x9c\x7e\x8b\x50\xbc\x84\xcb\xa2\x41\xab\x27\xa5\xf7\xc7\x8f\x6d\x9d\xb2\xa4\xc3\x20\x10\x7c\xc5\xd6\x29\xcc\x5d\xcb\x8d\x83\xda\x31\x8f\xdf\x3c\x7c\x60\x29\x7b\xd9\xed\xf8\x79\x3f\xcb\x4a\x3b\x7c\xc6\x93\xe5\x15\x3d\xed\xd8\xc8\x04\x7f\x4a\x37\xb6\xb1\x4d\xe5\xe5\xfd\x4d\x41\xbe\xbd\xef\x7e\x77\x65\xfb\x82\xa4\x8d\x48\xf8\xad\x62\x5e\xcd\xbe\x2b\xe6\xce\x34\xd8\xf7\x96\xf5\x54\x1b\xb3\xe2\x89\x31\x1a\xe7\xba\xb2\xd1\xb3\xea\x27\x5a\x4e\x57\x52\xa8\x66\x10\xc3\x1d\x5a\xa6\x78\xa9\x92\x0d\x52\xb7\xcd\x1e\xaf\x7d\x1e\x93\x08\xcc\xf7\xd4\xcd\x1e\xab\x45\xd7\xda\xa2\x75\x5e\xc0\xf7\xad\x7d\xdb\x0d\x99\xac\xb0\x17\xff\x3d\xd6\xbc\x33\xe4\xb1\x43\x41\xec\x6c\x43\x5c\xe3\xa3\x27\x45\x0e\xce\xa9\x29\xd7\x2e\x8b\x62\x2e\x2d\xfa\xc7\xf7\x47\x42\xfc\xb4\xee\x9c\xd8\x84\xf2\xee\x48\x41\x7c\x5a\x45\x87\x79\x8c\xcb\xad\xd3\x79\xf1\x48\xe7\xdc\x3a\xff\x0c\xfb\x24\x8d\x86\x13\x27\x8a\x58\x85\xf6\x76\x1f\xc9\x33\x26\xbb\x79\xf3\x02\x56\x51\x4a\x2f\xb9\xb9\xff\x9a\x49\x5e\xe9\xd3\xc5\xdb\x09\xea\x27\x34\x5a\xef\xff\x59\x5b\x19\x7d\x3e\xfc\xc4\x93\x6e\x16\x9f\x9c\xd8\xeb\xc4\xd1\xad\xe6\x19\xc5\xa3\x76\xe8\xab\xfe\x54\x6f\xe4\x77\x28\xf2\x6b\x78\xc7\x82\xd5\x20\xcf\xf2\xd4\xbf\xad\x5e\x67\x57\x7a\xdb\xbc\xb8\x72\xc6\x31\x6b\x0d\x7d\x50\x63\xf0\x2e\x66\xfa\xc5\x9d\xe9\xf6\x12\xfb\x4c\x40\xe4\xb7\x5e\x83\x2d\xdd\xd0\x37\xf0\x70\x6a\x84\x6f\xa9\xb1\xbb\x9c\x72\xcd\xa4\xf0\xfa\x44\xe2\xb6\xb4\x0b\x70\x70\x4b\x74\xf2\x81\xc2\x03\x72\x14\xfa\x8f\x55\x7d\xca\x24\x67\x6d\x4a\x74\x90\x41\x50\x83\xb4\xc3\x76\xad\xdd\xcb\x0c\x1c\x68\x13\x2a\xd9\xb2\xe5\xcd\x9b\x2d\xf7\xb5\xfd\x5a\xd0\x76\x26\xc5\x64\x48\xab\x6a\x7c\x34\xb7\x50\xc6\x0e\x39\xa0\xf3\xfb\xb1\xde\x3f\x5d\x5d\x7f\x7a\x05\x77\x1b\x18\xdb\xee\x02\x20\x11\x00\x80\x08\x1a\x77\xf8\xff\xa3\x4c\x9b\xe1\x0f\x07\x98\xc0\xda\x7a\xcd\x20\x7a\xc0\x85\xe9\x1e\xb8\xa0\xd0\xa9\x21\xd5\xf8\x2e\x05\x2b\x27\x2c\x7a\x9c\x62\x38\xfb\xee\x08\x83\xa7\x0f\x2a\xdf\xae\x24\x8b\xde\xea\x86\xce\x6a\xce\x86\x2c\x82\xb5\x37\xea\x62\x43\xe6\x85\x01\x15\xe3\xeb\x92\x6f\x9e\x2f\xda\xf7\x5d\xc1\x45\xac\x68\x2b\x1e\xba\x12\xb7\x23\x50\x4e\xaa\x19\xc8\x3a\x0d\x1f\xd2\xc7\x3c\x9f\x44\xe2\x53\x10\x5f\x53\x34\x10\x3b\x0e\xce\xd6\x4c\x47\x1f\xac\xae\x99\xdd\xef\xb3\xec\x56\x5f\xfd\x21\x47\xb3\xa9\x38\x97\x88\xca\x9c\x25\xb0\xf7\x02\x1d\xad\x67\x71\x5d\xb0\x77\x58\xb9\xdc\xc2\x1b\x18\x12\x5c\x7a\x0b\x5d\x88\x42\x97\x57\xb0\xfb\x0c\x87\xce\xbb\xd7\x7a\xfd\xec\x54\x53\xf9\x76\xa0\xf4\x6c\xd3\xca\xf0\xf0\xca\x10\x85\x86\x56\xb8\x2b\x23\xfa\x8a\xe1\xa1\x9c\xaa\xb5\xa7\xa5\x06\xb7\x02\xe6\x15\xfa\x1f\x0c\xf2\x4c\x20\xf4\x94\xbe\x15\xbe\x57\xff\xa7\xfe\xba\xcf\x9b\x3d\xdd\x75\x35\x0e\xd2\x66\x1e\x86\x5d\xea\x59\x3a\xdd\x35\x74\x67\x71\x38\x68\xc4\xa2\x29\xa3\xaa\xa1\xa8\x2b\xa9\xdb\x3c\x1e\x35\x64\xac\xb4\x50\xaf\x3a\x39\xdb\x3f\x74\x75\x6e\x24\xe1\xae\x7b\x60\x1c\xe7\xfb\x1e\x59\xac\x10\xab\xb4\x3f\x21\xc5\x26\x5d\xdc\xb3\x92\xdf\x70\xa3\x61\x81\x86\xbb\x52\xb2\x1c\x3c\xd4\xd2\xb1\xa5\x6e\x6b\x7d\xcb\x44\x70\x7a\x61\x77\x59\x81\xd6\x24\xd6\x7a\x15\xfa\x3a\xa1\xdf\x93\x89\x48\x19\x7a\xec\xe6\xd5\x11\x1b\x83\xef\xaf\x64\x59\x9c\x10\x47\x6a\xb1\x61\xef\x72\xcd\x3e\xf1\xef\xf7\x71\xcd\xb8\x45\x40\xca\xd8\x47\xe3\xac\x34\x8d\xde\x13\x9b\xbf\xda\x2b\xee\x80\xfc\xd4\xdb\xed\x93\x02\xb7\xf3\x35\x7c\xa8\xd9\x22\xc3\x45\x40\x9f\x9f\xe2\xe0\xcf\xe2\x38\x1f\xfd\x78\x8f\x79\x3e\xd7\xc1\x58\x03\x71\x49\xa7\xa6\x33\x25\xe5\x34\x26\x8d\x95\xc5\x55\x65\xd1\xa3\x78\x8c\xde\x9c\x2b\x1f\xd6\x1b\x56\x5b\x0a\x57\xb8\x0e\x3f\xd2\x24\xfe\x55\x8c\xa4\x8b\x99\x37\xa9\x8a\xec\x48\x9d\x95\xec\x90\x32\xb1\xdc\x98\xee\x6d\x0a\x87\x26\x1a\xe7\xae\x7b\x7d\xb4\x33\x03\xf1\x7d\x9d\xbd\xf7\x8c\xd7\xf5\xa2\x1d\x96\x60\x52\x07\x55\x05\xce\xd5\x3d\x7d\x69\x69\x2a\xf6\xa3\x22\x51\x3a\xb3\xeb\x2c\x20\x21\x38\xa9\xf3\xa0\x36\x8b\xdc\xa4\x50\xa5\x27\xe0\x54\x94\x73\xa4\xeb\xd6\x72\x76\x77\xa6\xac\x83\x4d\x12\x00\x44\x4b\x4f\x78\xef\xdb\xc9\x69\x6e\x4d\x82\x27\x5c\x57\xa7\xad\x09\x6d\x46\x93\x88\xd9\x66\x8a\x50\x82\xaa\x4f\xc4\x1c\x56\xa6\x0d\x09\xbb\xe6\x5c\x84\xb3\xd3\xca\x60\xbe\x0e\x95\xe3\x91\x13\x25\x7e\xf2\x4a\xc2\xf9\x4a\x76\x43\x6d\xa2\x38\x8f\x6b\x1d\x76\x39\xbd\x05\x45\x8a\xb7\x67\xdd\x66\x76\x9e\x47\xd9\xa1\xce\x77\x32\xef\xb1\x30\xf1\x24\xdb\x2d\xa7\x5c\xe6\xb4\xc6\x49\x98\x4d\x44\x37\x9c\x4f\x16\xdb\xba\xd2\xe3\xad\x72\x55\xfa\x0c\xca\x14\x3a\x51\xda\x83\x9b\x31\x3c\x3b\xd2\x09\x2d\xab\x98\xeb\x3a\x18\xe1\x7a\xeb\xaf\xfa\x5e\x25\xf1\x71\x90\xbc\x42\xbe\x5a\x4b\x8a\x51\x44\xeb\xe8\xc6\x7b\x05\xd2\x97\x96\x78\xc7\x6f\x65\x25\xb4\x2a\x70\x0c\xd7\x0e\x16\x37\x7c\xb5\x2d\x74\x3c\x5e\xdd\x78\xd8\xa3\xd0\x62\x54\xfe\xed\x2a\x6e\x0c\x95\xe5\x7d\xce\xdb\x99\x6f\xd0\xca\xcb\x9e\xd7\x28\xf3\xdd\x01\xef\xb4\xb2\x83\xa7\x04\xd7\xda\x5c\xb6\x9f\xa7\x5e\x28\xef\x1e\x5a\x6e\xc4\xd1\x33\xa0\x66\x82\xf1\xb1\x5a\xa4\x2c\x32\xcb\xed\x87\x3a\x83\xa7\xaf\xaa\x22\xba\x17\xd0\x6e\xbb\x40\x7b\xf3\xb6\xd5\x38\x2c\xa6\x2d\xa2\x5e\xb8\x9d\x77\x12\x51\xb3\xb7\x83\x52\x1e\xeb\x93\xe0\xed\xd0\x45\x7e\xa7\x7f\xea\xeb\x0b\x05\xc0\x27\x3e\xd1\x15\x40\x5e\x55\xb6\x3e\xff\x92\xdd\x57\x35\x0b\x80\xc0\x25\x33\x23\x58\x89\x35\xf4\x06\x22\xdf\xb6\xe7\xb8\xb5\xe8\x6d\x77\x7f\x0c\xae\xb7\xe8\x23\x2c\xe8\x7f\x2c\xb1\x43\xf5\x38\xe9\x96\x85\x9d\x57\x8e\xcf\x4f\x3d\xc4\xbb\xe2\x86\x18\xdc\x48\xf7\x1b\x37\xeb\xe3\x3d\xce\xb6\xc5\xcc\x1a\x3a\x2b\xd1\x0d\xe1\x93\x9e\x28\x4e\xe5\xac\x3c\xcd\xc2\x6e\x22\x5d\x3b\xd9\xac\xe1\x44\x0a\x0a\x0a\x2b\x87\x4d\x7d\x04\xb5\x59\x60\xd6\xe7\x2a\x4c\x10\x97\xe7\x76\x6c\x20\x00\x8b\x71\xc1\xaa\x87\x9e\x5a\x66\xa3\xfc\xb6\x75\x26\xad\xca\x2d\x7f\x98\xa3\x41\x38\xb3\x4d\xb2\xfb\xd4\xee\x80\xc0\x10\x1c\xb7\xe6\xea\xd6\xca\x36\x75\x0a\x74\x13\x10\x32\x69\x7b\xe6\x35\xf0\x95\xe2\xfe\x04\xc6\x6b\x10\xbe\x1c\xf7\xf9\x0d\x09\xc1\x76\x40\xbe\xbe\xe5\xd9\x4a\x67\x1d\x76\x3b\x31\x70\x68\xb7\x02\x04\x50\x02\x75\xda\x32\x5b\xeb\x70\x8c\x07\xbf\x43\x91\x95\x55\x6d\xa3\x97\x0a\xa9\x5e\x48\x85\xbf\x6e\xaa\x7c\x3a\xcc\x7d\xe5\xea\xf4\x4a\x08\x74\xa0\x1e\x38\xdd\xe1\x32\x45\x9e\xa4\xb0\x9e\x6c\x3d\xeb\x55\x2d\xbb\xd3\xad\x7d\xe8\xd5\xdb\x10\x93\x30\x15\x13\xe4\xc4\x73\xa9\x09\x2e\x3e\x51\xfd\x16\xa0\xa6\x1a\xcf\x78\xa7\xa0\x54\xae\xe6\x19\x16\x61\x37\x24\xee\x6d\x12\xfa\x7d\x1c\x89\x3b\x61\xc3\xbf\xff\x6d\x6b\x2e\xc4\x34\xd3\x1e\xdc\xe7\x37\xaa\xf1\xb6\x03\xb8\x4b\x74\xdd\x8b\x94\x42\xfb\x7b\xfc\x10\xde\xcf\x1f\xf3\x9e\xb9\x5a\x3d\xa3\x91\x7f\xfb\x2b\xf8\x49\xa1\x17\xfa\xa6\xe1\xe4\x97\xf7\x77\xf4\xfd\xe9\x93\x6f\x4e\xa9\x2e\xaf\x90\x52\xf1\x22\x6b\xae\x4f\x35\x68\xb2\xbc\x15\x61\xb9\xbd\x43\x95\x4b\x90\x30\x1b\x4f\xaf\x8a\xfd\x1f\x50\xab\x24\x84\x2f\xbb\x7b\x71\xcb\x75\x5b\xc1\x12\xd6\xc0\x5f\x66\xeb\x5f\x22\x2e\x90\x77\xe4\x79\x24\xec\x38\x29\x22\x6f\x58\x88\x3b\x33\xc0\x34\x5a\x27\xe4\xf2\x93\xa2\x47\x26\x9e\xac\xf4\x6f\xd9\xec\x35\x1b\xa0\xf2\x67\xc8\xac\x09\x5b\xe4\xed\x91\x82\x70\xae\x78\xa3\x24\x7e\x56\x6c\x59\x79\xd2\x3f\x41\x3a\xa7\x4f\x30\x4f\x2e\x3f\x49\x76\xc2\x7b\x05\xb1\xd7\x7e\x0c\x6c\x96\x7a\x5d\x25\xf2\xbe\xe0\x78\x81\xf9\xd5\xa4\xae\x31\x9f\x47\x32\xf5\xb2\x0d\xcd\xaf\x1e\xf7\x34\x60\x0b\x31\x77\xf9\xa1\xb3\xb9\x0f\x5e\xf8\x0e\xb1\x22\x42\xf6\x7e\xd9\xce\x3c\xd7\x8e\x6b\xd5\x68\xfa\x3a\xa5\xfb\xbf\x26\xf5\x39\x44\x83\xc9\x97\x1f\xfc\xd9\x40\x09\xf1\xba\x81\x49\xb8\xc8\xe2\x34\x3c\xec\x6c\x9c\x43\x22\xed\x60\xbf\xc8\x36\xe7\xfc\xa5\xc1\xde\x37\x16\xd0\x8b\x95\xec\xbd\x80\x7b\xef\x95\x85\xed\xa7\x3d\x56\x9f\x2b\xaf\x95\x0d\x60\x97\xe1\x54\x03\xf8\x7f\x0f\x55\x10\x30\xeb\x94\x8e\xa0\xb1\x73\x2a\x4f\xca\x8f\x1b\x12\xed\xbc\xb0\x74\x6a\x8d\xe1\xd4\x79\xe8\x32\x96\xcf\xa0\x8a\xc2\x7c\x2a\x05\x28\x54\x77\xd8\x6c\xa9\x64\xb6\xc5\x62\xe2\x6e\x51\x2f\xc8\xcb\x37\x5a\x5b\x9b\x69\x7d\x0f\x9a\x68\xc3\xad\x6d\x5e\x89\x9b\x57\xa3\x4c\xb6\x6d\xa7\x3f\xe4\x01\x2c\x2f\x6f\x6b\x6b\x02\x58\xc5\x46\x74\x06\xbb\x15\x02\x87\xb6\x13\xbb\xb1\x2b\x9d\x2d\xcf\xe4\x7b\x56\x9a\xaa\xba\x58\x37\x8c\x4e\x46\x64\x0c\xf7\x14\xfd\x17\xce\x33\x39\xc4\xc8\x91\x85\x56\xbd\xd1\x7b\x07\x5c\x8f\x14\xa8\x6f\xcc\x14\xac\x6f\x1f\xfd\xca\xfd\x97\x37\x2a\x0f\x1f\x3a\xc4\x5e\xcb\x2e\x66\x9d\xe2\x3d\x67\xf6\xa3\xad\x0a\x3b\x3a\x75\x50\x5b\xb0\x75\x9d\x2b\xcf\x5a\xea\xe5\x07\x50\x04\xc9\xee\xcf\xb8\xe5\x75\x7e\x28\x7b\x9c\xb9\xb4\xb7\xcb\xcd\xca\xfd\x9e\x08\x52\xa4\xfc\xee\xca\x91\xd0\xb3\x25\xa4\x3f\xce\x4c\xd8\xe1\x27\x6d\xa3\x4f\x23\x8d\xc8\x00\x1b\x38\xb4\x78\x0a\x80\xf4\x0f\x24\x1a\x4e\x3e\xc0\x7c\x92\xdf\x96\x5e\x1e\xb9\xaa\x1f\x79\x7e\x72\x07\xdb\x16\x89\x8f\xd7\xae\xdb\x99\x7c\xd6\x2c\x79\x2d\xae\x6e\xfb\xbf\x51\x11\xe9\xa0\xdf\x96\x42\xd3\x4e\xcf\x22\x6e\x0f\xf7\xfc\x06\x8d\x25\x3b\x54\x73\xd3\x03\x95\x11\x42\xd6\xad\x66\xec\x20\x3d\x33\xe8\x45\x58\x58\x99\x37\xa4\x57\x17\x0d\xf9\xc6\x73\x14\x09\xec\x94\xff\x12\x98\x69\x2a\x28\x2a\x2b\x22\x41\x43\x2e\xc2\xd5\xda\xa5\x18\xed\xb8\x2b\x9d\x3a\x8f\x82\x9f\xd3\x57\x52\x5e\x6d\x91\x53\x51\x4d\xc3\xc0\x9f\x18\x7a\x2b\x83\x0c\x2e\xa5\x20\xee\x73\x53\xda\xe6\x10\x21\xda\x46\x5d\xfe\xfb\x62\x5a\x78\x4c\xb7\x7d\x4e\xc8\xe2\x4e\x8f\x0a\x81\x01\x24\xeb\xd0\x70\x67\x76\x9d\x87\x45\x9e\x0c\xe9\x6d\x41\x7e\x44\xaf\x8c\x82\x50\x68\x23\xe3\xa2\x2e\xe4\x30\x6b\xb3\xc3\x0f\xc8\xe3\xb2\xa7\xc4\x6f\xe2\xb7\x6e\x8d\x7f\xf3\x3f\xef\xcd\xd6\xad\x6c\xff\x0f\x8d\x89\x2f\x15\x4f\x78\xbf\xf9\x24\x5d\x93\x0c\xd7\x4c\xa2\x60\x1a\x2e\x5c\x28\xa6\x50\x00\x82\x2b\x3a\x72\x6a\x7b\xd4\x78\x7d\x63\x4f\xfa\xee\xeb\xfd\x23\x56\x20\xa2\x06\xfb\x1d\xcc\xa5\x29\x9d\x3a\x0c\xcf\xee\x66\xa0\x9e\xa8\x28\xc3\xbd\xf2\x51\x1e\xea\xf0\x20\x1c\xf4\xc7\x80\xde\x2a\xa9\xca\x5b\xc3\xd5\xb5\x9f\x92\xac\xe1\x7e\xc4\x2d\x60\x68\xf8\xc0\x31\x29\x3a\xbf\x88\xc3\x05\x86\xd2\x99\x9c\x18\xb7\xc2\x6e\x0f\x40\x2d\xc8\xce\xdd\x81\xda\x27\x3e\x63\x13\x28\xb2\x9f\xf1\xef\xcf\x3e\x2c\xa6\xa9\xb1\x91\x55\x30\x8e\x2e\x51\x9f\xee\xaf\x7f\xee\xdb\x2f\x8c\xa4\x73\x55\x2a\xb6\x6b\xa2\xde\x91\x52\x31\x26\x26\x3b\x7b\x9c\x3d\x3c\xa4\x1e\x09\x51\x01\xa5\x16\xb5\x90\x64\xc3\x85\x52\x15\x18\x25\xa4\x95\x1d\xa5\xb1\x52\xaf\x09\xc0\xa4\xbd\xc5\xe2\xa7\x46\x40\x22\x12\x89\xce\xf8\x7a\x86\x86\x45\x47\x31\xe3\x4d\xeb\x7d\x3c\x2a\x3a\x51\xdf\x15\x35\x09\x83\xd5\x7a\x57\x9a\xc1\xa3\x0b\xd5\x9f\xa8\x90\xf8\x44\x16\x8b\x0e\xd7\x4b\x6a\x7e\x1f\xdc\x07\x5f\xbe\xf0\xff\x1f\x0c\x1e\xf3\xcf\xff\x0c\x81\xc2\x5b\x23\xa9\xd7\xc7\xcc\xe1\x10\xbc\x5a\x06\xb7\xee\xda\x2f\xc0\x84\x10\x39\x58\x4d\x46\x9d\xa8\xdb\x87\x7b\x12\xe0\xc1\xdc\x37\xf2\xfe\x1e\x02\xc8\x99\x90\xb1\x9c\xda\xa9\xe4\xf4\xcf\xe2\x1b\xb7\x2b\x8a\x05\x68\x86\xb3\xc3\xc3\xff\x73\x44\x66\x21\x21\x2f\xd7\xc5\xda\x79\xc6\xd9\x0b\x7b\xdc\xb8\xf4\xd0\x3d\xf5\xee\x67\x30\x3c\x89\x15\xcc\xef\x29\xe5\x38\xa0\x34\xb0\x07\x54\xec\x4d\xca\xa6\x7a\x6a\xb7\x5e\x4b\x22\x19\xc3\x7f\x03\xe2\x24\x4c\x9f\x2b\xca\xdc\x8f\xbf\x21\x5e\xa5\x86\x5c\x2a\x92\xfc\x64\x25\x5c\xc1\xff\x25\x1e\xa0\x8a\x4e\xb9\x18\xcc\x73\xbb\xe4\xc6\x24\x84\xcd\xcb\xf8\x5a\x1b\x96\x94\x3a\xcb\xbc\x18\x04\x8d\x86\x26\x85\x2c\x13\xc0\x74\x0c\x27\x55\xdc\x7d\x94\x7e\xb4\x23\xce\xce\xe2\x0a\xbd\x5c\x11\xe8\xb2\xe9\x80\xf4\xc9\x9d\xb8\x8c\x2f\x21\x2d\xec\x6d\x59\xc2\x56\xf3\x42\x2d\x45\x69\x38\xc9\xb7\x39\xac\xd0\xc9\x32\x3c\xc7\xc8\x53\x7e\x4e\x09\x4b\xdb\xa9\xc4\x70\xd3\x27\x87\xc3\x82\xa0\x87\x07\x80\x2a\x91\x15\xd6\x9c\xd6\x77\x63\x57\x46\xdf\xf6\x63\xa7\x1e\xa8\x9e\x4b\x3f\xc2\x5a\x41\x4a\x10\xd9\xc6\xba\xa5\x70\x37\xd4\xb7\xbc\xf3\x62\x20\xd1\x69\x87\xf8\xf6\xcb\x4b\x4c\xd2\x60\x5d\xc7\xeb\x67\xc9\x8e\x70\x24\x6c\x29\x87\x71\xfc\x0b\xb9\xa2\xc1\xb1\xd2\x8d\x56\xb1\x42\x1f\xa6\x43\x8f\x2a\x63\xef\x80\xfc\x4b\xaf\x69\x72\x7a\x7f\x21\x91\x33\xe8\xda\x87\xb6\x1c\xb6\xb3\x7c\x30\xe3\xdf\x46\xb3\x8a\x0d\x60\xf4\x07\x5a\x9b\x42\x04\x99\x51\x5e\x9e\xf6\x7a\x7d\x22\x21\xd5\xa9\x4d\x8f\xae\xf8\x72\x22\x0b\xbf\x5b\xde\x19\x52\xb2\x8c\x1a\xef\x91\xc0\x4d\x3f\xed\xc7\xf0\x0f\x86\xb8\x20\x13\xbd\x1f\x37\x96\xec\x0b\xe1\x09\x87\x64\x4c\x64\x1c\x48\x2b\x58\xd3\xe9\xf7\x54\x70\x9d\xbb\xb6\xf5\x97\x1f\x3b\x9d\x8c\xdf\xbb\x57\xb5\xcf\xcf\xdb\x33\x8f\x86\x6b\x3e\x6a\xfa\xa7\x57\x5d\xa0\x5b\xf7\x05\x01\xfa\xd1\x82\x97\x51\x54\x7e\xf8\x07\x37\x39\xb5\x45\x9d\x3c\x9b\x72\x05\x95\xa3\xa3\x6a\x4f\x02\x3e\xc2\x33\xaf\x53\xd1\xa7\x8a\x42\x30\x8f\x6e\x2b\xf9\x0f\x5c\x71\xc4\x5c\x58\x68\x1d\xc0\x3b\x65\x64\x91\x87\xe0\x49\xe6\x78\xf6\xe5\x36\xe5\x3e\xf1\xa7\x20\xa1\xa1\x58\x43\xa7\xfd\xa0\x56\x1d\x72\x01\x93\x70\x4e\xa6\x46\xaf\x13\x95\x4b\xef\x7c\x39\x39\x51\x50\xe7\x98\xf6\x1a\x62\x61\x2d\xfd\x7e\x0a\x24\x15\x02\x91\x47\x16\x6e\x58\x90\x80\x3f\x3a\x61\x2e\x70\x01\x66\x2e\x1f\x1e\x02\x0b\x21\xc2\xae\x43\xe1\x66\x88\x00\x84\xdf\x84\x5a\x0f\x24\xf9\xdc\xef\x80\xfa\xbe\x17\x0a\xea\xe1\xd6\xdd\x9e\x5c\xd8\x89\x6a\xb6\xb4\xab\x8d\x72\x76\xd2\x62\x9b\x31\xfa\xe4\xc0\x46\x34\x0b\x0a\x25\x42\x20\x10\x08\x1f\xb9\x42\x0d\x6b\x22\xbd\x72\xb2\x2c\x1d\x24\xa7\xf4\x24\xec\xc9\xfd\x5c\x89\x37\x4b\x95\xad\x35\xde\x73\xf7\xf3\x6e\x5f\xc4\x0c\xbe\xd1\x2b\xf5\xf5\xb1\xa3\x15\x76\xb5\xbd\xa7\x20\x8a\xf2\x50\x24\x92\xcf\xa9\x33\xcc\x2f\xa1\xa5\x18\x78\xbe\x1d\x3e\x4a\x82\x86\x61\x77\x2f\xcb\xf2\x54\xce\x69\xbb\x58\xea\x86\x46\x91\x4e\xad\x87\x29\x40\x1f\xd7\xcc\x1e\x1e\xd4\x85\x41\xfc\xa1\x02\xf5\xa4\x4b\x24\x72\x3e\xfa\x47\xd7\x6e\x63\x09\x51\xee\x52\x5d\x0d\xa1\xbf\x5d\x65\x5c\x15\x43\x20\x10\x77\x10\x5e\xea\xca\xba\xcd\x00\xf0\x91\x9e\xaf\x57\x36\xde\xaa\x7d\x4c\x42\x7c\xf9\xe8\xd2\xb1\x99\xa8\xb3\x36\x31\xf3\x9d\x52\x0c\x0d\xb4\xd1\x70\x6e\x3d\x92\x87\x0c\x1d\x0c\x62\x10\x94\x1d\x3e\x40\x6b\x06\xb3\xfe\x16\x44\xb6\x52\xd7\xd7\xc6\x8c\x42\x0c\xc0\x3c\x64\xeb\x16\x44\xcc\x4f\x4b\x9d\xe7\xde\x67\x7a\x4a\xeb\x32\x85\x6d\x6f\x05\xbf\xdd\x7a\x4d\x6e\x05\x45\xe7\x7d\x45\x4b\x47\xc0\x57\x94\xe4\xb7\x94\x48\xa1\x43\x83\x09\x69\xa7\xa2\xf3\x33\xb3\xb5\x05\x3c\x05\x49\x3e\xed\x4d\x19\x51\xfb\x81\x9b\x82\x6e\x85\x68\xe0\xee\xa9\x1e\x35\xeb\x30\xad\x16\x71\x62\x39\x6a\x0b\x43\x5f\xc0\x7e\x50\xea\x6f\xd6\xf5\xf0\x61\xad\x99\xca\x80\xc0\x31\xf0\x94\x3e\x62\xd7\xa9\x8a\x91\xd3\xdc\x69\xd6\x76\x86\xff\x9b\x36\x33\x19\x75\x5f\x08\x9c\xc9\x3b\x66\x6a\x1e\x03\xb8\x2f\x31\x27\x79\xb0\x19\x39\xb7\x44\x38\x9b\x61\xd1\x20\x05\xad\xba\x6e\x2b\x16\x2e\x5a\xc0\xf2\x18\x66\x71\xff\xb9\x3e\xc1\x5a\x0e\xcc\xc3\xf3\x54\x90\x9a\x16\xce\x9f\xce\xac\x04\xf5\x73\x36\xa7\xea\xe9\xcb\x1a\x0d\xd7\xee\x1f\xed\xa0\x77\xa3\x56\x0c\x1f\xac\x40\x29\xf8\xc1\xea\x08\x81\xf6\xe0\x77\x17\x31\xa8\x11\xfe\xbb\xb3\x60\xd2\x68\xef\x09\x03\xa6\x7c\x5a\x77\xb2\x90\x8b\xaa\x86\xf7\x55\xb3\xff\x69\xf3\xb7\x0f\x1e\x61\xae\x7f\x7b\xf8\x5d\xe7\xb2\xfe\x22\xaa\x97\x10\x35\x0b\x88\x58\xf7\x20\xaf\x4d\xf7\xa1\x44\x58\x66\x6c\x7c\x36\xcf\x62\xa6\xc9\x33\xcf\xd2\x5a\x1f\x3d\x63\xa1\x64\xf8\xc7\x86\x2f\xc0\xe2\x62\x57\x4f\xfc\xd0\xc5\xe2\xda\x67\x16\xc4\x4c\x20\x15\x0b\x0c\xd8\xc3\x81\x5e\xb0\x0c\x7e\xd0\x87\x6f\x94\x3b\x4c\x78\x9f\xd4\x30\x65\xb7\x5f\x08\xca\x5a\x9a\x92\x2c\x99\x90\xbb\x43\xc3\xb5\xdd\xb7\x25\xf7\x22\x98\xc4\x08\x87\xb9\x11\x28\x1b\x7b\xc1\x16\x9a\xcc\x3e\xd4\xed\x39\x82\x36\x07\x3f\xc2\xc1\x83\x04\xa5\x03\x98\xbc\x05\xfc\xfb\xef\x85\xe9\x43\x87\x8e\x60\x06\x19\x19\x2f\x87\xa0\xc6\x7d\xbd\x47\xd7\x28\x10\x01\x06\x3f\x04\xa4\x00\x11\x94\x0c\x9a\x5a\x69\xb4\x17\x09\xb9\x36\xfd\x6d\xfd\xf2\xb9\x09\x76\x7b\x4c\xaf\xc7\x33\xec\x5a\xab\x5b\x61\xa3\x90\x78\xb7\xca\xd9\xfa\x27\xb0\x39\x36\x12\x21\xa7\xb4\x31\xb6\x32\xb1\x17\x27\xe9\x70\xbd\xc0\xc8\xcd\xa5\xe6\x5b\xa4\xcb\x94\xc6\x1e\x29\xcd\x29\xb1\x4c\x40\xc6\x99\x56\x7e\x2b\x72\x98\x9e\xae\x32\x9f\xd5\xca\x91\x07\x6b\x6b\x83\xb5\x39\xf2\x03\x5a\xed\xe6\x09\x30\x4e\x47\xbb\x85\x86\xcb\x32\x83\x35\x72\xd9\x61\x51\x4a\x16\x0b\x0e\xc3\x23\xce\xfd\x7f\x2b\x8e\x16\x5a\xc1\x2c\xaa\x4f\xa8\xe9\xcf\x68\xed\x4f\x0d\xe8\x3a\xfa\x1a\xd6\x58\x15\x07\x3d\x60\xa7\x4f\xbf\xe6\x30\x88\xc1\x0c\x8e\x14\xdf\x8b\x1c\x1c\x8c\xbc\x57\x3c\xf2\x4e\x1d\xcc\x3b\xc0\xca\x7b\x5b\xb3\xbe\x1e\x9c\xfc\x1c\xd3\x65\x30\xc5\x5e\xb7\x47\xe7\xc8\xce\xdd\xac\xc0\x2d\x7b\x0c\x3a\xbe\x26\x1c\xdc\x96\xf5\x56\xa1\x16\x19\x4f\x1e\x3d\x74\x5d\x86\xf3\xbc\xb5\xc7\xd1\xf6\x34\xc6\x8f\x4b\x46\x7d\x31\x51\xac\x57\x01\x50\xca\x79\xe2\x13\x40\x4f\xa5\x7e\x6b\xf7\xf1\xa6\x5b\xef\x2b\x81\xb9\x63\x9f\x11\x0c\x04\xc0\x14\x44\x99\xc6\xca\xf7\xb7\xde\x40\xf9\x8d\x6b\x2c\xbf\x15\x55\x42\xd4\x23\xc5\xb1\x26\xd6\x72\x43\x8c\xb8\x65\xd6\x2c\xe4\x2f\x61\x74\x5b\x10\x58\x4f\x64\xeb\xd4\x9a\x7b\x2d\xfe\x40\xf2\x61\x0b\xa4\x14\x19\x69\x60\x20\x51\xee\xbc\x2f\xb0\x0d\xa2\x06\xa9\x42\x82\x58\xee\x18\x49\xf5\x48\x55\x88\x2c\x7d\xa3\xc8\xa4\x5d\xb4\x0b\x4f\x79\xaa\x2c\xae\xaa\xde\xed\xf4\xb9\x1b\x74\x47\x64\x08\x14\xb7\x8a\x9f\x2e\x40\xe7\x87\xeb\xbe\x84\x8c\xac\x00\xf6\x7d\xef\xdb\x80\xf9\xee\x1a\xc7\x0f\x39\x53\xad\x55\x12\xaf\x57\x00\x81\x21\x4f\xca\x1a\xa2\xd2\x95\xa4\xe9\x60\x68\xc0\xba\x3f\x9b\x2f\x98\x3d\x9f\xa4\xf3\x0a\x20\xf0\x6f\xc7\xf9\x22\xf7\x99\x1a\x06\x8f\x3a\x38\x82\xf8\x41\x36\x02\x56\x4b\xc6\x23\xa6\x91\x58\xae\x1f\xb6\x88\xa0\x89\x49\x71\xf4\x71\x8f\x4b\x85\x8e\xed\xdc\x79\x2c\xd1\xb8\x83\x3a\x5e\x50\x41\x75\x10\x7e\xdf\xdd\xf2\x5b\xb0\x01\xb9\x35\xa0\x80\xdf\x3c\x8b\x60\x64\x91\x99\x6c\x32\x75\xd8\xda\x1d\xff\x76\x0d\x36\x9d\x35\x62\xd2\xfd\x0b\x99\xc7\xad\xad\xb0\x81\x4b\xd3\xf7\x76\xeb\xfc\xed\xd1\x16\x8f\x6f\x0b\x88\x80\x8a\xae\xcb\x0d\x9d\x6f\x13\xa3\x99\x0a\x49\xd1\x90\xa5\x38\x10\x8a\xe8\x10\x30\x8a\xe8\xc8\x4d\x8c\xfc\xf9\xed\x09\x7f\x53\x7f\xc9\xd8\x17\x12\x4e\x1f\xf6\xfc\x05\x96\xd4\x26\x51\xfd\x25\xc2\xc2\xd9\xf8\xb6\xb6\x78\x5b\x1e\x22\xba\xa5\x3a\x86\x76\xcb\x45\x08\x62\x0e\x4a\xda\x93\xf5\x30\x90\x94\x4b\x22\x90\x60\xe4\x47\x7f\x5e\xba\xa4\xe0\x21\xf1\xdc\xbe\xf5\x14\x33\x23\x47\xb2\xcc\xc7\xfd\x8b\x57\x54\xa0\x62\xf8\x41\xc3\xbd\x27\x9a\xf2\xf8\xef\x34\x14\x49\xce\xc3\x49\x6f\xbe\xa1\x35\xf5\x4b\x40\xb3\x64\x29\xc6\xbb\xa2\x48\x39\x65\x57\x1a\x99\x60\x9c\xa3\x70\x92\x5b\xcb\xf1\x27\x3a\xed\xf1\x71\xce\x5c\x7d\xde\x01\x8e\xc7\x34\x3d\xee\xb0\x40\x44\x37\x7f\xe0\x5a\xc0\xf3\x13\x99\x77\xb6\x16\x59\x35\xe5\xe6\x9e\xde\xe9\x1b\x30\x14\x36\x93\xff\xbe\xd3\x98\xcd\xea\xd0\x92\x81\x20\xb4\x2a\x29\x03\xb3\xe8\xec\x80\xf3\x7a\xb7\x47\x16\xea\x53\x3c\x01\x2e\x46\x39\x22\xe7\xe0\x43\x61\xce\x21\x7a\x84\xae\xa3\x8a\x5b\xbe\x7e\xc5\x50\x3e\x9a\x92\xdd\xb4\x63\x03\x91\xd8\x5a\x42\xff\x8f\x62\xcc\x34\x6c\x1e\x10\xc2\x92\xd9\x9f\xe3\xdd\x73\x9f\x9d\xeb\x9b\xd4\xb3\xdc\xbb\x59\x89\x16\xa7\x81\x6a\x28\x4a\x95\xb4\xd5\x9c\x1b\xb2\x3a\x88\x71\x5a\x6f\x25\x39\x22\x20\x8c\x15\x9f\xc9\xe2\x85\x5d\x63\x2c\x3a\xb7\x5a\x72\x15\xf4\xa0\x50\x41\x3c\xd3\x05\x40\x70\x11\xc4\x2f\x8e\x22\xfb\x9c\xc6\xd4\x0d\x9f\x8f\x67\xcb\x5d\xbf\x5b\x75\x11\xb3\x6f\xc5\x57\x9c\x28\xbe\x41\xc7\xb8\x33\x61\x49\x83\x4c\x1c\x2f\xb1\x08\x8f\x29\x5e\x6a\xc1\x8b\x5f\x13\xd9\xee\x73\x13\x93\xc7\x3b\x91\x5f\x13\x22\xfe\x80\xad\xd5\x14\x4b\x95\x59\xb5\x09\x09\x6d\x11\xc4\x84\x9a\x22\xb8\x6f\x6a\xe9\xcd\x3d\x31\x48\xf6\x9e\x66\xc6\xce\xa4\x3b\x46\x20\xcf\xd9\x0d\x55\x5c\x56\x3e\xb3\xf0\x1f\x7b\xc0\xc5\x39\x59\x63\x36\x4a\x9c\x3f\x78\xde\xcc\x80\x57\xf3\x30\x4d\x2d\xab\xa5\x37\xd2\x1a\x1f\xd8\x99\x9e\xa2\xee\x48\x72\x56\xa8\x32\x0a\xb7\x91\x14\x1d\x49\xea\xb4\xee\x3c\xfb\xe0\x08\xeb\xe2\xe6\x28\xb7\xdc\xe6\xb9\x15\x06\xed\x0f\x9c\x0d\x35\x75\x79\x77\x6a\x42\x74\x85\xcb\xff\xe5\x1c\x8a\x06\x41\x91\xb0\xaf\xd6\x8f\x6f\x17\x0f\x86\xf5\x5c\x65\x1b\x33\x59\xe1\x8e\xfa\xb5\x4c\x5c\xee\xca\xba\x6b\x6c\x23\x73\xff\x73\xd0\xcb\x7f\x94\x0e\xcb\xaf\xcc\x1b\x14\x47\x13\x0e\xe8\x62\xff\x2f\x6b\xe6\xd0\xc4\x42\x5a\x30\x96\xf2\x72\x15\xce\x44\xb9\x68\x85\x44\xd8\x1a\x71\x39\xe1\xfe\x57\xeb\xf3\x9f\xd2\x7a\xb3\x43\x1d\x8c\x1d\x38\x20\x40\xac\xc9\x13\x00\xd3\x43\x17\xea\x05\x34\x91\x84\xb6\xe2\x9c\xf1\x15\x8a\x2e\x37\xa3\xc2\x55\x9b\x7b\x5f\xa7\x5c\xd1\x10\x80\x8f\x5f\x7d\x23\x21\x7c\x7a\x94\x28\x31\x32\xb8\x4f\x87\x8f\x9d\xaf\x04\xba\xb1\x64\xd9\x40\xfa\x43\x3f\xf9\x78\x37\xee\x0b\x4e\x2e\x3f\x79\x93\x6a\x76\x47\x43\xf4\xfd\x02\xe5\xd2\x8c\x8a\xb9\x22\x05\xfb\xca\x9a\x14\x59\xbc\x6c\x43\xaa\x60\xbd\x86\xc8\x32\xeb\x27\x25\x12\xc6\xf7\xec\x80\x62\x5b\x69\xdc\xab\x36\x87\x89\xe9\x68\x4c\x46\x92\x0a\xad\x19\x48\x4f\x5d\xbd\xfe\x84\x86\xde\xe7\xa3\x0d\x8d\x4d\x15\x9d\xe1\xee\x22\xdb\xdc\x55\xed\xd2\x31\x9f\x50\xe0\xd5\x0a\x0f\x5b\x10\xf2\x1e\xb9\x8d\x39\xaf\xb2\xa4\xc8\x13\x06\xfb\xfd\x96\xd2\xc2\x58\xac\x9d\x0d\x14\xb9\x7c\x55\xee\xaf\xb5\xea\xc3\x42\xd8\xf1\xb9\x1c\x89\xe9\x20\x53\x7e\x7a\x7c\x2e\xc2\x34\xfc\xd3\xef\x54\x50\xbe\x83\x7b\x2e\xf5\xa5\x62\x39\x8e\x70\xde\x79\xcc\x2d\xbe\x7e\x00\x5e\x7a\xac\xb3\x0a\xfa\x5c\xfa\xd6\x40\x15\x4a\xa8\xca\x58\x60\x6e\xee\x62\x10\x44\x57\x70\x6b\x0e\x39\x5f\x63\x2c\x1a\x3a\xb1\x32\xe3\x59\x61\x01\x11\x88\xca\x46\xce\xbc\xd2\xa6\xd7\xad\x14\x62\xd4\x31\xba\xfa\xf6\x44\x4c\x63\xf6\x61\xf5\x75\x22\xd2\x9d\x54\xe9\x54\x0c\x93\x37\x2b\x6f\x76\xfd\x04\x7a\xa0\x1f\xd3\x80\xc6\xa3\x0c\x3c\x8e\x6e\xcb\x73\x69\x44\x77\x1e\xd9\xa1\x2f\xb3\xc5\xa3\x07\xc3\xfa\x9b\xb1\xf0\xd5\x13\x33\x6d\x57\x2e\xc9\x7b\x32\x2b\x07\xd8\xa7\xac\xee\xcb\x74\x92\x17\x62\xf0\x80\x95\xc5\x4a\x9d\x82\x04\x96\x63\xd7\x0b\x04\x22\xea\xbd\xcb\x05\x39\x0b\xc5\xce\xc3\xe4\xca\x93\x19\x9b\xa2\xf3\x0b\xb9\xd3\x38\xe3\x6c\xc9\xad\x40\xb5\x9c\xd1\xa4\xcc\xa4\x25\xae\x3e\x69\xf0\xeb\x16\xfa\x8e\x05\xa7\x4f\x17\xe0\xf4\x01\x02\xc7\xc0\x81\xde\xd9\xdf\x14\xf6\x7e\x97\xd9\x7d\x24\xb9\xe8\xfa\x66\x7d\x65\xa6\xf3\xe7\x5d\xa6\xd4\xb7\x0e\xbb\xef\x39\x93\xa4\x39\x79\x32\xa9\x36\x57\x4c\xe2\xba\xff\xf8\xb7\x75\xe5\x53\x0b\x4d\x76\xfa\x89\xc6\xda\x71\xa1\xd2\x39\x74\xd9\x29\x69\x47\xd7\x89\xe3\xe8\x30\xa6\xce\xef\x87\x36\xf8\xf2\xa5\xa7\x47\x09\x2d\x30\x49\xe5\x00\x23\xc8\x17\x19\x75\xe0\xc9\x13\x31\x97\x8d\x7d\xc5\xad\x5b\x63\xb4\x02\xc1\x93\x7a\xa9\x94\xa1\x36\x12\x57\xc5\x81\x21\x2d\x70\x69\x3f\x16\x4b\xa1\xa4\xa4\x9c\x38\xfe\x27\x60\xb8\x50\x43\x72\x72\xbb\xf1\xec\x19\xd3\x13\xc7\xcf\x70\x5c\xfc\x8d\x9b\x42\x3b\xf9\x6b\x16\xc9\x03\x69\xfe\x85\x7e\x38\xd4\xdf\xaf\x49\x88\x87\x7b\x27\xd1\x44\x05\x89\xf1\x83\xd1\xf2\xca\xaa\xf1\x9c\x4a\xe0\x13\x22\x61\x6d\x40\x21\xaf\x42\x95\xb6\x53\xd2\x82\xb1\xb1\xfc\x20\x8f\x3f\x1f\x1f\x7b\xbe\xe3\x1d\x01\xe6\xc5\x82\x1a\x6b\x7d\xee\xa4\x4d\x71\xba\x57\x85\xc5\xce\x57\xde\x2c\x2f\xbf\xf5\x1b\xa0\x52\x2b\x4f\xd8\xec\x43\xfd\x5b\x12\xc6\xfc\x91\x59\x77\x33\x7c\x63\x7f\xf8\xcd\xc2\xfc\xe4\x6b\x3d\x7d\x0b\x51\xbe\xff\xb6\xdb\x63\x3b\x59\xa9\x34\xc0\xe5\xe2\x19\xfb\xf6\xce\xcc\x15\x87\x07\xfb\x65\x64\x36\x6e\xaa\x7f\x91\xed\x93\xfb\xda\xaf\x6c\x63\x60\xe3\xd7\x2c\xbd\xc9\xa9\xdf\xa4\x40\x15\x07\x0f\x37\x69\x4d\x8f\x91\x3d\x99\xcb\xe2\x47\x73\x9e\xad\x34\x67\x03\xea\xe7\x85\x25\xd6\x72\x47\x8e\x06\xa6\xdd\x70\xf4\x48\xea\xaa\x43\x1c\x03\x08\x35\x70\xbe\x23\xb3\x82\x53\x2f\xda\x9d\x2a\x91\xa6\xe4\x09\xcf\x93\x5d\x05\x36\xf2\x0f\x83\x1f\x1c\x7d\x17\xfc\x4e\xe0\x78\xfe\x9c\xbc\xed\xbb\xa1\xcb\xf7\xbd\xbc\x8d\x8b\xcb\x45\x72\xae\x50\x3f\x53\x72\xca\xee\x62\xb7\xfd\x8f\x4f\xd6\x1c\x7b\x16\x51\x80\xad\x70\x89\xc9\xd8\x68\x2a\x4c\xb5\xfe\xd4\x16\x0f\x62\xce\xfd\xef\x8e\xcc\xfc\x59\x0c\x53\xeb\x6e\xcb\x0d\x2f\xfb\x42\x5a\xfc\x3b\x0b\x7d\xd6\x6d\x7e\x39\x61\xb9\x34\xb2\x99\x1d\xac\xa2\x2d\xc2\x68\xac\x5b\x87\x0b\xb2\xd7\xf4\xe9\xcd\x8e\x1f\xcf\xad\x96\x4a\x24\xc5\x31\xb3\x05\x98\x00\x4e\xc7\x26\xcd\x7c\x27\xbb\x63\xc7\xe4\xac\xa5\x2f\xca\xba\xe9\xe7\xfc\x26\xe1\xa7\xa5\xb3\x2c\xa7\x1a\xb9\x2f\x9e\x39\x34\xec\x9d\x0a\xe2\xb3\x67\x87\x91\x29\x19\x5e\x44\x06\x14\x82\x0e\x08\xc7\x2f\xad\x15\x50\x22\xb8\xdc\x88\x45\x64\xd3\xbd\x0b\x1f\x26\x1d\x08\x53\x23\x96\xd5\x02\x70\x4b\xa0\xc8\xef\x80\x44\x1e\x98\xdb\x01\x44\xfc\xa4\x0a\xfb\xc8\x9a\x0b\xfc\xf0\xea\x1a\x4d\x88\x39\x42\xd6\xc5\x34\x47\xe1\x1e\xf3\x65\x40\xf1\x66\x8e\x7e\xde\xbb\x3b\x03\x61\x7e\xb7\x57\x4f\x6b\x0a\xd7\x43\x4c\x01\xe8\xf1\x8e\x20\x54\x86\xe7\x95\x7c\xa0\x3b\x96\xdd\x76\xe8\x29\xe2\x90\xb3\x61\x48\x16\x92\xb7\x0c\x96\xc0\xb9\xf0\x7a\xae\x3d\x6c\x79\x4e\xfa\x14\xa2\x53\x5e\xfa\xeb\x06\xdf\x78\x47\x87\xe9\xaf\x30\x18\xaa\x05\x66\xdf\xc6\x78\x21\x65\xb8\x03\xc6\xb8\x2e\x9a\x39\x95\xa6\xc0\xe2\x5c\x28\x0a\x07\xff\x28\x6e\x6f\x41\x69\x4f\xf9\x40\x75\x74\x3a\x29\x93\x53\xd8\x50\xd6\x55\x36\xbf\x26\x2a\xbd\xdf\xf6\x42\xf2\x76\xf5\xdd\xed\x70\x0c\x46\x7e\xb3\x5b\xc5\xc3\xc1\x1a\xba\xa3\x40\x0e\x8b\x08\x87\xe1\x1c\x5d\x1c\xdc\xcf\xed\x4a\x81\x15\x18\x98\x61\x30\xc8\xc8\x64\x54\xa5\x78\xcd\x8a\x5a\xad\xd0\xa1\x0b\x8d\x98\xe4\x71\x1c\x30\x2e\x8e\x57\x32\x76\xe1\xcd\xf7\xc2\x31\x68\x64\x8d\x2d\x43\x5a\xf1\xa4\xbf\x56\xd5\x41\x40\xb5\x47\x84\xc3\xb1\x7c\x67\x3b\xee\xe5\x3d\x19\x45\xd6\x18\x34\xca\x27\x4b\x3c\xfc\x40\xad\xba\x7c\x08\x8b\x98\x34\x5e\x80\x71\x09\x7c\xe5\x5c\xe5\x7f\xfb\x86\x56\x15\x1f\xe2\xed\x1b\x9f\x31\x70\xa0\x0f\x25\x5b\xc6\x23\x53\xd4\xef\xe0\x23\xec\x46\xe9\x8b\xfa\xe2\xf7\xcf\xd8\x23\xb2\xa8\x2d\xa6\x43\xa4\x49\xf1\xda\xcc\xed\xcc\xa5\xbe\x2b\x5c\x16\x29\x2c\xed\x57\x79\x79\xf2\x3a\x23\xec\xdf\x73\xed\xf7\x51\xa5\xbc\xa8\x98\xe5\x50\x5e\x3c\xf1\xf2\xdf\x45\xfe\x2f\xeb\x50\x98\x9e\xac\x94\x4e\x79\x87\x84\xba\xf3\x88\xff\xdf\x9e\x92\x3f\x29\x81\xe8\x65\xc0\xfd\x53\xfd\x92\x7f\x62\x3a\x09\x6a\x1e\x77\xa5\x6e\x61\xa6\x8d\xd2\xee\x5c\xb8\x54\xc7\xf7\x5d\x6e\x3e\x2c\xb2\xe6\x4a\x7a\xa3\xbb\x8d\x46\x20\x22\xe7\xa9\xbc\xa2\xc6\xb9\x30\x2d\xbc\xc9\xe1\x68\x8b\x00\x87\x96\xfa\xcb\x71\xf3\xb4\xb3\x28\x42\x3f\xd6\xe9\xe6\x5a\x08\x7b\x29\xb2\xb1\xcb\x36\x7b\xb3\x6f\xab\x8d\x9b\xdd\x94\xee\x98\xda\x32\x57\x43\xc1\x06\xdd\x74\xcb\x8b\x82\xdd\x67\x82\x35\xf3\x54\x38\xbe\xc3\xf6\x8e\xb0\xbe\x2c\x2b\x4f\xcd\x65\x30\x1b\x48\x55\xe0\xdc\xba\x07\xb7\x76\x52\x72\x41\xd6\x44\x8f\x0d\x99\xa7\x36\x91\x86\x12\xdb\xc5\x99\xa9\xff\x21\x16\xe8\x02\x04\x86\x44\x29\x6e\x3a\xa9\x9f\x6e\x63\x09\xa5\x61\x8b\xea\xb5\x3d\x32\xb6\xdd\xab\xef\xea\x1d\x77\x73\x39\xf4\x4f\xdd\x59\xd8\x56\x40\x5e\x8d\xe3\x58\x49\xfb\x03\x7b\x2b\x8b\x12\xea\xfb\x0b\xd5\x23\x96\xe7\x62\x9f\xae\x9e\x89\xed\xb7\xaa\x57\xf5\x16\x1b\xa0\x79\x15\x2b\x02\x40\x25\x0d\xb1\xaa\x30\x2e\xb9\x7b\xba\x27\x7e\x7b\x64\x84\x7a\xd2\x72\xed\xd3\x2f\x11\xdd\xdb\x8e\x6c\xf3\x7f\x9e\xbf\xe5\x9d\x4c\x8d\xfe\x18\x2a\x62\xdb\xd9\x64\xd2\x5f\x07\xbd\xbf\xa0\x12\x9c\x0e\x45\x63\xbd\x66\xff\xd7\xee\xe1\x15\x61\x93\x22\xc3\x73\xd8\xb5\xe2\x2d\x09\xfb\x9d\x76\x05\x14\xe7\x24\x95\x0e\x39\x35\x86\x5d\xdc\x26\x2c\xa7\xcc\x8b\xdf\x50\x17\xac\xcb\x4c\xae\x59\xe1\xdf\x24\x38\xf0\xc0\xa0\x3e\xf6\xd2\x0f\xd1\x3d\xf8\xc2\x5b\xc7\xd6\x77\xdc\x3c\x06\x2a\x09\x43\x18\x7e\xce\x24\x02\x5c\x98\xa5\x9e\x59\xc9\x59\x37\xff\x9b\x57\x24\x59\xe1\x93\x7f\xb1\xac\x5e\x90\x9c\x71\xe2\x46\x25\x45\x85\xd6\xd9\xd7\x41\xd3\x14\x57\x13\xb2\x51\xa9\x14\x37\xca\x7b\xd5\xf0\xe8\xad\xd1\x45\x48\x32\x87\x43\x06\xe6\x29\x43\xda\x1b\x8e\x75\xcd\x94\xbc\xe7\xfa\x12\x2e\x77\x39\x41\xc5\x59\x14\xc8\x93\x92\x4b\x9a\xb1\x12\xd6\xff\x81\x9c\xb8\x63\xea\xeb\x99\xeb\xc9\xe7\xe5\x64\x0a\xd1\x49\xcc\xa3\x97\x3c\xe5\x1b\x0c\xf1\x8e\xd7\xe3\x1d\x77\x82\x94\x1a\x54\x50\x4e\xe5\x90\xfd\x08\x77\x62\xb2\x8f\xbb\xd4\xa1\xbc\xa2\xb2\x22\x7e\x48\xa7\xd0\x36\xc8\x36\xca\x5f\x02\x10\xde\x30\x77\x6e\x44\x4b\x41\x41\x4e\x8e\x91\xde\x65\x39\xb8\xbe\xce\xd2\x18\xa9\xd3\x69\x46\x56\x67\x04\xb4\x3f\xfc\xf8\xac\x0f\xc2\x23\xc0\xd1\xde\x7c\x9f\xcf\xe7\xda\xe0\xd6\xbc\x5e\x0e\x32\xa5\x7c\x88\xc5\x9a\x7b\xe8\x84\x41\x26\xf0\x58\x10\x84\x7c\xb4\xe3\xac\x5b\x51\x68\x59\x88\x5e\xa1\x90\xcb\x6f\x47\x7c\xbe\x9d\xe1\x23\x57\x2a\x83\x8a\x66\x65\x60\x2d\xc6\xde\xa3\xac\x5c\x06\x07\x16\x00\x85\x36\xc6\x69\xf5\x85\xcb\xba\xaf\x2e\x74\x75\x2f\x5e\xed\xb2\xd1\x1e\x79\xfc\xf9\xe0\xb5\x6b\x41\xa8\x94\xf5\xed\xc9\x05\x02\x1e\x9f\xaf\x2f\xe1\xcb\x99\x82\xd4\x35\x99\xec\x6e\xd1\x6e\xd7\x9e\x7a\xd7\x5d\x31\xe7\xda\xda\x5a\x5b\xcf\x9d\x6f\x6d\x15\x56\x39\x35\x0f\xcb\x85\x08\x5f\xe1\x36\xe3\x9c\x09\x65\x5e\xe5\x5e\xc1\xcf\x21\x4d\xe5\xea\x1b\x19\x06\xcd\x4d\xb1\xfd\xe9\x48\xa1\x08\xd1\x87\x56\x78\x5d\x6d\x24\xef\xda\xd5\x8f\x91\x4b\x4a\x4d\xcf\x0f\x34\x46\x2d\xab\x97\x18\x6f\x51\xeb\x43\x1b\x9d\xaa\xb6\xda\x32\xd1\xc7\xed\xb3\x06\xba\x33\x71\x2f\x83\x54\x9f\x5d\xbd\x29\xf1\x1d\x16\x3c\x36\x2e\x6a\x78\x6f\xbf\x2f\x7c\x43\x41\x5e\xa6\x5b\x63\x42\xea\x32\xa9\xe3\x7c\x41\x09\xb9\x7b\x6f\x7f\xd0\x31\xad\x95\x4b\x7b\xf1\x06\x32\x41\x15\x60\x4f\xad\xf1\x0c\x1b\x46\x38\xbb\xc2\x3b\xa7\xd5\x27\x20\xbe\x8b\x39\x12\x04\x12\xc6\x80\x40\x62\x52\xc3\x5d\xee\x94\xa3\xca\xb7\xd1\x71\x2c\x56\xda\x6f\x17\x9f\x3c\x2a\xf0\x92\xfa\xf8\x6c\xbd\x11\x5e\x94\xdc\xab\xb5\x18\x51\x63\x54\xa4\x8a\x5f\x14\x91\x14\x35\x3f\x24\xb3\x55\xd8\x10\x30\x5f\x39\xd7\x8a\x20\x66\xc9\xd1\x29\x16\xfc\x03\x1c\x86\x12\x43\xc2\xc5\x05\xd7\xa5\x95\xb4\x29\xa7\x8c\x0b\xf3\xd7\x99\xe8\x84\x50\xa6\x5b\x22\x71\x2c\x36\x99\x17\xc6\x0a\x16\xba\xa8\xdd\x3c\x73\x1e\x5a\x8d\x6d\x4e\x76\x2e\x0d\x83\xb2\x81\x2e\x27\xa0\xeb\xba\x0d\x1f\xd4\x9c\x96\x11\xb9\xdf\xd5\xfc\x7d\x39\x89\xb5\x50\xcc\x82\xbc\x24\x0d\xfc\xb9\xc8\x68\x3f\xfa\xf7\xea\xcb\x83\x1b\x32\x3d\xf7\xf3\x82\x2b\x0b\x2e\xc5\x23\x47\x3d\x77\x4f\x93\x99\x1c\x47\x3e\x84\x23\xcc\x61\xc8\x00\xe6\xea\x9b\x00\x63\x64\x24\xa0\x5c\x1e\xc7\xd9\x80\x87\xee\x9d\xf8\xb5\xef\xdd\xbb\xfa\x8a\xe1\x67\xe3\xb5\x79\xb4\x5a\xba\x67\x8b\xeb\x76\x8c\x62\x9f\xbc\xf7\xd4\xb7\x61\x7a\x02\x38\x16\xa9\x7b\xc8\x9b\x7d\x0e\x42\x68\xd2\x41\xb7\x7b\x6d\x44\x03\xfe\x86\xae\x85\x85\x2e\x83\x1c\xf4\x27\x2a\x4b\xb8\xdb\x4f\x1b\x69\x6b\x3b\xa2\x9d\x44\x20\x96\x23\x99\x13\x81\x80\x9d\x1c\xae\x2f\x00\x68\x90\x86\x90\xba\x3b\x93\x40\x1a\xff\xe0\xc2\xb1\x0d\x21\xf4\xdb\x2b\xff\xda\xab\x0e\xcc\x2d\xb2\x16\x63\x9c\x6b\x6e\x2e\xfa\xcb\xef\x76\x19\x96\x24\x3f\x3a\x8b\xef\x89\xa6\x81\xef\xdc\x97\xdf\xc5\xc0\xfe\x62\xc7\x7b\xdf\x13\xcd\x61\x7a\x03\xc0\x4b\xc0\xc3\xea\xde\xa3\x64\x99\x47\x6b\x79\x56\xd6\xb6\xbc\xc1\x85\xa7\x5a\xf9\xaf\xcd\xa5\x3a\xb7\xcc\x27\x5a\x8e\x15\x73\x67\x9b\x2e\x02\xbb\x01\x4f\x5c\x17\x2f\x2b\xdf\x69\xfb\x2e\x84\xa5\x35\x6a\xca\x3e\x28\xa1\x8e\x0b\x3d\x82\xff\x3e\xf2\x08\xcb\x76\x1e\x0a\xdb\xf4\x77\x3d\x37\x5c\x83\x34\xbe\x1f\xd9\xe0\xdf\x88\x79\xf1\xfa\x7e\x29\xd8\xc9\x71\x19\x4e\x4b\x01\x02\x17\x02\x73\xa9\x73\x7e\xf2\x39\x7f\x3c\xa2\xd8\x0b\x6b\x0d\x9c\xe0\xb7\x7b\x64\x01\x86\xa6\xdf\xd6\x6f\xf9\xc3\x9e\x3b\x9f\xb5\xc7\x5a\xe8\x8d\x84\xb0\x04\xe6\x41\xc4\x52\x89\x34\xa7\x76\x72\xc3\xad\x4d\xcd\x81\x96\xd1\xb2\xf9\x12\xca\x80\x9e\x97\x8b\x26\xf2\x5f\x3e\xb5\x70\x3c\x61\x5c\x26\x10\xdd\x52\x16\xf3\x5f\x71\x9f\xbf\xcd\x6f\x0d\x40\x58\x22\x50\x5d\x54\x55\xde\x30\x79\xbf\xe8\xbe\x76\x19\xe0\x76\xb4\x0b\x77\xd6\xea\xfd\xa5\x74\xca\x5d\xe5\x55\xd5\x97\x16\xed\x69\xdf\x0b\x87\x3c\x15\x43\xd3\xe2\xf1\x69\xae\x78\x3d\x63\x31\x76\x37\x39\x8a\x28\x66\xf9\x0a\xec\x4d\xea\x6b\xf3\xda\x84\x3a\x93\x27\xda\xaa\x0a\xbb\x49\xea\x8a\x0c\x95\x06\xf7\x60\x7c\x79\xce\x08\x39\x44\xed\xbc\xa6\xf1\x35\x92\x6e\x8e\xf0\x55\x0e\x3a\xba\x43\x2b\x2f\x3e\x39\x55\xc7\x46\x28\x23\x65\x49\x94\x7c\x95\x4b\x21\xba\xda\xe1\xd0\x92\x93\x6c\x30\xa8\xa4\x33\x36\xb1\xd9\x6e\xc7\x4c\x47\x97\x65\x2a\x36\x4e\x65\x0d\x2f\xcb\x8c\x1a\xed\xd4\x8e\xd7\xc5\xaa\x6a\x6a\xd5\x9a\xe3\x77\xfa\xb4\xad\xf3\x65\xf5\xc5\x37\x72\x7c\xd1\x82\x90\xe0\x84\x94\xe4\xd6\x94\x94\xd6\xe4\xe4\x04\x99\xa8\xe8\xae\x9e\xec\xdd\x0d\x83\x41\xea\x9a\x5a\xcd\x53\xaa\x43\x72\x0a\xd6\x94\x42\xe3\x49\x9b\xb2\x6e\x74\x87\xda\xd6\x7e\xb5\x2d\xcd\x23\x5a\xe3\x56\xbb\x7f\xbb\xda\xc8\x76\xfa\xd6\x1d\x1b\x4c\xb2\xac\x42\x01\x1b\x72\xf9\xa7\x22\x39\xc5\x97\x35\x9e\xd8\xc3\x39\xe0\x1e\x80\x38\x56\x06\xbe\xea\xb8\x78\xac\x07\x68\xea\x5f\x64\x5e\xcb\x3a\x93\x7c\x78\x6d\x57\x01\x28\x9f\xb7\x7e\xab\xdf\x0d\xfa\x4d\xea\x79\x81\x2b\xa5\x29\x23\x12\x25\xca\x82\xb5\x99\x1f\x75\xfd\xaa\x85\x9d\x82\x7e\xde\xaf\xbe\x16\xfb\x87\xd1\x89\x8b\x2a\xb7\xf4\xa4\xb7\xc5\x4b\x13\xa3\x94\x58\x8e\x83\xaf\xef\x3c\xf8\xcf\xd1\x67\xab\xfb\x37\x00\x7c\x60\x10\x80\xcd\xda\xd6\x7a\x12\xb0\xc6\x48\x30\x95\x1c\xb4\xcf\x69\x6b\x59\x98\x3d\x32\xc7\x16\x16\xe4\xe1\xef\xfb\xe5\x6e\x0d\x5f\xfb\xd7\x75\xff\x58\xbf\xfe\x47\x57\x56\xd2\xb9\x8e\x8e\xb3\x81\x59\x5d\x2f\x4b\x3c\x4a\xee\x54\x64\x6e\x16\x9d\xb8\xb8\x59\xb3\xed\xe6\xf5\x4a\x4d\x36\x40\xe0\xe7\x72\xdd\x8d\x9c\x1b\xf3\x4e\xfb\x62\x6a\xbe\xef\xd3\x44\x1d\x38\xb5\x7c\x20\xcd\xc2\x27\xe4\x2b\x5e\x0e\xb7\x6a\x8d\x8b\x74\x7d\x8c\xf3\x07\xfb\xce\x81\xb4\x62\x46\x41\x47\xc4\x8a\x90\xa4\xbd\xcc\x83\xf9\xe9\xa2\x2f\xaf\x9d\x63\x96\x44\xa7\x3b\x27\x66\xb4\x7b\x73\x88\x29\x79\xb1\xc0\x18\x27\xfa\x09\xf9\x4b\x31\x37\xb4\xfa\x93\x45\xe5\xd3\x6d\xfa\xe8\x98\xb7\xd2\x94\xd3\x7f\x1b\x6b\xe1\x3c\x23\xfa\x04\xeb\xfd\xaf\xe1\xea\xa8\x8f\x53\xd4\xf8\x49\xb8\xc0\x56\x90\x3a\xe0\x09\xc7\x65\xf0\xf8\x1b\x38\x1e\x5a\x99\x28\x74\x20\x69\xbb\xf7\x40\x3e\x06\xf6\x38\x5b\x84\xe6\xc0\xeb\x34\x58\x4c\xef\xfd\xf0\xfb\x87\x7b\xa2\xc0\x4a\x2e\xfe\x17\xca\x14\x2e\x0a\x35\x7c\x45\xbc\xcf\x5e\x5d\x73\xd2\x9d\x63\x9d\x43\x11\x7e\xe9\xe1\x1b\x07\xd8\x12\x4c\x40\xfe\x21\x3d\xe1\x49\xa5\x14\x17\x75\x7f\x7a\xea\x6d\x0e\x9a\xca\x90\x5e\xbd\xdb\x49\x55\x3a\x94\x10\x80\xe9\x98\x6c\xd1\x63\x50\x25\x00\xdb\x37\xf0\xec\xad\xcd\xb6\xed\x4e\x3e\xb5\xd9\xb6\x6d\x6f\x9b\x6b\xdb\x6c\x9b\x9b\x6d\xdb\xd6\xc9\x6e\x33\x4e\xb6\x7b\xe7\x79\xef\x79\x66\x9e\x0f\xf7\xef\xeb\x35\x73\xe9\x6f\xfe\x15\x33\xb8\x15\x8d\x61\x82\x0a\x34\xe1\xb0\x86\x62\x8d\xaf\x1b\xb2\xb9\xf4\x1a\x16\x58\x5d\x71\x84\x53\xe9\x88\x78\x3e\x76\x22\x5b\xbd\x8a\x4f\xa2\x8b\xfa\x0c\x7c\x01\x11\xd2\x20\xe7\x09\x69\x0b\x30\xaf\x01\xe3\x7e\xd9\x89\x4d\xd0\xbf\xe7\xe5\x20\x13\x5a\x3a\xf0\xad\x6d\xce\xe7\x49\xdc\xa5\x9c\x5b\x1a\x12\x13\x14\x5c\x87\x30\x2b\xac\xa4\xca\x4e\x1e\x0b\x5d\x72\x39\x31\xb9\xa4\x4d\x26\xfe\xb5\x31\x0c\xd4\xd6\xb7\xd7\xde\x6e\xdc\xdc\x48\x0a\x4d\x48\x4b\x43\xf3\x61\xe6\x0f\xa8\xc9\x69\x38\x1c\x7c\xbb\xf8\x38\xd6\xf4\xc1\xda\x43\x5b\x07\x02\x1f\x68\x36\x51\xef\x18\x8c\x6c\x9e\xaf\x6b\x13\x0d\x0a\x86\x0b\x44\x5a\xe3\xfb\xf7\xd5\xfd\xd1\x37\xf9\xf0\x7d\xa6\xce\x89\x35\x9a\x9c\xab\xdf\x15\x3e\xd6\xb4\x89\x57\xe2\xff\xc2\xda\xbe\x0e\x8d\xab\x9d\x66\x95\x6b\xf1\xf3\x5f\x81\x44\x34\xb1\x92\x34\xd7\x7a\x6a\x2b\x84\x98\xbb\xbb\xfd\x8c\x2c\xde\xb2\xf6\xbd\x50\xa1\x7d\x22\x87\x62\x73\x0c\x7b\xad\x48\x16\x6d\x2c\x8f\xad\x4f\x6c\x0b\x5c\xd1\x52\x17\x6b\x50\x72\x6e\x57\xd8\xe8\x22\x46\x3d\xb0\xf8\xd8\x1a\x63\x8b\x7c\x8e\xd4\x97\x99\x94\xd4\x77\x05\xfd\xbf\x45\x46\x8e\xa1\xa0\x63\xc4\x0a\xcf\xb6\x6a\xe3\x69\x6a\x63\xcf\xe1\xe6\xe0\xd5\xf1\x76\x35\x1a\xfe\x9c\xa9\xa8\xba\xe9\xca\x18\x62\xad\x4e\x2f\x2a\x0d\xf5\x42\x6a\x95\x24\xa1\xe9\x4b\xa0\xd2\x95\x1f\xba\x80\x2e\x3a\x18\x8b\x23\x17\x47\xd8\x3b\x1a\x81\x9f\x90\x76\x9c\x0c\xe2\xdd\x75\xa8\x1f\x27\xc1\x68\x5d\x3e\x91\xef\x88\x7f\x69\xe5\x8f\x33\xbf\x90\x85\xa1\xad\x20\x87\x33\xd3\x07\x2e\x08\x8e\xb4\xf8\x0d\x11\xf5\xc6\x8a\xf8\xed\xee\x10\xcf\x40\x6c\x8f\xaf\xcf\x1c\x81\xb6\x02\x91\x28\xa0\x68\x77\x7d\x7d\x27\x39\x5e\x8c\xfc\xea\x9e\xb5\x10\x39\xf9\xd3\x0f\xc0\xe5\xf0\xf9\x7e\x3c\xf4\xda\x4d\x2c\x6d\xa7\x7f\xc2\xd3\x64\x92\xa0\xf2\x2a\x2d\xa2\x1d\xe0\x86\xb3\xa6\x21\xf4\xe6\xf8\xb7\x73\x70\x5b\x8f\x5c\xc3\x1d\xaa\xa2\xe5\x29\xad\xcd\xc9\xd2\x53\xcd\x0c\x9d\x8a\x7f\xa3\x97\x40\xe4\x0b\x80\x78\x76\xfb\x76\x23\x4d\x16\x9f\xc9\x1d\xaa\x9e\xf0\x9a\x17\xe4\xd7\xd5\x22\x42\x88\xf7\x91\x84\x53\x1d\x87\x26\x14\x99\x3b\x8e\xae\x21\x6c\x69\x37\xf9\xf0\x7e\x28\xbf\xfc\xd8\xd9\xa1\x00\x2c\x51\x13\x51\x94\x4c\xcd\xca\xe6\x09\xde\x47\x25\xed\xa2\xc2\x62\xe9\x96\xd6\xee\xd0\x47\x23\xf9\x95\xc2\xfd\x40\xdc\xd3\x83\x54\xfb\x08\x8e\x7c\xb9\xb7\x5a\x4c\x32\xa7\x0e\x4c\x28\x24\x02\x7c\x5b\x53\x6a\x40\x56\xc8\xff\x8e\xe5\x60\x79\x93\xa5\x1b\x63\xae\x02\xec\xbf\x2d\xe5\xb5\x4b\xce\x9d\x3b\xfe\x56\xd7\xc8\xab\xb9\xf7\x9b\x60\xce\x56\xab\xb3\xd3\xc7\x7b\x1d\x02\x29\x89\x9b\xb0\xdd\x7b\x29\x38\x21\xf9\xe6\x2b\xc0\xd2\x92\x83\x1c\x2d\xc8\xe0\x4e\x76\x18\x0f\xd0\xf1\x9e\x76\x71\xc8\x39\xb2\x03\x09\x25\x36\x12\xc2\xa1\x0c\xdf\x7a\x75\xbf\xcc\x54\xa6\xe0\x11\x1e\x37\xda\x9e\xb7\xb2\xcc\x40\x5f\x5e\xce\x2d\xbd\x7a\xfa\x72\x87\x97\xdf\x47\x0d\x49\xe6\xf6\x87\x6f\x3e\xee\xe7\xa5\xcc\x8d\x3a\xb2\xf4\xd1\x38\x2d\x2c\x42\x04\xaa\x3f\x51\x21\x9c\x8d\x59\xd8\x96\x1c\x24\xce\x06\x11\x45\x87\xbf\x76\x1d\x58\xc8\x5f\x4e\x3a\xdf\xf0\x94\x5c\xe9\x1d\x02\x06\xdf\x85\xe6\x13\xe9\x80\x22\x92\xc0\xb0\xe6\xf9\x36\x40\x8d\xcf\x8c\xc1\xde\xf8\xe7\xf8\x59\x20\x3b\x47\x07\xc7\x84\x4a\x88\x39\xce\x0b\x8a\x08\x41\x5f\xef\x9a\x2e\xfb\x9c\x62\xea\x57\xa1\x1e\x12\xff\x67\x59\x7c\x95\xb4\x7e\xff\xd4\xcf\xcd\xd0\x39\xa8\x7d\x82\x93\x20\x31\x8b\x34\xb5\x2a\xb5\x6b\x55\x5f\x71\x9c\x49\x54\xec\xbd\x78\x6d\x09\x31\x2f\xf3\xd3\x20\x6b\xe7\x5d\x3e\x11\x38\x08\x41\xba\x17\xc6\x97\xbb\x9d\xe7\xad\x31\xaa\xa9\x0c\xae\x92\xbe\x61\x01\x16\x7c\x3e\x70\x74\x14\x3d\x77\xc6\x93\x79\xa9\x05\x7e\xb1\xdb\x4a\xab\x37\x15\x64\x6f\xc3\xce\xa7\x46\xd6\x8a\x25\xe9\xd9\xd6\xdc\xbc\x4f\xc0\xe7\xa1\x20\xcd\xd6\x2f\x84\x79\xaa\x64\x84\x82\x53\xd3\x5b\x7a\xb9\xde\x40\x64\xad\xbb\x88\x03\xf5\xaf\xfa\xa9\xdb\x1d\x0c\x0c\xd5\x0e\x5e\x9d\x7e\xdb\xa4\xe2\x17\xda\xf2\x2e\x60\x80\x9c\xa1\x94\x56\xe0\xaa\x4f\xba\x13\x2a\x35\xef\xe5\x5d\xf4\xcb\x92\xb9\x47\x33\x7c\x61\xc3\x60\x40\xf3\xb4\x2c\x18\x1e\xce\x6a\x53\xe1\xdd\x1b\x91\x93\x25\x3b\x12\xa0\x36\xad\xf7\x61\x58\xe6\x18\x06\xec\x5f\x2c\x84\x9e\x83\x8c\xb4\xef\xd9\x9e\x16\xe3\xcb\xd7\x36\xef\xc5\x9c\x17\x03\x12\xc1\x24\x4e\x72\xfb\xb0\x3e\x0e\x5c\xa4\x4c\x9d\xfb\xb0\x5e\x6e\x2c\xf9\x0c\x90\x0d\xe2\x70\x88\xfb\x88\x7f\x73\x3f\xf6\x70\x8a\x3e\xad\x1d\x3e\xfb\x9a\x2a\x45\xfb\x47\xf8\x27\xfe\xdb\x7d\xe0\x7b\x80\x18\x91\x6d\x96\x59\x28\x38\xf9\x65\x55\x7d\x93\x72\x2c\x13\x65\x03\x13\xae\xbb\x06\xec\xc5\x28\x9f\x70\x27\xe2\xc1\x3e\x76\xfd\x71\x0a\x7a\xc8\x31\xeb\x13\x99\x35\xd8\x3a\x05\x9e\x17\xfb\x7e\xe6\x0c\xca\xa1\x3c\x46\xf1\xd5\x06\x99\x4f\x69\xd7\x07\x45\x6c\x6c\x58\x30\xb9\x46\x3f\x75\x00\xb8\xb9\x43\x8e\x67\xc1\x5d\x5d\x73\x6b\xf1\xe9\xa0\x15\x7d\x7d\x6e\xd1\xc6\x45\x30\xe2\x36\x20\x12\x31\x50\xef\x6e\xfa\xc7\xa7\x7f\x5b\x73\x3f\xc8\xf4\x14\x36\xc6\x8d\x68\xd6\xd0\xe3\x45\x82\x84\xde\xd8\x4d\xc9\x15\x14\x47\x6f\xb1\x5d\x02\x6b\x2f\xa6\xbb\x29\x22\x67\xf5\x59\x9f\xbb\x93\x93\xd3\xeb\x1d\x7b\xc4\xea\x60\x53\xaf\x40\x4f\xd8\xe1\x8b\x2f\x8e\xbe\xa3\x9a\x03\xea\x4d\xaa\x15\x2a\x2e\x9b\x60\x3d\x47\x7d\xf7\xed\x80\x19\x75\xf6\xd6\x2a\x52\x16\x13\xec\x7f\xf7\x5c\x73\x27\x15\xa2\xe3\x4b\xc5\x71\xe0\x75\x58\x8d\x6c\x65\x96\xd7\xaa\xa9\x63\x71\xe4\xaf\xd7\xf5\xf3\x38\xca\xc9\xe7\xe9\x40\xf2\xf8\xf7\x87\x8a\x22\x07\x76\x4d\x89\xbb\xe4\xfa\x67\x38\xf7\x57\xcf\x69\x74\xdf\xa1\xe2\x72\xe0\xbd\x00\xcd\x54\xc1\x45\x31\x34\x19\xad\xaf\x21\xdb\xce\xfb\x19\xca\xd2\x83\x6a\x25\xcb\xad\x3a\x9d\x2f\x95\xf3\x9f\x97\xb1\x86\x2c\xbc\xd2\x49\xf2\x9e\x10\x05\xfe\xbe\x6f\x3f\x9d\xd4\x87\x4a\xe4\x3e\x33\x92\x15\xa4\x69\xff\xcc\x13\x27\x75\xa4\x9c\x2a\x45\x46\xf9\x72\x34\xf3\x28\xd6\x72\x5f\x45\xd8\x91\xb1\xcb\x32\xaf\xb1\xa3\x9f\xe9\xe8\xb8\x3d\x74\x10\x6b\xda\x68\x6c\xf0\x3a\xe1\xbd\xc0\x0c\x58\xea\x38\x8f\xbb\x11\xd6\x31\xa4\xd8\x23\x8e\xb3\x2e\x4b\xfc\x72\xe3\x90\xad\xd8\x63\xfd\x0d\x24\xf6\xad\x6b\x1d\x6e\x0b\x92\x2c\x32\x65\x06\x69\x8a\x9a\x49\x5e\x81\xf9\x0b\x16\xfb\xa7\xec\xcf\xec\xa7\xaf\x7c\x8e\xeb\x3b\x31\xdf\xb0\x59\xe4\xee\x5f\x7a\x14\xe8\xf0\x78\x14\x74\x70\xb5\x7a\x97\x98\x38\x3b\x48\x2a\x3d\x50\xd2\xd2\xd2\x24\xcc\x06\xca\xf1\x55\x72\x76\xfb\xa3\xce\x09\x05\x91\x12\xca\x57\xc5\xd4\x81\x3b\xf6\xef\x00\x0d\xdd\x96\x1d\xa2\xa7\xea\x48\x06\x10\xc1\x94\x0f\x8c\x44\xcc\xad\x8d\xb3\x98\x7a\x13\x57\x8f\x19\xbd\xe5\x1a\x1d\x3b\x2b\xdc\x23\x82\x2e\x3a\xd3\x8d\x52\x7e\xc1\x77\x26\xe4\xae\x31\xf5\x4c\x0b\x89\xe5\xb7\x11\x1c\xb1\x94\xd7\x39\xbb\xd5\x54\x0c\xa2\xa7\x69\x0c\xb9\x77\xa6\x1b\x54\x39\x69\xfe\x52\x9a\xb1\x6b\x4a\x42\xe9\xa7\x7a\x88\x53\x71\x6e\x07\x57\xe9\xda\x9b\xfe\x7d\x20\x67\xbd\xca\x8e\x24\x45\x75\x6f\x97\xf8\xc2\x5c\x44\x5c\xd1\x00\xcf\xea\x4d\xe4\x70\xab\xf2\xac\x70\xdb\xce\x1e\x22\x79\x17\xb6\x86\x4b\xa8\xfb\x2d\xcb\xd5\x96\xe5\xa6\xd9\xb1\xe1\x41\xd3\xcf\xad\xab\xbe\xdf\xda\x55\xfa\xba\xba\xfb\xb2\x8d\x75\x7c\x10\x9a\x06\xd5\x73\xf5\x6b\xe1\x8c\x68\xbe\x77\x96\x57\x07\x2e\x81\x4c\x43\xc7\xf3\x71\x37\x87\xa2\x35\x46\xac\x87\xc1\xe9\x87\x74\x94\x60\x32\xfe\xe4\x99\xa4\x88\x14\xbb\xdf\x2a\x9b\x8e\xb3\x93\xfe\x62\x7f\x91\x32\xb2\xb2\x32\x71\x04\x6b\x67\x1b\x15\x9e\x2c\x63\x02\xc7\x8b\x4b\xa8\x60\x04\x05\x30\x43\x0e\xc1\xc9\xa8\x16\x71\x05\x07\x33\xeb\x45\xec\x78\xc4\xd4\x11\x11\x36\x93\x77\x20\x09\x0d\x54\xab\x1b\x17\x06\x81\xbb\x38\xd5\xa3\x23\x76\x21\xed\xd8\x41\x6b\x2d\xe3\x30\x4d\x8d\x55\x57\x40\xeb\xd5\x0c\x8b\x0e\x06\xc5\x8c\xcb\x53\x09\x94\xd7\xb4\x56\x23\x5d\x1e\xb4\x42\xd5\x25\x4d\xde\xa7\x4b\xd3\xe7\x6c\xf8\x53\x1a\xbc\xe9\x6d\xcf\x27\x36\xfd\x97\x19\xda\xef\x96\xdb\xe5\x25\x51\x47\xdb\x6d\x99\x0d\x2d\x2e\xaf\x62\x82\x8c\x9f\xf0\xf3\x39\x2b\xec\x65\xeb\xe7\x2a\x13\x38\x50\x9b\x41\x91\x01\xe7\xb6\x8f\x88\x3c\xd0\x93\x44\xd1\x4f\x5a\xe4\xd6\x97\xe6\x00\x5c\x5c\xc0\x6d\x14\x85\x62\x5b\x57\xed\x64\xd3\xf3\x7d\x2c\xff\xa5\xd8\x8d\x82\x3e\xc4\xcf\xe0\x4e\x1b\x76\xd7\xfa\x32\x3d\x12\xe0\x5c\x90\xd3\x94\xcf\x7e\x8c\xba\x84\x77\xb7\x6b\x03\xe2\x3e\x4f\x25\xee\xbe\x1d\x50\xb7\xe3\xbd\x4a\x45\xaf\x13\xbc\x03\x98\x65\x8d\x0e\xef\x8b\xc4\x1f\xd3\xfc\xf2\x61\x59\x41\x10\x5a\xaa\xd9\xa4\x68\xc0\x66\xcc\xaa\x78\x5c\xe0\x13\x02\x93\xc9\x2d\xc8\x5b\x30\x19\xab\x9d\xa2\x34\x78\x4c\xf3\x39\x69\x4d\xff\x1d\x4f\x7a\xb7\x1f\x59\x47\x22\x6e\xc3\x37\x5a\x9c\x97\x4a\x5b\x09\x35\x51\x4d\x64\xeb\x48\xb7\x18\xdc\x1b\x9f\x27\x30\x1a\x0d\x24\x75\x7f\x8c\x68\x81\xe6\x86\x4d\x9a\xd4\xe6\x08\x39\xb7\xcb\x15\xc6\x41\x28\xc9\x58\xd0\x6b\xe5\x0f\xf8\x03\x8b\xf1\x69\xb7\x0b\x4a\x63\x05\xf0\xdf\xe9\x0c\x26\x26\xdf\xdf\x33\x6a\xb1\xb0\x8b\x9a\x2f\xa3\x59\x08\xf4\x5b\x5e\xdc\xe5\x70\x3d\xb6\x45\x54\xc7\xe8\xb0\x24\x4f\x6c\x1c\x49\xf3\x97\x9c\x40\x1a\xe6\x0e\x4e\x4c\xcc\xb4\x19\x53\x10\x08\xe6\x48\x1f\x94\xbe\x6b\xe5\x6d\x3d\x4a\x91\xa7\xb9\xb7\x29\x8c\x32\xe1\x13\x9f\x95\xe8\x8a\xc8\x63\xa9\x03\xb6\xcc\xc4\x82\x06\xb6\x30\x6a\xb7\x63\x43\xfb\x12\x91\xda\x49\xb6\x85\x41\x44\x00\x6a\xf6\xe6\x3a\x2a\x09\xee\xe4\x4c\x7e\xf1\x54\x3b\xe5\xf2\xae\x7f\x31\x21\xd1\x1c\xae\x05\x98\x22\xe1\x25\x41\xab\x6f\xdc\x01\x21\x98\x2d\x1f\x15\x89\x5b\x29\x8c\x91\xba\x21\xaf\xe9\x18\x95\x96\x7e\x45\x13\x52\x23\xdf\x90\x01\x59\x99\x7b\xd1\xaa\xc4\x42\xed\x5c\x52\x4a\xa6\xaf\xc7\xea\x93\xad\x0d\x48\x01\xed\xfb\xb3\xb1\x49\xf0\x94\x46\x6f\x1e\x95\x28\xea\x26\xf3\x8d\x25\xb6\xaf\x25\x85\x3f\xbb\x07\xf5\x32\xa7\x3e\xa2\xc7\x5f\xa5\x7b\x11\x03\x99\x61\xbc\xdc\x22\x2e\xf7\xa4\xea\xcc\xf1\xc6\x30\xad\x33\x44\xdd\x59\x74\x13\xb8\xb9\x14\x0d\x7b\xa0\x1b\x5e\xc1\xe0\x46\xd5\xdd\x85\x06\x4c\xa9\x0d\x0e\x15\x50\xc2\xc3\xab\xbe\x0c\x4e\x58\x3a\x69\xf7\xb6\x30\xfe\x5d\xac\x81\x37\x91\xf2\xec\xf0\xbf\x15\xa1\x13\x61\x5a\x81\xa6\x6e\xd7\xac\xc9\xb3\x74\x60\x0f\xaf\xf8\xb0\xa7\x9e\x1d\xb7\x6d\x12\x97\x0c\x42\x87\x7a\xa9\x06\x62\xa3\x16\x98\xad\x8e\xa1\xb2\xb0\xb4\x02\xc7\x7a\xbd\x6a\x55\xd2\xaa\xf8\x43\x5e\xd5\xea\x55\x9b\x69\x7a\x74\xd3\x4c\x34\x9a\x3c\xf2\xea\xfc\x88\xe1\xfd\xdc\x8f\x3a\xe9\x00\xd9\x0d\xfb\x49\xc7\xf7\xd5\x07\x66\x4c\xb2\x73\x0b\x7c\xcc\x98\xf0\x3e\xe3\x6e\xf0\x4c\xb5\x6a\xe4\x24\x53\xe5\x8a\xc1\x08\xef\x36\xdc\x81\xff\xf1\x8b\xb7\x3b\xfd\xb2\xbd\xcc\xad\xf3\x38\x20\x2e\x55\xf5\x4f\xd9\x26\x90\x89\x1a\xcf\x28\xb2\x9d\x56\x91\x09\x37\x88\x97\x91\x6c\x72\x0d\xa6\xde\x6e\xa8\xf4\x46\x72\xc7\xca\x9c\x95\x4a\x2f\x94\x3b\x0d\x95\x36\xbb\x46\x77\x66\xf4\x2f\x09\x7d\x4a\x56\x13\x81\xe8\x9e\x8f\x72\x52\xfe\xc9\x37\x9f\x6a\x0e\xf3\xcf\x65\xcb\xcd\xe2\xd3\x56\x31\xba\xb2\xa0\x5e\x15\x8d\x0c\x2b\xf6\x19\xd7\x17\x7d\x81\x3d\xe9\x97\x28\x04\xd3\x9e\x69\x6c\xd3\x15\x64\xf8\xd9\xe0\xfb\x90\x2f\xd2\x9a\x7f\x24\xc9\x85\x16\x8c\xf6\x32\x71\x14\x9b\x14\x4f\x0b\xd9\x45\x29\xdf\xaa\x02\x58\xba\x80\x08\x49\xe5\xc2\x36\x76\x17\xc7\xa0\x43\x4d\x0e\x9d\x65\x57\x2c\x96\xb8\x01\x9e\x53\x50\xd4\xac\x20\xc1\xa6\x92\xa4\x9f\xdc\xce\xa1\xbd\xd9\x08\x23\x55\x29\xe5\x64\x29\x82\xcf\x78\x3a\x12\x8f\x5a\x1d\xdf\x7c\xbc\x7b\xd3\xc2\xd1\xae\x79\xf0\x29\xc8\xf8\xed\xf2\x94\xa1\x09\x63\x2d\x05\x46\x7b\xf6\xbc\x7d\x89\x7b\x53\xe8\xf5\xdd\xe2\xf8\xe4\xbe\x17\xc3\xc9\x1d\xe0\xff\xc5\xb5\xc8\x3c\xef\xf9\x31\x66\xd9\x3e\x49\x93\xe7\xbb\xd1\x65\x76\x58\xfd\x55\xd8\x2a\x30\xd0\x55\xcc\xd4\xa9\x7b\x91\x6d\xb4\x55\x3c\x48\x63\xb7\x5f\x5b\x3e\xf0\x71\x7a\x81\xac\x4f\xf3\x50\x6b\xe6\x21\x79\x8d\x90\x60\x86\x03\xce\xaf\x01\x9c\x91\x84\xad\x26\x7f\xbe\xcf\x68\xc9\x0d\x3f\x45\x19\xac\xfb\xa9\x04\xea\x94\xf2\xcf\x6f\x4a\xa3\x60\x88\x0a\xb9\xb2\xca\xb9\x6b\xa9\xcf\xe3\x00\x3e\x1a\xa6\x34\x9d\x6c\x8a\x21\xeb\x72\x5f\xfe\x55\x4f\x5d\x08\x1c\xc0\x2f\xc5\x44\x77\x13\xe1\x31\x56\xe1\x6f\xa5\x2a\x01\x2d\x92\x7a\xe2\x7a\xcf\x26\x1c\xa2\x18\x57\xf8\xb4\x52\x4b\xbf\x18\x42\x39\xab\xa3\x96\xe0\x14\x2a\x92\xdc\x85\xa0\x70\xb3\x3a\x99\x9f\x75\x55\xe9\x07\x46\x8f\xfb\x42\xc3\x55\x22\x7e\x91\x4b\x7c\xcf\x57\x31\x69\xa3\xe3\x4b\xc3\x56\x66\xfc\xf1\x6b\xd4\x47\x64\x11\x56\x82\x08\x83\x3b\x95\x01\xd3\xa5\xda\x00\x58\xb5\x40\xfa\x35\x3e\xfb\x4b\x2d\x71\x15\x35\x82\x5c\x6b\x3f\xbe\x6d\x08\x80\x8f\x65\x45\xbe\xae\x18\xfd\xe7\x78\xa0\x50\xc6\xb5\x2d\x54\x4b\xa9\xee\xa8\x6b\x14\x66\x31\xcc\x1c\xc7\xc1\x34\xa8\x26\x51\x6b\xee\x47\x67\x72\x8f\xc2\x10\xf9\x7e\xdb\xc7\x03\x83\x4c\x7a\x9d\x30\xec\xcf\x05\x4e\x41\x5d\xc2\xca\x1b\xa7\x91\x35\x4e\x36\xed\x7f\xed\x9f\x79\xa1\x41\x38\x70\x01\xdd\xe9\x9b\xa5\x10\x9f\xc0\x28\xaf\xec\x62\x64\x19\xa1\x36\x6e\xe3\xa5\xae\x62\xae\x4d\xdb\x0f\x05\xa6\xc8\x38\x31\xaf\x0a\xa1\x6b\xa7\xad\x88\x5a\x75\x67\x29\xed\x89\x19\x49\xa7\xf7\xa6\x69\x7f\x8d\x4f\xa7\xe8\x26\xb8\x4c\x46\x5d\x07\x29\xd0\xf9\xa7\x37\xf3\x83\x26\x1e\x73\x62\x6a\xa4\x00\xa9\xf7\x85\x4d\x5c\x49\xd6\x44\xa0\x48\x31\x37\xbe\xbf\x19\xaf\xcf\x65\x6b\xc6\xe3\xed\xa5\xe3\xb2\xb2\xfc\xbe\x7a\xae\x4f\xfc\x67\x3e\xe3\x82\x20\xf1\x8b\x3a\xd7\x59\xec\xf9\x8f\xfd\x23\xe6\xcd\x1e\xbd\x62\x11\xd1\x92\x79\x73\x56\x2f\x11\x8b\x96\x3b\xd1\x27\x06\x87\x61\xeb\xf1\xac\xd4\x70\x36\xce\x13\x54\x45\xe1\x63\xbe\xbf\x64\x77\x9c\x4f\x27\xe2\xf9\xcb\x93\x49\xcd\x01\xe9\x24\x44\xa1\x13\x55\x08\x57\x3b\x67\x70\x24\x85\x41\xa0\x7f\x5e\x50\xe7\x0c\xa4\x3e\x8c\x28\x97\x32\xf8\xf7\x96\xe2\x54\x50\xdc\x1e\xbd\x08\x78\xc9\xf9\x05\x7a\x12\x70\x51\x52\x98\x25\x16\x49\xa1\xf2\x3b\x16\x3d\xee\xae\xbf\xa5\x6f\xff\x75\xa0\x8d\x1f\x43\xb1\x47\xe7\xa0\x37\x11\xa6\x90\x76\xa9\x7f\xf9\xcf\x94\x12\xff\xd4\xf2\xf2\x68\xa4\xfa\xe5\x66\x8b\x87\x51\x65\xc9\x41\xf7\x61\x7e\xb2\x71\x25\xb9\x62\x65\x60\xa7\xe6\x4d\xee\x9f\x4f\x6b\x40\xc2\xcf\x05\x6b\x0c\x13\x61\xef\x65\xc3\x9e\xa7\x33\xd1\xf6\xbb\x0f\xe0\x75\x87\x50\xad\xbe\x5b\x38\x44\x8f\x21\x23\x0b\xba\xcd\x72\x8f\x9a\x26\x4b\x6d\x28\xee\x31\x1c\x1a\x80\x5e\x6a\xc4\x08\x1a\x6a\x4d\xa7\x35\x14\xff\x4b\x7a\xfc\x6b\x7e\x71\x0e\xf4\x14\xb4\x20\xe3\xa1\xe8\xc3\x48\x25\x3c\xea\x8b\x72\xbb\xb8\xda\x7b\xe7\x7d\x2e\x69\xfe\x82\xbb\x8d\x9f\xbd\x6d\x82\x72\x41\xd2\x91\x30\x75\x54\x00\xa3\xd4\xb5\x63\x2a\x2e\x4f\x0a\xf2\x99\xaa\x7a\x6a\x76\xea\xeb\xc9\x11\xe4\xf6\xfd\x9a\x88\x4f\xfd\xcd\x2c\x2e\x93\x97\xbf\x93\x69\xf7\x52\xbd\xe2\x05\x6e\xfe\xe1\xa4\x35\xcc\xf8\xe4\x94\x32\x39\x6e\x78\x32\x44\x6b\xa8\x08\xbc\xe9\x3f\x21\xc3\x11\xe2\xd5\xf7\x05\xb8\x3a\xb3\xed\xf9\xcb\xb8\xf4\x21\x87\x69\x77\x3d\x46\x66\x9e\x57\xbc\x36\x16\x4e\x70\x56\x23\x69\x27\xe7\xae\x9b\x7b\x79\xf7\x55\xd9\x67\x8c\x8f\xb3\x55\x4b\xe0\xa5\x23\x3b\xd3\x3f\x6c\xc8\x61\x47\x9b\x57\x93\x4c\xfc\x18\x4a\x66\x8a\x12\x3f\x94\x0b\xfe\x8b\x3c\x93\x6b\x17\xd4\xfe\xe1\xf0\x75\x73\x09\x34\xa4\x0a\x43\xb1\x54\x35\xe7\x53\xa0\x50\x29\x1b\xa3\x7e\x06\x97\x8e\x94\x81\x0a\x2d\xef\xa5\x2b\x46\x07\x4b\xc3\x0c\x4e\xf9\x8c\x54\x37\x5f\x34\xb2\xea\x44\x5d\xee\xfc\x04\x37\x57\x5f\x82\x97\x85\x7e\x1b\xde\x8c\x48\x32\xaf\x47\x2d\x6a\x66\x76\xde\x76\xc1\x9d\x67\x76\x6b\xba\xf4\x30\x0c\xe5\x54\xb0\x06\xb8\x6d\x42\xb8\x26\x67\x1e\xbf\x6f\xc1\xa3\x15\xd5\x81\xa7\xf1\xdd\xc9\x8d\xc5\xc1\x9b\xdb\xb7\x7a\x32\x60\x8f\x67\x21\x7a\x44\x09\xbb\xc8\x5f\xdb\x04\x95\xcb\x76\x63\xbd\x56\x4e\xee\x1f\x6a\xc9\x4c\xc6\x2f\xc7\x60\x10\x03\xea\x71\x63\x21\x7f\x38\xb2\x95\x60\xb0\x62\x6b\x61\x44\xc2\x6c\x0f\x95\xcf\x72\xf9\x7a\x9a\x43\x7a\xcf\x4e\x4a\xce\x64\x27\x3f\xc0\x61\x42\x7e\x2a\x47\x53\xb9\x0c\x31\xe2\x05\x2d\x58\xd7\x29\xc7\x73\x3f\xf4\x5e\x7f\xcd\x94\x56\xec\x79\x5d\xde\xcf\xdb\x85\x5c\x08\x5b\xc2\xa3\x00\xc9\x9a\xb7\x22\x3d\xe9\x67\x64\xa2\x5e\xbf\x24\xa7\xb6\x59\xf0\xd2\xae\xb6\xab\xfb\x35\x4b\x37\x15\x8c\x9c\xef\x2a\x67\xa4\x69\xd2\x02\x6f\xf1\x43\x86\x2b\x6c\xf1\x7c\x54\xe5\xc7\x06\x50\x81\xc8\xdb\x74\xbb\xac\x42\x94\x74\x7f\xb1\x14\x38\x61\xc7\xa8\xd2\x88\x7f\xf6\x5d\x28\x52\x56\x57\x40\xfd\xd9\xca\xf5\xa5\xd7\x40\x81\x00\xd3\x47\x6c\xd1\xef\x87\xdc\xd0\x22\x36\x0d\x5b\x5e\xb4\xa4\xbf\x7f\x81\x0e\x78\x9f\x3f\x46\xd9\x20\x53\x7f\xec\x00\xe9\x47\x4b\x74\xa2\x7a\x11\x03\x4d\xfd\x07\x93\x24\x69\x9e\x3b\xcc\xbd\x46\xab\x57\x5a\xc9\xbe\xb1\x74\xe0\x87\x63\xe3\x37\x47\x92\xfa\xcc\x6f\xc8\x92\x9f\xfb\x7d\xbe\x13\x72\x71\xf6\x8e\xa1\x20\xcf\xbe\x48\x7c\x7d\x96\xc3\x98\xeb\xf4\x6d\x69\xdf\x9a\xc1\x79\x19\x87\x58\xa6\x61\x1b\x83\x46\x1a\x82\x52\x48\x46\xb1\xc8\x76\xbe\xbb\xe7\x52\x42\x71\x54\xdd\x88\xd0\x93\x40\x40\x10\xe3\xd1\x9b\xd5\x47\x5c\xfc\xa8\xb8\x5b\xff\xa5\x70\x76\x79\xc8\x35\x64\x2e\x4c\x68\xe4\x41\xe3\x32\x8a\x83\x69\x7a\x80\xaf\xcf\x79\xa8\x8f\xcb\x6f\x25\x77\x2f\x8b\xbd\xb0\xf5\x2a\x3a\x46\x00\xcc\xce\x81\xd3\x44\xb8\x37\x1b\xed\x35\x25\x47\xbd\xa6\x0a\x7c\x43\xee\xea\x68\x1a\x96\x42\xa8\x44\x63\xad\x5f\x2e\x12\x11\x69\x65\x98\xbc\xdc\x15\xd7\x22\xc2\xb2\xff\xa3\x4c\x04\x7f\xce\x72\xc3\x68\x34\x37\xad\xec\x9c\x05\x9f\x87\x9b\x85\xb0\x8f\xb5\x72\x46\xa4\x55\x4c\x14\x4e\x32\x53\x65\xb8\x25\x79\x89\xdd\xe1\xe4\xea\x61\x76\x9e\xe1\xea\xc0\x48\x68\xf4\x89\xbd\x6f\x9f\xc7\xbb\xbb\xef\x60\xc2\x4e\x55\x87\xa0\xc5\xe2\x2d\xc6\x74\xd6\xe2\x33\xdc\x62\x8e\xaf\x87\xae\x88\xd2\x9e\x0d\x81\xf2\xf8\x6d\x0d\xe2\x6f\xfb\x7b\x38\x47\x37\x10\x71\xae\x1a\x4a\xdc\x72\x72\xfb\xdf\x22\xf9\x99\x71\x1c\xdf\xc4\xb7\x91\x1f\xae\x13\xff\xa8\x65\x92\xe7\xf2\x0b\xdd\x97\xff\x0a\x48\x6c\x4c\xa9\x32\xc5\xbe\x0d\x2b\xd8\x02\x2a\xb3\xd2\xec\xfd\x7a\x98\xf5\xfa\x67\x30\x7e\x1b\x63\x1d\x38\x3f\xee\xbe\xf6\xbf\x8f\xd7\x74\xe1\xb1\xad\x05\xb2\xb8\xe7\xa1\x0d\xca\xe0\x50\xb8\xa3\x8b\x89\xa1\xf3\x94\xca\x43\x64\x64\x60\xb7\x2b\x06\x1c\x1e\x31\x27\xca\x12\x17\x9b\x4e\x09\xfc\x08\x26\xef\x27\xcb\x3c\xf5\xa7\x8f\x4a\x8f\x3c\xe2\x32\x77\x4c\x34\x57\xb4\x05\xb8\x65\xd2\xb6\x48\x20\x3a\xc5\xf2\xc9\xee\xc7\x21\x23\x3a\xb2\x85\x27\xc6\x3b\x6f\x72\xe6\x42\x0b\x24\xf5\x34\x83\xa7\x72\x40\x6c\xd8\x00\x06\x03\xac\x67\xd5\xad\xb0\xe6\x91\x88\x13\x58\xb1\x15\xa2\x37\xb2\xcd\x0c\x41\xe0\x66\x7f\x40\x3c\xd7\x6b\xd1\x5f\x20\x5e\x8b\xcf\xcf\x4c\x97\xca\xdc\x86\x8a\xc6\x82\xbe\x67\xc2\xdc\x11\xd3\x15\xed\xdd\x3a\xd2\xb9\xad\x3a\xd2\x80\xae\xbb\x9b\xc0\xef\x16\x68\xdf\x77\x07\x1c\x1e\x00\xad\xa9\x88\x69\x88\x1e\x07\xbd\xbf\xda\xc5\xca\x02\x1a\xec\x0f\xde\x1f\xb4\x42\x6d\x37\x1d\x50\x68\x8f\x7c\xf5\xcc\x5b\x88\x1e\x85\xc7\x09\x4b\x4a\xc4\x13\x54\x92\x3c\x61\x39\xc5\xec\x76\x9c\x71\xe8\x3b\xb3\xef\x2c\x50\x6b\x73\x63\xc4\x84\xcb\x0e\x17\x73\xa9\x48\xd6\x39\x2c\x85\x76\x0f\xde\x8f\x6e\xf8\xa5\x27\x5e\xad\xb9\xd7\x0b\x10\x30\xfe\xbe\x5a\x4b\x9e\xbf\x67\xef\xca\xb7\x30\x89\xa4\xf7\xf0\x67\xc7\xe7\x15\x36\xe0\x49\xa4\x37\xf8\x03\x02\x8f\x7e\x68\x02\x55\x28\x13\xd2\xbb\x38\x55\x44\x8f\x58\x40\xe9\xeb\x55\xf1\x97\x9e\x5a\x17\xee\xb6\xd3\xea\xd0\x7f\x4c\x00\x44\xc6\x8a\x1d\x14\x85\x0c\xd1\x76\x72\xa6\x3a\x7d\x93\xb2\xe2\x44\xcd\xfc\x48\xb9\x11\x58\x4c\xea\xaf\x8d\xbd\x33\x9c\x6e\x2e\x63\xd4\xd3\x41\xe4\xf2\xb1\x4e\x28\x30\x18\x4e\xca\xd1\x0a\x5d\xba\xfe\xbc\x46\x24\x3f\x34\xc0\xb9\xd6\xdd\x1c\xbe\xc5\x0f\xd2\x58\x22\x29\x61\xc1\x77\xdd\xb7\x0e\x7b\xd5\x12\xb6\x06\x82\x58\xb5\xcb\x0e\xa4\x63\x78\x97\x9d\x88\x1e\x92\xe3\x61\x9d\xbe\x67\xe4\x7a\x85\x13\x54\x55\xb0\x47\x2a\x51\xc5\x94\xb3\xde\x0f\xa9\xe9\x60\x08\xf5\x6d\x82\xe5\x5c\xc5\x93\x09\x1e\x8c\x60\x44\xc4\xab\x93\x9a\xd8\xbf\xd2\x68\xc4\x8a\xa6\xe4\x84\xa6\xb4\x38\xae\x63\x9a\xbb\x13\xc3\xe4\xaa\xb0\x29\x8e\x24\xb5\x34\xc2\x1e\x3d\x11\x5b\x1e\x9f\x55\x9d\xeb\x24\xe9\x6d\x15\xf4\x45\xae\xaa\xf8\xc6\xb7\xc2\x82\xfa\x1d\xc7\xbe\x37\x25\x26\x10\x09\x64\x88\xfd\xdf\xe3\x19\xe3\x62\x55\x02\x36\xda\x9d\x0a\x2f\xaf\x7b\x84\x02\xa0\x4c\xa9\x64\xad\x93\x32\x36\x13\x29\x44\x0f\xda\x82\x0b\xdd\xdd\x81\x2f\x30\x30\xfa\x24\x57\xb9\x43\xd6\x52\xe4\x97\x00\xec\x89\xc9\x6e\x1a\x39\xe1\x8a\x1a\x67\x6e\xb6\x4a\x89\x8c\x4a\x86\xc3\xc5\x75\x7f\x4a\xe1\xa1\x22\xd5\x64\x61\x67\x5e\xea\x1d\x62\x97\xf7\x2c\x9f\xaf\x69\xbf\x49\x4a\xe4\xce\x5b\xe7\xb0\x88\x85\x21\x97\xa4\xe9\xde\x11\x4b\x25\x29\x3d\x67\x4d\x93\xfc\x23\x57\x74\xc5\x7f\xbf\xc6\xbe\x90\x44\x8c\xa5\x93\x5d\xcf\x5c\x5b\x73\x34\xa4\xed\x32\x67\xaa\x7d\xbd\xab\xd2\xad\x98\x7e\x7e\x5d\xab\x34\x5c\xff\x3b\x9f\xae\x3e\x51\x34\x7d\x87\x47\x6d\xa2\x3f\xbc\xd0\xc1\x1b\x62\x93\xda\xf1\xf3\x70\x13\x4a\x0b\x00\xa2\xb3\x7f\x18\xc0\x3d\xcf\xe4\x91\xb0\xf0\x1f\x2f\x1c\x81\xb4\x51\x20\x23\xae\x16\x3a\xa9\x0a\xa7\x88\x34\x5b\xb7\x63\xd6\x03\xdd\x3c\x56\x60\x59\xa3\xf7\x44\xaa\x45\x20\x61\xcf\x2e\xb7\x7d\xb4\x98\xfc\x7e\xed\x65\x17\x53\x2c\xb6\x79\xcf\x41\xdf\x2f\x2e\x4b\xc8\x90\xc2\xcb\xc8\xc5\x13\x6b\x5c\x40\x04\x0e\xc7\xc9\x58\x64\x29\x43\x24\x18\x47\x64\x59\xba\xa4\x73\x9d\x25\xfe\x16\x94\xf8\xd9\xa4\xef\x8b\xc6\xc5\x2f\x46\xe7\x8d\x46\xec\x50\x26\xe0\x88\x98\x6c\x63\x4d\xcc\x06\x48\x6f\xc7\x66\xa7\x8b\xd2\xd6\xfe\x32\x15\x5e\xf3\x32\xa0\x36\xb8\xee\x20\xcb\x44\x60\x26\xa2\x58\x4a\xe2\x43\xdf\x75\x0b\x3b\xf2\xfe\x8e\xa7\x6a\x83\x9e\x42\xf6\x6d\xad\x82\x74\x21\x06\x9c\x57\xc4\x8e\x19\x4d\x5e\xa4\x66\x7b\xc3\xf9\xed\x69\xd4\xb0\xaa\x94\x59\xcd\x58\x87\x0f\x02\x26\x38\x9b\xb4\x1e\xe6\x37\xf5\x54\xf1\x44\x62\xa0\x70\x01\x47\x1a\x4b\x0f\xb3\x5f\xab\x33\xa8\xf5\xf4\x0e\xf0\xd4\x6e\x88\x73\xc4\xac\xda\xb6\xc4\x71\xaa\x71\xd5\xa8\xb7\x77\xfb\x84\x2a\xa7\x19\x47\x6a\xd8\xdc\x12\xd7\x69\x7b\x33\x67\x80\x71\xa9\x78\x1c\x11\x42\x12\x68\x12\x3b\x42\xe1\xf7\xda\xd2\xc1\x7c\x7a\xee\xfb\xd8\xf0\xda\xd0\x41\x66\x47\xba\xc5\x61\xf2\x0a\x65\x58\x92\x9f\x9b\x4c\x6e\x4a\xcf\x2c\xde\x34\x8f\xcd\xc0\x8d\x36\x0b\xb0\x76\x5a\x03\xe5\xbf\x9d\xfc\x91\xfd\xbc\x9d\x07\xea\xcf\xb4\x38\x0a\x12\xdc\x3b\x7d\xdd\xa8\x64\x7d\x36\xb1\x19\x96\xb0\xf1\xe4\x52\xc3\x59\xdd\x62\x0b\xd3\xf7\x59\x6e\x8f\x6a\x4c\x31\x00\x60\xb7\x06\x46\x35\x4e\x3e\xb2\xbf\x68\xdb\x03\xc2\x15\xa8\x18\xc1\xb3\x1f\x23\x3c\x46\x00\xc4\xc5\xa2\xfc\x57\x52\x9d\x25\x78\x5f\xdb\x87\xfb\xbb\xe8\x7e\x1b\xe7\xd7\x2f\x0d\xef\xd1\x66\xd1\xf8\x0d\xcc\x8a\xb1\xb7\xd9\xe5\xdb\xb8\x26\x54\xbd\x79\x14\x94\xa4\x44\x96\xef\xc6\x08\xf7\x3e\x28\x96\x9d\x14\x7a\x67\x65\x41\x85\x8f\xd9\x3b\xd2\xec\x80\x65\xb6\xa0\x1a\x77\x32\x0b\x8b\xf1\x06\xe9\x76\x3b\x96\xc4\x9e\x01\x13\x36\x41\x90\xa9\x94\xca\x9c\xac\x4d\x06\x75\x7b\x82\xd1\x04\x23\xf9\xca\xc2\x89\x9f\xd6\x93\xed\x46\x82\x3b\x9d\x94\x9d\xe5\xde\xa6\x84\x9b\x64\x3a\x6b\xa1\xeb\x1a\xa4\x97\xd7\x30\x65\xa4\x76\x00\xf7\xba\x64\xc6\x2c\xa6\xf4\xde\x48\x0d\xf7\xf7\xb7\x3c\x02\x9d\x49\x8b\x8c\x33\x5e\xc1\x5b\x76\x12\xab\x8b\xec\x32\x82\x74\x3f\x4b\xe5\x4a\xbf\x25\x26\xe6\x12\x43\xa3\x48\xd9\xf5\x11\x92\xd9\x56\x1a\x3f\xaa\x9b\x0d\x9e\xd1\x5f\x23\x6d\x1b\x97\x45\x50\xf5\x5f\x16\x2b\x9f\xcb\x43\x4e\x09\x6c\xb5\x51\x24\x40\x30\x29\x12\xa4\xcf\xa2\xf9\x40\xea\x2e\x05\xc4\xde\x23\x23\x5c\x0a\x96\x50\xc6\x73\x62\x0f\x43\xe9\xba\x59\x34\x96\x57\xc5\x9e\xa7\xd7\xa4\x2e\x75\xb5\xd0\x2f\x35\x4a\xb1\x91\x53\x3e\x24\x67\x0a\x5e\x86\x73\x43\x62\x5d\xcf\xa1\x2d\x80\xda\xf2\x74\xa4\xc0\xec\xda\xf0\xab\x5b\x57\x7b\x9b\x11\x45\xca\x54\xad\x4d\xef\x0a\x25\xed\x38\x23\xc3\xa8\x0b\x07\x01\xa6\x0c\xec\x3c\x49\xb2\x97\x3d\x35\x72\x5a\xa4\x44\x6c\x5b\x51\xa1\xa1\xde\x48\xc4\x73\x08\xa0\x8e\x57\xb4\x8a\x19\x6a\x01\x87\x8b\xe8\x6e\x3f\xaa\xe1\x9d\xa5\xf2\x59\x74\xc1\x9d\x44\xf2\x2c\x46\x42\x49\x37\xd3\x64\x1b\x4f\x40\x95\x53\x0a\x76\x49\xf2\xf8\x60\x04\x0f\xef\xd4\x1f\x0b\x9a\x32\x61\x20\x17\xef\x24\x42\xbd\xc3\x40\xdf\xc7\xd6\xea\xaf\xd6\x7d\x34\x9a\x36\x7c\x23\x82\xff\xa3\x20\x4a\x96\xb3\xb8\x43\xbd\xc4\xc4\x56\xf5\xde\xfd\x85\x4a\x28\x41\xac\x54\x37\x8a\x18\x0c\x21\xda\xed\x75\xf8\xf3\xb1\x90\x73\x04\x95\x9b\x58\xa5\x3a\x45\x67\x42\xb4\x0e\x69\x93\xbb\x14\x70\x73\x99\xdd\x7b\x32\xdf\xb3\xf2\xdd\x06\xb2\xf9\x57\x02\x37\xff\x89\x75\x95\xf1\x3c\x42\xd8\x41\x47\x1e\x65\x1e\x03\x71\x7c\x7c\x42\x66\x34\xd3\x53\x47\x21\x1e\x38\xd1\x12\xee\xfb\x33\x25\xb6\x30\xa7\x45\xa3\xba\xfb\x45\xd2\xa2\x3b\x23\xdd\x55\xa0\x7d\x08\xff\xc2\x24\x83\xd3\xaa\xc7\xc8\xc1\xdc\x27\xf4\xab\x4a\xd2\xdb\xe1\x44\x42\xdc\x82\x94\x87\x44\x2f\x54\x35\xef\x73\xc8\x4d\x9d\x47\x4d\x56\x6d\xaf\x46\x4a\xc3\x52\xd6\xbb\x23\xb8\x14\x4d\x2e\x9a\xb9\x95\x6c\x03\x79\x3a\x56\xee\xaf\xc2\x45\xc3\xbe\x6b\x28\x5f\xaf\x41\xb5\x89\xd7\x6b\x0b\xe3\xfd\x1c\x47\x4b\xcb\xb6\x33\xe3\x7c\xfb\x25\x69\x55\x47\x99\x67\x51\x1a\xf0\xc0\x48\xc5\xe7\x39\x9a\x6e\xb4\x05\x55\x20\x00\x69\x8b\x19\x97\x3c\xfd\x80\x5d\x52\x95\x90\xcf\xf1\x0b\xcb\x32\x0a\xe5\x89\xbc\x7a\x2e\x73\x7d\x14\x2d\xb3\x02\x1d\x9c\x00\x74\x04\x3f\x23\x1c\x45\x23\x41\x90\x99\x41\x8b\x53\x09\xc9\xc5\xb6\x38\x32\x29\x47\xe8\x58\x7d\x4e\x12\x78\xba\xcc\x4e\x97\x83\x68\xc5\x6e\xe6\xe0\xc8\x90\xb6\xfd\x96\xa5\x76\xa9\x39\xc5\xac\xaa\x55\x5e\x16\xb2\xcd\x50\xa9\x96\x1d\x9f\xa8\xed\xcd\x2c\x4f\xaa\x34\x26\xa3\xf3\x15\xcf\x5a\x51\x0d\x1f\xb7\x8b\x48\x3a\x10\x0a\x15\x42\x99\x2f\x69\xe5\x34\xbb\x66\x33\xa7\xf9\xda\xbc\x12\xee\x2c\x6e\xbd\xeb\x4d\x55\xa0\x4b\x7a\xc6\x9a\xff\x7e\x6f\x1c\x89\xf3\x54\xdf\x57\x9d\x53\x29\x49\x2b\xe1\xf6\xff\x66\x98\x13\xe3\xce\x67\x85\x7e\x74\xcd\xf9\x45\x64\x49\x36\xe5\x13\x51\x43\x43\xa9\x1e\x19\xee\xbe\x20\x9d\x13\x00\xc3\x4b\x8d\xfd\x5c\xb2\xc5\xf1\xf3\x96\x9e\xff\x41\x91\x72\x3f\xcc\x2d\x13\x08\xa4\x4e\x04\x97\x01\xd9\xb8\x8b\x31\x4a\x5b\xe6\x41\x19\x4d\xea\x0c\xd5\xd0\xaa\x9d\xd0\x55\x56\x0b\xf4\x6a\x2b\xf1\x5e\x04\x14\xf3\x61\x6a\xa2\x9b\x9d\x13\xa7\xd1\x15\xb5\xb8\xf4\x2e\x9f\x4f\xc5\xaa\x0b\x72\x42\x5a\xdf\xd3\xa4\x87\x30\xe2\x73\x84\xea\xba\x58\xe8\x04\x7b\x17\x27\x85\xe5\xfd\xbe\x98\x66\xf0\x01\xd7\x47\xf5\x95\xd3\x23\xb1\x04\x69\x6d\xca\xa5\xb9\x79\x64\x01\x6e\x17\x8c\x24\x47\x96\x32\x50\xdd\x73\xda\xfa\xd6\xa9\x71\xb9\x02\x6e\x23\xa6\xf4\xf7\xdd\x2c\x9a\x10\xbb\xb5\x0b\x43\x25\x4c\xe7\x4b\xbe\xce\x1a\x4f\xef\x19\xa7\x3a\x3a\xcd\x78\xdf\x9a\x6b\xfc\xe6\xd9\x16\xe2\xd5\x8b\xbc\x71\xde\xaa\x5d\xd6\x15\x72\x2d\x54\x9d\x51\xde\x91\xd1\xfb\x66\x71\x98\x15\xa1\xd4\xf4\xc9\xfe\xf5\xb1\xec\x1b\x5c\x23\x27\x5d\xbc\x48\x87\x99\xc7\xfd\x82\x1f\xb5\xd9\x31\x97\xe3\xf3\xbb\x32\x77\xf1\x0e\x44\xdb\xdb\x93\x9b\xf8\xce\x7d\xe7\xa8\x4d\x66\x11\x76\xfc\xfd\x9d\xdb\x54\xb2\x37\xbf\x9f\xa7\x7c\x22\xc6\x21\x4c\x6c\x62\x51\x44\xe0\x10\xd8\xea\x73\x15\x5e\xa3\xca\x64\x5f\x27\xb4\xfd\x9a\x19\xea\x3c\xf4\x61\x91\x71\x1d\x4e\x77\x85\x53\x2b\xa9\xc0\xbc\xb3\x62\x86\x33\x24\xd8\xc9\x8f\x2c\x35\x36\x97\x43\xe8\x38\x06\x3a\x4c\x8d\x84\xdd\x3e\xc2\xda\xd8\xa4\xc1\x53\x1d\x31\x51\xd5\x9c\x59\xf2\xc6\x62\x60\x0d\x9a\x6f\x52\xcf\xa0\xbc\xcb\x96\xe6\x41\xa8\xfa\x7d\xf3\xf7\xfc\xd7\xda\x7d\x75\xd3\x06\xe5\x04\x9a\xcc\x16\xdd\xca\xee\xc6\xa9\x26\xb9\xca\x7c\x7e\xf0\x34\x9e\xd4\xf1\x75\xc0\xe9\x4e\x70\x0e\x0c\x2e\xa3\xe7\x90\x03\x87\x1d\x67\x59\x09\x34\x5e\xe7\xae\xb7\xc6\x11\x27\xf7\x52\x5d\x29\x74\xc8\x53\x03\x87\x13\x41\x86\xbf\x94\x4b\x38\xd8\x35\xf9\x17\x19\x1a\x4c\x7f\x63\xcf\x9f\x3b\x34\x86\xfd\x6f\xc5\xcd\x7a\x4b\x89\xbb\x62\x67\x55\x7a\xfe\xfc\x60\x07\x9a\x94\x2d\xaa\x6d\x78\x2e\x1b\xdb\xe2\xab\x1f\xbc\xb5\x5c\xbe\x69\x1d\xaf\xab\x31\xce\xd2\x9b\x47\xae\x79\x84\x2b\x4b\x8c\x23\x1d\x2a\xf4\xe5\xeb\x6f\xab\x7f\x32\x64\xb6\x91\x6e\x05\xc5\x1d\x48\xac\xb7\x66\x10\xed\x1b\xdb\xa5\x49\xf6\x01\x32\x5e\x28\x15\x62\xb1\x87\xb8\xb6\x8d\x2f\xb3\xef\xdd\xef\xa2\x52\x7f\x45\x08\xeb\x86\x26\x0c\x0f\x5c\x35\x60\x2c\xb8\xe3\x1f\x07\x9b\xcc\x5e\xa5\x08\x29\xf5\xc8\xc5\xc6\x29\x64\xa1\x4f\xd5\x37\x3b\x5d\x01\x8c\xf2\xd0\x1a\x13\x9d\xaf\xf1\xbe\xd4\x57\x94\x8a\xbf\x15\x5a\x79\x96\x7e\x02\x31\x68\x1a\x82\x9e\x7f\x7c\x5c\x57\x8b\x77\x3b\xbd\x86\x08\x1c\xc2\x09\x0a\x8f\xcf\x59\x35\x48\x17\xab\xc1\x4f\x9e\xd5\x98\x9a\x30\xbb\xdb\x30\x07\x92\x8e\xd8\x7f\xfd\xdd\xb8\x7f\x66\x9d\xeb\x99\x63\x2b\xd1\x57\x98\xf4\x93\x7b\x06\x1e\x48\x9a\x8b\x27\xa5\xfa\x08\x8d\xf9\x08\xc2\x2f\xc6\x90\x06\x1c\x5e\x21\x44\x1a\x82\xf2\x13\xaf\xa2\x05\xae\x23\xb1\x9f\x7c\x3d\x3b\xb7\xa2\x10\xd3\x08\x6e\x5f\x0c\x88\xf9\xb8\x6c\xdf\xa6\x36\x09\xd1\x25\xd1\x4d\x5e\xff\x5a\xee\xf8\x62\x8c\xd8\xeb\xe3\x10\x76\xa9\x34\x92\xc7\xba\x72\xb7\xdf\x73\xca\x6f\x91\x9a\x11\xf2\x64\x02\x4d\xf6\x4d\x1e\xdb\x07\xb9\x77\xcc\x62\xa6\xa5\x7c\x6b\x99\x9f\x21\x47\xfb\xc2\xd6\xec\xdd\x0c\x57\xee\x2a\x87\x78\x33\xa9\x27\x71\x79\xdc\xff\x65\x29\x85\x1e\xf3\xed\xab\xb4\xf5\x8c\xe6\x21\xa7\xc5\x3a\x6a\xcb\x78\xd6\x7e\xc4\xdc\x72\x39\x9b\x6c\x76\x13\x58\x76\xcf\xb4\x6c\x3d\xca\xf9\x4f\x00\x89\x18\x39\xbc\x64\x60\x4d\xe9\x0b\xea\x05\x8e\xe8\x5e\x08\x0e\x65\xdf\x13\x62\x67\x52\xe6\x24\xa5\x3b\xce\x12\x9e\x6f\x66\x56\x19\xff\x05\x33\xb0\xd3\x50\x8c\xd7\xed\xee\x8e\xc7\x54\xd5\x6d\x29\x43\x8d\x98\xcc\x50\xd3\x3a\xc1\x25\x58\x02\xbb\x89\x52\x82\xcd\x94\x26\x94\xfa\xe5\x90\x0f\xce\x89\x77\x06\x78\xb3\x35\xbd\xcf\xce\x15\x52\xa2\x07\xcb\x13\xcc\xac\xc2\x67\x96\x4b\x31\x1f\x88\x78\x74\x8c\xfc\x9e\x10\x37\x50\x9d\xde\x93\x1d\xba\xee\xbe\x18\xbd\xad\xd4\x7d\x2f\x43\x34\x55\x80\xb4\xe5\x0f\xe8\xb1\xa7\x19\x14\x09\x9e\x25\x78\xb8\x07\xaa\x71\x02\x56\x4a\x86\x8b\xf2\x1b\x43\xbc\x02\x8b\xdb\x2e\x23\x9b\xdb\x26\x75\x61\x3b\xe9\xf6\xd5\xf2\xa6\xd1\xf2\xfa\xaf\x5a\x1e\x63\xc2\x76\x75\x2f\xa1\xfe\x7a\x56\x1e\x76\xfb\x37\xb0\xfc\x1b\x20\x61\x18\x0e\x3f\xdd\xa8\x1f\x79\x3e\x39\x85\x5a\x98\x48\x4c\xb7\x09\x1e\xdd\x34\xeb\x6a\x35\x64\x76\x2b\x93\x38\xb8\x26\x22\xa9\x8b\x6d\x77\xc0\x76\x1e\x61\xce\xc2\xbf\x2d\x09\x8e\x42\xf4\x40\x9f\x3e\x8e\xe7\x4d\xc8\xe2\xe0\x89\xcb\xeb\xfb\xd0\xcc\x11\x69\x0e\x62\x26\x64\x7a\x97\xa4\x01\x69\x04\x63\x94\xd7\x9e\xed\x94\x0e\x4e\x5b\x3b\xf5\xa1\xdc\x1f\xf8\x24\xaf\xe9\x63\xc0\x44\x8c\x6d\x15\x07\x2a\xea\x4d\xfa\xd7\xf8\xe4\xfb\x5d\x3f\x53\x8d\x75\x17\xa3\xc3\x7a\xb3\x1e\x17\x1d\x44\xe6\x60\xc2\x95\xc5\x49\x4c\x04\xa3\x29\xf6\x85\xc0\x1e\x7a\xdb\x65\x20\x76\x59\x69\x98\x84\x10\x40\xb8\x74\x9f\x99\xef\x80\xe7\xd0\x3e\x2f\x1e\x26\x89\xa5\x22\x8b\xcc\xed\x26\xf5\x8f\x27\xc5\xae\xf5\xbf\xd4\x3f\x31\x66\x3d\xad\x6d\x7a\x7d\xb3\x5e\xb9\x9d\x80\x30\x60\x95\xe2\x37\xe6\x4f\x9c\xfa\xdf\x4b\x18\x4d\x78\x05\x64\xea\x07\x37\xdf\xe5\xa6\x9f\xe7\x87\x61\xff\xdc\x3f\x01\x9e\x60\xf8\x0e\x7d\xeb\x41\x75\x9e\x78\xde\xc9\xb6\xf3\x56\x0e\xd6\x44\x07\x32\x4f\x8e\xad\xd2\x3b\x4e\x89\x56\xf4\xe0\xf0\x5f\x61\x15\x6b\xfe\xeb\x38\x0f\x57\x8d\x84\xe0\x6f\x62\x5f\x02\xdf\xe5\x33\x65\x5d\x2e\x72\x08\xdc\x91\xef\xb2\xe6\x9d\x6b\x61\x3f\x1c\xb4\x8e\x05\xb1\x9f\x5a\x1a\x27\xd3\x84\x70\xed\x19\xe9\x82\xed\xc5\x94\xdf\x6f\xf0\x73\x1d\x98\xd3\xf4\x64\x1a\xa5\x9f\xa4\xe5\xe8\x42\x92\x7c\xe5\x55\xec\xfe\x59\xa1\x05\x0e\x54\x00\xc5\x9e\x25\xd0\x7f\x78\xb6\xf5\xfa\xa9\x28\xfe\xa3\x98\xbe\x11\x68\xa9\x93\x54\xd4\xa8\x8f\x34\x93\x40\x3b\x2f\xd7\xb7\xe3\x96\xd8\x95\x42\x9a\xeb\x1e\xc3\x30\x94\xfd\xb5\x2a\x18\xcc\x98\x56\x2a\x6e\xd7\x8d\x1c\x32\xeb\x5a\x23\x77\x2e\x56\xad\xf8\x2d\xa0\xdb\x63\xa0\x9d\xa1\xc6\x27\xfa\xa6\x3f\x60\xe0\xb1\xad\x72\x36\xf3\xa6\x5c\xf8\x04\x0e\x27\xc6\xf6\xef\xbe\xf5\xf3\xd7\x60\x44\xb7\x96\x7f\x80\x4f\xad\xef\xbd\x5d\xd6\x60\x6f\xe5\x2c\x15\x9c\xc9\x97\x50\x7b\xfd\xe7\xd8\xbe\xd5\x03\xfb\x9a\x0d\x9a\xf7\xf1\x56\x5f\x90\xe5\x7c\xa8\x42\x55\x94\x43\x63\x31\x1c\x19\x24\x18\xe5\x1a\x44\xea\x6d\x3c\xff\x56\xc5\x46\xa0\xfd\xfd\x8b\xa1\x69\x92\x51\x6a\x3f\xa0\xcc\x91\x00\x04\x22\x03\xca\xa2\x11\xa3\x80\x85\xa1\xc7\xe0\x20\xf4\xd4\x7e\x06\x9a\xd7\x09\xd3\xe3\xc6\x60\x40\x1b\x7b\x9b\x2b\x90\x26\xb4\x35\x31\x8e\xf1\xfd\xe9\xaf\x61\xd2\xa5\x65\x22\x1b\xaa\x15\xc6\xff\x6e\xe6\xee\xe7\xd8\x57\xe1\x30\x14\xbf\xaa\x78\x1a\x2f\x94\xe1\xcd\x0b\x49\x85\xae\x0a\xb5\x54\x38\xc5\x79\x6b\x86\x52\x5f\x86\xcb\x0e\xa9\x20\xf1\xbd\x6a\x48\xae\x48\xa7\x9b\xaa\xb5\x25\x26\xaa\x70\xe1\x3a\x74\x15\xe6\xef\xe2\x37\xee\x33\xa4\x03\x03\x22\x1d\x41\xef\x70\xba\xba\x98\xc6\xce\x72\x7e\x92\x59\x25\xd3\x33\xc5\xb2\x6e\xd1\x2c\x89\x68\x68\xee\xd5\x62\xa6\xce\x58\xd6\x5c\xc8\x39\x54\x78\x08\xe6\xa2\xfa\x6d\x71\x94\xb5\x89\xba\x23\xc8\x06\x48\xcc\x6a\x37\x8d\x60\x0e\x24\xd3\x29\x31\xa1\xb0\xb0\x14\xba\x3a\xc9\x71\x37\x0d\xc8\x15\x81\xc9\x38\x3a\x96\x3b\xec\x03\x9a\x88\x2b\x91\xc1\x56\x74\xa0\x5c\x2a\x03\x2e\xe4\x6a\xca\x04\x7b\xd1\x7b\x9b\x84\x60\x18\x12\x5a\x84\xaf\xd5\x8a\x60\x13\x35\xaa\x3b\x05\x52\x52\x5d\x26\x8c\x9d\xd8\xb5\x38\x3e\xf5\x44\x65\xc2\xb4\xf3\x6f\x6f\x89\x72\x83\x2b\x6b\x60\x11\x83\x79\xa3\xb2\xd5\x98\xfe\x1b\x09\xba\x2a\x92\xf8\xc6\x50\x18\xc4\x99\x46\x07\x95\x64\x5f\x21\x0d\xc8\xa6\xec\xa8\x3c\xec\xa6\x56\x57\xd8\x50\x08\xdb\x73\x33\xff\x28\x5c\x4e\x5a\x43\xd1\x0b\x2f\x2e\xbb\x22\xdc\x53\xa3\xa9\xff\x11\xc6\x25\xf3\x48\x67\x1c\x6a\xec\xd9\x9c\x61\xc9\xca\x0a\xec\x00\xe5\x28\x8f\xdd\x46\x5d\x13\xe4\x8a\x73\x50\xd7\x45\xbe\x2e\x92\xbc\xa8\x4b\x81\x39\x72\x9b\xad\x47\x42\x41\x77\x3b\x9d\xee\x6c\x79\x36\x6b\x57\x93\x4a\x48\xf1\x2b\xec\xcf\x3f\x42\x2a\xd4\x9e\xd9\x40\x3e\x9a\x00\xf9\x2c\x99\x26\x15\xa2\xbf\x09\x57\xff\x34\xdf\xf9\x7b\xba\x1b\xb4\x64\x74\x17\xed\x22\x01\x47\x50\xfb\xea\xea\x3d\xe4\x53\xda\x59\xdc\x1c\x2a\xe5\x65\x9b\x32\xfd\xa7\xfd\x16\x74\x51\xba\xc1\xb0\x25\xa1\xca\x59\xcf\x30\xd8\x48\xa6\xa5\xc3\x7e\xf2\xf2\x5b\xb3\x75\x3b\xfc\xcb\x2c\xb4\xb5\xb3\x50\x81\x78\xea\x18\xac\x28\x11\x76\xe1\x6a\x38\xcc\x51\xc2\x15\xfd\xd9\xf6\x55\x09\xea\x18\x20\x8c\x51\x6e\x90\x9f\x3a\xcc\x8a\x2b\x34\x6c\xe4\x19\xe5\x90\xc5\x01\x5d\xe9\xbb\x5a\xb6\x54\x5c\x36\x3f\x4e\x0d\xad\x16\xba\x43\xa6\x32\x19\x04\xef\xcb\x6e\x9e\x93\x66\x8a\xe6\xe8\x43\xef\x1c\x31\xc1\x65\x2c\x40\x2d\x80\xa1\x22\x12\x0a\x97\x67\x2f\xaa\x32\x28\x91\xf9\xcf\x57\x19\xc0\x6e\x50\xe6\x1f\xb7\xb2\x2f\xf3\xb1\x07\x08\x2d\x3d\xe4\x9f\x5a\xb6\x76\x05\x68\xfc\xa2\xfb\x84\x19\xc3\xaa\x68\xe9\x16\xd9\x98\x0e\x61\x5d\xbd\x2a\xce\x5b\x26\x80\x0e\xd3\x16\x63\xc3\x44\x37\xd1\xcc\x30\xd9\x83\x25\x23\x95\xb7\x36\x13\xcb\x8a\x79\xdc\x52\x33\x63\xe0\xb1\xca\xc0\xda\xfe\x91\x93\xc5\x4b\x29\xc4\x9d\x68\x8f\x83\xe6\x71\x7d\xe3\xa9\x06\xb7\xa3\x18\x9e\x57\x42\x54\xdc\x57\xde\x57\x77\x9d\xb3\x6d\xfc\x6f\xf1\x1c\x88\x63\xd9\xe0\x74\x23\xe1\x81\xfb\x5c\xce\x45\x29\x4f\xef\xef\x6a\xd3\x66\x33\x13\x0c\xe9\x52\xb0\xf0\x96\x1d\x43\xc6\xd2\x90\xed\x32\x49\x13\xaa\xdb\x4c\x75\x26\x22\x43\xcc\x36\xa8\xc6\x57\xff\x02\x4d\x54\x0f\x29\x75\x54\xfd\xaa\x66\x12\x16\x39\xa2\x5c\x69\x6a\x4b\x88\xbb\x46\x84\xf6\x03\x6d\x77\x7e\xd9\x3b\xfb\x08\x4a\xc8\x40\x97\x4e\x8c\x50\x0a\x4e\xe2\x74\xc7\x12\x5d\xa1\xe5\x82\x97\x38\x59\xea\x36\x48\x2b\x6c\x5c\x99\xd1\xa5\x5e\x51\xe2\x77\xab\xc3\x95\x24\x1b\xcf\x3e\xaf\x2e\x3f\x86\x29\xa0\x7d\x76\x98\x39\x9a\x60\xae\x2a\xab\x89\x3a\x60\xc4\x27\x7d\x5a\xcc\x7a\x14\xbf\xae\xf0\x2a\x98\x3d\xe7\xc9\xf0\xe7\xf0\xb6\x03\x93\x6a\x55\x39\xa9\x7e\x1c\xec\x89\xf4\x1e\x8a\x3a\x64\xa1\x2e\xa5\x67\xdd\x7e\x4d\x77\x44\xda\x98\xf1\xce\xb9\x4e\x23\xed\xe5\xe6\x53\x83\x1f\xb0\xbe\xeb\x31\x17\xcf\x0f\xb2\xf0\xdc\xc6\xc9\x9d\x77\x4a\x6e\x75\x59\x99\x1d\x3c\x70\x8b\xd0\xd9\xbd\x5f\x9c\x71\x58\x14\x2a\xd6\xd0\x3e\x01\x91\x49\xd2\x7b\xb1\xb7\x01\xae\xeb\x4b\xd4\x4d\xa0\x68\xe4\x85\x8b\x69\xac\x2a\x5d\x5e\x15\xf1\x5c\x41\xc2\x1b\x68\x66\x9e\x35\x36\xce\x56\xb6\x8d\xf6\xe3\x91\xb7\x4f\x53\xcd\x7c\x79\xbb\xd7\xd0\xbf\x7c\x0b\xe2\xd1\x43\x99\x06\x89\xe9\x56\xb7\xe6\x75\x86\x2b\x6e\x52\x10\xdf\x8f\x31\xe8\x34\x82\x08\x1f\x84\x48\x88\x39\xc5\x92\xc6\x7a\x38\x87\xef\xee\x53\xd7\x0b\x03\xb7\x3c\xfd\x6b\xe7\x30\xde\x98\xcc\x48\x2d\x08\xbb\xa5\xe0\x23\x73\xb1\x90\x05\xd2\x98\xb8\x67\x54\x85\x35\x1a\x3d\x8e\xc2\x79\x16\xbb\x9a\xd4\x44\x55\x01\xbe\x30\x26\x2e\x4f\xa7\xee\x30\x61\xd7\x86\xab\xeb\x81\x78\x02\x9a\x0d\xc6\x1b\x5d\x82\x35\x35\x9a\x09\x8f\xdd\x37\x89\x57\xf9\x9a\x0b\xd2\xe3\x15\x12\xcc\x67\x9c\x7b\x18\x71\x3f\xf9\xc6\x43\xac\x53\xd1\x43\xa5\xc0\x02\x23\xbb\x99\xfe\xf8\x98\x9a\x27\x8e\x82\xae\x90\xcc\x93\xc5\xcb\x47\x63\x97\x01\x98\xe1\xa1\x9a\x43\xcb\xc0\x3e\xea\x48\x68\x13\x37\xd5\x0f\xf6\xd6\x64\x61\xfe\xb4\xf4\xe0\x0c\x9f\x55\xff\x8d\x64\xcf\x0f\x04\x3e\xfe\x65\x80\xe2\xc6\x1b\xa3\x03\xfb\xd6\xf6\xf2\xbe\x25\x80\xdb\x1c\x5f\x0a\xd7\x75\x76\xd4\x7b\xed\x2a\x4d\x57\x72\xab\x8a\x8e\x7f\x63\x87\xba\x55\x39\x0f\x07\x89\xef\xb6\xb3\x4c\xaa\x2a\xd4\x24\xdb\x53\x5e\xe6\x1f\xb4\xab\x3d\x87\x5f\x04\x68\x5d\x18\x47\xa1\xca\x11\xb8\x3c\x2b\xf7\xe6\x21\xc1\xba\x86\x99\xc8\xaf\xbe\x2f\xb2\x02\xd5\xab\x63\xd4\x3a\x7a\x95\x64\x72\x79\x79\x65\xa8\x04\xf1\x0a\xab\x20\x61\xc8\x99\x8f\xd8\x1b\x1e\x97\xae\x54\x1a\xaf\xff\xbd\x6d\x0e\x3a\x30\x29\xbb\x2f\x30\xcd\x0d\xe9\x9b\xd1\x11\x8a\x61\xf6\x38\x1f\x11\x15\x33\xee\x75\x42\x82\xca\x11\x6a\xf5\x38\x77\x74\xb1\x57\x3b\x2a\x6d\xf5\xa4\x43\xdd\x02\x9a\x1b\x3c\xc6\xe9\xf8\x71\x07\x28\xf0\x1b\xd4\xa0\xd9\xe6\xaf\x5d\x4d\xb2\x43\x18\x99\xb2\x88\xa6\x81\x9d\xb0\x6c\x72\x4c\xe0\x11\x91\x4c\xf0\x11\xd4\x1a\x15\x60\x62\xf3\xef\x99\xfe\x60\xa3\xb9\x5e\x0d\x65\x48\xcd\xa4\x83\x74\xfe\xee\x66\xe0\xcc\x7d\xe3\xd7\xa5\x64\xc0\xc8\x36\x0d\x2f\xd1\x15\xd5\x77\x86\xe6\xa2\x3a\x88\x47\xe7\x89\x65\x0f\xa6\xa3\xe0\xb8\x73\x6b\x1b\x42\xeb\xa9\xd2\x9f\x3b\xcc\x70\x4c\x3c\xe8\x83\x10\x36\x6c\x0d\x15\xa8\x32\x44\xa7\x86\xb5\x4c\xc6\x71\xc3\x99\x70\x80\xa2\x6b\x1f\xff\x0a\x6e\x95\x77\x55\x64\x41\xa0\xd2\x58\xa4\x19\xb5\x5a\x58\x7c\x24\x5d\x66\xbe\xb8\x20\x3a\xe1\x82\xd8\x78\xd2\x4c\xd5\xde\xe8\xe5\x0a\x43\x06\x1c\x54\x81\x2b\x41\xf6\xd3\xbb\x16\x6b\x8f\x20\xf7\x5d\x86\x8c\x7a\x7a\x58\x0d\xd3\x87\x57\x14\xa9\xf2\xc9\x17\xe2\xcb\xed\x03\x57\x8e\x82\x61\xaf\xe6\x64\x6f\xeb\x4a\x5c\x6d\xa5\x05\x90\xfd\x40\x81\xe8\xe9\xfd\x87\xd2\xa0\x72\x47\xb5\xa0\xcb\x0f\x75\xbf\xca\x15\x3c\x1e\x5d\x44\x5f\x78\x16\xc1\x80\xc2\x2c\x14\x22\x4e\xe7\x31\xa9\x49\x0e\x97\x5a\x5d\xa7\xad\xf6\x74\x67\x5f\x0d\x45\x53\x0d\x17\xbb\x93\x21\x0f\x7f\x87\x2a\xec\x76\x3e\xe3\x11\xf9\x54\x89\x25\x09\x11\x39\x13\xbf\xd4\x09\x72\x14\x26\xd8\xa6\x68\xd6\xc8\x78\x48\xe7\xd6\xfc\x0c\x40\x64\xca\x83\x69\x54\x35\x99\xc1\xf6\xf7\x5d\x29\xcc\x66\x9f\x7f\x63\x17\xf5\xf1\x8d\x75\x4a\xec\x3d\x78\xaa\xec\x9b\x6b\xdf\x04\x86\x62\xa2\x0f\x44\x41\x9b\x8f\x34\x99\xdd\x45\xee\xc4\x03\x8d\x92\x15\xd9\x10\xc0\x30\x07\xc4\x81\xcf\x11\x82\x81\x1c\x83\xdf\x60\x22\xf6\x2c\xf0\xd3\x3c\xca\x6c\x16\x56\x8f\x94\x15\xe9\xc7\xfa\xe0\x1a\x38\xae\xe7\xfd\x4b\x46\xa7\x28\xe5\xb0\x6d\x24\x08\xfd\x8d\x52\xb6\xa1\xc0\xb6\xc3\x44\xb7\x65\xdf\x1b\x82\x42\x9e\x6e\xff\x87\xb7\xff\x77\x49\x97\x82\xa6\x7a\x9b\x54\x5c\x0b\x0d\x80\xc3\x0a\xda\x3e\x17\x2b\xb8\x85\xf4\xd8\x1d\x78\x75\x0c\x21\xf2\x1d\x0f\x2a\xa4\x1f\x5d\x1a\x8b\x20\x68\x78\x17\x51\x1c\x23\xe3\x47\x31\x08\x5f\x1e\x27\x6b\xf0\xf0\x06\x76\x80\xcd\x8f\xa1\x47\x9b\x22\x65\x1c\x5b\x36\x45\xb7\x70\xe9\xf4\x9b\x64\xd2\x9a\x69\xf3\x1a\xb1\x62\xda\xc6\xe8\x3e\x18\x56\x04\x41\x52\x19\x85\x56\x3a\xd2\x52\x3b\x16\x57\x5c\x46\x53\x5d\x01\x20\x3f\xf9\x4b\x7f\x16\x6d\x80\x4e\x71\x9e\x89\x75\xa2\xc2\x71\xbd\x86\x74\xc4\xc6\x70\xd9\x01\x38\x03\xf6\xdf\xde\xd9\xf9\xbf\x05\xf8\xef\x26\x3f\xf0\x71\x55\x6d\xcc\xb6\xd8\x14\xef\x1a\x1c\xdf\x5c\x0c\x9f\xee\xfc\x81\xf5\x65\x5e\xe6\x0f\xe7\x42\x94\x58\xc0\xa2\x02\xdb\x0e\xf4\x89\x9d\x26\xfb\xd1\x07\x5f\x88\x60\x63\x98\x61\xe7\x3f\x07\x37\xb0\x3f\x12\xb4\x7f\x80\x50\x18\xff\xdb\x42\xfb\x0f\x2e\x10\x64\x08\x28\x81\x03\xff\x10\xa8\x90\x62\xfa\xf7\xae\x61\x28\xe8\x21\xf2\x95\x6d\x7e\xc2\x25\x0d\x1f\x39\x7b\xf9\x06\x2a\x53\xa5\x4a\x5b\xb8\x86\xa8\x16\x2f\x5b\xbb\x7b\x07\x81\xcc\x5b\xb4\x1d\x7e\x85\x2d\x1c\x3e\xde\x3c\x7b\x43\xfe\x97\x27\xe8\xe4\xce\x18\x37\xac\x12\xb1\xc4\xb1\x7e\x8f\x1c\xc2\x28\x97\xaf\x51\xae\x58\x24\xa8\x56\x74\x62\xcb\x9c\xc2\xa9\x9c\xbe\x74\xee\xd8\x24\xa9\xcd\x03\x1a\x91\x61\x45\x50\xab\x66\xe8\xff\x55\x2f\xe7\xd6\xcd\x21\x81\x20\xc7\x13\x65\xcf\x26\xa3\xcf\x34\xe1\xfb\x3f\x13\x3c\xfd\xfc\x83\x11\x2d\xf4\xa5\x8b\x63\xdc\x49\xb2\xb0\xa1\x17\x1a\x0c\x1c\x47\xf7\x1f\xe8\x7b\x71\x20\xd0\x69\x92\x5d\xc8\x85\x80\x08\x85\xbc\x2a\xeb\xab\x5c\x93\x51\x0d\x15\x59\x2d\xe0\x30\x97\xcc\x34\xf7\x8d\xb8\xbb\x8e\xbc\x27\x37\x08\x84\x7e\x84\xc8\x5d\x18\x19\x10\xca\xe4\xcd\x1f\xba\xf1\xc8\x8a\xd3\x50\x9b\xb5\x58\xf0\x8b\x28\xde\xb0\x4c\xe6\xa1\x84\xce\x92\xc2\xc6\xc3\x20\xef\xf4\x64\xc7\xc5\xa8\xd7\x56\xde\xf1\x1b\x14\x19\x0c\x25\x5d\x28\x26\x95\x04\x27\xd3\x28\x72\x01\x15\x63\x45\x09\x61\x89\x85\x40\xcd\x31\xbc\x09\x16\xed\xff\xc6\x4f\x3a\xc3\x4a\x9e\xbe\xe4\x40\x6f\xed\xaa\xe3\x6d\x9a\xf9\xc9\x49\x70\xc1\xb9\xad\x16\x2b\x6d\x6c\x20\x3a\xa0\xe0\xc9\x2e\xda\x50\xf3\x5b\xd8\x20\x30\xfc\x95\x3b\xc7\x36\x30\xc7\x90\x58\xf2\xd0\xa6\x59\x5d\x1f\xc8\x2b\xe1\xbb\x90\x12\x51\x6f\x94\x64\xb1\x74\xe5\x24\xed\xa3\x11\x1b\x37\x94\xff\x51\xaa\x7e\x4a\x23\xff\x97\x99\xf3\x9f\x8a\xd6\xb4\x63\x77\xe2\x62\x11\x14\xba\x3b\xec\x27\xb8\x19\xbe\x32\x56\xa1\xf9\x33\x21\xbc\xf7\x95\x01\x69\xa3\xb8\xb5\xb0\xe2\xb2\xa0\xa5\x52\x7c\x73\x99\x91\x24\x9c\xba\xd3\x56\xe0\xc4\xf4\xdf\x74\x4d\x3e\x3c\x2d\x99\x0e\x5a\x83\xf0\x37\xba\xd5\xbc\x54\xae\xd8\x4b\x64\x5c\x8f\x3b\x03\x5f\xdc\x7b\xd2\xe7\x2a\xd6\x8c\x81\xb7\x50\x59\x2d\xca\xb1\x22\x88\x91\x07\x5d\x33\x13\xc0\x50\x7f\x6e\x78\x62\xe7\x0f\x5a\x5e\x7e\x9f\x6d\x3f\xb2\x84\x75\x45\xe2\xf3\x07\xaa\x3f\xbc\xc5\x4e\x89\xe9\x98\x2a\xbe\x5a\x81\xbd\xb9\xef\x64\x73\x0e\x4a\x8e\xf2\xad\x58\xf4\xcf\xd1\x2a\x86\xe4\xc4\x5a\xd9\x75\x62\x0a\xbc\x61\x7e\xfc\x8a\x71\xd6\x1b\x09\x66\x34\x5c\x6b\x39\x2e\x2d\x4e\xf1\x01\xbd\x25\x46\x97\xcb\x22\xa9\x9e\xdb\x11\x84\x90\x6f\xe3\xf1\x9d\xc3\xdc\xb0\x0d\x57\xa1\x63\xeb\xdf\x54\x5a\x19\xb1\x52\xe1\x7e\x5e\x31\xe8\xaf\x43\xf6\x1b\x40\x47\x79\x20\x2e\xbe\x8a\x91\x0f\x6a\x81\x06\x0d\x29\x7e\x7b\x79\x8c\x6c\x3b\x7e\xce\xdd\xc2\x87\x0c\x1c\xa5\xa1\x5b\x9c\x57\xb2\x82\x9f\x37\x55\x2b\x84\xd2\x8d\x7b\x09\x5a\x2e\x19\x8a\xf7\x42\xb9\x4d\x3f\x64\x6b\x60\x40\x4f\x89\x39\xde\xb5\xd0\x0a\x1e\xba\x15\x81\xcf\x24\x8a\x88\xd6\x5b\xfd\x28\x9f\xca\x08\xa8\x2a\x19\x80\x80\xed\x26\xac\xe5\x5d\x9c\x60\xe6\xee\xbd\xf8\xec\xbf\x12\xf3\x3b\x56\x8f\x5d\x71\xd9\x90\x6b\x62\xc5\x1c\x7c\x13\xb7\x0c\xda\x3b\x5b\x01\x98\x23\x4f\x97\x3a\x72\x6d\x1a\x76\x43\x34\xb0\xe2\xb7\x68\xd0\x31\x17\x08\xfa\x53\x5c\xb9\x15\xbf\xdf\x0d\xa6\xe1\x4d\x02\x3c\xe2\x98\x73\x51\xb9\x87\x68\x8c\xec\xc4\xaf\x23\x44\x46\x04\x82\x62\x6a\x65\xd8\x2d\x9b\xa7\x2b\x1b\x7d\x66\xc4\x22\xf5\x86\xe3\x74\xfc\x24\xca\xa1\x03\x3d\xb1\xcd\x1f\xd4\x66\xf9\xc6\xc3\xc2\x37\x3f\x44\xee\xfd\x1b\x3a\xa8\x48\xae\xd2\x8c\x83\xe4\xde\x37\x95\xdb\x0a\xef\x60\xd3\xe5\xfc\xc6\xee\x13\x27\x84\x60\x13\x3d\x7e\xe1\xc6\x2c\x7d\xea\xaa\x22\x01\x95\x3b\xca\xad\x7d\x4a\xa9\xeb\x72\x7b\x75\xcd\x67\x33\x8e\x68\x49\x5b\x4c\x6d\x4a\xd0\x21\x83\xbc\xdc\x98\xe5\xac\x95\x92\x07\xbb\x72\x1f\x09\x20\x96\x70\x59\xde\x8f\xc8\xf4\x02\xb8\x58\xa9\xd9\xbc\x52\x0c\x16\x7d\xb1\x76\x49\xe9\x42\x92\x8f\xe3\x2a\xc5\x73\x9e\x66\x60\x7f\x4c\xfe\xa6\xcb\x15\x8f\x59\xc0\x06\x77\xb4\xdf\x12\x53\xdc\x98\x0d\x1f\xe6\x59\x7a\x84\x86\xf3\xd6\x37\x2b\x5a\x15\x28\xe3\x26\x3b\xbc\x25\x10\x85\x79\x9b\x5f\x3a\xa1\x30\x0c\x15\xd8\xf2\x58\x9f\x46\x38\xce\xd8\xe8\x41\xce\xf9\xad\xd8\xe8\x20\xc9\x9f\xac\xd5\xdf\x48\xc4\x5a\xbe\xf3\x6d\xdd\x11\x58\x48\x76\xf0\xee\x17\x9a\x7f\x8c\x16\x26\xad\x28\xdd\x15\xd8\xe5\x89\xa4\x39\x27\x0f\x5c\x80\x29\x89\x7f\xe8\xbf\xe1\x97\x1f\xd0\x42\x29\x38\xc1\x7d\x0a\x35\xd1\xc3\x96\x7e\x73\x1f\x8a\x97\xe8\xfe\x21\xcc\x7f\x36\xfd\xca\xa3\x62\xef\x14\x92\x55\x31\x85\x9d\xcc\xd3\x7c\x1f\x6f\x50\xaa\xcb\x40\x56\x44\x7f\xf0\x6d\xb2\xcd\x6e\x1c\x12\x7d\xb9\xf7\x39\xfe\xa1\xff\x94\x6c\x8b\x35\xd4\x1c\xc8\x43\x74\xf9\x4d\x65\x85\x70\x7e\x0c\x20\x1e\x1f\xb0\xec\x59\xf1\xb8\xbf\x4f\x6b\xe1\xc5\x7f\x37\x41\x2a\xf7\x71\xd5\x81\x2d\x66\xa2\x10\xb8\xd1\xbd\xa4\x4e\xf3\xe1\x6e\x39\x0b\x56\x0f\x1c\x87\xd9\x9f\xf2\x34\x0a\xac\xed\xc9\xc4\xed\xd0\xfa\x14\x1f\xa6\xf7\xe1\x3e\x53\x96\x05\x64\x89\xb6\xc0\x86\x4e\x5d\xb5\xa2\x04\x71\x04\x75\x78\x68\xa5\xba\x24\xbf\x39\x31\x8b\x35\x5d\x59\x31\x24\xcd\xef\x2c\xae\xfd\x24\xb4\xf8\xfa\x76\x9f\x16\xb9\x32\x64\x8b\x6c\x48\xb1\xe5\x7f\xc5\x75\xe2\x23\x60\xe9\xc4\xdc\xad\x75\x0b\x0c\x4a\x62\xf0\x28\xd4\x3a\x60\x6f\xf3\x19\x9e\xc4\xb8\xf3\x5d\x1a\x7a\xbc\xb1\x2b\x67\x51\x69\xd3\xa5\x18\x79\x47\xd2\xbe\x65\xbe\x4f\x3c\x91\x1d\xfb\x4c\x64\xf5\xaf\xc6\x3f\x9a\x45\x49\xff\x40\xdb\xdc\x68\x8e\x33\x77\x6e\x4b\x10\xb8\x81\x10\xd4\xaa\xa9\x87\x1a\xbe\xe1\x5a\x52\x58\x54\xeb\x7a\x40\x63\xdd\xbc\x65\x2c\x97\x70\x4c\x02\x37\x2f\xaf\x36\x1d\xb1\x5d\x08\xa4\xc7\x0a\xb5\x82\x15\x2b\x1e\x40\xc4\x3e\xe9\x9c\x31\x1f\x95\x45\xe4\xbd\x2a\xf4\x7c\x06\x42\x54\x7e\x49\x99\x27\xdb\xcd\xe3\x4b\x53\x1c\xfb\x68\x69\xc3\xb8\x59\x72\x44\xdd\x05\xca\x98\xc4\x56\x74\x1b\x95\xca\x3a\x09\xf4\x76\xc7\x47\x71\x99\xf9\x96\x98\x08\x49\x4c\x35\x7e\xaf\x16\x72\x50\xef\x8b\x96\xd6\x8b\x78\x7d\x68\x94\x68\xa7\xcd\x0c\x41\x9c\x5a\xff\xa2\x2a\xaa\x45\x19\xdf\xdb\x82\xcf\x36\x10\x3c\x7f\xbd\xe7\x5b\x5a\xe0\xb4\xa6\x33\xa2\xbf\x31\x6e\x32\xa5\xd7\x5b\xaa\xbb\x5e\xfa\xdb\x82\xdb\x6e\xe8\x11\x6f\xc3\x3a\xf4\xd4\x71\x1c\x13\xa7\x77\x4f\x18\xf6\x2f\xe2\xb8\x9c\xc7\xae\x42\x0c\x4a\x9f\x3a\xb4\xd8\x47\x1b\xf3\xa8\x51\x5a\x2c\x9b\x4a\xb9\x19\xbc\x3e\xaf\x47\x8e\xaf\x9e\xb4\x08\x11\xf7\x23\xef\x11\x45\x74\x56\xf9\xfc\x33\xde\x4f\x2b\xce\x06\xa3\x9e\x76\x57\xc7\x83\xd3\xd5\x71\xb9\x57\xb5\x67\xd7\x1a\x6d\x8c\x62\x71\x5d\x28\xc9\x3e\x09\x04\x72\xde\xb7\xd0\xc0\x21\x13\x72\x74\xc4\xd5\xdc\x3c\xd5\x7c\xf2\x6f\xa8\x92\x2a\x53\x10\xac\xef\x01\xaa\x23\xb7\x57\xf2\xd0\x75\x7f\x25\x24\x68\x54\x91\xbd\x4b\x87\x94\xde\x25\x08\xe5\x7a\xe6\x98\x73\x54\xfc\x74\xd2\x50\xed\x60\x7f\x6d\xfd\x3b\xfc\x86\x10\x72\x51\x94\x55\x37\x73\x53\x02\xb9\xeb\xe2\xa6\x44\x28\x6f\xf6\x24\x85\x5f\x84\xc6\x31\x7e\x59\xd8\xfb\xdd\x7a\x7e\x7c\x13\xb6\xd3\x71\xaf\xa2\xb3\x94\x8c\xdf\x18\x01\x21\x7f\xb9\xb8\x70\x97\x2a\x2a\xf3\x36\x21\x60\x75\x34\x1d\xa0\x01\xaa\x72\x25\x4a\xae\x9b\x34\x92\xfd\x52\x21\xf7\x90\x0d\x49\x2b\x28\x0f\xab\xe0\xe7\x79\x58\x9a\x71\x98\x3b\xee\x88\xb3\xc6\x7f\xa0\xae\x03\x9b\xe6\xb5\x70\x35\x61\xd4\xcd\xee\x20\x26\xaa\x87\x29\x2c\x7e\xd6\x18\x41\x15\x72\xea\xdb\x0e\x78\x67\x9c\x49\xba\xb1\x5b\x3d\xb2\xa0\xbf\x9b\xc1\xc6\x9a\xe6\x44\x4b\x65\x99\x03\x39\x54\x75\x8c\x21\x9d\x2e\xe6\x05\x86\x16\x1f\x5b\x43\x2b\x39\xdc\x0b\xd3\xa9\xdb\x7d\x32\xda\x0c\x5d\x03\xda\xe9\x8d\x19\xaf\x7f\x1d\x13\x63\x37\x6f\x34\xe6\x44\xfd\x83\x7d\x01\x6d\x01\x9e\x24\xdd\x84\x22\x48\xf3\xd7\xc4\xdc\xc5\xae\xbb\x7d\xb6\xc5\x58\x96\x84\x08\x75\x79\xed\x34\xfb\x74\x2c\x60\x42\x13\xf1\x57\x8d\x1f\x17\x6b\x8c\x74\x22\xce\x92\x0a\x35\xdc\x45\xe6\x6c\xfa\x82\x55\x09\x7d\xf9\x13\x7e\xc3\x62\x19\xce\x79\xd5\x2e\x52\x57\xa6\x47\x3d\xfc\xf1\x63\x59\xf8\x4d\xaa\xce\xa5\x14\xd6\x3d\x00\xcd\x62\xe0\xe2\x52\xac\xcb\xfc\x8b\x85\xd0\xe3\xb4\xc6\x22\xfc\xc1\xa6\x7b\x7d\x30\x80\x30\xa1\xb7\xa9\xef\xc8\xe9\x2d\xb6\x9d\x7f\xe0\x95\xf0\xc8\x92\x95\x84\x5d\xc6\x57\x72\xcb\x74\xaf\x05\x73\x7f\x4d\x7c\x5e\xfb\x2b\x6e\xef\x10\x5e\x4c\xa2\x6a\x1a\xe8\x93\xfb\x15\xa5\xf1\xc6\xac\xe8\xf9\x79\x70\xd7\xce\x16\xe5\x11\x99\x1a\xc3\xb3\xe1\xaf\x41\xd4\xed\xef\xc7\xe2\xf9\x5c\x16\x9f\x7b\xf5\x62\xb6\xb6\x60\x79\x9e\x4b\x0e\x89\x5d\xcf\xf3\xe4\xd9\x2d\xbc\xe7\x97\x0b\x0d\x01\x01\x81\xac\x25\x2a\x2e\x68\xb3\x01\xe6\x7c\xbf\x6d\x59\x69\xa2\x8f\x13\xbe\xf7\x55\x19\x6a\x8d\x39\xf2\x5f\x7f\x8d\x4c\x0e\x45\x0d\x89\xd4\xce\xaa\xef\x14\x83\xda\xbe\x78\x7f\xde\x9e\xb9\xf2\x1b\xb8\xdb\x11\x14\x8d\x13\xc6\xca\x2f\x38\x84\x5e\xb9\x9a\xc5\x0f\xe1\x31\x43\x85\x50\x1f\x5a\x9f\x12\xb0\xab\xde\x7a\xcc\xa2\x04\xb0\xf8\x00\xcc\x6a\xce\x0a\x78\xb3\x61\xd4\x87\xd6\xdf\xb7\x16\x3e\x8c\xb2\xf6\xdf\xa7\xb8\x7e\xff\x4f\x1f\x81\x1f\x50\x0c\xa6\x0e\x23\x97\xd1\xa7\x94\x14\x14\x14\x0c\xc5\xc9\xaa\xb2\xf4\x12\xe2\xe2\xe2\xe2\x43\x53\x53\x53\x53\x59\x40\xbe\x8a\x52\xc0\xf4\xf2\xe8\x4f\x4e\x5d\xbb\x6a\xab\x40\x4c\xf4\xff\x01\x0a\x2c\xb3\xf6\x7e\x8c\xec\x25\xfa\x68\x8d\xfe\xfc\x49\xb3\x5d\xeb\xc1\x12\x3b\xb8\xab\x93\xa5\xf8\x32\x19\xb5\xd4\x83\xdf\x69\x25\x2d\x22\x51\x35\xbd\x4a\xfc\xff\xef\x8a\x8b\x79\x7c\xc0\xf1\xc7\x37\x4d\x71\xdd\x6a\xea\xcf\x1b\xf3\xde\x18\x37\x10\xff\x0f\xcb\xff\xd0\xd4\xf8\x8f\x46\x9b\x8e\x0e\x1f\xef\xb7\x92\xa4\xec\x80\x60\x9e\x6e\x45\xf3\x6a\x48\x88\xff\x17\x00\x00\xff\xff\xa7\xc3\x17\x55\x68\x2d\x01\x00") + +func uiAppLibFontAwesome470FontsFontawesomeWebfontWoff2Bytes() ([]byte, error) { + return bindataRead( + _uiAppLibFontAwesome470FontsFontawesomeWebfontWoff2, + "ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.woff2", + ) +} + +func uiAppLibFontAwesome470FontsFontawesomeWebfontWoff2() (*asset, error) { + bytes, err := uiAppLibFontAwesome470FontsFontawesomeWebfontWoff2Bytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.woff2", size: 77160, mode: os.FileMode(420), modTime: time.Unix(1, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +// Asset loads and returns the asset for the given name. +// It returns an error if the asset could not be found or +// could not be loaded. +func Asset(name string) ([]byte, error) { + cannonicalName := strings.Replace(name, "\\", "/", -1) + if f, ok := _bindata[cannonicalName]; ok { + a, err := f() + if err != nil { + return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err) + } + return a.bytes, nil + } + return nil, fmt.Errorf("Asset %s not found", name) +} + +// MustAsset is like Asset but panics when Asset would return an error. +// It simplifies safe initialization of global variables. +func MustAsset(name string) []byte { + a, err := Asset(name) + if err != nil { + panic("asset: Asset(" + name + "): " + err.Error()) + } + + return a +} + +// AssetInfo loads and returns the asset info for the given name. +// It returns an error if the asset could not be found or +// could not be loaded. +func AssetInfo(name string) (os.FileInfo, error) { + cannonicalName := strings.Replace(name, "\\", "/", -1) + if f, ok := _bindata[cannonicalName]; ok { + a, err := f() + if err != nil { + return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err) + } + return a.info, nil + } + return nil, fmt.Errorf("AssetInfo %s not found", name) +} + +// AssetNames returns the names of the assets. +func AssetNames() []string { + names := make([]string, 0, len(_bindata)) + for name := range _bindata { + names = append(names, name) + } + return names +} + +// _bindata is a table, holding each asset generator, mapped to its name. +var _bindata = map[string]func() (*asset, error){ + "ui/app/script.js": uiAppScriptJs, + "ui/app/index.html": uiAppIndexHtml, + "ui/app/favicon.ico": uiAppFaviconIco, + "ui/app/lib/bootstrap-4.0.0-alpha.6-dist/css/bootstrap.min.css": uiAppLibBootstrap400Alpha6DistCssBootstrapMinCss, + "ui/app/lib/bootstrap-4.0.0-alpha.6-dist/css/bootstrap.min.css.map": uiAppLibBootstrap400Alpha6DistCssBootstrapMinCssMap, + "ui/app/lib/font-awesome-4.7.0/css/font-awesome.css": uiAppLibFontAwesome470CssFontAwesomeCss, + "ui/app/lib/font-awesome-4.7.0/css/font-awesome.min.css": uiAppLibFontAwesome470CssFontAwesomeMinCss, + "ui/app/lib/font-awesome-4.7.0/fonts/FontAwesome.otf": uiAppLibFontAwesome470FontsFontawesomeOtf, + "ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.eot": uiAppLibFontAwesome470FontsFontawesomeWebfontEot, + "ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.svg": uiAppLibFontAwesome470FontsFontawesomeWebfontSvg, + "ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.ttf": uiAppLibFontAwesome470FontsFontawesomeWebfontTtf, + "ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.woff": uiAppLibFontAwesome470FontsFontawesomeWebfontWoff, + "ui/app/lib/font-awesome-4.7.0/fonts/fontawesome-webfont.woff2": uiAppLibFontAwesome470FontsFontawesomeWebfontWoff2, +} + +// AssetDir returns the file names below a certain +// directory embedded in the file by go-bindata. +// For example if you run go-bindata on data/... and data contains the +// following hierarchy: +// data/ +// foo.txt +// img/ +// a.png +// b.png +// then AssetDir("data") would return []string{"foo.txt", "img"} +// AssetDir("data/img") would return []string{"a.png", "b.png"} +// AssetDir("foo.txt") and AssetDir("notexist") would return an error +// AssetDir("") will return []string{"data"}. +func AssetDir(name string) ([]string, error) { + node := _bintree + if len(name) != 0 { + cannonicalName := strings.Replace(name, "\\", "/", -1) + pathList := strings.Split(cannonicalName, "/") + for _, p := range pathList { + node = node.Children[p] + if node == nil { + return nil, fmt.Errorf("Asset %s not found", name) + } + } + } + if node.Func != nil { + return nil, fmt.Errorf("Asset %s not found", name) + } + rv := make([]string, 0, len(node.Children)) + for childName := range node.Children { + rv = append(rv, childName) + } + return rv, nil +} + +type bintree struct { + Func func() (*asset, error) + Children map[string]*bintree +} + +var _bintree = &bintree{nil, map[string]*bintree{ + "ui": &bintree{nil, map[string]*bintree{ + "app": &bintree{nil, map[string]*bintree{ + "favicon.ico": &bintree{uiAppFaviconIco, map[string]*bintree{}}, + "index.html": &bintree{uiAppIndexHtml, map[string]*bintree{}}, + "lib": &bintree{nil, map[string]*bintree{ + "bootstrap-4.0.0-alpha.6-dist": &bintree{nil, map[string]*bintree{ + "css": &bintree{nil, map[string]*bintree{ + "bootstrap.min.css": &bintree{uiAppLibBootstrap400Alpha6DistCssBootstrapMinCss, map[string]*bintree{}}, + "bootstrap.min.css.map": &bintree{uiAppLibBootstrap400Alpha6DistCssBootstrapMinCssMap, map[string]*bintree{}}, + }}, + }}, + "font-awesome-4.7.0": &bintree{nil, map[string]*bintree{ + "css": &bintree{nil, map[string]*bintree{ + "font-awesome.css": &bintree{uiAppLibFontAwesome470CssFontAwesomeCss, map[string]*bintree{}}, + "font-awesome.min.css": &bintree{uiAppLibFontAwesome470CssFontAwesomeMinCss, map[string]*bintree{}}, + }}, + "fonts": &bintree{nil, map[string]*bintree{ + "FontAwesome.otf": &bintree{uiAppLibFontAwesome470FontsFontawesomeOtf, map[string]*bintree{}}, + "fontawesome-webfont.eot": &bintree{uiAppLibFontAwesome470FontsFontawesomeWebfontEot, map[string]*bintree{}}, + "fontawesome-webfont.svg": &bintree{uiAppLibFontAwesome470FontsFontawesomeWebfontSvg, map[string]*bintree{}}, + "fontawesome-webfont.ttf": &bintree{uiAppLibFontAwesome470FontsFontawesomeWebfontTtf, map[string]*bintree{}}, + "fontawesome-webfont.woff": &bintree{uiAppLibFontAwesome470FontsFontawesomeWebfontWoff, map[string]*bintree{}}, + "fontawesome-webfont.woff2": &bintree{uiAppLibFontAwesome470FontsFontawesomeWebfontWoff2, map[string]*bintree{}}, + }}, + }}, + }}, + "script.js": &bintree{uiAppScriptJs, map[string]*bintree{}}, + }}, + }}, +}} + +// RestoreAsset restores an asset under the given directory +func RestoreAsset(dir, name string) error { + data, err := Asset(name) + if err != nil { + return err + } + info, err := AssetInfo(name) + if err != nil { + return err + } + err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755)) + if err != nil { + return err + } + err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode()) + if err != nil { + return err + } + err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime()) + if err != nil { + return err + } + return nil +} + +// RestoreAssets restores an asset under the given directory recursively +func RestoreAssets(dir, name string) error { + children, err := AssetDir(name) + // File + if err != nil { + return RestoreAsset(dir, name) + } + // Dir + for _, child := range children { + err = RestoreAssets(dir, filepath.Join(name, child)) + if err != nil { + return err + } + } + return nil +} + +func _filePath(dir, name string) string { + cannonicalName := strings.Replace(name, "\\", "/", -1) + return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...) +} diff --git a/src/alertmanager/ui/web.go b/src/alertmanager/ui/web.go new file mode 100644 index 0000000..049ef33 --- /dev/null +++ b/src/alertmanager/ui/web.go @@ -0,0 +1,94 @@ +// Copyright 2015 Prometheus Team +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package ui + +import ( + "bytes" + "fmt" + "io" + "net/http" + _ "net/http/pprof" // Comment this line to disable pprof endpoint. + "path/filepath" + + "github.com/go-kit/kit/log" + "github.com/go-kit/kit/log/level" + "github.com/prometheus/client_golang/prometheus/promhttp" + "github.com/prometheus/common/route" +) + +func serveAsset(w http.ResponseWriter, req *http.Request, fp string, logger log.Logger) { + info, err := AssetInfo(fp) + if err != nil { + level.Warn(logger).Log("msg", "Could not get file", "err", err) + w.WriteHeader(http.StatusNotFound) + return + } + file, err := Asset(fp) + if err != nil { + if err != io.EOF { + level.Warn(logger).Log("msg", "Could not get file", "file", fp, "err", err) + } + w.WriteHeader(http.StatusNotFound) + return + } + + w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate") + http.ServeContent(w, req, info.Name(), info.ModTime(), bytes.NewReader(file)) +} + +// Register registers handlers to serve files for the web interface. +func Register(r *route.Router, reloadCh chan<- chan error, logger log.Logger) { + r.Get("/metrics", promhttp.Handler().ServeHTTP) + + r.Get("/", http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { + serveAsset(w, req, "ui/app/index.html", logger) + })) + + r.Get("/script.js", http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { + serveAsset(w, req, "ui/app/script.js", logger) + })) + + r.Get("/favicon.ico", http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { + serveAsset(w, req, "ui/app/favicon.ico", logger) + })) + + r.Get("/lib/*filepath", http.HandlerFunc( + func(w http.ResponseWriter, req *http.Request) { + fp := route.Param(req.Context(), "filepath") + serveAsset(w, req, filepath.Join("ui/app/lib", fp), logger) + }, + )) + + r.Post("/-/reload", http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { + errc := make(chan error) + defer close(errc) + + reloadCh <- errc + if err := <-errc; err != nil { + http.Error(w, fmt.Sprintf("failed to reload config: %s", err), http.StatusInternalServerError) + } + })) + + r.Get("/-/healthy", http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(http.StatusOK) + fmt.Fprintf(w, "OK") + })) + r.Get("/-/ready", http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(http.StatusOK) + fmt.Fprintf(w, "OK") + })) + + r.Get("/debug/*subpath", http.DefaultServeMux.ServeHTTP) + r.Post("/debug/*subpath", http.DefaultServeMux.ServeHTTP) +} diff --git a/src/alertmanager/vendor/github.com/alecthomas/template/LICENSE b/src/alertmanager/vendor/github.com/alecthomas/template/LICENSE new file mode 100644 index 0000000..7448756 --- /dev/null +++ b/src/alertmanager/vendor/github.com/alecthomas/template/LICENSE @@ -0,0 +1,27 @@ +Copyright (c) 2012 The Go Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/src/alertmanager/vendor/github.com/alecthomas/template/README.md b/src/alertmanager/vendor/github.com/alecthomas/template/README.md new file mode 100644 index 0000000..ef6a8ee --- /dev/null +++ b/src/alertmanager/vendor/github.com/alecthomas/template/README.md @@ -0,0 +1,25 @@ +# Go's `text/template` package with newline elision + +This is a fork of Go 1.4's [text/template](http://golang.org/pkg/text/template/) package with one addition: a backslash immediately after a closing delimiter will delete all subsequent newlines until a non-newline. + +eg. + +``` +{{if true}}\ +hello +{{end}}\ +``` + +Will result in: + +``` +hello\n +``` + +Rather than: + +``` +\n +hello\n +\n +``` diff --git a/src/alertmanager/vendor/github.com/alecthomas/template/doc.go b/src/alertmanager/vendor/github.com/alecthomas/template/doc.go new file mode 100644 index 0000000..223c595 --- /dev/null +++ b/src/alertmanager/vendor/github.com/alecthomas/template/doc.go @@ -0,0 +1,406 @@ +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +/* +Package template implements data-driven templates for generating textual output. + +To generate HTML output, see package html/template, which has the same interface +as this package but automatically secures HTML output against certain attacks. + +Templates are executed by applying them to a data structure. Annotations in the +template refer to elements of the data structure (typically a field of a struct +or a key in a map) to control execution and derive values to be displayed. +Execution of the template walks the structure and sets the cursor, represented +by a period '.' and called "dot", to the value at the current location in the +structure as execution proceeds. + +The input text for a template is UTF-8-encoded text in any format. +"Actions"--data evaluations or control structures--are delimited by +"{{" and "}}"; all text outside actions is copied to the output unchanged. +Actions may not span newlines, although comments can. + +Once parsed, a template may be executed safely in parallel. + +Here is a trivial example that prints "17 items are made of wool". + + type Inventory struct { + Material string + Count uint + } + sweaters := Inventory{"wool", 17} + tmpl, err := template.New("test").Parse("{{.Count}} items are made of {{.Material}}") + if err != nil { panic(err) } + err = tmpl.Execute(os.Stdout, sweaters) + if err != nil { panic(err) } + +More intricate examples appear below. + +Actions + +Here is the list of actions. "Arguments" and "pipelines" are evaluations of +data, defined in detail below. + +*/ +// {{/* a comment */}} +// A comment; discarded. May contain newlines. +// Comments do not nest and must start and end at the +// delimiters, as shown here. +/* + + {{pipeline}} + The default textual representation of the value of the pipeline + is copied to the output. + + {{if pipeline}} T1 {{end}} + If the value of the pipeline is empty, no output is generated; + otherwise, T1 is executed. The empty values are false, 0, any + nil pointer or interface value, and any array, slice, map, or + string of length zero. + Dot is unaffected. + + {{if pipeline}} T1 {{else}} T0 {{end}} + If the value of the pipeline is empty, T0 is executed; + otherwise, T1 is executed. Dot is unaffected. + + {{if pipeline}} T1 {{else if pipeline}} T0 {{end}} + To simplify the appearance of if-else chains, the else action + of an if may include another if directly; the effect is exactly + the same as writing + {{if pipeline}} T1 {{else}}{{if pipeline}} T0 {{end}}{{end}} + + {{range pipeline}} T1 {{end}} + The value of the pipeline must be an array, slice, map, or channel. + If the value of the pipeline has length zero, nothing is output; + otherwise, dot is set to the successive elements of the array, + slice, or map and T1 is executed. If the value is a map and the + keys are of basic type with a defined order ("comparable"), the + elements will be visited in sorted key order. + + {{range pipeline}} T1 {{else}} T0 {{end}} + The value of the pipeline must be an array, slice, map, or channel. + If the value of the pipeline has length zero, dot is unaffected and + T0 is executed; otherwise, dot is set to the successive elements + of the array, slice, or map and T1 is executed. + + {{template "name"}} + The template with the specified name is executed with nil data. + + {{template "name" pipeline}} + The template with the specified name is executed with dot set + to the value of the pipeline. + + {{with pipeline}} T1 {{end}} + If the value of the pipeline is empty, no output is generated; + otherwise, dot is set to the value of the pipeline and T1 is + executed. + + {{with pipeline}} T1 {{else}} T0 {{end}} + If the value of the pipeline is empty, dot is unaffected and T0 + is executed; otherwise, dot is set to the value of the pipeline + and T1 is executed. + +Arguments + +An argument is a simple value, denoted by one of the following. + + - A boolean, string, character, integer, floating-point, imaginary + or complex constant in Go syntax. These behave like Go's untyped + constants, although raw strings may not span newlines. + - The keyword nil, representing an untyped Go nil. + - The character '.' (period): + . + The result is the value of dot. + - A variable name, which is a (possibly empty) alphanumeric string + preceded by a dollar sign, such as + $piOver2 + or + $ + The result is the value of the variable. + Variables are described below. + - The name of a field of the data, which must be a struct, preceded + by a period, such as + .Field + The result is the value of the field. Field invocations may be + chained: + .Field1.Field2 + Fields can also be evaluated on variables, including chaining: + $x.Field1.Field2 + - The name of a key of the data, which must be a map, preceded + by a period, such as + .Key + The result is the map element value indexed by the key. + Key invocations may be chained and combined with fields to any + depth: + .Field1.Key1.Field2.Key2 + Although the key must be an alphanumeric identifier, unlike with + field names they do not need to start with an upper case letter. + Keys can also be evaluated on variables, including chaining: + $x.key1.key2 + - The name of a niladic method of the data, preceded by a period, + such as + .Method + The result is the value of invoking the method with dot as the + receiver, dot.Method(). Such a method must have one return value (of + any type) or two return values, the second of which is an error. + If it has two and the returned error is non-nil, execution terminates + and an error is returned to the caller as the value of Execute. + Method invocations may be chained and combined with fields and keys + to any depth: + .Field1.Key1.Method1.Field2.Key2.Method2 + Methods can also be evaluated on variables, including chaining: + $x.Method1.Field + - The name of a niladic function, such as + fun + The result is the value of invoking the function, fun(). The return + types and values behave as in methods. Functions and function + names are described below. + - A parenthesized instance of one the above, for grouping. The result + may be accessed by a field or map key invocation. + print (.F1 arg1) (.F2 arg2) + (.StructValuedMethod "arg").Field + +Arguments may evaluate to any type; if they are pointers the implementation +automatically indirects to the base type when required. +If an evaluation yields a function value, such as a function-valued +field of a struct, the function is not invoked automatically, but it +can be used as a truth value for an if action and the like. To invoke +it, use the call function, defined below. + +A pipeline is a possibly chained sequence of "commands". A command is a simple +value (argument) or a function or method call, possibly with multiple arguments: + + Argument + The result is the value of evaluating the argument. + .Method [Argument...] + The method can be alone or the last element of a chain but, + unlike methods in the middle of a chain, it can take arguments. + The result is the value of calling the method with the + arguments: + dot.Method(Argument1, etc.) + functionName [Argument...] + The result is the value of calling the function associated + with the name: + function(Argument1, etc.) + Functions and function names are described below. + +Pipelines + +A pipeline may be "chained" by separating a sequence of commands with pipeline +characters '|'. In a chained pipeline, the result of the each command is +passed as the last argument of the following command. The output of the final +command in the pipeline is the value of the pipeline. + +The output of a command will be either one value or two values, the second of +which has type error. If that second value is present and evaluates to +non-nil, execution terminates and the error is returned to the caller of +Execute. + +Variables + +A pipeline inside an action may initialize a variable to capture the result. +The initialization has syntax + + $variable := pipeline + +where $variable is the name of the variable. An action that declares a +variable produces no output. + +If a "range" action initializes a variable, the variable is set to the +successive elements of the iteration. Also, a "range" may declare two +variables, separated by a comma: + + range $index, $element := pipeline + +in which case $index and $element are set to the successive values of the +array/slice index or map key and element, respectively. Note that if there is +only one variable, it is assigned the element; this is opposite to the +convention in Go range clauses. + +A variable's scope extends to the "end" action of the control structure ("if", +"with", or "range") in which it is declared, or to the end of the template if +there is no such control structure. A template invocation does not inherit +variables from the point of its invocation. + +When execution begins, $ is set to the data argument passed to Execute, that is, +to the starting value of dot. + +Examples + +Here are some example one-line templates demonstrating pipelines and variables. +All produce the quoted word "output": + + {{"\"output\""}} + A string constant. + {{`"output"`}} + A raw string constant. + {{printf "%q" "output"}} + A function call. + {{"output" | printf "%q"}} + A function call whose final argument comes from the previous + command. + {{printf "%q" (print "out" "put")}} + A parenthesized argument. + {{"put" | printf "%s%s" "out" | printf "%q"}} + A more elaborate call. + {{"output" | printf "%s" | printf "%q"}} + A longer chain. + {{with "output"}}{{printf "%q" .}}{{end}} + A with action using dot. + {{with $x := "output" | printf "%q"}}{{$x}}{{end}} + A with action that creates and uses a variable. + {{with $x := "output"}}{{printf "%q" $x}}{{end}} + A with action that uses the variable in another action. + {{with $x := "output"}}{{$x | printf "%q"}}{{end}} + The same, but pipelined. + +Functions + +During execution functions are found in two function maps: first in the +template, then in the global function map. By default, no functions are defined +in the template but the Funcs method can be used to add them. + +Predefined global functions are named as follows. + + and + Returns the boolean AND of its arguments by returning the + first empty argument or the last argument, that is, + "and x y" behaves as "if x then y else x". All the + arguments are evaluated. + call + Returns the result of calling the first argument, which + must be a function, with the remaining arguments as parameters. + Thus "call .X.Y 1 2" is, in Go notation, dot.X.Y(1, 2) where + Y is a func-valued field, map entry, or the like. + The first argument must be the result of an evaluation + that yields a value of function type (as distinct from + a predefined function such as print). The function must + return either one or two result values, the second of which + is of type error. If the arguments don't match the function + or the returned error value is non-nil, execution stops. + html + Returns the escaped HTML equivalent of the textual + representation of its arguments. + index + Returns the result of indexing its first argument by the + following arguments. Thus "index x 1 2 3" is, in Go syntax, + x[1][2][3]. Each indexed item must be a map, slice, or array. + js + Returns the escaped JavaScript equivalent of the textual + representation of its arguments. + len + Returns the integer length of its argument. + not + Returns the boolean negation of its single argument. + or + Returns the boolean OR of its arguments by returning the + first non-empty argument or the last argument, that is, + "or x y" behaves as "if x then x else y". All the + arguments are evaluated. + print + An alias for fmt.Sprint + printf + An alias for fmt.Sprintf + println + An alias for fmt.Sprintln + urlquery + Returns the escaped value of the textual representation of + its arguments in a form suitable for embedding in a URL query. + +The boolean functions take any zero value to be false and a non-zero +value to be true. + +There is also a set of binary comparison operators defined as +functions: + + eq + Returns the boolean truth of arg1 == arg2 + ne + Returns the boolean truth of arg1 != arg2 + lt + Returns the boolean truth of arg1 < arg2 + le + Returns the boolean truth of arg1 <= arg2 + gt + Returns the boolean truth of arg1 > arg2 + ge + Returns the boolean truth of arg1 >= arg2 + +For simpler multi-way equality tests, eq (only) accepts two or more +arguments and compares the second and subsequent to the first, +returning in effect + + arg1==arg2 || arg1==arg3 || arg1==arg4 ... + +(Unlike with || in Go, however, eq is a function call and all the +arguments will be evaluated.) + +The comparison functions work on basic types only (or named basic +types, such as "type Celsius float32"). They implement the Go rules +for comparison of values, except that size and exact type are +ignored, so any integer value, signed or unsigned, may be compared +with any other integer value. (The arithmetic value is compared, +not the bit pattern, so all negative integers are less than all +unsigned integers.) However, as usual, one may not compare an int +with a float32 and so on. + +Associated templates + +Each template is named by a string specified when it is created. Also, each +template is associated with zero or more other templates that it may invoke by +name; such associations are transitive and form a name space of templates. + +A template may use a template invocation to instantiate another associated +template; see the explanation of the "template" action above. The name must be +that of a template associated with the template that contains the invocation. + +Nested template definitions + +When parsing a template, another template may be defined and associated with the +template being parsed. Template definitions must appear at the top level of the +template, much like global variables in a Go program. + +The syntax of such definitions is to surround each template declaration with a +"define" and "end" action. + +The define action names the template being created by providing a string +constant. Here is a simple example: + + `{{define "T1"}}ONE{{end}} + {{define "T2"}}TWO{{end}} + {{define "T3"}}{{template "T1"}} {{template "T2"}}{{end}} + {{template "T3"}}` + +This defines two templates, T1 and T2, and a third T3 that invokes the other two +when it is executed. Finally it invokes T3. If executed this template will +produce the text + + ONE TWO + +By construction, a template may reside in only one association. If it's +necessary to have a template addressable from multiple associations, the +template definition must be parsed multiple times to create distinct *Template +values, or must be copied with the Clone or AddParseTree method. + +Parse may be called multiple times to assemble the various associated templates; +see the ParseFiles and ParseGlob functions and methods for simple ways to parse +related templates stored in files. + +A template may be executed directly or through ExecuteTemplate, which executes +an associated template identified by name. To invoke our example above, we +might write, + + err := tmpl.Execute(os.Stdout, "no data needed") + if err != nil { + log.Fatalf("execution failed: %s", err) + } + +or to invoke a particular template explicitly by name, + + err := tmpl.ExecuteTemplate(os.Stdout, "T2", "no data needed") + if err != nil { + log.Fatalf("execution failed: %s", err) + } + +*/ +package template diff --git a/src/alertmanager/vendor/github.com/alecthomas/template/exec.go b/src/alertmanager/vendor/github.com/alecthomas/template/exec.go new file mode 100644 index 0000000..c3078e5 --- /dev/null +++ b/src/alertmanager/vendor/github.com/alecthomas/template/exec.go @@ -0,0 +1,845 @@ +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package template + +import ( + "bytes" + "fmt" + "io" + "reflect" + "runtime" + "sort" + "strings" + + "github.com/alecthomas/template/parse" +) + +// state represents the state of an execution. It's not part of the +// template so that multiple executions of the same template +// can execute in parallel. +type state struct { + tmpl *Template + wr io.Writer + node parse.Node // current node, for errors + vars []variable // push-down stack of variable values. +} + +// variable holds the dynamic value of a variable such as $, $x etc. +type variable struct { + name string + value reflect.Value +} + +// push pushes a new variable on the stack. +func (s *state) push(name string, value reflect.Value) { + s.vars = append(s.vars, variable{name, value}) +} + +// mark returns the length of the variable stack. +func (s *state) mark() int { + return len(s.vars) +} + +// pop pops the variable stack up to the mark. +func (s *state) pop(mark int) { + s.vars = s.vars[0:mark] +} + +// setVar overwrites the top-nth variable on the stack. Used by range iterations. +func (s *state) setVar(n int, value reflect.Value) { + s.vars[len(s.vars)-n].value = value +} + +// varValue returns the value of the named variable. +func (s *state) varValue(name string) reflect.Value { + for i := s.mark() - 1; i >= 0; i-- { + if s.vars[i].name == name { + return s.vars[i].value + } + } + s.errorf("undefined variable: %s", name) + return zero +} + +var zero reflect.Value + +// at marks the state to be on node n, for error reporting. +func (s *state) at(node parse.Node) { + s.node = node +} + +// doublePercent returns the string with %'s replaced by %%, if necessary, +// so it can be used safely inside a Printf format string. +func doublePercent(str string) string { + if strings.Contains(str, "%") { + str = strings.Replace(str, "%", "%%", -1) + } + return str +} + +// errorf formats the error and terminates processing. +func (s *state) errorf(format string, args ...interface{}) { + name := doublePercent(s.tmpl.Name()) + if s.node == nil { + format = fmt.Sprintf("template: %s: %s", name, format) + } else { + location, context := s.tmpl.ErrorContext(s.node) + format = fmt.Sprintf("template: %s: executing %q at <%s>: %s", location, name, doublePercent(context), format) + } + panic(fmt.Errorf(format, args...)) +} + +// errRecover is the handler that turns panics into returns from the top +// level of Parse. +func errRecover(errp *error) { + e := recover() + if e != nil { + switch err := e.(type) { + case runtime.Error: + panic(e) + case error: + *errp = err + default: + panic(e) + } + } +} + +// ExecuteTemplate applies the template associated with t that has the given name +// to the specified data object and writes the output to wr. +// If an error occurs executing the template or writing its output, +// execution stops, but partial results may already have been written to +// the output writer. +// A template may be executed safely in parallel. +func (t *Template) ExecuteTemplate(wr io.Writer, name string, data interface{}) error { + tmpl := t.tmpl[name] + if tmpl == nil { + return fmt.Errorf("template: no template %q associated with template %q", name, t.name) + } + return tmpl.Execute(wr, data) +} + +// Execute applies a parsed template to the specified data object, +// and writes the output to wr. +// If an error occurs executing the template or writing its output, +// execution stops, but partial results may already have been written to +// the output writer. +// A template may be executed safely in parallel. +func (t *Template) Execute(wr io.Writer, data interface{}) (err error) { + defer errRecover(&err) + value := reflect.ValueOf(data) + state := &state{ + tmpl: t, + wr: wr, + vars: []variable{{"$", value}}, + } + t.init() + if t.Tree == nil || t.Root == nil { + var b bytes.Buffer + for name, tmpl := range t.tmpl { + if tmpl.Tree == nil || tmpl.Root == nil { + continue + } + if b.Len() > 0 { + b.WriteString(", ") + } + fmt.Fprintf(&b, "%q", name) + } + var s string + if b.Len() > 0 { + s = "; defined templates are: " + b.String() + } + state.errorf("%q is an incomplete or empty template%s", t.Name(), s) + } + state.walk(value, t.Root) + return +} + +// Walk functions step through the major pieces of the template structure, +// generating output as they go. +func (s *state) walk(dot reflect.Value, node parse.Node) { + s.at(node) + switch node := node.(type) { + case *parse.ActionNode: + // Do not pop variables so they persist until next end. + // Also, if the action declares variables, don't print the result. + val := s.evalPipeline(dot, node.Pipe) + if len(node.Pipe.Decl) == 0 { + s.printValue(node, val) + } + case *parse.IfNode: + s.walkIfOrWith(parse.NodeIf, dot, node.Pipe, node.List, node.ElseList) + case *parse.ListNode: + for _, node := range node.Nodes { + s.walk(dot, node) + } + case *parse.RangeNode: + s.walkRange(dot, node) + case *parse.TemplateNode: + s.walkTemplate(dot, node) + case *parse.TextNode: + if _, err := s.wr.Write(node.Text); err != nil { + s.errorf("%s", err) + } + case *parse.WithNode: + s.walkIfOrWith(parse.NodeWith, dot, node.Pipe, node.List, node.ElseList) + default: + s.errorf("unknown node: %s", node) + } +} + +// walkIfOrWith walks an 'if' or 'with' node. The two control structures +// are identical in behavior except that 'with' sets dot. +func (s *state) walkIfOrWith(typ parse.NodeType, dot reflect.Value, pipe *parse.PipeNode, list, elseList *parse.ListNode) { + defer s.pop(s.mark()) + val := s.evalPipeline(dot, pipe) + truth, ok := isTrue(val) + if !ok { + s.errorf("if/with can't use %v", val) + } + if truth { + if typ == parse.NodeWith { + s.walk(val, list) + } else { + s.walk(dot, list) + } + } else if elseList != nil { + s.walk(dot, elseList) + } +} + +// isTrue reports whether the value is 'true', in the sense of not the zero of its type, +// and whether the value has a meaningful truth value. +func isTrue(val reflect.Value) (truth, ok bool) { + if !val.IsValid() { + // Something like var x interface{}, never set. It's a form of nil. + return false, true + } + switch val.Kind() { + case reflect.Array, reflect.Map, reflect.Slice, reflect.String: + truth = val.Len() > 0 + case reflect.Bool: + truth = val.Bool() + case reflect.Complex64, reflect.Complex128: + truth = val.Complex() != 0 + case reflect.Chan, reflect.Func, reflect.Ptr, reflect.Interface: + truth = !val.IsNil() + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + truth = val.Int() != 0 + case reflect.Float32, reflect.Float64: + truth = val.Float() != 0 + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + truth = val.Uint() != 0 + case reflect.Struct: + truth = true // Struct values are always true. + default: + return + } + return truth, true +} + +func (s *state) walkRange(dot reflect.Value, r *parse.RangeNode) { + s.at(r) + defer s.pop(s.mark()) + val, _ := indirect(s.evalPipeline(dot, r.Pipe)) + // mark top of stack before any variables in the body are pushed. + mark := s.mark() + oneIteration := func(index, elem reflect.Value) { + // Set top var (lexically the second if there are two) to the element. + if len(r.Pipe.Decl) > 0 { + s.setVar(1, elem) + } + // Set next var (lexically the first if there are two) to the index. + if len(r.Pipe.Decl) > 1 { + s.setVar(2, index) + } + s.walk(elem, r.List) + s.pop(mark) + } + switch val.Kind() { + case reflect.Array, reflect.Slice: + if val.Len() == 0 { + break + } + for i := 0; i < val.Len(); i++ { + oneIteration(reflect.ValueOf(i), val.Index(i)) + } + return + case reflect.Map: + if val.Len() == 0 { + break + } + for _, key := range sortKeys(val.MapKeys()) { + oneIteration(key, val.MapIndex(key)) + } + return + case reflect.Chan: + if val.IsNil() { + break + } + i := 0 + for ; ; i++ { + elem, ok := val.Recv() + if !ok { + break + } + oneIteration(reflect.ValueOf(i), elem) + } + if i == 0 { + break + } + return + case reflect.Invalid: + break // An invalid value is likely a nil map, etc. and acts like an empty map. + default: + s.errorf("range can't iterate over %v", val) + } + if r.ElseList != nil { + s.walk(dot, r.ElseList) + } +} + +func (s *state) walkTemplate(dot reflect.Value, t *parse.TemplateNode) { + s.at(t) + tmpl := s.tmpl.tmpl[t.Name] + if tmpl == nil { + s.errorf("template %q not defined", t.Name) + } + // Variables declared by the pipeline persist. + dot = s.evalPipeline(dot, t.Pipe) + newState := *s + newState.tmpl = tmpl + // No dynamic scoping: template invocations inherit no variables. + newState.vars = []variable{{"$", dot}} + newState.walk(dot, tmpl.Root) +} + +// Eval functions evaluate pipelines, commands, and their elements and extract +// values from the data structure by examining fields, calling methods, and so on. +// The printing of those values happens only through walk functions. + +// evalPipeline returns the value acquired by evaluating a pipeline. If the +// pipeline has a variable declaration, the variable will be pushed on the +// stack. Callers should therefore pop the stack after they are finished +// executing commands depending on the pipeline value. +func (s *state) evalPipeline(dot reflect.Value, pipe *parse.PipeNode) (value reflect.Value) { + if pipe == nil { + return + } + s.at(pipe) + for _, cmd := range pipe.Cmds { + value = s.evalCommand(dot, cmd, value) // previous value is this one's final arg. + // If the object has type interface{}, dig down one level to the thing inside. + if value.Kind() == reflect.Interface && value.Type().NumMethod() == 0 { + value = reflect.ValueOf(value.Interface()) // lovely! + } + } + for _, variable := range pipe.Decl { + s.push(variable.Ident[0], value) + } + return value +} + +func (s *state) notAFunction(args []parse.Node, final reflect.Value) { + if len(args) > 1 || final.IsValid() { + s.errorf("can't give argument to non-function %s", args[0]) + } +} + +func (s *state) evalCommand(dot reflect.Value, cmd *parse.CommandNode, final reflect.Value) reflect.Value { + firstWord := cmd.Args[0] + switch n := firstWord.(type) { + case *parse.FieldNode: + return s.evalFieldNode(dot, n, cmd.Args, final) + case *parse.ChainNode: + return s.evalChainNode(dot, n, cmd.Args, final) + case *parse.IdentifierNode: + // Must be a function. + return s.evalFunction(dot, n, cmd, cmd.Args, final) + case *parse.PipeNode: + // Parenthesized pipeline. The arguments are all inside the pipeline; final is ignored. + return s.evalPipeline(dot, n) + case *parse.VariableNode: + return s.evalVariableNode(dot, n, cmd.Args, final) + } + s.at(firstWord) + s.notAFunction(cmd.Args, final) + switch word := firstWord.(type) { + case *parse.BoolNode: + return reflect.ValueOf(word.True) + case *parse.DotNode: + return dot + case *parse.NilNode: + s.errorf("nil is not a command") + case *parse.NumberNode: + return s.idealConstant(word) + case *parse.StringNode: + return reflect.ValueOf(word.Text) + } + s.errorf("can't evaluate command %q", firstWord) + panic("not reached") +} + +// idealConstant is called to return the value of a number in a context where +// we don't know the type. In that case, the syntax of the number tells us +// its type, and we use Go rules to resolve. Note there is no such thing as +// a uint ideal constant in this situation - the value must be of int type. +func (s *state) idealConstant(constant *parse.NumberNode) reflect.Value { + // These are ideal constants but we don't know the type + // and we have no context. (If it was a method argument, + // we'd know what we need.) The syntax guides us to some extent. + s.at(constant) + switch { + case constant.IsComplex: + return reflect.ValueOf(constant.Complex128) // incontrovertible. + case constant.IsFloat && !isHexConstant(constant.Text) && strings.IndexAny(constant.Text, ".eE") >= 0: + return reflect.ValueOf(constant.Float64) + case constant.IsInt: + n := int(constant.Int64) + if int64(n) != constant.Int64 { + s.errorf("%s overflows int", constant.Text) + } + return reflect.ValueOf(n) + case constant.IsUint: + s.errorf("%s overflows int", constant.Text) + } + return zero +} + +func isHexConstant(s string) bool { + return len(s) > 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X') +} + +func (s *state) evalFieldNode(dot reflect.Value, field *parse.FieldNode, args []parse.Node, final reflect.Value) reflect.Value { + s.at(field) + return s.evalFieldChain(dot, dot, field, field.Ident, args, final) +} + +func (s *state) evalChainNode(dot reflect.Value, chain *parse.ChainNode, args []parse.Node, final reflect.Value) reflect.Value { + s.at(chain) + // (pipe).Field1.Field2 has pipe as .Node, fields as .Field. Eval the pipeline, then the fields. + pipe := s.evalArg(dot, nil, chain.Node) + if len(chain.Field) == 0 { + s.errorf("internal error: no fields in evalChainNode") + } + return s.evalFieldChain(dot, pipe, chain, chain.Field, args, final) +} + +func (s *state) evalVariableNode(dot reflect.Value, variable *parse.VariableNode, args []parse.Node, final reflect.Value) reflect.Value { + // $x.Field has $x as the first ident, Field as the second. Eval the var, then the fields. + s.at(variable) + value := s.varValue(variable.Ident[0]) + if len(variable.Ident) == 1 { + s.notAFunction(args, final) + return value + } + return s.evalFieldChain(dot, value, variable, variable.Ident[1:], args, final) +} + +// evalFieldChain evaluates .X.Y.Z possibly followed by arguments. +// dot is the environment in which to evaluate arguments, while +// receiver is the value being walked along the chain. +func (s *state) evalFieldChain(dot, receiver reflect.Value, node parse.Node, ident []string, args []parse.Node, final reflect.Value) reflect.Value { + n := len(ident) + for i := 0; i < n-1; i++ { + receiver = s.evalField(dot, ident[i], node, nil, zero, receiver) + } + // Now if it's a method, it gets the arguments. + return s.evalField(dot, ident[n-1], node, args, final, receiver) +} + +func (s *state) evalFunction(dot reflect.Value, node *parse.IdentifierNode, cmd parse.Node, args []parse.Node, final reflect.Value) reflect.Value { + s.at(node) + name := node.Ident + function, ok := findFunction(name, s.tmpl) + if !ok { + s.errorf("%q is not a defined function", name) + } + return s.evalCall(dot, function, cmd, name, args, final) +} + +// evalField evaluates an expression like (.Field) or (.Field arg1 arg2). +// The 'final' argument represents the return value from the preceding +// value of the pipeline, if any. +func (s *state) evalField(dot reflect.Value, fieldName string, node parse.Node, args []parse.Node, final, receiver reflect.Value) reflect.Value { + if !receiver.IsValid() { + return zero + } + typ := receiver.Type() + receiver, _ = indirect(receiver) + // Unless it's an interface, need to get to a value of type *T to guarantee + // we see all methods of T and *T. + ptr := receiver + if ptr.Kind() != reflect.Interface && ptr.CanAddr() { + ptr = ptr.Addr() + } + if method := ptr.MethodByName(fieldName); method.IsValid() { + return s.evalCall(dot, method, node, fieldName, args, final) + } + hasArgs := len(args) > 1 || final.IsValid() + // It's not a method; must be a field of a struct or an element of a map. The receiver must not be nil. + receiver, isNil := indirect(receiver) + if isNil { + s.errorf("nil pointer evaluating %s.%s", typ, fieldName) + } + switch receiver.Kind() { + case reflect.Struct: + tField, ok := receiver.Type().FieldByName(fieldName) + if ok { + field := receiver.FieldByIndex(tField.Index) + if tField.PkgPath != "" { // field is unexported + s.errorf("%s is an unexported field of struct type %s", fieldName, typ) + } + // If it's a function, we must call it. + if hasArgs { + s.errorf("%s has arguments but cannot be invoked as function", fieldName) + } + return field + } + s.errorf("%s is not a field of struct type %s", fieldName, typ) + case reflect.Map: + // If it's a map, attempt to use the field name as a key. + nameVal := reflect.ValueOf(fieldName) + if nameVal.Type().AssignableTo(receiver.Type().Key()) { + if hasArgs { + s.errorf("%s is not a method but has arguments", fieldName) + } + return receiver.MapIndex(nameVal) + } + } + s.errorf("can't evaluate field %s in type %s", fieldName, typ) + panic("not reached") +} + +var ( + errorType = reflect.TypeOf((*error)(nil)).Elem() + fmtStringerType = reflect.TypeOf((*fmt.Stringer)(nil)).Elem() +) + +// evalCall executes a function or method call. If it's a method, fun already has the receiver bound, so +// it looks just like a function call. The arg list, if non-nil, includes (in the manner of the shell), arg[0] +// as the function itself. +func (s *state) evalCall(dot, fun reflect.Value, node parse.Node, name string, args []parse.Node, final reflect.Value) reflect.Value { + if args != nil { + args = args[1:] // Zeroth arg is function name/node; not passed to function. + } + typ := fun.Type() + numIn := len(args) + if final.IsValid() { + numIn++ + } + numFixed := len(args) + if typ.IsVariadic() { + numFixed = typ.NumIn() - 1 // last arg is the variadic one. + if numIn < numFixed { + s.errorf("wrong number of args for %s: want at least %d got %d", name, typ.NumIn()-1, len(args)) + } + } else if numIn < typ.NumIn()-1 || !typ.IsVariadic() && numIn != typ.NumIn() { + s.errorf("wrong number of args for %s: want %d got %d", name, typ.NumIn(), len(args)) + } + if !goodFunc(typ) { + // TODO: This could still be a confusing error; maybe goodFunc should provide info. + s.errorf("can't call method/function %q with %d results", name, typ.NumOut()) + } + // Build the arg list. + argv := make([]reflect.Value, numIn) + // Args must be evaluated. Fixed args first. + i := 0 + for ; i < numFixed && i < len(args); i++ { + argv[i] = s.evalArg(dot, typ.In(i), args[i]) + } + // Now the ... args. + if typ.IsVariadic() { + argType := typ.In(typ.NumIn() - 1).Elem() // Argument is a slice. + for ; i < len(args); i++ { + argv[i] = s.evalArg(dot, argType, args[i]) + } + } + // Add final value if necessary. + if final.IsValid() { + t := typ.In(typ.NumIn() - 1) + if typ.IsVariadic() { + t = t.Elem() + } + argv[i] = s.validateType(final, t) + } + result := fun.Call(argv) + // If we have an error that is not nil, stop execution and return that error to the caller. + if len(result) == 2 && !result[1].IsNil() { + s.at(node) + s.errorf("error calling %s: %s", name, result[1].Interface().(error)) + } + return result[0] +} + +// canBeNil reports whether an untyped nil can be assigned to the type. See reflect.Zero. +func canBeNil(typ reflect.Type) bool { + switch typ.Kind() { + case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice: + return true + } + return false +} + +// validateType guarantees that the value is valid and assignable to the type. +func (s *state) validateType(value reflect.Value, typ reflect.Type) reflect.Value { + if !value.IsValid() { + if typ == nil || canBeNil(typ) { + // An untyped nil interface{}. Accept as a proper nil value. + return reflect.Zero(typ) + } + s.errorf("invalid value; expected %s", typ) + } + if typ != nil && !value.Type().AssignableTo(typ) { + if value.Kind() == reflect.Interface && !value.IsNil() { + value = value.Elem() + if value.Type().AssignableTo(typ) { + return value + } + // fallthrough + } + // Does one dereference or indirection work? We could do more, as we + // do with method receivers, but that gets messy and method receivers + // are much more constrained, so it makes more sense there than here. + // Besides, one is almost always all you need. + switch { + case value.Kind() == reflect.Ptr && value.Type().Elem().AssignableTo(typ): + value = value.Elem() + if !value.IsValid() { + s.errorf("dereference of nil pointer of type %s", typ) + } + case reflect.PtrTo(value.Type()).AssignableTo(typ) && value.CanAddr(): + value = value.Addr() + default: + s.errorf("wrong type for value; expected %s; got %s", typ, value.Type()) + } + } + return value +} + +func (s *state) evalArg(dot reflect.Value, typ reflect.Type, n parse.Node) reflect.Value { + s.at(n) + switch arg := n.(type) { + case *parse.DotNode: + return s.validateType(dot, typ) + case *parse.NilNode: + if canBeNil(typ) { + return reflect.Zero(typ) + } + s.errorf("cannot assign nil to %s", typ) + case *parse.FieldNode: + return s.validateType(s.evalFieldNode(dot, arg, []parse.Node{n}, zero), typ) + case *parse.VariableNode: + return s.validateType(s.evalVariableNode(dot, arg, nil, zero), typ) + case *parse.PipeNode: + return s.validateType(s.evalPipeline(dot, arg), typ) + case *parse.IdentifierNode: + return s.evalFunction(dot, arg, arg, nil, zero) + case *parse.ChainNode: + return s.validateType(s.evalChainNode(dot, arg, nil, zero), typ) + } + switch typ.Kind() { + case reflect.Bool: + return s.evalBool(typ, n) + case reflect.Complex64, reflect.Complex128: + return s.evalComplex(typ, n) + case reflect.Float32, reflect.Float64: + return s.evalFloat(typ, n) + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return s.evalInteger(typ, n) + case reflect.Interface: + if typ.NumMethod() == 0 { + return s.evalEmptyInterface(dot, n) + } + case reflect.String: + return s.evalString(typ, n) + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + return s.evalUnsignedInteger(typ, n) + } + s.errorf("can't handle %s for arg of type %s", n, typ) + panic("not reached") +} + +func (s *state) evalBool(typ reflect.Type, n parse.Node) reflect.Value { + s.at(n) + if n, ok := n.(*parse.BoolNode); ok { + value := reflect.New(typ).Elem() + value.SetBool(n.True) + return value + } + s.errorf("expected bool; found %s", n) + panic("not reached") +} + +func (s *state) evalString(typ reflect.Type, n parse.Node) reflect.Value { + s.at(n) + if n, ok := n.(*parse.StringNode); ok { + value := reflect.New(typ).Elem() + value.SetString(n.Text) + return value + } + s.errorf("expected string; found %s", n) + panic("not reached") +} + +func (s *state) evalInteger(typ reflect.Type, n parse.Node) reflect.Value { + s.at(n) + if n, ok := n.(*parse.NumberNode); ok && n.IsInt { + value := reflect.New(typ).Elem() + value.SetInt(n.Int64) + return value + } + s.errorf("expected integer; found %s", n) + panic("not reached") +} + +func (s *state) evalUnsignedInteger(typ reflect.Type, n parse.Node) reflect.Value { + s.at(n) + if n, ok := n.(*parse.NumberNode); ok && n.IsUint { + value := reflect.New(typ).Elem() + value.SetUint(n.Uint64) + return value + } + s.errorf("expected unsigned integer; found %s", n) + panic("not reached") +} + +func (s *state) evalFloat(typ reflect.Type, n parse.Node) reflect.Value { + s.at(n) + if n, ok := n.(*parse.NumberNode); ok && n.IsFloat { + value := reflect.New(typ).Elem() + value.SetFloat(n.Float64) + return value + } + s.errorf("expected float; found %s", n) + panic("not reached") +} + +func (s *state) evalComplex(typ reflect.Type, n parse.Node) reflect.Value { + if n, ok := n.(*parse.NumberNode); ok && n.IsComplex { + value := reflect.New(typ).Elem() + value.SetComplex(n.Complex128) + return value + } + s.errorf("expected complex; found %s", n) + panic("not reached") +} + +func (s *state) evalEmptyInterface(dot reflect.Value, n parse.Node) reflect.Value { + s.at(n) + switch n := n.(type) { + case *parse.BoolNode: + return reflect.ValueOf(n.True) + case *parse.DotNode: + return dot + case *parse.FieldNode: + return s.evalFieldNode(dot, n, nil, zero) + case *parse.IdentifierNode: + return s.evalFunction(dot, n, n, nil, zero) + case *parse.NilNode: + // NilNode is handled in evalArg, the only place that calls here. + s.errorf("evalEmptyInterface: nil (can't happen)") + case *parse.NumberNode: + return s.idealConstant(n) + case *parse.StringNode: + return reflect.ValueOf(n.Text) + case *parse.VariableNode: + return s.evalVariableNode(dot, n, nil, zero) + case *parse.PipeNode: + return s.evalPipeline(dot, n) + } + s.errorf("can't handle assignment of %s to empty interface argument", n) + panic("not reached") +} + +// indirect returns the item at the end of indirection, and a bool to indicate if it's nil. +// We indirect through pointers and empty interfaces (only) because +// non-empty interfaces have methods we might need. +func indirect(v reflect.Value) (rv reflect.Value, isNil bool) { + for ; v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface; v = v.Elem() { + if v.IsNil() { + return v, true + } + if v.Kind() == reflect.Interface && v.NumMethod() > 0 { + break + } + } + return v, false +} + +// printValue writes the textual representation of the value to the output of +// the template. +func (s *state) printValue(n parse.Node, v reflect.Value) { + s.at(n) + iface, ok := printableValue(v) + if !ok { + s.errorf("can't print %s of type %s", n, v.Type()) + } + fmt.Fprint(s.wr, iface) +} + +// printableValue returns the, possibly indirected, interface value inside v that +// is best for a call to formatted printer. +func printableValue(v reflect.Value) (interface{}, bool) { + if v.Kind() == reflect.Ptr { + v, _ = indirect(v) // fmt.Fprint handles nil. + } + if !v.IsValid() { + return "", true + } + + if !v.Type().Implements(errorType) && !v.Type().Implements(fmtStringerType) { + if v.CanAddr() && (reflect.PtrTo(v.Type()).Implements(errorType) || reflect.PtrTo(v.Type()).Implements(fmtStringerType)) { + v = v.Addr() + } else { + switch v.Kind() { + case reflect.Chan, reflect.Func: + return nil, false + } + } + } + return v.Interface(), true +} + +// Types to help sort the keys in a map for reproducible output. + +type rvs []reflect.Value + +func (x rvs) Len() int { return len(x) } +func (x rvs) Swap(i, j int) { x[i], x[j] = x[j], x[i] } + +type rvInts struct{ rvs } + +func (x rvInts) Less(i, j int) bool { return x.rvs[i].Int() < x.rvs[j].Int() } + +type rvUints struct{ rvs } + +func (x rvUints) Less(i, j int) bool { return x.rvs[i].Uint() < x.rvs[j].Uint() } + +type rvFloats struct{ rvs } + +func (x rvFloats) Less(i, j int) bool { return x.rvs[i].Float() < x.rvs[j].Float() } + +type rvStrings struct{ rvs } + +func (x rvStrings) Less(i, j int) bool { return x.rvs[i].String() < x.rvs[j].String() } + +// sortKeys sorts (if it can) the slice of reflect.Values, which is a slice of map keys. +func sortKeys(v []reflect.Value) []reflect.Value { + if len(v) <= 1 { + return v + } + switch v[0].Kind() { + case reflect.Float32, reflect.Float64: + sort.Sort(rvFloats{v}) + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + sort.Sort(rvInts{v}) + case reflect.String: + sort.Sort(rvStrings{v}) + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + sort.Sort(rvUints{v}) + } + return v +} diff --git a/src/alertmanager/vendor/github.com/alecthomas/template/funcs.go b/src/alertmanager/vendor/github.com/alecthomas/template/funcs.go new file mode 100644 index 0000000..39ee5ed --- /dev/null +++ b/src/alertmanager/vendor/github.com/alecthomas/template/funcs.go @@ -0,0 +1,598 @@ +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package template + +import ( + "bytes" + "errors" + "fmt" + "io" + "net/url" + "reflect" + "strings" + "unicode" + "unicode/utf8" +) + +// FuncMap is the type of the map defining the mapping from names to functions. +// Each function must have either a single return value, or two return values of +// which the second has type error. In that case, if the second (error) +// return value evaluates to non-nil during execution, execution terminates and +// Execute returns that error. +type FuncMap map[string]interface{} + +var builtins = FuncMap{ + "and": and, + "call": call, + "html": HTMLEscaper, + "index": index, + "js": JSEscaper, + "len": length, + "not": not, + "or": or, + "print": fmt.Sprint, + "printf": fmt.Sprintf, + "println": fmt.Sprintln, + "urlquery": URLQueryEscaper, + + // Comparisons + "eq": eq, // == + "ge": ge, // >= + "gt": gt, // > + "le": le, // <= + "lt": lt, // < + "ne": ne, // != +} + +var builtinFuncs = createValueFuncs(builtins) + +// createValueFuncs turns a FuncMap into a map[string]reflect.Value +func createValueFuncs(funcMap FuncMap) map[string]reflect.Value { + m := make(map[string]reflect.Value) + addValueFuncs(m, funcMap) + return m +} + +// addValueFuncs adds to values the functions in funcs, converting them to reflect.Values. +func addValueFuncs(out map[string]reflect.Value, in FuncMap) { + for name, fn := range in { + v := reflect.ValueOf(fn) + if v.Kind() != reflect.Func { + panic("value for " + name + " not a function") + } + if !goodFunc(v.Type()) { + panic(fmt.Errorf("can't install method/function %q with %d results", name, v.Type().NumOut())) + } + out[name] = v + } +} + +// addFuncs adds to values the functions in funcs. It does no checking of the input - +// call addValueFuncs first. +func addFuncs(out, in FuncMap) { + for name, fn := range in { + out[name] = fn + } +} + +// goodFunc checks that the function or method has the right result signature. +func goodFunc(typ reflect.Type) bool { + // We allow functions with 1 result or 2 results where the second is an error. + switch { + case typ.NumOut() == 1: + return true + case typ.NumOut() == 2 && typ.Out(1) == errorType: + return true + } + return false +} + +// findFunction looks for a function in the template, and global map. +func findFunction(name string, tmpl *Template) (reflect.Value, bool) { + if tmpl != nil && tmpl.common != nil { + if fn := tmpl.execFuncs[name]; fn.IsValid() { + return fn, true + } + } + if fn := builtinFuncs[name]; fn.IsValid() { + return fn, true + } + return reflect.Value{}, false +} + +// Indexing. + +// index returns the result of indexing its first argument by the following +// arguments. Thus "index x 1 2 3" is, in Go syntax, x[1][2][3]. Each +// indexed item must be a map, slice, or array. +func index(item interface{}, indices ...interface{}) (interface{}, error) { + v := reflect.ValueOf(item) + for _, i := range indices { + index := reflect.ValueOf(i) + var isNil bool + if v, isNil = indirect(v); isNil { + return nil, fmt.Errorf("index of nil pointer") + } + switch v.Kind() { + case reflect.Array, reflect.Slice, reflect.String: + var x int64 + switch index.Kind() { + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + x = index.Int() + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + x = int64(index.Uint()) + default: + return nil, fmt.Errorf("cannot index slice/array with type %s", index.Type()) + } + if x < 0 || x >= int64(v.Len()) { + return nil, fmt.Errorf("index out of range: %d", x) + } + v = v.Index(int(x)) + case reflect.Map: + if !index.IsValid() { + index = reflect.Zero(v.Type().Key()) + } + if !index.Type().AssignableTo(v.Type().Key()) { + return nil, fmt.Errorf("%s is not index type for %s", index.Type(), v.Type()) + } + if x := v.MapIndex(index); x.IsValid() { + v = x + } else { + v = reflect.Zero(v.Type().Elem()) + } + default: + return nil, fmt.Errorf("can't index item of type %s", v.Type()) + } + } + return v.Interface(), nil +} + +// Length + +// length returns the length of the item, with an error if it has no defined length. +func length(item interface{}) (int, error) { + v, isNil := indirect(reflect.ValueOf(item)) + if isNil { + return 0, fmt.Errorf("len of nil pointer") + } + switch v.Kind() { + case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice, reflect.String: + return v.Len(), nil + } + return 0, fmt.Errorf("len of type %s", v.Type()) +} + +// Function invocation + +// call returns the result of evaluating the first argument as a function. +// The function must return 1 result, or 2 results, the second of which is an error. +func call(fn interface{}, args ...interface{}) (interface{}, error) { + v := reflect.ValueOf(fn) + typ := v.Type() + if typ.Kind() != reflect.Func { + return nil, fmt.Errorf("non-function of type %s", typ) + } + if !goodFunc(typ) { + return nil, fmt.Errorf("function called with %d args; should be 1 or 2", typ.NumOut()) + } + numIn := typ.NumIn() + var dddType reflect.Type + if typ.IsVariadic() { + if len(args) < numIn-1 { + return nil, fmt.Errorf("wrong number of args: got %d want at least %d", len(args), numIn-1) + } + dddType = typ.In(numIn - 1).Elem() + } else { + if len(args) != numIn { + return nil, fmt.Errorf("wrong number of args: got %d want %d", len(args), numIn) + } + } + argv := make([]reflect.Value, len(args)) + for i, arg := range args { + value := reflect.ValueOf(arg) + // Compute the expected type. Clumsy because of variadics. + var argType reflect.Type + if !typ.IsVariadic() || i < numIn-1 { + argType = typ.In(i) + } else { + argType = dddType + } + if !value.IsValid() && canBeNil(argType) { + value = reflect.Zero(argType) + } + if !value.Type().AssignableTo(argType) { + return nil, fmt.Errorf("arg %d has type %s; should be %s", i, value.Type(), argType) + } + argv[i] = value + } + result := v.Call(argv) + if len(result) == 2 && !result[1].IsNil() { + return result[0].Interface(), result[1].Interface().(error) + } + return result[0].Interface(), nil +} + +// Boolean logic. + +func truth(a interface{}) bool { + t, _ := isTrue(reflect.ValueOf(a)) + return t +} + +// and computes the Boolean AND of its arguments, returning +// the first false argument it encounters, or the last argument. +func and(arg0 interface{}, args ...interface{}) interface{} { + if !truth(arg0) { + return arg0 + } + for i := range args { + arg0 = args[i] + if !truth(arg0) { + break + } + } + return arg0 +} + +// or computes the Boolean OR of its arguments, returning +// the first true argument it encounters, or the last argument. +func or(arg0 interface{}, args ...interface{}) interface{} { + if truth(arg0) { + return arg0 + } + for i := range args { + arg0 = args[i] + if truth(arg0) { + break + } + } + return arg0 +} + +// not returns the Boolean negation of its argument. +func not(arg interface{}) (truth bool) { + truth, _ = isTrue(reflect.ValueOf(arg)) + return !truth +} + +// Comparison. + +// TODO: Perhaps allow comparison between signed and unsigned integers. + +var ( + errBadComparisonType = errors.New("invalid type for comparison") + errBadComparison = errors.New("incompatible types for comparison") + errNoComparison = errors.New("missing argument for comparison") +) + +type kind int + +const ( + invalidKind kind = iota + boolKind + complexKind + intKind + floatKind + integerKind + stringKind + uintKind +) + +func basicKind(v reflect.Value) (kind, error) { + switch v.Kind() { + case reflect.Bool: + return boolKind, nil + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return intKind, nil + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + return uintKind, nil + case reflect.Float32, reflect.Float64: + return floatKind, nil + case reflect.Complex64, reflect.Complex128: + return complexKind, nil + case reflect.String: + return stringKind, nil + } + return invalidKind, errBadComparisonType +} + +// eq evaluates the comparison a == b || a == c || ... +func eq(arg1 interface{}, arg2 ...interface{}) (bool, error) { + v1 := reflect.ValueOf(arg1) + k1, err := basicKind(v1) + if err != nil { + return false, err + } + if len(arg2) == 0 { + return false, errNoComparison + } + for _, arg := range arg2 { + v2 := reflect.ValueOf(arg) + k2, err := basicKind(v2) + if err != nil { + return false, err + } + truth := false + if k1 != k2 { + // Special case: Can compare integer values regardless of type's sign. + switch { + case k1 == intKind && k2 == uintKind: + truth = v1.Int() >= 0 && uint64(v1.Int()) == v2.Uint() + case k1 == uintKind && k2 == intKind: + truth = v2.Int() >= 0 && v1.Uint() == uint64(v2.Int()) + default: + return false, errBadComparison + } + } else { + switch k1 { + case boolKind: + truth = v1.Bool() == v2.Bool() + case complexKind: + truth = v1.Complex() == v2.Complex() + case floatKind: + truth = v1.Float() == v2.Float() + case intKind: + truth = v1.Int() == v2.Int() + case stringKind: + truth = v1.String() == v2.String() + case uintKind: + truth = v1.Uint() == v2.Uint() + default: + panic("invalid kind") + } + } + if truth { + return true, nil + } + } + return false, nil +} + +// ne evaluates the comparison a != b. +func ne(arg1, arg2 interface{}) (bool, error) { + // != is the inverse of ==. + equal, err := eq(arg1, arg2) + return !equal, err +} + +// lt evaluates the comparison a < b. +func lt(arg1, arg2 interface{}) (bool, error) { + v1 := reflect.ValueOf(arg1) + k1, err := basicKind(v1) + if err != nil { + return false, err + } + v2 := reflect.ValueOf(arg2) + k2, err := basicKind(v2) + if err != nil { + return false, err + } + truth := false + if k1 != k2 { + // Special case: Can compare integer values regardless of type's sign. + switch { + case k1 == intKind && k2 == uintKind: + truth = v1.Int() < 0 || uint64(v1.Int()) < v2.Uint() + case k1 == uintKind && k2 == intKind: + truth = v2.Int() >= 0 && v1.Uint() < uint64(v2.Int()) + default: + return false, errBadComparison + } + } else { + switch k1 { + case boolKind, complexKind: + return false, errBadComparisonType + case floatKind: + truth = v1.Float() < v2.Float() + case intKind: + truth = v1.Int() < v2.Int() + case stringKind: + truth = v1.String() < v2.String() + case uintKind: + truth = v1.Uint() < v2.Uint() + default: + panic("invalid kind") + } + } + return truth, nil +} + +// le evaluates the comparison <= b. +func le(arg1, arg2 interface{}) (bool, error) { + // <= is < or ==. + lessThan, err := lt(arg1, arg2) + if lessThan || err != nil { + return lessThan, err + } + return eq(arg1, arg2) +} + +// gt evaluates the comparison a > b. +func gt(arg1, arg2 interface{}) (bool, error) { + // > is the inverse of <=. + lessOrEqual, err := le(arg1, arg2) + if err != nil { + return false, err + } + return !lessOrEqual, nil +} + +// ge evaluates the comparison a >= b. +func ge(arg1, arg2 interface{}) (bool, error) { + // >= is the inverse of <. + lessThan, err := lt(arg1, arg2) + if err != nil { + return false, err + } + return !lessThan, nil +} + +// HTML escaping. + +var ( + htmlQuot = []byte(""") // shorter than """ + htmlApos = []byte("'") // shorter than "'" and apos was not in HTML until HTML5 + htmlAmp = []byte("&") + htmlLt = []byte("<") + htmlGt = []byte(">") +) + +// HTMLEscape writes to w the escaped HTML equivalent of the plain text data b. +func HTMLEscape(w io.Writer, b []byte) { + last := 0 + for i, c := range b { + var html []byte + switch c { + case '"': + html = htmlQuot + case '\'': + html = htmlApos + case '&': + html = htmlAmp + case '<': + html = htmlLt + case '>': + html = htmlGt + default: + continue + } + w.Write(b[last:i]) + w.Write(html) + last = i + 1 + } + w.Write(b[last:]) +} + +// HTMLEscapeString returns the escaped HTML equivalent of the plain text data s. +func HTMLEscapeString(s string) string { + // Avoid allocation if we can. + if strings.IndexAny(s, `'"&<>`) < 0 { + return s + } + var b bytes.Buffer + HTMLEscape(&b, []byte(s)) + return b.String() +} + +// HTMLEscaper returns the escaped HTML equivalent of the textual +// representation of its arguments. +func HTMLEscaper(args ...interface{}) string { + return HTMLEscapeString(evalArgs(args)) +} + +// JavaScript escaping. + +var ( + jsLowUni = []byte(`\u00`) + hex = []byte("0123456789ABCDEF") + + jsBackslash = []byte(`\\`) + jsApos = []byte(`\'`) + jsQuot = []byte(`\"`) + jsLt = []byte(`\x3C`) + jsGt = []byte(`\x3E`) +) + +// JSEscape writes to w the escaped JavaScript equivalent of the plain text data b. +func JSEscape(w io.Writer, b []byte) { + last := 0 + for i := 0; i < len(b); i++ { + c := b[i] + + if !jsIsSpecial(rune(c)) { + // fast path: nothing to do + continue + } + w.Write(b[last:i]) + + if c < utf8.RuneSelf { + // Quotes, slashes and angle brackets get quoted. + // Control characters get written as \u00XX. + switch c { + case '\\': + w.Write(jsBackslash) + case '\'': + w.Write(jsApos) + case '"': + w.Write(jsQuot) + case '<': + w.Write(jsLt) + case '>': + w.Write(jsGt) + default: + w.Write(jsLowUni) + t, b := c>>4, c&0x0f + w.Write(hex[t : t+1]) + w.Write(hex[b : b+1]) + } + } else { + // Unicode rune. + r, size := utf8.DecodeRune(b[i:]) + if unicode.IsPrint(r) { + w.Write(b[i : i+size]) + } else { + fmt.Fprintf(w, "\\u%04X", r) + } + i += size - 1 + } + last = i + 1 + } + w.Write(b[last:]) +} + +// JSEscapeString returns the escaped JavaScript equivalent of the plain text data s. +func JSEscapeString(s string) string { + // Avoid allocation if we can. + if strings.IndexFunc(s, jsIsSpecial) < 0 { + return s + } + var b bytes.Buffer + JSEscape(&b, []byte(s)) + return b.String() +} + +func jsIsSpecial(r rune) bool { + switch r { + case '\\', '\'', '"', '<', '>': + return true + } + return r < ' ' || utf8.RuneSelf <= r +} + +// JSEscaper returns the escaped JavaScript equivalent of the textual +// representation of its arguments. +func JSEscaper(args ...interface{}) string { + return JSEscapeString(evalArgs(args)) +} + +// URLQueryEscaper returns the escaped value of the textual representation of +// its arguments in a form suitable for embedding in a URL query. +func URLQueryEscaper(args ...interface{}) string { + return url.QueryEscape(evalArgs(args)) +} + +// evalArgs formats the list of arguments into a string. It is therefore equivalent to +// fmt.Sprint(args...) +// except that each argument is indirected (if a pointer), as required, +// using the same rules as the default string evaluation during template +// execution. +func evalArgs(args []interface{}) string { + ok := false + var s string + // Fast path for simple common case. + if len(args) == 1 { + s, ok = args[0].(string) + } + if !ok { + for i, arg := range args { + a, ok := printableValue(reflect.ValueOf(arg)) + if ok { + args[i] = a + } // else left fmt do its thing + } + s = fmt.Sprint(args...) + } + return s +} diff --git a/src/alertmanager/vendor/github.com/alecthomas/template/helper.go b/src/alertmanager/vendor/github.com/alecthomas/template/helper.go new file mode 100644 index 0000000..3636fb5 --- /dev/null +++ b/src/alertmanager/vendor/github.com/alecthomas/template/helper.go @@ -0,0 +1,108 @@ +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Helper functions to make constructing templates easier. + +package template + +import ( + "fmt" + "io/ioutil" + "path/filepath" +) + +// Functions and methods to parse templates. + +// Must is a helper that wraps a call to a function returning (*Template, error) +// and panics if the error is non-nil. It is intended for use in variable +// initializations such as +// var t = template.Must(template.New("name").Parse("text")) +func Must(t *Template, err error) *Template { + if err != nil { + panic(err) + } + return t +} + +// ParseFiles creates a new Template and parses the template definitions from +// the named files. The returned template's name will have the (base) name and +// (parsed) contents of the first file. There must be at least one file. +// If an error occurs, parsing stops and the returned *Template is nil. +func ParseFiles(filenames ...string) (*Template, error) { + return parseFiles(nil, filenames...) +} + +// ParseFiles parses the named files and associates the resulting templates with +// t. If an error occurs, parsing stops and the returned template is nil; +// otherwise it is t. There must be at least one file. +func (t *Template) ParseFiles(filenames ...string) (*Template, error) { + return parseFiles(t, filenames...) +} + +// parseFiles is the helper for the method and function. If the argument +// template is nil, it is created from the first file. +func parseFiles(t *Template, filenames ...string) (*Template, error) { + if len(filenames) == 0 { + // Not really a problem, but be consistent. + return nil, fmt.Errorf("template: no files named in call to ParseFiles") + } + for _, filename := range filenames { + b, err := ioutil.ReadFile(filename) + if err != nil { + return nil, err + } + s := string(b) + name := filepath.Base(filename) + // First template becomes return value if not already defined, + // and we use that one for subsequent New calls to associate + // all the templates together. Also, if this file has the same name + // as t, this file becomes the contents of t, so + // t, err := New(name).Funcs(xxx).ParseFiles(name) + // works. Otherwise we create a new template associated with t. + var tmpl *Template + if t == nil { + t = New(name) + } + if name == t.Name() { + tmpl = t + } else { + tmpl = t.New(name) + } + _, err = tmpl.Parse(s) + if err != nil { + return nil, err + } + } + return t, nil +} + +// ParseGlob creates a new Template and parses the template definitions from the +// files identified by the pattern, which must match at least one file. The +// returned template will have the (base) name and (parsed) contents of the +// first file matched by the pattern. ParseGlob is equivalent to calling +// ParseFiles with the list of files matched by the pattern. +func ParseGlob(pattern string) (*Template, error) { + return parseGlob(nil, pattern) +} + +// ParseGlob parses the template definitions in the files identified by the +// pattern and associates the resulting templates with t. The pattern is +// processed by filepath.Glob and must match at least one file. ParseGlob is +// equivalent to calling t.ParseFiles with the list of files matched by the +// pattern. +func (t *Template) ParseGlob(pattern string) (*Template, error) { + return parseGlob(t, pattern) +} + +// parseGlob is the implementation of the function and method ParseGlob. +func parseGlob(t *Template, pattern string) (*Template, error) { + filenames, err := filepath.Glob(pattern) + if err != nil { + return nil, err + } + if len(filenames) == 0 { + return nil, fmt.Errorf("template: pattern matches no files: %#q", pattern) + } + return parseFiles(t, filenames...) +} diff --git a/src/alertmanager/vendor/github.com/alecthomas/template/parse/lex.go b/src/alertmanager/vendor/github.com/alecthomas/template/parse/lex.go new file mode 100644 index 0000000..55f1c05 --- /dev/null +++ b/src/alertmanager/vendor/github.com/alecthomas/template/parse/lex.go @@ -0,0 +1,556 @@ +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package parse + +import ( + "fmt" + "strings" + "unicode" + "unicode/utf8" +) + +// item represents a token or text string returned from the scanner. +type item struct { + typ itemType // The type of this item. + pos Pos // The starting position, in bytes, of this item in the input string. + val string // The value of this item. +} + +func (i item) String() string { + switch { + case i.typ == itemEOF: + return "EOF" + case i.typ == itemError: + return i.val + case i.typ > itemKeyword: + return fmt.Sprintf("<%s>", i.val) + case len(i.val) > 10: + return fmt.Sprintf("%.10q...", i.val) + } + return fmt.Sprintf("%q", i.val) +} + +// itemType identifies the type of lex items. +type itemType int + +const ( + itemError itemType = iota // error occurred; value is text of error + itemBool // boolean constant + itemChar // printable ASCII character; grab bag for comma etc. + itemCharConstant // character constant + itemComplex // complex constant (1+2i); imaginary is just a number + itemColonEquals // colon-equals (':=') introducing a declaration + itemEOF + itemField // alphanumeric identifier starting with '.' + itemIdentifier // alphanumeric identifier not starting with '.' + itemLeftDelim // left action delimiter + itemLeftParen // '(' inside action + itemNumber // simple number, including imaginary + itemPipe // pipe symbol + itemRawString // raw quoted string (includes quotes) + itemRightDelim // right action delimiter + itemElideNewline // elide newline after right delim + itemRightParen // ')' inside action + itemSpace // run of spaces separating arguments + itemString // quoted string (includes quotes) + itemText // plain text + itemVariable // variable starting with '$', such as '$' or '$1' or '$hello' + // Keywords appear after all the rest. + itemKeyword // used only to delimit the keywords + itemDot // the cursor, spelled '.' + itemDefine // define keyword + itemElse // else keyword + itemEnd // end keyword + itemIf // if keyword + itemNil // the untyped nil constant, easiest to treat as a keyword + itemRange // range keyword + itemTemplate // template keyword + itemWith // with keyword +) + +var key = map[string]itemType{ + ".": itemDot, + "define": itemDefine, + "else": itemElse, + "end": itemEnd, + "if": itemIf, + "range": itemRange, + "nil": itemNil, + "template": itemTemplate, + "with": itemWith, +} + +const eof = -1 + +// stateFn represents the state of the scanner as a function that returns the next state. +type stateFn func(*lexer) stateFn + +// lexer holds the state of the scanner. +type lexer struct { + name string // the name of the input; used only for error reports + input string // the string being scanned + leftDelim string // start of action + rightDelim string // end of action + state stateFn // the next lexing function to enter + pos Pos // current position in the input + start Pos // start position of this item + width Pos // width of last rune read from input + lastPos Pos // position of most recent item returned by nextItem + items chan item // channel of scanned items + parenDepth int // nesting depth of ( ) exprs +} + +// next returns the next rune in the input. +func (l *lexer) next() rune { + if int(l.pos) >= len(l.input) { + l.width = 0 + return eof + } + r, w := utf8.DecodeRuneInString(l.input[l.pos:]) + l.width = Pos(w) + l.pos += l.width + return r +} + +// peek returns but does not consume the next rune in the input. +func (l *lexer) peek() rune { + r := l.next() + l.backup() + return r +} + +// backup steps back one rune. Can only be called once per call of next. +func (l *lexer) backup() { + l.pos -= l.width +} + +// emit passes an item back to the client. +func (l *lexer) emit(t itemType) { + l.items <- item{t, l.start, l.input[l.start:l.pos]} + l.start = l.pos +} + +// ignore skips over the pending input before this point. +func (l *lexer) ignore() { + l.start = l.pos +} + +// accept consumes the next rune if it's from the valid set. +func (l *lexer) accept(valid string) bool { + if strings.IndexRune(valid, l.next()) >= 0 { + return true + } + l.backup() + return false +} + +// acceptRun consumes a run of runes from the valid set. +func (l *lexer) acceptRun(valid string) { + for strings.IndexRune(valid, l.next()) >= 0 { + } + l.backup() +} + +// lineNumber reports which line we're on, based on the position of +// the previous item returned by nextItem. Doing it this way +// means we don't have to worry about peek double counting. +func (l *lexer) lineNumber() int { + return 1 + strings.Count(l.input[:l.lastPos], "\n") +} + +// errorf returns an error token and terminates the scan by passing +// back a nil pointer that will be the next state, terminating l.nextItem. +func (l *lexer) errorf(format string, args ...interface{}) stateFn { + l.items <- item{itemError, l.start, fmt.Sprintf(format, args...)} + return nil +} + +// nextItem returns the next item from the input. +func (l *lexer) nextItem() item { + item := <-l.items + l.lastPos = item.pos + return item +} + +// lex creates a new scanner for the input string. +func lex(name, input, left, right string) *lexer { + if left == "" { + left = leftDelim + } + if right == "" { + right = rightDelim + } + l := &lexer{ + name: name, + input: input, + leftDelim: left, + rightDelim: right, + items: make(chan item), + } + go l.run() + return l +} + +// run runs the state machine for the lexer. +func (l *lexer) run() { + for l.state = lexText; l.state != nil; { + l.state = l.state(l) + } +} + +// state functions + +const ( + leftDelim = "{{" + rightDelim = "}}" + leftComment = "/*" + rightComment = "*/" +) + +// lexText scans until an opening action delimiter, "{{". +func lexText(l *lexer) stateFn { + for { + if strings.HasPrefix(l.input[l.pos:], l.leftDelim) { + if l.pos > l.start { + l.emit(itemText) + } + return lexLeftDelim + } + if l.next() == eof { + break + } + } + // Correctly reached EOF. + if l.pos > l.start { + l.emit(itemText) + } + l.emit(itemEOF) + return nil +} + +// lexLeftDelim scans the left delimiter, which is known to be present. +func lexLeftDelim(l *lexer) stateFn { + l.pos += Pos(len(l.leftDelim)) + if strings.HasPrefix(l.input[l.pos:], leftComment) { + return lexComment + } + l.emit(itemLeftDelim) + l.parenDepth = 0 + return lexInsideAction +} + +// lexComment scans a comment. The left comment marker is known to be present. +func lexComment(l *lexer) stateFn { + l.pos += Pos(len(leftComment)) + i := strings.Index(l.input[l.pos:], rightComment) + if i < 0 { + return l.errorf("unclosed comment") + } + l.pos += Pos(i + len(rightComment)) + if !strings.HasPrefix(l.input[l.pos:], l.rightDelim) { + return l.errorf("comment ends before closing delimiter") + + } + l.pos += Pos(len(l.rightDelim)) + l.ignore() + return lexText +} + +// lexRightDelim scans the right delimiter, which is known to be present. +func lexRightDelim(l *lexer) stateFn { + l.pos += Pos(len(l.rightDelim)) + l.emit(itemRightDelim) + if l.peek() == '\\' { + l.pos++ + l.emit(itemElideNewline) + } + return lexText +} + +// lexInsideAction scans the elements inside action delimiters. +func lexInsideAction(l *lexer) stateFn { + // Either number, quoted string, or identifier. + // Spaces separate arguments; runs of spaces turn into itemSpace. + // Pipe symbols separate and are emitted. + if strings.HasPrefix(l.input[l.pos:], l.rightDelim+"\\") || strings.HasPrefix(l.input[l.pos:], l.rightDelim) { + if l.parenDepth == 0 { + return lexRightDelim + } + return l.errorf("unclosed left paren") + } + switch r := l.next(); { + case r == eof || isEndOfLine(r): + return l.errorf("unclosed action") + case isSpace(r): + return lexSpace + case r == ':': + if l.next() != '=' { + return l.errorf("expected :=") + } + l.emit(itemColonEquals) + case r == '|': + l.emit(itemPipe) + case r == '"': + return lexQuote + case r == '`': + return lexRawQuote + case r == '$': + return lexVariable + case r == '\'': + return lexChar + case r == '.': + // special look-ahead for ".field" so we don't break l.backup(). + if l.pos < Pos(len(l.input)) { + r := l.input[l.pos] + if r < '0' || '9' < r { + return lexField + } + } + fallthrough // '.' can start a number. + case r == '+' || r == '-' || ('0' <= r && r <= '9'): + l.backup() + return lexNumber + case isAlphaNumeric(r): + l.backup() + return lexIdentifier + case r == '(': + l.emit(itemLeftParen) + l.parenDepth++ + return lexInsideAction + case r == ')': + l.emit(itemRightParen) + l.parenDepth-- + if l.parenDepth < 0 { + return l.errorf("unexpected right paren %#U", r) + } + return lexInsideAction + case r <= unicode.MaxASCII && unicode.IsPrint(r): + l.emit(itemChar) + return lexInsideAction + default: + return l.errorf("unrecognized character in action: %#U", r) + } + return lexInsideAction +} + +// lexSpace scans a run of space characters. +// One space has already been seen. +func lexSpace(l *lexer) stateFn { + for isSpace(l.peek()) { + l.next() + } + l.emit(itemSpace) + return lexInsideAction +} + +// lexIdentifier scans an alphanumeric. +func lexIdentifier(l *lexer) stateFn { +Loop: + for { + switch r := l.next(); { + case isAlphaNumeric(r): + // absorb. + default: + l.backup() + word := l.input[l.start:l.pos] + if !l.atTerminator() { + return l.errorf("bad character %#U", r) + } + switch { + case key[word] > itemKeyword: + l.emit(key[word]) + case word[0] == '.': + l.emit(itemField) + case word == "true", word == "false": + l.emit(itemBool) + default: + l.emit(itemIdentifier) + } + break Loop + } + } + return lexInsideAction +} + +// lexField scans a field: .Alphanumeric. +// The . has been scanned. +func lexField(l *lexer) stateFn { + return lexFieldOrVariable(l, itemField) +} + +// lexVariable scans a Variable: $Alphanumeric. +// The $ has been scanned. +func lexVariable(l *lexer) stateFn { + if l.atTerminator() { // Nothing interesting follows -> "$". + l.emit(itemVariable) + return lexInsideAction + } + return lexFieldOrVariable(l, itemVariable) +} + +// lexVariable scans a field or variable: [.$]Alphanumeric. +// The . or $ has been scanned. +func lexFieldOrVariable(l *lexer, typ itemType) stateFn { + if l.atTerminator() { // Nothing interesting follows -> "." or "$". + if typ == itemVariable { + l.emit(itemVariable) + } else { + l.emit(itemDot) + } + return lexInsideAction + } + var r rune + for { + r = l.next() + if !isAlphaNumeric(r) { + l.backup() + break + } + } + if !l.atTerminator() { + return l.errorf("bad character %#U", r) + } + l.emit(typ) + return lexInsideAction +} + +// atTerminator reports whether the input is at valid termination character to +// appear after an identifier. Breaks .X.Y into two pieces. Also catches cases +// like "$x+2" not being acceptable without a space, in case we decide one +// day to implement arithmetic. +func (l *lexer) atTerminator() bool { + r := l.peek() + if isSpace(r) || isEndOfLine(r) { + return true + } + switch r { + case eof, '.', ',', '|', ':', ')', '(': + return true + } + // Does r start the delimiter? This can be ambiguous (with delim=="//", $x/2 will + // succeed but should fail) but only in extremely rare cases caused by willfully + // bad choice of delimiter. + if rd, _ := utf8.DecodeRuneInString(l.rightDelim); rd == r { + return true + } + return false +} + +// lexChar scans a character constant. The initial quote is already +// scanned. Syntax checking is done by the parser. +func lexChar(l *lexer) stateFn { +Loop: + for { + switch l.next() { + case '\\': + if r := l.next(); r != eof && r != '\n' { + break + } + fallthrough + case eof, '\n': + return l.errorf("unterminated character constant") + case '\'': + break Loop + } + } + l.emit(itemCharConstant) + return lexInsideAction +} + +// lexNumber scans a number: decimal, octal, hex, float, or imaginary. This +// isn't a perfect number scanner - for instance it accepts "." and "0x0.2" +// and "089" - but when it's wrong the input is invalid and the parser (via +// strconv) will notice. +func lexNumber(l *lexer) stateFn { + if !l.scanNumber() { + return l.errorf("bad number syntax: %q", l.input[l.start:l.pos]) + } + if sign := l.peek(); sign == '+' || sign == '-' { + // Complex: 1+2i. No spaces, must end in 'i'. + if !l.scanNumber() || l.input[l.pos-1] != 'i' { + return l.errorf("bad number syntax: %q", l.input[l.start:l.pos]) + } + l.emit(itemComplex) + } else { + l.emit(itemNumber) + } + return lexInsideAction +} + +func (l *lexer) scanNumber() bool { + // Optional leading sign. + l.accept("+-") + // Is it hex? + digits := "0123456789" + if l.accept("0") && l.accept("xX") { + digits = "0123456789abcdefABCDEF" + } + l.acceptRun(digits) + if l.accept(".") { + l.acceptRun(digits) + } + if l.accept("eE") { + l.accept("+-") + l.acceptRun("0123456789") + } + // Is it imaginary? + l.accept("i") + // Next thing mustn't be alphanumeric. + if isAlphaNumeric(l.peek()) { + l.next() + return false + } + return true +} + +// lexQuote scans a quoted string. +func lexQuote(l *lexer) stateFn { +Loop: + for { + switch l.next() { + case '\\': + if r := l.next(); r != eof && r != '\n' { + break + } + fallthrough + case eof, '\n': + return l.errorf("unterminated quoted string") + case '"': + break Loop + } + } + l.emit(itemString) + return lexInsideAction +} + +// lexRawQuote scans a raw quoted string. +func lexRawQuote(l *lexer) stateFn { +Loop: + for { + switch l.next() { + case eof, '\n': + return l.errorf("unterminated raw quoted string") + case '`': + break Loop + } + } + l.emit(itemRawString) + return lexInsideAction +} + +// isSpace reports whether r is a space character. +func isSpace(r rune) bool { + return r == ' ' || r == '\t' +} + +// isEndOfLine reports whether r is an end-of-line character. +func isEndOfLine(r rune) bool { + return r == '\r' || r == '\n' +} + +// isAlphaNumeric reports whether r is an alphabetic, digit, or underscore. +func isAlphaNumeric(r rune) bool { + return r == '_' || unicode.IsLetter(r) || unicode.IsDigit(r) +} diff --git a/src/alertmanager/vendor/github.com/alecthomas/template/parse/node.go b/src/alertmanager/vendor/github.com/alecthomas/template/parse/node.go new file mode 100644 index 0000000..55c37f6 --- /dev/null +++ b/src/alertmanager/vendor/github.com/alecthomas/template/parse/node.go @@ -0,0 +1,834 @@ +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Parse nodes. + +package parse + +import ( + "bytes" + "fmt" + "strconv" + "strings" +) + +var textFormat = "%s" // Changed to "%q" in tests for better error messages. + +// A Node is an element in the parse tree. The interface is trivial. +// The interface contains an unexported method so that only +// types local to this package can satisfy it. +type Node interface { + Type() NodeType + String() string + // Copy does a deep copy of the Node and all its components. + // To avoid type assertions, some XxxNodes also have specialized + // CopyXxx methods that return *XxxNode. + Copy() Node + Position() Pos // byte position of start of node in full original input string + // tree returns the containing *Tree. + // It is unexported so all implementations of Node are in this package. + tree() *Tree +} + +// NodeType identifies the type of a parse tree node. +type NodeType int + +// Pos represents a byte position in the original input text from which +// this template was parsed. +type Pos int + +func (p Pos) Position() Pos { + return p +} + +// Type returns itself and provides an easy default implementation +// for embedding in a Node. Embedded in all non-trivial Nodes. +func (t NodeType) Type() NodeType { + return t +} + +const ( + NodeText NodeType = iota // Plain text. + NodeAction // A non-control action such as a field evaluation. + NodeBool // A boolean constant. + NodeChain // A sequence of field accesses. + NodeCommand // An element of a pipeline. + NodeDot // The cursor, dot. + nodeElse // An else action. Not added to tree. + nodeEnd // An end action. Not added to tree. + NodeField // A field or method name. + NodeIdentifier // An identifier; always a function name. + NodeIf // An if action. + NodeList // A list of Nodes. + NodeNil // An untyped nil constant. + NodeNumber // A numerical constant. + NodePipe // A pipeline of commands. + NodeRange // A range action. + NodeString // A string constant. + NodeTemplate // A template invocation action. + NodeVariable // A $ variable. + NodeWith // A with action. +) + +// Nodes. + +// ListNode holds a sequence of nodes. +type ListNode struct { + NodeType + Pos + tr *Tree + Nodes []Node // The element nodes in lexical order. +} + +func (t *Tree) newList(pos Pos) *ListNode { + return &ListNode{tr: t, NodeType: NodeList, Pos: pos} +} + +func (l *ListNode) append(n Node) { + l.Nodes = append(l.Nodes, n) +} + +func (l *ListNode) tree() *Tree { + return l.tr +} + +func (l *ListNode) String() string { + b := new(bytes.Buffer) + for _, n := range l.Nodes { + fmt.Fprint(b, n) + } + return b.String() +} + +func (l *ListNode) CopyList() *ListNode { + if l == nil { + return l + } + n := l.tr.newList(l.Pos) + for _, elem := range l.Nodes { + n.append(elem.Copy()) + } + return n +} + +func (l *ListNode) Copy() Node { + return l.CopyList() +} + +// TextNode holds plain text. +type TextNode struct { + NodeType + Pos + tr *Tree + Text []byte // The text; may span newlines. +} + +func (t *Tree) newText(pos Pos, text string) *TextNode { + return &TextNode{tr: t, NodeType: NodeText, Pos: pos, Text: []byte(text)} +} + +func (t *TextNode) String() string { + return fmt.Sprintf(textFormat, t.Text) +} + +func (t *TextNode) tree() *Tree { + return t.tr +} + +func (t *TextNode) Copy() Node { + return &TextNode{tr: t.tr, NodeType: NodeText, Pos: t.Pos, Text: append([]byte{}, t.Text...)} +} + +// PipeNode holds a pipeline with optional declaration +type PipeNode struct { + NodeType + Pos + tr *Tree + Line int // The line number in the input (deprecated; kept for compatibility) + Decl []*VariableNode // Variable declarations in lexical order. + Cmds []*CommandNode // The commands in lexical order. +} + +func (t *Tree) newPipeline(pos Pos, line int, decl []*VariableNode) *PipeNode { + return &PipeNode{tr: t, NodeType: NodePipe, Pos: pos, Line: line, Decl: decl} +} + +func (p *PipeNode) append(command *CommandNode) { + p.Cmds = append(p.Cmds, command) +} + +func (p *PipeNode) String() string { + s := "" + if len(p.Decl) > 0 { + for i, v := range p.Decl { + if i > 0 { + s += ", " + } + s += v.String() + } + s += " := " + } + for i, c := range p.Cmds { + if i > 0 { + s += " | " + } + s += c.String() + } + return s +} + +func (p *PipeNode) tree() *Tree { + return p.tr +} + +func (p *PipeNode) CopyPipe() *PipeNode { + if p == nil { + return p + } + var decl []*VariableNode + for _, d := range p.Decl { + decl = append(decl, d.Copy().(*VariableNode)) + } + n := p.tr.newPipeline(p.Pos, p.Line, decl) + for _, c := range p.Cmds { + n.append(c.Copy().(*CommandNode)) + } + return n +} + +func (p *PipeNode) Copy() Node { + return p.CopyPipe() +} + +// ActionNode holds an action (something bounded by delimiters). +// Control actions have their own nodes; ActionNode represents simple +// ones such as field evaluations and parenthesized pipelines. +type ActionNode struct { + NodeType + Pos + tr *Tree + Line int // The line number in the input (deprecated; kept for compatibility) + Pipe *PipeNode // The pipeline in the action. +} + +func (t *Tree) newAction(pos Pos, line int, pipe *PipeNode) *ActionNode { + return &ActionNode{tr: t, NodeType: NodeAction, Pos: pos, Line: line, Pipe: pipe} +} + +func (a *ActionNode) String() string { + return fmt.Sprintf("{{%s}}", a.Pipe) + +} + +func (a *ActionNode) tree() *Tree { + return a.tr +} + +func (a *ActionNode) Copy() Node { + return a.tr.newAction(a.Pos, a.Line, a.Pipe.CopyPipe()) + +} + +// CommandNode holds a command (a pipeline inside an evaluating action). +type CommandNode struct { + NodeType + Pos + tr *Tree + Args []Node // Arguments in lexical order: Identifier, field, or constant. +} + +func (t *Tree) newCommand(pos Pos) *CommandNode { + return &CommandNode{tr: t, NodeType: NodeCommand, Pos: pos} +} + +func (c *CommandNode) append(arg Node) { + c.Args = append(c.Args, arg) +} + +func (c *CommandNode) String() string { + s := "" + for i, arg := range c.Args { + if i > 0 { + s += " " + } + if arg, ok := arg.(*PipeNode); ok { + s += "(" + arg.String() + ")" + continue + } + s += arg.String() + } + return s +} + +func (c *CommandNode) tree() *Tree { + return c.tr +} + +func (c *CommandNode) Copy() Node { + if c == nil { + return c + } + n := c.tr.newCommand(c.Pos) + for _, c := range c.Args { + n.append(c.Copy()) + } + return n +} + +// IdentifierNode holds an identifier. +type IdentifierNode struct { + NodeType + Pos + tr *Tree + Ident string // The identifier's name. +} + +// NewIdentifier returns a new IdentifierNode with the given identifier name. +func NewIdentifier(ident string) *IdentifierNode { + return &IdentifierNode{NodeType: NodeIdentifier, Ident: ident} +} + +// SetPos sets the position. NewIdentifier is a public method so we can't modify its signature. +// Chained for convenience. +// TODO: fix one day? +func (i *IdentifierNode) SetPos(pos Pos) *IdentifierNode { + i.Pos = pos + return i +} + +// SetTree sets the parent tree for the node. NewIdentifier is a public method so we can't modify its signature. +// Chained for convenience. +// TODO: fix one day? +func (i *IdentifierNode) SetTree(t *Tree) *IdentifierNode { + i.tr = t + return i +} + +func (i *IdentifierNode) String() string { + return i.Ident +} + +func (i *IdentifierNode) tree() *Tree { + return i.tr +} + +func (i *IdentifierNode) Copy() Node { + return NewIdentifier(i.Ident).SetTree(i.tr).SetPos(i.Pos) +} + +// VariableNode holds a list of variable names, possibly with chained field +// accesses. The dollar sign is part of the (first) name. +type VariableNode struct { + NodeType + Pos + tr *Tree + Ident []string // Variable name and fields in lexical order. +} + +func (t *Tree) newVariable(pos Pos, ident string) *VariableNode { + return &VariableNode{tr: t, NodeType: NodeVariable, Pos: pos, Ident: strings.Split(ident, ".")} +} + +func (v *VariableNode) String() string { + s := "" + for i, id := range v.Ident { + if i > 0 { + s += "." + } + s += id + } + return s +} + +func (v *VariableNode) tree() *Tree { + return v.tr +} + +func (v *VariableNode) Copy() Node { + return &VariableNode{tr: v.tr, NodeType: NodeVariable, Pos: v.Pos, Ident: append([]string{}, v.Ident...)} +} + +// DotNode holds the special identifier '.'. +type DotNode struct { + NodeType + Pos + tr *Tree +} + +func (t *Tree) newDot(pos Pos) *DotNode { + return &DotNode{tr: t, NodeType: NodeDot, Pos: pos} +} + +func (d *DotNode) Type() NodeType { + // Override method on embedded NodeType for API compatibility. + // TODO: Not really a problem; could change API without effect but + // api tool complains. + return NodeDot +} + +func (d *DotNode) String() string { + return "." +} + +func (d *DotNode) tree() *Tree { + return d.tr +} + +func (d *DotNode) Copy() Node { + return d.tr.newDot(d.Pos) +} + +// NilNode holds the special identifier 'nil' representing an untyped nil constant. +type NilNode struct { + NodeType + Pos + tr *Tree +} + +func (t *Tree) newNil(pos Pos) *NilNode { + return &NilNode{tr: t, NodeType: NodeNil, Pos: pos} +} + +func (n *NilNode) Type() NodeType { + // Override method on embedded NodeType for API compatibility. + // TODO: Not really a problem; could change API without effect but + // api tool complains. + return NodeNil +} + +func (n *NilNode) String() string { + return "nil" +} + +func (n *NilNode) tree() *Tree { + return n.tr +} + +func (n *NilNode) Copy() Node { + return n.tr.newNil(n.Pos) +} + +// FieldNode holds a field (identifier starting with '.'). +// The names may be chained ('.x.y'). +// The period is dropped from each ident. +type FieldNode struct { + NodeType + Pos + tr *Tree + Ident []string // The identifiers in lexical order. +} + +func (t *Tree) newField(pos Pos, ident string) *FieldNode { + return &FieldNode{tr: t, NodeType: NodeField, Pos: pos, Ident: strings.Split(ident[1:], ".")} // [1:] to drop leading period +} + +func (f *FieldNode) String() string { + s := "" + for _, id := range f.Ident { + s += "." + id + } + return s +} + +func (f *FieldNode) tree() *Tree { + return f.tr +} + +func (f *FieldNode) Copy() Node { + return &FieldNode{tr: f.tr, NodeType: NodeField, Pos: f.Pos, Ident: append([]string{}, f.Ident...)} +} + +// ChainNode holds a term followed by a chain of field accesses (identifier starting with '.'). +// The names may be chained ('.x.y'). +// The periods are dropped from each ident. +type ChainNode struct { + NodeType + Pos + tr *Tree + Node Node + Field []string // The identifiers in lexical order. +} + +func (t *Tree) newChain(pos Pos, node Node) *ChainNode { + return &ChainNode{tr: t, NodeType: NodeChain, Pos: pos, Node: node} +} + +// Add adds the named field (which should start with a period) to the end of the chain. +func (c *ChainNode) Add(field string) { + if len(field) == 0 || field[0] != '.' { + panic("no dot in field") + } + field = field[1:] // Remove leading dot. + if field == "" { + panic("empty field") + } + c.Field = append(c.Field, field) +} + +func (c *ChainNode) String() string { + s := c.Node.String() + if _, ok := c.Node.(*PipeNode); ok { + s = "(" + s + ")" + } + for _, field := range c.Field { + s += "." + field + } + return s +} + +func (c *ChainNode) tree() *Tree { + return c.tr +} + +func (c *ChainNode) Copy() Node { + return &ChainNode{tr: c.tr, NodeType: NodeChain, Pos: c.Pos, Node: c.Node, Field: append([]string{}, c.Field...)} +} + +// BoolNode holds a boolean constant. +type BoolNode struct { + NodeType + Pos + tr *Tree + True bool // The value of the boolean constant. +} + +func (t *Tree) newBool(pos Pos, true bool) *BoolNode { + return &BoolNode{tr: t, NodeType: NodeBool, Pos: pos, True: true} +} + +func (b *BoolNode) String() string { + if b.True { + return "true" + } + return "false" +} + +func (b *BoolNode) tree() *Tree { + return b.tr +} + +func (b *BoolNode) Copy() Node { + return b.tr.newBool(b.Pos, b.True) +} + +// NumberNode holds a number: signed or unsigned integer, float, or complex. +// The value is parsed and stored under all the types that can represent the value. +// This simulates in a small amount of code the behavior of Go's ideal constants. +type NumberNode struct { + NodeType + Pos + tr *Tree + IsInt bool // Number has an integral value. + IsUint bool // Number has an unsigned integral value. + IsFloat bool // Number has a floating-point value. + IsComplex bool // Number is complex. + Int64 int64 // The signed integer value. + Uint64 uint64 // The unsigned integer value. + Float64 float64 // The floating-point value. + Complex128 complex128 // The complex value. + Text string // The original textual representation from the input. +} + +func (t *Tree) newNumber(pos Pos, text string, typ itemType) (*NumberNode, error) { + n := &NumberNode{tr: t, NodeType: NodeNumber, Pos: pos, Text: text} + switch typ { + case itemCharConstant: + rune, _, tail, err := strconv.UnquoteChar(text[1:], text[0]) + if err != nil { + return nil, err + } + if tail != "'" { + return nil, fmt.Errorf("malformed character constant: %s", text) + } + n.Int64 = int64(rune) + n.IsInt = true + n.Uint64 = uint64(rune) + n.IsUint = true + n.Float64 = float64(rune) // odd but those are the rules. + n.IsFloat = true + return n, nil + case itemComplex: + // fmt.Sscan can parse the pair, so let it do the work. + if _, err := fmt.Sscan(text, &n.Complex128); err != nil { + return nil, err + } + n.IsComplex = true + n.simplifyComplex() + return n, nil + } + // Imaginary constants can only be complex unless they are zero. + if len(text) > 0 && text[len(text)-1] == 'i' { + f, err := strconv.ParseFloat(text[:len(text)-1], 64) + if err == nil { + n.IsComplex = true + n.Complex128 = complex(0, f) + n.simplifyComplex() + return n, nil + } + } + // Do integer test first so we get 0x123 etc. + u, err := strconv.ParseUint(text, 0, 64) // will fail for -0; fixed below. + if err == nil { + n.IsUint = true + n.Uint64 = u + } + i, err := strconv.ParseInt(text, 0, 64) + if err == nil { + n.IsInt = true + n.Int64 = i + if i == 0 { + n.IsUint = true // in case of -0. + n.Uint64 = u + } + } + // If an integer extraction succeeded, promote the float. + if n.IsInt { + n.IsFloat = true + n.Float64 = float64(n.Int64) + } else if n.IsUint { + n.IsFloat = true + n.Float64 = float64(n.Uint64) + } else { + f, err := strconv.ParseFloat(text, 64) + if err == nil { + n.IsFloat = true + n.Float64 = f + // If a floating-point extraction succeeded, extract the int if needed. + if !n.IsInt && float64(int64(f)) == f { + n.IsInt = true + n.Int64 = int64(f) + } + if !n.IsUint && float64(uint64(f)) == f { + n.IsUint = true + n.Uint64 = uint64(f) + } + } + } + if !n.IsInt && !n.IsUint && !n.IsFloat { + return nil, fmt.Errorf("illegal number syntax: %q", text) + } + return n, nil +} + +// simplifyComplex pulls out any other types that are represented by the complex number. +// These all require that the imaginary part be zero. +func (n *NumberNode) simplifyComplex() { + n.IsFloat = imag(n.Complex128) == 0 + if n.IsFloat { + n.Float64 = real(n.Complex128) + n.IsInt = float64(int64(n.Float64)) == n.Float64 + if n.IsInt { + n.Int64 = int64(n.Float64) + } + n.IsUint = float64(uint64(n.Float64)) == n.Float64 + if n.IsUint { + n.Uint64 = uint64(n.Float64) + } + } +} + +func (n *NumberNode) String() string { + return n.Text +} + +func (n *NumberNode) tree() *Tree { + return n.tr +} + +func (n *NumberNode) Copy() Node { + nn := new(NumberNode) + *nn = *n // Easy, fast, correct. + return nn +} + +// StringNode holds a string constant. The value has been "unquoted". +type StringNode struct { + NodeType + Pos + tr *Tree + Quoted string // The original text of the string, with quotes. + Text string // The string, after quote processing. +} + +func (t *Tree) newString(pos Pos, orig, text string) *StringNode { + return &StringNode{tr: t, NodeType: NodeString, Pos: pos, Quoted: orig, Text: text} +} + +func (s *StringNode) String() string { + return s.Quoted +} + +func (s *StringNode) tree() *Tree { + return s.tr +} + +func (s *StringNode) Copy() Node { + return s.tr.newString(s.Pos, s.Quoted, s.Text) +} + +// endNode represents an {{end}} action. +// It does not appear in the final parse tree. +type endNode struct { + NodeType + Pos + tr *Tree +} + +func (t *Tree) newEnd(pos Pos) *endNode { + return &endNode{tr: t, NodeType: nodeEnd, Pos: pos} +} + +func (e *endNode) String() string { + return "{{end}}" +} + +func (e *endNode) tree() *Tree { + return e.tr +} + +func (e *endNode) Copy() Node { + return e.tr.newEnd(e.Pos) +} + +// elseNode represents an {{else}} action. Does not appear in the final tree. +type elseNode struct { + NodeType + Pos + tr *Tree + Line int // The line number in the input (deprecated; kept for compatibility) +} + +func (t *Tree) newElse(pos Pos, line int) *elseNode { + return &elseNode{tr: t, NodeType: nodeElse, Pos: pos, Line: line} +} + +func (e *elseNode) Type() NodeType { + return nodeElse +} + +func (e *elseNode) String() string { + return "{{else}}" +} + +func (e *elseNode) tree() *Tree { + return e.tr +} + +func (e *elseNode) Copy() Node { + return e.tr.newElse(e.Pos, e.Line) +} + +// BranchNode is the common representation of if, range, and with. +type BranchNode struct { + NodeType + Pos + tr *Tree + Line int // The line number in the input (deprecated; kept for compatibility) + Pipe *PipeNode // The pipeline to be evaluated. + List *ListNode // What to execute if the value is non-empty. + ElseList *ListNode // What to execute if the value is empty (nil if absent). +} + +func (b *BranchNode) String() string { + name := "" + switch b.NodeType { + case NodeIf: + name = "if" + case NodeRange: + name = "range" + case NodeWith: + name = "with" + default: + panic("unknown branch type") + } + if b.ElseList != nil { + return fmt.Sprintf("{{%s %s}}%s{{else}}%s{{end}}", name, b.Pipe, b.List, b.ElseList) + } + return fmt.Sprintf("{{%s %s}}%s{{end}}", name, b.Pipe, b.List) +} + +func (b *BranchNode) tree() *Tree { + return b.tr +} + +func (b *BranchNode) Copy() Node { + switch b.NodeType { + case NodeIf: + return b.tr.newIf(b.Pos, b.Line, b.Pipe, b.List, b.ElseList) + case NodeRange: + return b.tr.newRange(b.Pos, b.Line, b.Pipe, b.List, b.ElseList) + case NodeWith: + return b.tr.newWith(b.Pos, b.Line, b.Pipe, b.List, b.ElseList) + default: + panic("unknown branch type") + } +} + +// IfNode represents an {{if}} action and its commands. +type IfNode struct { + BranchNode +} + +func (t *Tree) newIf(pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) *IfNode { + return &IfNode{BranchNode{tr: t, NodeType: NodeIf, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}} +} + +func (i *IfNode) Copy() Node { + return i.tr.newIf(i.Pos, i.Line, i.Pipe.CopyPipe(), i.List.CopyList(), i.ElseList.CopyList()) +} + +// RangeNode represents a {{range}} action and its commands. +type RangeNode struct { + BranchNode +} + +func (t *Tree) newRange(pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) *RangeNode { + return &RangeNode{BranchNode{tr: t, NodeType: NodeRange, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}} +} + +func (r *RangeNode) Copy() Node { + return r.tr.newRange(r.Pos, r.Line, r.Pipe.CopyPipe(), r.List.CopyList(), r.ElseList.CopyList()) +} + +// WithNode represents a {{with}} action and its commands. +type WithNode struct { + BranchNode +} + +func (t *Tree) newWith(pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) *WithNode { + return &WithNode{BranchNode{tr: t, NodeType: NodeWith, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}} +} + +func (w *WithNode) Copy() Node { + return w.tr.newWith(w.Pos, w.Line, w.Pipe.CopyPipe(), w.List.CopyList(), w.ElseList.CopyList()) +} + +// TemplateNode represents a {{template}} action. +type TemplateNode struct { + NodeType + Pos + tr *Tree + Line int // The line number in the input (deprecated; kept for compatibility) + Name string // The name of the template (unquoted). + Pipe *PipeNode // The command to evaluate as dot for the template. +} + +func (t *Tree) newTemplate(pos Pos, line int, name string, pipe *PipeNode) *TemplateNode { + return &TemplateNode{tr: t, NodeType: NodeTemplate, Pos: pos, Line: line, Name: name, Pipe: pipe} +} + +func (t *TemplateNode) String() string { + if t.Pipe == nil { + return fmt.Sprintf("{{template %q}}", t.Name) + } + return fmt.Sprintf("{{template %q %s}}", t.Name, t.Pipe) +} + +func (t *TemplateNode) tree() *Tree { + return t.tr +} + +func (t *TemplateNode) Copy() Node { + return t.tr.newTemplate(t.Pos, t.Line, t.Name, t.Pipe.CopyPipe()) +} diff --git a/src/alertmanager/vendor/github.com/alecthomas/template/parse/parse.go b/src/alertmanager/vendor/github.com/alecthomas/template/parse/parse.go new file mode 100644 index 0000000..0d77ade --- /dev/null +++ b/src/alertmanager/vendor/github.com/alecthomas/template/parse/parse.go @@ -0,0 +1,700 @@ +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package parse builds parse trees for templates as defined by text/template +// and html/template. Clients should use those packages to construct templates +// rather than this one, which provides shared internal data structures not +// intended for general use. +package parse + +import ( + "bytes" + "fmt" + "runtime" + "strconv" + "strings" +) + +// Tree is the representation of a single parsed template. +type Tree struct { + Name string // name of the template represented by the tree. + ParseName string // name of the top-level template during parsing, for error messages. + Root *ListNode // top-level root of the tree. + text string // text parsed to create the template (or its parent) + // Parsing only; cleared after parse. + funcs []map[string]interface{} + lex *lexer + token [3]item // three-token lookahead for parser. + peekCount int + vars []string // variables defined at the moment. +} + +// Copy returns a copy of the Tree. Any parsing state is discarded. +func (t *Tree) Copy() *Tree { + if t == nil { + return nil + } + return &Tree{ + Name: t.Name, + ParseName: t.ParseName, + Root: t.Root.CopyList(), + text: t.text, + } +} + +// Parse returns a map from template name to parse.Tree, created by parsing the +// templates described in the argument string. The top-level template will be +// given the specified name. If an error is encountered, parsing stops and an +// empty map is returned with the error. +func Parse(name, text, leftDelim, rightDelim string, funcs ...map[string]interface{}) (treeSet map[string]*Tree, err error) { + treeSet = make(map[string]*Tree) + t := New(name) + t.text = text + _, err = t.Parse(text, leftDelim, rightDelim, treeSet, funcs...) + return +} + +// next returns the next token. +func (t *Tree) next() item { + if t.peekCount > 0 { + t.peekCount-- + } else { + t.token[0] = t.lex.nextItem() + } + return t.token[t.peekCount] +} + +// backup backs the input stream up one token. +func (t *Tree) backup() { + t.peekCount++ +} + +// backup2 backs the input stream up two tokens. +// The zeroth token is already there. +func (t *Tree) backup2(t1 item) { + t.token[1] = t1 + t.peekCount = 2 +} + +// backup3 backs the input stream up three tokens +// The zeroth token is already there. +func (t *Tree) backup3(t2, t1 item) { // Reverse order: we're pushing back. + t.token[1] = t1 + t.token[2] = t2 + t.peekCount = 3 +} + +// peek returns but does not consume the next token. +func (t *Tree) peek() item { + if t.peekCount > 0 { + return t.token[t.peekCount-1] + } + t.peekCount = 1 + t.token[0] = t.lex.nextItem() + return t.token[0] +} + +// nextNonSpace returns the next non-space token. +func (t *Tree) nextNonSpace() (token item) { + for { + token = t.next() + if token.typ != itemSpace { + break + } + } + return token +} + +// peekNonSpace returns but does not consume the next non-space token. +func (t *Tree) peekNonSpace() (token item) { + for { + token = t.next() + if token.typ != itemSpace { + break + } + } + t.backup() + return token +} + +// Parsing. + +// New allocates a new parse tree with the given name. +func New(name string, funcs ...map[string]interface{}) *Tree { + return &Tree{ + Name: name, + funcs: funcs, + } +} + +// ErrorContext returns a textual representation of the location of the node in the input text. +// The receiver is only used when the node does not have a pointer to the tree inside, +// which can occur in old code. +func (t *Tree) ErrorContext(n Node) (location, context string) { + pos := int(n.Position()) + tree := n.tree() + if tree == nil { + tree = t + } + text := tree.text[:pos] + byteNum := strings.LastIndex(text, "\n") + if byteNum == -1 { + byteNum = pos // On first line. + } else { + byteNum++ // After the newline. + byteNum = pos - byteNum + } + lineNum := 1 + strings.Count(text, "\n") + context = n.String() + if len(context) > 20 { + context = fmt.Sprintf("%.20s...", context) + } + return fmt.Sprintf("%s:%d:%d", tree.ParseName, lineNum, byteNum), context +} + +// errorf formats the error and terminates processing. +func (t *Tree) errorf(format string, args ...interface{}) { + t.Root = nil + format = fmt.Sprintf("template: %s:%d: %s", t.ParseName, t.lex.lineNumber(), format) + panic(fmt.Errorf(format, args...)) +} + +// error terminates processing. +func (t *Tree) error(err error) { + t.errorf("%s", err) +} + +// expect consumes the next token and guarantees it has the required type. +func (t *Tree) expect(expected itemType, context string) item { + token := t.nextNonSpace() + if token.typ != expected { + t.unexpected(token, context) + } + return token +} + +// expectOneOf consumes the next token and guarantees it has one of the required types. +func (t *Tree) expectOneOf(expected1, expected2 itemType, context string) item { + token := t.nextNonSpace() + if token.typ != expected1 && token.typ != expected2 { + t.unexpected(token, context) + } + return token +} + +// unexpected complains about the token and terminates processing. +func (t *Tree) unexpected(token item, context string) { + t.errorf("unexpected %s in %s", token, context) +} + +// recover is the handler that turns panics into returns from the top level of Parse. +func (t *Tree) recover(errp *error) { + e := recover() + if e != nil { + if _, ok := e.(runtime.Error); ok { + panic(e) + } + if t != nil { + t.stopParse() + } + *errp = e.(error) + } + return +} + +// startParse initializes the parser, using the lexer. +func (t *Tree) startParse(funcs []map[string]interface{}, lex *lexer) { + t.Root = nil + t.lex = lex + t.vars = []string{"$"} + t.funcs = funcs +} + +// stopParse terminates parsing. +func (t *Tree) stopParse() { + t.lex = nil + t.vars = nil + t.funcs = nil +} + +// Parse parses the template definition string to construct a representation of +// the template for execution. If either action delimiter string is empty, the +// default ("{{" or "}}") is used. Embedded template definitions are added to +// the treeSet map. +func (t *Tree) Parse(text, leftDelim, rightDelim string, treeSet map[string]*Tree, funcs ...map[string]interface{}) (tree *Tree, err error) { + defer t.recover(&err) + t.ParseName = t.Name + t.startParse(funcs, lex(t.Name, text, leftDelim, rightDelim)) + t.text = text + t.parse(treeSet) + t.add(treeSet) + t.stopParse() + return t, nil +} + +// add adds tree to the treeSet. +func (t *Tree) add(treeSet map[string]*Tree) { + tree := treeSet[t.Name] + if tree == nil || IsEmptyTree(tree.Root) { + treeSet[t.Name] = t + return + } + if !IsEmptyTree(t.Root) { + t.errorf("template: multiple definition of template %q", t.Name) + } +} + +// IsEmptyTree reports whether this tree (node) is empty of everything but space. +func IsEmptyTree(n Node) bool { + switch n := n.(type) { + case nil: + return true + case *ActionNode: + case *IfNode: + case *ListNode: + for _, node := range n.Nodes { + if !IsEmptyTree(node) { + return false + } + } + return true + case *RangeNode: + case *TemplateNode: + case *TextNode: + return len(bytes.TrimSpace(n.Text)) == 0 + case *WithNode: + default: + panic("unknown node: " + n.String()) + } + return false +} + +// parse is the top-level parser for a template, essentially the same +// as itemList except it also parses {{define}} actions. +// It runs to EOF. +func (t *Tree) parse(treeSet map[string]*Tree) (next Node) { + t.Root = t.newList(t.peek().pos) + for t.peek().typ != itemEOF { + if t.peek().typ == itemLeftDelim { + delim := t.next() + if t.nextNonSpace().typ == itemDefine { + newT := New("definition") // name will be updated once we know it. + newT.text = t.text + newT.ParseName = t.ParseName + newT.startParse(t.funcs, t.lex) + newT.parseDefinition(treeSet) + continue + } + t.backup2(delim) + } + n := t.textOrAction() + if n.Type() == nodeEnd { + t.errorf("unexpected %s", n) + } + t.Root.append(n) + } + return nil +} + +// parseDefinition parses a {{define}} ... {{end}} template definition and +// installs the definition in the treeSet map. The "define" keyword has already +// been scanned. +func (t *Tree) parseDefinition(treeSet map[string]*Tree) { + const context = "define clause" + name := t.expectOneOf(itemString, itemRawString, context) + var err error + t.Name, err = strconv.Unquote(name.val) + if err != nil { + t.error(err) + } + t.expect(itemRightDelim, context) + var end Node + t.Root, end = t.itemList() + if end.Type() != nodeEnd { + t.errorf("unexpected %s in %s", end, context) + } + t.add(treeSet) + t.stopParse() +} + +// itemList: +// textOrAction* +// Terminates at {{end}} or {{else}}, returned separately. +func (t *Tree) itemList() (list *ListNode, next Node) { + list = t.newList(t.peekNonSpace().pos) + for t.peekNonSpace().typ != itemEOF { + n := t.textOrAction() + switch n.Type() { + case nodeEnd, nodeElse: + return list, n + } + list.append(n) + } + t.errorf("unexpected EOF") + return +} + +// textOrAction: +// text | action +func (t *Tree) textOrAction() Node { + switch token := t.nextNonSpace(); token.typ { + case itemElideNewline: + return t.elideNewline() + case itemText: + return t.newText(token.pos, token.val) + case itemLeftDelim: + return t.action() + default: + t.unexpected(token, "input") + } + return nil +} + +// elideNewline: +// Remove newlines trailing rightDelim if \\ is present. +func (t *Tree) elideNewline() Node { + token := t.peek() + if token.typ != itemText { + t.unexpected(token, "input") + return nil + } + + t.next() + stripped := strings.TrimLeft(token.val, "\n\r") + diff := len(token.val) - len(stripped) + if diff > 0 { + // This is a bit nasty. We mutate the token in-place to remove + // preceding newlines. + token.pos += Pos(diff) + token.val = stripped + } + return t.newText(token.pos, token.val) +} + +// Action: +// control +// command ("|" command)* +// Left delim is past. Now get actions. +// First word could be a keyword such as range. +func (t *Tree) action() (n Node) { + switch token := t.nextNonSpace(); token.typ { + case itemElse: + return t.elseControl() + case itemEnd: + return t.endControl() + case itemIf: + return t.ifControl() + case itemRange: + return t.rangeControl() + case itemTemplate: + return t.templateControl() + case itemWith: + return t.withControl() + } + t.backup() + // Do not pop variables; they persist until "end". + return t.newAction(t.peek().pos, t.lex.lineNumber(), t.pipeline("command")) +} + +// Pipeline: +// declarations? command ('|' command)* +func (t *Tree) pipeline(context string) (pipe *PipeNode) { + var decl []*VariableNode + pos := t.peekNonSpace().pos + // Are there declarations? + for { + if v := t.peekNonSpace(); v.typ == itemVariable { + t.next() + // Since space is a token, we need 3-token look-ahead here in the worst case: + // in "$x foo" we need to read "foo" (as opposed to ":=") to know that $x is an + // argument variable rather than a declaration. So remember the token + // adjacent to the variable so we can push it back if necessary. + tokenAfterVariable := t.peek() + if next := t.peekNonSpace(); next.typ == itemColonEquals || (next.typ == itemChar && next.val == ",") { + t.nextNonSpace() + variable := t.newVariable(v.pos, v.val) + decl = append(decl, variable) + t.vars = append(t.vars, v.val) + if next.typ == itemChar && next.val == "," { + if context == "range" && len(decl) < 2 { + continue + } + t.errorf("too many declarations in %s", context) + } + } else if tokenAfterVariable.typ == itemSpace { + t.backup3(v, tokenAfterVariable) + } else { + t.backup2(v) + } + } + break + } + pipe = t.newPipeline(pos, t.lex.lineNumber(), decl) + for { + switch token := t.nextNonSpace(); token.typ { + case itemRightDelim, itemRightParen: + if len(pipe.Cmds) == 0 { + t.errorf("missing value for %s", context) + } + if token.typ == itemRightParen { + t.backup() + } + return + case itemBool, itemCharConstant, itemComplex, itemDot, itemField, itemIdentifier, + itemNumber, itemNil, itemRawString, itemString, itemVariable, itemLeftParen: + t.backup() + pipe.append(t.command()) + default: + t.unexpected(token, context) + } + } +} + +func (t *Tree) parseControl(allowElseIf bool, context string) (pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) { + defer t.popVars(len(t.vars)) + line = t.lex.lineNumber() + pipe = t.pipeline(context) + var next Node + list, next = t.itemList() + switch next.Type() { + case nodeEnd: //done + case nodeElse: + if allowElseIf { + // Special case for "else if". If the "else" is followed immediately by an "if", + // the elseControl will have left the "if" token pending. Treat + // {{if a}}_{{else if b}}_{{end}} + // as + // {{if a}}_{{else}}{{if b}}_{{end}}{{end}}. + // To do this, parse the if as usual and stop at it {{end}}; the subsequent{{end}} + // is assumed. This technique works even for long if-else-if chains. + // TODO: Should we allow else-if in with and range? + if t.peek().typ == itemIf { + t.next() // Consume the "if" token. + elseList = t.newList(next.Position()) + elseList.append(t.ifControl()) + // Do not consume the next item - only one {{end}} required. + break + } + } + elseList, next = t.itemList() + if next.Type() != nodeEnd { + t.errorf("expected end; found %s", next) + } + } + return pipe.Position(), line, pipe, list, elseList +} + +// If: +// {{if pipeline}} itemList {{end}} +// {{if pipeline}} itemList {{else}} itemList {{end}} +// If keyword is past. +func (t *Tree) ifControl() Node { + return t.newIf(t.parseControl(true, "if")) +} + +// Range: +// {{range pipeline}} itemList {{end}} +// {{range pipeline}} itemList {{else}} itemList {{end}} +// Range keyword is past. +func (t *Tree) rangeControl() Node { + return t.newRange(t.parseControl(false, "range")) +} + +// With: +// {{with pipeline}} itemList {{end}} +// {{with pipeline}} itemList {{else}} itemList {{end}} +// If keyword is past. +func (t *Tree) withControl() Node { + return t.newWith(t.parseControl(false, "with")) +} + +// End: +// {{end}} +// End keyword is past. +func (t *Tree) endControl() Node { + return t.newEnd(t.expect(itemRightDelim, "end").pos) +} + +// Else: +// {{else}} +// Else keyword is past. +func (t *Tree) elseControl() Node { + // Special case for "else if". + peek := t.peekNonSpace() + if peek.typ == itemIf { + // We see "{{else if ... " but in effect rewrite it to {{else}}{{if ... ". + return t.newElse(peek.pos, t.lex.lineNumber()) + } + return t.newElse(t.expect(itemRightDelim, "else").pos, t.lex.lineNumber()) +} + +// Template: +// {{template stringValue pipeline}} +// Template keyword is past. The name must be something that can evaluate +// to a string. +func (t *Tree) templateControl() Node { + var name string + token := t.nextNonSpace() + switch token.typ { + case itemString, itemRawString: + s, err := strconv.Unquote(token.val) + if err != nil { + t.error(err) + } + name = s + default: + t.unexpected(token, "template invocation") + } + var pipe *PipeNode + if t.nextNonSpace().typ != itemRightDelim { + t.backup() + // Do not pop variables; they persist until "end". + pipe = t.pipeline("template") + } + return t.newTemplate(token.pos, t.lex.lineNumber(), name, pipe) +} + +// command: +// operand (space operand)* +// space-separated arguments up to a pipeline character or right delimiter. +// we consume the pipe character but leave the right delim to terminate the action. +func (t *Tree) command() *CommandNode { + cmd := t.newCommand(t.peekNonSpace().pos) + for { + t.peekNonSpace() // skip leading spaces. + operand := t.operand() + if operand != nil { + cmd.append(operand) + } + switch token := t.next(); token.typ { + case itemSpace: + continue + case itemError: + t.errorf("%s", token.val) + case itemRightDelim, itemRightParen: + t.backup() + case itemPipe: + default: + t.errorf("unexpected %s in operand; missing space?", token) + } + break + } + if len(cmd.Args) == 0 { + t.errorf("empty command") + } + return cmd +} + +// operand: +// term .Field* +// An operand is a space-separated component of a command, +// a term possibly followed by field accesses. +// A nil return means the next item is not an operand. +func (t *Tree) operand() Node { + node := t.term() + if node == nil { + return nil + } + if t.peek().typ == itemField { + chain := t.newChain(t.peek().pos, node) + for t.peek().typ == itemField { + chain.Add(t.next().val) + } + // Compatibility with original API: If the term is of type NodeField + // or NodeVariable, just put more fields on the original. + // Otherwise, keep the Chain node. + // TODO: Switch to Chains always when we can. + switch node.Type() { + case NodeField: + node = t.newField(chain.Position(), chain.String()) + case NodeVariable: + node = t.newVariable(chain.Position(), chain.String()) + default: + node = chain + } + } + return node +} + +// term: +// literal (number, string, nil, boolean) +// function (identifier) +// . +// .Field +// $ +// '(' pipeline ')' +// A term is a simple "expression". +// A nil return means the next item is not a term. +func (t *Tree) term() Node { + switch token := t.nextNonSpace(); token.typ { + case itemError: + t.errorf("%s", token.val) + case itemIdentifier: + if !t.hasFunction(token.val) { + t.errorf("function %q not defined", token.val) + } + return NewIdentifier(token.val).SetTree(t).SetPos(token.pos) + case itemDot: + return t.newDot(token.pos) + case itemNil: + return t.newNil(token.pos) + case itemVariable: + return t.useVar(token.pos, token.val) + case itemField: + return t.newField(token.pos, token.val) + case itemBool: + return t.newBool(token.pos, token.val == "true") + case itemCharConstant, itemComplex, itemNumber: + number, err := t.newNumber(token.pos, token.val, token.typ) + if err != nil { + t.error(err) + } + return number + case itemLeftParen: + pipe := t.pipeline("parenthesized pipeline") + if token := t.next(); token.typ != itemRightParen { + t.errorf("unclosed right paren: unexpected %s", token) + } + return pipe + case itemString, itemRawString: + s, err := strconv.Unquote(token.val) + if err != nil { + t.error(err) + } + return t.newString(token.pos, token.val, s) + } + t.backup() + return nil +} + +// hasFunction reports if a function name exists in the Tree's maps. +func (t *Tree) hasFunction(name string) bool { + for _, funcMap := range t.funcs { + if funcMap == nil { + continue + } + if funcMap[name] != nil { + return true + } + } + return false +} + +// popVars trims the variable list to the specified length +func (t *Tree) popVars(n int) { + t.vars = t.vars[:n] +} + +// useVar returns a node for a variable reference. It errors if the +// variable is not defined. +func (t *Tree) useVar(pos Pos, name string) Node { + v := t.newVariable(pos, name) + for _, varName := range t.vars { + if varName == v.Ident[0] { + return v + } + } + t.errorf("undefined variable %q", v.Ident[0]) + return nil +} diff --git a/src/alertmanager/vendor/github.com/alecthomas/template/template.go b/src/alertmanager/vendor/github.com/alecthomas/template/template.go new file mode 100644 index 0000000..447ed2a --- /dev/null +++ b/src/alertmanager/vendor/github.com/alecthomas/template/template.go @@ -0,0 +1,218 @@ +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package template + +import ( + "fmt" + "reflect" + + "github.com/alecthomas/template/parse" +) + +// common holds the information shared by related templates. +type common struct { + tmpl map[string]*Template + // We use two maps, one for parsing and one for execution. + // This separation makes the API cleaner since it doesn't + // expose reflection to the client. + parseFuncs FuncMap + execFuncs map[string]reflect.Value +} + +// Template is the representation of a parsed template. The *parse.Tree +// field is exported only for use by html/template and should be treated +// as unexported by all other clients. +type Template struct { + name string + *parse.Tree + *common + leftDelim string + rightDelim string +} + +// New allocates a new template with the given name. +func New(name string) *Template { + return &Template{ + name: name, + } +} + +// Name returns the name of the template. +func (t *Template) Name() string { + return t.name +} + +// New allocates a new template associated with the given one and with the same +// delimiters. The association, which is transitive, allows one template to +// invoke another with a {{template}} action. +func (t *Template) New(name string) *Template { + t.init() + return &Template{ + name: name, + common: t.common, + leftDelim: t.leftDelim, + rightDelim: t.rightDelim, + } +} + +func (t *Template) init() { + if t.common == nil { + t.common = new(common) + t.tmpl = make(map[string]*Template) + t.parseFuncs = make(FuncMap) + t.execFuncs = make(map[string]reflect.Value) + } +} + +// Clone returns a duplicate of the template, including all associated +// templates. The actual representation is not copied, but the name space of +// associated templates is, so further calls to Parse in the copy will add +// templates to the copy but not to the original. Clone can be used to prepare +// common templates and use them with variant definitions for other templates +// by adding the variants after the clone is made. +func (t *Template) Clone() (*Template, error) { + nt := t.copy(nil) + nt.init() + nt.tmpl[t.name] = nt + for k, v := range t.tmpl { + if k == t.name { // Already installed. + continue + } + // The associated templates share nt's common structure. + tmpl := v.copy(nt.common) + nt.tmpl[k] = tmpl + } + for k, v := range t.parseFuncs { + nt.parseFuncs[k] = v + } + for k, v := range t.execFuncs { + nt.execFuncs[k] = v + } + return nt, nil +} + +// copy returns a shallow copy of t, with common set to the argument. +func (t *Template) copy(c *common) *Template { + nt := New(t.name) + nt.Tree = t.Tree + nt.common = c + nt.leftDelim = t.leftDelim + nt.rightDelim = t.rightDelim + return nt +} + +// AddParseTree creates a new template with the name and parse tree +// and associates it with t. +func (t *Template) AddParseTree(name string, tree *parse.Tree) (*Template, error) { + if t.common != nil && t.tmpl[name] != nil { + return nil, fmt.Errorf("template: redefinition of template %q", name) + } + nt := t.New(name) + nt.Tree = tree + t.tmpl[name] = nt + return nt, nil +} + +// Templates returns a slice of the templates associated with t, including t +// itself. +func (t *Template) Templates() []*Template { + if t.common == nil { + return nil + } + // Return a slice so we don't expose the map. + m := make([]*Template, 0, len(t.tmpl)) + for _, v := range t.tmpl { + m = append(m, v) + } + return m +} + +// Delims sets the action delimiters to the specified strings, to be used in +// subsequent calls to Parse, ParseFiles, or ParseGlob. Nested template +// definitions will inherit the settings. An empty delimiter stands for the +// corresponding default: {{ or }}. +// The return value is the template, so calls can be chained. +func (t *Template) Delims(left, right string) *Template { + t.leftDelim = left + t.rightDelim = right + return t +} + +// Funcs adds the elements of the argument map to the template's function map. +// It panics if a value in the map is not a function with appropriate return +// type. However, it is legal to overwrite elements of the map. The return +// value is the template, so calls can be chained. +func (t *Template) Funcs(funcMap FuncMap) *Template { + t.init() + addValueFuncs(t.execFuncs, funcMap) + addFuncs(t.parseFuncs, funcMap) + return t +} + +// Lookup returns the template with the given name that is associated with t, +// or nil if there is no such template. +func (t *Template) Lookup(name string) *Template { + if t.common == nil { + return nil + } + return t.tmpl[name] +} + +// Parse parses a string into a template. Nested template definitions will be +// associated with the top-level template t. Parse may be called multiple times +// to parse definitions of templates to associate with t. It is an error if a +// resulting template is non-empty (contains content other than template +// definitions) and would replace a non-empty template with the same name. +// (In multiple calls to Parse with the same receiver template, only one call +// can contain text other than space, comments, and template definitions.) +func (t *Template) Parse(text string) (*Template, error) { + t.init() + trees, err := parse.Parse(t.name, text, t.leftDelim, t.rightDelim, t.parseFuncs, builtins) + if err != nil { + return nil, err + } + // Add the newly parsed trees, including the one for t, into our common structure. + for name, tree := range trees { + // If the name we parsed is the name of this template, overwrite this template. + // The associate method checks it's not a redefinition. + tmpl := t + if name != t.name { + tmpl = t.New(name) + } + // Even if t == tmpl, we need to install it in the common.tmpl map. + if replace, err := t.associate(tmpl, tree); err != nil { + return nil, err + } else if replace { + tmpl.Tree = tree + } + tmpl.leftDelim = t.leftDelim + tmpl.rightDelim = t.rightDelim + } + return t, nil +} + +// associate installs the new template into the group of templates associated +// with t. It is an error to reuse a name except to overwrite an empty +// template. The two are already known to share the common structure. +// The boolean return value reports wither to store this tree as t.Tree. +func (t *Template) associate(new *Template, tree *parse.Tree) (bool, error) { + if new.common != t.common { + panic("internal error: associate not common") + } + name := new.name + if old := t.tmpl[name]; old != nil { + oldIsEmpty := parse.IsEmptyTree(old.Root) + newIsEmpty := parse.IsEmptyTree(tree.Root) + if newIsEmpty { + // Whether old is empty or not, new is empty; no reason to replace old. + return false, nil + } + if !oldIsEmpty { + return false, fmt.Errorf("template: redefinition of template %q", name) + } + } + t.tmpl[name] = new + return true, nil +} diff --git a/src/alertmanager/vendor/github.com/alecthomas/units/COPYING b/src/alertmanager/vendor/github.com/alecthomas/units/COPYING new file mode 100644 index 0000000..2993ec0 --- /dev/null +++ b/src/alertmanager/vendor/github.com/alecthomas/units/COPYING @@ -0,0 +1,19 @@ +Copyright (C) 2014 Alec Thomas + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/src/alertmanager/vendor/github.com/alecthomas/units/README.md b/src/alertmanager/vendor/github.com/alecthomas/units/README.md new file mode 100644 index 0000000..bee884e --- /dev/null +++ b/src/alertmanager/vendor/github.com/alecthomas/units/README.md @@ -0,0 +1,11 @@ +# Units - Helpful unit multipliers and functions for Go + +The goal of this package is to have functionality similar to the [time](http://golang.org/pkg/time/) package. + +It allows for code like this: + +```go +n, err := ParseBase2Bytes("1KB") +// n == 1024 +n = units.Mebibyte * 512 +``` diff --git a/src/alertmanager/vendor/github.com/alecthomas/units/bytes.go b/src/alertmanager/vendor/github.com/alecthomas/units/bytes.go new file mode 100644 index 0000000..eaadeb8 --- /dev/null +++ b/src/alertmanager/vendor/github.com/alecthomas/units/bytes.go @@ -0,0 +1,83 @@ +package units + +// Base2Bytes is the old non-SI power-of-2 byte scale (1024 bytes in a kilobyte, +// etc.). +type Base2Bytes int64 + +// Base-2 byte units. +const ( + Kibibyte Base2Bytes = 1024 + KiB = Kibibyte + Mebibyte = Kibibyte * 1024 + MiB = Mebibyte + Gibibyte = Mebibyte * 1024 + GiB = Gibibyte + Tebibyte = Gibibyte * 1024 + TiB = Tebibyte + Pebibyte = Tebibyte * 1024 + PiB = Pebibyte + Exbibyte = Pebibyte * 1024 + EiB = Exbibyte +) + +var ( + bytesUnitMap = MakeUnitMap("iB", "B", 1024) + oldBytesUnitMap = MakeUnitMap("B", "B", 1024) +) + +// ParseBase2Bytes supports both iB and B in base-2 multipliers. That is, KB +// and KiB are both 1024. +func ParseBase2Bytes(s string) (Base2Bytes, error) { + n, err := ParseUnit(s, bytesUnitMap) + if err != nil { + n, err = ParseUnit(s, oldBytesUnitMap) + } + return Base2Bytes(n), err +} + +func (b Base2Bytes) String() string { + return ToString(int64(b), 1024, "iB", "B") +} + +var ( + metricBytesUnitMap = MakeUnitMap("B", "B", 1000) +) + +// MetricBytes are SI byte units (1000 bytes in a kilobyte). +type MetricBytes SI + +// SI base-10 byte units. +const ( + Kilobyte MetricBytes = 1000 + KB = Kilobyte + Megabyte = Kilobyte * 1000 + MB = Megabyte + Gigabyte = Megabyte * 1000 + GB = Gigabyte + Terabyte = Gigabyte * 1000 + TB = Terabyte + Petabyte = Terabyte * 1000 + PB = Petabyte + Exabyte = Petabyte * 1000 + EB = Exabyte +) + +// ParseMetricBytes parses base-10 metric byte units. That is, KB is 1000 bytes. +func ParseMetricBytes(s string) (MetricBytes, error) { + n, err := ParseUnit(s, metricBytesUnitMap) + return MetricBytes(n), err +} + +func (m MetricBytes) String() string { + return ToString(int64(m), 1000, "B", "B") +} + +// ParseStrictBytes supports both iB and B suffixes for base 2 and metric, +// respectively. That is, KiB represents 1024 and KB represents 1000. +func ParseStrictBytes(s string) (int64, error) { + n, err := ParseUnit(s, bytesUnitMap) + if err != nil { + n, err = ParseUnit(s, metricBytesUnitMap) + } + return int64(n), err +} diff --git a/src/alertmanager/vendor/github.com/alecthomas/units/doc.go b/src/alertmanager/vendor/github.com/alecthomas/units/doc.go new file mode 100644 index 0000000..156ae38 --- /dev/null +++ b/src/alertmanager/vendor/github.com/alecthomas/units/doc.go @@ -0,0 +1,13 @@ +// Package units provides helpful unit multipliers and functions for Go. +// +// The goal of this package is to have functionality similar to the time [1] package. +// +// +// [1] http://golang.org/pkg/time/ +// +// It allows for code like this: +// +// n, err := ParseBase2Bytes("1KB") +// // n == 1024 +// n = units.Mebibyte * 512 +package units diff --git a/src/alertmanager/vendor/github.com/alecthomas/units/si.go b/src/alertmanager/vendor/github.com/alecthomas/units/si.go new file mode 100644 index 0000000..8234a9d --- /dev/null +++ b/src/alertmanager/vendor/github.com/alecthomas/units/si.go @@ -0,0 +1,26 @@ +package units + +// SI units. +type SI int64 + +// SI unit multiples. +const ( + Kilo SI = 1000 + Mega = Kilo * 1000 + Giga = Mega * 1000 + Tera = Giga * 1000 + Peta = Tera * 1000 + Exa = Peta * 1000 +) + +func MakeUnitMap(suffix, shortSuffix string, scale int64) map[string]float64 { + return map[string]float64{ + shortSuffix: 1, + "K" + suffix: float64(scale), + "M" + suffix: float64(scale * scale), + "G" + suffix: float64(scale * scale * scale), + "T" + suffix: float64(scale * scale * scale * scale), + "P" + suffix: float64(scale * scale * scale * scale * scale), + "E" + suffix: float64(scale * scale * scale * scale * scale * scale), + } +} diff --git a/src/alertmanager/vendor/github.com/alecthomas/units/util.go b/src/alertmanager/vendor/github.com/alecthomas/units/util.go new file mode 100644 index 0000000..6527e92 --- /dev/null +++ b/src/alertmanager/vendor/github.com/alecthomas/units/util.go @@ -0,0 +1,138 @@ +package units + +import ( + "errors" + "fmt" + "strings" +) + +var ( + siUnits = []string{"", "K", "M", "G", "T", "P", "E"} +) + +func ToString(n int64, scale int64, suffix, baseSuffix string) string { + mn := len(siUnits) + out := make([]string, mn) + for i, m := range siUnits { + if n%scale != 0 || i == 0 && n == 0 { + s := suffix + if i == 0 { + s = baseSuffix + } + out[mn-1-i] = fmt.Sprintf("%d%s%s", n%scale, m, s) + } + n /= scale + if n == 0 { + break + } + } + return strings.Join(out, "") +} + +// Below code ripped straight from http://golang.org/src/pkg/time/format.go?s=33392:33438#L1123 +var errLeadingInt = errors.New("units: bad [0-9]*") // never printed + +// leadingInt consumes the leading [0-9]* from s. +func leadingInt(s string) (x int64, rem string, err error) { + i := 0 + for ; i < len(s); i++ { + c := s[i] + if c < '0' || c > '9' { + break + } + if x >= (1<<63-10)/10 { + // overflow + return 0, "", errLeadingInt + } + x = x*10 + int64(c) - '0' + } + return x, s[i:], nil +} + +func ParseUnit(s string, unitMap map[string]float64) (int64, error) { + // [-+]?([0-9]*(\.[0-9]*)?[a-z]+)+ + orig := s + f := float64(0) + neg := false + + // Consume [-+]? + if s != "" { + c := s[0] + if c == '-' || c == '+' { + neg = c == '-' + s = s[1:] + } + } + // Special case: if all that is left is "0", this is zero. + if s == "0" { + return 0, nil + } + if s == "" { + return 0, errors.New("units: invalid " + orig) + } + for s != "" { + g := float64(0) // this element of the sequence + + var x int64 + var err error + + // The next character must be [0-9.] + if !(s[0] == '.' || ('0' <= s[0] && s[0] <= '9')) { + return 0, errors.New("units: invalid " + orig) + } + // Consume [0-9]* + pl := len(s) + x, s, err = leadingInt(s) + if err != nil { + return 0, errors.New("units: invalid " + orig) + } + g = float64(x) + pre := pl != len(s) // whether we consumed anything before a period + + // Consume (\.[0-9]*)? + post := false + if s != "" && s[0] == '.' { + s = s[1:] + pl := len(s) + x, s, err = leadingInt(s) + if err != nil { + return 0, errors.New("units: invalid " + orig) + } + scale := 1.0 + for n := pl - len(s); n > 0; n-- { + scale *= 10 + } + g += float64(x) / scale + post = pl != len(s) + } + if !pre && !post { + // no digits (e.g. ".s" or "-.s") + return 0, errors.New("units: invalid " + orig) + } + + // Consume unit. + i := 0 + for ; i < len(s); i++ { + c := s[i] + if c == '.' || ('0' <= c && c <= '9') { + break + } + } + u := s[:i] + s = s[i:] + unit, ok := unitMap[u] + if !ok { + return 0, errors.New("units: unknown unit " + u + " in " + orig) + } + + f += g * unit + } + + if neg { + f = -f + } + if f < float64(-1<<63) || f > float64(1<<63-1) { + return 0, errors.New("units: overflow parsing unit") + } + return int64(f), nil +} diff --git a/src/alertmanager/vendor/github.com/armon/go-metrics/LICENSE b/src/alertmanager/vendor/github.com/armon/go-metrics/LICENSE new file mode 100644 index 0000000..106569e --- /dev/null +++ b/src/alertmanager/vendor/github.com/armon/go-metrics/LICENSE @@ -0,0 +1,20 @@ +The MIT License (MIT) + +Copyright (c) 2013 Armon Dadgar + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/src/alertmanager/vendor/github.com/armon/go-metrics/README.md b/src/alertmanager/vendor/github.com/armon/go-metrics/README.md new file mode 100644 index 0000000..a7399cd --- /dev/null +++ b/src/alertmanager/vendor/github.com/armon/go-metrics/README.md @@ -0,0 +1,74 @@ +go-metrics +========== + +This library provides a `metrics` package which can be used to instrument code, +expose application metrics, and profile runtime performance in a flexible manner. + +Current API: [![GoDoc](https://godoc.org/github.com/armon/go-metrics?status.svg)](https://godoc.org/github.com/armon/go-metrics) + +Sinks +===== + +The `metrics` package makes use of a `MetricSink` interface to support delivery +to any type of backend. Currently the following sinks are provided: + +* StatsiteSink : Sinks to a [statsite](https://github.com/armon/statsite/) instance (TCP) +* StatsdSink: Sinks to a [StatsD](https://github.com/etsy/statsd/) / statsite instance (UDP) +* PrometheusSink: Sinks to a [Prometheus](http://prometheus.io/) metrics endpoint (exposed via HTTP for scrapes) +* InmemSink : Provides in-memory aggregation, can be used to export stats +* FanoutSink : Sinks to multiple sinks. Enables writing to multiple statsite instances for example. +* BlackholeSink : Sinks to nowhere + +In addition to the sinks, the `InmemSignal` can be used to catch a signal, +and dump a formatted output of recent metrics. For example, when a process gets +a SIGUSR1, it can dump to stderr recent performance metrics for debugging. + +Examples +======== + +Here is an example of using the package: + +```go +func SlowMethod() { + // Profiling the runtime of a method + defer metrics.MeasureSince([]string{"SlowMethod"}, time.Now()) +} + +// Configure a statsite sink as the global metrics sink +sink, _ := metrics.NewStatsiteSink("statsite:8125") +metrics.NewGlobal(metrics.DefaultConfig("service-name"), sink) + +// Emit a Key/Value pair +metrics.EmitKey([]string{"questions", "meaning of life"}, 42) +``` + +Here is an example of setting up a signal handler: + +```go +// Setup the inmem sink and signal handler +inm := metrics.NewInmemSink(10*time.Second, time.Minute) +sig := metrics.DefaultInmemSignal(inm) +metrics.NewGlobal(metrics.DefaultConfig("service-name"), inm) + +// Run some code +inm.SetGauge([]string{"foo"}, 42) +inm.EmitKey([]string{"bar"}, 30) + +inm.IncrCounter([]string{"baz"}, 42) +inm.IncrCounter([]string{"baz"}, 1) +inm.IncrCounter([]string{"baz"}, 80) + +inm.AddSample([]string{"method", "wow"}, 42) +inm.AddSample([]string{"method", "wow"}, 100) +inm.AddSample([]string{"method", "wow"}, 22) + +.... +``` + +When a signal comes in, output like the following will be dumped to stderr: + + [2014-01-28 14:57:33.04 -0800 PST][G] 'foo': 42.000 + [2014-01-28 14:57:33.04 -0800 PST][P] 'bar': 30.000 + [2014-01-28 14:57:33.04 -0800 PST][C] 'baz': Count: 3 Min: 1.000 Mean: 41.000 Max: 80.000 Stddev: 39.509 + [2014-01-28 14:57:33.04 -0800 PST][S] 'method.wow': Count: 3 Min: 22.000 Mean: 54.667 Max: 100.000 Stddev: 40.513 + diff --git a/src/alertmanager/vendor/github.com/armon/go-metrics/const_unix.go b/src/alertmanager/vendor/github.com/armon/go-metrics/const_unix.go new file mode 100644 index 0000000..31098dd --- /dev/null +++ b/src/alertmanager/vendor/github.com/armon/go-metrics/const_unix.go @@ -0,0 +1,12 @@ +// +build !windows + +package metrics + +import ( + "syscall" +) + +const ( + // DefaultSignal is used with DefaultInmemSignal + DefaultSignal = syscall.SIGUSR1 +) diff --git a/src/alertmanager/vendor/github.com/armon/go-metrics/const_windows.go b/src/alertmanager/vendor/github.com/armon/go-metrics/const_windows.go new file mode 100644 index 0000000..38136af --- /dev/null +++ b/src/alertmanager/vendor/github.com/armon/go-metrics/const_windows.go @@ -0,0 +1,13 @@ +// +build windows + +package metrics + +import ( + "syscall" +) + +const ( + // DefaultSignal is used with DefaultInmemSignal + // Windows has no SIGUSR1, use SIGBREAK + DefaultSignal = syscall.Signal(21) +) diff --git a/src/alertmanager/vendor/github.com/armon/go-metrics/inmem.go b/src/alertmanager/vendor/github.com/armon/go-metrics/inmem.go new file mode 100644 index 0000000..8fe1de8 --- /dev/null +++ b/src/alertmanager/vendor/github.com/armon/go-metrics/inmem.go @@ -0,0 +1,319 @@ +package metrics + +import ( + "bytes" + "fmt" + "math" + "net/url" + "strings" + "sync" + "time" +) + +// InmemSink provides a MetricSink that does in-memory aggregation +// without sending metrics over a network. It can be embedded within +// an application to provide profiling information. +type InmemSink struct { + // How long is each aggregation interval + interval time.Duration + + // Retain controls how many metrics interval we keep + retain time.Duration + + // maxIntervals is the maximum length of intervals. + // It is retain / interval. + maxIntervals int + + // intervals is a slice of the retained intervals + intervals []*IntervalMetrics + intervalLock sync.RWMutex + + rateDenom float64 +} + +// IntervalMetrics stores the aggregated metrics +// for a specific interval +type IntervalMetrics struct { + sync.RWMutex + + // The start time of the interval + Interval time.Time + + // Gauges maps the key to the last set value + Gauges map[string]GaugeValue + + // Points maps the string to the list of emitted values + // from EmitKey + Points map[string][]float32 + + // Counters maps the string key to a sum of the counter + // values + Counters map[string]SampledValue + + // Samples maps the key to an AggregateSample, + // which has the rolled up view of a sample + Samples map[string]SampledValue +} + +// NewIntervalMetrics creates a new IntervalMetrics for a given interval +func NewIntervalMetrics(intv time.Time) *IntervalMetrics { + return &IntervalMetrics{ + Interval: intv, + Gauges: make(map[string]GaugeValue), + Points: make(map[string][]float32), + Counters: make(map[string]SampledValue), + Samples: make(map[string]SampledValue), + } +} + +// AggregateSample is used to hold aggregate metrics +// about a sample +type AggregateSample struct { + Count int // The count of emitted pairs + Rate float64 // The values rate per time unit (usually 1 second) + Sum float64 // The sum of values + SumSq float64 `json:"-"` // The sum of squared values + Min float64 // Minimum value + Max float64 // Maximum value + LastUpdated time.Time `json:"-"` // When value was last updated +} + +// Computes a Stddev of the values +func (a *AggregateSample) Stddev() float64 { + num := (float64(a.Count) * a.SumSq) - math.Pow(a.Sum, 2) + div := float64(a.Count * (a.Count - 1)) + if div == 0 { + return 0 + } + return math.Sqrt(num / div) +} + +// Computes a mean of the values +func (a *AggregateSample) Mean() float64 { + if a.Count == 0 { + return 0 + } + return a.Sum / float64(a.Count) +} + +// Ingest is used to update a sample +func (a *AggregateSample) Ingest(v float64, rateDenom float64) { + a.Count++ + a.Sum += v + a.SumSq += (v * v) + if v < a.Min || a.Count == 1 { + a.Min = v + } + if v > a.Max || a.Count == 1 { + a.Max = v + } + a.Rate = float64(a.Sum) / rateDenom + a.LastUpdated = time.Now() +} + +func (a *AggregateSample) String() string { + if a.Count == 0 { + return "Count: 0" + } else if a.Stddev() == 0 { + return fmt.Sprintf("Count: %d Sum: %0.3f LastUpdated: %s", a.Count, a.Sum, a.LastUpdated) + } else { + return fmt.Sprintf("Count: %d Min: %0.3f Mean: %0.3f Max: %0.3f Stddev: %0.3f Sum: %0.3f LastUpdated: %s", + a.Count, a.Min, a.Mean(), a.Max, a.Stddev(), a.Sum, a.LastUpdated) + } +} + +// NewInmemSinkFromURL creates an InmemSink from a URL. It is used +// (and tested) from NewMetricSinkFromURL. +func NewInmemSinkFromURL(u *url.URL) (MetricSink, error) { + params := u.Query() + + interval, err := time.ParseDuration(params.Get("interval")) + if err != nil { + return nil, fmt.Errorf("Bad 'interval' param: %s", err) + } + + retain, err := time.ParseDuration(params.Get("retain")) + if err != nil { + return nil, fmt.Errorf("Bad 'retain' param: %s", err) + } + + return NewInmemSink(interval, retain), nil +} + +// NewInmemSink is used to construct a new in-memory sink. +// Uses an aggregation interval and maximum retention period. +func NewInmemSink(interval, retain time.Duration) *InmemSink { + rateTimeUnit := time.Second + i := &InmemSink{ + interval: interval, + retain: retain, + maxIntervals: int(retain / interval), + rateDenom: float64(interval.Nanoseconds()) / float64(rateTimeUnit.Nanoseconds()), + } + i.intervals = make([]*IntervalMetrics, 0, i.maxIntervals) + return i +} + +func (i *InmemSink) SetGauge(key []string, val float32) { + i.SetGaugeWithLabels(key, val, nil) +} + +func (i *InmemSink) SetGaugeWithLabels(key []string, val float32, labels []Label) { + k, name := i.flattenKeyLabels(key, labels) + intv := i.getInterval() + + intv.Lock() + defer intv.Unlock() + intv.Gauges[k] = GaugeValue{Name: name, Value: val, Labels: labels} +} + +func (i *InmemSink) EmitKey(key []string, val float32) { + k := i.flattenKey(key) + intv := i.getInterval() + + intv.Lock() + defer intv.Unlock() + vals := intv.Points[k] + intv.Points[k] = append(vals, val) +} + +func (i *InmemSink) IncrCounter(key []string, val float32) { + i.IncrCounterWithLabels(key, val, nil) +} + +func (i *InmemSink) IncrCounterWithLabels(key []string, val float32, labels []Label) { + k, name := i.flattenKeyLabels(key, labels) + intv := i.getInterval() + + intv.Lock() + defer intv.Unlock() + + agg, ok := intv.Counters[k] + if !ok { + agg = SampledValue{ + Name: name, + AggregateSample: &AggregateSample{}, + Labels: labels, + } + intv.Counters[k] = agg + } + agg.Ingest(float64(val), i.rateDenom) +} + +func (i *InmemSink) AddSample(key []string, val float32) { + i.AddSampleWithLabels(key, val, nil) +} + +func (i *InmemSink) AddSampleWithLabels(key []string, val float32, labels []Label) { + k, name := i.flattenKeyLabels(key, labels) + intv := i.getInterval() + + intv.Lock() + defer intv.Unlock() + + agg, ok := intv.Samples[k] + if !ok { + agg = SampledValue{ + Name: name, + AggregateSample: &AggregateSample{}, + Labels: labels, + } + intv.Samples[k] = agg + } + agg.Ingest(float64(val), i.rateDenom) +} + +// Data is used to retrieve all the aggregated metrics +// Intervals may be in use, and a read lock should be acquired +func (i *InmemSink) Data() []*IntervalMetrics { + // Get the current interval, forces creation + i.getInterval() + + i.intervalLock.RLock() + defer i.intervalLock.RUnlock() + + intervals := make([]*IntervalMetrics, len(i.intervals)) + copy(intervals, i.intervals) + return intervals +} + +func (i *InmemSink) getExistingInterval(intv time.Time) *IntervalMetrics { + i.intervalLock.RLock() + defer i.intervalLock.RUnlock() + + n := len(i.intervals) + if n > 0 && i.intervals[n-1].Interval == intv { + return i.intervals[n-1] + } + return nil +} + +func (i *InmemSink) createInterval(intv time.Time) *IntervalMetrics { + i.intervalLock.Lock() + defer i.intervalLock.Unlock() + + // Check for an existing interval + n := len(i.intervals) + if n > 0 && i.intervals[n-1].Interval == intv { + return i.intervals[n-1] + } + + // Add the current interval + current := NewIntervalMetrics(intv) + i.intervals = append(i.intervals, current) + n++ + + // Truncate the intervals if they are too long + if n >= i.maxIntervals { + copy(i.intervals[0:], i.intervals[n-i.maxIntervals:]) + i.intervals = i.intervals[:i.maxIntervals] + } + return current +} + +// getInterval returns the current interval to write to +func (i *InmemSink) getInterval() *IntervalMetrics { + intv := time.Now().Truncate(i.interval) + if m := i.getExistingInterval(intv); m != nil { + return m + } + return i.createInterval(intv) +} + +// Flattens the key for formatting, removes spaces +func (i *InmemSink) flattenKey(parts []string) string { + buf := &bytes.Buffer{} + replacer := strings.NewReplacer(" ", "_") + + if len(parts) > 0 { + replacer.WriteString(buf, parts[0]) + } + for _, part := range parts[1:] { + replacer.WriteString(buf, ".") + replacer.WriteString(buf, part) + } + + return buf.String() +} + +// Flattens the key for formatting along with its labels, removes spaces +func (i *InmemSink) flattenKeyLabels(parts []string, labels []Label) (string, string) { + buf := &bytes.Buffer{} + replacer := strings.NewReplacer(" ", "_") + + if len(parts) > 0 { + replacer.WriteString(buf, parts[0]) + } + for _, part := range parts[1:] { + replacer.WriteString(buf, ".") + replacer.WriteString(buf, part) + } + + key := buf.String() + + for _, label := range labels { + replacer.WriteString(buf, fmt.Sprintf(";%s=%s", label.Name, label.Value)) + } + + return buf.String(), key +} diff --git a/src/alertmanager/vendor/github.com/armon/go-metrics/inmem_endpoint.go b/src/alertmanager/vendor/github.com/armon/go-metrics/inmem_endpoint.go new file mode 100644 index 0000000..504f1b3 --- /dev/null +++ b/src/alertmanager/vendor/github.com/armon/go-metrics/inmem_endpoint.go @@ -0,0 +1,118 @@ +package metrics + +import ( + "fmt" + "net/http" + "sort" + "time" +) + +// MetricsSummary holds a roll-up of metrics info for a given interval +type MetricsSummary struct { + Timestamp string + Gauges []GaugeValue + Points []PointValue + Counters []SampledValue + Samples []SampledValue +} + +type GaugeValue struct { + Name string + Hash string `json:"-"` + Value float32 + + Labels []Label `json:"-"` + DisplayLabels map[string]string `json:"Labels"` +} + +type PointValue struct { + Name string + Points []float32 +} + +type SampledValue struct { + Name string + Hash string `json:"-"` + *AggregateSample + Mean float64 + Stddev float64 + + Labels []Label `json:"-"` + DisplayLabels map[string]string `json:"Labels"` +} + +// DisplayMetrics returns a summary of the metrics from the most recent finished interval. +func (i *InmemSink) DisplayMetrics(resp http.ResponseWriter, req *http.Request) (interface{}, error) { + data := i.Data() + + var interval *IntervalMetrics + n := len(data) + switch { + case n == 0: + return nil, fmt.Errorf("no metric intervals have been initialized yet") + case n == 1: + // Show the current interval if it's all we have + interval = i.intervals[0] + default: + // Show the most recent finished interval if we have one + interval = i.intervals[n-2] + } + + summary := MetricsSummary{ + Timestamp: interval.Interval.Round(time.Second).UTC().String(), + Gauges: make([]GaugeValue, 0, len(interval.Gauges)), + Points: make([]PointValue, 0, len(interval.Points)), + } + + // Format and sort the output of each metric type, so it gets displayed in a + // deterministic order. + for name, points := range interval.Points { + summary.Points = append(summary.Points, PointValue{name, points}) + } + sort.Slice(summary.Points, func(i, j int) bool { + return summary.Points[i].Name < summary.Points[j].Name + }) + + for hash, value := range interval.Gauges { + value.Hash = hash + value.DisplayLabels = make(map[string]string) + for _, label := range value.Labels { + value.DisplayLabels[label.Name] = label.Value + } + value.Labels = nil + + summary.Gauges = append(summary.Gauges, value) + } + sort.Slice(summary.Gauges, func(i, j int) bool { + return summary.Gauges[i].Hash < summary.Gauges[j].Hash + }) + + summary.Counters = formatSamples(interval.Counters) + summary.Samples = formatSamples(interval.Samples) + + return summary, nil +} + +func formatSamples(source map[string]SampledValue) []SampledValue { + output := make([]SampledValue, 0, len(source)) + for hash, sample := range source { + displayLabels := make(map[string]string) + for _, label := range sample.Labels { + displayLabels[label.Name] = label.Value + } + + output = append(output, SampledValue{ + Name: sample.Name, + Hash: hash, + AggregateSample: sample.AggregateSample, + Mean: sample.AggregateSample.Mean(), + Stddev: sample.AggregateSample.Stddev(), + DisplayLabels: displayLabels, + }) + } + sort.Slice(output, func(i, j int) bool { + return output[i].Hash < output[j].Hash + }) + + return output +} diff --git a/src/alertmanager/vendor/github.com/armon/go-metrics/inmem_signal.go b/src/alertmanager/vendor/github.com/armon/go-metrics/inmem_signal.go new file mode 100644 index 0000000..0937f4a --- /dev/null +++ b/src/alertmanager/vendor/github.com/armon/go-metrics/inmem_signal.go @@ -0,0 +1,117 @@ +package metrics + +import ( + "bytes" + "fmt" + "io" + "os" + "os/signal" + "strings" + "sync" + "syscall" +) + +// InmemSignal is used to listen for a given signal, and when received, +// to dump the current metrics from the InmemSink to an io.Writer +type InmemSignal struct { + signal syscall.Signal + inm *InmemSink + w io.Writer + sigCh chan os.Signal + + stop bool + stopCh chan struct{} + stopLock sync.Mutex +} + +// NewInmemSignal creates a new InmemSignal which listens for a given signal, +// and dumps the current metrics out to a writer +func NewInmemSignal(inmem *InmemSink, sig syscall.Signal, w io.Writer) *InmemSignal { + i := &InmemSignal{ + signal: sig, + inm: inmem, + w: w, + sigCh: make(chan os.Signal, 1), + stopCh: make(chan struct{}), + } + signal.Notify(i.sigCh, sig) + go i.run() + return i +} + +// DefaultInmemSignal returns a new InmemSignal that responds to SIGUSR1 +// and writes output to stderr. Windows uses SIGBREAK +func DefaultInmemSignal(inmem *InmemSink) *InmemSignal { + return NewInmemSignal(inmem, DefaultSignal, os.Stderr) +} + +// Stop is used to stop the InmemSignal from listening +func (i *InmemSignal) Stop() { + i.stopLock.Lock() + defer i.stopLock.Unlock() + + if i.stop { + return + } + i.stop = true + close(i.stopCh) + signal.Stop(i.sigCh) +} + +// run is a long running routine that handles signals +func (i *InmemSignal) run() { + for { + select { + case <-i.sigCh: + i.dumpStats() + case <-i.stopCh: + return + } + } +} + +// dumpStats is used to dump the data to output writer +func (i *InmemSignal) dumpStats() { + buf := bytes.NewBuffer(nil) + + data := i.inm.Data() + // Skip the last period which is still being aggregated + for j := 0; j < len(data)-1; j++ { + intv := data[j] + intv.RLock() + for _, val := range intv.Gauges { + name := i.flattenLabels(val.Name, val.Labels) + fmt.Fprintf(buf, "[%v][G] '%s': %0.3f\n", intv.Interval, name, val.Value) + } + for name, vals := range intv.Points { + for _, val := range vals { + fmt.Fprintf(buf, "[%v][P] '%s': %0.3f\n", intv.Interval, name, val) + } + } + for _, agg := range intv.Counters { + name := i.flattenLabels(agg.Name, agg.Labels) + fmt.Fprintf(buf, "[%v][C] '%s': %s\n", intv.Interval, name, agg.AggregateSample) + } + for _, agg := range intv.Samples { + name := i.flattenLabels(agg.Name, agg.Labels) + fmt.Fprintf(buf, "[%v][S] '%s': %s\n", intv.Interval, name, agg.AggregateSample) + } + intv.RUnlock() + } + + // Write out the bytes + i.w.Write(buf.Bytes()) +} + +// Flattens the key for formatting along with its labels, removes spaces +func (i *InmemSignal) flattenLabels(name string, labels []Label) string { + buf := bytes.NewBufferString(name) + replacer := strings.NewReplacer(" ", "_", ":", "_") + + for _, label := range labels { + replacer.WriteString(buf, ".") + replacer.WriteString(buf, label.Value) + } + + return buf.String() +} diff --git a/src/alertmanager/vendor/github.com/armon/go-metrics/metrics.go b/src/alertmanager/vendor/github.com/armon/go-metrics/metrics.go new file mode 100644 index 0000000..d260bd4 --- /dev/null +++ b/src/alertmanager/vendor/github.com/armon/go-metrics/metrics.go @@ -0,0 +1,216 @@ +package metrics + +import ( + "runtime" + "strings" + "time" + + "github.com/hashicorp/go-immutable-radix" +) + +type Label struct { + Name string + Value string +} + +func (m *Metrics) SetGauge(key []string, val float32) { + m.SetGaugeWithLabels(key, val, nil) +} + +func (m *Metrics) SetGaugeWithLabels(key []string, val float32, labels []Label) { + if m.HostName != "" { + if m.EnableHostnameLabel { + labels = append(labels, Label{"host", m.HostName}) + } else if m.EnableHostname { + key = insert(0, m.HostName, key) + } + } + if m.EnableTypePrefix { + key = insert(0, "gauge", key) + } + if m.ServiceName != "" { + if m.EnableServiceLabel { + labels = append(labels, Label{"service", m.ServiceName}) + } else { + key = insert(0, m.ServiceName, key) + } + } + if !m.allowMetric(key) { + return + } + m.sink.SetGaugeWithLabels(key, val, labels) +} + +func (m *Metrics) EmitKey(key []string, val float32) { + if m.EnableTypePrefix { + key = insert(0, "kv", key) + } + if m.ServiceName != "" { + key = insert(0, m.ServiceName, key) + } + if !m.allowMetric(key) { + return + } + m.sink.EmitKey(key, val) +} + +func (m *Metrics) IncrCounter(key []string, val float32) { + m.IncrCounterWithLabels(key, val, nil) +} + +func (m *Metrics) IncrCounterWithLabels(key []string, val float32, labels []Label) { + if m.HostName != "" && m.EnableHostnameLabel { + labels = append(labels, Label{"host", m.HostName}) + } + if m.EnableTypePrefix { + key = insert(0, "counter", key) + } + if m.ServiceName != "" { + if m.EnableServiceLabel { + labels = append(labels, Label{"service", m.ServiceName}) + } else { + key = insert(0, m.ServiceName, key) + } + } + if !m.allowMetric(key) { + return + } + m.sink.IncrCounterWithLabels(key, val, labels) +} + +func (m *Metrics) AddSample(key []string, val float32) { + m.AddSampleWithLabels(key, val, nil) +} + +func (m *Metrics) AddSampleWithLabels(key []string, val float32, labels []Label) { + if m.HostName != "" && m.EnableHostnameLabel { + labels = append(labels, Label{"host", m.HostName}) + } + if m.EnableTypePrefix { + key = insert(0, "sample", key) + } + if m.ServiceName != "" { + if m.EnableServiceLabel { + labels = append(labels, Label{"service", m.ServiceName}) + } else { + key = insert(0, m.ServiceName, key) + } + } + if !m.allowMetric(key) { + return + } + m.sink.AddSampleWithLabels(key, val, labels) +} + +func (m *Metrics) MeasureSince(key []string, start time.Time) { + m.MeasureSinceWithLabels(key, start, nil) +} + +func (m *Metrics) MeasureSinceWithLabels(key []string, start time.Time, labels []Label) { + if m.HostName != "" && m.EnableHostnameLabel { + labels = append(labels, Label{"host", m.HostName}) + } + if m.EnableTypePrefix { + key = insert(0, "timer", key) + } + if m.ServiceName != "" { + if m.EnableServiceLabel { + labels = append(labels, Label{"service", m.ServiceName}) + } else { + key = insert(0, m.ServiceName, key) + } + } + if !m.allowMetric(key) { + return + } + now := time.Now() + elapsed := now.Sub(start) + msec := float32(elapsed.Nanoseconds()) / float32(m.TimerGranularity) + m.sink.AddSampleWithLabels(key, msec, labels) +} + +// UpdateFilter overwrites the existing filter with the given rules. +func (m *Metrics) UpdateFilter(allow, block []string) { + m.filterLock.Lock() + defer m.filterLock.Unlock() + + m.AllowedPrefixes = allow + m.BlockedPrefixes = block + + m.filter = iradix.New() + for _, prefix := range m.AllowedPrefixes { + m.filter, _, _ = m.filter.Insert([]byte(prefix), true) + } + for _, prefix := range m.BlockedPrefixes { + m.filter, _, _ = m.filter.Insert([]byte(prefix), false) + } +} + +// Returns whether the metric should be allowed based on configured prefix filters +func (m *Metrics) allowMetric(key []string) bool { + m.filterLock.RLock() + defer m.filterLock.RUnlock() + + if m.filter == nil || m.filter.Len() == 0 { + return m.Config.FilterDefault + } + + _, allowed, ok := m.filter.Root().LongestPrefix([]byte(strings.Join(key, "."))) + if !ok { + return m.Config.FilterDefault + } + return allowed.(bool) +} + +// Periodically collects runtime stats to publish +func (m *Metrics) collectStats() { + for { + time.Sleep(m.ProfileInterval) + m.emitRuntimeStats() + } +} + +// Emits various runtime statsitics +func (m *Metrics) emitRuntimeStats() { + // Export number of Goroutines + numRoutines := runtime.NumGoroutine() + m.SetGauge([]string{"runtime", "num_goroutines"}, float32(numRoutines)) + + // Export memory stats + var stats runtime.MemStats + runtime.ReadMemStats(&stats) + m.SetGauge([]string{"runtime", "alloc_bytes"}, float32(stats.Alloc)) + m.SetGauge([]string{"runtime", "sys_bytes"}, float32(stats.Sys)) + m.SetGauge([]string{"runtime", "malloc_count"}, float32(stats.Mallocs)) + m.SetGauge([]string{"runtime", "free_count"}, float32(stats.Frees)) + m.SetGauge([]string{"runtime", "heap_objects"}, float32(stats.HeapObjects)) + m.SetGauge([]string{"runtime", "total_gc_pause_ns"}, float32(stats.PauseTotalNs)) + m.SetGauge([]string{"runtime", "total_gc_runs"}, float32(stats.NumGC)) + + // Export info about the last few GC runs + num := stats.NumGC + + // Handle wrap around + if num < m.lastNumGC { + m.lastNumGC = 0 + } + + // Ensure we don't scan more than 256 + if num-m.lastNumGC >= 256 { + m.lastNumGC = num - 255 + } + + for i := m.lastNumGC; i < num; i++ { + pause := stats.PauseNs[i%256] + m.AddSample([]string{"runtime", "gc_pause_ns"}, float32(pause)) + } + m.lastNumGC = num +} + +// Inserts a string value at an index into the slice +func insert(i int, v string, s []string) []string { + s = append(s, "") + copy(s[i+1:], s[i:]) + s[i] = v + return s +} diff --git a/src/alertmanager/vendor/github.com/armon/go-metrics/sink.go b/src/alertmanager/vendor/github.com/armon/go-metrics/sink.go new file mode 100644 index 0000000..0b7d6e4 --- /dev/null +++ b/src/alertmanager/vendor/github.com/armon/go-metrics/sink.go @@ -0,0 +1,115 @@ +package metrics + +import ( + "fmt" + "net/url" +) + +// The MetricSink interface is used to transmit metrics information +// to an external system +type MetricSink interface { + // A Gauge should retain the last value it is set to + SetGauge(key []string, val float32) + SetGaugeWithLabels(key []string, val float32, labels []Label) + + // Should emit a Key/Value pair for each call + EmitKey(key []string, val float32) + + // Counters should accumulate values + IncrCounter(key []string, val float32) + IncrCounterWithLabels(key []string, val float32, labels []Label) + + // Samples are for timing information, where quantiles are used + AddSample(key []string, val float32) + AddSampleWithLabels(key []string, val float32, labels []Label) +} + +// BlackholeSink is used to just blackhole messages +type BlackholeSink struct{} + +func (*BlackholeSink) SetGauge(key []string, val float32) {} +func (*BlackholeSink) SetGaugeWithLabels(key []string, val float32, labels []Label) {} +func (*BlackholeSink) EmitKey(key []string, val float32) {} +func (*BlackholeSink) IncrCounter(key []string, val float32) {} +func (*BlackholeSink) IncrCounterWithLabels(key []string, val float32, labels []Label) {} +func (*BlackholeSink) AddSample(key []string, val float32) {} +func (*BlackholeSink) AddSampleWithLabels(key []string, val float32, labels []Label) {} + +// FanoutSink is used to sink to fanout values to multiple sinks +type FanoutSink []MetricSink + +func (fh FanoutSink) SetGauge(key []string, val float32) { + fh.SetGaugeWithLabels(key, val, nil) +} + +func (fh FanoutSink) SetGaugeWithLabels(key []string, val float32, labels []Label) { + for _, s := range fh { + s.SetGaugeWithLabels(key, val, labels) + } +} + +func (fh FanoutSink) EmitKey(key []string, val float32) { + for _, s := range fh { + s.EmitKey(key, val) + } +} + +func (fh FanoutSink) IncrCounter(key []string, val float32) { + fh.IncrCounterWithLabels(key, val, nil) +} + +func (fh FanoutSink) IncrCounterWithLabels(key []string, val float32, labels []Label) { + for _, s := range fh { + s.IncrCounterWithLabels(key, val, labels) + } +} + +func (fh FanoutSink) AddSample(key []string, val float32) { + fh.AddSampleWithLabels(key, val, nil) +} + +func (fh FanoutSink) AddSampleWithLabels(key []string, val float32, labels []Label) { + for _, s := range fh { + s.AddSampleWithLabels(key, val, labels) + } +} + +// sinkURLFactoryFunc is an generic interface around the *SinkFromURL() function provided +// by each sink type +type sinkURLFactoryFunc func(*url.URL) (MetricSink, error) + +// sinkRegistry supports the generic NewMetricSink function by mapping URL +// schemes to metric sink factory functions +var sinkRegistry = map[string]sinkURLFactoryFunc{ + "statsd": NewStatsdSinkFromURL, + "statsite": NewStatsiteSinkFromURL, + "inmem": NewInmemSinkFromURL, +} + +// NewMetricSinkFromURL allows a generic URL input to configure any of the +// supported sinks. The scheme of the URL identifies the type of the sink, the +// and query parameters are used to set options. +// +// "statsd://" - Initializes a StatsdSink. The host and port are passed through +// as the "addr" of the sink +// +// "statsite://" - Initializes a StatsiteSink. The host and port become the +// "addr" of the sink +// +// "inmem://" - Initializes an InmemSink. The host and port are ignored. The +// "interval" and "duration" query parameters must be specified with valid +// durations, see NewInmemSink for details. +func NewMetricSinkFromURL(urlStr string) (MetricSink, error) { + u, err := url.Parse(urlStr) + if err != nil { + return nil, err + } + + sinkURLFactoryFunc := sinkRegistry[u.Scheme] + if sinkURLFactoryFunc == nil { + return nil, fmt.Errorf( + "cannot create metric sink, unrecognized sink name: %q", u.Scheme) + } + + return sinkURLFactoryFunc(u) +} diff --git a/src/alertmanager/vendor/github.com/armon/go-metrics/start.go b/src/alertmanager/vendor/github.com/armon/go-metrics/start.go new file mode 100644 index 0000000..46f0c2e --- /dev/null +++ b/src/alertmanager/vendor/github.com/armon/go-metrics/start.go @@ -0,0 +1,129 @@ +package metrics + +import ( + "os" + "sync" + "sync/atomic" + "time" + + "github.com/hashicorp/go-immutable-radix" +) + +// Config is used to configure metrics settings +type Config struct { + ServiceName string // Prefixed with keys to seperate services + HostName string // Hostname to use. If not provided and EnableHostname, it will be os.Hostname + EnableHostname bool // Enable prefixing gauge values with hostname + EnableHostnameLabel bool // Enable adding hostname to labels + EnableServiceLabel bool // Enable adding service to labels + EnableRuntimeMetrics bool // Enables profiling of runtime metrics (GC, Goroutines, Memory) + EnableTypePrefix bool // Prefixes key with a type ("counter", "gauge", "timer") + TimerGranularity time.Duration // Granularity of timers. + ProfileInterval time.Duration // Interval to profile runtime metrics + + AllowedPrefixes []string // A list of metric prefixes to allow, with '.' as the separator + BlockedPrefixes []string // A list of metric prefixes to block, with '.' as the separator + FilterDefault bool // Whether to allow metrics by default +} + +// Metrics represents an instance of a metrics sink that can +// be used to emit +type Metrics struct { + Config + lastNumGC uint32 + sink MetricSink + filter *iradix.Tree + filterLock sync.RWMutex +} + +// Shared global metrics instance +var globalMetrics atomic.Value // *Metrics + +func init() { + // Initialize to a blackhole sink to avoid errors + globalMetrics.Store(&Metrics{sink: &BlackholeSink{}}) +} + +// DefaultConfig provides a sane default configuration +func DefaultConfig(serviceName string) *Config { + c := &Config{ + ServiceName: serviceName, // Use client provided service + HostName: "", + EnableHostname: true, // Enable hostname prefix + EnableRuntimeMetrics: true, // Enable runtime profiling + EnableTypePrefix: false, // Disable type prefix + TimerGranularity: time.Millisecond, // Timers are in milliseconds + ProfileInterval: time.Second, // Poll runtime every second + FilterDefault: true, // Don't filter metrics by default + } + + // Try to get the hostname + name, _ := os.Hostname() + c.HostName = name + return c +} + +// New is used to create a new instance of Metrics +func New(conf *Config, sink MetricSink) (*Metrics, error) { + met := &Metrics{} + met.Config = *conf + met.sink = sink + met.UpdateFilter(conf.AllowedPrefixes, conf.BlockedPrefixes) + + // Start the runtime collector + if conf.EnableRuntimeMetrics { + go met.collectStats() + } + return met, nil +} + +// NewGlobal is the same as New, but it assigns the metrics object to be +// used globally as well as returning it. +func NewGlobal(conf *Config, sink MetricSink) (*Metrics, error) { + metrics, err := New(conf, sink) + if err == nil { + globalMetrics.Store(metrics) + } + return metrics, err +} + +// Proxy all the methods to the globalMetrics instance +func SetGauge(key []string, val float32) { + globalMetrics.Load().(*Metrics).SetGauge(key, val) +} + +func SetGaugeWithLabels(key []string, val float32, labels []Label) { + globalMetrics.Load().(*Metrics).SetGaugeWithLabels(key, val, labels) +} + +func EmitKey(key []string, val float32) { + globalMetrics.Load().(*Metrics).EmitKey(key, val) +} + +func IncrCounter(key []string, val float32) { + globalMetrics.Load().(*Metrics).IncrCounter(key, val) +} + +func IncrCounterWithLabels(key []string, val float32, labels []Label) { + globalMetrics.Load().(*Metrics).IncrCounterWithLabels(key, val, labels) +} + +func AddSample(key []string, val float32) { + globalMetrics.Load().(*Metrics).AddSample(key, val) +} + +func AddSampleWithLabels(key []string, val float32, labels []Label) { + globalMetrics.Load().(*Metrics).AddSampleWithLabels(key, val, labels) +} + +func MeasureSince(key []string, start time.Time) { + globalMetrics.Load().(*Metrics).MeasureSince(key, start) +} + +func MeasureSinceWithLabels(key []string, start time.Time, labels []Label) { + globalMetrics.Load().(*Metrics).MeasureSinceWithLabels(key, start, labels) +} + +func UpdateFilter(allow, block []string) { + globalMetrics.Load().(*Metrics).UpdateFilter(allow, block) +} diff --git a/src/alertmanager/vendor/github.com/armon/go-metrics/statsd.go b/src/alertmanager/vendor/github.com/armon/go-metrics/statsd.go new file mode 100644 index 0000000..1bfffce --- /dev/null +++ b/src/alertmanager/vendor/github.com/armon/go-metrics/statsd.go @@ -0,0 +1,184 @@ +package metrics + +import ( + "bytes" + "fmt" + "log" + "net" + "net/url" + "strings" + "time" +) + +const ( + // statsdMaxLen is the maximum size of a packet + // to send to statsd + statsdMaxLen = 1400 +) + +// StatsdSink provides a MetricSink that can be used +// with a statsite or statsd metrics server. It uses +// only UDP packets, while StatsiteSink uses TCP. +type StatsdSink struct { + addr string + metricQueue chan string +} + +// NewStatsdSinkFromURL creates an StatsdSink from a URL. It is used +// (and tested) from NewMetricSinkFromURL. +func NewStatsdSinkFromURL(u *url.URL) (MetricSink, error) { + return NewStatsdSink(u.Host) +} + +// NewStatsdSink is used to create a new StatsdSink +func NewStatsdSink(addr string) (*StatsdSink, error) { + s := &StatsdSink{ + addr: addr, + metricQueue: make(chan string, 4096), + } + go s.flushMetrics() + return s, nil +} + +// Close is used to stop flushing to statsd +func (s *StatsdSink) Shutdown() { + close(s.metricQueue) +} + +func (s *StatsdSink) SetGauge(key []string, val float32) { + flatKey := s.flattenKey(key) + s.pushMetric(fmt.Sprintf("%s:%f|g\n", flatKey, val)) +} + +func (s *StatsdSink) SetGaugeWithLabels(key []string, val float32, labels []Label) { + flatKey := s.flattenKeyLabels(key, labels) + s.pushMetric(fmt.Sprintf("%s:%f|g\n", flatKey, val)) +} + +func (s *StatsdSink) EmitKey(key []string, val float32) { + flatKey := s.flattenKey(key) + s.pushMetric(fmt.Sprintf("%s:%f|kv\n", flatKey, val)) +} + +func (s *StatsdSink) IncrCounter(key []string, val float32) { + flatKey := s.flattenKey(key) + s.pushMetric(fmt.Sprintf("%s:%f|c\n", flatKey, val)) +} + +func (s *StatsdSink) IncrCounterWithLabels(key []string, val float32, labels []Label) { + flatKey := s.flattenKeyLabels(key, labels) + s.pushMetric(fmt.Sprintf("%s:%f|c\n", flatKey, val)) +} + +func (s *StatsdSink) AddSample(key []string, val float32) { + flatKey := s.flattenKey(key) + s.pushMetric(fmt.Sprintf("%s:%f|ms\n", flatKey, val)) +} + +func (s *StatsdSink) AddSampleWithLabels(key []string, val float32, labels []Label) { + flatKey := s.flattenKeyLabels(key, labels) + s.pushMetric(fmt.Sprintf("%s:%f|ms\n", flatKey, val)) +} + +// Flattens the key for formatting, removes spaces +func (s *StatsdSink) flattenKey(parts []string) string { + joined := strings.Join(parts, ".") + return strings.Map(func(r rune) rune { + switch r { + case ':': + fallthrough + case ' ': + return '_' + default: + return r + } + }, joined) +} + +// Flattens the key along with labels for formatting, removes spaces +func (s *StatsdSink) flattenKeyLabels(parts []string, labels []Label) string { + for _, label := range labels { + parts = append(parts, label.Value) + } + return s.flattenKey(parts) +} + +// Does a non-blocking push to the metrics queue +func (s *StatsdSink) pushMetric(m string) { + select { + case s.metricQueue <- m: + default: + } +} + +// Flushes metrics +func (s *StatsdSink) flushMetrics() { + var sock net.Conn + var err error + var wait <-chan time.Time + ticker := time.NewTicker(flushInterval) + defer ticker.Stop() + +CONNECT: + // Create a buffer + buf := bytes.NewBuffer(nil) + + // Attempt to connect + sock, err = net.Dial("udp", s.addr) + if err != nil { + log.Printf("[ERR] Error connecting to statsd! Err: %s", err) + goto WAIT + } + + for { + select { + case metric, ok := <-s.metricQueue: + // Get a metric from the queue + if !ok { + goto QUIT + } + + // Check if this would overflow the packet size + if len(metric)+buf.Len() > statsdMaxLen { + _, err := sock.Write(buf.Bytes()) + buf.Reset() + if err != nil { + log.Printf("[ERR] Error writing to statsd! Err: %s", err) + goto WAIT + } + } + + // Append to the buffer + buf.WriteString(metric) + + case <-ticker.C: + if buf.Len() == 0 { + continue + } + + _, err := sock.Write(buf.Bytes()) + buf.Reset() + if err != nil { + log.Printf("[ERR] Error flushing to statsd! Err: %s", err) + goto WAIT + } + } + } + +WAIT: + // Wait for a while + wait = time.After(time.Duration(5) * time.Second) + for { + select { + // Dequeue the messages to avoid backlog + case _, ok := <-s.metricQueue: + if !ok { + goto QUIT + } + case <-wait: + goto CONNECT + } + } +QUIT: + s.metricQueue = nil +} diff --git a/src/alertmanager/vendor/github.com/armon/go-metrics/statsite.go b/src/alertmanager/vendor/github.com/armon/go-metrics/statsite.go new file mode 100644 index 0000000..6c0d284 --- /dev/null +++ b/src/alertmanager/vendor/github.com/armon/go-metrics/statsite.go @@ -0,0 +1,172 @@ +package metrics + +import ( + "bufio" + "fmt" + "log" + "net" + "net/url" + "strings" + "time" +) + +const ( + // We force flush the statsite metrics after this period of + // inactivity. Prevents stats from getting stuck in a buffer + // forever. + flushInterval = 100 * time.Millisecond +) + +// NewStatsiteSinkFromURL creates an StatsiteSink from a URL. It is used +// (and tested) from NewMetricSinkFromURL. +func NewStatsiteSinkFromURL(u *url.URL) (MetricSink, error) { + return NewStatsiteSink(u.Host) +} + +// StatsiteSink provides a MetricSink that can be used with a +// statsite metrics server +type StatsiteSink struct { + addr string + metricQueue chan string +} + +// NewStatsiteSink is used to create a new StatsiteSink +func NewStatsiteSink(addr string) (*StatsiteSink, error) { + s := &StatsiteSink{ + addr: addr, + metricQueue: make(chan string, 4096), + } + go s.flushMetrics() + return s, nil +} + +// Close is used to stop flushing to statsite +func (s *StatsiteSink) Shutdown() { + close(s.metricQueue) +} + +func (s *StatsiteSink) SetGauge(key []string, val float32) { + flatKey := s.flattenKey(key) + s.pushMetric(fmt.Sprintf("%s:%f|g\n", flatKey, val)) +} + +func (s *StatsiteSink) SetGaugeWithLabels(key []string, val float32, labels []Label) { + flatKey := s.flattenKeyLabels(key, labels) + s.pushMetric(fmt.Sprintf("%s:%f|g\n", flatKey, val)) +} + +func (s *StatsiteSink) EmitKey(key []string, val float32) { + flatKey := s.flattenKey(key) + s.pushMetric(fmt.Sprintf("%s:%f|kv\n", flatKey, val)) +} + +func (s *StatsiteSink) IncrCounter(key []string, val float32) { + flatKey := s.flattenKey(key) + s.pushMetric(fmt.Sprintf("%s:%f|c\n", flatKey, val)) +} + +func (s *StatsiteSink) IncrCounterWithLabels(key []string, val float32, labels []Label) { + flatKey := s.flattenKeyLabels(key, labels) + s.pushMetric(fmt.Sprintf("%s:%f|c\n", flatKey, val)) +} + +func (s *StatsiteSink) AddSample(key []string, val float32) { + flatKey := s.flattenKey(key) + s.pushMetric(fmt.Sprintf("%s:%f|ms\n", flatKey, val)) +} + +func (s *StatsiteSink) AddSampleWithLabels(key []string, val float32, labels []Label) { + flatKey := s.flattenKeyLabels(key, labels) + s.pushMetric(fmt.Sprintf("%s:%f|ms\n", flatKey, val)) +} + +// Flattens the key for formatting, removes spaces +func (s *StatsiteSink) flattenKey(parts []string) string { + joined := strings.Join(parts, ".") + return strings.Map(func(r rune) rune { + switch r { + case ':': + fallthrough + case ' ': + return '_' + default: + return r + } + }, joined) +} + +// Flattens the key along with labels for formatting, removes spaces +func (s *StatsiteSink) flattenKeyLabels(parts []string, labels []Label) string { + for _, label := range labels { + parts = append(parts, label.Value) + } + return s.flattenKey(parts) +} + +// Does a non-blocking push to the metrics queue +func (s *StatsiteSink) pushMetric(m string) { + select { + case s.metricQueue <- m: + default: + } +} + +// Flushes metrics +func (s *StatsiteSink) flushMetrics() { + var sock net.Conn + var err error + var wait <-chan time.Time + var buffered *bufio.Writer + ticker := time.NewTicker(flushInterval) + defer ticker.Stop() + +CONNECT: + // Attempt to connect + sock, err = net.Dial("tcp", s.addr) + if err != nil { + log.Printf("[ERR] Error connecting to statsite! Err: %s", err) + goto WAIT + } + + // Create a buffered writer + buffered = bufio.NewWriter(sock) + + for { + select { + case metric, ok := <-s.metricQueue: + // Get a metric from the queue + if !ok { + goto QUIT + } + + // Try to send to statsite + _, err := buffered.Write([]byte(metric)) + if err != nil { + log.Printf("[ERR] Error writing to statsite! Err: %s", err) + goto WAIT + } + case <-ticker.C: + if err := buffered.Flush(); err != nil { + log.Printf("[ERR] Error flushing to statsite! Err: %s", err) + goto WAIT + } + } + } + +WAIT: + // Wait for a while + wait = time.After(time.Duration(5) * time.Second) + for { + select { + // Dequeue the messages to avoid backlog + case _, ok := <-s.metricQueue: + if !ok { + goto QUIT + } + case <-wait: + goto CONNECT + } + } +QUIT: + s.metricQueue = nil +} diff --git a/src/alertmanager/vendor/github.com/beorn7/perks/quantile/exampledata.txt b/src/alertmanager/vendor/github.com/beorn7/perks/quantile/exampledata.txt new file mode 100644 index 0000000..1602287 --- /dev/null +++ b/src/alertmanager/vendor/github.com/beorn7/perks/quantile/exampledata.txt @@ -0,0 +1,2388 @@ +8 +5 +26 +12 +5 +235 +13 +6 +28 +30 +3 +3 +3 +3 +5 +2 +33 +7 +2 +4 +7 +12 +14 +5 +8 +3 +10 +4 +5 +3 +6 +6 +209 +20 +3 +10 +14 +3 +4 +6 +8 +5 +11 +7 +3 +2 +3 +3 +212 +5 +222 +4 +10 +10 +5 +6 +3 +8 +3 +10 +254 +220 +2 +3 +5 +24 +5 +4 +222 +7 +3 +3 +223 +8 +15 +12 +14 +14 +3 +2 +2 +3 +13 +3 +11 +4 +4 +6 +5 +7 +13 +5 +3 +5 +2 +5 +3 +5 +2 +7 +15 +17 +14 +3 +6 +6 +3 +17 +5 +4 +7 +6 +4 +4 +8 +6 +8 +3 +9 +3 +6 +3 +4 +5 +3 +3 +660 +4 +6 +10 +3 +6 +3 +2 +5 +13 +2 +4 +4 +10 +4 +8 +4 +3 +7 +9 +9 +3 +10 +37 +3 +13 +4 +12 +3 +6 +10 +8 +5 +21 +2 +3 +8 +3 +2 +3 +3 +4 +12 +2 +4 +8 +8 +4 +3 +2 +20 +1 +6 +32 +2 +11 +6 +18 +3 +8 +11 +3 +212 +3 +4 +2 +6 +7 +12 +11 +3 +2 +16 +10 +6 +4 +6 +3 +2 +7 +3 +2 +2 +2 +2 +5 +6 +4 +3 +10 +3 +4 +6 +5 +3 +4 +4 +5 +6 +4 +3 +4 +4 +5 +7 +5 +5 +3 +2 +7 +2 +4 +12 +4 +5 +6 +2 +4 +4 +8 +4 +15 +13 +7 +16 +5 +3 +23 +5 +5 +7 +3 +2 +9 +8 +7 +5 +8 +11 +4 +10 +76 +4 +47 +4 +3 +2 +7 +4 +2 +3 +37 +10 +4 +2 +20 +5 +4 +4 +10 +10 +4 +3 +7 +23 +240 +7 +13 +5 +5 +3 +3 +2 +5 +4 +2 +8 +7 +19 +2 +23 +8 +7 +2 +5 +3 +8 +3 +8 +13 +5 +5 +5 +2 +3 +23 +4 +9 +8 +4 +3 +3 +5 +220 +2 +3 +4 +6 +14 +3 +53 +6 +2 +5 +18 +6 +3 +219 +6 +5 +2 +5 +3 +6 +5 +15 +4 +3 +17 +3 +2 +4 +7 +2 +3 +3 +4 +4 +3 +2 +664 +6 +3 +23 +5 +5 +16 +5 +8 +2 +4 +2 +24 +12 +3 +2 +3 +5 +8 +3 +5 +4 +3 +14 +3 +5 +8 +2 +3 +7 +9 +4 +2 +3 +6 +8 +4 +3 +4 +6 +5 +3 +3 +6 +3 +19 +4 +4 +6 +3 +6 +3 +5 +22 +5 +4 +4 +3 +8 +11 +4 +9 +7 +6 +13 +4 +4 +4 +6 +17 +9 +3 +3 +3 +4 +3 +221 +5 +11 +3 +4 +2 +12 +6 +3 +5 +7 +5 +7 +4 +9 +7 +14 +37 +19 +217 +16 +3 +5 +2 +2 +7 +19 +7 +6 +7 +4 +24 +5 +11 +4 +7 +7 +9 +13 +3 +4 +3 +6 +28 +4 +4 +5 +5 +2 +5 +6 +4 +4 +6 +10 +5 +4 +3 +2 +3 +3 +6 +5 +5 +4 +3 +2 +3 +7 +4 +6 +18 +16 +8 +16 +4 +5 +8 +6 +9 +13 +1545 +6 +215 +6 +5 +6 +3 +45 +31 +5 +2 +2 +4 +3 +3 +2 +5 +4 +3 +5 +7 +7 +4 +5 +8 +5 +4 +749 +2 +31 +9 +11 +2 +11 +5 +4 +4 +7 +9 +11 +4 +5 +4 +7 +3 +4 +6 +2 +15 +3 +4 +3 +4 +3 +5 +2 +13 +5 +5 +3 +3 +23 +4 +4 +5 +7 +4 +13 +2 +4 +3 +4 +2 +6 +2 +7 +3 +5 +5 +3 +29 +5 +4 +4 +3 +10 +2 +3 +79 +16 +6 +6 +7 +7 +3 +5 +5 +7 +4 +3 +7 +9 +5 +6 +5 +9 +6 +3 +6 +4 +17 +2 +10 +9 +3 +6 +2 +3 +21 +22 +5 +11 +4 +2 +17 +2 +224 +2 +14 +3 +4 +4 +2 +4 +4 +4 +4 +5 +3 +4 +4 +10 +2 +6 +3 +3 +5 +7 +2 +7 +5 +6 +3 +218 +2 +2 +5 +2 +6 +3 +5 +222 +14 +6 +33 +3 +2 +5 +3 +3 +3 +9 +5 +3 +3 +2 +7 +4 +3 +4 +3 +5 +6 +5 +26 +4 +13 +9 +7 +3 +221 +3 +3 +4 +4 +4 +4 +2 +18 +5 +3 +7 +9 +6 +8 +3 +10 +3 +11 +9 +5 +4 +17 +5 +5 +6 +6 +3 +2 +4 +12 +17 +6 +7 +218 +4 +2 +4 +10 +3 +5 +15 +3 +9 +4 +3 +3 +6 +29 +3 +3 +4 +5 +5 +3 +8 +5 +6 +6 +7 +5 +3 +5 +3 +29 +2 +31 +5 +15 +24 +16 +5 +207 +4 +3 +3 +2 +15 +4 +4 +13 +5 +5 +4 +6 +10 +2 +7 +8 +4 +6 +20 +5 +3 +4 +3 +12 +12 +5 +17 +7 +3 +3 +3 +6 +10 +3 +5 +25 +80 +4 +9 +3 +2 +11 +3 +3 +2 +3 +8 +7 +5 +5 +19 +5 +3 +3 +12 +11 +2 +6 +5 +5 +5 +3 +3 +3 +4 +209 +14 +3 +2 +5 +19 +4 +4 +3 +4 +14 +5 +6 +4 +13 +9 +7 +4 +7 +10 +2 +9 +5 +7 +2 +8 +4 +6 +5 +5 +222 +8 +7 +12 +5 +216 +3 +4 +4 +6 +3 +14 +8 +7 +13 +4 +3 +3 +3 +3 +17 +5 +4 +3 +33 +6 +6 +33 +7 +5 +3 +8 +7 +5 +2 +9 +4 +2 +233 +24 +7 +4 +8 +10 +3 +4 +15 +2 +16 +3 +3 +13 +12 +7 +5 +4 +207 +4 +2 +4 +27 +15 +2 +5 +2 +25 +6 +5 +5 +6 +13 +6 +18 +6 +4 +12 +225 +10 +7 +5 +2 +2 +11 +4 +14 +21 +8 +10 +3 +5 +4 +232 +2 +5 +5 +3 +7 +17 +11 +6 +6 +23 +4 +6 +3 +5 +4 +2 +17 +3 +6 +5 +8 +3 +2 +2 +14 +9 +4 +4 +2 +5 +5 +3 +7 +6 +12 +6 +10 +3 +6 +2 +2 +19 +5 +4 +4 +9 +2 +4 +13 +3 +5 +6 +3 +6 +5 +4 +9 +6 +3 +5 +7 +3 +6 +6 +4 +3 +10 +6 +3 +221 +3 +5 +3 +6 +4 +8 +5 +3 +6 +4 +4 +2 +54 +5 +6 +11 +3 +3 +4 +4 +4 +3 +7 +3 +11 +11 +7 +10 +6 +13 +223 +213 +15 +231 +7 +3 +7 +228 +2 +3 +4 +4 +5 +6 +7 +4 +13 +3 +4 +5 +3 +6 +4 +6 +7 +2 +4 +3 +4 +3 +3 +6 +3 +7 +3 +5 +18 +5 +6 +8 +10 +3 +3 +3 +2 +4 +2 +4 +4 +5 +6 +6 +4 +10 +13 +3 +12 +5 +12 +16 +8 +4 +19 +11 +2 +4 +5 +6 +8 +5 +6 +4 +18 +10 +4 +2 +216 +6 +6 +6 +2 +4 +12 +8 +3 +11 +5 +6 +14 +5 +3 +13 +4 +5 +4 +5 +3 +28 +6 +3 +7 +219 +3 +9 +7 +3 +10 +6 +3 +4 +19 +5 +7 +11 +6 +15 +19 +4 +13 +11 +3 +7 +5 +10 +2 +8 +11 +2 +6 +4 +6 +24 +6 +3 +3 +3 +3 +6 +18 +4 +11 +4 +2 +5 +10 +8 +3 +9 +5 +3 +4 +5 +6 +2 +5 +7 +4 +4 +14 +6 +4 +4 +5 +5 +7 +2 +4 +3 +7 +3 +3 +6 +4 +5 +4 +4 +4 +3 +3 +3 +3 +8 +14 +2 +3 +5 +3 +2 +4 +5 +3 +7 +3 +3 +18 +3 +4 +4 +5 +7 +3 +3 +3 +13 +5 +4 +8 +211 +5 +5 +3 +5 +2 +5 +4 +2 +655 +6 +3 +5 +11 +2 +5 +3 +12 +9 +15 +11 +5 +12 +217 +2 +6 +17 +3 +3 +207 +5 +5 +4 +5 +9 +3 +2 +8 +5 +4 +3 +2 +5 +12 +4 +14 +5 +4 +2 +13 +5 +8 +4 +225 +4 +3 +4 +5 +4 +3 +3 +6 +23 +9 +2 +6 +7 +233 +4 +4 +6 +18 +3 +4 +6 +3 +4 +4 +2 +3 +7 +4 +13 +227 +4 +3 +5 +4 +2 +12 +9 +17 +3 +7 +14 +6 +4 +5 +21 +4 +8 +9 +2 +9 +25 +16 +3 +6 +4 +7 +8 +5 +2 +3 +5 +4 +3 +3 +5 +3 +3 +3 +2 +3 +19 +2 +4 +3 +4 +2 +3 +4 +4 +2 +4 +3 +3 +3 +2 +6 +3 +17 +5 +6 +4 +3 +13 +5 +3 +3 +3 +4 +9 +4 +2 +14 +12 +4 +5 +24 +4 +3 +37 +12 +11 +21 +3 +4 +3 +13 +4 +2 +3 +15 +4 +11 +4 +4 +3 +8 +3 +4 +4 +12 +8 +5 +3 +3 +4 +2 +220 +3 +5 +223 +3 +3 +3 +10 +3 +15 +4 +241 +9 +7 +3 +6 +6 +23 +4 +13 +7 +3 +4 +7 +4 +9 +3 +3 +4 +10 +5 +5 +1 +5 +24 +2 +4 +5 +5 +6 +14 +3 +8 +2 +3 +5 +13 +13 +3 +5 +2 +3 +15 +3 +4 +2 +10 +4 +4 +4 +5 +5 +3 +5 +3 +4 +7 +4 +27 +3 +6 +4 +15 +3 +5 +6 +6 +5 +4 +8 +3 +9 +2 +6 +3 +4 +3 +7 +4 +18 +3 +11 +3 +3 +8 +9 +7 +24 +3 +219 +7 +10 +4 +5 +9 +12 +2 +5 +4 +4 +4 +3 +3 +19 +5 +8 +16 +8 +6 +22 +3 +23 +3 +242 +9 +4 +3 +3 +5 +7 +3 +3 +5 +8 +3 +7 +5 +14 +8 +10 +3 +4 +3 +7 +4 +6 +7 +4 +10 +4 +3 +11 +3 +7 +10 +3 +13 +6 +8 +12 +10 +5 +7 +9 +3 +4 +7 +7 +10 +8 +30 +9 +19 +4 +3 +19 +15 +4 +13 +3 +215 +223 +4 +7 +4 +8 +17 +16 +3 +7 +6 +5 +5 +4 +12 +3 +7 +4 +4 +13 +4 +5 +2 +5 +6 +5 +6 +6 +7 +10 +18 +23 +9 +3 +3 +6 +5 +2 +4 +2 +7 +3 +3 +2 +5 +5 +14 +10 +224 +6 +3 +4 +3 +7 +5 +9 +3 +6 +4 +2 +5 +11 +4 +3 +3 +2 +8 +4 +7 +4 +10 +7 +3 +3 +18 +18 +17 +3 +3 +3 +4 +5 +3 +3 +4 +12 +7 +3 +11 +13 +5 +4 +7 +13 +5 +4 +11 +3 +12 +3 +6 +4 +4 +21 +4 +6 +9 +5 +3 +10 +8 +4 +6 +4 +4 +6 +5 +4 +8 +6 +4 +6 +4 +4 +5 +9 +6 +3 +4 +2 +9 +3 +18 +2 +4 +3 +13 +3 +6 +6 +8 +7 +9 +3 +2 +16 +3 +4 +6 +3 +2 +33 +22 +14 +4 +9 +12 +4 +5 +6 +3 +23 +9 +4 +3 +5 +5 +3 +4 +5 +3 +5 +3 +10 +4 +5 +5 +8 +4 +4 +6 +8 +5 +4 +3 +4 +6 +3 +3 +3 +5 +9 +12 +6 +5 +9 +3 +5 +3 +2 +2 +2 +18 +3 +2 +21 +2 +5 +4 +6 +4 +5 +10 +3 +9 +3 +2 +10 +7 +3 +6 +6 +4 +4 +8 +12 +7 +3 +7 +3 +3 +9 +3 +4 +5 +4 +4 +5 +5 +10 +15 +4 +4 +14 +6 +227 +3 +14 +5 +216 +22 +5 +4 +2 +2 +6 +3 +4 +2 +9 +9 +4 +3 +28 +13 +11 +4 +5 +3 +3 +2 +3 +3 +5 +3 +4 +3 +5 +23 +26 +3 +4 +5 +6 +4 +6 +3 +5 +5 +3 +4 +3 +2 +2 +2 +7 +14 +3 +6 +7 +17 +2 +2 +15 +14 +16 +4 +6 +7 +13 +6 +4 +5 +6 +16 +3 +3 +28 +3 +6 +15 +3 +9 +2 +4 +6 +3 +3 +22 +4 +12 +6 +7 +2 +5 +4 +10 +3 +16 +6 +9 +2 +5 +12 +7 +5 +5 +5 +5 +2 +11 +9 +17 +4 +3 +11 +7 +3 +5 +15 +4 +3 +4 +211 +8 +7 +5 +4 +7 +6 +7 +6 +3 +6 +5 +6 +5 +3 +4 +4 +26 +4 +6 +10 +4 +4 +3 +2 +3 +3 +4 +5 +9 +3 +9 +4 +4 +5 +5 +8 +2 +4 +2 +3 +8 +4 +11 +19 +5 +8 +6 +3 +5 +6 +12 +3 +2 +4 +16 +12 +3 +4 +4 +8 +6 +5 +6 +6 +219 +8 +222 +6 +16 +3 +13 +19 +5 +4 +3 +11 +6 +10 +4 +7 +7 +12 +5 +3 +3 +5 +6 +10 +3 +8 +2 +5 +4 +7 +2 +4 +4 +2 +12 +9 +6 +4 +2 +40 +2 +4 +10 +4 +223 +4 +2 +20 +6 +7 +24 +5 +4 +5 +2 +20 +16 +6 +5 +13 +2 +3 +3 +19 +3 +2 +4 +5 +6 +7 +11 +12 +5 +6 +7 +7 +3 +5 +3 +5 +3 +14 +3 +4 +4 +2 +11 +1 +7 +3 +9 +6 +11 +12 +5 +8 +6 +221 +4 +2 +12 +4 +3 +15 +4 +5 +226 +7 +218 +7 +5 +4 +5 +18 +4 +5 +9 +4 +4 +2 +9 +18 +18 +9 +5 +6 +6 +3 +3 +7 +3 +5 +4 +4 +4 +12 +3 +6 +31 +5 +4 +7 +3 +6 +5 +6 +5 +11 +2 +2 +11 +11 +6 +7 +5 +8 +7 +10 +5 +23 +7 +4 +3 +5 +34 +2 +5 +23 +7 +3 +6 +8 +4 +4 +4 +2 +5 +3 +8 +5 +4 +8 +25 +2 +3 +17 +8 +3 +4 +8 +7 +3 +15 +6 +5 +7 +21 +9 +5 +6 +6 +5 +3 +2 +3 +10 +3 +6 +3 +14 +7 +4 +4 +8 +7 +8 +2 +6 +12 +4 +213 +6 +5 +21 +8 +2 +5 +23 +3 +11 +2 +3 +6 +25 +2 +3 +6 +7 +6 +6 +4 +4 +6 +3 +17 +9 +7 +6 +4 +3 +10 +7 +2 +3 +3 +3 +11 +8 +3 +7 +6 +4 +14 +36 +3 +4 +3 +3 +22 +13 +21 +4 +2 +7 +4 +4 +17 +15 +3 +7 +11 +2 +4 +7 +6 +209 +6 +3 +2 +2 +24 +4 +9 +4 +3 +3 +3 +29 +2 +2 +4 +3 +3 +5 +4 +6 +3 +3 +2 +4 diff --git a/src/alertmanager/vendor/github.com/beorn7/perks/quantile/stream.go b/src/alertmanager/vendor/github.com/beorn7/perks/quantile/stream.go new file mode 100644 index 0000000..587b1fc --- /dev/null +++ b/src/alertmanager/vendor/github.com/beorn7/perks/quantile/stream.go @@ -0,0 +1,292 @@ +// Package quantile computes approximate quantiles over an unbounded data +// stream within low memory and CPU bounds. +// +// A small amount of accuracy is traded to achieve the above properties. +// +// Multiple streams can be merged before calling Query to generate a single set +// of results. This is meaningful when the streams represent the same type of +// data. See Merge and Samples. +// +// For more detailed information about the algorithm used, see: +// +// Effective Computation of Biased Quantiles over Data Streams +// +// http://www.cs.rutgers.edu/~muthu/bquant.pdf +package quantile + +import ( + "math" + "sort" +) + +// Sample holds an observed value and meta information for compression. JSON +// tags have been added for convenience. +type Sample struct { + Value float64 `json:",string"` + Width float64 `json:",string"` + Delta float64 `json:",string"` +} + +// Samples represents a slice of samples. It implements sort.Interface. +type Samples []Sample + +func (a Samples) Len() int { return len(a) } +func (a Samples) Less(i, j int) bool { return a[i].Value < a[j].Value } +func (a Samples) Swap(i, j int) { a[i], a[j] = a[j], a[i] } + +type invariant func(s *stream, r float64) float64 + +// NewLowBiased returns an initialized Stream for low-biased quantiles +// (e.g. 0.01, 0.1, 0.5) where the needed quantiles are not known a priori, but +// error guarantees can still be given even for the lower ranks of the data +// distribution. +// +// The provided epsilon is a relative error, i.e. the true quantile of a value +// returned by a query is guaranteed to be within (1±Epsilon)*Quantile. +// +// See http://www.cs.rutgers.edu/~muthu/bquant.pdf for time, space, and error +// properties. +func NewLowBiased(epsilon float64) *Stream { + ƒ := func(s *stream, r float64) float64 { + return 2 * epsilon * r + } + return newStream(ƒ) +} + +// NewHighBiased returns an initialized Stream for high-biased quantiles +// (e.g. 0.01, 0.1, 0.5) where the needed quantiles are not known a priori, but +// error guarantees can still be given even for the higher ranks of the data +// distribution. +// +// The provided epsilon is a relative error, i.e. the true quantile of a value +// returned by a query is guaranteed to be within 1-(1±Epsilon)*(1-Quantile). +// +// See http://www.cs.rutgers.edu/~muthu/bquant.pdf for time, space, and error +// properties. +func NewHighBiased(epsilon float64) *Stream { + ƒ := func(s *stream, r float64) float64 { + return 2 * epsilon * (s.n - r) + } + return newStream(ƒ) +} + +// NewTargeted returns an initialized Stream concerned with a particular set of +// quantile values that are supplied a priori. Knowing these a priori reduces +// space and computation time. The targets map maps the desired quantiles to +// their absolute errors, i.e. the true quantile of a value returned by a query +// is guaranteed to be within (Quantile±Epsilon). +// +// See http://www.cs.rutgers.edu/~muthu/bquant.pdf for time, space, and error properties. +func NewTargeted(targets map[float64]float64) *Stream { + ƒ := func(s *stream, r float64) float64 { + var m = math.MaxFloat64 + var f float64 + for quantile, epsilon := range targets { + if quantile*s.n <= r { + f = (2 * epsilon * r) / quantile + } else { + f = (2 * epsilon * (s.n - r)) / (1 - quantile) + } + if f < m { + m = f + } + } + return m + } + return newStream(ƒ) +} + +// Stream computes quantiles for a stream of float64s. It is not thread-safe by +// design. Take care when using across multiple goroutines. +type Stream struct { + *stream + b Samples + sorted bool +} + +func newStream(ƒ invariant) *Stream { + x := &stream{ƒ: ƒ} + return &Stream{x, make(Samples, 0, 500), true} +} + +// Insert inserts v into the stream. +func (s *Stream) Insert(v float64) { + s.insert(Sample{Value: v, Width: 1}) +} + +func (s *Stream) insert(sample Sample) { + s.b = append(s.b, sample) + s.sorted = false + if len(s.b) == cap(s.b) { + s.flush() + } +} + +// Query returns the computed qth percentiles value. If s was created with +// NewTargeted, and q is not in the set of quantiles provided a priori, Query +// will return an unspecified result. +func (s *Stream) Query(q float64) float64 { + if !s.flushed() { + // Fast path when there hasn't been enough data for a flush; + // this also yields better accuracy for small sets of data. + l := len(s.b) + if l == 0 { + return 0 + } + i := int(float64(l) * q) + if i > 0 { + i -= 1 + } + s.maybeSort() + return s.b[i].Value + } + s.flush() + return s.stream.query(q) +} + +// Merge merges samples into the underlying streams samples. This is handy when +// merging multiple streams from separate threads, database shards, etc. +// +// ATTENTION: This method is broken and does not yield correct results. The +// underlying algorithm is not capable of merging streams correctly. +func (s *Stream) Merge(samples Samples) { + sort.Sort(samples) + s.stream.merge(samples) +} + +// Reset reinitializes and clears the list reusing the samples buffer memory. +func (s *Stream) Reset() { + s.stream.reset() + s.b = s.b[:0] +} + +// Samples returns stream samples held by s. +func (s *Stream) Samples() Samples { + if !s.flushed() { + return s.b + } + s.flush() + return s.stream.samples() +} + +// Count returns the total number of samples observed in the stream +// since initialization. +func (s *Stream) Count() int { + return len(s.b) + s.stream.count() +} + +func (s *Stream) flush() { + s.maybeSort() + s.stream.merge(s.b) + s.b = s.b[:0] +} + +func (s *Stream) maybeSort() { + if !s.sorted { + s.sorted = true + sort.Sort(s.b) + } +} + +func (s *Stream) flushed() bool { + return len(s.stream.l) > 0 +} + +type stream struct { + n float64 + l []Sample + ƒ invariant +} + +func (s *stream) reset() { + s.l = s.l[:0] + s.n = 0 +} + +func (s *stream) insert(v float64) { + s.merge(Samples{{v, 1, 0}}) +} + +func (s *stream) merge(samples Samples) { + // TODO(beorn7): This tries to merge not only individual samples, but + // whole summaries. The paper doesn't mention merging summaries at + // all. Unittests show that the merging is inaccurate. Find out how to + // do merges properly. + var r float64 + i := 0 + for _, sample := range samples { + for ; i < len(s.l); i++ { + c := s.l[i] + if c.Value > sample.Value { + // Insert at position i. + s.l = append(s.l, Sample{}) + copy(s.l[i+1:], s.l[i:]) + s.l[i] = Sample{ + sample.Value, + sample.Width, + math.Max(sample.Delta, math.Floor(s.ƒ(s, r))-1), + // TODO(beorn7): How to calculate delta correctly? + } + i++ + goto inserted + } + r += c.Width + } + s.l = append(s.l, Sample{sample.Value, sample.Width, 0}) + i++ + inserted: + s.n += sample.Width + r += sample.Width + } + s.compress() +} + +func (s *stream) count() int { + return int(s.n) +} + +func (s *stream) query(q float64) float64 { + t := math.Ceil(q * s.n) + t += math.Ceil(s.ƒ(s, t) / 2) + p := s.l[0] + var r float64 + for _, c := range s.l[1:] { + r += p.Width + if r+c.Width+c.Delta > t { + return p.Value + } + p = c + } + return p.Value +} + +func (s *stream) compress() { + if len(s.l) < 2 { + return + } + x := s.l[len(s.l)-1] + xi := len(s.l) - 1 + r := s.n - 1 - x.Width + + for i := len(s.l) - 2; i >= 0; i-- { + c := s.l[i] + if c.Width+x.Width+x.Delta <= s.ƒ(s, r) { + x.Width += c.Width + s.l[xi] = x + // Remove element at i. + copy(s.l[i:], s.l[i+1:]) + s.l = s.l[:len(s.l)-1] + xi -= 1 + } else { + x = c + xi = i + } + r -= c.Width + } +} + +func (s *stream) samples() Samples { + samples := make(Samples, len(s.l)) + copy(samples, s.l) + return samples +} diff --git a/src/alertmanager/vendor/github.com/cenkalti/backoff/LICENSE b/src/alertmanager/vendor/github.com/cenkalti/backoff/LICENSE new file mode 100644 index 0000000..89b8179 --- /dev/null +++ b/src/alertmanager/vendor/github.com/cenkalti/backoff/LICENSE @@ -0,0 +1,20 @@ +The MIT License (MIT) + +Copyright (c) 2014 Cenk Altı + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/src/alertmanager/vendor/github.com/cenkalti/backoff/README.md b/src/alertmanager/vendor/github.com/cenkalti/backoff/README.md new file mode 100644 index 0000000..020b8fb --- /dev/null +++ b/src/alertmanager/vendor/github.com/cenkalti/backoff/README.md @@ -0,0 +1,116 @@ +# Exponential Backoff [![GoDoc][godoc image]][godoc] [![Build Status][travis image]][travis] + +This is a Go port of the exponential backoff algorithm from [Google's HTTP Client Library for Java][google-http-java-client]. + +[Exponential backoff][exponential backoff wiki] +is an algorithm that uses feedback to multiplicatively decrease the rate of some process, +in order to gradually find an acceptable rate. +The retries exponentially increase and stop increasing when a certain threshold is met. + +## How To + +We define two functions, `Retry()` and `RetryNotify()`. +They receive an `Operation` to execute, a `BackOff` algorithm, +and an optional `Notify` error handler. + +The operation will be executed, and will be retried on failure with delay +as given by the backoff algorithm. The backoff algorithm can also decide when to stop +retrying. +In addition, the notify error handler will be called after each failed attempt, +except for the last time, whose error should be handled by the caller. + +```go +// An Operation is executing by Retry() or RetryNotify(). +// The operation will be retried using a backoff policy if it returns an error. +type Operation func() error + +// Notify is a notify-on-error function. It receives an operation error and +// backoff delay if the operation failed (with an error). +// +// NOTE that if the backoff policy stated to stop retrying, +// the notify function isn't called. +type Notify func(error, time.Duration) + +func Retry(Operation, BackOff) error +func RetryNotify(Operation, BackOff, Notify) +``` + +## Examples + +See more advanced examples in the [godoc][advanced example]. + +### Retry + +Simple retry helper that uses the default exponential backoff algorithm: + +```go +operation := func() error { + // An operation that might fail. + return nil // or return errors.New("some error") +} + +err := Retry(operation, NewExponentialBackOff()) +if err != nil { + // Handle error. + return err +} + +// Operation is successful. +return nil +``` + +### Ticker + +```go +operation := func() error { + // An operation that might fail + return nil // or return errors.New("some error") +} + +b := NewExponentialBackOff() +ticker := NewTicker(b) + +var err error + +// Ticks will continue to arrive when the previous operation is still running, +// so operations that take a while to fail could run in quick succession. +for range ticker.C { + if err = operation(); err != nil { + log.Println(err, "will retry...") + continue + } + + ticker.Stop() + break +} + +if err != nil { + // Operation has failed. + return err +} + +// Operation is successful. +return nil +``` + +## Getting Started + +```bash +# install +$ go get github.com/cenkalti/backoff + +# test +$ cd $GOPATH/src/github.com/cenkalti/backoff +$ go get -t ./... +$ go test -v -cover +``` + +[godoc]: https://godoc.org/github.com/cenkalti/backoff +[godoc image]: https://godoc.org/github.com/cenkalti/backoff?status.png +[travis]: https://travis-ci.org/cenkalti/backoff +[travis image]: https://travis-ci.org/cenkalti/backoff.png + +[google-http-java-client]: https://github.com/google/google-http-java-client +[exponential backoff wiki]: http://en.wikipedia.org/wiki/Exponential_backoff + +[advanced example]: https://godoc.org/github.com/cenkalti/backoff#example_ diff --git a/src/alertmanager/vendor/github.com/cenkalti/backoff/backoff.go b/src/alertmanager/vendor/github.com/cenkalti/backoff/backoff.go new file mode 100644 index 0000000..61bd6df --- /dev/null +++ b/src/alertmanager/vendor/github.com/cenkalti/backoff/backoff.go @@ -0,0 +1,59 @@ +// Package backoff implements backoff algorithms for retrying operations. +// +// Also has a Retry() helper for retrying operations that may fail. +package backoff + +import "time" + +// BackOff is a backoff policy for retrying an operation. +type BackOff interface { + // NextBackOff returns the duration to wait before retrying the operation, + // or backoff.Stop to indicate that no more retries should be made. + // + // Example usage: + // + // duration := backoff.NextBackOff(); + // if (duration == backoff.Stop) { + // // Do not retry operation. + // } else { + // // Sleep for duration and retry operation. + // } + // + NextBackOff() time.Duration + + // Reset to initial state. + Reset() +} + +// Indicates that no more retries should be made for use in NextBackOff(). +const Stop time.Duration = -1 + +// ZeroBackOff is a fixed backoff policy whose backoff time is always zero, +// meaning that the operation is retried immediately without waiting, indefinitely. +type ZeroBackOff struct{} + +func (b *ZeroBackOff) Reset() {} + +func (b *ZeroBackOff) NextBackOff() time.Duration { return 0 } + +// StopBackOff is a fixed backoff policy that always returns backoff.Stop for +// NextBackOff(), meaning that the operation should never be retried. +type StopBackOff struct{} + +func (b *StopBackOff) Reset() {} + +func (b *StopBackOff) NextBackOff() time.Duration { return Stop } + +// ConstantBackOff is a backoff policy that always returns the same backoff delay. +// This is in contrast to an exponential backoff policy, +// which returns a delay that grows longer as you call NextBackOff() over and over again. +type ConstantBackOff struct { + Interval time.Duration +} + +func (b *ConstantBackOff) Reset() {} +func (b *ConstantBackOff) NextBackOff() time.Duration { return b.Interval } + +func NewConstantBackOff(d time.Duration) *ConstantBackOff { + return &ConstantBackOff{Interval: d} +} diff --git a/src/alertmanager/vendor/github.com/cenkalti/backoff/exponential.go b/src/alertmanager/vendor/github.com/cenkalti/backoff/exponential.go new file mode 100644 index 0000000..cc2a164 --- /dev/null +++ b/src/alertmanager/vendor/github.com/cenkalti/backoff/exponential.go @@ -0,0 +1,151 @@ +package backoff + +import ( + "math/rand" + "time" +) + +/* +ExponentialBackOff is a backoff implementation that increases the backoff +period for each retry attempt using a randomization function that grows exponentially. + +NextBackOff() is calculated using the following formula: + + randomized interval = + RetryInterval * (random value in range [1 - RandomizationFactor, 1 + RandomizationFactor]) + +In other words NextBackOff() will range between the randomization factor +percentage below and above the retry interval. + +For example, given the following parameters: + + RetryInterval = 2 + RandomizationFactor = 0.5 + Multiplier = 2 + +the actual backoff period used in the next retry attempt will range between 1 and 3 seconds, +multiplied by the exponential, that is, between 2 and 6 seconds. + +Note: MaxInterval caps the RetryInterval and not the randomized interval. + +If the time elapsed since an ExponentialBackOff instance is created goes past the +MaxElapsedTime, then the method NextBackOff() starts returning backoff.Stop. + +The elapsed time can be reset by calling Reset(). + +Example: Given the following default arguments, for 10 tries the sequence will be, +and assuming we go over the MaxElapsedTime on the 10th try: + + Request # RetryInterval (seconds) Randomized Interval (seconds) + + 1 0.5 [0.25, 0.75] + 2 0.75 [0.375, 1.125] + 3 1.125 [0.562, 1.687] + 4 1.687 [0.8435, 2.53] + 5 2.53 [1.265, 3.795] + 6 3.795 [1.897, 5.692] + 7 5.692 [2.846, 8.538] + 8 8.538 [4.269, 12.807] + 9 12.807 [6.403, 19.210] + 10 19.210 backoff.Stop + +Note: Implementation is not thread-safe. +*/ +type ExponentialBackOff struct { + InitialInterval time.Duration + RandomizationFactor float64 + Multiplier float64 + MaxInterval time.Duration + // After MaxElapsedTime the ExponentialBackOff stops. + // It never stops if MaxElapsedTime == 0. + MaxElapsedTime time.Duration + Clock Clock + + currentInterval time.Duration + startTime time.Time +} + +// Clock is an interface that returns current time for BackOff. +type Clock interface { + Now() time.Time +} + +// Default values for ExponentialBackOff. +const ( + DefaultInitialInterval = 500 * time.Millisecond + DefaultRandomizationFactor = 0.5 + DefaultMultiplier = 1.5 + DefaultMaxInterval = 60 * time.Second + DefaultMaxElapsedTime = 15 * time.Minute +) + +// NewExponentialBackOff creates an instance of ExponentialBackOff using default values. +func NewExponentialBackOff() *ExponentialBackOff { + b := &ExponentialBackOff{ + InitialInterval: DefaultInitialInterval, + RandomizationFactor: DefaultRandomizationFactor, + Multiplier: DefaultMultiplier, + MaxInterval: DefaultMaxInterval, + MaxElapsedTime: DefaultMaxElapsedTime, + Clock: SystemClock, + } + b.Reset() + return b +} + +type systemClock struct{} + +func (t systemClock) Now() time.Time { + return time.Now() +} + +// SystemClock implements Clock interface that uses time.Now(). +var SystemClock = systemClock{} + +// Reset the interval back to the initial retry interval and restarts the timer. +func (b *ExponentialBackOff) Reset() { + b.currentInterval = b.InitialInterval + b.startTime = b.Clock.Now() +} + +// NextBackOff calculates the next backoff interval using the formula: +// Randomized interval = RetryInterval +/- (RandomizationFactor * RetryInterval) +func (b *ExponentialBackOff) NextBackOff() time.Duration { + // Make sure we have not gone over the maximum elapsed time. + if b.MaxElapsedTime != 0 && b.GetElapsedTime() > b.MaxElapsedTime { + return Stop + } + defer b.incrementCurrentInterval() + return getRandomValueFromInterval(b.RandomizationFactor, rand.Float64(), b.currentInterval) +} + +// GetElapsedTime returns the elapsed time since an ExponentialBackOff instance +// is created and is reset when Reset() is called. +// +// The elapsed time is computed using time.Now().UnixNano(). +func (b *ExponentialBackOff) GetElapsedTime() time.Duration { + return b.Clock.Now().Sub(b.startTime) +} + +// Increments the current interval by multiplying it with the multiplier. +func (b *ExponentialBackOff) incrementCurrentInterval() { + // Check for overflow, if overflow is detected set the current interval to the max interval. + if float64(b.currentInterval) >= float64(b.MaxInterval)/b.Multiplier { + b.currentInterval = b.MaxInterval + } else { + b.currentInterval = time.Duration(float64(b.currentInterval) * b.Multiplier) + } +} + +// Returns a random value from the following interval: +// [randomizationFactor * currentInterval, randomizationFactor * currentInterval]. +func getRandomValueFromInterval(randomizationFactor, random float64, currentInterval time.Duration) time.Duration { + var delta = randomizationFactor * float64(currentInterval) + var minInterval = float64(currentInterval) - delta + var maxInterval = float64(currentInterval) + delta + + // Get a random value from the range [minInterval, maxInterval]. + // The formula used below has a +1 because if the minInterval is 1 and the maxInterval is 3 then + // we want a 33% chance for selecting either 1, 2 or 3. + return time.Duration(minInterval + (random * (maxInterval - minInterval + 1))) +} diff --git a/src/alertmanager/vendor/github.com/cenkalti/backoff/retry.go b/src/alertmanager/vendor/github.com/cenkalti/backoff/retry.go new file mode 100644 index 0000000..f01f2bb --- /dev/null +++ b/src/alertmanager/vendor/github.com/cenkalti/backoff/retry.go @@ -0,0 +1,46 @@ +package backoff + +import "time" + +// An Operation is executing by Retry() or RetryNotify(). +// The operation will be retried using a backoff policy if it returns an error. +type Operation func() error + +// Notify is a notify-on-error function. It receives an operation error and +// backoff delay if the operation failed (with an error). +// +// NOTE that if the backoff policy stated to stop retrying, +// the notify function isn't called. +type Notify func(error, time.Duration) + +// Retry the function f until it does not return error or BackOff stops. +// f is guaranteed to be run at least once. +// It is the caller's responsibility to reset b after Retry returns. +// +// Retry sleeps the goroutine for the duration returned by BackOff after a +// failed operation returns. +func Retry(o Operation, b BackOff) error { return RetryNotify(o, b, nil) } + +// RetryNotify calls notify function with the error and wait duration +// for each failed attempt before sleep. +func RetryNotify(operation Operation, b BackOff, notify Notify) error { + var err error + var next time.Duration + + b.Reset() + for { + if err = operation(); err == nil { + return nil + } + + if next = b.NextBackOff(); next == Stop { + return err + } + + if notify != nil { + notify(err, next) + } + + time.Sleep(next) + } +} diff --git a/src/alertmanager/vendor/github.com/cenkalti/backoff/ticker.go b/src/alertmanager/vendor/github.com/cenkalti/backoff/ticker.go new file mode 100644 index 0000000..7a5ff4e --- /dev/null +++ b/src/alertmanager/vendor/github.com/cenkalti/backoff/ticker.go @@ -0,0 +1,79 @@ +package backoff + +import ( + "runtime" + "sync" + "time" +) + +// Ticker holds a channel that delivers `ticks' of a clock at times reported by a BackOff. +// +// Ticks will continue to arrive when the previous operation is still running, +// so operations that take a while to fail could run in quick succession. +type Ticker struct { + C <-chan time.Time + c chan time.Time + b BackOff + stop chan struct{} + stopOnce sync.Once +} + +// NewTicker returns a new Ticker containing a channel that will send the time at times +// specified by the BackOff argument. Ticker is guaranteed to tick at least once. +// The channel is closed when Stop method is called or BackOff stops. +func NewTicker(b BackOff) *Ticker { + c := make(chan time.Time) + t := &Ticker{ + C: c, + c: c, + b: b, + stop: make(chan struct{}), + } + go t.run() + runtime.SetFinalizer(t, (*Ticker).Stop) + return t +} + +// Stop turns off a ticker. After Stop, no more ticks will be sent. +func (t *Ticker) Stop() { + t.stopOnce.Do(func() { close(t.stop) }) +} + +func (t *Ticker) run() { + c := t.c + defer close(c) + t.b.Reset() + + // Ticker is guaranteed to tick at least once. + afterC := t.send(time.Now()) + + for { + if afterC == nil { + return + } + + select { + case tick := <-afterC: + afterC = t.send(tick) + case <-t.stop: + t.c = nil // Prevent future ticks from being sent to the channel. + return + } + } +} + +func (t *Ticker) send(tick time.Time) <-chan time.Time { + select { + case t.c <- tick: + case <-t.stop: + return nil + } + + next := t.b.NextBackOff() + if next == Stop { + t.Stop() + return nil + } + + return time.After(next) +} diff --git a/src/alertmanager/vendor/github.com/cespare/xxhash/LICENSE.txt b/src/alertmanager/vendor/github.com/cespare/xxhash/LICENSE.txt new file mode 100644 index 0000000..24b5306 --- /dev/null +++ b/src/alertmanager/vendor/github.com/cespare/xxhash/LICENSE.txt @@ -0,0 +1,22 @@ +Copyright (c) 2016 Caleb Spare + +MIT License + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/src/alertmanager/vendor/github.com/cespare/xxhash/README.md b/src/alertmanager/vendor/github.com/cespare/xxhash/README.md new file mode 100644 index 0000000..23c3a36 --- /dev/null +++ b/src/alertmanager/vendor/github.com/cespare/xxhash/README.md @@ -0,0 +1,41 @@ +# xxhash + +[![GoDoc](https://godoc.org/github.com/cespare/mph?status.svg)](https://godoc.org/github.com/cespare/xxhash) + +xxhash is a Go implementation of the 64-bit +[xxHash](http://cyan4973.github.io/xxHash/) algorithm, XXH64. This is a +high-quality hashing algorithm that is much faster than anything in the Go +standard library. + +The API is very small, taking its cue from the other hashing packages in the +standard library: + + $ go doc github.com/cespare/xxhash ! + package xxhash // import "github.com/cespare/xxhash" + + Package xxhash implements the 64-bit variant of xxHash (XXH64) as described + at http://cyan4973.github.io/xxHash/. + + func New() hash.Hash64 + func Sum64(b []byte) uint64 + func Sum64String(s string) uint64 + +This implementation provides a fast pure-Go implementation and an even faster +assembly implementation for amd64. + +## Benchmarks + +Here are some quick benchmarks comparing the pure-Go and assembly +implementations of Sum64 against another popular Go XXH64 implementation, +[github.com/OneOfOne/xxhash](https://github.com/OneOfOne/xxhash): + +| input size | OneOfOne | cespare (noasm) | cespare | +| --- | --- | --- | --- | +| 5 B | 438.34 MB/s | 596.40 MB/s | 711.11 MB/s | +| 100 B | 3676.54 MB/s | 4301.40 MB/s | 4598.95 MB/s | +| 4 KB | 8128.64 MB/s | 8840.83 MB/s | 10549.72 MB/s | +| 10 MB | 7335.19 MB/s | 7736.64 MB/s | 9024.04 MB/s | + +## Projects using this package + +- [InfluxDB](https://github.com/influxdata/influxdb) diff --git a/src/alertmanager/vendor/github.com/cespare/xxhash/xxhash.go b/src/alertmanager/vendor/github.com/cespare/xxhash/xxhash.go new file mode 100644 index 0000000..96ca219 --- /dev/null +++ b/src/alertmanager/vendor/github.com/cespare/xxhash/xxhash.go @@ -0,0 +1,207 @@ +// Package xxhash implements the 64-bit variant of xxHash (XXH64) as described +// at http://cyan4973.github.io/xxHash/. +package xxhash + +import ( + "encoding/binary" + "hash" + "reflect" + "unsafe" +) + +const ( + prime1 uint64 = 11400714785074694791 + prime2 uint64 = 14029467366897019727 + prime3 uint64 = 1609587929392839161 + prime4 uint64 = 9650029242287828579 + prime5 uint64 = 2870177450012600261 +) + +// NOTE(caleb): I'm using both consts and vars of the primes. Using consts where +// possible in the Go code is worth a small (but measurable) performance boost +// by avoiding some MOVQs. Vars are needed for the asm and also are useful for +// convenience in the Go code in a few places where we need to intentionally +// avoid constant arithmetic (e.g., v1 := prime1 + prime2 fails because the +// result overflows a uint64). +var ( + prime1v = prime1 + prime2v = prime2 + prime3v = prime3 + prime4v = prime4 + prime5v = prime5 +) + +// Sum64String computes the 64-bit xxHash digest of s. +// It may be faster than Sum64([]byte(s)) by avoiding a copy. +// +// TODO(caleb): Consider removing this if an optimization is ever added to make +// it unnecessary: https://golang.org/issue//2205. +// +// TODO(caleb): We still have a function call; we could instead write Go/asm +// copies of Sum64 for strings to squeeze out a bit more speed. +func Sum64String(s string) uint64 { + var b []byte + sh := (*reflect.StringHeader)(unsafe.Pointer(&s)) + bh := (*reflect.SliceHeader)(unsafe.Pointer(&b)) + bh.Data = uintptr(unsafe.Pointer(sh.Data)) + bh.Len = sh.Len + bh.Cap = sh.Len + return Sum64(b) +} + +type xxh struct { + v1 uint64 + v2 uint64 + v3 uint64 + v4 uint64 + total int + mem [32]byte + n int // how much of mem is used +} + +// New creates a new hash.Hash64 that implements the 64-bit xxHash algorithm. +func New() hash.Hash64 { + var x xxh + x.Reset() + return &x +} + +func (x *xxh) Reset() { + x.n = 0 + x.total = 0 + x.v1 = prime1v + prime2 + x.v2 = prime2 + x.v3 = 0 + x.v4 = -prime1v +} + +func (x *xxh) Size() int { return 8 } +func (x *xxh) BlockSize() int { return 32 } + +// Write adds more data to x. It always returns len(b), nil. +func (x *xxh) Write(b []byte) (n int, err error) { + n = len(b) + x.total += len(b) + + if x.n+len(b) < 32 { + // This new data doesn't even fill the current block. + copy(x.mem[x.n:], b) + x.n += len(b) + return + } + + if x.n > 0 { + // Finish off the partial block. + copy(x.mem[x.n:], b) + x.v1 = round(x.v1, u64(x.mem[0:8])) + x.v2 = round(x.v2, u64(x.mem[8:16])) + x.v3 = round(x.v3, u64(x.mem[16:24])) + x.v4 = round(x.v4, u64(x.mem[24:32])) + b = b[32-x.n:] + x.n = 0 + } + + if len(b) >= 32 { + // One or more full blocks left. + b = writeBlocks(x, b) + } + + // Store any remaining partial block. + copy(x.mem[:], b) + x.n = len(b) + + return +} + +func (x *xxh) Sum(b []byte) []byte { + s := x.Sum64() + return append( + b, + byte(s>>56), + byte(s>>48), + byte(s>>40), + byte(s>>32), + byte(s>>24), + byte(s>>16), + byte(s>>8), + byte(s), + ) +} + +func (x *xxh) Sum64() uint64 { + var h uint64 + + if x.total >= 32 { + v1, v2, v3, v4 := x.v1, x.v2, x.v3, x.v4 + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + } else { + h = x.v3 + prime5 + } + + h += uint64(x.total) + + i, end := 0, x.n + for ; i+8 <= end; i += 8 { + k1 := round(0, u64(x.mem[i:i+8])) + h ^= k1 + h = rol27(h)*prime1 + prime4 + } + if i+4 <= end { + h ^= uint64(u32(x.mem[i:i+4])) * prime1 + h = rol23(h)*prime2 + prime3 + i += 4 + } + for i < end { + h ^= uint64(x.mem[i]) * prime5 + h = rol11(h) * prime1 + i++ + } + + h ^= h >> 33 + h *= prime2 + h ^= h >> 29 + h *= prime3 + h ^= h >> 32 + + return h +} + +func u64(b []byte) uint64 { return binary.LittleEndian.Uint64(b) } +func u32(b []byte) uint32 { return binary.LittleEndian.Uint32(b) } + +func round(acc, input uint64) uint64 { + acc += input * prime2 + acc = rol31(acc) + acc *= prime1 + return acc +} + +func mergeRound(acc, val uint64) uint64 { + val = round(0, val) + acc ^= val + acc = acc*prime1 + prime4 + return acc +} + +// It's important for performance to get the rotates to actually compile to +// ROLQs. gc will do this for us but only if rotate amount is a constant. +// +// TODO(caleb): In Go 1.9 a single function +// rol(x uint64, k uint) uint64 +// should do instead. See https://golang.org/issue/18254. +// +// TODO(caleb): In Go 1.x (1.9?) consider using the new math/bits package to be more +// explicit about things. See https://golang.org/issue/18616. + +func rol1(x uint64) uint64 { return (x << 1) | (x >> (64 - 1)) } +func rol7(x uint64) uint64 { return (x << 7) | (x >> (64 - 7)) } +func rol11(x uint64) uint64 { return (x << 11) | (x >> (64 - 11)) } +func rol12(x uint64) uint64 { return (x << 12) | (x >> (64 - 12)) } +func rol18(x uint64) uint64 { return (x << 18) | (x >> (64 - 18)) } +func rol23(x uint64) uint64 { return (x << 23) | (x >> (64 - 23)) } +func rol27(x uint64) uint64 { return (x << 27) | (x >> (64 - 27)) } +func rol31(x uint64) uint64 { return (x << 31) | (x >> (64 - 31)) } diff --git a/src/alertmanager/vendor/github.com/cespare/xxhash/xxhash_amd64.go b/src/alertmanager/vendor/github.com/cespare/xxhash/xxhash_amd64.go new file mode 100644 index 0000000..fc417c1 --- /dev/null +++ b/src/alertmanager/vendor/github.com/cespare/xxhash/xxhash_amd64.go @@ -0,0 +1,12 @@ +// +build !appengine +// +build gc +// +build !noasm + +package xxhash + +// Sum64 computes the 64-bit xxHash digest of b. +// +//go:noescape +func Sum64(b []byte) uint64 + +func writeBlocks(x *xxh, b []byte) []byte diff --git a/src/alertmanager/vendor/github.com/cespare/xxhash/xxhash_amd64.s b/src/alertmanager/vendor/github.com/cespare/xxhash/xxhash_amd64.s new file mode 100644 index 0000000..37aa8f0 --- /dev/null +++ b/src/alertmanager/vendor/github.com/cespare/xxhash/xxhash_amd64.s @@ -0,0 +1,233 @@ +// +build !appengine +// +build gc +// +build !noasm + +#include "textflag.h" + +// Register allocation: +// AX h +// CX pointer to advance through b +// DX n +// BX loop end +// R8 v1, k1 +// R9 v2 +// R10 v3 +// R11 v4 +// R12 tmp +// R13 prime1v +// R14 prime2v +// R15 prime4v + +// round reads from and advances the buffer pointer in CX. +// It assumes that R13 has prime1v and R14 has prime2v. +#define round(r) \ + MOVQ (CX), R12 \ + ADDQ $8, CX \ + IMULQ R14, R12 \ + ADDQ R12, r \ + ROLQ $31, r \ + IMULQ R13, r + +// mergeRound applies a merge round on the two registers acc and val. +// It assumes that R13 has prime1v, R14 has prime2v, and R15 has prime4v. +#define mergeRound(acc, val) \ + IMULQ R14, val \ + ROLQ $31, val \ + IMULQ R13, val \ + XORQ val, acc \ + IMULQ R13, acc \ + ADDQ R15, acc + +// func Sum64(b []byte) uint64 +TEXT ·Sum64(SB), NOSPLIT, $0-32 + // Load fixed primes. + MOVQ ·prime1v(SB), R13 + MOVQ ·prime2v(SB), R14 + MOVQ ·prime4v(SB), R15 + + // Load slice. + MOVQ b_base+0(FP), CX + MOVQ b_len+8(FP), DX + LEAQ (CX)(DX*1), BX + + // The first loop limit will be len(b)-32. + SUBQ $32, BX + + // Check whether we have at least one block. + CMPQ DX, $32 + JLT noBlocks + + // Set up initial state (v1, v2, v3, v4). + MOVQ R13, R8 + ADDQ R14, R8 + MOVQ R14, R9 + XORQ R10, R10 + XORQ R11, R11 + SUBQ R13, R11 + + // Loop until CX > BX. +blockLoop: + round(R8) + round(R9) + round(R10) + round(R11) + + CMPQ CX, BX + JLE blockLoop + + MOVQ R8, AX + ROLQ $1, AX + MOVQ R9, R12 + ROLQ $7, R12 + ADDQ R12, AX + MOVQ R10, R12 + ROLQ $12, R12 + ADDQ R12, AX + MOVQ R11, R12 + ROLQ $18, R12 + ADDQ R12, AX + + mergeRound(AX, R8) + mergeRound(AX, R9) + mergeRound(AX, R10) + mergeRound(AX, R11) + + JMP afterBlocks + +noBlocks: + MOVQ ·prime5v(SB), AX + +afterBlocks: + ADDQ DX, AX + + // Right now BX has len(b)-32, and we want to loop until CX > len(b)-8. + ADDQ $24, BX + + CMPQ CX, BX + JG fourByte + +wordLoop: + // Calculate k1. + MOVQ (CX), R8 + ADDQ $8, CX + IMULQ R14, R8 + ROLQ $31, R8 + IMULQ R13, R8 + + XORQ R8, AX + ROLQ $27, AX + IMULQ R13, AX + ADDQ R15, AX + + CMPQ CX, BX + JLE wordLoop + +fourByte: + ADDQ $4, BX + CMPQ CX, BX + JG singles + + MOVL (CX), R8 + ADDQ $4, CX + IMULQ R13, R8 + XORQ R8, AX + + ROLQ $23, AX + IMULQ R14, AX + ADDQ ·prime3v(SB), AX + +singles: + ADDQ $4, BX + CMPQ CX, BX + JGE finalize + +singlesLoop: + MOVBQZX (CX), R12 + ADDQ $1, CX + IMULQ ·prime5v(SB), R12 + XORQ R12, AX + + ROLQ $11, AX + IMULQ R13, AX + + CMPQ CX, BX + JL singlesLoop + +finalize: + MOVQ AX, R12 + SHRQ $33, R12 + XORQ R12, AX + IMULQ R14, AX + MOVQ AX, R12 + SHRQ $29, R12 + XORQ R12, AX + IMULQ ·prime3v(SB), AX + MOVQ AX, R12 + SHRQ $32, R12 + XORQ R12, AX + + MOVQ AX, ret+24(FP) + RET + +// writeBlocks uses the same registers as above except that it uses AX to store +// the x pointer. + +// func writeBlocks(x *xxh, b []byte) []byte +TEXT ·writeBlocks(SB), NOSPLIT, $0-56 + // Load fixed primes needed for round. + MOVQ ·prime1v(SB), R13 + MOVQ ·prime2v(SB), R14 + + // Load slice. + MOVQ b_base+8(FP), CX + MOVQ CX, ret_base+32(FP) // initialize return base pointer; see NOTE below + MOVQ b_len+16(FP), DX + LEAQ (CX)(DX*1), BX + SUBQ $32, BX + + // Load vN from x. + MOVQ x+0(FP), AX + MOVQ 0(AX), R8 // v1 + MOVQ 8(AX), R9 // v2 + MOVQ 16(AX), R10 // v3 + MOVQ 24(AX), R11 // v4 + + // We don't need to check the loop condition here; this function is + // always called with at least one block of data to process. +blockLoop: + round(R8) + round(R9) + round(R10) + round(R11) + + CMPQ CX, BX + JLE blockLoop + + // Copy vN back to x. + MOVQ R8, 0(AX) + MOVQ R9, 8(AX) + MOVQ R10, 16(AX) + MOVQ R11, 24(AX) + + // Construct return slice. + // NOTE: It's important that we don't construct a slice that has a base + // pointer off the end of the original slice, as in Go 1.7+ this will + // cause runtime crashes. (See discussion in, for example, + // https://github.com/golang/go/issues/16772.) + // Therefore, we calculate the length/cap first, and if they're zero, we + // keep the old base. This is what the compiler does as well if you + // write code like + // b = b[len(b):] + + // New length is 32 - (CX - BX) -> BX+32 - CX. + ADDQ $32, BX + SUBQ CX, BX + JZ afterSetBase + + MOVQ CX, ret_base+32(FP) + +afterSetBase: + MOVQ BX, ret_len+40(FP) + MOVQ BX, ret_cap+48(FP) // set cap == len + + RET diff --git a/src/alertmanager/vendor/github.com/cespare/xxhash/xxhash_other.go b/src/alertmanager/vendor/github.com/cespare/xxhash/xxhash_other.go new file mode 100644 index 0000000..058c315 --- /dev/null +++ b/src/alertmanager/vendor/github.com/cespare/xxhash/xxhash_other.go @@ -0,0 +1,75 @@ +// +build !amd64 appengine !gc noasm + +package xxhash + +// Sum64 computes the 64-bit xxHash digest of b. +func Sum64(b []byte) uint64 { + // A simpler version would be + // x := New() + // x.Write(b) + // return x.Sum64() + // but this is faster, particularly for small inputs. + + n := len(b) + var h uint64 + + if n >= 32 { + v1 := prime1v + prime2 + v2 := prime2 + v3 := uint64(0) + v4 := -prime1v + for len(b) >= 32 { + v1 = round(v1, u64(b[0:8:len(b)])) + v2 = round(v2, u64(b[8:16:len(b)])) + v3 = round(v3, u64(b[16:24:len(b)])) + v4 = round(v4, u64(b[24:32:len(b)])) + b = b[32:len(b):len(b)] + } + h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4) + h = mergeRound(h, v1) + h = mergeRound(h, v2) + h = mergeRound(h, v3) + h = mergeRound(h, v4) + } else { + h = prime5 + } + + h += uint64(n) + + i, end := 0, len(b) + for ; i+8 <= end; i += 8 { + k1 := round(0, u64(b[i:i+8:len(b)])) + h ^= k1 + h = rol27(h)*prime1 + prime4 + } + if i+4 <= end { + h ^= uint64(u32(b[i:i+4:len(b)])) * prime1 + h = rol23(h)*prime2 + prime3 + i += 4 + } + for ; i < end; i++ { + h ^= uint64(b[i]) * prime5 + h = rol11(h) * prime1 + } + + h ^= h >> 33 + h *= prime2 + h ^= h >> 29 + h *= prime3 + h ^= h >> 32 + + return h +} + +func writeBlocks(x *xxh, b []byte) []byte { + v1, v2, v3, v4 := x.v1, x.v2, x.v3, x.v4 + for len(b) >= 32 { + v1 = round(v1, u64(b[0:8:len(b)])) + v2 = round(v2, u64(b[8:16:len(b)])) + v3 = round(v3, u64(b[16:24:len(b)])) + v4 = round(v4, u64(b[24:32:len(b)])) + b = b[32:len(b):len(b)] + } + x.v1, x.v2, x.v3, x.v4 = v1, v2, v3, v4 + return b +} diff --git a/src/alertmanager/vendor/github.com/davecgh/go-spew/LICENSE b/src/alertmanager/vendor/github.com/davecgh/go-spew/LICENSE new file mode 100644 index 0000000..c836416 --- /dev/null +++ b/src/alertmanager/vendor/github.com/davecgh/go-spew/LICENSE @@ -0,0 +1,15 @@ +ISC License + +Copyright (c) 2012-2016 Dave Collins + +Permission to use, copy, modify, and distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. diff --git a/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/bypass.go b/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/bypass.go new file mode 100644 index 0000000..8a4a658 --- /dev/null +++ b/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/bypass.go @@ -0,0 +1,152 @@ +// Copyright (c) 2015-2016 Dave Collins +// +// Permission to use, copy, modify, and distribute this software for any +// purpose with or without fee is hereby granted, provided that the above +// copyright notice and this permission notice appear in all copies. +// +// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +// NOTE: Due to the following build constraints, this file will only be compiled +// when the code is not running on Google App Engine, compiled by GopherJS, and +// "-tags safe" is not added to the go build command line. The "disableunsafe" +// tag is deprecated and thus should not be used. +// +build !js,!appengine,!safe,!disableunsafe + +package spew + +import ( + "reflect" + "unsafe" +) + +const ( + // UnsafeDisabled is a build-time constant which specifies whether or + // not access to the unsafe package is available. + UnsafeDisabled = false + + // ptrSize is the size of a pointer on the current arch. + ptrSize = unsafe.Sizeof((*byte)(nil)) +) + +var ( + // offsetPtr, offsetScalar, and offsetFlag are the offsets for the + // internal reflect.Value fields. These values are valid before golang + // commit ecccf07e7f9d which changed the format. The are also valid + // after commit 82f48826c6c7 which changed the format again to mirror + // the original format. Code in the init function updates these offsets + // as necessary. + offsetPtr = uintptr(ptrSize) + offsetScalar = uintptr(0) + offsetFlag = uintptr(ptrSize * 2) + + // flagKindWidth and flagKindShift indicate various bits that the + // reflect package uses internally to track kind information. + // + // flagRO indicates whether or not the value field of a reflect.Value is + // read-only. + // + // flagIndir indicates whether the value field of a reflect.Value is + // the actual data or a pointer to the data. + // + // These values are valid before golang commit 90a7c3c86944 which + // changed their positions. Code in the init function updates these + // flags as necessary. + flagKindWidth = uintptr(5) + flagKindShift = uintptr(flagKindWidth - 1) + flagRO = uintptr(1 << 0) + flagIndir = uintptr(1 << 1) +) + +func init() { + // Older versions of reflect.Value stored small integers directly in the + // ptr field (which is named val in the older versions). Versions + // between commits ecccf07e7f9d and 82f48826c6c7 added a new field named + // scalar for this purpose which unfortunately came before the flag + // field, so the offset of the flag field is different for those + // versions. + // + // This code constructs a new reflect.Value from a known small integer + // and checks if the size of the reflect.Value struct indicates it has + // the scalar field. When it does, the offsets are updated accordingly. + vv := reflect.ValueOf(0xf00) + if unsafe.Sizeof(vv) == (ptrSize * 4) { + offsetScalar = ptrSize * 2 + offsetFlag = ptrSize * 3 + } + + // Commit 90a7c3c86944 changed the flag positions such that the low + // order bits are the kind. This code extracts the kind from the flags + // field and ensures it's the correct type. When it's not, the flag + // order has been changed to the newer format, so the flags are updated + // accordingly. + upf := unsafe.Pointer(uintptr(unsafe.Pointer(&vv)) + offsetFlag) + upfv := *(*uintptr)(upf) + flagKindMask := uintptr((1<>flagKindShift != uintptr(reflect.Int) { + flagKindShift = 0 + flagRO = 1 << 5 + flagIndir = 1 << 6 + + // Commit adf9b30e5594 modified the flags to separate the + // flagRO flag into two bits which specifies whether or not the + // field is embedded. This causes flagIndir to move over a bit + // and means that flagRO is the combination of either of the + // original flagRO bit and the new bit. + // + // This code detects the change by extracting what used to be + // the indirect bit to ensure it's set. When it's not, the flag + // order has been changed to the newer format, so the flags are + // updated accordingly. + if upfv&flagIndir == 0 { + flagRO = 3 << 5 + flagIndir = 1 << 7 + } + } +} + +// unsafeReflectValue converts the passed reflect.Value into a one that bypasses +// the typical safety restrictions preventing access to unaddressable and +// unexported data. It works by digging the raw pointer to the underlying +// value out of the protected value and generating a new unprotected (unsafe) +// reflect.Value to it. +// +// This allows us to check for implementations of the Stringer and error +// interfaces to be used for pretty printing ordinarily unaddressable and +// inaccessible values such as unexported struct fields. +func unsafeReflectValue(v reflect.Value) (rv reflect.Value) { + indirects := 1 + vt := v.Type() + upv := unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetPtr) + rvf := *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetFlag)) + if rvf&flagIndir != 0 { + vt = reflect.PtrTo(v.Type()) + indirects++ + } else if offsetScalar != 0 { + // The value is in the scalar field when it's not one of the + // reference types. + switch vt.Kind() { + case reflect.Uintptr: + case reflect.Chan: + case reflect.Func: + case reflect.Map: + case reflect.Ptr: + case reflect.UnsafePointer: + default: + upv = unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + + offsetScalar) + } + } + + pv := reflect.NewAt(vt, upv) + rv = pv + for i := 0; i < indirects; i++ { + rv = rv.Elem() + } + return rv +} diff --git a/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go b/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go new file mode 100644 index 0000000..1fe3cf3 --- /dev/null +++ b/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go @@ -0,0 +1,38 @@ +// Copyright (c) 2015-2016 Dave Collins +// +// Permission to use, copy, modify, and distribute this software for any +// purpose with or without fee is hereby granted, provided that the above +// copyright notice and this permission notice appear in all copies. +// +// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +// NOTE: Due to the following build constraints, this file will only be compiled +// when the code is running on Google App Engine, compiled by GopherJS, or +// "-tags safe" is added to the go build command line. The "disableunsafe" +// tag is deprecated and thus should not be used. +// +build js appengine safe disableunsafe + +package spew + +import "reflect" + +const ( + // UnsafeDisabled is a build-time constant which specifies whether or + // not access to the unsafe package is available. + UnsafeDisabled = true +) + +// unsafeReflectValue typically converts the passed reflect.Value into a one +// that bypasses the typical safety restrictions preventing access to +// unaddressable and unexported data. However, doing this relies on access to +// the unsafe package. This is a stub version which simply returns the passed +// reflect.Value when the unsafe package is not available. +func unsafeReflectValue(v reflect.Value) reflect.Value { + return v +} diff --git a/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/common.go b/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/common.go new file mode 100644 index 0000000..7c519ff --- /dev/null +++ b/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/common.go @@ -0,0 +1,341 @@ +/* + * Copyright (c) 2013-2016 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package spew + +import ( + "bytes" + "fmt" + "io" + "reflect" + "sort" + "strconv" +) + +// Some constants in the form of bytes to avoid string overhead. This mirrors +// the technique used in the fmt package. +var ( + panicBytes = []byte("(PANIC=") + plusBytes = []byte("+") + iBytes = []byte("i") + trueBytes = []byte("true") + falseBytes = []byte("false") + interfaceBytes = []byte("(interface {})") + commaNewlineBytes = []byte(",\n") + newlineBytes = []byte("\n") + openBraceBytes = []byte("{") + openBraceNewlineBytes = []byte("{\n") + closeBraceBytes = []byte("}") + asteriskBytes = []byte("*") + colonBytes = []byte(":") + colonSpaceBytes = []byte(": ") + openParenBytes = []byte("(") + closeParenBytes = []byte(")") + spaceBytes = []byte(" ") + pointerChainBytes = []byte("->") + nilAngleBytes = []byte("") + maxNewlineBytes = []byte("\n") + maxShortBytes = []byte("") + circularBytes = []byte("") + circularShortBytes = []byte("") + invalidAngleBytes = []byte("") + openBracketBytes = []byte("[") + closeBracketBytes = []byte("]") + percentBytes = []byte("%") + precisionBytes = []byte(".") + openAngleBytes = []byte("<") + closeAngleBytes = []byte(">") + openMapBytes = []byte("map[") + closeMapBytes = []byte("]") + lenEqualsBytes = []byte("len=") + capEqualsBytes = []byte("cap=") +) + +// hexDigits is used to map a decimal value to a hex digit. +var hexDigits = "0123456789abcdef" + +// catchPanic handles any panics that might occur during the handleMethods +// calls. +func catchPanic(w io.Writer, v reflect.Value) { + if err := recover(); err != nil { + w.Write(panicBytes) + fmt.Fprintf(w, "%v", err) + w.Write(closeParenBytes) + } +} + +// handleMethods attempts to call the Error and String methods on the underlying +// type the passed reflect.Value represents and outputes the result to Writer w. +// +// It handles panics in any called methods by catching and displaying the error +// as the formatted value. +func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) { + // We need an interface to check if the type implements the error or + // Stringer interface. However, the reflect package won't give us an + // interface on certain things like unexported struct fields in order + // to enforce visibility rules. We use unsafe, when it's available, + // to bypass these restrictions since this package does not mutate the + // values. + if !v.CanInterface() { + if UnsafeDisabled { + return false + } + + v = unsafeReflectValue(v) + } + + // Choose whether or not to do error and Stringer interface lookups against + // the base type or a pointer to the base type depending on settings. + // Technically calling one of these methods with a pointer receiver can + // mutate the value, however, types which choose to satisify an error or + // Stringer interface with a pointer receiver should not be mutating their + // state inside these interface methods. + if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() { + v = unsafeReflectValue(v) + } + if v.CanAddr() { + v = v.Addr() + } + + // Is it an error or Stringer? + switch iface := v.Interface().(type) { + case error: + defer catchPanic(w, v) + if cs.ContinueOnMethod { + w.Write(openParenBytes) + w.Write([]byte(iface.Error())) + w.Write(closeParenBytes) + w.Write(spaceBytes) + return false + } + + w.Write([]byte(iface.Error())) + return true + + case fmt.Stringer: + defer catchPanic(w, v) + if cs.ContinueOnMethod { + w.Write(openParenBytes) + w.Write([]byte(iface.String())) + w.Write(closeParenBytes) + w.Write(spaceBytes) + return false + } + w.Write([]byte(iface.String())) + return true + } + return false +} + +// printBool outputs a boolean value as true or false to Writer w. +func printBool(w io.Writer, val bool) { + if val { + w.Write(trueBytes) + } else { + w.Write(falseBytes) + } +} + +// printInt outputs a signed integer value to Writer w. +func printInt(w io.Writer, val int64, base int) { + w.Write([]byte(strconv.FormatInt(val, base))) +} + +// printUint outputs an unsigned integer value to Writer w. +func printUint(w io.Writer, val uint64, base int) { + w.Write([]byte(strconv.FormatUint(val, base))) +} + +// printFloat outputs a floating point value using the specified precision, +// which is expected to be 32 or 64bit, to Writer w. +func printFloat(w io.Writer, val float64, precision int) { + w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision))) +} + +// printComplex outputs a complex value using the specified float precision +// for the real and imaginary parts to Writer w. +func printComplex(w io.Writer, c complex128, floatPrecision int) { + r := real(c) + w.Write(openParenBytes) + w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision))) + i := imag(c) + if i >= 0 { + w.Write(plusBytes) + } + w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision))) + w.Write(iBytes) + w.Write(closeParenBytes) +} + +// printHexPtr outputs a uintptr formatted as hexidecimal with a leading '0x' +// prefix to Writer w. +func printHexPtr(w io.Writer, p uintptr) { + // Null pointer. + num := uint64(p) + if num == 0 { + w.Write(nilAngleBytes) + return + } + + // Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix + buf := make([]byte, 18) + + // It's simpler to construct the hex string right to left. + base := uint64(16) + i := len(buf) - 1 + for num >= base { + buf[i] = hexDigits[num%base] + num /= base + i-- + } + buf[i] = hexDigits[num] + + // Add '0x' prefix. + i-- + buf[i] = 'x' + i-- + buf[i] = '0' + + // Strip unused leading bytes. + buf = buf[i:] + w.Write(buf) +} + +// valuesSorter implements sort.Interface to allow a slice of reflect.Value +// elements to be sorted. +type valuesSorter struct { + values []reflect.Value + strings []string // either nil or same len and values + cs *ConfigState +} + +// newValuesSorter initializes a valuesSorter instance, which holds a set of +// surrogate keys on which the data should be sorted. It uses flags in +// ConfigState to decide if and how to populate those surrogate keys. +func newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Interface { + vs := &valuesSorter{values: values, cs: cs} + if canSortSimply(vs.values[0].Kind()) { + return vs + } + if !cs.DisableMethods { + vs.strings = make([]string, len(values)) + for i := range vs.values { + b := bytes.Buffer{} + if !handleMethods(cs, &b, vs.values[i]) { + vs.strings = nil + break + } + vs.strings[i] = b.String() + } + } + if vs.strings == nil && cs.SpewKeys { + vs.strings = make([]string, len(values)) + for i := range vs.values { + vs.strings[i] = Sprintf("%#v", vs.values[i].Interface()) + } + } + return vs +} + +// canSortSimply tests whether a reflect.Kind is a primitive that can be sorted +// directly, or whether it should be considered for sorting by surrogate keys +// (if the ConfigState allows it). +func canSortSimply(kind reflect.Kind) bool { + // This switch parallels valueSortLess, except for the default case. + switch kind { + case reflect.Bool: + return true + case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: + return true + case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: + return true + case reflect.Float32, reflect.Float64: + return true + case reflect.String: + return true + case reflect.Uintptr: + return true + case reflect.Array: + return true + } + return false +} + +// Len returns the number of values in the slice. It is part of the +// sort.Interface implementation. +func (s *valuesSorter) Len() int { + return len(s.values) +} + +// Swap swaps the values at the passed indices. It is part of the +// sort.Interface implementation. +func (s *valuesSorter) Swap(i, j int) { + s.values[i], s.values[j] = s.values[j], s.values[i] + if s.strings != nil { + s.strings[i], s.strings[j] = s.strings[j], s.strings[i] + } +} + +// valueSortLess returns whether the first value should sort before the second +// value. It is used by valueSorter.Less as part of the sort.Interface +// implementation. +func valueSortLess(a, b reflect.Value) bool { + switch a.Kind() { + case reflect.Bool: + return !a.Bool() && b.Bool() + case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: + return a.Int() < b.Int() + case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: + return a.Uint() < b.Uint() + case reflect.Float32, reflect.Float64: + return a.Float() < b.Float() + case reflect.String: + return a.String() < b.String() + case reflect.Uintptr: + return a.Uint() < b.Uint() + case reflect.Array: + // Compare the contents of both arrays. + l := a.Len() + for i := 0; i < l; i++ { + av := a.Index(i) + bv := b.Index(i) + if av.Interface() == bv.Interface() { + continue + } + return valueSortLess(av, bv) + } + } + return a.String() < b.String() +} + +// Less returns whether the value at index i should sort before the +// value at index j. It is part of the sort.Interface implementation. +func (s *valuesSorter) Less(i, j int) bool { + if s.strings == nil { + return valueSortLess(s.values[i], s.values[j]) + } + return s.strings[i] < s.strings[j] +} + +// sortValues is a sort function that handles both native types and any type that +// can be converted to error or Stringer. Other inputs are sorted according to +// their Value.String() value to ensure display stability. +func sortValues(values []reflect.Value, cs *ConfigState) { + if len(values) == 0 { + return + } + sort.Sort(newValuesSorter(values, cs)) +} diff --git a/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/config.go b/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/config.go new file mode 100644 index 0000000..2e3d22f --- /dev/null +++ b/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/config.go @@ -0,0 +1,306 @@ +/* + * Copyright (c) 2013-2016 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package spew + +import ( + "bytes" + "fmt" + "io" + "os" +) + +// ConfigState houses the configuration options used by spew to format and +// display values. There is a global instance, Config, that is used to control +// all top-level Formatter and Dump functionality. Each ConfigState instance +// provides methods equivalent to the top-level functions. +// +// The zero value for ConfigState provides no indentation. You would typically +// want to set it to a space or a tab. +// +// Alternatively, you can use NewDefaultConfig to get a ConfigState instance +// with default settings. See the documentation of NewDefaultConfig for default +// values. +type ConfigState struct { + // Indent specifies the string to use for each indentation level. The + // global config instance that all top-level functions use set this to a + // single space by default. If you would like more indentation, you might + // set this to a tab with "\t" or perhaps two spaces with " ". + Indent string + + // MaxDepth controls the maximum number of levels to descend into nested + // data structures. The default, 0, means there is no limit. + // + // NOTE: Circular data structures are properly detected, so it is not + // necessary to set this value unless you specifically want to limit deeply + // nested data structures. + MaxDepth int + + // DisableMethods specifies whether or not error and Stringer interfaces are + // invoked for types that implement them. + DisableMethods bool + + // DisablePointerMethods specifies whether or not to check for and invoke + // error and Stringer interfaces on types which only accept a pointer + // receiver when the current type is not a pointer. + // + // NOTE: This might be an unsafe action since calling one of these methods + // with a pointer receiver could technically mutate the value, however, + // in practice, types which choose to satisify an error or Stringer + // interface with a pointer receiver should not be mutating their state + // inside these interface methods. As a result, this option relies on + // access to the unsafe package, so it will not have any effect when + // running in environments without access to the unsafe package such as + // Google App Engine or with the "safe" build tag specified. + DisablePointerMethods bool + + // DisablePointerAddresses specifies whether to disable the printing of + // pointer addresses. This is useful when diffing data structures in tests. + DisablePointerAddresses bool + + // DisableCapacities specifies whether to disable the printing of capacities + // for arrays, slices, maps and channels. This is useful when diffing + // data structures in tests. + DisableCapacities bool + + // ContinueOnMethod specifies whether or not recursion should continue once + // a custom error or Stringer interface is invoked. The default, false, + // means it will print the results of invoking the custom error or Stringer + // interface and return immediately instead of continuing to recurse into + // the internals of the data type. + // + // NOTE: This flag does not have any effect if method invocation is disabled + // via the DisableMethods or DisablePointerMethods options. + ContinueOnMethod bool + + // SortKeys specifies map keys should be sorted before being printed. Use + // this to have a more deterministic, diffable output. Note that only + // native types (bool, int, uint, floats, uintptr and string) and types + // that support the error or Stringer interfaces (if methods are + // enabled) are supported, with other types sorted according to the + // reflect.Value.String() output which guarantees display stability. + SortKeys bool + + // SpewKeys specifies that, as a last resort attempt, map keys should + // be spewed to strings and sorted by those strings. This is only + // considered if SortKeys is true. + SpewKeys bool +} + +// Config is the active configuration of the top-level functions. +// The configuration can be changed by modifying the contents of spew.Config. +var Config = ConfigState{Indent: " "} + +// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the formatted string as a value that satisfies error. See NewFormatter +// for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Errorf(format, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Errorf(format string, a ...interface{}) (err error) { + return fmt.Errorf(format, c.convertArgs(a)...) +} + +// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprint(w, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Fprint(w io.Writer, a ...interface{}) (n int, err error) { + return fmt.Fprint(w, c.convertArgs(a)...) +} + +// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprintf(w, format, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) { + return fmt.Fprintf(w, format, c.convertArgs(a)...) +} + +// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it +// passed with a Formatter interface returned by c.NewFormatter. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprintln(w, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Fprintln(w io.Writer, a ...interface{}) (n int, err error) { + return fmt.Fprintln(w, c.convertArgs(a)...) +} + +// Print is a wrapper for fmt.Print that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Print(c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Print(a ...interface{}) (n int, err error) { + return fmt.Print(c.convertArgs(a)...) +} + +// Printf is a wrapper for fmt.Printf that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Printf(format, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Printf(format string, a ...interface{}) (n int, err error) { + return fmt.Printf(format, c.convertArgs(a)...) +} + +// Println is a wrapper for fmt.Println that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Println(c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Println(a ...interface{}) (n int, err error) { + return fmt.Println(c.convertArgs(a)...) +} + +// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprint(c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Sprint(a ...interface{}) string { + return fmt.Sprint(c.convertArgs(a)...) +} + +// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprintf(format, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Sprintf(format string, a ...interface{}) string { + return fmt.Sprintf(format, c.convertArgs(a)...) +} + +// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it +// were passed with a Formatter interface returned by c.NewFormatter. It +// returns the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprintln(c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Sprintln(a ...interface{}) string { + return fmt.Sprintln(c.convertArgs(a)...) +} + +/* +NewFormatter returns a custom formatter that satisfies the fmt.Formatter +interface. As a result, it integrates cleanly with standard fmt package +printing functions. The formatter is useful for inline printing of smaller data +types similar to the standard %v format specifier. + +The custom formatter only responds to the %v (most compact), %+v (adds pointer +addresses), %#v (adds types), and %#+v (adds types and pointer addresses) verb +combinations. Any other verbs such as %x and %q will be sent to the the +standard fmt package for formatting. In addition, the custom formatter ignores +the width and precision arguments (however they will still work on the format +specifiers not handled by the custom formatter). + +Typically this function shouldn't be called directly. It is much easier to make +use of the custom formatter by calling one of the convenience functions such as +c.Printf, c.Println, or c.Printf. +*/ +func (c *ConfigState) NewFormatter(v interface{}) fmt.Formatter { + return newFormatter(c, v) +} + +// Fdump formats and displays the passed arguments to io.Writer w. It formats +// exactly the same as Dump. +func (c *ConfigState) Fdump(w io.Writer, a ...interface{}) { + fdump(c, w, a...) +} + +/* +Dump displays the passed parameters to standard out with newlines, customizable +indentation, and additional debug information such as complete types and all +pointer addresses used to indirect to the final value. It provides the +following features over the built-in printing facilities provided by the fmt +package: + + * Pointers are dereferenced and followed + * Circular data structures are detected and handled properly + * Custom Stringer/error interfaces are optionally invoked, including + on unexported types + * Custom types which only implement the Stringer/error interfaces via + a pointer receiver are optionally invoked when passing non-pointer + variables + * Byte arrays and slices are dumped like the hexdump -C command which + includes offsets, byte values in hex, and ASCII output + +The configuration options are controlled by modifying the public members +of c. See ConfigState for options documentation. + +See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to +get the formatted result as a string. +*/ +func (c *ConfigState) Dump(a ...interface{}) { + fdump(c, os.Stdout, a...) +} + +// Sdump returns a string with the passed arguments formatted exactly the same +// as Dump. +func (c *ConfigState) Sdump(a ...interface{}) string { + var buf bytes.Buffer + fdump(c, &buf, a...) + return buf.String() +} + +// convertArgs accepts a slice of arguments and returns a slice of the same +// length with each argument converted to a spew Formatter interface using +// the ConfigState associated with s. +func (c *ConfigState) convertArgs(args []interface{}) (formatters []interface{}) { + formatters = make([]interface{}, len(args)) + for index, arg := range args { + formatters[index] = newFormatter(c, arg) + } + return formatters +} + +// NewDefaultConfig returns a ConfigState with the following default settings. +// +// Indent: " " +// MaxDepth: 0 +// DisableMethods: false +// DisablePointerMethods: false +// ContinueOnMethod: false +// SortKeys: false +func NewDefaultConfig() *ConfigState { + return &ConfigState{Indent: " "} +} diff --git a/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/doc.go b/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/doc.go new file mode 100644 index 0000000..aacaac6 --- /dev/null +++ b/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/doc.go @@ -0,0 +1,211 @@ +/* + * Copyright (c) 2013-2016 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* +Package spew implements a deep pretty printer for Go data structures to aid in +debugging. + +A quick overview of the additional features spew provides over the built-in +printing facilities for Go data types are as follows: + + * Pointers are dereferenced and followed + * Circular data structures are detected and handled properly + * Custom Stringer/error interfaces are optionally invoked, including + on unexported types + * Custom types which only implement the Stringer/error interfaces via + a pointer receiver are optionally invoked when passing non-pointer + variables + * Byte arrays and slices are dumped like the hexdump -C command which + includes offsets, byte values in hex, and ASCII output (only when using + Dump style) + +There are two different approaches spew allows for dumping Go data structures: + + * Dump style which prints with newlines, customizable indentation, + and additional debug information such as types and all pointer addresses + used to indirect to the final value + * A custom Formatter interface that integrates cleanly with the standard fmt + package and replaces %v, %+v, %#v, and %#+v to provide inline printing + similar to the default %v while providing the additional functionality + outlined above and passing unsupported format verbs such as %x and %q + along to fmt + +Quick Start + +This section demonstrates how to quickly get started with spew. See the +sections below for further details on formatting and configuration options. + +To dump a variable with full newlines, indentation, type, and pointer +information use Dump, Fdump, or Sdump: + spew.Dump(myVar1, myVar2, ...) + spew.Fdump(someWriter, myVar1, myVar2, ...) + str := spew.Sdump(myVar1, myVar2, ...) + +Alternatively, if you would prefer to use format strings with a compacted inline +printing style, use the convenience wrappers Printf, Fprintf, etc with +%v (most compact), %+v (adds pointer addresses), %#v (adds types), or +%#+v (adds types and pointer addresses): + spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2) + spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) + spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2) + spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) + +Configuration Options + +Configuration of spew is handled by fields in the ConfigState type. For +convenience, all of the top-level functions use a global state available +via the spew.Config global. + +It is also possible to create a ConfigState instance that provides methods +equivalent to the top-level functions. This allows concurrent configuration +options. See the ConfigState documentation for more details. + +The following configuration options are available: + * Indent + String to use for each indentation level for Dump functions. + It is a single space by default. A popular alternative is "\t". + + * MaxDepth + Maximum number of levels to descend into nested data structures. + There is no limit by default. + + * DisableMethods + Disables invocation of error and Stringer interface methods. + Method invocation is enabled by default. + + * DisablePointerMethods + Disables invocation of error and Stringer interface methods on types + which only accept pointer receivers from non-pointer variables. + Pointer method invocation is enabled by default. + + * DisablePointerAddresses + DisablePointerAddresses specifies whether to disable the printing of + pointer addresses. This is useful when diffing data structures in tests. + + * DisableCapacities + DisableCapacities specifies whether to disable the printing of + capacities for arrays, slices, maps and channels. This is useful when + diffing data structures in tests. + + * ContinueOnMethod + Enables recursion into types after invoking error and Stringer interface + methods. Recursion after method invocation is disabled by default. + + * SortKeys + Specifies map keys should be sorted before being printed. Use + this to have a more deterministic, diffable output. Note that + only native types (bool, int, uint, floats, uintptr and string) + and types which implement error or Stringer interfaces are + supported with other types sorted according to the + reflect.Value.String() output which guarantees display + stability. Natural map order is used by default. + + * SpewKeys + Specifies that, as a last resort attempt, map keys should be + spewed to strings and sorted by those strings. This is only + considered if SortKeys is true. + +Dump Usage + +Simply call spew.Dump with a list of variables you want to dump: + + spew.Dump(myVar1, myVar2, ...) + +You may also call spew.Fdump if you would prefer to output to an arbitrary +io.Writer. For example, to dump to standard error: + + spew.Fdump(os.Stderr, myVar1, myVar2, ...) + +A third option is to call spew.Sdump to get the formatted output as a string: + + str := spew.Sdump(myVar1, myVar2, ...) + +Sample Dump Output + +See the Dump example for details on the setup of the types and variables being +shown here. + + (main.Foo) { + unexportedField: (*main.Bar)(0xf84002e210)({ + flag: (main.Flag) flagTwo, + data: (uintptr) + }), + ExportedField: (map[interface {}]interface {}) (len=1) { + (string) (len=3) "one": (bool) true + } + } + +Byte (and uint8) arrays and slices are displayed uniquely like the hexdump -C +command as shown. + ([]uint8) (len=32 cap=32) { + 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 |............... | + 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30 |!"#$%&'()*+,-./0| + 00000020 31 32 |12| + } + +Custom Formatter + +Spew provides a custom formatter that implements the fmt.Formatter interface +so that it integrates cleanly with standard fmt package printing functions. The +formatter is useful for inline printing of smaller data types similar to the +standard %v format specifier. + +The custom formatter only responds to the %v (most compact), %+v (adds pointer +addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb +combinations. Any other verbs such as %x and %q will be sent to the the +standard fmt package for formatting. In addition, the custom formatter ignores +the width and precision arguments (however they will still work on the format +specifiers not handled by the custom formatter). + +Custom Formatter Usage + +The simplest way to make use of the spew custom formatter is to call one of the +convenience functions such as spew.Printf, spew.Println, or spew.Printf. The +functions have syntax you are most likely already familiar with: + + spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2) + spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) + spew.Println(myVar, myVar2) + spew.Fprintf(os.Stderr, "myVar1: %v -- myVar2: %+v", myVar1, myVar2) + spew.Fprintf(os.Stderr, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) + +See the Index for the full list convenience functions. + +Sample Formatter Output + +Double pointer to a uint8: + %v: <**>5 + %+v: <**>(0xf8400420d0->0xf8400420c8)5 + %#v: (**uint8)5 + %#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5 + +Pointer to circular struct with a uint8 field and a pointer to itself: + %v: <*>{1 <*>} + %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)} + %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)} + %#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)} + +See the Printf example for details on the setup of variables being shown +here. + +Errors + +Since it is possible for custom Stringer/error interfaces to panic, spew +detects them and handles them internally by printing the panic information +inline with the output. Since spew is intended to provide deep pretty printing +capabilities on structures, it intentionally does not return any errors. +*/ +package spew diff --git a/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/dump.go b/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/dump.go new file mode 100644 index 0000000..df1d582 --- /dev/null +++ b/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/dump.go @@ -0,0 +1,509 @@ +/* + * Copyright (c) 2013-2016 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package spew + +import ( + "bytes" + "encoding/hex" + "fmt" + "io" + "os" + "reflect" + "regexp" + "strconv" + "strings" +) + +var ( + // uint8Type is a reflect.Type representing a uint8. It is used to + // convert cgo types to uint8 slices for hexdumping. + uint8Type = reflect.TypeOf(uint8(0)) + + // cCharRE is a regular expression that matches a cgo char. + // It is used to detect character arrays to hexdump them. + cCharRE = regexp.MustCompile("^.*\\._Ctype_char$") + + // cUnsignedCharRE is a regular expression that matches a cgo unsigned + // char. It is used to detect unsigned character arrays to hexdump + // them. + cUnsignedCharRE = regexp.MustCompile("^.*\\._Ctype_unsignedchar$") + + // cUint8tCharRE is a regular expression that matches a cgo uint8_t. + // It is used to detect uint8_t arrays to hexdump them. + cUint8tCharRE = regexp.MustCompile("^.*\\._Ctype_uint8_t$") +) + +// dumpState contains information about the state of a dump operation. +type dumpState struct { + w io.Writer + depth int + pointers map[uintptr]int + ignoreNextType bool + ignoreNextIndent bool + cs *ConfigState +} + +// indent performs indentation according to the depth level and cs.Indent +// option. +func (d *dumpState) indent() { + if d.ignoreNextIndent { + d.ignoreNextIndent = false + return + } + d.w.Write(bytes.Repeat([]byte(d.cs.Indent), d.depth)) +} + +// unpackValue returns values inside of non-nil interfaces when possible. +// This is useful for data types like structs, arrays, slices, and maps which +// can contain varying types packed inside an interface. +func (d *dumpState) unpackValue(v reflect.Value) reflect.Value { + if v.Kind() == reflect.Interface && !v.IsNil() { + v = v.Elem() + } + return v +} + +// dumpPtr handles formatting of pointers by indirecting them as necessary. +func (d *dumpState) dumpPtr(v reflect.Value) { + // Remove pointers at or below the current depth from map used to detect + // circular refs. + for k, depth := range d.pointers { + if depth >= d.depth { + delete(d.pointers, k) + } + } + + // Keep list of all dereferenced pointers to show later. + pointerChain := make([]uintptr, 0) + + // Figure out how many levels of indirection there are by dereferencing + // pointers and unpacking interfaces down the chain while detecting circular + // references. + nilFound := false + cycleFound := false + indirects := 0 + ve := v + for ve.Kind() == reflect.Ptr { + if ve.IsNil() { + nilFound = true + break + } + indirects++ + addr := ve.Pointer() + pointerChain = append(pointerChain, addr) + if pd, ok := d.pointers[addr]; ok && pd < d.depth { + cycleFound = true + indirects-- + break + } + d.pointers[addr] = d.depth + + ve = ve.Elem() + if ve.Kind() == reflect.Interface { + if ve.IsNil() { + nilFound = true + break + } + ve = ve.Elem() + } + } + + // Display type information. + d.w.Write(openParenBytes) + d.w.Write(bytes.Repeat(asteriskBytes, indirects)) + d.w.Write([]byte(ve.Type().String())) + d.w.Write(closeParenBytes) + + // Display pointer information. + if !d.cs.DisablePointerAddresses && len(pointerChain) > 0 { + d.w.Write(openParenBytes) + for i, addr := range pointerChain { + if i > 0 { + d.w.Write(pointerChainBytes) + } + printHexPtr(d.w, addr) + } + d.w.Write(closeParenBytes) + } + + // Display dereferenced value. + d.w.Write(openParenBytes) + switch { + case nilFound == true: + d.w.Write(nilAngleBytes) + + case cycleFound == true: + d.w.Write(circularBytes) + + default: + d.ignoreNextType = true + d.dump(ve) + } + d.w.Write(closeParenBytes) +} + +// dumpSlice handles formatting of arrays and slices. Byte (uint8 under +// reflection) arrays and slices are dumped in hexdump -C fashion. +func (d *dumpState) dumpSlice(v reflect.Value) { + // Determine whether this type should be hex dumped or not. Also, + // for types which should be hexdumped, try to use the underlying data + // first, then fall back to trying to convert them to a uint8 slice. + var buf []uint8 + doConvert := false + doHexDump := false + numEntries := v.Len() + if numEntries > 0 { + vt := v.Index(0).Type() + vts := vt.String() + switch { + // C types that need to be converted. + case cCharRE.MatchString(vts): + fallthrough + case cUnsignedCharRE.MatchString(vts): + fallthrough + case cUint8tCharRE.MatchString(vts): + doConvert = true + + // Try to use existing uint8 slices and fall back to converting + // and copying if that fails. + case vt.Kind() == reflect.Uint8: + // We need an addressable interface to convert the type + // to a byte slice. However, the reflect package won't + // give us an interface on certain things like + // unexported struct fields in order to enforce + // visibility rules. We use unsafe, when available, to + // bypass these restrictions since this package does not + // mutate the values. + vs := v + if !vs.CanInterface() || !vs.CanAddr() { + vs = unsafeReflectValue(vs) + } + if !UnsafeDisabled { + vs = vs.Slice(0, numEntries) + + // Use the existing uint8 slice if it can be + // type asserted. + iface := vs.Interface() + if slice, ok := iface.([]uint8); ok { + buf = slice + doHexDump = true + break + } + } + + // The underlying data needs to be converted if it can't + // be type asserted to a uint8 slice. + doConvert = true + } + + // Copy and convert the underlying type if needed. + if doConvert && vt.ConvertibleTo(uint8Type) { + // Convert and copy each element into a uint8 byte + // slice. + buf = make([]uint8, numEntries) + for i := 0; i < numEntries; i++ { + vv := v.Index(i) + buf[i] = uint8(vv.Convert(uint8Type).Uint()) + } + doHexDump = true + } + } + + // Hexdump the entire slice as needed. + if doHexDump { + indent := strings.Repeat(d.cs.Indent, d.depth) + str := indent + hex.Dump(buf) + str = strings.Replace(str, "\n", "\n"+indent, -1) + str = strings.TrimRight(str, d.cs.Indent) + d.w.Write([]byte(str)) + return + } + + // Recursively call dump for each item. + for i := 0; i < numEntries; i++ { + d.dump(d.unpackValue(v.Index(i))) + if i < (numEntries - 1) { + d.w.Write(commaNewlineBytes) + } else { + d.w.Write(newlineBytes) + } + } +} + +// dump is the main workhorse for dumping a value. It uses the passed reflect +// value to figure out what kind of object we are dealing with and formats it +// appropriately. It is a recursive function, however circular data structures +// are detected and handled properly. +func (d *dumpState) dump(v reflect.Value) { + // Handle invalid reflect values immediately. + kind := v.Kind() + if kind == reflect.Invalid { + d.w.Write(invalidAngleBytes) + return + } + + // Handle pointers specially. + if kind == reflect.Ptr { + d.indent() + d.dumpPtr(v) + return + } + + // Print type information unless already handled elsewhere. + if !d.ignoreNextType { + d.indent() + d.w.Write(openParenBytes) + d.w.Write([]byte(v.Type().String())) + d.w.Write(closeParenBytes) + d.w.Write(spaceBytes) + } + d.ignoreNextType = false + + // Display length and capacity if the built-in len and cap functions + // work with the value's kind and the len/cap itself is non-zero. + valueLen, valueCap := 0, 0 + switch v.Kind() { + case reflect.Array, reflect.Slice, reflect.Chan: + valueLen, valueCap = v.Len(), v.Cap() + case reflect.Map, reflect.String: + valueLen = v.Len() + } + if valueLen != 0 || !d.cs.DisableCapacities && valueCap != 0 { + d.w.Write(openParenBytes) + if valueLen != 0 { + d.w.Write(lenEqualsBytes) + printInt(d.w, int64(valueLen), 10) + } + if !d.cs.DisableCapacities && valueCap != 0 { + if valueLen != 0 { + d.w.Write(spaceBytes) + } + d.w.Write(capEqualsBytes) + printInt(d.w, int64(valueCap), 10) + } + d.w.Write(closeParenBytes) + d.w.Write(spaceBytes) + } + + // Call Stringer/error interfaces if they exist and the handle methods flag + // is enabled + if !d.cs.DisableMethods { + if (kind != reflect.Invalid) && (kind != reflect.Interface) { + if handled := handleMethods(d.cs, d.w, v); handled { + return + } + } + } + + switch kind { + case reflect.Invalid: + // Do nothing. We should never get here since invalid has already + // been handled above. + + case reflect.Bool: + printBool(d.w, v.Bool()) + + case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: + printInt(d.w, v.Int(), 10) + + case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: + printUint(d.w, v.Uint(), 10) + + case reflect.Float32: + printFloat(d.w, v.Float(), 32) + + case reflect.Float64: + printFloat(d.w, v.Float(), 64) + + case reflect.Complex64: + printComplex(d.w, v.Complex(), 32) + + case reflect.Complex128: + printComplex(d.w, v.Complex(), 64) + + case reflect.Slice: + if v.IsNil() { + d.w.Write(nilAngleBytes) + break + } + fallthrough + + case reflect.Array: + d.w.Write(openBraceNewlineBytes) + d.depth++ + if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) { + d.indent() + d.w.Write(maxNewlineBytes) + } else { + d.dumpSlice(v) + } + d.depth-- + d.indent() + d.w.Write(closeBraceBytes) + + case reflect.String: + d.w.Write([]byte(strconv.Quote(v.String()))) + + case reflect.Interface: + // The only time we should get here is for nil interfaces due to + // unpackValue calls. + if v.IsNil() { + d.w.Write(nilAngleBytes) + } + + case reflect.Ptr: + // Do nothing. We should never get here since pointers have already + // been handled above. + + case reflect.Map: + // nil maps should be indicated as different than empty maps + if v.IsNil() { + d.w.Write(nilAngleBytes) + break + } + + d.w.Write(openBraceNewlineBytes) + d.depth++ + if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) { + d.indent() + d.w.Write(maxNewlineBytes) + } else { + numEntries := v.Len() + keys := v.MapKeys() + if d.cs.SortKeys { + sortValues(keys, d.cs) + } + for i, key := range keys { + d.dump(d.unpackValue(key)) + d.w.Write(colonSpaceBytes) + d.ignoreNextIndent = true + d.dump(d.unpackValue(v.MapIndex(key))) + if i < (numEntries - 1) { + d.w.Write(commaNewlineBytes) + } else { + d.w.Write(newlineBytes) + } + } + } + d.depth-- + d.indent() + d.w.Write(closeBraceBytes) + + case reflect.Struct: + d.w.Write(openBraceNewlineBytes) + d.depth++ + if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) { + d.indent() + d.w.Write(maxNewlineBytes) + } else { + vt := v.Type() + numFields := v.NumField() + for i := 0; i < numFields; i++ { + d.indent() + vtf := vt.Field(i) + d.w.Write([]byte(vtf.Name)) + d.w.Write(colonSpaceBytes) + d.ignoreNextIndent = true + d.dump(d.unpackValue(v.Field(i))) + if i < (numFields - 1) { + d.w.Write(commaNewlineBytes) + } else { + d.w.Write(newlineBytes) + } + } + } + d.depth-- + d.indent() + d.w.Write(closeBraceBytes) + + case reflect.Uintptr: + printHexPtr(d.w, uintptr(v.Uint())) + + case reflect.UnsafePointer, reflect.Chan, reflect.Func: + printHexPtr(d.w, v.Pointer()) + + // There were not any other types at the time this code was written, but + // fall back to letting the default fmt package handle it in case any new + // types are added. + default: + if v.CanInterface() { + fmt.Fprintf(d.w, "%v", v.Interface()) + } else { + fmt.Fprintf(d.w, "%v", v.String()) + } + } +} + +// fdump is a helper function to consolidate the logic from the various public +// methods which take varying writers and config states. +func fdump(cs *ConfigState, w io.Writer, a ...interface{}) { + for _, arg := range a { + if arg == nil { + w.Write(interfaceBytes) + w.Write(spaceBytes) + w.Write(nilAngleBytes) + w.Write(newlineBytes) + continue + } + + d := dumpState{w: w, cs: cs} + d.pointers = make(map[uintptr]int) + d.dump(reflect.ValueOf(arg)) + d.w.Write(newlineBytes) + } +} + +// Fdump formats and displays the passed arguments to io.Writer w. It formats +// exactly the same as Dump. +func Fdump(w io.Writer, a ...interface{}) { + fdump(&Config, w, a...) +} + +// Sdump returns a string with the passed arguments formatted exactly the same +// as Dump. +func Sdump(a ...interface{}) string { + var buf bytes.Buffer + fdump(&Config, &buf, a...) + return buf.String() +} + +/* +Dump displays the passed parameters to standard out with newlines, customizable +indentation, and additional debug information such as complete types and all +pointer addresses used to indirect to the final value. It provides the +following features over the built-in printing facilities provided by the fmt +package: + + * Pointers are dereferenced and followed + * Circular data structures are detected and handled properly + * Custom Stringer/error interfaces are optionally invoked, including + on unexported types + * Custom types which only implement the Stringer/error interfaces via + a pointer receiver are optionally invoked when passing non-pointer + variables + * Byte arrays and slices are dumped like the hexdump -C command which + includes offsets, byte values in hex, and ASCII output + +The configuration options are controlled by an exported package global, +spew.Config. See ConfigState for options documentation. + +See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to +get the formatted result as a string. +*/ +func Dump(a ...interface{}) { + fdump(&Config, os.Stdout, a...) +} diff --git a/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/format.go b/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/format.go new file mode 100644 index 0000000..c49875b --- /dev/null +++ b/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/format.go @@ -0,0 +1,419 @@ +/* + * Copyright (c) 2013-2016 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package spew + +import ( + "bytes" + "fmt" + "reflect" + "strconv" + "strings" +) + +// supportedFlags is a list of all the character flags supported by fmt package. +const supportedFlags = "0-+# " + +// formatState implements the fmt.Formatter interface and contains information +// about the state of a formatting operation. The NewFormatter function can +// be used to get a new Formatter which can be used directly as arguments +// in standard fmt package printing calls. +type formatState struct { + value interface{} + fs fmt.State + depth int + pointers map[uintptr]int + ignoreNextType bool + cs *ConfigState +} + +// buildDefaultFormat recreates the original format string without precision +// and width information to pass in to fmt.Sprintf in the case of an +// unrecognized type. Unless new types are added to the language, this +// function won't ever be called. +func (f *formatState) buildDefaultFormat() (format string) { + buf := bytes.NewBuffer(percentBytes) + + for _, flag := range supportedFlags { + if f.fs.Flag(int(flag)) { + buf.WriteRune(flag) + } + } + + buf.WriteRune('v') + + format = buf.String() + return format +} + +// constructOrigFormat recreates the original format string including precision +// and width information to pass along to the standard fmt package. This allows +// automatic deferral of all format strings this package doesn't support. +func (f *formatState) constructOrigFormat(verb rune) (format string) { + buf := bytes.NewBuffer(percentBytes) + + for _, flag := range supportedFlags { + if f.fs.Flag(int(flag)) { + buf.WriteRune(flag) + } + } + + if width, ok := f.fs.Width(); ok { + buf.WriteString(strconv.Itoa(width)) + } + + if precision, ok := f.fs.Precision(); ok { + buf.Write(precisionBytes) + buf.WriteString(strconv.Itoa(precision)) + } + + buf.WriteRune(verb) + + format = buf.String() + return format +} + +// unpackValue returns values inside of non-nil interfaces when possible and +// ensures that types for values which have been unpacked from an interface +// are displayed when the show types flag is also set. +// This is useful for data types like structs, arrays, slices, and maps which +// can contain varying types packed inside an interface. +func (f *formatState) unpackValue(v reflect.Value) reflect.Value { + if v.Kind() == reflect.Interface { + f.ignoreNextType = false + if !v.IsNil() { + v = v.Elem() + } + } + return v +} + +// formatPtr handles formatting of pointers by indirecting them as necessary. +func (f *formatState) formatPtr(v reflect.Value) { + // Display nil if top level pointer is nil. + showTypes := f.fs.Flag('#') + if v.IsNil() && (!showTypes || f.ignoreNextType) { + f.fs.Write(nilAngleBytes) + return + } + + // Remove pointers at or below the current depth from map used to detect + // circular refs. + for k, depth := range f.pointers { + if depth >= f.depth { + delete(f.pointers, k) + } + } + + // Keep list of all dereferenced pointers to possibly show later. + pointerChain := make([]uintptr, 0) + + // Figure out how many levels of indirection there are by derferencing + // pointers and unpacking interfaces down the chain while detecting circular + // references. + nilFound := false + cycleFound := false + indirects := 0 + ve := v + for ve.Kind() == reflect.Ptr { + if ve.IsNil() { + nilFound = true + break + } + indirects++ + addr := ve.Pointer() + pointerChain = append(pointerChain, addr) + if pd, ok := f.pointers[addr]; ok && pd < f.depth { + cycleFound = true + indirects-- + break + } + f.pointers[addr] = f.depth + + ve = ve.Elem() + if ve.Kind() == reflect.Interface { + if ve.IsNil() { + nilFound = true + break + } + ve = ve.Elem() + } + } + + // Display type or indirection level depending on flags. + if showTypes && !f.ignoreNextType { + f.fs.Write(openParenBytes) + f.fs.Write(bytes.Repeat(asteriskBytes, indirects)) + f.fs.Write([]byte(ve.Type().String())) + f.fs.Write(closeParenBytes) + } else { + if nilFound || cycleFound { + indirects += strings.Count(ve.Type().String(), "*") + } + f.fs.Write(openAngleBytes) + f.fs.Write([]byte(strings.Repeat("*", indirects))) + f.fs.Write(closeAngleBytes) + } + + // Display pointer information depending on flags. + if f.fs.Flag('+') && (len(pointerChain) > 0) { + f.fs.Write(openParenBytes) + for i, addr := range pointerChain { + if i > 0 { + f.fs.Write(pointerChainBytes) + } + printHexPtr(f.fs, addr) + } + f.fs.Write(closeParenBytes) + } + + // Display dereferenced value. + switch { + case nilFound == true: + f.fs.Write(nilAngleBytes) + + case cycleFound == true: + f.fs.Write(circularShortBytes) + + default: + f.ignoreNextType = true + f.format(ve) + } +} + +// format is the main workhorse for providing the Formatter interface. It +// uses the passed reflect value to figure out what kind of object we are +// dealing with and formats it appropriately. It is a recursive function, +// however circular data structures are detected and handled properly. +func (f *formatState) format(v reflect.Value) { + // Handle invalid reflect values immediately. + kind := v.Kind() + if kind == reflect.Invalid { + f.fs.Write(invalidAngleBytes) + return + } + + // Handle pointers specially. + if kind == reflect.Ptr { + f.formatPtr(v) + return + } + + // Print type information unless already handled elsewhere. + if !f.ignoreNextType && f.fs.Flag('#') { + f.fs.Write(openParenBytes) + f.fs.Write([]byte(v.Type().String())) + f.fs.Write(closeParenBytes) + } + f.ignoreNextType = false + + // Call Stringer/error interfaces if they exist and the handle methods + // flag is enabled. + if !f.cs.DisableMethods { + if (kind != reflect.Invalid) && (kind != reflect.Interface) { + if handled := handleMethods(f.cs, f.fs, v); handled { + return + } + } + } + + switch kind { + case reflect.Invalid: + // Do nothing. We should never get here since invalid has already + // been handled above. + + case reflect.Bool: + printBool(f.fs, v.Bool()) + + case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: + printInt(f.fs, v.Int(), 10) + + case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: + printUint(f.fs, v.Uint(), 10) + + case reflect.Float32: + printFloat(f.fs, v.Float(), 32) + + case reflect.Float64: + printFloat(f.fs, v.Float(), 64) + + case reflect.Complex64: + printComplex(f.fs, v.Complex(), 32) + + case reflect.Complex128: + printComplex(f.fs, v.Complex(), 64) + + case reflect.Slice: + if v.IsNil() { + f.fs.Write(nilAngleBytes) + break + } + fallthrough + + case reflect.Array: + f.fs.Write(openBracketBytes) + f.depth++ + if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) { + f.fs.Write(maxShortBytes) + } else { + numEntries := v.Len() + for i := 0; i < numEntries; i++ { + if i > 0 { + f.fs.Write(spaceBytes) + } + f.ignoreNextType = true + f.format(f.unpackValue(v.Index(i))) + } + } + f.depth-- + f.fs.Write(closeBracketBytes) + + case reflect.String: + f.fs.Write([]byte(v.String())) + + case reflect.Interface: + // The only time we should get here is for nil interfaces due to + // unpackValue calls. + if v.IsNil() { + f.fs.Write(nilAngleBytes) + } + + case reflect.Ptr: + // Do nothing. We should never get here since pointers have already + // been handled above. + + case reflect.Map: + // nil maps should be indicated as different than empty maps + if v.IsNil() { + f.fs.Write(nilAngleBytes) + break + } + + f.fs.Write(openMapBytes) + f.depth++ + if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) { + f.fs.Write(maxShortBytes) + } else { + keys := v.MapKeys() + if f.cs.SortKeys { + sortValues(keys, f.cs) + } + for i, key := range keys { + if i > 0 { + f.fs.Write(spaceBytes) + } + f.ignoreNextType = true + f.format(f.unpackValue(key)) + f.fs.Write(colonBytes) + f.ignoreNextType = true + f.format(f.unpackValue(v.MapIndex(key))) + } + } + f.depth-- + f.fs.Write(closeMapBytes) + + case reflect.Struct: + numFields := v.NumField() + f.fs.Write(openBraceBytes) + f.depth++ + if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) { + f.fs.Write(maxShortBytes) + } else { + vt := v.Type() + for i := 0; i < numFields; i++ { + if i > 0 { + f.fs.Write(spaceBytes) + } + vtf := vt.Field(i) + if f.fs.Flag('+') || f.fs.Flag('#') { + f.fs.Write([]byte(vtf.Name)) + f.fs.Write(colonBytes) + } + f.format(f.unpackValue(v.Field(i))) + } + } + f.depth-- + f.fs.Write(closeBraceBytes) + + case reflect.Uintptr: + printHexPtr(f.fs, uintptr(v.Uint())) + + case reflect.UnsafePointer, reflect.Chan, reflect.Func: + printHexPtr(f.fs, v.Pointer()) + + // There were not any other types at the time this code was written, but + // fall back to letting the default fmt package handle it if any get added. + default: + format := f.buildDefaultFormat() + if v.CanInterface() { + fmt.Fprintf(f.fs, format, v.Interface()) + } else { + fmt.Fprintf(f.fs, format, v.String()) + } + } +} + +// Format satisfies the fmt.Formatter interface. See NewFormatter for usage +// details. +func (f *formatState) Format(fs fmt.State, verb rune) { + f.fs = fs + + // Use standard formatting for verbs that are not v. + if verb != 'v' { + format := f.constructOrigFormat(verb) + fmt.Fprintf(fs, format, f.value) + return + } + + if f.value == nil { + if fs.Flag('#') { + fs.Write(interfaceBytes) + } + fs.Write(nilAngleBytes) + return + } + + f.format(reflect.ValueOf(f.value)) +} + +// newFormatter is a helper function to consolidate the logic from the various +// public methods which take varying config states. +func newFormatter(cs *ConfigState, v interface{}) fmt.Formatter { + fs := &formatState{value: v, cs: cs} + fs.pointers = make(map[uintptr]int) + return fs +} + +/* +NewFormatter returns a custom formatter that satisfies the fmt.Formatter +interface. As a result, it integrates cleanly with standard fmt package +printing functions. The formatter is useful for inline printing of smaller data +types similar to the standard %v format specifier. + +The custom formatter only responds to the %v (most compact), %+v (adds pointer +addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb +combinations. Any other verbs such as %x and %q will be sent to the the +standard fmt package for formatting. In addition, the custom formatter ignores +the width and precision arguments (however they will still work on the format +specifiers not handled by the custom formatter). + +Typically this function shouldn't be called directly. It is much easier to make +use of the custom formatter by calling one of the convenience functions such as +Printf, Println, or Fprintf. +*/ +func NewFormatter(v interface{}) fmt.Formatter { + return newFormatter(&Config, v) +} diff --git a/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/spew.go b/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/spew.go new file mode 100644 index 0000000..32c0e33 --- /dev/null +++ b/src/alertmanager/vendor/github.com/davecgh/go-spew/spew/spew.go @@ -0,0 +1,148 @@ +/* + * Copyright (c) 2013-2016 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package spew + +import ( + "fmt" + "io" +) + +// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the formatted string as a value that satisfies error. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Errorf(format, spew.NewFormatter(a), spew.NewFormatter(b)) +func Errorf(format string, a ...interface{}) (err error) { + return fmt.Errorf(format, convertArgs(a)...) +} + +// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprint(w, spew.NewFormatter(a), spew.NewFormatter(b)) +func Fprint(w io.Writer, a ...interface{}) (n int, err error) { + return fmt.Fprint(w, convertArgs(a)...) +} + +// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprintf(w, format, spew.NewFormatter(a), spew.NewFormatter(b)) +func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) { + return fmt.Fprintf(w, format, convertArgs(a)...) +} + +// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it +// passed with a default Formatter interface returned by NewFormatter. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprintln(w, spew.NewFormatter(a), spew.NewFormatter(b)) +func Fprintln(w io.Writer, a ...interface{}) (n int, err error) { + return fmt.Fprintln(w, convertArgs(a)...) +} + +// Print is a wrapper for fmt.Print that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Print(spew.NewFormatter(a), spew.NewFormatter(b)) +func Print(a ...interface{}) (n int, err error) { + return fmt.Print(convertArgs(a)...) +} + +// Printf is a wrapper for fmt.Printf that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Printf(format, spew.NewFormatter(a), spew.NewFormatter(b)) +func Printf(format string, a ...interface{}) (n int, err error) { + return fmt.Printf(format, convertArgs(a)...) +} + +// Println is a wrapper for fmt.Println that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Println(spew.NewFormatter(a), spew.NewFormatter(b)) +func Println(a ...interface{}) (n int, err error) { + return fmt.Println(convertArgs(a)...) +} + +// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprint(spew.NewFormatter(a), spew.NewFormatter(b)) +func Sprint(a ...interface{}) string { + return fmt.Sprint(convertArgs(a)...) +} + +// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprintf(format, spew.NewFormatter(a), spew.NewFormatter(b)) +func Sprintf(format string, a ...interface{}) string { + return fmt.Sprintf(format, convertArgs(a)...) +} + +// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it +// were passed with a default Formatter interface returned by NewFormatter. It +// returns the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprintln(spew.NewFormatter(a), spew.NewFormatter(b)) +func Sprintln(a ...interface{}) string { + return fmt.Sprintln(convertArgs(a)...) +} + +// convertArgs accepts a slice of arguments and returns a slice of the same +// length with each argument converted to a default spew Formatter interface. +func convertArgs(args []interface{}) (formatters []interface{}) { + formatters = make([]interface{}, len(args)) + for index, arg := range args { + formatters[index] = NewFormatter(arg) + } + return formatters +} diff --git a/src/alertmanager/vendor/github.com/go-kit/kit/LICENSE b/src/alertmanager/vendor/github.com/go-kit/kit/LICENSE new file mode 100644 index 0000000..9d83342 --- /dev/null +++ b/src/alertmanager/vendor/github.com/go-kit/kit/LICENSE @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright (c) 2015 Peter Bourgon + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + diff --git a/src/alertmanager/vendor/github.com/go-kit/kit/log/README.md b/src/alertmanager/vendor/github.com/go-kit/kit/log/README.md new file mode 100644 index 0000000..7222f80 --- /dev/null +++ b/src/alertmanager/vendor/github.com/go-kit/kit/log/README.md @@ -0,0 +1,147 @@ +# package log + +`package log` provides a minimal interface for structured logging in services. +It may be wrapped to encode conventions, enforce type-safety, provide leveled +logging, and so on. It can be used for both typical application log events, +and log-structured data streams. + +## Structured logging + +Structured logging is, basically, conceding to the reality that logs are +_data_, and warrant some level of schematic rigor. Using a stricter, +key/value-oriented message format for our logs, containing contextual and +semantic information, makes it much easier to get insight into the +operational activity of the systems we build. Consequently, `package log` is +of the strong belief that "[the benefits of structured logging outweigh the +minimal effort involved](https://www.thoughtworks.com/radar/techniques/structured-logging)". + +Migrating from unstructured to structured logging is probably a lot easier +than you'd expect. + +```go +// Unstructured +log.Printf("HTTP server listening on %s", addr) + +// Structured +logger.Log("transport", "HTTP", "addr", addr, "msg", "listening") +``` + +## Usage + +### Typical application logging + +```go +w := log.NewSyncWriter(os.Stderr) +logger := log.NewLogfmtLogger(w) +logger.Log("question", "what is the meaning of life?", "answer", 42) + +// Output: +// question="what is the meaning of life?" answer=42 +``` + +### Contextual Loggers + +```go +func main() { + var logger log.Logger + logger = log.NewLogfmtLogger(log.NewSyncWriter(os.Stderr)) + logger = log.With(logger, "instance_id", 123) + + logger.Log("msg", "starting") + NewWorker(log.With(logger, "component", "worker")).Run() + NewSlacker(log.With(logger, "component", "slacker")).Run() +} + +// Output: +// instance_id=123 msg=starting +// instance_id=123 component=worker msg=running +// instance_id=123 component=slacker msg=running +``` + +### Interact with stdlib logger + +Redirect stdlib logger to Go kit logger. + +```go +import ( + "os" + stdlog "log" + kitlog "github.com/go-kit/kit/log" +) + +func main() { + logger := kitlog.NewJSONLogger(kitlog.NewSyncWriter(os.Stdout)) + stdlog.SetOutput(kitlog.NewStdlibAdapter(logger)) + stdlog.Print("I sure like pie") +} + +// Output: +// {"msg":"I sure like pie","ts":"2016/01/01 12:34:56"} +``` + +Or, if, for legacy reasons, you need to pipe all of your logging through the +stdlib log package, you can redirect Go kit logger to the stdlib logger. + +```go +logger := kitlog.NewLogfmtLogger(kitlog.StdlibWriter{}) +logger.Log("legacy", true, "msg", "at least it's something") + +// Output: +// 2016/01/01 12:34:56 legacy=true msg="at least it's something" +``` + +### Timestamps and callers + +```go +var logger log.Logger +logger = log.NewLogfmtLogger(log.NewSyncWriter(os.Stderr)) +logger = log.With(logger, "ts", log.DefaultTimestampUTC, "caller", log.DefaultCaller) + +logger.Log("msg", "hello") + +// Output: +// ts=2016-01-01T12:34:56Z caller=main.go:15 msg=hello +``` + +## Supported output formats + +- [Logfmt](https://brandur.org/logfmt) ([see also](https://blog.codeship.com/logfmt-a-log-format-thats-easy-to-read-and-write)) +- JSON + +## Enhancements + +`package log` is centered on the one-method Logger interface. + +```go +type Logger interface { + Log(keyvals ...interface{}) error +} +``` + +This interface, and its supporting code like is the product of much iteration +and evaluation. For more details on the evolution of the Logger interface, +see [The Hunt for a Logger Interface](http://go-talks.appspot.com/github.com/ChrisHines/talks/structured-logging/structured-logging.slide#1), +a talk by [Chris Hines](https://github.com/ChrisHines). +Also, please see +[#63](https://github.com/go-kit/kit/issues/63), +[#76](https://github.com/go-kit/kit/pull/76), +[#131](https://github.com/go-kit/kit/issues/131), +[#157](https://github.com/go-kit/kit/pull/157), +[#164](https://github.com/go-kit/kit/issues/164), and +[#252](https://github.com/go-kit/kit/pull/252) +to review historical conversations about package log and the Logger interface. + +Value-add packages and suggestions, +like improvements to [the leveled logger](https://godoc.org/github.com/go-kit/kit/log/level), +are of course welcome. Good proposals should + +- Be composable with [contextual loggers](https://godoc.org/github.com/go-kit/kit/log#With), +- Not break the behavior of [log.Caller](https://godoc.org/github.com/go-kit/kit/log#Caller) in any wrapped contextual loggers, and +- Be friendly to packages that accept only an unadorned log.Logger. + +## Benchmarks & comparisons + +There are a few Go logging benchmarks and comparisons that include Go kit's package log. + +- [imkira/go-loggers-bench](https://github.com/imkira/go-loggers-bench) includes kit/log +- [uber-common/zap](https://github.com/uber-common/zap), a zero-alloc logging library, includes a comparison with kit/log diff --git a/src/alertmanager/vendor/github.com/go-kit/kit/log/doc.go b/src/alertmanager/vendor/github.com/go-kit/kit/log/doc.go new file mode 100644 index 0000000..918c0af --- /dev/null +++ b/src/alertmanager/vendor/github.com/go-kit/kit/log/doc.go @@ -0,0 +1,116 @@ +// Package log provides a structured logger. +// +// Structured logging produces logs easily consumed later by humans or +// machines. Humans might be interested in debugging errors, or tracing +// specific requests. Machines might be interested in counting interesting +// events, or aggregating information for off-line processing. In both cases, +// it is important that the log messages are structured and actionable. +// Package log is designed to encourage both of these best practices. +// +// Basic Usage +// +// The fundamental interface is Logger. Loggers create log events from +// key/value data. The Logger interface has a single method, Log, which +// accepts a sequence of alternating key/value pairs, which this package names +// keyvals. +// +// type Logger interface { +// Log(keyvals ...interface{}) error +// } +// +// Here is an example of a function using a Logger to create log events. +// +// func RunTask(task Task, logger log.Logger) string { +// logger.Log("taskID", task.ID, "event", "starting task") +// ... +// logger.Log("taskID", task.ID, "event", "task complete") +// } +// +// The keys in the above example are "taskID" and "event". The values are +// task.ID, "starting task", and "task complete". Every key is followed +// immediately by its value. +// +// Keys are usually plain strings. Values may be any type that has a sensible +// encoding in the chosen log format. With structured logging it is a good +// idea to log simple values without formatting them. This practice allows +// the chosen logger to encode values in the most appropriate way. +// +// Contextual Loggers +// +// A contextual logger stores keyvals that it includes in all log events. +// Building appropriate contextual loggers reduces repetition and aids +// consistency in the resulting log output. With and WithPrefix add context to +// a logger. We can use With to improve the RunTask example. +// +// func RunTask(task Task, logger log.Logger) string { +// logger = log.With(logger, "taskID", task.ID) +// logger.Log("event", "starting task") +// ... +// taskHelper(task.Cmd, logger) +// ... +// logger.Log("event", "task complete") +// } +// +// The improved version emits the same log events as the original for the +// first and last calls to Log. Passing the contextual logger to taskHelper +// enables each log event created by taskHelper to include the task.ID even +// though taskHelper does not have access to that value. Using contextual +// loggers this way simplifies producing log output that enables tracing the +// life cycle of individual tasks. (See the Contextual example for the full +// code of the above snippet.) +// +// Dynamic Contextual Values +// +// A Valuer function stored in a contextual logger generates a new value each +// time an event is logged. The Valuer example demonstrates how this feature +// works. +// +// Valuers provide the basis for consistently logging timestamps and source +// code location. The log package defines several valuers for that purpose. +// See Timestamp, DefaultTimestamp, DefaultTimestampUTC, Caller, and +// DefaultCaller. A common logger initialization sequence that ensures all log +// entries contain a timestamp and source location looks like this: +// +// logger := log.NewLogfmtLogger(log.NewSyncWriter(os.Stdout)) +// logger = log.With(logger, "ts", log.DefaultTimestampUTC, "caller", log.DefaultCaller) +// +// Concurrent Safety +// +// Applications with multiple goroutines want each log event written to the +// same logger to remain separate from other log events. Package log provides +// two simple solutions for concurrent safe logging. +// +// NewSyncWriter wraps an io.Writer and serializes each call to its Write +// method. Using a SyncWriter has the benefit that the smallest practical +// portion of the logging logic is performed within a mutex, but it requires +// the formatting Logger to make only one call to Write per log event. +// +// NewSyncLogger wraps any Logger and serializes each call to its Log method. +// Using a SyncLogger has the benefit that it guarantees each log event is +// handled atomically within the wrapped logger, but it typically serializes +// both the formatting and output logic. Use a SyncLogger if the formatting +// logger may perform multiple writes per log event. +// +// Error Handling +// +// This package relies on the practice of wrapping or decorating loggers with +// other loggers to provide composable pieces of functionality. It also means +// that Logger.Log must return an error because some +// implementations—especially those that output log data to an io.Writer—may +// encounter errors that cannot be handled locally. This in turn means that +// Loggers that wrap other loggers should return errors from the wrapped +// logger up the stack. +// +// Fortunately, the decorator pattern also provides a way to avoid the +// necessity to check for errors every time an application calls Logger.Log. +// An application required to panic whenever its Logger encounters +// an error could initialize its logger as follows. +// +// fmtlogger := log.NewLogfmtLogger(log.NewSyncWriter(os.Stdout)) +// logger := log.LoggerFunc(func(keyvals ...interface{}) error { +// if err := fmtlogger.Log(keyvals...); err != nil { +// panic(err) +// } +// return nil +// }) +package log diff --git a/src/alertmanager/vendor/github.com/go-kit/kit/log/json_logger.go b/src/alertmanager/vendor/github.com/go-kit/kit/log/json_logger.go new file mode 100644 index 0000000..66094b4 --- /dev/null +++ b/src/alertmanager/vendor/github.com/go-kit/kit/log/json_logger.go @@ -0,0 +1,89 @@ +package log + +import ( + "encoding" + "encoding/json" + "fmt" + "io" + "reflect" +) + +type jsonLogger struct { + io.Writer +} + +// NewJSONLogger returns a Logger that encodes keyvals to the Writer as a +// single JSON object. Each log event produces no more than one call to +// w.Write. The passed Writer must be safe for concurrent use by multiple +// goroutines if the returned Logger will be used concurrently. +func NewJSONLogger(w io.Writer) Logger { + return &jsonLogger{w} +} + +func (l *jsonLogger) Log(keyvals ...interface{}) error { + n := (len(keyvals) + 1) / 2 // +1 to handle case when len is odd + m := make(map[string]interface{}, n) + for i := 0; i < len(keyvals); i += 2 { + k := keyvals[i] + var v interface{} = ErrMissingValue + if i+1 < len(keyvals) { + v = keyvals[i+1] + } + merge(m, k, v) + } + return json.NewEncoder(l.Writer).Encode(m) +} + +func merge(dst map[string]interface{}, k, v interface{}) { + var key string + switch x := k.(type) { + case string: + key = x + case fmt.Stringer: + key = safeString(x) + default: + key = fmt.Sprint(x) + } + + // We want json.Marshaler and encoding.TextMarshaller to take priority over + // err.Error() and v.String(). But json.Marshall (called later) does that by + // default so we force a no-op if it's one of those 2 case. + switch x := v.(type) { + case json.Marshaler: + case encoding.TextMarshaler: + case error: + v = safeError(x) + case fmt.Stringer: + v = safeString(x) + } + + dst[key] = v +} + +func safeString(str fmt.Stringer) (s string) { + defer func() { + if panicVal := recover(); panicVal != nil { + if v := reflect.ValueOf(str); v.Kind() == reflect.Ptr && v.IsNil() { + s = "NULL" + } else { + panic(panicVal) + } + } + }() + s = str.String() + return +} + +func safeError(err error) (s interface{}) { + defer func() { + if panicVal := recover(); panicVal != nil { + if v := reflect.ValueOf(err); v.Kind() == reflect.Ptr && v.IsNil() { + s = nil + } else { + panic(panicVal) + } + } + }() + s = err.Error() + return +} diff --git a/src/alertmanager/vendor/github.com/go-kit/kit/log/level/doc.go b/src/alertmanager/vendor/github.com/go-kit/kit/log/level/doc.go new file mode 100644 index 0000000..5e9df7f --- /dev/null +++ b/src/alertmanager/vendor/github.com/go-kit/kit/log/level/doc.go @@ -0,0 +1,22 @@ +// Package level implements leveled logging on top of package log. To use the +// level package, create a logger as per normal in your func main, and wrap it +// with level.NewFilter. +// +// var logger log.Logger +// logger = log.NewLogfmtLogger(os.Stderr) +// logger = level.NewFilter(logger, level.AllowInfoAndAbove()) // <-- +// logger = log.With(logger, "ts", log.DefaultTimestampUTC) +// +// Then, at the callsites, use one of the level.Debug, Info, Warn, or Error +// helper methods to emit leveled log events. +// +// logger.Log("foo", "bar") // as normal, no level +// level.Debug(logger).Log("request_id", reqID, "trace_data", trace.Get()) +// if value > 100 { +// level.Error(logger).Log("value", value) +// } +// +// NewFilter allows precise control over what happens when a log event is +// emitted without a level key, or if a squelched level is used. Check the +// Option functions for details. +package level diff --git a/src/alertmanager/vendor/github.com/go-kit/kit/log/level/level.go b/src/alertmanager/vendor/github.com/go-kit/kit/log/level/level.go new file mode 100644 index 0000000..6833b0d --- /dev/null +++ b/src/alertmanager/vendor/github.com/go-kit/kit/log/level/level.go @@ -0,0 +1,205 @@ +package level + +import "github.com/go-kit/kit/log" + +// Error returns a logger that includes a Key/ErrorValue pair. +func Error(logger log.Logger) log.Logger { + return log.WithPrefix(logger, Key(), ErrorValue()) +} + +// Warn returns a logger that includes a Key/WarnValue pair. +func Warn(logger log.Logger) log.Logger { + return log.WithPrefix(logger, Key(), WarnValue()) +} + +// Info returns a logger that includes a Key/InfoValue pair. +func Info(logger log.Logger) log.Logger { + return log.WithPrefix(logger, Key(), InfoValue()) +} + +// Debug returns a logger that includes a Key/DebugValue pair. +func Debug(logger log.Logger) log.Logger { + return log.WithPrefix(logger, Key(), DebugValue()) +} + +// NewFilter wraps next and implements level filtering. See the commentary on +// the Option functions for a detailed description of how to configure levels. +// If no options are provided, all leveled log events created with Debug, +// Info, Warn or Error helper methods are squelched and non-leveled log +// events are passed to next unmodified. +func NewFilter(next log.Logger, options ...Option) log.Logger { + l := &logger{ + next: next, + } + for _, option := range options { + option(l) + } + return l +} + +type logger struct { + next log.Logger + allowed level + squelchNoLevel bool + errNotAllowed error + errNoLevel error +} + +func (l *logger) Log(keyvals ...interface{}) error { + var hasLevel, levelAllowed bool + for i := 1; i < len(keyvals); i += 2 { + if v, ok := keyvals[i].(*levelValue); ok { + hasLevel = true + levelAllowed = l.allowed&v.level != 0 + break + } + } + if !hasLevel && l.squelchNoLevel { + return l.errNoLevel + } + if hasLevel && !levelAllowed { + return l.errNotAllowed + } + return l.next.Log(keyvals...) +} + +// Option sets a parameter for the leveled logger. +type Option func(*logger) + +// AllowAll is an alias for AllowDebug. +func AllowAll() Option { + return AllowDebug() +} + +// AllowDebug allows error, warn, info and debug level log events to pass. +func AllowDebug() Option { + return allowed(levelError | levelWarn | levelInfo | levelDebug) +} + +// AllowInfo allows error, warn and info level log events to pass. +func AllowInfo() Option { + return allowed(levelError | levelWarn | levelInfo) +} + +// AllowWarn allows error and warn level log events to pass. +func AllowWarn() Option { + return allowed(levelError | levelWarn) +} + +// AllowError allows only error level log events to pass. +func AllowError() Option { + return allowed(levelError) +} + +// AllowNone allows no leveled log events to pass. +func AllowNone() Option { + return allowed(0) +} + +func allowed(allowed level) Option { + return func(l *logger) { l.allowed = allowed } +} + +// ErrNotAllowed sets the error to return from Log when it squelches a log +// event disallowed by the configured Allow[Level] option. By default, +// ErrNotAllowed is nil; in this case the log event is squelched with no +// error. +func ErrNotAllowed(err error) Option { + return func(l *logger) { l.errNotAllowed = err } +} + +// SquelchNoLevel instructs Log to squelch log events with no level, so that +// they don't proceed through to the wrapped logger. If SquelchNoLevel is set +// to true and a log event is squelched in this way, the error value +// configured with ErrNoLevel is returned to the caller. +func SquelchNoLevel(squelch bool) Option { + return func(l *logger) { l.squelchNoLevel = squelch } +} + +// ErrNoLevel sets the error to return from Log when it squelches a log event +// with no level. By default, ErrNoLevel is nil; in this case the log event is +// squelched with no error. +func ErrNoLevel(err error) Option { + return func(l *logger) { l.errNoLevel = err } +} + +// NewInjector wraps next and returns a logger that adds a Key/level pair to +// the beginning of log events that don't already contain a level. In effect, +// this gives a default level to logs without a level. +func NewInjector(next log.Logger, level Value) log.Logger { + return &injector{ + next: next, + level: level, + } +} + +type injector struct { + next log.Logger + level interface{} +} + +func (l *injector) Log(keyvals ...interface{}) error { + for i := 1; i < len(keyvals); i += 2 { + if _, ok := keyvals[i].(*levelValue); ok { + return l.next.Log(keyvals...) + } + } + kvs := make([]interface{}, len(keyvals)+2) + kvs[0], kvs[1] = key, l.level + copy(kvs[2:], keyvals) + return l.next.Log(kvs...) +} + +// Value is the interface that each of the canonical level values implement. +// It contains unexported methods that prevent types from other packages from +// implementing it and guaranteeing that NewFilter can distinguish the levels +// defined in this package from all other values. +type Value interface { + String() string + levelVal() +} + +// Key returns the unique key added to log events by the loggers in this +// package. +func Key() interface{} { return key } + +// ErrorValue returns the unique value added to log events by Error. +func ErrorValue() Value { return errorValue } + +// WarnValue returns the unique value added to log events by Warn. +func WarnValue() Value { return warnValue } + +// InfoValue returns the unique value added to log events by Info. +func InfoValue() Value { return infoValue } + +// DebugValue returns the unique value added to log events by Warn. +func DebugValue() Value { return debugValue } + +var ( + // key is of type interfae{} so that it allocates once during package + // initialization and avoids allocating every type the value is added to a + // []interface{} later. + key interface{} = "level" + + errorValue = &levelValue{level: levelError, name: "error"} + warnValue = &levelValue{level: levelWarn, name: "warn"} + infoValue = &levelValue{level: levelInfo, name: "info"} + debugValue = &levelValue{level: levelDebug, name: "debug"} +) + +type level byte + +const ( + levelDebug level = 1 << iota + levelInfo + levelWarn + levelError +) + +type levelValue struct { + name string + level +} + +func (v *levelValue) String() string { return v.name } +func (v *levelValue) levelVal() {} diff --git a/src/alertmanager/vendor/github.com/go-kit/kit/log/log.go b/src/alertmanager/vendor/github.com/go-kit/kit/log/log.go new file mode 100644 index 0000000..66a9e2f --- /dev/null +++ b/src/alertmanager/vendor/github.com/go-kit/kit/log/log.go @@ -0,0 +1,135 @@ +package log + +import "errors" + +// Logger is the fundamental interface for all log operations. Log creates a +// log event from keyvals, a variadic sequence of alternating keys and values. +// Implementations must be safe for concurrent use by multiple goroutines. In +// particular, any implementation of Logger that appends to keyvals or +// modifies or retains any of its elements must make a copy first. +type Logger interface { + Log(keyvals ...interface{}) error +} + +// ErrMissingValue is appended to keyvals slices with odd length to substitute +// the missing value. +var ErrMissingValue = errors.New("(MISSING)") + +// With returns a new contextual logger with keyvals prepended to those passed +// to calls to Log. If logger is also a contextual logger created by With or +// WithPrefix, keyvals is appended to the existing context. +// +// The returned Logger replaces all value elements (odd indexes) containing a +// Valuer with their generated value for each call to its Log method. +func With(logger Logger, keyvals ...interface{}) Logger { + if len(keyvals) == 0 { + return logger + } + l := newContext(logger) + kvs := append(l.keyvals, keyvals...) + if len(kvs)%2 != 0 { + kvs = append(kvs, ErrMissingValue) + } + return &context{ + logger: l.logger, + // Limiting the capacity of the stored keyvals ensures that a new + // backing array is created if the slice must grow in Log or With. + // Using the extra capacity without copying risks a data race that + // would violate the Logger interface contract. + keyvals: kvs[:len(kvs):len(kvs)], + hasValuer: l.hasValuer || containsValuer(keyvals), + } +} + +// WithPrefix returns a new contextual logger with keyvals prepended to those +// passed to calls to Log. If logger is also a contextual logger created by +// With or WithPrefix, keyvals is prepended to the existing context. +// +// The returned Logger replaces all value elements (odd indexes) containing a +// Valuer with their generated value for each call to its Log method. +func WithPrefix(logger Logger, keyvals ...interface{}) Logger { + if len(keyvals) == 0 { + return logger + } + l := newContext(logger) + // Limiting the capacity of the stored keyvals ensures that a new + // backing array is created if the slice must grow in Log or With. + // Using the extra capacity without copying risks a data race that + // would violate the Logger interface contract. + n := len(l.keyvals) + len(keyvals) + if len(keyvals)%2 != 0 { + n++ + } + kvs := make([]interface{}, 0, n) + kvs = append(kvs, keyvals...) + if len(kvs)%2 != 0 { + kvs = append(kvs, ErrMissingValue) + } + kvs = append(kvs, l.keyvals...) + return &context{ + logger: l.logger, + keyvals: kvs, + hasValuer: l.hasValuer || containsValuer(keyvals), + } +} + +// context is the Logger implementation returned by With and WithPrefix. It +// wraps a Logger and holds keyvals that it includes in all log events. Its +// Log method calls bindValues to generate values for each Valuer in the +// context keyvals. +// +// A context must always have the same number of stack frames between calls to +// its Log method and the eventual binding of Valuers to their value. This +// requirement comes from the functional requirement to allow a context to +// resolve application call site information for a Caller stored in the +// context. To do this we must be able to predict the number of logging +// functions on the stack when bindValues is called. +// +// Two implementation details provide the needed stack depth consistency. +// +// 1. newContext avoids introducing an additional layer when asked to +// wrap another context. +// 2. With and WithPrefix avoid introducing an additional layer by +// returning a newly constructed context with a merged keyvals rather +// than simply wrapping the existing context. +type context struct { + logger Logger + keyvals []interface{} + hasValuer bool +} + +func newContext(logger Logger) *context { + if c, ok := logger.(*context); ok { + return c + } + return &context{logger: logger} +} + +// Log replaces all value elements (odd indexes) containing a Valuer in the +// stored context with their generated value, appends keyvals, and passes the +// result to the wrapped Logger. +func (l *context) Log(keyvals ...interface{}) error { + kvs := append(l.keyvals, keyvals...) + if len(kvs)%2 != 0 { + kvs = append(kvs, ErrMissingValue) + } + if l.hasValuer { + // If no keyvals were appended above then we must copy l.keyvals so + // that future log events will reevaluate the stored Valuers. + if len(keyvals) == 0 { + kvs = append([]interface{}{}, l.keyvals...) + } + bindValues(kvs[:len(l.keyvals)]) + } + return l.logger.Log(kvs...) +} + +// LoggerFunc is an adapter to allow use of ordinary functions as Loggers. If +// f is a function with the appropriate signature, LoggerFunc(f) is a Logger +// object that calls f. +type LoggerFunc func(...interface{}) error + +// Log implements Logger by calling f(keyvals...). +func (f LoggerFunc) Log(keyvals ...interface{}) error { + return f(keyvals...) +} diff --git a/src/alertmanager/vendor/github.com/go-kit/kit/log/logfmt_logger.go b/src/alertmanager/vendor/github.com/go-kit/kit/log/logfmt_logger.go new file mode 100644 index 0000000..a003052 --- /dev/null +++ b/src/alertmanager/vendor/github.com/go-kit/kit/log/logfmt_logger.go @@ -0,0 +1,62 @@ +package log + +import ( + "bytes" + "io" + "sync" + + "github.com/go-logfmt/logfmt" +) + +type logfmtEncoder struct { + *logfmt.Encoder + buf bytes.Buffer +} + +func (l *logfmtEncoder) Reset() { + l.Encoder.Reset() + l.buf.Reset() +} + +var logfmtEncoderPool = sync.Pool{ + New: func() interface{} { + var enc logfmtEncoder + enc.Encoder = logfmt.NewEncoder(&enc.buf) + return &enc + }, +} + +type logfmtLogger struct { + w io.Writer +} + +// NewLogfmtLogger returns a logger that encodes keyvals to the Writer in +// logfmt format. Each log event produces no more than one call to w.Write. +// The passed Writer must be safe for concurrent use by multiple goroutines if +// the returned Logger will be used concurrently. +func NewLogfmtLogger(w io.Writer) Logger { + return &logfmtLogger{w} +} + +func (l logfmtLogger) Log(keyvals ...interface{}) error { + enc := logfmtEncoderPool.Get().(*logfmtEncoder) + enc.Reset() + defer logfmtEncoderPool.Put(enc) + + if err := enc.EncodeKeyvals(keyvals...); err != nil { + return err + } + + // Add newline to the end of the buffer + if err := enc.EndRecord(); err != nil { + return err + } + + // The Logger interface requires implementations to be safe for concurrent + // use by multiple goroutines. For this implementation that means making + // only one call to l.w.Write() for each call to Log. + if _, err := l.w.Write(enc.buf.Bytes()); err != nil { + return err + } + return nil +} diff --git a/src/alertmanager/vendor/github.com/go-kit/kit/log/nop_logger.go b/src/alertmanager/vendor/github.com/go-kit/kit/log/nop_logger.go new file mode 100644 index 0000000..1047d62 --- /dev/null +++ b/src/alertmanager/vendor/github.com/go-kit/kit/log/nop_logger.go @@ -0,0 +1,8 @@ +package log + +type nopLogger struct{} + +// NewNopLogger returns a logger that doesn't do anything. +func NewNopLogger() Logger { return nopLogger{} } + +func (nopLogger) Log(...interface{}) error { return nil } diff --git a/src/alertmanager/vendor/github.com/go-kit/kit/log/stdlib.go b/src/alertmanager/vendor/github.com/go-kit/kit/log/stdlib.go new file mode 100644 index 0000000..ff96b5d --- /dev/null +++ b/src/alertmanager/vendor/github.com/go-kit/kit/log/stdlib.go @@ -0,0 +1,116 @@ +package log + +import ( + "io" + "log" + "regexp" + "strings" +) + +// StdlibWriter implements io.Writer by invoking the stdlib log.Print. It's +// designed to be passed to a Go kit logger as the writer, for cases where +// it's necessary to redirect all Go kit log output to the stdlib logger. +// +// If you have any choice in the matter, you shouldn't use this. Prefer to +// redirect the stdlib log to the Go kit logger via NewStdlibAdapter. +type StdlibWriter struct{} + +// Write implements io.Writer. +func (w StdlibWriter) Write(p []byte) (int, error) { + log.Print(strings.TrimSpace(string(p))) + return len(p), nil +} + +// StdlibAdapter wraps a Logger and allows it to be passed to the stdlib +// logger's SetOutput. It will extract date/timestamps, filenames, and +// messages, and place them under relevant keys. +type StdlibAdapter struct { + Logger + timestampKey string + fileKey string + messageKey string +} + +// StdlibAdapterOption sets a parameter for the StdlibAdapter. +type StdlibAdapterOption func(*StdlibAdapter) + +// TimestampKey sets the key for the timestamp field. By default, it's "ts". +func TimestampKey(key string) StdlibAdapterOption { + return func(a *StdlibAdapter) { a.timestampKey = key } +} + +// FileKey sets the key for the file and line field. By default, it's "caller". +func FileKey(key string) StdlibAdapterOption { + return func(a *StdlibAdapter) { a.fileKey = key } +} + +// MessageKey sets the key for the actual log message. By default, it's "msg". +func MessageKey(key string) StdlibAdapterOption { + return func(a *StdlibAdapter) { a.messageKey = key } +} + +// NewStdlibAdapter returns a new StdlibAdapter wrapper around the passed +// logger. It's designed to be passed to log.SetOutput. +func NewStdlibAdapter(logger Logger, options ...StdlibAdapterOption) io.Writer { + a := StdlibAdapter{ + Logger: logger, + timestampKey: "ts", + fileKey: "caller", + messageKey: "msg", + } + for _, option := range options { + option(&a) + } + return a +} + +func (a StdlibAdapter) Write(p []byte) (int, error) { + result := subexps(p) + keyvals := []interface{}{} + var timestamp string + if date, ok := result["date"]; ok && date != "" { + timestamp = date + } + if time, ok := result["time"]; ok && time != "" { + if timestamp != "" { + timestamp += " " + } + timestamp += time + } + if timestamp != "" { + keyvals = append(keyvals, a.timestampKey, timestamp) + } + if file, ok := result["file"]; ok && file != "" { + keyvals = append(keyvals, a.fileKey, file) + } + if msg, ok := result["msg"]; ok { + keyvals = append(keyvals, a.messageKey, msg) + } + if err := a.Logger.Log(keyvals...); err != nil { + return 0, err + } + return len(p), nil +} + +const ( + logRegexpDate = `(?P[0-9]{4}/[0-9]{2}/[0-9]{2})?[ ]?` + logRegexpTime = `(?P